Mirroristas/etcd
2
0
Fork 0
mirror of https://github.com/etcd-io/etcd.git synced 2024-09-27 06:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

tests: Add context to common client interface

Browse Source 
Signed-off-by: Marek Siarkowicz <siarkowicz@google.com>
This commit is contained in:
Marek Siarkowicz 2022-08-25 14:14:25 +02:00
parent e40828540c
commit 72bec6fbc2
23 changed files with 288 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
tests/common/alarm_test.go
View File

@ -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)
}
})

10
tests/common/compact_test.go
View File

@ -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 <nil>")
}
_, 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)

6
tests/common/defrag_test.go
View File

@ -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)
}
})

6
tests/common/endpoint_test.go
View File

@ -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)
}
})

16
tests/common/kv_test.go
View File

@ -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)

36
tests/common/lease_test.go
View File

@ -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)

5
tests/common/member_test.go
View File

@ -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)
}

32
tests/common/role_test.go
View File

@ -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)
}

2
tests/common/status_test.go
View File

@ -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)
}

10
tests/common/txn_test.go
View File

@ -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 {

28
tests/common/user_test.go
View File

@ -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")
}

2
tests/common/watch_test.go
View File

@ -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)
}
}

2
tests/e2e/cluster_downgrade_test.go
View File

@ -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)
}

18
tests/e2e/corrupt_test.go
View File

@ -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)
}

5
tests/e2e/ctl_v3_grpc_test.go
View File

@ -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)
}

12
tests/e2e/etcd_grpcproxy_test.go
View File

@ -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

33
tests/e2e/v2store_deprecation_test.go
View File

@ -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

2
tests/e2e/v3_curl_test.go
View File

@ -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)
}

4
tests/framework/e2e.go
View File

@ -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

140
tests/framework/e2e/etcdctl.go
View File

@ -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
}

6
tests/framework/e2e/util.go
View File

@ -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)

115
tests/framework/integration.go
View File

@ -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 {

54
tests/framework/interface.go
View File

@ -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
}