func TestBackendFactory(t *testing.T) {
var cnf config.Config
// 1) AMQP backend test
cnf = config.Config{ResultBackend: "amqp"}
actual, err := BackendFactory(&cnf)
if err != nil {
t.Errorf(err.Error())
}
expected := backends.NewAMQPBackend(&cnf)
if !reflect.DeepEqual(actual, expected) {
t.Errorf("conn = %v, want %v", actual, expected)
}
// 2) Memcache backend test
cnf = config.Config{
ResultBackend: "memcache://10.0.0.1:11211,10.0.0.2:11211",
}
actual, err = BackendFactory(&cnf)
if err != nil {
t.Errorf(err.Error())
}
servers := []string{"10.0.0.1:11211", "10.0.0.2:11211"}
expected = backends.NewMemcacheBackend(&cnf, servers)
if !reflect.DeepEqual(actual, expected) {
t.Errorf("conn = %v, want %v", actual, expected)
}
}
// BackendFactory creates a new object with backends.Backend interface
// Currently supported backends are AMQP and Memcache
func BackendFactory(cnf *config.Config) (backends.Backend, error) {
if strings.HasPrefix(cnf.ResultBackend, "amqp://") {
return backends.NewAMQPBackend(cnf), nil
}
if strings.HasPrefix(cnf.ResultBackend, "memcache://") {
parts := strings.Split(cnf.ResultBackend, "memcache://")
if len(parts) != 2 {
return nil, fmt.Errorf(
"Memcache result backend connection string should be in format memcache://server1:port,server2:port, instead got %s",
cnf.ResultBackend,
)
}
servers := strings.Split(parts[1], ",")
return backends.NewMemcacheBackend(cnf, servers), nil
}
if strings.HasPrefix(cnf.ResultBackend, "redis://") {
parts := strings.Split(cnf.ResultBackend, "redis://")
if len(parts) != 2 {
return nil, fmt.Errorf(
"Redis result backend connection string should be in format redis://host:port, instead got %s",
cnf.ResultBackend,
)
}
return backends.NewRedisBackend(cnf, parts[1]), nil
}
return nil, fmt.Errorf("Factory failed with result backend: %v", cnf.ResultBackend)
}
// BackendFactory creates a new object with backends.Backend interface
// Currently supported backends are AMQP and Memcache
func BackendFactory(cnf *config.Config) (backends.Backend, error) {
if cnf.ResultBackend == "amqp" {
return backends.NewAMQPBackend(cnf), nil
}
if strings.HasPrefix(cnf.ResultBackend, "memcache://") {
serversString := strings.Split(cnf.ResultBackend, "memcache://")[1]
servers := strings.Split(serversString, ",")
return backends.NewMemcacheBackend(cnf, servers), nil
}
return nil, fmt.Errorf("Factory failed with result backend: %v", cnf.ResultBackend)
}
// BackendFactory creates a new object with backends.Backend interface
// Currently supported backends are AMQP and Memcache
func BackendFactory(cnf *config.Config) (backends.Backend, error) {
if strings.HasPrefix(cnf.ResultBackend, "amqp://") {
return backends.NewAMQPBackend(cnf), nil
}
if strings.HasPrefix(cnf.ResultBackend, "memcache://") {
parts := strings.Split(cnf.ResultBackend, "memcache://")
if len(parts) != 2 {
return nil, fmt.Errorf(
"Memcache result backend connection string should be in format memcache://server1:port,server2:port, instead got %s",
cnf.ResultBackend,
)
}
servers := strings.Split(parts[1], ",")
return backends.NewMemcacheBackend(cnf, servers), nil
}
if strings.HasPrefix(cnf.ResultBackend, "redis://") {
parts := strings.Split(cnf.ResultBackend, "redis://")
if len(parts) != 2 {
return nil, fmt.Errorf(
"Redis result backend connection string should be in format redis://password@host:port, instead got %s",
cnf.ResultBackend,
)
}
var redisHost, redisPassword string
parts = strings.Split(parts[1], "@")
if len(parts) == 2 {
redisHost = parts[1]
redisPassword = parts[0]
} else {
redisHost = parts[0]
}
return backends.NewRedisBackend(cnf, redisHost, redisPassword), nil
}
if strings.HasPrefix(cnf.ResultBackend, "eager") {
return backends.NewEagerBackend(), nil
}
return nil, fmt.Errorf("Factory failed with result backend: %v", cnf.ResultBackend)
}
func TestBackendFactory(t *testing.T) {
var cnf config.Config
// 1) AMQP backend test
cnf = config.Config{ResultBackend: "amqp://*****:*****@localhost:5672/"}
actual, err := BackendFactory(&cnf)
if err != nil {
t.Errorf(err.Error())
}
expected := backends.NewAMQPBackend(&cnf)
if !reflect.DeepEqual(actual, expected) {
t.Errorf("conn = %v, want %v", actual, expected)
}
// 2) Memcache backend test
cnf = config.Config{
ResultBackend: "memcache://10.0.0.1:11211,10.0.0.2:11211",
}
actual, err = BackendFactory(&cnf)
if err != nil {
t.Errorf(err.Error())
}
servers := []string{"10.0.0.1:11211", "10.0.0.2:11211"}
expected = backends.NewMemcacheBackend(&cnf, servers)
if !reflect.DeepEqual(actual, expected) {
t.Errorf("conn = %v, want %v", actual, expected)
}
// 2) Redis backend test
// with password
cnf = config.Config{
ResultBackend: "redis://password@localhost:6379",
}
actual, err = BackendFactory(&cnf)
if err != nil {
t.Errorf(err.Error())
}
expected = backends.NewRedisBackend(&cnf, "localhost:6379", "password")
if !reflect.DeepEqual(actual, expected) {
t.Errorf("conn = %v, want %v", actual, expected)
}
// without password
cnf = config.Config{
ResultBackend: "redis://localhost:6379",
}
actual, err = BackendFactory(&cnf)
if err != nil {
t.Errorf(err.Error())
}
expected = backends.NewRedisBackend(&cnf, "localhost:6379", "")
if !reflect.DeepEqual(actual, expected) {
t.Errorf("conn = %v, want %v", actual, expected)
}
}