From 72bec6fbc27461c3dda5e845c2c3b41e9ba8466f Mon Sep 17 00:00:00 2001 From: Marek Siarkowicz Date: Thu, 25 Aug 2022 14:14:25 +0200 Subject: [PATCH 1/3] tests: Add context to common client interface Signed-off-by: Marek Siarkowicz --- tests/common/alarm_test.go | 18 ++-- tests/common/compact_test.go | 10 +- tests/common/defrag_test.go | 6 +- tests/common/endpoint_test.go | 6 +- tests/common/kv_test.go | 16 +-- tests/common/lease_test.go | 36 +++---- tests/common/member_test.go | 5 +- tests/common/role_test.go | 32 +++--- tests/common/status_test.go | 2 +- tests/common/txn_test.go | 10 +- tests/common/user_test.go | 28 +++--- tests/common/watch_test.go | 2 +- tests/e2e/cluster_downgrade_test.go | 2 +- tests/e2e/corrupt_test.go | 18 ++-- tests/e2e/ctl_v3_grpc_test.go | 5 +- tests/e2e/etcd_grpcproxy_test.go | 12 ++- tests/e2e/v2store_deprecation_test.go | 33 +++--- tests/e2e/v3_curl_test.go | 2 +- tests/framework/e2e.go | 4 +- tests/framework/e2e/etcdctl.go | 140 +++++++++++++------------- tests/framework/e2e/util.go | 6 +- tests/framework/integration.go | 115 ++++++++++----------- tests/framework/interface.go | 54 +++++----- 23 files changed, 288 insertions(+), 274 deletions(-) diff --git a/tests/common/alarm_test.go b/tests/common/alarm_test.go index 9f0ace141..11784fc3b 100644 --- a/tests/common/alarm_test.go +++ b/tests/common/alarm_test.go @@ -35,14 +35,14 @@ func TestAlarm(t *testing.T) { testutils.ExecuteUntil(ctx, t, func() { // test small put still works smallbuf := strings.Repeat("a", 64) - if err := clus.Client().Put("1st_test", smallbuf, config.PutOptions{}); err != nil { + if err := clus.Client().Put(ctx, "1st_test", smallbuf, config.PutOptions{}); err != nil { t.Fatalf("alarmTest: put kv error (%v)", err) } // write some chunks to fill up the database buf := strings.Repeat("b", os.Getpagesize()) for { - if err := clus.Client().Put("2nd_test", buf, config.PutOptions{}); err != nil { + if err := clus.Client().Put(ctx, "2nd_test", buf, config.PutOptions{}); err != nil { if !strings.Contains(err.Error(), "etcdserver: mvcc: database space exceeded") { t.Fatal(err) } @@ -51,20 +51,20 @@ func TestAlarm(t *testing.T) { } // quota alarm should now be on - alarmResp, err := clus.Client().AlarmList() + alarmResp, err := clus.Client().AlarmList(ctx) if err != nil { t.Fatalf("alarmTest: Alarm error (%v)", err) } // check that Put is rejected when alarm is on - if err := clus.Client().Put("3rd_test", smallbuf, config.PutOptions{}); err != nil { + if err := clus.Client().Put(ctx, "3rd_test", smallbuf, config.PutOptions{}); err != nil { if !strings.Contains(err.Error(), "etcdserver: mvcc: database space exceeded") { t.Fatal(err) } } // get latest revision to compact - sresp, err := clus.Client().Status() + sresp, err := clus.Client().Status(ctx) if err != nil { t.Fatalf("get endpoint status error: %v", err) } @@ -77,12 +77,12 @@ func TestAlarm(t *testing.T) { } // make some space - _, err = clus.Client().Compact(rvs, config.CompactOption{Physical: true, Timeout: 10 * time.Second}) + _, err = clus.Client().Compact(ctx, rvs, config.CompactOption{Physical: true, Timeout: 10 * time.Second}) if err != nil { t.Fatalf("alarmTest: Compact error (%v)", err) } - if err = clus.Client().Defragment(config.DefragOption{Timeout: 10 * time.Second}); err != nil { + if err = clus.Client().Defragment(ctx, config.DefragOption{Timeout: 10 * time.Second}); err != nil { t.Fatalf("alarmTest: defrag error (%v)", err) } @@ -92,14 +92,14 @@ func TestAlarm(t *testing.T) { MemberID: alarm.MemberID, Alarm: alarm.Alarm, } - _, err = clus.Client().AlarmDisarm(alarmMember) + _, err = clus.Client().AlarmDisarm(ctx, alarmMember) if err != nil { t.Fatalf("alarmTest: Alarm error (%v)", err) } } // put one more key below quota - if err := clus.Client().Put("4th_test", smallbuf, config.PutOptions{}); err != nil { + if err := clus.Client().Put(ctx, "4th_test", smallbuf, config.PutOptions{}); err != nil { t.Fatal(err) } }) diff --git a/tests/common/compact_test.go b/tests/common/compact_test.go index 2b1031dae..b1a4848d5 100644 --- a/tests/common/compact_test.go +++ b/tests/common/compact_test.go @@ -50,11 +50,11 @@ func TestCompact(t *testing.T) { testutils.ExecuteUntil(ctx, t, func() { var kvs = []testutils.KV{{Key: "key", Val: "val1"}, {Key: "key", Val: "val2"}, {Key: "key", Val: "val3"}} for i := range kvs { - if err := clus.Client().Put(kvs[i].Key, kvs[i].Val, config.PutOptions{}); err != nil { + if err := clus.Client().Put(ctx, kvs[i].Key, kvs[i].Val, config.PutOptions{}); err != nil { t.Fatalf("compactTest #%d: put kv error (%v)", i, err) } } - get, err := clus.Client().Get("key", config.GetOptions{Revision: 3}) + get, err := clus.Client().Get(ctx, "key", config.GetOptions{Revision: 3}) if err != nil { t.Fatalf("compactTest: Get kv by revision error (%v)", err) } @@ -62,12 +62,12 @@ func TestCompact(t *testing.T) { getkvs := testutils.KeyValuesFromGetResponse(get) assert.Equal(t, kvs[1:2], getkvs) - _, err = clus.Client().Compact(4, tc.options) + _, err = clus.Client().Compact(ctx, 4, tc.options) if err != nil { t.Fatalf("compactTest: Compact error (%v)", err) } - get, err = clus.Client().Get("key", config.GetOptions{Revision: 3}) + get, err = clus.Client().Get(ctx, "key", config.GetOptions{Revision: 3}) if err != nil { if !strings.Contains(err.Error(), "required revision has been compacted") { t.Fatalf("compactTest: Get compact key error (%v)", err) @@ -76,7 +76,7 @@ func TestCompact(t *testing.T) { t.Fatalf("expected '...has been compacted' error, got ") } - _, err = clus.Client().Compact(2, tc.options) + _, err = clus.Client().Compact(ctx, 2, tc.options) if err != nil { if !strings.Contains(err.Error(), "required revision has been compacted") { t.Fatal(err) diff --git a/tests/common/defrag_test.go b/tests/common/defrag_test.go index 295149312..e6bac2070 100644 --- a/tests/common/defrag_test.go +++ b/tests/common/defrag_test.go @@ -33,16 +33,16 @@ func TestDefragOnline(t *testing.T) { defer clus.Close() var kvs = []testutils.KV{{Key: "key", Val: "val1"}, {Key: "key", Val: "val2"}, {Key: "key", Val: "val3"}} for i := range kvs { - if err := clus.Client().Put(kvs[i].Key, kvs[i].Val, config.PutOptions{}); err != nil { + if err := clus.Client().Put(ctx, kvs[i].Key, kvs[i].Val, config.PutOptions{}); err != nil { t.Fatalf("compactTest #%d: put kv error (%v)", i, err) } } - _, err := clus.Client().Compact(4, config.CompactOption{Physical: true, Timeout: 10 * time.Second}) + _, err := clus.Client().Compact(ctx, 4, config.CompactOption{Physical: true, Timeout: 10 * time.Second}) if err != nil { t.Fatalf("defrag_test: compact with revision error (%v)", err) } - if err = clus.Client().Defragment(options); err != nil { + if err = clus.Client().Defragment(ctx, options); err != nil { t.Fatalf("defrag_test: defrag error (%v)", err) } }) diff --git a/tests/common/endpoint_test.go b/tests/common/endpoint_test.go index d1ba6da18..963340add 100644 --- a/tests/common/endpoint_test.go +++ b/tests/common/endpoint_test.go @@ -30,7 +30,7 @@ func TestEndpointStatus(t *testing.T) { clus := testRunner.NewCluster(ctx, t, config.ClusterConfig{ClusterSize: 3}) defer clus.Close() testutils.ExecuteUntil(ctx, t, func() { - _, err := clus.Client().Status() + _, err := clus.Client().Status(ctx) if err != nil { t.Fatalf("get endpoint status error: %v", err) } @@ -44,7 +44,7 @@ func TestEndpointHashKV(t *testing.T) { clus := testRunner.NewCluster(ctx, t, config.ClusterConfig{ClusterSize: 3}) defer clus.Close() testutils.ExecuteUntil(ctx, t, func() { - _, err := clus.Client().HashKV(0) + _, err := clus.Client().HashKV(ctx, 0) if err != nil { t.Fatalf("get endpoint hashkv error: %v", err) } @@ -58,7 +58,7 @@ func TestEndpointHealth(t *testing.T) { clus := testRunner.NewCluster(ctx, t, config.ClusterConfig{ClusterSize: 3}) defer clus.Close() testutils.ExecuteUntil(ctx, t, func() { - if err := clus.Client().Health(); err != nil { + if err := clus.Client().Health(ctx); err != nil { t.Fatalf("get endpoint health error: %v", err) } }) diff --git a/tests/common/kv_test.go b/tests/common/kv_test.go index ef2540ced..23e387bd1 100644 --- a/tests/common/kv_test.go +++ b/tests/common/kv_test.go @@ -38,10 +38,10 @@ func TestKVPut(t *testing.T) { testutils.ExecuteUntil(ctx, t, func() { key, value := "foo", "bar" - if err := cc.Put(key, value, config.PutOptions{}); err != nil { + if err := cc.Put(ctx, key, value, config.PutOptions{}); err != nil { t.Fatalf("count not put key %q, err: %s", key, err) } - resp, err := cc.Get(key, config.GetOptions{}) + resp, err := cc.Get(ctx, key, config.GetOptions{}) if err != nil { t.Fatalf("count not get key %q, err: %s", key, err) } @@ -78,7 +78,7 @@ func TestKVGet(t *testing.T) { ) for i := range kvs { - if err := cc.Put(kvs[i], "bar", config.PutOptions{}); err != nil { + if err := cc.Put(ctx, kvs[i], "bar", config.PutOptions{}); err != nil { t.Fatalf("count not put key %q, err: %s", kvs[i], err) } } @@ -107,7 +107,7 @@ func TestKVGet(t *testing.T) { {begin: "", options: config.GetOptions{Prefix: true, Order: clientv3.SortDescend, SortBy: clientv3.SortByKey}, wkv: reversedKvs}, } for _, tt := range tests { - resp, err := cc.Get(tt.begin, tt.options) + resp, err := cc.Get(ctx, tt.begin, tt.options) if err != nil { t.Fatalf("count not get key %q, err: %s", tt.begin, err) } @@ -178,16 +178,16 @@ func TestKVDelete(t *testing.T) { } for _, tt := range tests { for i := range kvs { - if err := cc.Put(kvs[i], "bar", config.PutOptions{}); err != nil { + if err := cc.Put(ctx, kvs[i], "bar", config.PutOptions{}); err != nil { t.Fatalf("count not put key %q, err: %s", kvs[i], err) } } - del, err := cc.Delete(tt.deleteKey, tt.options) + del, err := cc.Delete(ctx, tt.deleteKey, tt.options) if err != nil { t.Fatalf("count not get key %q, err: %s", tt.deleteKey, err) } assert.Equal(t, tt.wantDeleted, int(del.Deleted)) - get, err := cc.Get("", config.GetOptions{Prefix: true}) + get, err := cc.Get(ctx, "", config.GetOptions{Prefix: true}) if err != nil { t.Fatalf("count not get key, err: %s", err) } @@ -230,7 +230,7 @@ func TestKVGetNoQuorum(t *testing.T) { cc := clus.Members()[2].Client() testutils.ExecuteUntil(ctx, t, func() { key := "foo" - _, err := cc.Get(key, tc.options) + _, err := cc.Get(ctx, key, tc.options) gotError := err != nil if gotError != tc.wantError { t.Fatalf("Unexpeted result, wantError: %v, gotErr: %v, err: %s", tc.wantError, gotError, err) diff --git a/tests/common/lease_test.go b/tests/common/lease_test.go index 0281b3cfe..ad7b7b090 100644 --- a/tests/common/lease_test.go +++ b/tests/common/lease_test.go @@ -63,10 +63,10 @@ func TestLeaseGrantTimeToLive(t *testing.T) { testutils.ExecuteUntil(ctx, t, func() { ttl := int64(10) - leaseResp, err := cc.Grant(ttl) + leaseResp, err := cc.Grant(ctx, ttl) require.NoError(t, err) - ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{}) + ttlResp, err := cc.TimeToLive(ctx, leaseResp.ID, config.LeaseOption{}) require.NoError(t, err) require.Equal(t, ttl, ttlResp.GrantedTTL) }) @@ -108,7 +108,7 @@ func TestLeaseGrantAndList(t *testing.T) { testutils.ExecuteUntil(ctx, t, func() { createdLeases := []clientv3.LeaseID{} for i := 0; i < nc.leaseCount; i++ { - leaseResp, err := cc.Grant(10) + leaseResp, err := cc.Grant(ctx, 10) t.Logf("Grant returned: resp:%s err:%v", leaseResp.String(), err) require.NoError(t, err) createdLeases = append(createdLeases, leaseResp.ID) @@ -119,7 +119,7 @@ func TestLeaseGrantAndList(t *testing.T) { // or by hitting an up to date member. leases := []clientv3.LeaseStatus{} require.Eventually(t, func() bool { - resp, err := cc.LeaseList() + resp, err := cc.LeaseList(ctx) if err != nil { return false } @@ -153,23 +153,23 @@ func TestLeaseGrantTimeToLiveExpired(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - leaseResp, err := cc.Grant(2) + leaseResp, err := cc.Grant(ctx, 2) require.NoError(t, err) - err = cc.Put("foo", "bar", config.PutOptions{LeaseID: leaseResp.ID}) + err = cc.Put(ctx, "foo", "bar", config.PutOptions{LeaseID: leaseResp.ID}) require.NoError(t, err) - getResp, err := cc.Get("foo", config.GetOptions{}) + getResp, err := cc.Get(ctx, "foo", config.GetOptions{}) require.NoError(t, err) require.Equal(t, int64(1), getResp.Count) time.Sleep(3 * time.Second) - ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{}) + ttlResp, err := cc.TimeToLive(ctx, leaseResp.ID, config.LeaseOption{}) require.NoError(t, err) require.Equal(t, int64(-1), ttlResp.TTL) - getResp, err = cc.Get("foo", config.GetOptions{}) + getResp, err = cc.Get(ctx, "foo", config.GetOptions{}) require.NoError(t, err) // Value should expire with the lease require.Equal(t, int64(0), getResp.Count) @@ -190,15 +190,15 @@ func TestLeaseGrantKeepAliveOnce(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - leaseResp, err := cc.Grant(2) + leaseResp, err := cc.Grant(ctx, 2) require.NoError(t, err) - _, err = cc.LeaseKeepAliveOnce(leaseResp.ID) + _, err = cc.LeaseKeepAliveOnce(ctx, leaseResp.ID) require.NoError(t, err) time.Sleep(2 * time.Second) // Wait for the original lease to expire - ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{}) + ttlResp, err := cc.TimeToLive(ctx, leaseResp.ID, config.LeaseOption{}) require.NoError(t, err) // We still have a lease! require.Greater(t, int64(2), ttlResp.TTL) @@ -219,24 +219,24 @@ func TestLeaseGrantRevoke(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - leaseResp, err := cc.Grant(20) + leaseResp, err := cc.Grant(ctx, 20) require.NoError(t, err) - err = cc.Put("foo", "bar", config.PutOptions{LeaseID: leaseResp.ID}) + err = cc.Put(ctx, "foo", "bar", config.PutOptions{LeaseID: leaseResp.ID}) require.NoError(t, err) - getResp, err := cc.Get("foo", config.GetOptions{}) + getResp, err := cc.Get(ctx, "foo", config.GetOptions{}) require.NoError(t, err) require.Equal(t, int64(1), getResp.Count) - _, err = cc.LeaseRevoke(leaseResp.ID) + _, err = cc.LeaseRevoke(ctx, leaseResp.ID) require.NoError(t, err) - ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{}) + ttlResp, err := cc.TimeToLive(ctx, leaseResp.ID, config.LeaseOption{}) require.NoError(t, err) require.Equal(t, int64(-1), ttlResp.TTL) - getResp, err = cc.Get("foo", config.GetOptions{}) + getResp, err = cc.Get(ctx, "foo", config.GetOptions{}) require.NoError(t, err) // Value should expire with the lease require.Equal(t, int64(0), getResp.Count) diff --git a/tests/common/member_test.go b/tests/common/member_test.go index f1b6be3ae..a9b2ba428 100644 --- a/tests/common/member_test.go +++ b/tests/common/member_test.go @@ -16,9 +16,10 @@ package common import ( "context" - "go.etcd.io/etcd/tests/v3/framework/testutils" "testing" "time" + + "go.etcd.io/etcd/tests/v3/framework/testutils" ) func TestMemberList(t *testing.T) { @@ -33,7 +34,7 @@ func TestMemberList(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - resp, err := cc.MemberList() + resp, err := cc.MemberList(ctx) if err != nil { t.Fatalf("could not get member list, err: %s", err) } diff --git a/tests/common/role_test.go b/tests/common/role_test.go index 6b1382aa2..6f116fb5b 100644 --- a/tests/common/role_test.go +++ b/tests/common/role_test.go @@ -37,7 +37,7 @@ func TestRoleAdd_Simple(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - _, err := cc.RoleAdd("root") + _, err := cc.RoleAdd(ctx, "root") if err != nil { t.Fatalf("want no error, but got (%v)", err) } @@ -54,15 +54,15 @@ func TestRoleAdd_Error(t *testing.T) { defer clus.Close() cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - _, err := cc.RoleAdd("test-role") + _, err := cc.RoleAdd(ctx, "test-role") if err != nil { t.Fatalf("want no error, but got (%v)", err) } - _, err = cc.RoleAdd("test-role") + _, err = cc.RoleAdd(ctx, "test-role") if err == nil || !strings.Contains(err.Error(), rpctypes.ErrRoleAlreadyExist.Error()) { t.Fatalf("want (%v) error, but got (%v)", rpctypes.ErrRoleAlreadyExist, err) } - _, err = cc.RoleAdd("") + _, err = cc.RoleAdd(ctx, "") if err == nil || !strings.Contains(err.Error(), rpctypes.ErrRoleEmpty.Error()) { t.Fatalf("want (%v) error, but got (%v)", rpctypes.ErrRoleEmpty, err) } @@ -77,21 +77,21 @@ func TestRootRole(t *testing.T) { defer clus.Close() cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - _, err := cc.RoleAdd("root") + _, err := cc.RoleAdd(ctx, "root") if err != nil { t.Fatalf("want no error, but got (%v)", err) } - resp, err := cc.RoleGet("root") + resp, err := cc.RoleGet(ctx, "root") if err != nil { t.Fatalf("want no error, but got (%v)", err) } t.Logf("get role resp %+v", resp) // granting to root should be refused by server and a no-op - _, err = cc.RoleGrantPermission("root", "foo", "", clientv3.PermissionType(clientv3.PermReadWrite)) + _, err = cc.RoleGrantPermission(ctx, "root", "foo", "", clientv3.PermissionType(clientv3.PermReadWrite)) if err != nil { t.Fatalf("want no error, but got (%v)", err) } - resp2, err := cc.RoleGet("root") + resp2, err := cc.RoleGet(ctx, "root") if err != nil { t.Fatalf("want no error, but got (%v)", err) } @@ -107,27 +107,27 @@ func TestRoleGrantRevokePermission(t *testing.T) { defer clus.Close() cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - _, err := cc.RoleAdd("role1") + _, err := cc.RoleAdd(ctx, "role1") if err != nil { t.Fatalf("want no error, but got (%v)", err) } - _, err = cc.RoleGrantPermission("role1", "bar", "", clientv3.PermissionType(clientv3.PermRead)) + _, err = cc.RoleGrantPermission(ctx, "role1", "bar", "", clientv3.PermissionType(clientv3.PermRead)) if err != nil { t.Fatalf("want no error, but got (%v)", err) } - _, err = cc.RoleGrantPermission("role1", "bar", "", clientv3.PermissionType(clientv3.PermWrite)) + _, err = cc.RoleGrantPermission(ctx, "role1", "bar", "", clientv3.PermissionType(clientv3.PermWrite)) if err != nil { t.Fatalf("want no error, but got (%v)", err) } - _, err = cc.RoleGrantPermission("role1", "bar", "foo", clientv3.PermissionType(clientv3.PermReadWrite)) + _, err = cc.RoleGrantPermission(ctx, "role1", "bar", "foo", clientv3.PermissionType(clientv3.PermReadWrite)) if err != nil { t.Fatalf("want no error, but got (%v)", err) } - _, err = cc.RoleRevokePermission("role1", "foo", "") + _, err = cc.RoleRevokePermission(ctx, "role1", "foo", "") if err == nil || !strings.Contains(err.Error(), rpctypes.ErrPermissionNotGranted.Error()) { t.Fatalf("want error (%v), but got (%v)", rpctypes.ErrPermissionNotGranted, err) } - _, err = cc.RoleRevokePermission("role1", "bar", "foo") + _, err = cc.RoleRevokePermission(ctx, "role1", "bar", "foo") if err != nil { t.Fatalf("want no error, but got (%v)", err) } @@ -142,11 +142,11 @@ func TestRoleDelete(t *testing.T) { defer clus.Close() cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - _, err := cc.RoleAdd("role1") + _, err := cc.RoleAdd(ctx, "role1") if err != nil { t.Fatalf("want no error, but got (%v)", err) } - _, err = cc.RoleDelete("role1") + _, err = cc.RoleDelete(ctx, "role1") if err != nil { t.Fatalf("want no error, but got (%v)", err) } diff --git a/tests/common/status_test.go b/tests/common/status_test.go index deb058030..746d091a2 100644 --- a/tests/common/status_test.go +++ b/tests/common/status_test.go @@ -35,7 +35,7 @@ func TestStatus(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - rs, err := cc.Status() + rs, err := cc.Status(ctx) if err != nil { t.Fatalf("could not get status, err: %s", err) } diff --git a/tests/common/txn_test.go b/tests/common/txn_test.go index 79497224e..890c0f738 100644 --- a/tests/common/txn_test.go +++ b/tests/common/txn_test.go @@ -62,14 +62,14 @@ func TestTxnSucc(t *testing.T) { defer clus.Close() cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - if err := cc.Put("key1", "value1", config.PutOptions{}); err != nil { + if err := cc.Put(ctx, "key1", "value1", config.PutOptions{}); err != nil { t.Fatalf("could not create key:%s, value:%s", "key1", "value1") } - if err := cc.Put("key2", "value2", config.PutOptions{}); err != nil { + if err := cc.Put(ctx, "key2", "value2", config.PutOptions{}); err != nil { t.Fatalf("could not create key:%s, value:%s", "key2", "value2") } for _, req := range reqs { - resp, err := cc.Txn(req.compare, req.ifSucess, req.ifFail, config.TxnOptions{ + resp, err := cc.Txn(ctx, req.compare, req.ifSucess, req.ifFail, config.TxnOptions{ Interactive: true, }) if err != nil { @@ -106,11 +106,11 @@ func TestTxnFail(t *testing.T) { defer clus.Close() cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - if err := cc.Put("key1", "value1", config.PutOptions{}); err != nil { + if err := cc.Put(ctx, "key1", "value1", config.PutOptions{}); err != nil { t.Fatalf("could not create key:%s, value:%s", "key1", "value1") } for _, req := range reqs { - resp, err := cc.Txn(req.compare, req.ifSucess, req.ifFail, config.TxnOptions{ + resp, err := cc.Txn(ctx, req.compare, req.ifSucess, req.ifFail, config.TxnOptions{ Interactive: true, }) if err != nil { diff --git a/tests/common/user_test.go b/tests/common/user_test.go index b48a8224e..bdd785943 100644 --- a/tests/common/user_test.go +++ b/tests/common/user_test.go @@ -71,7 +71,7 @@ func TestUserAdd_Simple(t *testing.T) { cc := clus.Client() testutils.ExecuteUntil(ctx, t, func() { - resp, err := cc.UserAdd(nc.username, nc.password, config.UserAddOptions{NoPassword: nc.noPassword}) + resp, err := cc.UserAdd(ctx, nc.username, nc.password, config.UserAddOptions{NoPassword: nc.noPassword}) if nc.expectedError != "" { if err != nil { assert.Contains(t, err.Error(), nc.expectedError) @@ -108,12 +108,12 @@ func TestUserAdd_DuplicateUserNotAllowed(t *testing.T) { user := "barb" password := "rhubarb" - _, err := cc.UserAdd(user, password, config.UserAddOptions{}) + _, err := cc.UserAdd(ctx, user, password, config.UserAddOptions{}) if err != nil { t.Fatalf("first user creation should succeed, err: %v", err) } - _, err = cc.UserAdd(user, password, config.UserAddOptions{}) + _, err = cc.UserAdd(ctx, user, password, config.UserAddOptions{}) if err == nil { t.Fatalf("duplicate user creation should fail") } @@ -135,7 +135,7 @@ func TestUserList(t *testing.T) { testutils.ExecuteUntil(ctx, t, func() { // No Users Yet - resp, err := cc.UserList() + resp, err := cc.UserList(ctx) if err != nil { t.Fatalf("user listing should succeed, err: %v", err) } @@ -146,13 +146,13 @@ func TestUserList(t *testing.T) { user := "barb" password := "rhubarb" - _, err = cc.UserAdd(user, password, config.UserAddOptions{}) + _, err = cc.UserAdd(ctx, user, password, config.UserAddOptions{}) if err != nil { t.Fatalf("user creation should succeed, err: %v", err) } // Users! - resp, err = cc.UserList() + resp, err = cc.UserList(ctx) if err != nil { t.Fatalf("user listing should succeed, err: %v", err) } @@ -178,12 +178,12 @@ func TestUserDelete(t *testing.T) { user := "barb" password := "rhubarb" - _, err := cc.UserAdd(user, password, config.UserAddOptions{}) + _, err := cc.UserAdd(ctx, user, password, config.UserAddOptions{}) if err != nil { t.Fatalf("user creation should succeed, err: %v", err) } - resp, err := cc.UserList() + resp, err := cc.UserList(ctx) if err != nil { t.Fatalf("user listing should succeed, err: %v", err) } @@ -192,12 +192,12 @@ func TestUserDelete(t *testing.T) { } // Delete barb, sorry barb! - _, err = cc.UserDelete(user) + _, err = cc.UserDelete(ctx, user) if err != nil { t.Fatalf("user deletion should succeed at first, err: %v", err) } - resp, err = cc.UserList() + resp, err = cc.UserList(ctx) if err != nil { t.Fatalf("user listing should succeed, err: %v", err) } @@ -206,7 +206,7 @@ func TestUserDelete(t *testing.T) { } // Try to delete barb again - _, err = cc.UserDelete(user) + _, err = cc.UserDelete(ctx, user) if err == nil { t.Fatalf("deleting a non-existent user should fail") } @@ -231,17 +231,17 @@ func TestUserChangePassword(t *testing.T) { password := "rhubarb" newPassword := "potato" - _, err := cc.UserAdd(user, password, config.UserAddOptions{}) + _, err := cc.UserAdd(ctx, user, password, config.UserAddOptions{}) if err != nil { t.Fatalf("user creation should succeed, err: %v", err) } - err = cc.UserChangePass(user, newPassword) + err = cc.UserChangePass(ctx, user, newPassword) if err != nil { t.Fatalf("user password change should succeed, err: %v", err) } - err = cc.UserChangePass("non-existent-user", newPassword) + err = cc.UserChangePass(ctx, "non-existent-user", newPassword) if err == nil { t.Fatalf("user password change for non-existent user should fail") } diff --git a/tests/common/watch_test.go b/tests/common/watch_test.go index 496e3bc1e..e7b9cac9d 100644 --- a/tests/common/watch_test.go +++ b/tests/common/watch_test.go @@ -62,7 +62,7 @@ func TestWatch(t *testing.T) { } for j := range tt.puts { - if err := cc.Put(tt.puts[j].Key, tt.puts[j].Val, config.PutOptions{}); err != nil { + if err := cc.Put(ctx, tt.puts[j].Key, tt.puts[j].Val, config.PutOptions{}); err != nil { t.Fatalf("can't not put key %q, err: %s", tt.puts[j].Key, err) } } diff --git a/tests/e2e/cluster_downgrade_test.go b/tests/e2e/cluster_downgrade_test.go index eecf4c862..4e032e1b3 100644 --- a/tests/e2e/cluster_downgrade_test.go +++ b/tests/e2e/cluster_downgrade_test.go @@ -124,7 +124,7 @@ func startEtcd(t *testing.T, ep e2e.EtcdProcess, execPath string) { func downgradeEnable(t *testing.T, epc *e2e.EtcdProcessCluster, ver semver.Version) { c := e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()) testutils.ExecuteWithTimeout(t, 20*time.Second, func() { - err := c.DowngradeEnable(ver.String()) + err := c.DowngradeEnable(context.TODO(), ver.String()) if err != nil { t.Fatal(err) } diff --git a/tests/e2e/corrupt_test.go b/tests/e2e/corrupt_test.go index 795ef99df..88abeaa70 100644 --- a/tests/e2e/corrupt_test.go +++ b/tests/e2e/corrupt_test.go @@ -100,6 +100,8 @@ func corruptTest(cx ctlCtx) { func TestPeriodicCheckDetectsCorruption(t *testing.T) { checkTime := time.Second e2e.BeforeTest(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() epc, err := e2e.NewEtcdProcessCluster(t, &e2e.EtcdProcessClusterConfig{ ClusterSize: 3, KeepDataDir: true, @@ -117,11 +119,11 @@ func TestPeriodicCheckDetectsCorruption(t *testing.T) { cc := e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()) for i := 0; i < 10; i++ { - err := cc.Put(testutil.PickKey(int64(i)), fmt.Sprint(i), config.PutOptions{}) + err := cc.Put(ctx, testutil.PickKey(int64(i)), fmt.Sprint(i), config.PutOptions{}) assert.NoError(t, err, "error on put") } - members, err := cc.MemberList() + members, err := cc.MemberList(ctx) assert.NoError(t, err, "error on member list") var memberID uint64 for _, m := range members.Members { @@ -137,7 +139,7 @@ func TestPeriodicCheckDetectsCorruption(t *testing.T) { err = epc.Procs[0].Restart() assert.NoError(t, err) time.Sleep(checkTime * 11 / 10) - alarmResponse, err := cc.AlarmList() + alarmResponse, err := cc.AlarmList(ctx) assert.NoError(t, err, "error on alarm list") assert.Equal(t, []*etcdserverpb.AlarmMember{{Alarm: etcdserverpb.AlarmType_CORRUPT, MemberID: memberID}}, alarmResponse.Alarms) } @@ -145,6 +147,8 @@ func TestPeriodicCheckDetectsCorruption(t *testing.T) { func TestCompactHashCheckDetectCorruption(t *testing.T) { checkTime := time.Second e2e.BeforeTest(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() epc, err := e2e.NewEtcdProcessCluster(t, &e2e.EtcdProcessClusterConfig{ ClusterSize: 3, KeepDataDir: true, @@ -163,10 +167,10 @@ func TestCompactHashCheckDetectCorruption(t *testing.T) { cc := e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()) for i := 0; i < 10; i++ { - err := cc.Put(testutil.PickKey(int64(i)), fmt.Sprint(i), config.PutOptions{}) + err := cc.Put(ctx, testutil.PickKey(int64(i)), fmt.Sprint(i), config.PutOptions{}) assert.NoError(t, err, "error on put") } - members, err := cc.MemberList() + members, err := cc.MemberList(ctx) assert.NoError(t, err, "error on member list") var memberID uint64 for _, m := range members.Members { @@ -181,10 +185,10 @@ func TestCompactHashCheckDetectCorruption(t *testing.T) { err = epc.Procs[0].Restart() assert.NoError(t, err) - _, err = cc.Compact(5, config.CompactOption{}) + _, err = cc.Compact(ctx, 5, config.CompactOption{}) assert.NoError(t, err) time.Sleep(checkTime * 11 / 10) - alarmResponse, err := cc.AlarmList() + alarmResponse, err := cc.AlarmList(ctx) assert.NoError(t, err, "error on alarm list") assert.Equal(t, []*etcdserverpb.AlarmMember{{Alarm: etcdserverpb.AlarmType_CORRUPT, MemberID: memberID}}, alarmResponse.Alarms) } diff --git a/tests/e2e/ctl_v3_grpc_test.go b/tests/e2e/ctl_v3_grpc_test.go index 878dd7948..1c0bf8474 100644 --- a/tests/e2e/ctl_v3_grpc_test.go +++ b/tests/e2e/ctl_v3_grpc_test.go @@ -18,6 +18,7 @@ package e2e import ( + "context" "fmt" "strings" "testing" @@ -83,6 +84,8 @@ func TestAuthority(t *testing.T) { for _, clusterSize := range []int{1, 3} { t.Run(fmt.Sprintf("Size: %d, Scenario: %q", clusterSize, tc.name), func(t *testing.T) { e2e.BeforeTest(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() cfg := e2e.NewConfigNoTLS() cfg.ClusterSize = clusterSize @@ -101,7 +104,7 @@ func TestAuthority(t *testing.T) { endpoints := templateEndpoints(t, tc.clientURLPattern, epc) client := e2e.NewEtcdctl(cfg, endpoints) - err = client.Put("foo", "bar", config.PutOptions{}) + err = client.Put(ctx, "foo", "bar", config.PutOptions{}) if err != nil { t.Fatal(err) } diff --git a/tests/e2e/etcd_grpcproxy_test.go b/tests/e2e/etcd_grpcproxy_test.go index b9c40daa8..b5568a80f 100644 --- a/tests/e2e/etcd_grpcproxy_test.go +++ b/tests/e2e/etcd_grpcproxy_test.go @@ -34,6 +34,8 @@ import ( func TestGrpcProxyAutoSync(t *testing.T) { e2e.SkipInShortMode(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() var ( node1Name = "node1" @@ -66,11 +68,11 @@ func TestGrpcProxyAutoSync(t *testing.T) { require.NoError(t, err) proxyCtl := e2e.NewEtcdctl(&e2e.EtcdProcessClusterConfig{}, []string{proxyClientURL}) - err = proxyCtl.Put("k1", "v1", config.PutOptions{}) + err = proxyCtl.Put(ctx, "k1", "v1", config.PutOptions{}) require.NoError(t, err) memberCtl := e2e.NewEtcdctl(&e2e.EtcdProcessClusterConfig{}, []string{node1ClientURL}) - _, err = memberCtl.MemberAdd(node2Name, []string{node2PeerURL}) + _, err = memberCtl.MemberAdd(ctx, node2Name, []string{node2PeerURL}) if err != nil { t.Fatal(err) } @@ -87,7 +89,7 @@ func TestGrpcProxyAutoSync(t *testing.T) { err = waitForEndpointInLog(proxyProc, node2ClientURL) require.NoError(t, err) - memberList, err := memberCtl.MemberList() + memberList, err := memberCtl.MemberList(ctx) require.NoError(t, err) node1MemberID, err := findMemberIDByEndpoint(memberList.Members, node1ClientURL) @@ -95,7 +97,7 @@ func TestGrpcProxyAutoSync(t *testing.T) { // Second node could be not ready yet for i := 0; i < 10; i++ { - _, err = memberCtl.MemberRemove(node1MemberID) + _, err = memberCtl.MemberRemove(ctx, node1MemberID) if err != nil && strings.Contains(err.Error(), rpctypes.ErrGRPCUnhealthy.Error()) { time.Sleep(500 * time.Millisecond) continue @@ -109,7 +111,7 @@ func TestGrpcProxyAutoSync(t *testing.T) { var resp *clientv3.GetResponse for i := 0; i < 10; i++ { - resp, err = proxyCtl.Get("k1", config.GetOptions{}) + resp, err = proxyCtl.Get(ctx, "k1", config.GetOptions{}) if err != nil && strings.Contains(err.Error(), rpctypes.ErrGRPCLeaderChanged.Error()) { time.Sleep(500 * time.Millisecond) continue diff --git a/tests/e2e/v2store_deprecation_test.go b/tests/e2e/v2store_deprecation_test.go index 6ed4dca62..08c4670b8 100644 --- a/tests/e2e/v2store_deprecation_test.go +++ b/tests/e2e/v2store_deprecation_test.go @@ -16,6 +16,7 @@ package e2e import ( "bytes" + "context" "fmt" "sort" "strings" @@ -97,6 +98,8 @@ func TestV2DeprecationSnapshotMatches(t *testing.T) { e2e.BeforeTest(t) lastReleaseData := t.TempDir() currentReleaseData := t.TempDir() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() lastReleaseBinary := e2e.BinDir + "/etcd-last-release" currentReleaseBinary := e2e.BinDir + "/etcd" @@ -106,10 +109,10 @@ func TestV2DeprecationSnapshotMatches(t *testing.T) { } snapshotCount := 10 epc := runEtcdAndCreateSnapshot(t, lastReleaseBinary, lastReleaseData, snapshotCount) - members1 := addAndRemoveKeysAndMembers(t, e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()), snapshotCount) + members1 := addAndRemoveKeysAndMembers(ctx, t, e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()), snapshotCount) assert.NoError(t, epc.Close()) epc = runEtcdAndCreateSnapshot(t, currentReleaseBinary, currentReleaseData, snapshotCount) - members2 := addAndRemoveKeysAndMembers(t, e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()), snapshotCount) + members2 := addAndRemoveKeysAndMembers(ctx, t, e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()), snapshotCount) assert.NoError(t, epc.Close()) assertSnapshotsMatch(t, lastReleaseData, currentReleaseData, func(data []byte) []byte { @@ -130,6 +133,8 @@ func TestV2DeprecationSnapshotMatches(t *testing.T) { func TestV2DeprecationSnapshotRecover(t *testing.T) { e2e.BeforeTest(t) dataDir := t.TempDir() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() lastReleaseBinary := e2e.BinDir + "/etcd-last-release" currentReleaseBinary := e2e.BinDir + "/etcd" @@ -141,10 +146,10 @@ func TestV2DeprecationSnapshotRecover(t *testing.T) { cc := e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()) - lastReleaseGetResponse, err := cc.Get("", config.GetOptions{Prefix: true}) + lastReleaseGetResponse, err := cc.Get(ctx, "", config.GetOptions{Prefix: true}) assert.NoError(t, err) - lastReleaseMemberListResponse, err := cc.MemberList() + lastReleaseMemberListResponse, err := cc.MemberList(ctx) assert.NoError(t, err) assert.NoError(t, epc.Close()) @@ -153,10 +158,10 @@ func TestV2DeprecationSnapshotRecover(t *testing.T) { assert.NoError(t, err) cc = e2e.NewEtcdctl(epc.Cfg, epc.EndpointsV3()) - currentReleaseGetResponse, err := cc.Get("", config.GetOptions{Prefix: true}) + currentReleaseGetResponse, err := cc.Get(ctx, "", config.GetOptions{Prefix: true}) assert.NoError(t, err) - currentReleaseMemberListResponse, err := cc.MemberList() + currentReleaseMemberListResponse, err := cc.MemberList(ctx) assert.NoError(t, err) assert.Equal(t, lastReleaseGetResponse.Kvs, currentReleaseGetResponse.Kvs) @@ -171,33 +176,33 @@ func runEtcdAndCreateSnapshot(t testing.TB, binary, dataDir string, snapshotCoun return epc } -func addAndRemoveKeysAndMembers(t testing.TB, cc *e2e.EtcdctlV3, snapshotCount int) (members []uint64) { +func addAndRemoveKeysAndMembers(ctx context.Context, t testing.TB, cc *e2e.EtcdctlV3, snapshotCount int) (members []uint64) { // Execute some non-trivial key&member operation for i := 0; i < snapshotCount*3; i++ { - err := cc.Put(fmt.Sprintf("%d", i), "1", config.PutOptions{}) + err := cc.Put(ctx, fmt.Sprintf("%d", i), "1", config.PutOptions{}) assert.NoError(t, err) } - member1, err := cc.MemberAddAsLearner("member1", []string{"http://127.0.0.1:2000"}) + member1, err := cc.MemberAddAsLearner(ctx, "member1", []string{"http://127.0.0.1:2000"}) assert.NoError(t, err) members = append(members, member1.Member.ID) for i := 0; i < snapshotCount*2; i++ { - _, err = cc.Delete(fmt.Sprintf("%d", i), config.DeleteOptions{}) + _, err = cc.Delete(ctx, fmt.Sprintf("%d", i), config.DeleteOptions{}) assert.NoError(t, err) } - _, err = cc.MemberRemove(member1.Member.ID) + _, err = cc.MemberRemove(ctx, member1.Member.ID) assert.NoError(t, err) for i := 0; i < snapshotCount; i++ { - err = cc.Put(fmt.Sprintf("%d", i), "2", config.PutOptions{}) + err = cc.Put(ctx, fmt.Sprintf("%d", i), "2", config.PutOptions{}) assert.NoError(t, err) } - member2, err := cc.MemberAddAsLearner("member2", []string{"http://127.0.0.1:2001"}) + member2, err := cc.MemberAddAsLearner(ctx, "member2", []string{"http://127.0.0.1:2001"}) assert.NoError(t, err) members = append(members, member2.Member.ID) for i := 0; i < snapshotCount/2; i++ { - err = cc.Put(fmt.Sprintf("%d", i), "3", config.PutOptions{}) + err = cc.Put(ctx, fmt.Sprintf("%d", i), "3", config.PutOptions{}) assert.NoError(t, err) } return members diff --git a/tests/e2e/v3_curl_test.go b/tests/e2e/v3_curl_test.go index e01e8dd44..10e996a2c 100644 --- a/tests/e2e/v3_curl_test.go +++ b/tests/e2e/v3_curl_test.go @@ -288,7 +288,7 @@ func testV3CurlCampaign(cx ctlCtx) { Endpoint: path.Join(cx.apiPrefix, "/election/campaign"), Value: string(cdata), }) - lines, err := e2e.SpawnWithExpectLines(cargs, cx.envMap, `"leader":{"name":"`) + lines, err := e2e.SpawnWithExpectLines(context.TODO(), cargs, cx.envMap, `"leader":{"name":"`) if err != nil { cx.t.Fatalf("failed post campaign request (%s) (%v)", cx.apiPrefix, err) } diff --git a/tests/framework/e2e.go b/tests/framework/e2e.go index fda02990d..d1731eac0 100644 --- a/tests/framework/e2e.go +++ b/tests/framework/e2e.go @@ -114,7 +114,7 @@ func (c *e2eCluster) WaitMembersForLeader(ctx context.Context, t testing.TB, mem t.Fatal("WaitMembersForLeader timeout") default: } - _, err := cc.Get("0", config.GetOptions{Timeout: 10*config.TickDuration + time.Second}) + _, err := cc.Get(ctx, "0", config.GetOptions{Timeout: 10*config.TickDuration + time.Second}) if err == nil || strings.Contains(err.Error(), "Key not found") { break } @@ -129,7 +129,7 @@ func (c *e2eCluster) WaitMembersForLeader(ctx context.Context, t testing.TB, mem default: } for i := range membs { - resp, err := membs[i].Client().Status() + resp, err := membs[i].Client().Status(ctx) if err != nil { if strings.Contains(err.Error(), "connection refused") { // if member[i] has stopped diff --git a/tests/framework/e2e/etcdctl.go b/tests/framework/e2e/etcdctl.go index fd5e7d81d..c08d51e63 100644 --- a/tests/framework/e2e/etcdctl.go +++ b/tests/framework/e2e/etcdctl.go @@ -40,11 +40,12 @@ func NewEtcdctl(cfg *EtcdProcessClusterConfig, endpoints []string) *EtcdctlV3 { } } -func (ctl *EtcdctlV3) DowngradeEnable(version string) error { - return SpawnWithExpect(ctl.cmdArgs("downgrade", "enable", version), "Downgrade enable success") +func (ctl *EtcdctlV3) DowngradeEnable(ctx context.Context, version string) error { + _, err := SpawnWithExpectLines(ctx, ctl.cmdArgs("downgrade", "enable", version), nil, "Downgrade enable success") + return err } -func (ctl *EtcdctlV3) Get(key string, o config.GetOptions) (*clientv3.GetResponse, error) { +func (ctl *EtcdctlV3) Get(ctx context.Context, key string, o config.GetOptions) (*clientv3.GetResponse, error) { resp := clientv3.GetResponse{} var args []string if o.Timeout != 0 { @@ -104,23 +105,24 @@ func (ctl *EtcdctlV3) Get(key string, o config.GetOptions) (*clientv3.GetRespons return nil, err } defer cmd.Close() - _, err = cmd.Expect("Count") + _, err = cmd.ExpectWithContext(ctx, "Count") return &resp, err } - err := ctl.spawnJsonCmd(&resp, args...) + err := ctl.spawnJsonCmd(ctx, &resp, args...) return &resp, err } -func (ctl *EtcdctlV3) Put(key, value string, opts config.PutOptions) error { +func (ctl *EtcdctlV3) Put(ctx context.Context, key, value string, opts config.PutOptions) error { args := ctl.cmdArgs() args = append(args, "put", key, value) if opts.LeaseID != 0 { args = append(args, "--lease", strconv.FormatInt(int64(opts.LeaseID), 16)) } - return SpawnWithExpect(args, "OK") + _, err := SpawnWithExpectLines(ctx, args, nil, "OK") + return err } -func (ctl *EtcdctlV3) Delete(key string, o config.DeleteOptions) (*clientv3.DeleteResponse, error) { +func (ctl *EtcdctlV3) Delete(ctx context.Context, key string, o config.DeleteOptions) (*clientv3.DeleteResponse, error) { args := []string{"del", key} if o.End != "" { args = append(args, o.End) @@ -132,11 +134,11 @@ func (ctl *EtcdctlV3) Delete(key string, o config.DeleteOptions) (*clientv3.Dele args = append(args, "--from-key") } var resp clientv3.DeleteResponse - err := ctl.spawnJsonCmd(&resp, args...) + err := ctl.spawnJsonCmd(ctx, &resp, args...) return &resp, err } -func (ctl *EtcdctlV3) Txn(compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) { +func (ctl *EtcdctlV3) Txn(ctx context.Context, compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) { args := ctl.cmdArgs() args = append(args, "txn") if o.Interactive { @@ -148,7 +150,7 @@ func (ctl *EtcdctlV3) Txn(compares, ifSucess, ifFail []string, o config.TxnOptio return nil, err } defer cmd.Close() - _, err = cmd.Expect("compares:") + _, err = cmd.ExpectWithContext(ctx, "compares:") if err != nil { return nil, err } @@ -160,7 +162,7 @@ func (ctl *EtcdctlV3) Txn(compares, ifSucess, ifFail []string, o config.TxnOptio if err := cmd.Send("\r"); err != nil { return nil, err } - _, err = cmd.Expect("success requests (get, put, del):") + _, err = cmd.ExpectWithContext(ctx, "success requests (get, put, del):") if err != nil { return nil, err } @@ -173,7 +175,7 @@ func (ctl *EtcdctlV3) Txn(compares, ifSucess, ifFail []string, o config.TxnOptio return nil, err } - _, err = cmd.Expect("failure requests (get, put, del):") + _, err = cmd.ExpectWithContext(ctx, "failure requests (get, put, del):") if err != nil { return nil, err } @@ -186,7 +188,7 @@ func (ctl *EtcdctlV3) Txn(compares, ifSucess, ifFail []string, o config.TxnOptio return nil, err } var line string - line, err = cmd.Expect("header") + line, err = cmd.ExpectWithContext(ctx, "header") if err != nil { return nil, err } @@ -232,27 +234,27 @@ func AddTxnResponse(resp *clientv3.TxnResponse, jsonData string) { } } } -func (ctl *EtcdctlV3) MemberList() (*clientv3.MemberListResponse, error) { +func (ctl *EtcdctlV3) MemberList(ctx context.Context) (*clientv3.MemberListResponse, error) { var resp clientv3.MemberListResponse - err := ctl.spawnJsonCmd(&resp, "member", "list") + err := ctl.spawnJsonCmd(ctx, &resp, "member", "list") return &resp, err } -func (ctl *EtcdctlV3) MemberAdd(name string, peerAddrs []string) (*clientv3.MemberAddResponse, error) { +func (ctl *EtcdctlV3) MemberAdd(ctx context.Context, name string, peerAddrs []string) (*clientv3.MemberAddResponse, error) { var resp clientv3.MemberAddResponse - err := ctl.spawnJsonCmd(&resp, "member", "add", name, "--peer-urls", strings.Join(peerAddrs, ",")) + err := ctl.spawnJsonCmd(ctx, &resp, "member", "add", name, "--peer-urls", strings.Join(peerAddrs, ",")) return &resp, err } -func (ctl *EtcdctlV3) MemberAddAsLearner(name string, peerAddrs []string) (*clientv3.MemberAddResponse, error) { +func (ctl *EtcdctlV3) MemberAddAsLearner(ctx context.Context, name string, peerAddrs []string) (*clientv3.MemberAddResponse, error) { var resp clientv3.MemberAddResponse - err := ctl.spawnJsonCmd(&resp, "member", "add", name, "--learner", "--peer-urls", strings.Join(peerAddrs, ",")) + err := ctl.spawnJsonCmd(ctx, &resp, "member", "add", name, "--learner", "--peer-urls", strings.Join(peerAddrs, ",")) return &resp, err } -func (ctl *EtcdctlV3) MemberRemove(id uint64) (*clientv3.MemberRemoveResponse, error) { +func (ctl *EtcdctlV3) MemberRemove(ctx context.Context, id uint64) (*clientv3.MemberRemoveResponse, error) { var resp clientv3.MemberRemoveResponse - err := ctl.spawnJsonCmd(&resp, "member", "remove", fmt.Sprintf("%x", id)) + err := ctl.spawnJsonCmd(ctx, &resp, "member", "remove", fmt.Sprintf("%x", id)) return &resp, err } @@ -284,7 +286,7 @@ func (ctl *EtcdctlV3) flags() map[string]string { return fmap } -func (ctl *EtcdctlV3) Compact(rev int64, o config.CompactOption) (*clientv3.CompactResponse, error) { +func (ctl *EtcdctlV3) Compact(ctx context.Context, rev int64, o config.CompactOption) (*clientv3.CompactResponse, error) { args := ctl.cmdArgs("compact", fmt.Sprint(rev)) if o.Timeout != 0 { args = append(args, fmt.Sprintf("--command-timeout=%s", o.Timeout)) @@ -293,15 +295,16 @@ func (ctl *EtcdctlV3) Compact(rev int64, o config.CompactOption) (*clientv3.Comp args = append(args, "--physical") } - return nil, SpawnWithExpect(args, fmt.Sprintf("compacted revision %v", rev)) + _, err := SpawnWithExpectLines(ctx, args, nil, fmt.Sprintf("compacted revision %v", rev)) + return nil, err } -func (ctl *EtcdctlV3) Status() ([]*clientv3.StatusResponse, error) { +func (ctl *EtcdctlV3) Status(ctx context.Context) ([]*clientv3.StatusResponse, error) { var epStatus []*struct { Endpoint string Status *clientv3.StatusResponse } - err := ctl.spawnJsonCmd(&epStatus, "endpoint", "status") + err := ctl.spawnJsonCmd(ctx, &epStatus, "endpoint", "status") if err != nil { return nil, err } @@ -312,12 +315,12 @@ func (ctl *EtcdctlV3) Status() ([]*clientv3.StatusResponse, error) { return resp, err } -func (ctl *EtcdctlV3) HashKV(rev int64) ([]*clientv3.HashKVResponse, error) { +func (ctl *EtcdctlV3) HashKV(ctx context.Context, rev int64) ([]*clientv3.HashKVResponse, error) { var epHashKVs []*struct { Endpoint string HashKV *clientv3.HashKVResponse } - err := ctl.spawnJsonCmd(&epHashKVs, "endpoint", "hashkv", "--endpoints", strings.Join(ctl.endpoints, ","), "--rev", fmt.Sprint(rev)) + err := ctl.spawnJsonCmd(ctx, &epHashKVs, "endpoint", "hashkv", "--endpoints", strings.Join(ctl.endpoints, ","), "--rev", fmt.Sprint(rev)) if err != nil { return nil, err } @@ -328,17 +331,18 @@ func (ctl *EtcdctlV3) HashKV(rev int64) ([]*clientv3.HashKVResponse, error) { return resp, err } -func (ctl *EtcdctlV3) Health() error { +func (ctl *EtcdctlV3) Health(ctx context.Context) error { args := ctl.cmdArgs() args = append(args, "endpoint", "health") lines := make([]string, len(ctl.endpoints)) for i := range lines { lines[i] = "is healthy" } - return SpawnWithExpects(args, map[string]string{}, lines...) + _, err := SpawnWithExpectLines(ctx, args, nil, lines...) + return err } -func (ctl *EtcdctlV3) Grant(ttl int64) (*clientv3.LeaseGrantResponse, error) { +func (ctl *EtcdctlV3) Grant(ctx context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error) { args := ctl.cmdArgs() args = append(args, "lease", "grant", strconv.FormatInt(ttl, 10), "-w", "json") cmd, err := SpawnCmd(args, nil) @@ -347,7 +351,7 @@ func (ctl *EtcdctlV3) Grant(ttl int64) (*clientv3.LeaseGrantResponse, error) { } defer cmd.Close() var resp clientv3.LeaseGrantResponse - line, err := cmd.Expect("ID") + line, err := cmd.ExpectWithContext(ctx, "ID") if err != nil { return nil, err } @@ -355,7 +359,7 @@ func (ctl *EtcdctlV3) Grant(ttl int64) (*clientv3.LeaseGrantResponse, error) { return &resp, err } -func (ctl *EtcdctlV3) TimeToLive(id clientv3.LeaseID, o config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) { +func (ctl *EtcdctlV3) TimeToLive(ctx context.Context, id clientv3.LeaseID, o config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) { args := ctl.cmdArgs() args = append(args, "lease", "timetolive", strconv.FormatInt(int64(id), 16), "-w", "json") if o.WithAttachedKeys { @@ -367,7 +371,7 @@ func (ctl *EtcdctlV3) TimeToLive(id clientv3.LeaseID, o config.LeaseOption) (*cl } defer cmd.Close() var resp clientv3.LeaseTimeToLiveResponse - line, err := cmd.Expect("id") + line, err := cmd.ExpectWithContext(ctx, "id") if err != nil { return nil, err } @@ -375,7 +379,7 @@ func (ctl *EtcdctlV3) TimeToLive(id clientv3.LeaseID, o config.LeaseOption) (*cl return &resp, err } -func (ctl *EtcdctlV3) Defragment(o config.DefragOption) error { +func (ctl *EtcdctlV3) Defragment(ctx context.Context, o config.DefragOption) error { args := append(ctl.cmdArgs(), "defrag") if o.Timeout != 0 { args = append(args, fmt.Sprintf("--command-timeout=%s", o.Timeout)) @@ -384,11 +388,11 @@ func (ctl *EtcdctlV3) Defragment(o config.DefragOption) error { for i := range lines { lines[i] = "Finished defragmenting etcd member" } - _, err := SpawnWithExpectLines(args, map[string]string{}, lines...) + _, err := SpawnWithExpectLines(ctx, args, map[string]string{}, lines...) return err } -func (ctl *EtcdctlV3) LeaseList() (*clientv3.LeaseLeasesResponse, error) { +func (ctl *EtcdctlV3) LeaseList(ctx context.Context) (*clientv3.LeaseLeasesResponse, error) { args := ctl.cmdArgs("lease", "list", "-w", "json") cmd, err := SpawnCmd(args, nil) if err != nil { @@ -396,7 +400,7 @@ func (ctl *EtcdctlV3) LeaseList() (*clientv3.LeaseLeasesResponse, error) { } defer cmd.Close() var resp clientv3.LeaseLeasesResponse - line, err := cmd.Expect("id") + line, err := cmd.ExpectWithContext(ctx, "id") if err != nil { return nil, err } @@ -404,7 +408,7 @@ func (ctl *EtcdctlV3) LeaseList() (*clientv3.LeaseLeasesResponse, error) { return &resp, err } -func (ctl *EtcdctlV3) LeaseKeepAliveOnce(id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { +func (ctl *EtcdctlV3) LeaseKeepAliveOnce(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { args := ctl.cmdArgs("lease", "keep-alive", strconv.FormatInt(int64(id), 16), "--once", "-w", "json") cmd, err := SpawnCmd(args, nil) if err != nil { @@ -412,7 +416,7 @@ func (ctl *EtcdctlV3) LeaseKeepAliveOnce(id clientv3.LeaseID) (*clientv3.LeaseKe } defer cmd.Close() var resp clientv3.LeaseKeepAliveResponse - line, err := cmd.Expect("ID") + line, err := cmd.ExpectWithContext(ctx, "ID") if err != nil { return nil, err } @@ -420,19 +424,19 @@ func (ctl *EtcdctlV3) LeaseKeepAliveOnce(id clientv3.LeaseID) (*clientv3.LeaseKe return &resp, err } -func (ctl *EtcdctlV3) LeaseRevoke(id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { +func (ctl *EtcdctlV3) LeaseRevoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { var resp clientv3.LeaseRevokeResponse - err := ctl.spawnJsonCmd(&resp, "lease", "revoke", strconv.FormatInt(int64(id), 16)) + err := ctl.spawnJsonCmd(ctx, &resp, "lease", "revoke", strconv.FormatInt(int64(id), 16)) return &resp, err } -func (ctl *EtcdctlV3) AlarmList() (*clientv3.AlarmResponse, error) { +func (ctl *EtcdctlV3) AlarmList(ctx context.Context) (*clientv3.AlarmResponse, error) { var resp clientv3.AlarmResponse - err := ctl.spawnJsonCmd(&resp, "alarm", "list") + err := ctl.spawnJsonCmd(ctx, &resp, "alarm", "list") return &resp, err } -func (ctl *EtcdctlV3) AlarmDisarm(_ *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) { +func (ctl *EtcdctlV3) AlarmDisarm(ctx context.Context, _ *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) { args := ctl.cmdArgs() args = append(args, "alarm", "disarm", "-w", "json") ep, err := SpawnCmd(args, nil) @@ -441,7 +445,7 @@ func (ctl *EtcdctlV3) AlarmDisarm(_ *clientv3.AlarmMember) (*clientv3.AlarmRespo } defer ep.Close() var resp clientv3.AlarmResponse - line, err := ep.Expect("alarm") + line, err := ep.ExpectWithContext(ctx, "alarm") if err != nil { return nil, err } @@ -449,7 +453,7 @@ func (ctl *EtcdctlV3) AlarmDisarm(_ *clientv3.AlarmMember) (*clientv3.AlarmRespo return &resp, err } -func (ctl *EtcdctlV3) UserAdd(name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) { +func (ctl *EtcdctlV3) UserAdd(ctx context.Context, name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) { args := ctl.cmdArgs() args = append(args, "user", "add") if password == "" { @@ -480,7 +484,7 @@ func (ctl *EtcdctlV3) UserAdd(name, password string, opts config.UserAddOptions) } var resp clientv3.AuthUserAddResponse - line, err := cmd.Expect("header") + line, err := cmd.ExpectWithContext(ctx, "header") if err != nil { return nil, err } @@ -488,19 +492,19 @@ func (ctl *EtcdctlV3) UserAdd(name, password string, opts config.UserAddOptions) return &resp, err } -func (ctl *EtcdctlV3) UserList() (*clientv3.AuthUserListResponse, error) { +func (ctl *EtcdctlV3) UserList(ctx context.Context) (*clientv3.AuthUserListResponse, error) { var resp clientv3.AuthUserListResponse - err := ctl.spawnJsonCmd(&resp, "user", "list") + err := ctl.spawnJsonCmd(ctx, &resp, "user", "list") return &resp, err } -func (ctl *EtcdctlV3) UserDelete(name string) (*clientv3.AuthUserDeleteResponse, error) { +func (ctl *EtcdctlV3) UserDelete(ctx context.Context, name string) (*clientv3.AuthUserDeleteResponse, error) { var resp clientv3.AuthUserDeleteResponse - err := ctl.spawnJsonCmd(&resp, "user", "delete", name) + err := ctl.spawnJsonCmd(ctx, &resp, "user", "delete", name) return &resp, err } -func (ctl *EtcdctlV3) UserChangePass(user, newPass string) error { +func (ctl *EtcdctlV3) UserChangePass(ctx context.Context, user, newPass string) error { args := ctl.cmdArgs() args = append(args, "user", "passwd", user, "--interactive=false") cmd, err := SpawnCmd(args, nil) @@ -513,55 +517,55 @@ func (ctl *EtcdctlV3) UserChangePass(user, newPass string) error { return err } - _, err = cmd.Expect("Password updated") + _, err = cmd.ExpectWithContext(ctx, "Password updated") return err } -func (ctl *EtcdctlV3) RoleAdd(name string) (*clientv3.AuthRoleAddResponse, error) { +func (ctl *EtcdctlV3) RoleAdd(ctx context.Context, name string) (*clientv3.AuthRoleAddResponse, error) { var resp clientv3.AuthRoleAddResponse - err := ctl.spawnJsonCmd(&resp, "role", "add", name) + err := ctl.spawnJsonCmd(ctx, &resp, "role", "add", name) return &resp, err } -func (ctl *EtcdctlV3) RoleGrantPermission(name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) { +func (ctl *EtcdctlV3) RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) { permissionType := authpb.Permission_Type_name[int32(permType)] var resp clientv3.AuthRoleGrantPermissionResponse - err := ctl.spawnJsonCmd(&resp, "role", "grant-permission", name, permissionType, key, rangeEnd) + err := ctl.spawnJsonCmd(ctx, &resp, "role", "grant-permission", name, permissionType, key, rangeEnd) return &resp, err } -func (ctl *EtcdctlV3) RoleGet(role string) (*clientv3.AuthRoleGetResponse, error) { +func (ctl *EtcdctlV3) RoleGet(ctx context.Context, role string) (*clientv3.AuthRoleGetResponse, error) { var resp clientv3.AuthRoleGetResponse - err := ctl.spawnJsonCmd(&resp, "role", "get", role) + err := ctl.spawnJsonCmd(ctx, &resp, "role", "get", role) return &resp, err } -func (ctl *EtcdctlV3) RoleList() (*clientv3.AuthRoleListResponse, error) { +func (ctl *EtcdctlV3) RoleList(ctx context.Context) (*clientv3.AuthRoleListResponse, error) { var resp clientv3.AuthRoleListResponse - err := ctl.spawnJsonCmd(&resp, "role", "list") + err := ctl.spawnJsonCmd(ctx, &resp, "role", "list") return &resp, err } -func (ctl *EtcdctlV3) RoleRevokePermission(role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) { +func (ctl *EtcdctlV3) RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) { var resp clientv3.AuthRoleRevokePermissionResponse - err := ctl.spawnJsonCmd(&resp, "role", "revoke-permission", role, key, rangeEnd) + err := ctl.spawnJsonCmd(ctx, &resp, "role", "revoke-permission", role, key, rangeEnd) return &resp, err } -func (ctl *EtcdctlV3) RoleDelete(role string) (*clientv3.AuthRoleDeleteResponse, error) { +func (ctl *EtcdctlV3) RoleDelete(ctx context.Context, role string) (*clientv3.AuthRoleDeleteResponse, error) { var resp clientv3.AuthRoleDeleteResponse - err := ctl.spawnJsonCmd(&resp, "role", "delete", role) + err := ctl.spawnJsonCmd(ctx, &resp, "role", "delete", role) return &resp, err } -func (ctl *EtcdctlV3) spawnJsonCmd(output interface{}, args ...string) error { +func (ctl *EtcdctlV3) spawnJsonCmd(ctx context.Context, output interface{}, args ...string) error { args = append(args, "-w", "json") cmd, err := SpawnCmd(append(ctl.cmdArgs(), args...), nil) if err != nil { return err } defer cmd.Close() - line, err := cmd.Expect("header") + line, err := cmd.ExpectWithContext(ctx, "header") if err != nil { return err } diff --git a/tests/framework/e2e/util.go b/tests/framework/e2e/util.go index 22da4482e..ab9cf69bc 100644 --- a/tests/framework/e2e/util.go +++ b/tests/framework/e2e/util.go @@ -50,11 +50,11 @@ func SpawnWithExpectWithEnv(args []string, envVars map[string]string, expected s } func SpawnWithExpects(args []string, envVars map[string]string, xs ...string) error { - _, err := SpawnWithExpectLines(args, envVars, xs...) + _, err := SpawnWithExpectLines(context.TODO(), args, envVars, xs...) return err } -func SpawnWithExpectLines(args []string, envVars map[string]string, xs ...string) ([]string, error) { +func SpawnWithExpectLines(ctx context.Context, args []string, envVars map[string]string, xs ...string) ([]string, error) { proc, err := SpawnCmd(args, envVars) if err != nil { return nil, err @@ -66,7 +66,7 @@ func SpawnWithExpectLines(args []string, envVars map[string]string, xs ...string lines []string ) for _, txt := range xs { - l, lerr := proc.Expect(txt) + l, lerr := proc.ExpectWithContext(ctx, txt) if lerr != nil { proc.Close() return nil, fmt.Errorf("%v %v (expected %q, got %q). Try EXPECT_DEBUG=TRUE", args, lerr, txt, lines) diff --git a/tests/framework/integration.go b/tests/framework/integration.go index efb22f24a..907781a39 100644 --- a/tests/framework/integration.go +++ b/tests/framework/integration.go @@ -87,19 +87,18 @@ type integrationCluster struct { func (c *integrationCluster) Members() (ms []Member) { for _, m := range c.Cluster.Members { - ms = append(ms, integrationMember{Member: m, t: c.t, ctx: c.ctx}) + ms = append(ms, integrationMember{Member: m, t: c.t}) } return ms } type integrationMember struct { *integration.Member - t testing.TB - ctx context.Context + t testing.TB } func (m integrationMember) Client() Client { - return integrationClient{Client: m.Member.Client, ctx: m.ctx} + return integrationClient{Client: m.Member.Client} } func (m integrationMember) Start() error { @@ -120,16 +119,14 @@ func (c *integrationCluster) Client() Client { if err != nil { c.t.Fatal(err) } - return integrationClient{Client: cc, ctx: c.ctx} + return integrationClient{Client: cc} } type integrationClient struct { *clientv3.Client - ctx context.Context } -func (c integrationClient) Get(key string, o config.GetOptions) (*clientv3.GetResponse, error) { - ctx := c.ctx +func (c integrationClient) Get(ctx context.Context, key string, o config.GetOptions) (*clientv3.GetResponse, error) { if o.Timeout != 0 { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, o.Timeout) @@ -163,16 +160,16 @@ func (c integrationClient) Get(key string, o config.GetOptions) (*clientv3.GetRe return c.Client.Get(ctx, key, clientOpts...) } -func (c integrationClient) Put(key, value string, opts config.PutOptions) error { +func (c integrationClient) Put(ctx context.Context, key, value string, opts config.PutOptions) error { clientOpts := []clientv3.OpOption{} if opts.LeaseID != 0 { clientOpts = append(clientOpts, clientv3.WithLease(opts.LeaseID)) } - _, err := c.Client.Put(c.ctx, key, value, clientOpts...) + _, err := c.Client.Put(ctx, key, value, clientOpts...) return err } -func (c integrationClient) Delete(key string, o config.DeleteOptions) (*clientv3.DeleteResponse, error) { +func (c integrationClient) Delete(ctx context.Context, key string, o config.DeleteOptions) (*clientv3.DeleteResponse, error) { clientOpts := []clientv3.OpOption{} if o.Prefix { clientOpts = append(clientOpts, clientv3.WithPrefix()) @@ -183,11 +180,10 @@ func (c integrationClient) Delete(key string, o config.DeleteOptions) (*clientv3 if o.End != "" { clientOpts = append(clientOpts, clientv3.WithRange(o.End)) } - return c.Client.Delete(c.ctx, key, clientOpts...) + return c.Client.Delete(ctx, key, clientOpts...) } -func (c integrationClient) Compact(rev int64, o config.CompactOption) (*clientv3.CompactResponse, error) { - ctx := c.ctx +func (c integrationClient) Compact(ctx context.Context, rev int64, o config.CompactOption) (*clientv3.CompactResponse, error) { if o.Timeout != 0 { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, o.Timeout) @@ -200,19 +196,19 @@ func (c integrationClient) Compact(rev int64, o config.CompactOption) (*clientv3 return c.Client.Compact(ctx, rev, clientOpts...) } -func (c integrationClient) AlarmList() (*clientv3.AlarmResponse, error) { - return c.Client.AlarmList(c.ctx) +func (c integrationClient) AlarmList(ctx context.Context) (*clientv3.AlarmResponse, error) { + return c.Client.AlarmList(ctx) } -func (c integrationClient) AlarmDisarm(alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) { - return c.Client.AlarmDisarm(c.ctx, alarmMember) +func (c integrationClient) AlarmDisarm(ctx context.Context, alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) { + return c.Client.AlarmDisarm(ctx, alarmMember) } -func (c integrationClient) Status() ([]*clientv3.StatusResponse, error) { +func (c integrationClient) Status(ctx context.Context) ([]*clientv3.StatusResponse, error) { endpoints := c.Client.Endpoints() var resp []*clientv3.StatusResponse for _, ep := range endpoints { - status, err := c.Client.Status(c.ctx, ep) + status, err := c.Client.Status(ctx, ep) if err != nil { return nil, err } @@ -221,11 +217,11 @@ func (c integrationClient) Status() ([]*clientv3.StatusResponse, error) { return resp, nil } -func (c integrationClient) HashKV(rev int64) ([]*clientv3.HashKVResponse, error) { +func (c integrationClient) HashKV(ctx context.Context, rev int64) ([]*clientv3.HashKVResponse, error) { endpoints := c.Client.Endpoints() var resp []*clientv3.HashKVResponse for _, ep := range endpoints { - hashKV, err := c.Client.HashKV(c.ctx, ep, rev) + hashKV, err := c.Client.HashKV(ctx, ep, rev) if err != nil { return nil, err } @@ -234,9 +230,9 @@ func (c integrationClient) HashKV(rev int64) ([]*clientv3.HashKVResponse, error) return resp, nil } -func (c integrationClient) Health() error { +func (c integrationClient) Health(ctx context.Context) error { cli := healthpb.NewHealthClient(c.Client.ActiveConnection()) - resp, err := cli.Check(c.ctx, &healthpb.HealthCheckRequest{}) + resp, err := cli.Check(ctx, &healthpb.HealthCheckRequest{}) if err != nil { return err } @@ -246,8 +242,7 @@ func (c integrationClient) Health() error { return nil } -func (c integrationClient) Defragment(o config.DefragOption) error { - ctx := c.ctx +func (c integrationClient) Defragment(ctx context.Context, o config.DefragOption) error { if o.Timeout != 0 { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, o.Timeout) @@ -262,76 +257,76 @@ func (c integrationClient) Defragment(o config.DefragOption) error { return nil } -func (c integrationClient) Grant(ttl int64) (*clientv3.LeaseGrantResponse, error) { - return c.Client.Grant(c.ctx, ttl) +func (c integrationClient) Grant(ctx context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error) { + return c.Client.Grant(ctx, ttl) } -func (c integrationClient) TimeToLive(id clientv3.LeaseID, o config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) { +func (c integrationClient) TimeToLive(ctx context.Context, id clientv3.LeaseID, o config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) { leaseOpts := []clientv3.LeaseOption{} if o.WithAttachedKeys { leaseOpts = append(leaseOpts, clientv3.WithAttachedKeys()) } - return c.Client.TimeToLive(c.ctx, id, leaseOpts...) + return c.Client.TimeToLive(ctx, id, leaseOpts...) } -func (c integrationClient) LeaseList() (*clientv3.LeaseLeasesResponse, error) { - return c.Client.Leases(c.ctx) +func (c integrationClient) LeaseList(ctx context.Context) (*clientv3.LeaseLeasesResponse, error) { + return c.Client.Leases(ctx) } -func (c integrationClient) LeaseKeepAliveOnce(id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { - return c.Client.KeepAliveOnce(c.ctx, id) +func (c integrationClient) LeaseKeepAliveOnce(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { + return c.Client.KeepAliveOnce(ctx, id) } -func (c integrationClient) LeaseRevoke(id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { - return c.Client.Revoke(c.ctx, id) +func (c integrationClient) LeaseRevoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { + return c.Client.Revoke(ctx, id) } -func (c integrationClient) UserAdd(name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) { - return c.Client.UserAddWithOptions(c.ctx, name, password, &clientv3.UserAddOptions{ +func (c integrationClient) UserAdd(ctx context.Context, name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) { + return c.Client.UserAddWithOptions(ctx, name, password, &clientv3.UserAddOptions{ NoPassword: opts.NoPassword, }) } -func (c integrationClient) UserList() (*clientv3.AuthUserListResponse, error) { - return c.Client.UserList(c.ctx) +func (c integrationClient) UserList(ctx context.Context) (*clientv3.AuthUserListResponse, error) { + return c.Client.UserList(ctx) } -func (c integrationClient) UserDelete(name string) (*clientv3.AuthUserDeleteResponse, error) { - return c.Client.UserDelete(c.ctx, name) +func (c integrationClient) UserDelete(ctx context.Context, name string) (*clientv3.AuthUserDeleteResponse, error) { + return c.Client.UserDelete(ctx, name) } -func (c integrationClient) UserChangePass(user, newPass string) error { - _, err := c.Client.UserChangePassword(c.ctx, user, newPass) +func (c integrationClient) UserChangePass(ctx context.Context, user, newPass string) error { + _, err := c.Client.UserChangePassword(ctx, user, newPass) return err } -func (c integrationClient) RoleAdd(name string) (*clientv3.AuthRoleAddResponse, error) { - return c.Client.RoleAdd(c.ctx, name) +func (c integrationClient) RoleAdd(ctx context.Context, name string) (*clientv3.AuthRoleAddResponse, error) { + return c.Client.RoleAdd(ctx, name) } -func (c integrationClient) RoleGrantPermission(name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) { - return c.Client.RoleGrantPermission(c.ctx, name, key, rangeEnd, permType) +func (c integrationClient) RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) { + return c.Client.RoleGrantPermission(ctx, name, key, rangeEnd, permType) } -func (c integrationClient) RoleGet(role string) (*clientv3.AuthRoleGetResponse, error) { - return c.Client.RoleGet(c.ctx, role) +func (c integrationClient) RoleGet(ctx context.Context, role string) (*clientv3.AuthRoleGetResponse, error) { + return c.Client.RoleGet(ctx, role) } -func (c integrationClient) RoleList() (*clientv3.AuthRoleListResponse, error) { - return c.Client.RoleList(c.ctx) +func (c integrationClient) RoleList(ctx context.Context) (*clientv3.AuthRoleListResponse, error) { + return c.Client.RoleList(ctx) } -func (c integrationClient) RoleRevokePermission(role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) { - return c.Client.RoleRevokePermission(c.ctx, role, key, rangeEnd) +func (c integrationClient) RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) { + return c.Client.RoleRevokePermission(ctx, role, key, rangeEnd) } -func (c integrationClient) RoleDelete(role string) (*clientv3.AuthRoleDeleteResponse, error) { - return c.Client.RoleDelete(c.ctx, role) +func (c integrationClient) RoleDelete(ctx context.Context, role string) (*clientv3.AuthRoleDeleteResponse, error) { + return c.Client.RoleDelete(ctx, role) } -func (c integrationClient) Txn(compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) { - txn := c.Client.Txn(c.ctx) +func (c integrationClient) Txn(ctx context.Context, compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) { + txn := c.Client.Txn(ctx) cmps := []clientv3.Cmp{} for _, c := range compares { cmp, err := etcdctlcmd.ParseCompare(c) @@ -373,8 +368,8 @@ func getOps(ss []string) ([]clientv3.Op, error) { return ops, nil } -func (c integrationClient) MemberList() (*clientv3.MemberListResponse, error) { - return c.Client.MemberList(c.ctx) +func (c integrationClient) MemberList(ctx context.Context) (*clientv3.MemberListResponse, error) { + return c.Client.MemberList(ctx) } func (c integrationClient) Watch(ctx context.Context, key string, opts config.WatchOptions) clientv3.WatchChan { diff --git a/tests/framework/interface.go b/tests/framework/interface.go index cb06afef3..7198fd3f5 100644 --- a/tests/framework/interface.go +++ b/tests/framework/interface.go @@ -42,36 +42,36 @@ type Member interface { } type Client interface { - Put(key, value string, opts config.PutOptions) error - Get(key string, opts config.GetOptions) (*clientv3.GetResponse, error) - Delete(key string, opts config.DeleteOptions) (*clientv3.DeleteResponse, error) - Compact(rev int64, opts config.CompactOption) (*clientv3.CompactResponse, error) - Status() ([]*clientv3.StatusResponse, error) - HashKV(rev int64) ([]*clientv3.HashKVResponse, error) - Health() error - Defragment(opts config.DefragOption) error - AlarmList() (*clientv3.AlarmResponse, error) - AlarmDisarm(alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) - Grant(ttl int64) (*clientv3.LeaseGrantResponse, error) - TimeToLive(id clientv3.LeaseID, opts config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) - LeaseList() (*clientv3.LeaseLeasesResponse, error) - LeaseKeepAliveOnce(id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) - LeaseRevoke(id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) - UserAdd(name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) - UserList() (*clientv3.AuthUserListResponse, error) - UserDelete(name string) (*clientv3.AuthUserDeleteResponse, error) - UserChangePass(user, newPass string) error + Put(context context.Context, key, value string, opts config.PutOptions) error + Get(context context.Context, key string, opts config.GetOptions) (*clientv3.GetResponse, error) + Delete(context context.Context, key string, opts config.DeleteOptions) (*clientv3.DeleteResponse, error) + Compact(context context.Context, rev int64, opts config.CompactOption) (*clientv3.CompactResponse, error) + Status(context context.Context) ([]*clientv3.StatusResponse, error) + HashKV(context context.Context, rev int64) ([]*clientv3.HashKVResponse, error) + Health(context context.Context) error + Defragment(context context.Context, opts config.DefragOption) error + AlarmList(context context.Context) (*clientv3.AlarmResponse, error) + AlarmDisarm(context context.Context, alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) + Grant(context context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error) + TimeToLive(context context.Context, id clientv3.LeaseID, opts config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) + LeaseList(context context.Context) (*clientv3.LeaseLeasesResponse, error) + LeaseKeepAliveOnce(context context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) + LeaseRevoke(context context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) + UserAdd(context context.Context, name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) + UserList(context context.Context) (*clientv3.AuthUserListResponse, error) + UserDelete(context context.Context, name string) (*clientv3.AuthUserDeleteResponse, error) + UserChangePass(context context.Context, user, newPass string) error - RoleAdd(name string) (*clientv3.AuthRoleAddResponse, error) - RoleGrantPermission(name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) - RoleGet(role string) (*clientv3.AuthRoleGetResponse, error) - RoleList() (*clientv3.AuthRoleListResponse, error) - RoleRevokePermission(role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) - RoleDelete(role string) (*clientv3.AuthRoleDeleteResponse, error) + RoleAdd(context context.Context, name string) (*clientv3.AuthRoleAddResponse, error) + RoleGrantPermission(context context.Context, name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) + RoleGet(context context.Context, role string) (*clientv3.AuthRoleGetResponse, error) + RoleList(context context.Context) (*clientv3.AuthRoleListResponse, error) + RoleRevokePermission(context context.Context, role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) + RoleDelete(context context.Context, role string) (*clientv3.AuthRoleDeleteResponse, error) - Txn(compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) + Txn(context context.Context, compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) - MemberList() (*clientv3.MemberListResponse, error) + MemberList(context context.Context) (*clientv3.MemberListResponse, error) Watch(ctx context.Context, key string, opts config.WatchOptions) clientv3.WatchChan } From b7272df69f0e6827c99d222b2e71653744d7ad65 Mon Sep 17 00:00:00 2001 From: Marek Siarkowicz Date: Thu, 25 Aug 2022 14:19:54 +0200 Subject: [PATCH 2/3] tests: Remove dummy client implementations Signed-off-by: Marek Siarkowicz --- tests/framework/integration.go | 48 ---------------------------------- 1 file changed, 48 deletions(-) diff --git a/tests/framework/integration.go b/tests/framework/integration.go index 907781a39..fed20d3d3 100644 --- a/tests/framework/integration.go +++ b/tests/framework/integration.go @@ -196,14 +196,6 @@ func (c integrationClient) Compact(ctx context.Context, rev int64, o config.Comp return c.Client.Compact(ctx, rev, clientOpts...) } -func (c integrationClient) AlarmList(ctx context.Context) (*clientv3.AlarmResponse, error) { - return c.Client.AlarmList(ctx) -} - -func (c integrationClient) AlarmDisarm(ctx context.Context, alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) { - return c.Client.AlarmDisarm(ctx, alarmMember) -} - func (c integrationClient) Status(ctx context.Context) ([]*clientv3.StatusResponse, error) { endpoints := c.Client.Endpoints() var resp []*clientv3.StatusResponse @@ -257,10 +249,6 @@ func (c integrationClient) Defragment(ctx context.Context, o config.DefragOption return nil } -func (c integrationClient) Grant(ctx context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error) { - return c.Client.Grant(ctx, ttl) -} - func (c integrationClient) TimeToLive(ctx context.Context, id clientv3.LeaseID, o config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) { leaseOpts := []clientv3.LeaseOption{} if o.WithAttachedKeys { @@ -288,43 +276,11 @@ func (c integrationClient) UserAdd(ctx context.Context, name, password string, o }) } -func (c integrationClient) UserList(ctx context.Context) (*clientv3.AuthUserListResponse, error) { - return c.Client.UserList(ctx) -} - -func (c integrationClient) UserDelete(ctx context.Context, name string) (*clientv3.AuthUserDeleteResponse, error) { - return c.Client.UserDelete(ctx, name) -} - func (c integrationClient) UserChangePass(ctx context.Context, user, newPass string) error { _, err := c.Client.UserChangePassword(ctx, user, newPass) return err } -func (c integrationClient) RoleAdd(ctx context.Context, name string) (*clientv3.AuthRoleAddResponse, error) { - return c.Client.RoleAdd(ctx, name) -} - -func (c integrationClient) RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType clientv3.PermissionType) (*clientv3.AuthRoleGrantPermissionResponse, error) { - return c.Client.RoleGrantPermission(ctx, name, key, rangeEnd, permType) -} - -func (c integrationClient) RoleGet(ctx context.Context, role string) (*clientv3.AuthRoleGetResponse, error) { - return c.Client.RoleGet(ctx, role) -} - -func (c integrationClient) RoleList(ctx context.Context) (*clientv3.AuthRoleListResponse, error) { - return c.Client.RoleList(ctx) -} - -func (c integrationClient) RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*clientv3.AuthRoleRevokePermissionResponse, error) { - return c.Client.RoleRevokePermission(ctx, role, key, rangeEnd) -} - -func (c integrationClient) RoleDelete(ctx context.Context, role string) (*clientv3.AuthRoleDeleteResponse, error) { - return c.Client.RoleDelete(ctx, role) -} - func (c integrationClient) Txn(ctx context.Context, compares, ifSucess, ifFail []string, o config.TxnOptions) (*clientv3.TxnResponse, error) { txn := c.Client.Txn(ctx) cmps := []clientv3.Cmp{} @@ -368,10 +324,6 @@ func getOps(ss []string) ([]clientv3.Op, error) { return ops, nil } -func (c integrationClient) MemberList(ctx context.Context) (*clientv3.MemberListResponse, error) { - return c.Client.MemberList(ctx) -} - func (c integrationClient) Watch(ctx context.Context, key string, opts config.WatchOptions) clientv3.WatchChan { opOpts := []clientv3.OpOption{} if opts.Prefix { From 46fe4b8e1c49e0da4e7284c781d02466cde00d68 Mon Sep 17 00:00:00 2001 From: Marek Siarkowicz Date: Thu, 25 Aug 2022 14:22:59 +0200 Subject: [PATCH 3/3] tests: Rename common client lease methods to match Signed-off-by: Marek Siarkowicz --- tests/common/lease_test.go | 6 +++--- tests/framework/e2e/etcdctl.go | 6 +++--- tests/framework/integration.go | 12 ------------ tests/framework/interface.go | 6 +++--- 4 files changed, 9 insertions(+), 21 deletions(-) diff --git a/tests/common/lease_test.go b/tests/common/lease_test.go index ad7b7b090..7a424dc38 100644 --- a/tests/common/lease_test.go +++ b/tests/common/lease_test.go @@ -119,7 +119,7 @@ func TestLeaseGrantAndList(t *testing.T) { // or by hitting an up to date member. leases := []clientv3.LeaseStatus{} require.Eventually(t, func() bool { - resp, err := cc.LeaseList(ctx) + resp, err := cc.Leases(ctx) if err != nil { return false } @@ -193,7 +193,7 @@ func TestLeaseGrantKeepAliveOnce(t *testing.T) { leaseResp, err := cc.Grant(ctx, 2) require.NoError(t, err) - _, err = cc.LeaseKeepAliveOnce(ctx, leaseResp.ID) + _, err = cc.KeepAliveOnce(ctx, leaseResp.ID) require.NoError(t, err) time.Sleep(2 * time.Second) // Wait for the original lease to expire @@ -229,7 +229,7 @@ func TestLeaseGrantRevoke(t *testing.T) { require.NoError(t, err) require.Equal(t, int64(1), getResp.Count) - _, err = cc.LeaseRevoke(ctx, leaseResp.ID) + _, err = cc.Revoke(ctx, leaseResp.ID) require.NoError(t, err) ttlResp, err := cc.TimeToLive(ctx, leaseResp.ID, config.LeaseOption{}) diff --git a/tests/framework/e2e/etcdctl.go b/tests/framework/e2e/etcdctl.go index c08d51e63..e29c1c273 100644 --- a/tests/framework/e2e/etcdctl.go +++ b/tests/framework/e2e/etcdctl.go @@ -392,7 +392,7 @@ func (ctl *EtcdctlV3) Defragment(ctx context.Context, o config.DefragOption) err return err } -func (ctl *EtcdctlV3) LeaseList(ctx context.Context) (*clientv3.LeaseLeasesResponse, error) { +func (ctl *EtcdctlV3) Leases(ctx context.Context) (*clientv3.LeaseLeasesResponse, error) { args := ctl.cmdArgs("lease", "list", "-w", "json") cmd, err := SpawnCmd(args, nil) if err != nil { @@ -408,7 +408,7 @@ func (ctl *EtcdctlV3) LeaseList(ctx context.Context) (*clientv3.LeaseLeasesRespo return &resp, err } -func (ctl *EtcdctlV3) LeaseKeepAliveOnce(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { +func (ctl *EtcdctlV3) KeepAliveOnce(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { args := ctl.cmdArgs("lease", "keep-alive", strconv.FormatInt(int64(id), 16), "--once", "-w", "json") cmd, err := SpawnCmd(args, nil) if err != nil { @@ -424,7 +424,7 @@ func (ctl *EtcdctlV3) LeaseKeepAliveOnce(ctx context.Context, id clientv3.LeaseI return &resp, err } -func (ctl *EtcdctlV3) LeaseRevoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { +func (ctl *EtcdctlV3) Revoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { var resp clientv3.LeaseRevokeResponse err := ctl.spawnJsonCmd(ctx, &resp, "lease", "revoke", strconv.FormatInt(int64(id), 16)) return &resp, err diff --git a/tests/framework/integration.go b/tests/framework/integration.go index fed20d3d3..6ba1c9808 100644 --- a/tests/framework/integration.go +++ b/tests/framework/integration.go @@ -258,18 +258,6 @@ func (c integrationClient) TimeToLive(ctx context.Context, id clientv3.LeaseID, return c.Client.TimeToLive(ctx, id, leaseOpts...) } -func (c integrationClient) LeaseList(ctx context.Context) (*clientv3.LeaseLeasesResponse, error) { - return c.Client.Leases(ctx) -} - -func (c integrationClient) LeaseKeepAliveOnce(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) { - return c.Client.KeepAliveOnce(ctx, id) -} - -func (c integrationClient) LeaseRevoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) { - return c.Client.Revoke(ctx, id) -} - func (c integrationClient) UserAdd(ctx context.Context, name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) { return c.Client.UserAddWithOptions(ctx, name, password, &clientv3.UserAddOptions{ NoPassword: opts.NoPassword, diff --git a/tests/framework/interface.go b/tests/framework/interface.go index 7198fd3f5..f46c4819a 100644 --- a/tests/framework/interface.go +++ b/tests/framework/interface.go @@ -54,9 +54,9 @@ type Client interface { AlarmDisarm(context context.Context, alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) Grant(context context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error) TimeToLive(context context.Context, id clientv3.LeaseID, opts config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error) - LeaseList(context context.Context) (*clientv3.LeaseLeasesResponse, error) - LeaseKeepAliveOnce(context context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) - LeaseRevoke(context context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) + Leases(context context.Context) (*clientv3.LeaseLeasesResponse, error) + KeepAliveOnce(context context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error) + Revoke(context context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error) UserAdd(context context.Context, name, password string, opts config.UserAddOptions) (*clientv3.AuthUserAddResponse, error) UserList(context context.Context) (*clientv3.AuthUserListResponse, error) UserDelete(context context.Context, name string) (*clientv3.AuthUserDeleteResponse, error)