diff --git a/internal/db/kvs/redis/option_test.go b/internal/db/kvs/redis/option_test.go index fd48aa04d5..d8c009ce91 100644 --- a/internal/db/kvs/redis/option_test.go +++ b/internal/db/kvs/redis/option_test.go @@ -24,7 +24,6 @@ import ( redis "github.com/go-redis/redis/v7" "github.com/vdaas/vald/internal/net" - "go.uber.org/goleak" ) @@ -3078,3 +3077,117 @@ func TestWithInitialPingDuration(t *testing.T) { }) } } + +func TestWithPingFlag(t *testing.T) { + // Change interface type to the type of object you are testing + type T = interface{} + type args struct { + flag bool + } + type want struct { + obj *T + // Uncomment this line if the option returns an error, otherwise delete it + // err error + } + type test struct { + name string + args args + want want + // Use the first line if the option returns an error. otherwise use the second line + // checkFunc func(want, *T, error) error + // checkFunc func(want, *T) error + beforeFunc func(args) + afterFunc func(args) + } + + // Uncomment this block if the option returns an error, otherwise delete it + /* + defaultCheckFunc := func(w want, obj *T, err error) error { + if !errors.Is(err, w.err) { + return errors.Errorf("got error = %v, want %v", err, w.err) + } + if !reflect.DeepEqual(obj, w.obj) { + return errors.Errorf("got = %v, want %v", obj, w.obj) + } + return nil + } + */ + + // Uncomment this block if the option do not returns an error, otherwise delete it + /* + defaultCheckFunc := func(w want, obj *T) error { + if !reflect.DeepEqual(obj, w.obj) { + return errors.Errorf("got = %v, want %v", obj, w.obj) + } + return nil + } + */ + + tests := []test{ + // TODO test cases + /* + { + name: "test_case_1", + args: args { + flag: false, + }, + want: want { + obj: new(T), + }, + }, + */ + + // TODO test cases + /* + func() test { + return test { + name: "test_case_2", + args: args { + flag: false, + }, + want: want { + obj: new(T), + }, + } + }(), + */ + } + + for _, test := range tests { + t.Run(test.name, func(tt *testing.T) { + defer goleak.VerifyNone(tt) + if test.beforeFunc != nil { + test.beforeFunc(test.args) + } + if test.afterFunc != nil { + defer test.afterFunc(test.args) + } + + // Uncomment this block if the option returns an error, otherwise delete it + /* + if test.checkFunc == nil { + test.checkFunc = defaultCheckFunc + } + + got := WithPingFlag(test.args.flag) + obj := new(T) + if err := test.checkFunc(test.want, obj, got(obj)); err != nil { + tt.Errorf("error = %v", err) + } + */ + + // Uncomment this block if the option do not return an error, otherwise delete it + /* + if test.checkFunc == nil { + test.checkFunc = defaultCheckFunc + } + got := WithPingFlag(test.args.flag) + obj := new(T) + got(obj) + if err := test.checkFunc(test.want, obj); err != nil { + tt.Errorf("error = %v", err) + } + */ + }) + } +} diff --git a/internal/db/kvs/redis/redis_test.go b/internal/db/kvs/redis/redis_test.go index 7025b1e209..a76690aee0 100644 --- a/internal/db/kvs/redis/redis_test.go +++ b/internal/db/kvs/redis/redis_test.go @@ -18,11 +18,14 @@ package redis import ( "context" + "crypto/tls" "reflect" "testing" + "time" + redis "github.com/go-redis/redis/v7" "github.com/vdaas/vald/internal/errors" - + "github.com/vdaas/vald/internal/net" "go.uber.org/goleak" ) @@ -103,3 +106,199 @@ func TestNew(t *testing.T) { }) } } + +func Test_redisClient_ping(t *testing.T) { + type args struct { + ctx context.Context + } + type fields struct { + addrs []string + clusterSlots func() ([]redis.ClusterSlot, error) + db int + dialTimeout time.Duration + dialer func(ctx context.Context, network, addr string) (net.Conn, error) + idleCheckFrequency time.Duration + idleTimeout time.Duration + initialPingDuration time.Duration + initialPingTimeLimit time.Duration + keyPref string + maxConnAge time.Duration + maxRedirects int + maxRetries int + maxRetryBackoff time.Duration + minIdleConns int + minRetryBackoff time.Duration + onConnect func(*redis.Conn) error + onNewNode func(*redis.Client) + password string + poolSize int + poolTimeout time.Duration + readOnly bool + readTimeout time.Duration + routeByLatency bool + routeRandomly bool + tlsConfig *tls.Config + writeTimeout time.Duration + client Redis + pingEnabled bool + } + type want struct { + err error + } + type test struct { + name string + args args + fields fields + want want + checkFunc func(want, error) error + beforeFunc func(args) + afterFunc func(args) + } + defaultCheckFunc := func(w want, err error) error { + if !errors.Is(err, w.err) { + return errors.Errorf("got error = %v, want %v", err, w.err) + } + return nil + } + tests := []test{ + // TODO test cases + /* + { + name: "test_case_1", + args: args { + ctx: nil, + }, + fields: fields { + addrs: nil, + clusterSlots: nil, + db: 0, + dialTimeout: nil, + dialer: nil, + idleCheckFrequency: nil, + idleTimeout: nil, + initialPingDuration: nil, + initialPingTimeLimit: nil, + keyPref: "", + maxConnAge: nil, + maxRedirects: 0, + maxRetries: 0, + maxRetryBackoff: nil, + minIdleConns: 0, + minRetryBackoff: nil, + onConnect: nil, + onNewNode: nil, + password: "", + poolSize: 0, + poolTimeout: nil, + readOnly: false, + readTimeout: nil, + routeByLatency: false, + routeRandomly: false, + tlsConfig: nil, + writeTimeout: nil, + client: nil, + pingEnabled: false, + }, + want: want{}, + checkFunc: defaultCheckFunc, + }, + */ + + // TODO test cases + /* + func() test { + return test { + name: "test_case_2", + args: args { + ctx: nil, + }, + fields: fields { + addrs: nil, + clusterSlots: nil, + db: 0, + dialTimeout: nil, + dialer: nil, + idleCheckFrequency: nil, + idleTimeout: nil, + initialPingDuration: nil, + initialPingTimeLimit: nil, + keyPref: "", + maxConnAge: nil, + maxRedirects: 0, + maxRetries: 0, + maxRetryBackoff: nil, + minIdleConns: 0, + minRetryBackoff: nil, + onConnect: nil, + onNewNode: nil, + password: "", + poolSize: 0, + poolTimeout: nil, + readOnly: false, + readTimeout: nil, + routeByLatency: false, + routeRandomly: false, + tlsConfig: nil, + writeTimeout: nil, + client: nil, + pingEnabled: false, + }, + want: want{}, + checkFunc: defaultCheckFunc, + } + }(), + */ + } + + for _, test := range tests { + t.Run(test.name, func(tt *testing.T) { + defer goleak.VerifyNone(tt) + if test.beforeFunc != nil { + test.beforeFunc(test.args) + } + if test.afterFunc != nil { + defer test.afterFunc(test.args) + } + if test.checkFunc == nil { + test.checkFunc = defaultCheckFunc + } + rc := &redisClient{ + addrs: test.fields.addrs, + clusterSlots: test.fields.clusterSlots, + db: test.fields.db, + dialTimeout: test.fields.dialTimeout, + dialer: test.fields.dialer, + idleCheckFrequency: test.fields.idleCheckFrequency, + idleTimeout: test.fields.idleTimeout, + initialPingDuration: test.fields.initialPingDuration, + initialPingTimeLimit: test.fields.initialPingTimeLimit, + keyPref: test.fields.keyPref, + maxConnAge: test.fields.maxConnAge, + maxRedirects: test.fields.maxRedirects, + maxRetries: test.fields.maxRetries, + maxRetryBackoff: test.fields.maxRetryBackoff, + minIdleConns: test.fields.minIdleConns, + minRetryBackoff: test.fields.minRetryBackoff, + onConnect: test.fields.onConnect, + onNewNode: test.fields.onNewNode, + password: test.fields.password, + poolSize: test.fields.poolSize, + poolTimeout: test.fields.poolTimeout, + readOnly: test.fields.readOnly, + readTimeout: test.fields.readTimeout, + routeByLatency: test.fields.routeByLatency, + routeRandomly: test.fields.routeRandomly, + tlsConfig: test.fields.tlsConfig, + writeTimeout: test.fields.writeTimeout, + client: test.fields.client, + pingEnabled: test.fields.pingEnabled, + } + + err := rc.ping(test.args.ctx) + if err := test.checkFunc(test.want, err); err != nil { + tt.Errorf("error = %v", err) + } + + }) + } +}