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: Move integration setup to separa framework package

Browse Source
This commit is contained in:
Marek Siarkowicz 2021-10-08 21:59:56 +02:00
parent dcd0d3fc9c
commit ca9b720c1d
70 changed files with 1561 additions and 1539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/framework/e2e/etcd_spawn_cov.go
View File

@ -26,7 +26,7 @@ import (
"go.etcd.io/etcd/client/pkg/v3/fileutil" "go.etcd.io/etcd/client/pkg/v3/fileutil"
"go.etcd.io/etcd/pkg/v3/expect" "go.etcd.io/etcd/pkg/v3/expect"
"go.etcd.io/etcd/tests/v3/integration" "go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap" "go.uber.org/zap"
) )

2
tests/framework/e2e/flags.go
View File

@ -19,7 +19,7 @@ import (
"os" "os"
"runtime" "runtime"
"go.etcd.io/etcd/tests/v3/integration" "go.etcd.io/etcd/tests/v3/framework/integration"
) )
var ( var (

0
tests/integration/bridge.go → tests/framework/integration/bridge.go
View File

752
tests/integration/cluster.go → tests/framework/integration/cluster.go
View File

File diff suppressed because it is too large Load Diff

4
tests/integration/cluster_direct.go → tests/framework/integration/cluster_direct.go
View File

@ -26,8 +26,8 @@ import (
const ThroughProxy = false const ThroughProxy = false
func toGRPC(c *clientv3.Client) grpcAPI { func ToGRPC(c *clientv3.Client) GrpcAPI {
return grpcAPI{ return GrpcAPI{
pb.NewClusterClient(c.ActiveConnection()), pb.NewClusterClient(c.ActiveConnection()),
pb.NewKVClient(c.ActiveConnection()), pb.NewKVClient(c.ActiveConnection()),
pb.NewLeaseClient(c.ActiveConnection()), pb.NewLeaseClient(c.ActiveConnection()),

8
tests/integration/cluster_proxy.go → tests/framework/integration/cluster_proxy.go
View File

@ -39,13 +39,13 @@ const proxyNamespace = "proxy-namespace"
type grpcClientProxy struct { type grpcClientProxy struct {
ctx context.Context ctx context.Context
ctxCancel func() ctxCancel func()
grpc grpcAPI grpc GrpcAPI
wdonec <-chan struct{} wdonec <-chan struct{}
kvdonec <-chan struct{} kvdonec <-chan struct{}
lpdonec <-chan struct{} lpdonec <-chan struct{}
} }
func toGRPC(c *clientv3.Client) grpcAPI { func ToGRPC(c *clientv3.Client) GrpcAPI {
pmu.Lock() pmu.Lock()
defer pmu.Unlock() defer pmu.Unlock()
@ -74,7 +74,7 @@ func toGRPC(c *clientv3.Client) grpcAPI {
lockp := grpcproxy.NewLockProxy(c) lockp := grpcproxy.NewLockProxy(c)
electp := grpcproxy.NewElectionProxy(c) electp := grpcproxy.NewElectionProxy(c)
grpc := grpcAPI{ grpc := GrpcAPI{
adapter.ClusterServerToClusterClient(clp), adapter.ClusterServerToClusterClient(clp),
adapter.KvServerToKvClient(kvp), adapter.KvServerToKvClient(kvp),
adapter.LeaseServerToLeaseClient(lp), adapter.LeaseServerToLeaseClient(lp),
@ -112,7 +112,7 @@ func newClientV3(cfg clientv3.Config) (*clientv3.Client, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
rpc := toGRPC(c) rpc := ToGRPC(c)
c.KV = clientv3.NewKVFromKVClient(rpc.KV, c) c.KV = clientv3.NewKVFromKVClient(rpc.KV, c)
pmu.Lock() pmu.Lock()
lc := c.Lease lc := c.Lease

0
tests/integration/testing.go → tests/framework/integration/testing.go
View File

24
tests/integration/client/client_test.go
View File

@ -25,14 +25,14 @@ import (
"testing" "testing"
"go.etcd.io/etcd/client/v2" "go.etcd.io/etcd/client/v2"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestV2NoRetryEOF tests destructive api calls won't retry on a disconnection. // TestV2NoRetryEOF tests destructive api calls won't retry on a disconnection.
func TestV2NoRetryEOF(t *testing.T) { func TestV2NoRetryEOF(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
// generate an EOF response; specify address so appears first in sorted ep list // generate an EOF response; specify address so appears first in sorted ep list
lEOF := integration.NewListenerWithAddr(t, fmt.Sprintf("127.0.0.1:%05d", os.Getpid())) lEOF := integration2.NewListenerWithAddr(t, fmt.Sprintf("127.0.0.1:%05d", os.Getpid()))
defer lEOF.Close() defer lEOF.Close()
tries := uint32(0) tries := uint32(0)
go func() { go func() {
@ -45,8 +45,8 @@ func TestV2NoRetryEOF(t *testing.T) {
conn.Close() conn.Close()
} }
}() }()
eofURL := integration.URLScheme + "://" + lEOF.Addr().String() eofURL := integration2.URLScheme + "://" + lEOF.Addr().String()
cli := integration.MustNewHTTPClient(t, []string{eofURL, eofURL}, nil) cli := integration2.MustNewHTTPClient(t, []string{eofURL, eofURL}, nil)
kapi := client.NewKeysAPI(cli) kapi := client.NewKeysAPI(cli)
for i, f := range noRetryList(kapi) { for i, f := range noRetryList(kapi) {
startTries := atomic.LoadUint32(&tries) startTries := atomic.LoadUint32(&tries)
@ -62,17 +62,17 @@ func TestV2NoRetryEOF(t *testing.T) {
// TestV2NoRetryNoLeader tests destructive api calls won't retry if given an error code. // TestV2NoRetryNoLeader tests destructive api calls won't retry if given an error code.
func TestV2NoRetryNoLeader(t *testing.T) { func TestV2NoRetryNoLeader(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
lHTTP := integration.NewListenerWithAddr(t, fmt.Sprintf("127.0.0.1:%05d", os.Getpid())) lHTTP := integration2.NewListenerWithAddr(t, fmt.Sprintf("127.0.0.1:%05d", os.Getpid()))
eh := &errHandler{errCode: http.StatusServiceUnavailable} eh := &errHandler{errCode: http.StatusServiceUnavailable}
srv := httptest.NewUnstartedServer(eh) srv := httptest.NewUnstartedServer(eh)
defer lHTTP.Close() defer lHTTP.Close()
defer srv.Close() defer srv.Close()
srv.Listener = lHTTP srv.Listener = lHTTP
go srv.Start() go srv.Start()
lHTTPURL := integration.URLScheme + "://" + lHTTP.Addr().String() lHTTPURL := integration2.URLScheme + "://" + lHTTP.Addr().String()
cli := integration.MustNewHTTPClient(t, []string{lHTTPURL, lHTTPURL}, nil) cli := integration2.MustNewHTTPClient(t, []string{lHTTPURL, lHTTPURL}, nil)
kapi := client.NewKeysAPI(cli) kapi := client.NewKeysAPI(cli)
// test error code // test error code
for i, f := range noRetryList(kapi) { for i, f := range noRetryList(kapi) {
@ -88,12 +88,12 @@ func TestV2NoRetryNoLeader(t *testing.T) {
// TestV2RetryRefuse tests destructive api calls will retry if a connection is refused. // TestV2RetryRefuse tests destructive api calls will retry if a connection is refused.
func TestV2RetryRefuse(t *testing.T) { func TestV2RetryRefuse(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cl := integration.NewCluster(t, 1) cl := integration2.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
// test connection refused; expect no error failover // test connection refused; expect no error failover
cli := integration.MustNewHTTPClient(t, []string{integration.URLScheme + "://refuseconn:123", cl.URL(0)}, nil) cli := integration2.MustNewHTTPClient(t, []string{integration2.URLScheme + "://refuseconn:123", cl.URL(0)}, nil)
kapi := client.NewKeysAPI(cli) kapi := client.NewKeysAPI(cli)
if _, err := kapi.Set(context.Background(), "/delkey", "def", nil); err != nil { if _, err := kapi.Set(context.Background(), "/delkey", "def", nil); err != nil {
t.Fatal(err) t.Fatal(err)

46
tests/integration/clientv3/cluster_test.go
View File

@ -23,13 +23,13 @@ import (
"time" "time"
"go.etcd.io/etcd/client/pkg/v3/types" "go.etcd.io/etcd/client/pkg/v3/types"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestMemberList(t *testing.T) { func TestMemberList(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.RandClient() capi := clus.RandClient()
@ -45,9 +45,9 @@ func TestMemberList(t *testing.T) {
} }
func TestMemberAdd(t *testing.T) { func TestMemberAdd(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.RandClient() capi := clus.RandClient()
@ -64,9 +64,9 @@ func TestMemberAdd(t *testing.T) {
} }
func TestMemberAddWithExistingURLs(t *testing.T) { func TestMemberAddWithExistingURLs(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.RandClient() capi := clus.RandClient()
@ -88,9 +88,9 @@ func TestMemberAddWithExistingURLs(t *testing.T) {
} }
func TestMemberRemove(t *testing.T) { func TestMemberRemove(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.Client(1) capi := clus.Client(1)
@ -126,9 +126,9 @@ func TestMemberRemove(t *testing.T) {
} }
func TestMemberUpdate(t *testing.T) { func TestMemberUpdate(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.RandClient() capi := clus.RandClient()
@ -154,9 +154,9 @@ func TestMemberUpdate(t *testing.T) {
} }
func TestMemberAddUpdateWrongURLs(t *testing.T) { func TestMemberAddUpdateWrongURLs(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.RandClient() capi := clus.RandClient()
@ -187,9 +187,9 @@ func TestMemberAddUpdateWrongURLs(t *testing.T) {
} }
func TestMemberAddForLearner(t *testing.T) { func TestMemberAddForLearner(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
capi := clus.RandClient() capi := clus.RandClient()
@ -216,9 +216,9 @@ func TestMemberAddForLearner(t *testing.T) {
} }
func TestMemberPromote(t *testing.T) { func TestMemberPromote(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// member promote request can be sent to any server in cluster, // member promote request can be sent to any server in cluster,
@ -293,9 +293,9 @@ func TestMemberPromote(t *testing.T) {
// TestMemberPromoteMemberNotLearner ensures that promoting a voting member fails. // TestMemberPromoteMemberNotLearner ensures that promoting a voting member fails.
func TestMemberPromoteMemberNotLearner(t *testing.T) { func TestMemberPromoteMemberNotLearner(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// member promote request can be sent to any server in cluster, // member promote request can be sent to any server in cluster,
@ -329,9 +329,9 @@ func TestMemberPromoteMemberNotLearner(t *testing.T) {
// TestMemberPromoteMemberNotExist ensures that promoting a member that does not exist in cluster fails. // TestMemberPromoteMemberNotExist ensures that promoting a member that does not exist in cluster fails.
func TestMemberPromoteMemberNotExist(t *testing.T) { func TestMemberPromoteMemberNotExist(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// member promote request can be sent to any server in cluster, // member promote request can be sent to any server in cluster,
@ -378,10 +378,10 @@ func TestMemberPromoteMemberNotExist(t *testing.T) {
// TestMaxLearnerInCluster verifies that the maximum number of learners allowed in a cluster is 1 // TestMaxLearnerInCluster verifies that the maximum number of learners allowed in a cluster is 1
func TestMaxLearnerInCluster(t *testing.T) { func TestMaxLearnerInCluster(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
// 1. start with a cluster with 3 voting member and 0 learner member // 1. start with a cluster with 3 voting member and 0 learner member
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// 2. adding a learner member should succeed // 2. adding a learner member should succeed

4
tests/integration/clientv3/concurrency/election_test.go
View File

@ -23,13 +23,13 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestResumeElection(t *testing.T) { func TestResumeElection(t *testing.T) {
const prefix = "/resume-election/" const prefix = "/resume-election/"
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: exampleEndpoints()}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: exampleEndpoints()})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }

4
tests/integration/clientv3/concurrency/mutex_test.go
View File

@ -20,11 +20,11 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestMutexLockSessionExpired(t *testing.T) { func TestMutexLockSessionExpired(t *testing.T) {
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: exampleEndpoints()}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: exampleEndpoints()})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

16
tests/integration/clientv3/connectivity/black_hole_test.go
View File

@ -24,7 +24,7 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.etcd.io/etcd/tests/v3/integration/clientv3" "go.etcd.io/etcd/tests/v3/integration/clientv3"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
@ -33,9 +33,9 @@ import (
// blackholed endpoint, client balancer switches to healthy one. // blackholed endpoint, client balancer switches to healthy one.
// TODO: test server-to-client keepalive ping // TODO: test server-to-client keepalive ping
func TestBalancerUnderBlackholeKeepAliveWatch(t *testing.T) { func TestBalancerUnderBlackholeKeepAliveWatch(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 2, Size: 2,
GRPCKeepAliveMinTime: time.Millisecond, // avoid too_many_pings GRPCKeepAliveMinTime: time.Millisecond, // avoid too_many_pings
UseBridge: true, UseBridge: true,
@ -58,9 +58,9 @@ func TestBalancerUnderBlackholeKeepAliveWatch(t *testing.T) {
// TODO: only send healthy endpoint to gRPC so gRPC wont waste time to // TODO: only send healthy endpoint to gRPC so gRPC wont waste time to
// dial for unhealthy endpoint. // dial for unhealthy endpoint.
// then we can reduce 3s to 1s. // then we can reduce 3s to 1s.
timeout := pingInterval + integration.RequestWaitTimeout timeout := pingInterval + integration2.RequestWaitTimeout
cli, err := integration.NewClient(t, ccfg) cli, err := integration2.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -166,9 +166,9 @@ func TestBalancerUnderBlackholeNoKeepAliveSerializableGet(t *testing.T) {
// testBalancerUnderBlackholeNoKeepAlive ensures that first request to blackholed endpoint // testBalancerUnderBlackholeNoKeepAlive ensures that first request to blackholed endpoint
// fails due to context timeout, but succeeds on next try, with endpoint switch. // fails due to context timeout, but succeeds on next try, with endpoint switch.
func testBalancerUnderBlackholeNoKeepAlive(t *testing.T, op func(*clientv3.Client, context.Context) error) { func testBalancerUnderBlackholeNoKeepAlive(t *testing.T, op func(*clientv3.Client, context.Context) error) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 2, Size: 2,
SkipCreatingClient: true, SkipCreatingClient: true,
UseBridge: true, UseBridge: true,
@ -182,7 +182,7 @@ func testBalancerUnderBlackholeNoKeepAlive(t *testing.T, op func(*clientv3.Clien
DialTimeout: 1 * time.Second, DialTimeout: 1 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
cli, err := integration.NewClient(t, ccfg) cli, err := integration2.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

52
tests/integration/clientv3/connectivity/dial_test.go
View File

@ -24,31 +24,31 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/client/pkg/v3/transport" "go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
clientv3test "go.etcd.io/etcd/tests/v3/integration/clientv3" clientv3test "go.etcd.io/etcd/tests/v3/integration/clientv3"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
var ( var (
testTLSInfo = transport.TLSInfo{ testTLSInfo = transport.TLSInfo{
KeyFile: integration.MustAbsPath("../../../fixtures/server.key.insecure"), KeyFile: integration2.MustAbsPath("../../../fixtures/server.key.insecure"),
CertFile: integration.MustAbsPath("../../../fixtures/server.crt"), CertFile: integration2.MustAbsPath("../../../fixtures/server.crt"),
TrustedCAFile: integration.MustAbsPath("../../../fixtures/ca.crt"), TrustedCAFile: integration2.MustAbsPath("../../../fixtures/ca.crt"),
ClientCertAuth: true, ClientCertAuth: true,
} }
testTLSInfoExpired = transport.TLSInfo{ testTLSInfoExpired = transport.TLSInfo{
KeyFile: integration.MustAbsPath("../../fixtures-expired/server.key.insecure"), KeyFile: integration2.MustAbsPath("../../fixtures-expired/server.key.insecure"),
CertFile: integration.MustAbsPath("../../fixtures-expired/server.crt"), CertFile: integration2.MustAbsPath("../../fixtures-expired/server.crt"),
TrustedCAFile: integration.MustAbsPath("../../fixtures-expired/ca.crt"), TrustedCAFile: integration2.MustAbsPath("../../fixtures-expired/ca.crt"),
ClientCertAuth: true, ClientCertAuth: true,
} }
) )
// TestDialTLSExpired tests client with expired certs fails to dial. // TestDialTLSExpired tests client with expired certs fails to dial.
func TestDialTLSExpired(t *testing.T) { func TestDialTLSExpired(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, PeerTLS: &testTLSInfo, ClientTLS: &testTLSInfo, SkipCreatingClient: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, PeerTLS: &testTLSInfo, ClientTLS: &testTLSInfo, SkipCreatingClient: true})
defer clus.Terminate(t) defer clus.Terminate(t)
tls, err := testTLSInfoExpired.ClientConfig() tls, err := testTLSInfoExpired.ClientConfig()
@ -56,7 +56,7 @@ func TestDialTLSExpired(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
// expect remote errors "tls: bad certificate" // expect remote errors "tls: bad certificate"
_, err = integration.NewClient(t, clientv3.Config{ _, err = integration2.NewClient(t, clientv3.Config{
Endpoints: []string{clus.Members[0].GRPCURL()}, Endpoints: []string{clus.Members[0].GRPCURL()},
DialTimeout: 3 * time.Second, DialTimeout: 3 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
@ -70,11 +70,11 @@ func TestDialTLSExpired(t *testing.T) {
// TestDialTLSNoConfig ensures the client fails to dial / times out // TestDialTLSNoConfig ensures the client fails to dial / times out
// when TLS endpoints (https, unixs) are given but no tls config. // when TLS endpoints (https, unixs) are given but no tls config.
func TestDialTLSNoConfig(t *testing.T) { func TestDialTLSNoConfig(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, ClientTLS: &testTLSInfo, SkipCreatingClient: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, ClientTLS: &testTLSInfo, SkipCreatingClient: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// expect "signed by unknown authority" // expect "signed by unknown authority"
c, err := integration.NewClient(t, clientv3.Config{ c, err := integration2.NewClient(t, clientv3.Config{
Endpoints: []string{clus.Members[0].GRPCURL()}, Endpoints: []string{clus.Members[0].GRPCURL()},
DialTimeout: time.Second, DialTimeout: time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
@ -101,8 +101,8 @@ func TestDialSetEndpointsAfterFail(t *testing.T) {
// testDialSetEndpoints ensures SetEndpoints can replace unavailable endpoints with available ones. // testDialSetEndpoints ensures SetEndpoints can replace unavailable endpoints with available ones.
func testDialSetEndpoints(t *testing.T, setBefore bool) { func testDialSetEndpoints(t *testing.T, setBefore bool) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, SkipCreatingClient: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, SkipCreatingClient: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// get endpoint list // get endpoint list
@ -117,7 +117,7 @@ func testDialSetEndpoints(t *testing.T, setBefore bool) {
DialTimeout: 1 * time.Second, DialTimeout: 1 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -134,7 +134,7 @@ func testDialSetEndpoints(t *testing.T, setBefore bool) {
cli.SetEndpoints(eps[toKill%3], eps[(toKill+1)%3]) cli.SetEndpoints(eps[toKill%3], eps[(toKill+1)%3])
} }
time.Sleep(time.Second * 2) time.Sleep(time.Second * 2)
ctx, cancel := context.WithTimeout(context.Background(), integration.RequestWaitTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration2.RequestWaitTimeout)
if _, err = cli.Get(ctx, "foo", clientv3.WithSerializable()); err != nil { if _, err = cli.Get(ctx, "foo", clientv3.WithSerializable()); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -144,8 +144,8 @@ func testDialSetEndpoints(t *testing.T, setBefore bool) {
// TestSwitchSetEndpoints ensures SetEndpoints can switch one endpoint // TestSwitchSetEndpoints ensures SetEndpoints can switch one endpoint
// with a new one that doesn't include original endpoint. // with a new one that doesn't include original endpoint.
func TestSwitchSetEndpoints(t *testing.T) { func TestSwitchSetEndpoints(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// get non partitioned members endpoints // get non partitioned members endpoints
@ -164,9 +164,9 @@ func TestSwitchSetEndpoints(t *testing.T) {
} }
func TestRejectOldCluster(t *testing.T) { func TestRejectOldCluster(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
// 2 endpoints to test multi-endpoint Status // 2 endpoints to test multi-endpoint Status
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2, SkipCreatingClient: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2, SkipCreatingClient: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cfg := clientv3.Config{ cfg := clientv3.Config{
@ -175,7 +175,7 @@ func TestRejectOldCluster(t *testing.T) {
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
RejectOldCluster: true, RejectOldCluster: true,
} }
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -185,8 +185,8 @@ func TestRejectOldCluster(t *testing.T) {
// TestDialForeignEndpoint checks an endpoint that is not registered // TestDialForeignEndpoint checks an endpoint that is not registered
// with the balancer can be dialed. // with the balancer can be dialed.
func TestDialForeignEndpoint(t *testing.T) { func TestDialForeignEndpoint(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2})
defer clus.Terminate(t) defer clus.Terminate(t)
conn, err := clus.Client(0).Dial(clus.Client(1).Endpoints()[0]) conn, err := clus.Client(0).Dial(clus.Client(1).Endpoints()[0])
@ -208,8 +208,8 @@ func TestDialForeignEndpoint(t *testing.T) {
// TestSetEndpointAndPut checks that a Put following a SetEndpoints // TestSetEndpointAndPut checks that a Put following a SetEndpoints
// to a working endpoint will always succeed. // to a working endpoint will always succeed.
func TestSetEndpointAndPut(t *testing.T) { func TestSetEndpointAndPut(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2})
defer clus.Terminate(t) defer clus.Terminate(t)
clus.Client(1).SetEndpoints(clus.Members[0].GRPCURL()) clus.Client(1).SetEndpoints(clus.Members[0].GRPCURL())

30
tests/integration/clientv3/connectivity/network_partition_test.go
View File

@ -26,7 +26,7 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.etcd.io/etcd/tests/v3/integration/clientv3" "go.etcd.io/etcd/tests/v3/integration/clientv3"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
@ -103,9 +103,9 @@ func TestBalancerUnderNetworkPartitionSerializableGet(t *testing.T) {
} }
func testBalancerUnderNetworkPartition(t *testing.T, op func(*clientv3.Client, context.Context) error, timeout time.Duration) { func testBalancerUnderNetworkPartition(t *testing.T, op func(*clientv3.Client, context.Context) error, timeout time.Duration) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
}) })
@ -119,7 +119,7 @@ func testBalancerUnderNetworkPartition(t *testing.T, op func(*clientv3.Client, c
DialTimeout: 3 * time.Second, DialTimeout: 3 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
cli, err := integration.NewClient(t, ccfg) cli, err := integration2.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -159,9 +159,9 @@ func testBalancerUnderNetworkPartition(t *testing.T, op func(*clientv3.Client, c
// switches endpoint when leader fails and linearizable get requests returns // switches endpoint when leader fails and linearizable get requests returns
// "etcdserver: request timed out". // "etcdserver: request timed out".
func TestBalancerUnderNetworkPartitionLinearizableGetLeaderElection(t *testing.T) { func TestBalancerUnderNetworkPartitionLinearizableGetLeaderElection(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
}) })
@ -172,7 +172,7 @@ func TestBalancerUnderNetworkPartitionLinearizableGetLeaderElection(t *testing.T
timeout := 3 * clus.Members[(lead+1)%2].ServerConfig.ReqTimeout() timeout := 3 * clus.Members[(lead+1)%2].ServerConfig.ReqTimeout()
cli, err := integration.NewClient(t, clientv3.Config{ cli, err := integration2.NewClient(t, clientv3.Config{
Endpoints: []string{eps[(lead+1)%2]}, Endpoints: []string{eps[(lead+1)%2]},
DialTimeout: 2 * time.Second, DialTimeout: 2 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
@ -214,9 +214,9 @@ func TestBalancerUnderNetworkPartitionWatchFollower(t *testing.T) {
// testBalancerUnderNetworkPartitionWatch ensures watch stream // testBalancerUnderNetworkPartitionWatch ensures watch stream
// to a partitioned node be closed when context requires leader. // to a partitioned node be closed when context requires leader.
func testBalancerUnderNetworkPartitionWatch(t *testing.T, isolateLeader bool) { func testBalancerUnderNetworkPartitionWatch(t *testing.T, isolateLeader bool) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
}) })
@ -230,7 +230,7 @@ func testBalancerUnderNetworkPartitionWatch(t *testing.T, isolateLeader bool) {
} }
// pin eps[target] // pin eps[target]
watchCli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{eps[target]}}) watchCli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{eps[target]}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -248,7 +248,7 @@ func testBalancerUnderNetworkPartitionWatch(t *testing.T, isolateLeader bool) {
wch := watchCli.Watch(clientv3.WithRequireLeader(context.Background()), "foo", clientv3.WithCreatedNotify()) wch := watchCli.Watch(clientv3.WithRequireLeader(context.Background()), "foo", clientv3.WithCreatedNotify())
select { select {
case <-wch: case <-wch:
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("took too long to create watch") t.Fatal("took too long to create watch")
} }
@ -268,15 +268,15 @@ func testBalancerUnderNetworkPartitionWatch(t *testing.T, isolateLeader bool) {
if err = ev.Err(); err != rpctypes.ErrNoLeader { if err = ev.Err(); err != rpctypes.ErrNoLeader {
t.Fatalf("expected %v, got %v", rpctypes.ErrNoLeader, err) t.Fatalf("expected %v, got %v", rpctypes.ErrNoLeader, err)
} }
case <-time.After(integration.RequestWaitTimeout): // enough time to detect leader lost case <-time.After(integration2.RequestWaitTimeout): // enough time to detect leader lost
t.Fatal("took too long to detect leader lost") t.Fatal("took too long to detect leader lost")
} }
} }
func TestDropReadUnderNetworkPartition(t *testing.T) { func TestDropReadUnderNetworkPartition(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
}) })
@ -289,7 +289,7 @@ func TestDropReadUnderNetworkPartition(t *testing.T) {
DialTimeout: 10 * time.Second, DialTimeout: 10 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
cli, err := integration.NewClient(t, ccfg) cli, err := integration2.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

34
tests/integration/clientv3/connectivity/server_shutdown_test.go
View File

@ -23,16 +23,16 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.etcd.io/etcd/tests/v3/integration/clientv3" "go.etcd.io/etcd/tests/v3/integration/clientv3"
) )
// TestBalancerUnderServerShutdownWatch expects that watch client // TestBalancerUnderServerShutdownWatch expects that watch client
// switch its endpoints when the member of the pinned endpoint fails. // switch its endpoints when the member of the pinned endpoint fails.
func TestBalancerUnderServerShutdownWatch(t *testing.T) { func TestBalancerUnderServerShutdownWatch(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
UseBridge: true, UseBridge: true,
@ -44,7 +44,7 @@ func TestBalancerUnderServerShutdownWatch(t *testing.T) {
lead := clus.WaitLeader(t) lead := clus.WaitLeader(t)
// pin eps[lead] // pin eps[lead]
watchCli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{eps[lead]}}) watchCli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{eps[lead]}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -61,7 +61,7 @@ func TestBalancerUnderServerShutdownWatch(t *testing.T) {
wch := watchCli.Watch(context.Background(), key, clientv3.WithCreatedNotify()) wch := watchCli.Watch(context.Background(), key, clientv3.WithCreatedNotify())
select { select {
case <-wch: case <-wch:
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("took too long to create watch") t.Fatal("took too long to create watch")
} }
@ -90,7 +90,7 @@ func TestBalancerUnderServerShutdownWatch(t *testing.T) {
clus.Members[lead].Terminate(t) clus.Members[lead].Terminate(t)
// writes to eps[lead+1] // writes to eps[lead+1]
putCli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{eps[(lead+1)%3]}}) putCli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{eps[(lead+1)%3]}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -143,9 +143,9 @@ func TestBalancerUnderServerShutdownTxn(t *testing.T) {
// the pinned endpoint is shut down, the balancer switches its endpoints // the pinned endpoint is shut down, the balancer switches its endpoints
// and all subsequent put/delete/txn requests succeed with new endpoints. // and all subsequent put/delete/txn requests succeed with new endpoints.
func testBalancerUnderServerShutdownMutable(t *testing.T, op func(*clientv3.Client, context.Context) error) { func testBalancerUnderServerShutdownMutable(t *testing.T, op func(*clientv3.Client, context.Context) error) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
}) })
@ -154,7 +154,7 @@ func testBalancerUnderServerShutdownMutable(t *testing.T, op func(*clientv3.Clie
eps := []string{clus.Members[0].GRPCURL(), clus.Members[1].GRPCURL(), clus.Members[2].GRPCURL()} eps := []string{clus.Members[0].GRPCURL(), clus.Members[1].GRPCURL(), clus.Members[2].GRPCURL()}
// pin eps[0] // pin eps[0]
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{eps[0]}}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{eps[0]}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -201,9 +201,9 @@ func TestBalancerUnderServerShutdownGetSerializable(t *testing.T) {
// the pinned endpoint is shut down, the balancer switches its endpoints // the pinned endpoint is shut down, the balancer switches its endpoints
// and all subsequent range requests succeed with new endpoints. // and all subsequent range requests succeed with new endpoints.
func testBalancerUnderServerShutdownImmutable(t *testing.T, op func(*clientv3.Client, context.Context) error, timeout time.Duration) { func testBalancerUnderServerShutdownImmutable(t *testing.T, op func(*clientv3.Client, context.Context) error, timeout time.Duration) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{ clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{
Size: 3, Size: 3,
SkipCreatingClient: true, SkipCreatingClient: true,
}) })
@ -212,7 +212,7 @@ func testBalancerUnderServerShutdownImmutable(t *testing.T, op func(*clientv3.Cl
eps := []string{clus.Members[0].GRPCURL(), clus.Members[1].GRPCURL(), clus.Members[2].GRPCURL()} eps := []string{clus.Members[0].GRPCURL(), clus.Members[1].GRPCURL(), clus.Members[2].GRPCURL()}
// pin eps[0] // pin eps[0]
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{eps[0]}}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{eps[0]}})
if err != nil { if err != nil {
t.Errorf("failed to create client: %v", err) t.Errorf("failed to create client: %v", err)
} }
@ -274,9 +274,9 @@ type pinTestOpt struct {
// testBalancerUnderServerStopInflightRangeOnRestart expects // testBalancerUnderServerStopInflightRangeOnRestart expects
// inflight range request reconnects on server restart. // inflight range request reconnects on server restart.
func testBalancerUnderServerStopInflightRangeOnRestart(t *testing.T, linearizable bool, opt pinTestOpt) { func testBalancerUnderServerStopInflightRangeOnRestart(t *testing.T, linearizable bool, opt pinTestOpt) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cfg := &integration.ClusterConfig{ cfg := &integration2.ClusterConfig{
Size: 2, Size: 2,
SkipCreatingClient: true, SkipCreatingClient: true,
UseBridge: true, UseBridge: true,
@ -285,7 +285,7 @@ func testBalancerUnderServerStopInflightRangeOnRestart(t *testing.T, linearizabl
cfg.Size = 3 cfg.Size = 3
} }
clus := integration.NewClusterV3(t, cfg) clus := integration2.NewClusterV3(t, cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
eps := []string{clus.Members[0].GRPCURL(), clus.Members[1].GRPCURL()} eps := []string{clus.Members[0].GRPCURL(), clus.Members[1].GRPCURL()}
if linearizable { if linearizable {
@ -300,7 +300,7 @@ func testBalancerUnderServerStopInflightRangeOnRestart(t *testing.T, linearizabl
} }
// pin eps[target] // pin eps[target]
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{eps[target]}}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{eps[target]}})
if err != nil { if err != nil {
t.Errorf("failed to create client: %v", err) t.Errorf("failed to create client: %v", err)
} }
@ -361,7 +361,7 @@ func testBalancerUnderServerStopInflightRangeOnRestart(t *testing.T, linearizabl
clus.Members[target].Restart(t) clus.Members[target].Restart(t)
select { select {
case <-time.After(clientTimeout + integration.RequestWaitTimeout): case <-time.After(clientTimeout + integration2.RequestWaitTimeout):
t.Fatalf("timed out waiting for Get [linearizable: %v, opt: %+v]", linearizable, opt) t.Fatalf("timed out waiting for Get [linearizable: %v, opt: %+v]", linearizable, opt)
case <-donec: case <-donec:
} }

3
tests/integration/clientv3/examples/main_test.go
View File

@ -20,6 +20,7 @@ import (
"time" "time"
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.etcd.io/etcd/tests/v3/integration" "go.etcd.io/etcd/tests/v3/integration"
) )
@ -29,7 +30,7 @@ const (
) )
var lazyCluster = integration.NewLazyClusterWithConfig( var lazyCluster = integration.NewLazyClusterWithConfig(
integration.ClusterConfig{ integration2.ClusterConfig{
Size: 3, Size: 3,
WatchProgressNotifyInterval: 200 * time.Millisecond}) WatchProgressNotifyInterval: 200 * time.Millisecond})

10
tests/integration/clientv3/experimental/recipes/v3_barrier_test.go
View File

@ -20,19 +20,19 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
recipe "go.etcd.io/etcd/client/v3/experimental/recipes" recipe "go.etcd.io/etcd/client/v3/experimental/recipes"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestBarrierSingleNode(t *testing.T) { func TestBarrierSingleNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
testBarrier(t, 5, func() *clientv3.Client { return clus.Client(0) }) testBarrier(t, 5, func() *clientv3.Client { return clus.Client(0) })
} }
func TestBarrierMultiNode(t *testing.T) { func TestBarrierMultiNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
testBarrier(t, 5, func() *clientv3.Client { return clus.RandClient() }) testBarrier(t, 5, func() *clientv3.Client { return clus.RandClient() })
} }

10
tests/integration/clientv3/experimental/recipes/v3_double_barrier_test.go
View File

@ -20,13 +20,13 @@ import (
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
recipe "go.etcd.io/etcd/client/v3/experimental/recipes" recipe "go.etcd.io/etcd/client/v3/experimental/recipes"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestDoubleBarrier(t *testing.T) { func TestDoubleBarrier(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
waiters := 10 waiters := 10
@ -98,9 +98,9 @@ func TestDoubleBarrier(t *testing.T) {
} }
func TestDoubleBarrierFailover(t *testing.T) { func TestDoubleBarrierFailover(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
waiters := 10 waiters := 10

56
tests/integration/clientv3/experimental/recipes/v3_lock_test.go
View File

@ -24,29 +24,29 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
recipe "go.etcd.io/etcd/client/v3/experimental/recipes" recipe "go.etcd.io/etcd/client/v3/experimental/recipes"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestMutexLockSingleNode(t *testing.T) { func TestMutexLockSingleNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
var clients []*clientv3.Client var clients []*clientv3.Client
testMutexLock(t, 5, integration.MakeSingleNodeClients(t, clus, &clients)) testMutexLock(t, 5, integration2.MakeSingleNodeClients(t, clus, &clients))
integration.CloseClients(t, clients) integration2.CloseClients(t, clients)
} }
func TestMutexLockMultiNode(t *testing.T) { func TestMutexLockMultiNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
var clients []*clientv3.Client var clients []*clientv3.Client
testMutexLock(t, 5, integration.MakeMultiNodeClients(t, clus, &clients)) testMutexLock(t, 5, integration2.MakeMultiNodeClients(t, clus, &clients))
integration.CloseClients(t, clients) integration2.CloseClients(t, clients)
} }
func testMutexLock(t *testing.T, waiters int, chooseClient func() *clientv3.Client) { func testMutexLock(t *testing.T, waiters int, chooseClient func() *clientv3.Client) {
@ -93,27 +93,27 @@ func testMutexLock(t *testing.T, waiters int, chooseClient func() *clientv3.Clie
} }
func TestMutexTryLockSingleNode(t *testing.T) { func TestMutexTryLockSingleNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
var clients []*clientv3.Client var clients []*clientv3.Client
testMutexTryLock(t, 5, integration.MakeSingleNodeClients(t, clus, &clients)) testMutexTryLock(t, 5, integration2.MakeSingleNodeClients(t, clus, &clients))
integration.CloseClients(t, clients) integration2.CloseClients(t, clients)
} }
func TestMutexTryLockMultiNode(t *testing.T) { func TestMutexTryLockMultiNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
var clients []*clientv3.Client var clients []*clientv3.Client
testMutexTryLock(t, 5, integration.MakeMultiNodeClients(t, clus, &clients)) testMutexTryLock(t, 5, integration2.MakeMultiNodeClients(t, clus, &clients))
integration.CloseClients(t, clients) integration2.CloseClients(t, clients)
} }
func testMutexTryLock(t *testing.T, lockers int, chooseClient func() *clientv3.Client) { func testMutexTryLock(t *testing.T, lockers int, chooseClient func() *clientv3.Client) {
integration.BeforeTest(t) integration2.BeforeTest(t)
lockedC := make(chan *concurrency.Mutex) lockedC := make(chan *concurrency.Mutex)
notlockedC := make(chan *concurrency.Mutex) notlockedC := make(chan *concurrency.Mutex)
@ -163,9 +163,9 @@ func testMutexTryLock(t *testing.T, lockers int, chooseClient func() *clientv3.C
// TestMutexSessionRelock ensures that acquiring the same lock with the same // TestMutexSessionRelock ensures that acquiring the same lock with the same
// session will not result in deadlock. // session will not result in deadlock.
func TestMutexSessionRelock(t *testing.T) { func TestMutexSessionRelock(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
session, err := concurrency.NewSession(clus.RandClient()) session, err := concurrency.NewSession(clus.RandClient())
if err != nil { if err != nil {
@ -187,9 +187,9 @@ func TestMutexSessionRelock(t *testing.T) {
// waiters older than the new owner are gone by testing the case where // waiters older than the new owner are gone by testing the case where
// the waiter prior to the acquirer expires before the current holder. // the waiter prior to the acquirer expires before the current holder.
func TestMutexWaitsOnCurrentHolder(t *testing.T) { func TestMutexWaitsOnCurrentHolder(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cctx := context.Background() cctx := context.Background()
@ -295,9 +295,9 @@ func TestMutexWaitsOnCurrentHolder(t *testing.T) {
} }
func BenchmarkMutex4Waiters(b *testing.B) { func BenchmarkMutex4Waiters(b *testing.B) {
integration.BeforeTest(b) integration2.BeforeTest(b)
// XXX switch tests to use TB interface // XXX switch tests to use TB interface
clus := integration.NewClusterV3(nil, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(nil, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(nil) defer clus.Terminate(nil)
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
testMutexLock(nil, 4, func() *clientv3.Client { return clus.RandClient() }) testMutexLock(nil, 4, func() *clientv3.Client { return clus.RandClient() })
@ -305,15 +305,15 @@ func BenchmarkMutex4Waiters(b *testing.B) {
} }
func TestRWMutexSingleNode(t *testing.T) { func TestRWMutexSingleNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
testRWMutex(t, 5, func() *clientv3.Client { return clus.Client(0) }) testRWMutex(t, 5, func() *clientv3.Client { return clus.Client(0) })
} }
func TestRWMutexMultiNode(t *testing.T) { func TestRWMutexMultiNode(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
testRWMutex(t, 5, func() *clientv3.Client { return clus.RandClient() }) testRWMutex(t, 5, func() *clientv3.Client { return clus.RandClient() })
} }

30
tests/integration/clientv3/experimental/recipes/v3_queue_test.go
View File

@ -21,7 +21,7 @@ import (
"testing" "testing"
recipe "go.etcd.io/etcd/client/v3/experimental/recipes" recipe "go.etcd.io/etcd/client/v3/experimental/recipes"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
const ( const (
@ -31,9 +31,9 @@ const (
// TestQueueOneReaderOneWriter confirms the queue is FIFO // TestQueueOneReaderOneWriter confirms the queue is FIFO
func TestQueueOneReaderOneWriter(t *testing.T) { func TestQueueOneReaderOneWriter(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
done := make(chan struct{}) done := make(chan struct{})
@ -78,10 +78,10 @@ func TestQueueManyReaderManyWriter(t *testing.T) {
// BenchmarkQueue benchmarks Queues using many/many readers/writers // BenchmarkQueue benchmarks Queues using many/many readers/writers
func BenchmarkQueue(b *testing.B) { func BenchmarkQueue(b *testing.B) {
integration.BeforeTest(b) integration2.BeforeTest(b)
// XXX switch tests to use TB interface // XXX switch tests to use TB interface
clus := integration.NewClusterV3(nil, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(nil, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(nil) defer clus.Terminate(nil)
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
testQueueNReaderMWriter(nil, manyQueueClients, manyQueueClients) testQueueNReaderMWriter(nil, manyQueueClients, manyQueueClients)
@ -90,9 +90,9 @@ func BenchmarkQueue(b *testing.B) {
// TestPrQueueOneReaderOneWriter tests whether priority queues respect priorities. // TestPrQueueOneReaderOneWriter tests whether priority queues respect priorities.
func TestPrQueueOneReaderOneWriter(t *testing.T) { func TestPrQueueOneReaderOneWriter(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
// write out five items with random priority // write out five items with random priority
@ -124,9 +124,9 @@ func TestPrQueueOneReaderOneWriter(t *testing.T) {
} }
func TestPrQueueManyReaderManyWriter(t *testing.T) { func TestPrQueueManyReaderManyWriter(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
rqs := newPriorityQueues(clus, manyQueueClients) rqs := newPriorityQueues(clus, manyQueueClients)
wqs := newPriorityQueues(clus, manyQueueClients) wqs := newPriorityQueues(clus, manyQueueClients)
@ -135,10 +135,10 @@ func TestPrQueueManyReaderManyWriter(t *testing.T) {
// BenchmarkQueue benchmarks Queues using n/n readers/writers // BenchmarkQueue benchmarks Queues using n/n readers/writers
func BenchmarkPrQueueOneReaderOneWriter(b *testing.B) { func BenchmarkPrQueueOneReaderOneWriter(b *testing.B) {
integration.BeforeTest(b) integration2.BeforeTest(b)
// XXX switch tests to use TB interface // XXX switch tests to use TB interface
clus := integration.NewClusterV3(nil, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(nil, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(nil) defer clus.Terminate(nil)
rqs := newPriorityQueues(clus, 1) rqs := newPriorityQueues(clus, 1)
wqs := newPriorityQueues(clus, 1) wqs := newPriorityQueues(clus, 1)
@ -148,13 +148,13 @@ func BenchmarkPrQueueOneReaderOneWriter(b *testing.B) {
} }
func testQueueNReaderMWriter(t *testing.T, n int, m int) { func testQueueNReaderMWriter(t *testing.T, n int, m int) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
testReadersWriters(t, newQueues(clus, n), newQueues(clus, m)) testReadersWriters(t, newQueues(clus, n), newQueues(clus, m))
} }
func newQueues(clus *integration.ClusterV3, n int) (qs []testQueue) { func newQueues(clus *integration2.ClusterV3, n int) (qs []testQueue) {
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
etcdc := clus.RandClient() etcdc := clus.RandClient()
qs = append(qs, recipe.NewQueue(etcdc, "q")) qs = append(qs, recipe.NewQueue(etcdc, "q"))
@ -162,7 +162,7 @@ func newQueues(clus *integration.ClusterV3, n int) (qs []testQueue) {
return qs return qs
} }
func newPriorityQueues(clus *integration.ClusterV3, n int) (qs []testQueue) { func newPriorityQueues(clus *integration2.ClusterV3, n int) (qs []testQueue) {
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
etcdc := clus.RandClient() etcdc := clus.RandClient()
q := &flatPriorityQueue{recipe.NewPriorityQueue(etcdc, "prq")} q := &flatPriorityQueue{recipe.NewPriorityQueue(etcdc, "prq")}

96
tests/integration/clientv3/kv_test.go
View File

@ -29,20 +29,20 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/api/v3/version" "go.etcd.io/etcd/api/v3/version"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
) )
func TestKVPutError(t *testing.T) { func TestKVPutError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
var ( var (
maxReqBytes = 1.5 * 1024 * 1024 // hard coded max in v3_server.go maxReqBytes = 1.5 * 1024 * 1024 // hard coded max in v3_server.go
quota = int64(int(maxReqBytes*1.2) + 8*os.Getpagesize()) // make sure we have enough overhead in backend quota. See discussion in #6486. quota = int64(int(maxReqBytes*1.2) + 8*os.Getpagesize()) // make sure we have enough overhead in backend quota. See discussion in #6486.
) )
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, QuotaBackendBytes: quota, ClientMaxCallSendMsgSize: 100 * 1024 * 1024}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, QuotaBackendBytes: quota, ClientMaxCallSendMsgSize: 100 * 1024 * 1024})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -72,9 +72,9 @@ func TestKVPutError(t *testing.T) {
} }
func TestKVPut(t *testing.T) { func TestKVPut(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lapi := clus.RandClient() lapi := clus.RandClient()
@ -117,9 +117,9 @@ func TestKVPut(t *testing.T) {
// TestKVPutWithIgnoreValue ensures that Put with WithIgnoreValue does not clobber the old value. // TestKVPutWithIgnoreValue ensures that Put with WithIgnoreValue does not clobber the old value.
func TestKVPutWithIgnoreValue(t *testing.T) { func TestKVPutWithIgnoreValue(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -150,9 +150,9 @@ func TestKVPutWithIgnoreValue(t *testing.T) {
// TestKVPutWithIgnoreLease ensures that Put with WithIgnoreLease does not affect the existing lease for the key. // TestKVPutWithIgnoreLease ensures that Put with WithIgnoreLease does not affect the existing lease for the key.
func TestKVPutWithIgnoreLease(t *testing.T) { func TestKVPutWithIgnoreLease(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -189,9 +189,9 @@ func TestKVPutWithIgnoreLease(t *testing.T) {
} }
func TestKVPutWithRequireLeader(t *testing.T) { func TestKVPutWithRequireLeader(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
clus.Members[1].Stop(t) clus.Members[1].Stop(t)
@ -235,9 +235,9 @@ func TestKVPutWithRequireLeader(t *testing.T) {
} }
func TestKVRange(t *testing.T) { func TestKVRange(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -464,9 +464,9 @@ func TestKVRange(t *testing.T) {
} }
func TestKVGetErrConnClosed(t *testing.T) { func TestKVGetErrConnClosed(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -486,16 +486,16 @@ func TestKVGetErrConnClosed(t *testing.T) {
}() }()
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("kv.Get took too long") t.Fatal("kv.Get took too long")
case <-donec: case <-donec:
} }
} }
func TestKVNewAfterClose(t *testing.T) { func TestKVNewAfterClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -513,16 +513,16 @@ func TestKVNewAfterClose(t *testing.T) {
close(donec) close(donec)
}() }()
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("kv.Get took too long") t.Fatal("kv.Get took too long")
case <-donec: case <-donec:
} }
} }
func TestKVDeleteRange(t *testing.T) { func TestKVDeleteRange(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -592,9 +592,9 @@ func TestKVDeleteRange(t *testing.T) {
} }
func TestKVDelete(t *testing.T) { func TestKVDelete(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -624,9 +624,9 @@ func TestKVDelete(t *testing.T) {
} }
func TestKVCompactError(t *testing.T) { func TestKVCompactError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -654,9 +654,9 @@ func TestKVCompactError(t *testing.T) {
} }
func TestKVCompact(t *testing.T) { func TestKVCompact(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -709,10 +709,10 @@ func TestKVCompact(t *testing.T) {
// TestKVGetRetry ensures get will retry on disconnect. // TestKVGetRetry ensures get will retry on disconnect.
func TestKVGetRetry(t *testing.T) { func TestKVGetRetry(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clusterSize := 3 clusterSize := 3
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: clusterSize, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: clusterSize, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// because killing leader and following election // because killing leader and following election
@ -763,9 +763,9 @@ func TestKVGetRetry(t *testing.T) {
// TestKVPutFailGetRetry ensures a get will retry following a failed put. // TestKVPutFailGetRetry ensures a get will retry following a failed put.
func TestKVPutFailGetRetry(t *testing.T) { func TestKVPutFailGetRetry(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.Client(0) kv := clus.Client(0)
@ -803,9 +803,9 @@ func TestKVPutFailGetRetry(t *testing.T) {
// TestKVGetCancel tests that a context cancel on a Get terminates as expected. // TestKVGetCancel tests that a context cancel on a Get terminates as expected.
func TestKVGetCancel(t *testing.T) { func TestKVGetCancel(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
oldconn := clus.Client(0).ActiveConnection() oldconn := clus.Client(0).ActiveConnection()
@ -826,9 +826,9 @@ func TestKVGetCancel(t *testing.T) {
// TestKVGetStoppedServerAndClose ensures closing after a failed Get works. // TestKVGetStoppedServerAndClose ensures closing after a failed Get works.
func TestKVGetStoppedServerAndClose(t *testing.T) { func TestKVGetStoppedServerAndClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -844,9 +844,9 @@ func TestKVGetStoppedServerAndClose(t *testing.T) {
// TestKVPutStoppedServerAndClose ensures closing after a failed Put works. // TestKVPutStoppedServerAndClose ensures closing after a failed Put works.
func TestKVPutStoppedServerAndClose(t *testing.T) { func TestKVPutStoppedServerAndClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -875,8 +875,8 @@ func TestKVPutStoppedServerAndClose(t *testing.T) {
// TestKVPutAtMostOnce ensures that a Put will only occur at most once // TestKVPutAtMostOnce ensures that a Put will only occur at most once
// in the presence of network errors. // in the presence of network errors.
func TestKVPutAtMostOnce(t *testing.T) { func TestKVPutAtMostOnce(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
if _, err := clus.Client(0).Put(context.TODO(), "k", "1"); err != nil { if _, err := clus.Client(0).Put(context.TODO(), "k", "1"); err != nil {
@ -911,7 +911,7 @@ func TestKVPutAtMostOnce(t *testing.T) {
// TestKVLargeRequests tests various client/server side request limits. // TestKVLargeRequests tests various client/server side request limits.
func TestKVLargeRequests(t *testing.T) { func TestKVLargeRequests(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
tests := []struct { tests := []struct {
// make sure that "MaxCallSendMsgSize" < server-side default send/recv limit // make sure that "MaxCallSendMsgSize" < server-side default send/recv limit
maxRequestBytesServer uint maxRequestBytesServer uint
@ -970,8 +970,8 @@ func TestKVLargeRequests(t *testing.T) {
}, },
} }
for i, test := range tests { for i, test := range tests {
clus := integration.NewClusterV3(t, clus := integration2.NewClusterV3(t,
&integration.ClusterConfig{ &integration2.ClusterConfig{
Size: 1, Size: 1,
MaxRequestBytes: test.maxRequestBytesServer, MaxRequestBytes: test.maxRequestBytesServer,
ClientMaxCallSendMsgSize: test.maxCallSendBytesClient, ClientMaxCallSendMsgSize: test.maxCallSendBytesClient,
@ -1003,9 +1003,9 @@ func TestKVLargeRequests(t *testing.T) {
// TestKVForLearner ensures learner member only accepts serializable read request. // TestKVForLearner ensures learner member only accepts serializable read request.
func TestKVForLearner(t *testing.T) { func TestKVForLearner(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// we have to add and launch learner member after initial cluster was created, because // we have to add and launch learner member after initial cluster was created, because
@ -1034,7 +1034,7 @@ func TestKVForLearner(t *testing.T) {
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
// this client only has endpoint of the learner member // this client only has endpoint of the learner member
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatalf("failed to create clientv3: %v", err) t.Fatalf("failed to create clientv3: %v", err)
} }
@ -1082,9 +1082,9 @@ func TestKVForLearner(t *testing.T) {
// TestBalancerSupportLearner verifies that balancer's retry and failover mechanism supports cluster with learner member // TestBalancerSupportLearner verifies that balancer's retry and failover mechanism supports cluster with learner member
func TestBalancerSupportLearner(t *testing.T) { func TestBalancerSupportLearner(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// we have to add and launch learner member after initial cluster was created, because // we have to add and launch learner member after initial cluster was created, because
@ -1106,7 +1106,7 @@ func TestBalancerSupportLearner(t *testing.T) {
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatalf("failed to create clientv3: %v", err) t.Fatalf("failed to create clientv3: %v", err)
} }

96
tests/integration/clientv3/lease/lease_test.go
View File

@ -26,13 +26,13 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestLeaseNotFoundError(t *testing.T) { func TestLeaseNotFoundError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -44,9 +44,9 @@ func TestLeaseNotFoundError(t *testing.T) {
} }
func TestLeaseGrant(t *testing.T) { func TestLeaseGrant(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lapi := clus.RandClient() lapi := clus.RandClient()
@ -70,9 +70,9 @@ func TestLeaseGrant(t *testing.T) {
} }
func TestLeaseRevoke(t *testing.T) { func TestLeaseRevoke(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lapi := clus.RandClient() lapi := clus.RandClient()
@ -96,9 +96,9 @@ func TestLeaseRevoke(t *testing.T) {
} }
func TestLeaseKeepAliveOnce(t *testing.T) { func TestLeaseKeepAliveOnce(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lapi := clus.RandClient() lapi := clus.RandClient()
@ -120,9 +120,9 @@ func TestLeaseKeepAliveOnce(t *testing.T) {
} }
func TestLeaseKeepAlive(t *testing.T) { func TestLeaseKeepAlive(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lapi := clus.Client(0) lapi := clus.Client(0)
@ -160,9 +160,9 @@ func TestLeaseKeepAlive(t *testing.T) {
} }
func TestLeaseKeepAliveOneSecond(t *testing.T) { func TestLeaseKeepAliveOneSecond(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -188,9 +188,9 @@ func TestLeaseKeepAliveOneSecond(t *testing.T) {
func TestLeaseKeepAliveHandleFailure(t *testing.T) { func TestLeaseKeepAliveHandleFailure(t *testing.T) {
t.Skip("test it when we have a cluster client") t.Skip("test it when we have a cluster client")
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// TODO: change this line to get a cluster client // TODO: change this line to get a cluster client
@ -243,9 +243,9 @@ type leaseCh struct {
// TestLeaseKeepAliveNotFound ensures a revoked lease won't halt other leases. // TestLeaseKeepAliveNotFound ensures a revoked lease won't halt other leases.
func TestLeaseKeepAliveNotFound(t *testing.T) { func TestLeaseKeepAliveNotFound(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
@ -276,9 +276,9 @@ func TestLeaseKeepAliveNotFound(t *testing.T) {
} }
func TestLeaseGrantErrConnClosed(t *testing.T) { func TestLeaseGrantErrConnClosed(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -298,7 +298,7 @@ func TestLeaseGrantErrConnClosed(t *testing.T) {
}() }()
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("le.Grant took too long") t.Fatal("le.Grant took too long")
case <-donec: case <-donec:
} }
@ -308,9 +308,9 @@ func TestLeaseGrantErrConnClosed(t *testing.T) {
// queue is full thus dropping keepalive response sends, // queue is full thus dropping keepalive response sends,
// keepalive request is sent with the same rate of TTL / 3. // keepalive request is sent with the same rate of TTL / 3.
func TestLeaseKeepAliveFullResponseQueue(t *testing.T) { func TestLeaseKeepAliveFullResponseQueue(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lapi := clus.Client(0) lapi := clus.Client(0)
@ -348,9 +348,9 @@ func TestLeaseKeepAliveFullResponseQueue(t *testing.T) {
} }
func TestLeaseGrantNewAfterClose(t *testing.T) { func TestLeaseGrantNewAfterClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -368,16 +368,16 @@ func TestLeaseGrantNewAfterClose(t *testing.T) {
close(donec) close(donec)
}() }()
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("le.Grant took too long") t.Fatal("le.Grant took too long")
case <-donec: case <-donec:
} }
} }
func TestLeaseRevokeNewAfterClose(t *testing.T) { func TestLeaseRevokeNewAfterClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -402,7 +402,7 @@ func TestLeaseRevokeNewAfterClose(t *testing.T) {
} }
}() }()
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("le.Revoke took too long") t.Fatal("le.Revoke took too long")
case errMsg := <-errMsgCh: case errMsg := <-errMsgCh:
if errMsg != "" { if errMsg != "" {
@ -414,9 +414,9 @@ func TestLeaseRevokeNewAfterClose(t *testing.T) {
// TestLeaseKeepAliveCloseAfterDisconnectRevoke ensures the keep alive channel is closed // TestLeaseKeepAliveCloseAfterDisconnectRevoke ensures the keep alive channel is closed
// following a disconnection, lease revoke, then reconnect. // following a disconnection, lease revoke, then reconnect.
func TestLeaseKeepAliveCloseAfterDisconnectRevoke(t *testing.T) { func TestLeaseKeepAliveCloseAfterDisconnectRevoke(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -460,9 +460,9 @@ func TestLeaseKeepAliveCloseAfterDisconnectRevoke(t *testing.T) {
// TestLeaseKeepAliveInitTimeout ensures the keep alive channel closes if // TestLeaseKeepAliveInitTimeout ensures the keep alive channel closes if
// the initial keep alive request never gets a response. // the initial keep alive request never gets a response.
func TestLeaseKeepAliveInitTimeout(t *testing.T) { func TestLeaseKeepAliveInitTimeout(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -493,9 +493,9 @@ func TestLeaseKeepAliveInitTimeout(t *testing.T) {
// TestLeaseKeepAliveInitTimeout ensures the keep alive channel closes if // TestLeaseKeepAliveInitTimeout ensures the keep alive channel closes if
// a keep alive request after the first never gets a response. // a keep alive request after the first never gets a response.
func TestLeaseKeepAliveTTLTimeout(t *testing.T) { func TestLeaseKeepAliveTTLTimeout(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -528,9 +528,9 @@ func TestLeaseKeepAliveTTLTimeout(t *testing.T) {
} }
func TestLeaseTimeToLive(t *testing.T) { func TestLeaseTimeToLive(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.RandClient() c := clus.RandClient()
@ -586,9 +586,9 @@ func TestLeaseTimeToLive(t *testing.T) {
} }
func TestLeaseTimeToLiveLeaseNotFound(t *testing.T) { func TestLeaseTimeToLiveLeaseNotFound(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
@ -621,9 +621,9 @@ func TestLeaseTimeToLiveLeaseNotFound(t *testing.T) {
} }
func TestLeaseLeases(t *testing.T) { func TestLeaseLeases(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
@ -654,9 +654,9 @@ func TestLeaseLeases(t *testing.T) {
// TestLeaseRenewLostQuorum ensures keepalives work after losing quorum // TestLeaseRenewLostQuorum ensures keepalives work after losing quorum
// for a while. // for a while.
func TestLeaseRenewLostQuorum(t *testing.T) { func TestLeaseRenewLostQuorum(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -702,9 +702,9 @@ func TestLeaseRenewLostQuorum(t *testing.T) {
} }
func TestLeaseKeepAliveLoopExit(t *testing.T) { func TestLeaseKeepAliveLoopExit(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx := context.Background() ctx := context.Background()
@ -727,8 +727,8 @@ func TestLeaseKeepAliveLoopExit(t *testing.T) {
// before, during, and after quorum loss to confirm Grant/KeepAlive tolerates // before, during, and after quorum loss to confirm Grant/KeepAlive tolerates
// transient cluster failure. // transient cluster failure.
func TestV3LeaseFailureOverlap(t *testing.T) { func TestV3LeaseFailureOverlap(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
numReqs := 5 numReqs := 5
@ -780,9 +780,9 @@ func TestV3LeaseFailureOverlap(t *testing.T) {
// TestLeaseWithRequireLeader checks keep-alive channel close when no leader. // TestLeaseWithRequireLeader checks keep-alive channel close when no leader.
func TestLeaseWithRequireLeader(t *testing.T) { func TestLeaseWithRequireLeader(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.Client(0) c := clus.Client(0)

168
tests/integration/clientv3/lease/leasing_test.go
View File

@ -28,13 +28,13 @@ import (
clientv3 "go.etcd.io/etcd/client/v3" clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
"go.etcd.io/etcd/client/v3/leasing" "go.etcd.io/etcd/client/v3/leasing"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestLeasingPutGet(t *testing.T) { func TestLeasingPutGet(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lKV1, closeLKV1, err := leasing.NewKV(clus.Client(0), "foo/") lKV1, closeLKV1, err := leasing.NewKV(clus.Client(0), "foo/")
@ -91,8 +91,8 @@ func TestLeasingPutGet(t *testing.T) {
// TestLeasingInterval checks the leasing KV fetches key intervals. // TestLeasingInterval checks the leasing KV fetches key intervals.
func TestLeasingInterval(t *testing.T) { func TestLeasingInterval(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -130,8 +130,8 @@ func TestLeasingInterval(t *testing.T) {
// TestLeasingPutInvalidateNew checks the leasing KV updates its cache on a Put to a new key. // TestLeasingPutInvalidateNew checks the leasing KV updates its cache on a Put to a new key.
func TestLeasingPutInvalidateNew(t *testing.T) { func TestLeasingPutInvalidateNew(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -160,8 +160,8 @@ func TestLeasingPutInvalidateNew(t *testing.T) {
// TestLeasingPutInvalidateExisting checks the leasing KV updates its cache on a Put to an existing key. // TestLeasingPutInvalidateExisting checks the leasing KV updates its cache on a Put to an existing key.
func TestLeasingPutInvalidateExisting(t *testing.T) { func TestLeasingPutInvalidateExisting(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
if _, err := clus.Client(0).Put(context.TODO(), "k", "abc"); err != nil { if _, err := clus.Client(0).Put(context.TODO(), "k", "abc"); err != nil {
@ -194,8 +194,8 @@ func TestLeasingPutInvalidateExisting(t *testing.T) {
// TestLeasingGetNoLeaseTTL checks a key with a TTL is not leased. // TestLeasingGetNoLeaseTTL checks a key with a TTL is not leased.
func TestLeasingGetNoLeaseTTL(t *testing.T) { func TestLeasingGetNoLeaseTTL(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -223,8 +223,8 @@ func TestLeasingGetNoLeaseTTL(t *testing.T) {
// TestLeasingGetSerializable checks the leasing KV can make serialized requests // TestLeasingGetSerializable checks the leasing KV can make serialized requests
// when the etcd cluster is partitioned. // when the etcd cluster is partitioned.
func TestLeasingGetSerializable(t *testing.T) { func TestLeasingGetSerializable(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -263,8 +263,8 @@ func TestLeasingGetSerializable(t *testing.T) {
// TestLeasingPrevKey checks the cache respects WithPrevKV on puts. // TestLeasingPrevKey checks the cache respects WithPrevKV on puts.
func TestLeasingPrevKey(t *testing.T) { func TestLeasingPrevKey(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -289,8 +289,8 @@ func TestLeasingPrevKey(t *testing.T) {
// TestLeasingRevGet checks the cache respects Get by Revision. // TestLeasingRevGet checks the cache respects Get by Revision.
func TestLeasingRevGet(t *testing.T) { func TestLeasingRevGet(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -325,8 +325,8 @@ func TestLeasingRevGet(t *testing.T) {
// TestLeasingGetWithOpts checks options that can be served through the cache do not depend on the server. // TestLeasingGetWithOpts checks options that can be served through the cache do not depend on the server.
func TestLeasingGetWithOpts(t *testing.T) { func TestLeasingGetWithOpts(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -370,8 +370,8 @@ func TestLeasingGetWithOpts(t *testing.T) {
// TestLeasingConcurrentPut ensures that a get after concurrent puts returns // TestLeasingConcurrentPut ensures that a get after concurrent puts returns
// the recently put data. // the recently put data.
func TestLeasingConcurrentPut(t *testing.T) { func TestLeasingConcurrentPut(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -417,8 +417,8 @@ func TestLeasingConcurrentPut(t *testing.T) {
} }
func TestLeasingDisconnectedGet(t *testing.T) { func TestLeasingDisconnectedGet(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -446,8 +446,8 @@ func TestLeasingDisconnectedGet(t *testing.T) {
} }
func TestLeasingDeleteOwner(t *testing.T) { func TestLeasingDeleteOwner(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -480,8 +480,8 @@ func TestLeasingDeleteOwner(t *testing.T) {
} }
func TestLeasingDeleteNonOwner(t *testing.T) { func TestLeasingDeleteNonOwner(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv1, closeLKV1, err := leasing.NewKV(clus.Client(0), "pfx/") lkv1, closeLKV1, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -515,8 +515,8 @@ func TestLeasingDeleteNonOwner(t *testing.T) {
} }
func TestLeasingOverwriteResponse(t *testing.T) { func TestLeasingOverwriteResponse(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -549,8 +549,8 @@ func TestLeasingOverwriteResponse(t *testing.T) {
} }
func TestLeasingOwnerPutResponse(t *testing.T) { func TestLeasingOwnerPutResponse(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -587,8 +587,8 @@ func TestLeasingOwnerPutResponse(t *testing.T) {
} }
func TestLeasingTxnOwnerGetRange(t *testing.T) { func TestLeasingTxnOwnerGetRange(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -616,8 +616,8 @@ func TestLeasingTxnOwnerGetRange(t *testing.T) {
} }
func TestLeasingTxnOwnerGet(t *testing.T) { func TestLeasingTxnOwnerGet(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
client := clus.Client(0) client := clus.Client(0)
@ -702,8 +702,8 @@ func TestLeasingTxnOwnerGet(t *testing.T) {
} }
func TestLeasingTxnOwnerDeleteRange(t *testing.T) { func TestLeasingTxnOwnerDeleteRange(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -741,8 +741,8 @@ func TestLeasingTxnOwnerDeleteRange(t *testing.T) {
} }
func TestLeasingTxnOwnerDelete(t *testing.T) { func TestLeasingTxnOwnerDelete(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -772,8 +772,8 @@ func TestLeasingTxnOwnerDelete(t *testing.T) {
} }
func TestLeasingTxnOwnerIf(t *testing.T) { func TestLeasingTxnOwnerIf(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -866,8 +866,8 @@ func TestLeasingTxnOwnerIf(t *testing.T) {
} }
func TestLeasingTxnCancel(t *testing.T) { func TestLeasingTxnCancel(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv1, closeLKV1, err := leasing.NewKV(clus.Client(0), "pfx/") lkv1, closeLKV1, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -900,8 +900,8 @@ func TestLeasingTxnCancel(t *testing.T) {
} }
func TestLeasingTxnNonOwnerPut(t *testing.T) { func TestLeasingTxnNonOwnerPut(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -978,8 +978,8 @@ func TestLeasingTxnNonOwnerPut(t *testing.T) {
// TestLeasingTxnRandIfThenOrElse randomly leases keys two separate clients, then // TestLeasingTxnRandIfThenOrElse randomly leases keys two separate clients, then
// issues a random If/{Then,Else} transaction on those keys to one client. // issues a random If/{Then,Else} transaction on those keys to one client.
func TestLeasingTxnRandIfThenOrElse(t *testing.T) { func TestLeasingTxnRandIfThenOrElse(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv1, closeLKV1, err1 := leasing.NewKV(clus.Client(0), "pfx/") lkv1, closeLKV1, err1 := leasing.NewKV(clus.Client(0), "pfx/")
@ -1084,8 +1084,8 @@ func TestLeasingTxnRandIfThenOrElse(t *testing.T) {
} }
func TestLeasingOwnerPutError(t *testing.T) { func TestLeasingOwnerPutError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -1105,8 +1105,8 @@ func TestLeasingOwnerPutError(t *testing.T) {
} }
func TestLeasingOwnerDeleteError(t *testing.T) { func TestLeasingOwnerDeleteError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -1126,8 +1126,8 @@ func TestLeasingOwnerDeleteError(t *testing.T) {
} }
func TestLeasingNonOwnerPutError(t *testing.T) { func TestLeasingNonOwnerPutError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "pfx/")
@ -1151,8 +1151,8 @@ func TestLeasingOwnerDeleteFrom(t *testing.T) {
} }
func testLeasingOwnerDelete(t *testing.T, del clientv3.Op) { func testLeasingOwnerDelete(t *testing.T, del clientv3.Op) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "0/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "0/")
@ -1200,8 +1200,8 @@ func testLeasingOwnerDelete(t *testing.T, del clientv3.Op) {
} }
func TestLeasingDeleteRangeBounds(t *testing.T) { func TestLeasingDeleteRangeBounds(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
delkv, closeDelKV, err := leasing.NewKV(clus.Client(0), "0/") delkv, closeDelKV, err := leasing.NewKV(clus.Client(0), "0/")
@ -1258,8 +1258,8 @@ func TestLeaseDeleteRangeContendDel(t *testing.T) {
} }
func testLeasingDeleteRangeContend(t *testing.T, op clientv3.Op) { func testLeasingDeleteRangeContend(t *testing.T, op clientv3.Op) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
delkv, closeDelKV, err := leasing.NewKV(clus.Client(0), "0/") delkv, closeDelKV, err := leasing.NewKV(clus.Client(0), "0/")
@ -1316,8 +1316,8 @@ func testLeasingDeleteRangeContend(t *testing.T, op clientv3.Op) {
} }
func TestLeasingPutGetDeleteConcurrent(t *testing.T) { func TestLeasingPutGetDeleteConcurrent(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkvs := make([]clientv3.KV, 16) lkvs := make([]clientv3.KV, 16)
@ -1375,8 +1375,8 @@ func TestLeasingPutGetDeleteConcurrent(t *testing.T) {
// TestLeasingReconnectOwnerRevoke checks that revocation works if // TestLeasingReconnectOwnerRevoke checks that revocation works if
// disconnected when trying to submit revoke txn. // disconnected when trying to submit revoke txn.
func TestLeasingReconnectOwnerRevoke(t *testing.T) { func TestLeasingReconnectOwnerRevoke(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv1, closeLKV1, err1 := leasing.NewKV(clus.Client(0), "foo/") lkv1, closeLKV1, err1 := leasing.NewKV(clus.Client(0), "foo/")
@ -1436,8 +1436,8 @@ func TestLeasingReconnectOwnerRevoke(t *testing.T) {
// TestLeasingReconnectOwnerRevokeCompact checks that revocation works if // TestLeasingReconnectOwnerRevokeCompact checks that revocation works if
// disconnected and the watch is compacted. // disconnected and the watch is compacted.
func TestLeasingReconnectOwnerRevokeCompact(t *testing.T) { func TestLeasingReconnectOwnerRevokeCompact(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv1, closeLKV1, err1 := leasing.NewKV(clus.Client(0), "foo/") lkv1, closeLKV1, err1 := leasing.NewKV(clus.Client(0), "foo/")
@ -1489,8 +1489,8 @@ func TestLeasingReconnectOwnerRevokeCompact(t *testing.T) {
// TestLeasingReconnectOwnerConsistency checks a write error on an owner will // TestLeasingReconnectOwnerConsistency checks a write error on an owner will
// not cause inconsistency between the server and the client. // not cause inconsistency between the server and the client.
func TestLeasingReconnectOwnerConsistency(t *testing.T) { func TestLeasingReconnectOwnerConsistency(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1563,8 +1563,8 @@ func TestLeasingReconnectOwnerConsistency(t *testing.T) {
} }
func TestLeasingTxnAtomicCache(t *testing.T) { func TestLeasingTxnAtomicCache(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1649,8 +1649,8 @@ func TestLeasingTxnAtomicCache(t *testing.T) {
// TestLeasingReconnectTxn checks that Txn is resilient to disconnects. // TestLeasingReconnectTxn checks that Txn is resilient to disconnects.
func TestLeasingReconnectTxn(t *testing.T) { func TestLeasingReconnectTxn(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1685,8 +1685,8 @@ func TestLeasingReconnectTxn(t *testing.T) {
// TestLeasingReconnectNonOwnerGet checks a get error on an owner will // TestLeasingReconnectNonOwnerGet checks a get error on an owner will
// not cause inconsistency between the server and the client. // not cause inconsistency between the server and the client.
func TestLeasingReconnectNonOwnerGet(t *testing.T) { func TestLeasingReconnectNonOwnerGet(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1736,8 +1736,8 @@ func TestLeasingReconnectNonOwnerGet(t *testing.T) {
} }
func TestLeasingTxnRangeCmp(t *testing.T) { func TestLeasingTxnRangeCmp(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1771,8 +1771,8 @@ func TestLeasingTxnRangeCmp(t *testing.T) {
} }
func TestLeasingDo(t *testing.T) { func TestLeasingDo(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1813,8 +1813,8 @@ func TestLeasingDo(t *testing.T) {
} }
func TestLeasingTxnOwnerPutBranch(t *testing.T) { func TestLeasingTxnOwnerPutBranch(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/") lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/")
@ -1907,8 +1907,8 @@ func randCmps(pfx string, dat []*clientv3.PutResponse) (cmps []clientv3.Cmp, the
} }
func TestLeasingSessionExpire(t *testing.T) { func TestLeasingSessionExpire(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/", concurrency.WithTTL(1)) lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/", concurrency.WithTTL(1))
@ -1931,7 +1931,7 @@ func TestLeasingSessionExpire(t *testing.T) {
} }
waitForExpireAck(t, lkv) waitForExpireAck(t, lkv)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
integration.WaitClientV3(t, lkv2) integration2.WaitClientV3(t, lkv2)
if _, err = lkv2.Put(context.TODO(), "abc", "def"); err != nil { if _, err = lkv2.Put(context.TODO(), "abc", "def"); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1983,8 +1983,8 @@ func TestLeasingSessionExpireCancel(t *testing.T) {
} }
for i := range tests { for i := range tests {
t.Run(fmt.Sprintf("test %d", i), func(t *testing.T) { t.Run(fmt.Sprintf("test %d", i), func(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/", concurrency.WithTTL(1)) lkv, closeLKV, err := leasing.NewKV(clus.Client(0), "foo/", concurrency.WithTTL(1))

32
tests/integration/clientv3/maintenance_test.go
View File

@ -25,6 +25,7 @@ import (
"testing" "testing"
"time" "time"
integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
"google.golang.org/grpc" "google.golang.org/grpc"
@ -34,13 +35,12 @@ import (
"go.etcd.io/etcd/server/v3/lease" "go.etcd.io/etcd/server/v3/lease"
"go.etcd.io/etcd/server/v3/storage/backend" "go.etcd.io/etcd/server/v3/storage/backend"
"go.etcd.io/etcd/server/v3/storage/mvcc" "go.etcd.io/etcd/server/v3/storage/mvcc"
"go.etcd.io/etcd/tests/v3/integration"
) )
func TestMaintenanceHashKV(t *testing.T) { func TestMaintenanceHashKV(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
@ -71,9 +71,9 @@ func TestMaintenanceHashKV(t *testing.T) {
} }
func TestMaintenanceMoveLeader(t *testing.T) { func TestMaintenanceMoveLeader(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
oldLeadIdx := clus.WaitLeader(t) oldLeadIdx := clus.WaitLeader(t)
@ -102,9 +102,9 @@ func TestMaintenanceMoveLeader(t *testing.T) {
// TestMaintenanceSnapshotCancel ensures that context cancel // TestMaintenanceSnapshotCancel ensures that context cancel
// before snapshot reading returns corresponding context errors. // before snapshot reading returns corresponding context errors.
func TestMaintenanceSnapshotCancel(t *testing.T) { func TestMaintenanceSnapshotCancel(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
// reading snapshot with canceled context should error out // reading snapshot with canceled context should error out
@ -145,9 +145,9 @@ func TestMaintenanceSnapshotTimeout(t *testing.T) {
// testMaintenanceSnapshotTimeout given snapshot function ensures that it // testMaintenanceSnapshotTimeout given snapshot function ensures that it
// returns corresponding context errors when context timeout happened before snapshot reading // returns corresponding context errors when context timeout happened before snapshot reading
func testMaintenanceSnapshotTimeout(t *testing.T, snapshot func(context.Context, *clientv3.Client) (io.ReadCloser, error)) { func testMaintenanceSnapshotTimeout(t *testing.T, snapshot func(context.Context, *clientv3.Client) (io.ReadCloser, error)) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
// reading snapshot with deadline exceeded should error out // reading snapshot with deadline exceeded should error out
@ -190,9 +190,9 @@ func TestMaintenanceSnapshotErrorInflight(t *testing.T) {
// testMaintenanceSnapshotErrorInflight given snapshot function ensures that ReaderCloser returned by it // testMaintenanceSnapshotErrorInflight given snapshot function ensures that ReaderCloser returned by it
// will fail to read with corresponding context errors on inflight context cancel timeout. // will fail to read with corresponding context errors on inflight context cancel timeout.
func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Context, *clientv3.Client) (io.ReadCloser, error)) { func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Context, *clientv3.Client) (io.ReadCloser, error)) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// take about 1-second to read snapshot // take about 1-second to read snapshot
@ -247,10 +247,10 @@ func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Co
// TestMaintenanceSnapshotWithVersionVersion ensures that SnapshotWithVersion returns correct version value. // TestMaintenanceSnapshotWithVersionVersion ensures that SnapshotWithVersion returns correct version value.
func TestMaintenanceSnapshotWithVersionVersion(t *testing.T) { func TestMaintenanceSnapshotWithVersionVersion(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
// Set SnapshotCount to 1 to force raft snapshot to ensure that storage version is set // Set SnapshotCount to 1 to force raft snapshot to ensure that storage version is set
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, SnapshotCount: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, SnapshotCount: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
// Put some keys to ensure that wal snapshot is triggered // Put some keys to ensure that wal snapshot is triggered
@ -270,9 +270,9 @@ func TestMaintenanceSnapshotWithVersionVersion(t *testing.T) {
} }
func TestMaintenanceStatus(t *testing.T) { func TestMaintenanceStatus(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
clus.WaitLeader(t) clus.WaitLeader(t)
@ -282,7 +282,7 @@ func TestMaintenanceStatus(t *testing.T) {
eps[i] = clus.Members[i].GRPCURL() eps[i] = clus.Members[i].GRPCURL()
} }
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: eps, DialOptions: []grpc.DialOption{grpc.WithBlock()}}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: eps, DialOptions: []grpc.DialOption{grpc.WithBlock()}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

13
tests/integration/clientv3/metrics_test.go
View File

@ -25,17 +25,16 @@ import (
"testing" "testing"
"time" "time"
"go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
grpcprom "github.com/grpc-ecosystem/go-grpc-prometheus" grpcprom "github.com/grpc-ecosystem/go-grpc-prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp" "github.com/prometheus/client_golang/prometheus/promhttp"
"go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/client/v3"
integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
func TestV3ClientMetrics(t *testing.T) { func TestV3ClientMetrics(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
var ( var (
addr = "localhost:27989" addr = "localhost:27989"
@ -71,7 +70,7 @@ func TestV3ClientMetrics(t *testing.T) {
url := "unix://" + addr + "/metrics" url := "unix://" + addr + "/metrics"
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, SkipCreatingClient: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, SkipCreatingClient: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cfg := clientv3.Config{ cfg := clientv3.Config{
@ -81,7 +80,7 @@ func TestV3ClientMetrics(t *testing.T) {
grpc.WithStreamInterceptor(grpcprom.StreamClientInterceptor), grpc.WithStreamInterceptor(grpcprom.StreamClientInterceptor),
}, },
} }
cli, cerr := integration.NewClient(t, cfg) cli, cerr := integration2.NewClient(t, cfg)
if cerr != nil { if cerr != nil {
t.Fatal(cerr) t.Fatal(cerr)
} }

10
tests/integration/clientv3/mirror_test.go
View File

@ -24,13 +24,13 @@ import (
"go.etcd.io/etcd/api/v3/mvccpb" "go.etcd.io/etcd/api/v3/mvccpb"
"go.etcd.io/etcd/client/v3/mirror" "go.etcd.io/etcd/client/v3/mirror"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestMirrorSync(t *testing.T) { func TestMirrorSync(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.Client(0) c := clus.Client(0)
@ -72,9 +72,9 @@ func TestMirrorSync(t *testing.T) {
} }
func TestMirrorSyncBase(t *testing.T) { func TestMirrorSyncBase(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) cluster := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer cluster.Terminate(t) defer cluster.Terminate(t)
cli := cluster.Client(0) cli := cluster.Client(0)

10
tests/integration/clientv3/namespace_test.go
View File

@ -22,13 +22,13 @@ import (
"go.etcd.io/etcd/api/v3/mvccpb" "go.etcd.io/etcd/api/v3/mvccpb"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/namespace" "go.etcd.io/etcd/client/v3/namespace"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestNamespacePutGet(t *testing.T) { func TestNamespacePutGet(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.Client(0) c := clus.Client(0)
@ -55,9 +55,9 @@ func TestNamespacePutGet(t *testing.T) {
} }
func TestNamespaceWatch(t *testing.T) { func TestNamespaceWatch(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.Client(0) c := clus.Client(0)

15
tests/integration/clientv3/naming/endpoints_test.go
View File

@ -21,14 +21,13 @@ import (
etcd "go.etcd.io/etcd/client/v3" etcd "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/naming/endpoints" "go.etcd.io/etcd/client/v3/naming/endpoints"
integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.etcd.io/etcd/tests/v3/integration"
) )
func TestEndpointManager(t *testing.T) { func TestEndpointManager(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
em, err := endpoints.NewManager(clus.RandClient(), "foo") em, err := endpoints.NewManager(clus.RandClient(), "foo")
@ -88,9 +87,9 @@ func TestEndpointManager(t *testing.T) {
// correctly with multiple hosts and correctly receive multiple // correctly with multiple hosts and correctly receive multiple
// updates in a single revision. // updates in a single revision.
func TestEndpointManagerAtomicity(t *testing.T) { func TestEndpointManagerAtomicity(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.RandClient() c := clus.RandClient()
@ -130,9 +129,9 @@ func TestEndpointManagerAtomicity(t *testing.T) {
} }
func TestEndpointManagerCRUD(t *testing.T) { func TestEndpointManagerCRUD(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
em, err := endpoints.NewManager(clus.RandClient(), "foo") em, err := endpoints.NewManager(clus.RandClient(), "foo")

7
tests/integration/clientv3/naming/resolver_test.go
View File

@ -23,8 +23,7 @@ import (
"go.etcd.io/etcd/client/v3/naming/endpoints" "go.etcd.io/etcd/client/v3/naming/endpoints"
"go.etcd.io/etcd/client/v3/naming/resolver" "go.etcd.io/etcd/client/v3/naming/resolver"
"go.etcd.io/etcd/pkg/v3/grpc_testing" "go.etcd.io/etcd/pkg/v3/grpc_testing"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
testpb "google.golang.org/grpc/test/grpc_testing" testpb "google.golang.org/grpc/test/grpc_testing"
) )
@ -32,7 +31,7 @@ import (
// This test mimics scenario described in grpc_naming.md doc. // This test mimics scenario described in grpc_naming.md doc.
func TestEtcdGrpcResolver(t *testing.T) { func TestEtcdGrpcResolver(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
s1PayloadBody := []byte{'1'} s1PayloadBody := []byte{'1'}
s1 := grpc_testing.NewDummyStubServer(s1PayloadBody) s1 := grpc_testing.NewDummyStubServer(s1PayloadBody)
@ -48,7 +47,7 @@ func TestEtcdGrpcResolver(t *testing.T) {
} }
defer s2.Stop() defer s2.Stop()
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
em, err := endpoints.NewManager(clus.Client(0), "foo") em, err := endpoints.NewManager(clus.Client(0), "foo")

14
tests/integration/clientv3/ordering_kv_test.go
View File

@ -23,14 +23,14 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/ordering" "go.etcd.io/etcd/client/v3/ordering"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestDetectKvOrderViolation(t *testing.T) { func TestDetectKvOrderViolation(t *testing.T) {
var errOrderViolation = errors.New("DetectedOrderViolation") var errOrderViolation = errors.New("DetectedOrderViolation")
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cfg := clientv3.Config{ cfg := clientv3.Config{
@ -40,7 +40,7 @@ func TestDetectKvOrderViolation(t *testing.T) {
clus.Members[2].GRPCURL(), clus.Members[2].GRPCURL(),
}, },
} }
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -96,8 +96,8 @@ func TestDetectKvOrderViolation(t *testing.T) {
func TestDetectTxnOrderViolation(t *testing.T) { func TestDetectTxnOrderViolation(t *testing.T) {
var errOrderViolation = errors.New("DetectedOrderViolation") var errOrderViolation = errors.New("DetectedOrderViolation")
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cfg := clientv3.Config{ cfg := clientv3.Config{
@ -107,7 +107,7 @@ func TestDetectTxnOrderViolation(t *testing.T) {
clus.Members[2].GRPCURL(), clus.Members[2].GRPCURL(),
}, },
} }
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

14
tests/integration/clientv3/ordering_util_test.go
View File

@ -21,12 +21,12 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/ordering" "go.etcd.io/etcd/client/v3/ordering"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestEndpointSwitchResolvesViolation(t *testing.T) { func TestEndpointSwitchResolvesViolation(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
eps := []string{ eps := []string{
clus.Members[0].GRPCURL(), clus.Members[0].GRPCURL(),
@ -34,7 +34,7 @@ func TestEndpointSwitchResolvesViolation(t *testing.T) {
clus.Members[2].GRPCURL(), clus.Members[2].GRPCURL(),
} }
cfg := clientv3.Config{Endpoints: []string{clus.Members[0].GRPCURL()}} cfg := clientv3.Config{Endpoints: []string{clus.Members[0].GRPCURL()}}
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -79,8 +79,8 @@ func TestEndpointSwitchResolvesViolation(t *testing.T) {
} }
func TestUnresolvableOrderViolation(t *testing.T) { func TestUnresolvableOrderViolation(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 5, SkipCreatingClient: true, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 5, SkipCreatingClient: true, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cfg := clientv3.Config{ cfg := clientv3.Config{
Endpoints: []string{ Endpoints: []string{
@ -91,7 +91,7 @@ func TestUnresolvableOrderViolation(t *testing.T) {
clus.Members[4].GRPCURL(), clus.Members[4].GRPCURL(),
}, },
} }
cli, err := integration.NewClient(t, cfg) cli, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

6
tests/integration/clientv3/role_test.go
View File

@ -19,13 +19,13 @@ import (
"testing" "testing"
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestRoleError(t *testing.T) { func TestRoleError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
authapi := clus.RandClient() authapi := clus.RandClient()

6
tests/integration/clientv3/snapshot/v3_snapshot_test.go
View File

@ -29,7 +29,7 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/snapshot" "go.etcd.io/etcd/client/v3/snapshot"
"go.etcd.io/etcd/server/v3/embed" "go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
) )
@ -78,7 +78,7 @@ func newEmbedConfig(t *testing.T) *embed.Config {
clusterN := 1 clusterN := 1
urls := newEmbedURLs(clusterN * 2) urls := newEmbedURLs(clusterN * 2)
cURLs, pURLs := urls[:clusterN], urls[clusterN:] cURLs, pURLs := urls[:clusterN], urls[clusterN:]
cfg := integration.NewEmbedConfig(t, "default") cfg := integration2.NewEmbedConfig(t, "default")
cfg.ClusterState = "new" cfg.ClusterState = "new"
cfg.LCUrls, cfg.ACUrls = cURLs, cURLs cfg.LCUrls, cfg.ACUrls = cURLs, cURLs
cfg.LPUrls, cfg.APUrls = pURLs, pURLs cfg.LPUrls, cfg.APUrls = pURLs, pURLs
@ -105,7 +105,7 @@ func createSnapshotFile(t *testing.T, cfg *embed.Config, kvs []kv) (version stri
} }
ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}} ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}}
cli, err := integration.NewClient(t, ccfg) cli, err := integration2.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

26
tests/integration/clientv3/txn_test.go
View File

@ -23,13 +23,13 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/embed" "go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestTxnError(t *testing.T) { func TestTxnError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.RandClient() kv := clus.RandClient()
@ -51,9 +51,9 @@ func TestTxnError(t *testing.T) {
} }
func TestTxnWriteFail(t *testing.T) { func TestTxnWriteFail(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.Client(0) kv := clus.Client(0)
@ -101,9 +101,9 @@ func TestTxnWriteFail(t *testing.T) {
func TestTxnReadRetry(t *testing.T) { func TestTxnReadRetry(t *testing.T) {
t.Skipf("skipping txn read retry test: re-enable after we do retry on txn read request") t.Skipf("skipping txn read retry test: re-enable after we do retry on txn read request")
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.Client(0) kv := clus.Client(0)
@ -140,9 +140,9 @@ func TestTxnReadRetry(t *testing.T) {
} }
func TestTxnSuccess(t *testing.T) { func TestTxnSuccess(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.Client(0) kv := clus.Client(0)
@ -163,9 +163,9 @@ func TestTxnSuccess(t *testing.T) {
} }
func TestTxnCompareRange(t *testing.T) { func TestTxnCompareRange(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.Client(0) kv := clus.Client(0)
@ -190,9 +190,9 @@ func TestTxnCompareRange(t *testing.T) {
} }
func TestTxnNested(t *testing.T) { func TestTxnNested(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kv := clus.Client(0) kv := clus.Client(0)

22
tests/integration/clientv3/user_test.go
View File

@ -21,14 +21,14 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
func TestUserError(t *testing.T) { func TestUserError(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
authapi := clus.RandClient() authapi := clus.RandClient()
@ -55,9 +55,9 @@ func TestUserError(t *testing.T) {
} }
func TestUserErrorAuth(t *testing.T) { func TestUserErrorAuth(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
authapi := clus.RandClient() authapi := clus.RandClient()
@ -75,16 +75,16 @@ func TestUserErrorAuth(t *testing.T) {
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
} }
cfg.Username, cfg.Password = "wrong-id", "123" cfg.Username, cfg.Password = "wrong-id", "123"
if _, err := integration.NewClient(t, cfg); err != rpctypes.ErrAuthFailed { if _, err := integration2.NewClient(t, cfg); err != rpctypes.ErrAuthFailed {
t.Fatalf("expected %v, got %v", rpctypes.ErrAuthFailed, err) t.Fatalf("expected %v, got %v", rpctypes.ErrAuthFailed, err)
} }
cfg.Username, cfg.Password = "root", "wrong-pass" cfg.Username, cfg.Password = "root", "wrong-pass"
if _, err := integration.NewClient(t, cfg); err != rpctypes.ErrAuthFailed { if _, err := integration2.NewClient(t, cfg); err != rpctypes.ErrAuthFailed {
t.Fatalf("expected %v, got %v", rpctypes.ErrAuthFailed, err) t.Fatalf("expected %v, got %v", rpctypes.ErrAuthFailed, err)
} }
cfg.Username, cfg.Password = "root", "123" cfg.Username, cfg.Password = "root", "123"
authed, err := integration.NewClient(t, cfg) authed, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -112,9 +112,9 @@ func authSetupRoot(t *testing.T, auth clientv3.Auth) {
// Client can connect to etcd even if they supply credentials and the server is in AuthDisable mode. // Client can connect to etcd even if they supply credentials and the server is in AuthDisable mode.
func TestGetTokenWithoutAuth(t *testing.T) { func TestGetTokenWithoutAuth(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 2})
defer clus.Terminate(t) defer clus.Terminate(t)
authapi := clus.RandClient() authapi := clus.RandClient()
@ -135,7 +135,7 @@ func TestGetTokenWithoutAuth(t *testing.T) {
Password: "123", Password: "123",
} }
client, err = integration.NewClient(t, cfg) client, err = integration2.NewClient(t, cfg)
if err == nil { if err == nil {
defer client.Close() defer client.Close()
} }

8
tests/integration/clientv3/watch_fragment_test.go
View File

@ -26,7 +26,7 @@ import (
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestWatchFragmentDisable ensures that large watch // TestWatchFragmentDisable ensures that large watch
@ -64,16 +64,16 @@ func TestWatchFragmentEnableWithGRPCLimit(t *testing.T) {
// testWatchFragment triggers watch response that spans over multiple // testWatchFragment triggers watch response that spans over multiple
// revisions exceeding server request limits when combined. // revisions exceeding server request limits when combined.
func testWatchFragment(t *testing.T, fragment, exceedRecvLimit bool) { func testWatchFragment(t *testing.T, fragment, exceedRecvLimit bool) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cfg := &integration.ClusterConfig{ cfg := &integration2.ClusterConfig{
Size: 1, Size: 1,
MaxRequestBytes: 1.5 * 1024 * 1024, MaxRequestBytes: 1.5 * 1024 * 1024,
} }
if exceedRecvLimit { if exceedRecvLimit {
cfg.ClientMaxCallRecvMsgSize = 1.5 * 1024 * 1024 cfg.ClientMaxCallRecvMsgSize = 1.5 * 1024 * 1024
} }
clus := integration.NewClusterV3(t, cfg) clus := integration2.NewClusterV3(t, cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)

100
tests/integration/clientv3/watch_test.go
View File

@ -29,14 +29,14 @@ import (
"go.etcd.io/etcd/api/v3/version" "go.etcd.io/etcd/api/v3/version"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/etcdserver/api/v3rpc" "go.etcd.io/etcd/server/v3/etcdserver/api/v3rpc"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc/metadata" "google.golang.org/grpc/metadata"
) )
type watcherTest func(*testing.T, *watchctx) type watcherTest func(*testing.T, *watchctx)
type watchctx struct { type watchctx struct {
clus *integration.ClusterV3 clus *integration2.ClusterV3
w clientv3.Watcher w clientv3.Watcher
kv clientv3.KV kv clientv3.KV
wclientMember int wclientMember int
@ -45,9 +45,9 @@ type watchctx struct {
} }
func runWatchTest(t *testing.T, f watcherTest) { func runWatchTest(t *testing.T, f watcherTest) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
wclientMember := rand.Intn(3) wclientMember := rand.Intn(3)
@ -299,7 +299,7 @@ func TestWatchCancelRunning(t *testing.T) {
} }
func testWatchCancelRunning(t *testing.T, wctx *watchctx) { func testWatchCancelRunning(t *testing.T, wctx *watchctx) {
integration.BeforeTest(t) integration2.BeforeTest(t)
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
if wctx.ch = wctx.w.Watch(ctx, "a"); wctx.ch == nil { if wctx.ch = wctx.w.Watch(ctx, "a"); wctx.ch == nil {
@ -347,8 +347,8 @@ func putAndWatch(t *testing.T, wctx *watchctx, key, val string) {
} }
func TestWatchResumeInitRev(t *testing.T) { func TestWatchResumeInitRev(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -402,9 +402,9 @@ func TestWatchResumeInitRev(t *testing.T) {
// either a compaction error or all keys by staying in sync before the compaction // either a compaction error or all keys by staying in sync before the compaction
// is finally applied. // is finally applied.
func TestWatchResumeCompacted(t *testing.T) { func TestWatchResumeCompacted(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// create a waiting watcher at rev 1 // create a waiting watcher at rev 1
@ -489,9 +489,9 @@ func TestWatchResumeCompacted(t *testing.T) {
// TestWatchCompactRevision ensures the CompactRevision error is given on a // TestWatchCompactRevision ensures the CompactRevision error is given on a
// compaction event ahead of a watcher. // compaction event ahead of a watcher.
func TestWatchCompactRevision(t *testing.T) { func TestWatchCompactRevision(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
// set some keys // set some keys
@ -531,7 +531,7 @@ func TestWatchWithProgressNotify(t *testing.T) { testWatchWithProgressNot
func TestWatchWithProgressNotifyNoEvent(t *testing.T) { testWatchWithProgressNotify(t, false) } func TestWatchWithProgressNotifyNoEvent(t *testing.T) { testWatchWithProgressNotify(t, false) }
func testWatchWithProgressNotify(t *testing.T, watchOnPut bool) { func testWatchWithProgressNotify(t *testing.T, watchOnPut bool) {
integration.BeforeTest(t) integration2.BeforeTest(t)
// accelerate report interval so test terminates quickly // accelerate report interval so test terminates quickly
oldpi := v3rpc.GetProgressReportInterval() oldpi := v3rpc.GetProgressReportInterval()
@ -540,7 +540,7 @@ func testWatchWithProgressNotify(t *testing.T, watchOnPut bool) {
pi := 3 * time.Second pi := 3 * time.Second
defer func() { v3rpc.SetProgressReportInterval(oldpi) }() defer func() { v3rpc.SetProgressReportInterval(oldpi) }()
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
wc := clus.RandClient() wc := clus.RandClient()
@ -585,11 +585,11 @@ func testWatchWithProgressNotify(t *testing.T, watchOnPut bool) {
} }
func TestConfigurableWatchProgressNotifyInterval(t *testing.T) { func TestConfigurableWatchProgressNotifyInterval(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
progressInterval := 200 * time.Millisecond progressInterval := 200 * time.Millisecond
clus := integration.NewClusterV3(t, clus := integration2.NewClusterV3(t,
&integration.ClusterConfig{ &integration2.ClusterConfig{
Size: 3, Size: 3,
WatchProgressNotifyInterval: progressInterval, WatchProgressNotifyInterval: progressInterval,
}) })
@ -611,7 +611,7 @@ func TestConfigurableWatchProgressNotifyInterval(t *testing.T) {
} }
func TestWatchRequestProgress(t *testing.T) { func TestWatchRequestProgress(t *testing.T) {
if integration.ThroughProxy { if integration2.ThroughProxy {
t.Skipf("grpc-proxy does not support WatchProgress yet") t.Skipf("grpc-proxy does not support WatchProgress yet")
} }
testCases := []struct { testCases := []struct {
@ -625,11 +625,11 @@ func TestWatchRequestProgress(t *testing.T) {
for _, c := range testCases { for _, c := range testCases {
t.Run(c.name, func(t *testing.T) { t.Run(c.name, func(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
watchTimeout := 3 * time.Second watchTimeout := 3 * time.Second
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
wc := clus.RandClient() wc := clus.RandClient()
@ -686,9 +686,9 @@ func TestWatchRequestProgress(t *testing.T) {
} }
func TestWatchEventType(t *testing.T) { func TestWatchEventType(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) cluster := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer cluster.Terminate(t) defer cluster.Terminate(t)
client := cluster.RandClient() client := cluster.RandClient()
@ -760,9 +760,9 @@ func TestWatchEventType(t *testing.T) {
} }
func TestWatchErrConnClosed(t *testing.T) { func TestWatchErrConnClosed(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -783,16 +783,16 @@ func TestWatchErrConnClosed(t *testing.T) {
clus.TakeClient(0) clus.TakeClient(0)
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("wc.Watch took too long") t.Fatal("wc.Watch took too long")
case <-donec: case <-donec:
} }
} }
func TestWatchAfterClose(t *testing.T) { func TestWatchAfterClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -810,7 +810,7 @@ func TestWatchAfterClose(t *testing.T) {
close(donec) close(donec)
}() }()
select { select {
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("wc.Watch took too long") t.Fatal("wc.Watch took too long")
case <-donec: case <-donec:
} }
@ -818,9 +818,9 @@ func TestWatchAfterClose(t *testing.T) {
// TestWatchWithRequireLeader checks the watch channel closes when no leader. // TestWatchWithRequireLeader checks the watch channel closes when no leader.
func TestWatchWithRequireLeader(t *testing.T) { func TestWatchWithRequireLeader(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// Put a key for the non-require leader watch to read as an event. // Put a key for the non-require leader watch to read as an event.
@ -856,7 +856,7 @@ func TestWatchWithRequireLeader(t *testing.T) {
if resp.Err() != rpctypes.ErrNoLeader { if resp.Err() != rpctypes.ErrNoLeader {
t.Fatalf("expected %v watch response error, got %+v", rpctypes.ErrNoLeader, resp) t.Fatalf("expected %v watch response error, got %+v", rpctypes.ErrNoLeader, resp)
} }
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("watch without leader took too long to close") t.Fatal("watch without leader took too long to close")
} }
@ -865,7 +865,7 @@ func TestWatchWithRequireLeader(t *testing.T) {
if ok { if ok {
t.Fatalf("expected closed channel, got response %v", resp) t.Fatalf("expected closed channel, got response %v", resp)
} }
case <-time.After(integration.RequestWaitTimeout): case <-time.After(integration2.RequestWaitTimeout):
t.Fatal("waited too long for channel to close") t.Fatal("waited too long for channel to close")
} }
@ -892,9 +892,9 @@ func TestWatchWithRequireLeader(t *testing.T) {
// TestWatchWithFilter checks that watch filtering works. // TestWatchWithFilter checks that watch filtering works.
func TestWatchWithFilter(t *testing.T) { func TestWatchWithFilter(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) cluster := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer cluster.Terminate(t) defer cluster.Terminate(t)
client := cluster.RandClient() client := cluster.RandClient()
@ -931,9 +931,9 @@ func TestWatchWithFilter(t *testing.T) {
// TestWatchWithCreatedNotification checks that WithCreatedNotify returns a // TestWatchWithCreatedNotification checks that WithCreatedNotify returns a
// Created watch response. // Created watch response.
func TestWatchWithCreatedNotification(t *testing.T) { func TestWatchWithCreatedNotification(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) cluster := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer cluster.Terminate(t) defer cluster.Terminate(t)
client := cluster.RandClient() client := cluster.RandClient()
@ -953,9 +953,9 @@ func TestWatchWithCreatedNotification(t *testing.T) {
// a watcher with created notify does not post duplicate // a watcher with created notify does not post duplicate
// created events from disconnect. // created events from disconnect.
func TestWatchWithCreatedNotificationDropConn(t *testing.T) { func TestWatchWithCreatedNotificationDropConn(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) cluster := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer cluster.Terminate(t) defer cluster.Terminate(t)
client := cluster.RandClient() client := cluster.RandClient()
@ -982,9 +982,9 @@ func TestWatchWithCreatedNotificationDropConn(t *testing.T) {
// TestWatchCancelOnServer ensures client watcher cancels propagate back to the server. // TestWatchCancelOnServer ensures client watcher cancels propagate back to the server.
func TestWatchCancelOnServer(t *testing.T) { func TestWatchCancelOnServer(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) cluster := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer cluster.Terminate(t) defer cluster.Terminate(t)
client := cluster.RandClient() client := cluster.RandClient()
@ -1050,20 +1050,20 @@ func TestWatchCancelOnServer(t *testing.T) {
// 4. watcher client finishes tearing down stream on "ctx" // 4. watcher client finishes tearing down stream on "ctx"
// 5. w2 comes back canceled // 5. w2 comes back canceled
func TestWatchOverlapContextCancel(t *testing.T) { func TestWatchOverlapContextCancel(t *testing.T) {
f := func(clus *integration.ClusterV3) {} f := func(clus *integration2.ClusterV3) {}
testWatchOverlapContextCancel(t, f) testWatchOverlapContextCancel(t, f)
} }
func TestWatchOverlapDropConnContextCancel(t *testing.T) { func TestWatchOverlapDropConnContextCancel(t *testing.T) {
f := func(clus *integration.ClusterV3) { f := func(clus *integration2.ClusterV3) {
clus.Members[0].Bridge().DropConnections() clus.Members[0].Bridge().DropConnections()
} }
testWatchOverlapContextCancel(t, f) testWatchOverlapContextCancel(t, f)
} }
func testWatchOverlapContextCancel(t *testing.T, f func(*integration.ClusterV3)) { func testWatchOverlapContextCancel(t *testing.T, f func(*integration2.ClusterV3)) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
n := 100 n := 100
@ -1123,8 +1123,8 @@ func testWatchOverlapContextCancel(t *testing.T, f func(*integration.ClusterV3))
// TestWatchCancelAndCloseClient ensures that canceling a watcher then immediately // TestWatchCancelAndCloseClient ensures that canceling a watcher then immediately
// closing the client does not return a client closing error. // closing the client does not return a client closing error.
func TestWatchCancelAndCloseClient(t *testing.T) { func TestWatchCancelAndCloseClient(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
@ -1153,8 +1153,8 @@ func TestWatchCancelAndCloseClient(t *testing.T) {
// to put them in resuming mode, cancels them so some resumes by cancel fail, // to put them in resuming mode, cancels them so some resumes by cancel fail,
// then closes the watcher interface to ensure correct clean up. // then closes the watcher interface to ensure correct clean up.
func TestWatchStressResumeClose(t *testing.T) { func TestWatchStressResumeClose(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
@ -1175,8 +1175,8 @@ func TestWatchStressResumeClose(t *testing.T) {
// TestWatchCancelDisconnected ensures canceling a watcher works when // TestWatchCancelDisconnected ensures canceling a watcher works when
// its grpc stream is disconnected / reconnecting. // its grpc stream is disconnected / reconnecting.
func TestWatchCancelDisconnected(t *testing.T) { func TestWatchCancelDisconnected(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())

209
tests/integration/cluster_test.go
View File

@ -27,6 +27,7 @@ import (
"go.etcd.io/etcd/client/v2" "go.etcd.io/etcd/client/v2"
"go.etcd.io/etcd/server/v3/etcdserver" "go.etcd.io/etcd/server/v3/etcdserver"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
func init() { func init() {
@ -34,7 +35,7 @@ func init() {
log.SetFlags(log.Ltime | log.Lmicroseconds | log.Lshortfile) log.SetFlags(log.Ltime | log.Lmicroseconds | log.Lshortfile)
if t := os.Getenv("ETCD_ELECTION_TIMEOUT_TICKS"); t != "" { if t := os.Getenv("ETCD_ELECTION_TIMEOUT_TICKS"); t != "" {
if i, err := strconv.ParseInt(t, 10, 64); err == nil { if i, err := strconv.ParseInt(t, 10, 64); err == nil {
electionTicks = int(i) integration.ElectionTicks = int(i)
} }
} }
} }
@ -43,16 +44,16 @@ func TestClusterOf1(t *testing.T) { testCluster(t, 1) }
func TestClusterOf3(t *testing.T) { testCluster(t, 3) } func TestClusterOf3(t *testing.T) { testCluster(t, 3) }
func testCluster(t *testing.T, size int) { func testCluster(t *testing.T, size int) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, size) c := integration.NewCluster(t, size)
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
func TestTLSClusterOf3(t *testing.T) { func TestTLSClusterOf3(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := NewClusterByConfig(t, &ClusterConfig{Size: 3, PeerTLS: &testTLSInfo}) c := integration.NewClusterByConfig(t, &integration.ClusterConfig{Size: 3, PeerTLS: &integration.TestTLSInfo})
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
@ -61,8 +62,8 @@ func TestTLSClusterOf3(t *testing.T) {
// Test that a cluster can progress when using separate client and server certs when peering. This supports certificate // Test that a cluster can progress when using separate client and server certs when peering. This supports certificate
// authorities that don't issue dual-usage certificates. // authorities that don't issue dual-usage certificates.
func TestTLSClusterOf3WithSpecificUsage(t *testing.T) { func TestTLSClusterOf3WithSpecificUsage(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := NewClusterByConfig(t, &ClusterConfig{Size: 3, PeerTLS: &testTLSInfoWithSpecificUsage}) c := integration.NewClusterByConfig(t, &integration.ClusterConfig{Size: 3, PeerTLS: &integration.TestTLSInfoWithSpecificUsage})
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
@ -72,22 +73,22 @@ func TestClusterOf1UsingDiscovery(t *testing.T) { testClusterUsingDiscovery(t, 1
func TestClusterOf3UsingDiscovery(t *testing.T) { testClusterUsingDiscovery(t, 3) } func TestClusterOf3UsingDiscovery(t *testing.T) { testClusterUsingDiscovery(t, 3) }
func testClusterUsingDiscovery(t *testing.T, size int) { func testClusterUsingDiscovery(t *testing.T, size int) {
BeforeTest(t) integration.BeforeTest(t)
dc := NewCluster(t, 1) dc := integration.NewCluster(t, 1)
dc.Launch(t) dc.Launch(t)
defer dc.Terminate(t) defer dc.Terminate(t)
// init discovery token space // init discovery token space
dcc := MustNewHTTPClient(t, dc.URLs(), nil) dcc := integration.MustNewHTTPClient(t, dc.URLs(), nil)
dkapi := client.NewKeysAPI(dcc) dkapi := client.NewKeysAPI(dcc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
if _, err := dkapi.Create(ctx, "/_config/size", fmt.Sprintf("%d", size)); err != nil { if _, err := dkapi.Create(ctx, "/_config/size", fmt.Sprintf("%d", size)); err != nil {
t.Fatal(err) t.Fatal(err)
} }
cancel() cancel()
c := NewClusterByConfig( c := integration.NewClusterByConfig(
t, t,
&ClusterConfig{Size: size, DiscoveryURL: dc.URL(0) + "/v2/keys"}, &integration.ClusterConfig{Size: size, DiscoveryURL: dc.URL(0) + "/v2/keys"},
) )
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
@ -95,23 +96,23 @@ func testClusterUsingDiscovery(t *testing.T, size int) {
} }
func TestTLSClusterOf3UsingDiscovery(t *testing.T) { func TestTLSClusterOf3UsingDiscovery(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
dc := NewCluster(t, 1) dc := integration.NewCluster(t, 1)
dc.Launch(t) dc.Launch(t)
defer dc.Terminate(t) defer dc.Terminate(t)
// init discovery token space // init discovery token space
dcc := MustNewHTTPClient(t, dc.URLs(), nil) dcc := integration.MustNewHTTPClient(t, dc.URLs(), nil)
dkapi := client.NewKeysAPI(dcc) dkapi := client.NewKeysAPI(dcc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
if _, err := dkapi.Create(ctx, "/_config/size", fmt.Sprintf("%d", 3)); err != nil { if _, err := dkapi.Create(ctx, "/_config/size", fmt.Sprintf("%d", 3)); err != nil {
t.Fatal(err) t.Fatal(err)
} }
cancel() cancel()
c := NewClusterByConfig(t, c := integration.NewClusterByConfig(t,
&ClusterConfig{ &integration.ClusterConfig{
Size: 3, Size: 3,
PeerTLS: &testTLSInfo, PeerTLS: &integration.TestTLSInfo,
DiscoveryURL: dc.URL(0) + "/v2/keys"}, DiscoveryURL: dc.URL(0) + "/v2/keys"},
) )
c.Launch(t) c.Launch(t)
@ -123,8 +124,8 @@ func TestDoubleClusterSizeOf1(t *testing.T) { testDoubleClusterSize(t, 1) }
func TestDoubleClusterSizeOf3(t *testing.T) { testDoubleClusterSize(t, 3) } func TestDoubleClusterSizeOf3(t *testing.T) { testDoubleClusterSize(t, 3) }
func testDoubleClusterSize(t *testing.T, size int) { func testDoubleClusterSize(t *testing.T, size int) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, size) c := integration.NewCluster(t, size)
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
@ -135,8 +136,8 @@ func testDoubleClusterSize(t *testing.T, size int) {
} }
func TestDoubleTLSClusterSizeOf3(t *testing.T) { func TestDoubleTLSClusterSizeOf3(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := NewClusterByConfig(t, &ClusterConfig{Size: 3, PeerTLS: &testTLSInfo}) c := integration.NewClusterByConfig(t, &integration.ClusterConfig{Size: 3, PeerTLS: &integration.TestTLSInfo})
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
@ -150,16 +151,16 @@ func TestDecreaseClusterSizeOf3(t *testing.T) { testDecreaseClusterSize(t, 3) }
func TestDecreaseClusterSizeOf5(t *testing.T) { testDecreaseClusterSize(t, 5) } func TestDecreaseClusterSizeOf5(t *testing.T) { testDecreaseClusterSize(t, 5) }
func testDecreaseClusterSize(t *testing.T, size int) { func testDecreaseClusterSize(t *testing.T, size int) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, size) c := integration.NewCluster(t, size)
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
// TODO: remove the last but one member // TODO: remove the last but one member
for i := 0; i < size-1; i++ { for i := 0; i < size-1; i++ {
id := c.Members[len(c.Members)-1].s.ID() id := c.Members[len(c.Members)-1].Server.ID()
// may hit second leader election on slow machines // may hit second leader election on slow machines
if err := c.removeMember(t, uint64(id)); err != nil { if err := c.RemoveMember(t, uint64(id)); err != nil {
if strings.Contains(err.Error(), "no leader") { if strings.Contains(err.Error(), "no leader") {
t.Logf("got leader error (%v)", err) t.Logf("got leader error (%v)", err)
i-- i--
@ -167,24 +168,24 @@ func testDecreaseClusterSize(t *testing.T, size int) {
} }
t.Fatal(err) t.Fatal(err)
} }
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
} }
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
func TestForceNewCluster(t *testing.T) { func TestForceNewCluster(t *testing.T) {
c := newCluster(t, &ClusterConfig{Size: 3, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
c.Launch(t) c.Launch(t)
cc := MustNewHTTPClient(t, []string{c.Members[0].URL()}, nil) cc := integration.MustNewHTTPClient(t, []string{c.Members[0].URL()}, nil)
kapi := client.NewKeysAPI(cc) kapi := client.NewKeysAPI(cc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
resp, err := kapi.Create(ctx, "/foo", "bar") resp, err := kapi.Create(ctx, "/foo", "bar")
if err != nil { if err != nil {
t.Fatalf("unexpected create error: %v", err) t.Fatalf("unexpected create error: %v", err)
} }
cancel() cancel()
// ensure create has been applied in this machine // ensure create has been applied in this machine
ctx, cancel = context.WithTimeout(context.Background(), requestTimeout) ctx, cancel = context.WithTimeout(context.Background(), integration.RequestTimeout)
if _, err = kapi.Watcher("/foo", &client.WatcherOptions{AfterIndex: resp.Node.ModifiedIndex - 1}).Next(ctx); err != nil { if _, err = kapi.Watcher("/foo", &client.WatcherOptions{AfterIndex: resp.Node.ModifiedIndex - 1}).Next(ctx); err != nil {
t.Fatalf("unexpected watch error: %v", err) t.Fatalf("unexpected watch error: %v", err)
} }
@ -199,13 +200,13 @@ func TestForceNewCluster(t *testing.T) {
t.Fatalf("unexpected ForceRestart error: %v", err) t.Fatalf("unexpected ForceRestart error: %v", err)
} }
defer c.Members[0].Terminate(t) defer c.Members[0].Terminate(t)
c.waitLeader(t, c.Members[:1]) c.WaitMembersForLeader(t, c.Members[:1])
// use new http client to init new connection // use new http client to init new connection
cc = MustNewHTTPClient(t, []string{c.Members[0].URL()}, nil) cc = integration.MustNewHTTPClient(t, []string{c.Members[0].URL()}, nil)
kapi = client.NewKeysAPI(cc) kapi = client.NewKeysAPI(cc)
// ensure force restart keep the old data, and new cluster can make progress // ensure force restart keep the old data, and new Cluster can make progress
ctx, cancel = context.WithTimeout(context.Background(), requestTimeout) ctx, cancel = context.WithTimeout(context.Background(), integration.RequestTimeout)
if _, err := kapi.Watcher("/foo", &client.WatcherOptions{AfterIndex: resp.Node.ModifiedIndex - 1}).Next(ctx); err != nil { if _, err := kapi.Watcher("/foo", &client.WatcherOptions{AfterIndex: resp.Node.ModifiedIndex - 1}).Next(ctx); err != nil {
t.Fatalf("unexpected watch error: %v", err) t.Fatalf("unexpected watch error: %v", err)
} }
@ -214,38 +215,38 @@ func TestForceNewCluster(t *testing.T) {
} }
func TestAddMemberAfterClusterFullRotation(t *testing.T) { func TestAddMemberAfterClusterFullRotation(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, 3) c := integration.NewCluster(t, 3)
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
// remove all the previous three members and add in three new members. // remove all the previous three members and add in three new members.
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
c.RemoveMember(t, uint64(c.Members[0].s.ID())) c.MustRemoveMember(t, uint64(c.Members[0].Server.ID()))
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
c.AddMember(t) c.AddMember(t)
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
} }
c.AddMember(t) c.AddMember(t)
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
// Ensure we can remove a member then add a new one back immediately. // Ensure we can remove a member then add a new one back immediately.
func TestIssue2681(t *testing.T) { func TestIssue2681(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, 5) c := integration.NewCluster(t, 5)
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
c.RemoveMember(t, uint64(c.Members[4].s.ID())) c.MustRemoveMember(t, uint64(c.Members[4].Server.ID()))
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
c.AddMember(t) c.AddMember(t)
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
@ -256,8 +257,8 @@ func TestIssue2746(t *testing.T) { testIssue2746(t, 5) }
func TestIssue2746WithThree(t *testing.T) { testIssue2746(t, 3) } func TestIssue2746WithThree(t *testing.T) { testIssue2746(t, 3) }
func testIssue2746(t *testing.T, members int) { func testIssue2746(t *testing.T, members int) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, members) c := integration.NewCluster(t, members)
for _, m := range c.Members { for _, m := range c.Members {
m.SnapshotCount = 10 m.SnapshotCount = 10
@ -271,32 +272,32 @@ func testIssue2746(t *testing.T, members int) {
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
c.RemoveMember(t, uint64(c.Members[members-1].s.ID())) c.MustRemoveMember(t, uint64(c.Members[members-1].Server.ID()))
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
c.AddMember(t) c.AddMember(t)
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
// Ensure etcd will not panic when removing a just started member. // Ensure etcd will not panic when removing a just started member.
func TestIssue2904(t *testing.T) { func TestIssue2904(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
// start 1-member cluster to ensure member 0 is the leader of the cluster. // start 1-member Cluster to ensure member 0 is the leader of the Cluster.
c := newCluster(t, &ClusterConfig{Size: 1, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
c.AddMember(t) c.AddMember(t)
c.Members[1].Stop(t) c.Members[1].Stop(t)
// send remove member-1 request to the cluster. // send remove member-1 request to the Cluster.
cc := MustNewHTTPClient(t, c.URLs(), nil) cc := integration.MustNewHTTPClient(t, c.URLs(), nil)
ma := client.NewMembersAPI(cc) ma := client.NewMembersAPI(cc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
// the proposal is not committed because member 1 is stopped, but the // the proposal is not committed because member 1 is stopped, but the
// proposal is appended to leader's raft log. // proposal is appended to leader'Server raft log.
ma.Remove(ctx, c.Members[1].s.ID().String()) ma.Remove(ctx, c.Members[1].Server.ID().String())
cancel() cancel()
// restart member, and expect it to send UpdateAttributes request. // restart member, and expect it to send UpdateAttributes request.
@ -305,21 +306,21 @@ func TestIssue2904(t *testing.T) {
c.Members[1].Restart(t) c.Members[1].Restart(t)
// when the member comes back, it ack the proposal to remove itself, // when the member comes back, it ack the proposal to remove itself,
// and apply it. // and apply it.
<-c.Members[1].s.StopNotify() <-c.Members[1].Server.StopNotify()
// terminate removed member // terminate removed member
c.Members[1].Terminate(t) c.Members[1].Terminate(t)
c.Members = c.Members[:1] c.Members = c.Members[:1]
// wait member to be removed. // wait member to be removed.
c.waitMembersMatch(t, c.HTTPMembers()) c.WaitMembersMatch(t, c.HTTPMembers())
} }
// TestIssue3699 tests minority failure during cluster configuration; it was // TestIssue3699 tests minority failure during cluster configuration; it was
// deadlocking. // deadlocking.
func TestIssue3699(t *testing.T) { func TestIssue3699(t *testing.T) {
// start a cluster of 3 nodes a, b, c // start a Cluster of 3 nodes a, b, c
BeforeTest(t) integration.BeforeTest(t)
c := newCluster(t, &ClusterConfig{Size: 3, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
@ -330,16 +331,16 @@ func TestIssue3699(t *testing.T) {
c.AddMember(t) c.AddMember(t)
// electing node d as leader makes node a unable to participate // electing node d as leader makes node a unable to participate
leaderID := c.waitLeader(t, c.Members) leaderID := c.WaitMembersForLeader(t, c.Members)
for leaderID != 3 { for leaderID != 3 {
c.Members[leaderID].Stop(t) c.Members[leaderID].Stop(t)
<-c.Members[leaderID].s.StopNotify() <-c.Members[leaderID].Server.StopNotify()
// do not restart the killed member immediately. // do not restart the killed member immediately.
// the member will advance its election timeout after restart, // the member will advance its election timeout after restart,
// so it will have a better chance to become the leader again. // so it will have a better chance to become the leader again.
time.Sleep(time.Duration(electionTicks * int(tickDuration))) time.Sleep(time.Duration(integration.ElectionTicks * int(integration.TickDuration)))
c.Members[leaderID].Restart(t) c.Members[leaderID].Restart(t)
leaderID = c.waitLeader(t, c.Members) leaderID = c.WaitMembersForLeader(t, c.Members)
} }
// bring back node a // bring back node a
@ -351,17 +352,17 @@ func TestIssue3699(t *testing.T) {
// waiting for ReadyNotify can take several seconds // waiting for ReadyNotify can take several seconds
case <-time.After(10 * time.Second): case <-time.After(10 * time.Second):
t.Fatalf("waited too long for ready notification") t.Fatalf("waited too long for ready notification")
case <-c.Members[0].s.StopNotify(): case <-c.Members[0].Server.StopNotify():
t.Fatalf("should not be stopped") t.Fatalf("should not be stopped")
case <-c.Members[0].s.ReadyNotify(): case <-c.Members[0].Server.ReadyNotify():
} }
// must waitLeader so goroutines don't leak on terminate // must WaitMembersForLeader so goroutines don't leak on terminate
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
// try to participate in cluster // try to participate in Cluster
cc := MustNewHTTPClient(t, []string{c.URL(0)}, c.cfg.ClientTLS) cc := integration.MustNewHTTPClient(t, []string{c.URL(0)}, c.Cfg.ClientTLS)
kapi := client.NewKeysAPI(cc) kapi := client.NewKeysAPI(cc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
if _, err := kapi.Set(ctx, "/foo", "bar", nil); err != nil { if _, err := kapi.Set(ctx, "/foo", "bar", nil); err != nil {
t.Fatalf("unexpected error on Set (%v)", err) t.Fatalf("unexpected error on Set (%v)", err)
} }
@ -370,21 +371,21 @@ func TestIssue3699(t *testing.T) {
// TestRejectUnhealthyAdd ensures an unhealthy cluster rejects adding members. // TestRejectUnhealthyAdd ensures an unhealthy cluster rejects adding members.
func TestRejectUnhealthyAdd(t *testing.T) { func TestRejectUnhealthyAdd(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := newCluster(t, &ClusterConfig{Size: 3, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
for _, m := range c.Members { for _, m := range c.Members {
m.ServerConfig.StrictReconfigCheck = true m.ServerConfig.StrictReconfigCheck = true
} }
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
// make cluster unhealthy and wait for downed peer // make Cluster unhealthy and wait for downed peer
c.Members[0].Stop(t) c.Members[0].Stop(t)
c.WaitLeader(t) c.WaitLeader(t)
// all attempts to add member should fail // all attempts to add member should fail
for i := 1; i < len(c.Members); i++ { for i := 1; i < len(c.Members); i++ {
err := c.addMemberByURL(t, c.URL(i), "unix://foo:12345") err := c.AddMemberByURL(t, c.URL(i), "unix://foo:12345")
if err == nil { if err == nil {
t.Fatalf("should have failed adding peer") t.Fatalf("should have failed adding peer")
} }
@ -399,23 +400,23 @@ func TestRejectUnhealthyAdd(t *testing.T) {
c.WaitLeader(t) c.WaitLeader(t)
time.Sleep(2 * etcdserver.HealthInterval) time.Sleep(2 * etcdserver.HealthInterval)
// add member should succeed now that it's healthy // add member should succeed now that it'Server healthy
var err error var err error
for i := 1; i < len(c.Members); i++ { for i := 1; i < len(c.Members); i++ {
if err = c.addMemberByURL(t, c.URL(i), "unix://foo:12345"); err == nil { if err = c.AddMemberByURL(t, c.URL(i), "unix://foo:12345"); err == nil {
break break
} }
} }
if err != nil { if err != nil {
t.Fatalf("should have added peer to healthy cluster (%v)", err) t.Fatalf("should have added peer to healthy Cluster (%v)", err)
} }
} }
// TestRejectUnhealthyRemove ensures an unhealthy cluster rejects removing members // TestRejectUnhealthyRemove ensures an unhealthy cluster rejects removing members
// if quorum will be lost. // if quorum will be lost.
func TestRejectUnhealthyRemove(t *testing.T) { func TestRejectUnhealthyRemove(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := newCluster(t, &ClusterConfig{Size: 5, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 5, UseBridge: true})
for _, m := range c.Members { for _, m := range c.Members {
m.ServerConfig.StrictReconfigCheck = true m.ServerConfig.StrictReconfigCheck = true
} }
@ -428,7 +429,7 @@ func TestRejectUnhealthyRemove(t *testing.T) {
c.WaitLeader(t) c.WaitLeader(t)
// reject remove active member since (3,2)-(1,0) => (2,2) lacks quorum // reject remove active member since (3,2)-(1,0) => (2,2) lacks quorum
err := c.removeMember(t, uint64(c.Members[2].s.ID())) err := c.RemoveMember(t, uint64(c.Members[2].Server.ID()))
if err == nil { if err == nil {
t.Fatalf("should reject quorum breaking remove") t.Fatalf("should reject quorum breaking remove")
} }
@ -438,10 +439,10 @@ func TestRejectUnhealthyRemove(t *testing.T) {
} }
// member stopped after launch; wait for missing heartbeats // member stopped after launch; wait for missing heartbeats
time.Sleep(time.Duration(electionTicks * int(tickDuration))) time.Sleep(time.Duration(integration.ElectionTicks * int(integration.TickDuration)))
// permit remove dead member since (3,2) - (0,1) => (3,1) has quorum // permit remove dead member since (3,2) - (0,1) => (3,1) has quorum
if err = c.removeMember(t, uint64(c.Members[0].s.ID())); err != nil { if err = c.RemoveMember(t, uint64(c.Members[0].Server.ID())); err != nil {
t.Fatalf("should accept removing down member") t.Fatalf("should accept removing down member")
} }
@ -452,7 +453,7 @@ func TestRejectUnhealthyRemove(t *testing.T) {
time.Sleep((3 * etcdserver.HealthInterval) / 2) time.Sleep((3 * etcdserver.HealthInterval) / 2)
// accept remove member since (4,1)-(1,0) => (3,1) has quorum // accept remove member since (4,1)-(1,0) => (3,1) has quorum
if err = c.removeMember(t, uint64(c.Members[0].s.ID())); err != nil { if err = c.RemoveMember(t, uint64(c.Members[0].Server.ID())); err != nil {
t.Fatalf("expected to remove member, got error %v", err) t.Fatalf("expected to remove member, got error %v", err)
} }
} }
@ -461,10 +462,10 @@ func TestRejectUnhealthyRemove(t *testing.T) {
// if 'initial-cluster-state' is set 'new' and old data directory still exists // if 'initial-cluster-state' is set 'new' and old data directory still exists
// (see https://github.com/etcd-io/etcd/issues/7512 for more). // (see https://github.com/etcd-io/etcd/issues/7512 for more).
func TestRestartRemoved(t *testing.T) { func TestRestartRemoved(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
// 1. start single-member cluster // 1. start single-member Cluster
c := newCluster(t, &ClusterConfig{Size: 1, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
for _, m := range c.Members { for _, m := range c.Members {
m.ServerConfig.StrictReconfigCheck = true m.ServerConfig.StrictReconfigCheck = true
} }
@ -476,10 +477,10 @@ func TestRestartRemoved(t *testing.T) {
c.WaitLeader(t) c.WaitLeader(t)
oldm := c.Members[0] oldm := c.Members[0]
oldm.keepDataDirTerminate = true oldm.KeepDataDirTerminate = true
// 3. remove first member, shut down without deleting data // 3. remove first member, shut down without deleting data
if err := c.removeMember(t, uint64(c.Members[0].s.ID())); err != nil { if err := c.RemoveMember(t, uint64(c.Members[0].Server.ID())); err != nil {
t.Fatalf("expected to remove member, got error %v", err) t.Fatalf("expected to remove member, got error %v", err)
} }
c.WaitLeader(t) c.WaitLeader(t)
@ -495,7 +496,7 @@ func TestRestartRemoved(t *testing.T) {
os.RemoveAll(oldm.ServerConfig.DataDir) os.RemoveAll(oldm.ServerConfig.DataDir)
}() }()
select { select {
case <-oldm.s.StopNotify(): case <-oldm.Server.StopNotify():
case <-time.After(time.Minute): case <-time.After(time.Minute):
t.Fatalf("removed member didn't exit within %v", time.Minute) t.Fatalf("removed member didn't exit within %v", time.Minute)
} }
@ -504,8 +505,8 @@ func TestRestartRemoved(t *testing.T) {
// clusterMustProgress ensures that cluster can make progress. It creates // clusterMustProgress ensures that cluster can make progress. It creates
// a random key first, and check the new key could be got from all client urls // a random key first, and check the new key could be got from all client urls
// of the cluster. // of the cluster.
func clusterMustProgress(t *testing.T, membs []*member) { func clusterMustProgress(t *testing.T, membs []*integration.Member) {
cc := MustNewHTTPClient(t, []string{membs[0].URL()}, nil) cc := integration.MustNewHTTPClient(t, []string{membs[0].URL()}, nil)
kapi := client.NewKeysAPI(cc) kapi := client.NewKeysAPI(cc)
key := fmt.Sprintf("foo%d", rand.Int()) key := fmt.Sprintf("foo%d", rand.Int())
var ( var (
@ -514,7 +515,7 @@ func clusterMustProgress(t *testing.T, membs []*member) {
) )
// retry in case of leader loss induced by slow CI // retry in case of leader loss induced by slow CI
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
resp, err = kapi.Create(ctx, "/"+key, "bar") resp, err = kapi.Create(ctx, "/"+key, "bar")
cancel() cancel()
if err == nil { if err == nil {
@ -528,9 +529,9 @@ func clusterMustProgress(t *testing.T, membs []*member) {
for i, m := range membs { for i, m := range membs {
u := m.URL() u := m.URL()
mcc := MustNewHTTPClient(t, []string{u}, nil) mcc := integration.MustNewHTTPClient(t, []string{u}, nil)
mkapi := client.NewKeysAPI(mcc) mkapi := client.NewKeysAPI(mcc)
mctx, mcancel := context.WithTimeout(context.Background(), requestTimeout) mctx, mcancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
if _, err := mkapi.Watcher(key, &client.WatcherOptions{AfterIndex: resp.Node.ModifiedIndex - 1}).Next(mctx); err != nil { if _, err := mkapi.Watcher(key, &client.WatcherOptions{AfterIndex: resp.Node.ModifiedIndex - 1}).Next(mctx); err != nil {
t.Fatalf("#%d: watch on %s error: %v", i, u, err) t.Fatalf("#%d: watch on %s error: %v", i, u, err)
} }
@ -539,8 +540,8 @@ func clusterMustProgress(t *testing.T, membs []*member) {
} }
func TestSpeedyTerminate(t *testing.T) { func TestSpeedyTerminate(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
// Stop/Restart so requests will time out on lost leaders // Stop/Restart so requests will time out on lost leaders
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
clus.Members[i].Stop(t) clus.Members[i].Stop(t)
@ -553,7 +554,7 @@ func TestSpeedyTerminate(t *testing.T) {
}() }()
select { select {
case <-time.After(10 * time.Second): case <-time.After(10 * time.Second):
t.Fatalf("cluster took too long to terminate") t.Fatalf("Cluster took too long to terminate")
case <-donec: case <-donec:
} }
} }

10
tests/integration/embed/embed_test.go
View File

@ -34,14 +34,14 @@ import (
"go.etcd.io/etcd/client/pkg/v3/transport" "go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/embed" "go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
var ( var (
testTLSInfo = transport.TLSInfo{ testTLSInfo = transport.TLSInfo{
KeyFile: integration.MustAbsPath("../../fixtures/server.key.insecure"), KeyFile: integration2.MustAbsPath("../../fixtures/server.key.insecure"),
CertFile: integration.MustAbsPath("../../fixtures/server.crt"), CertFile: integration2.MustAbsPath("../../fixtures/server.crt"),
TrustedCAFile: integration.MustAbsPath("../../fixtures/ca.crt"), TrustedCAFile: integration2.MustAbsPath("../../fixtures/ca.crt"),
ClientCertAuth: true, ClientCertAuth: true,
} }
) )
@ -160,7 +160,7 @@ func testEmbedEtcdGracefulStop(t *testing.T, secure bool) {
t.Fatal(err) t.Fatal(err)
} }
} }
cli, err := integration.NewClient(t, clientCfg) cli, err := integration2.NewClient(t, clientCfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

25
tests/integration/grpc_test.go
View File

@ -23,6 +23,7 @@ import (
"time" "time"
clientv3 "go.etcd.io/etcd/client/v3" clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
@ -94,14 +95,14 @@ func TestAuthority(t *testing.T) {
for _, tc := range tcs { for _, tc := range tcs {
for _, clusterSize := range []int{1, 3} { for _, clusterSize := range []int{1, 3} {
t.Run(fmt.Sprintf("Size: %d, Scenario: %q", clusterSize, tc.name), func(t *testing.T) { t.Run(fmt.Sprintf("Size: %d, Scenario: %q", clusterSize, tc.name), func(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cfg := ClusterConfig{ cfg := integration.ClusterConfig{
Size: clusterSize, Size: clusterSize,
UseTCP: tc.useTCP, UseTCP: tc.useTCP,
UseIP: tc.useTCP, UseIP: tc.useTCP,
} }
cfg, tlsConfig := setupTLS(t, tc.useTLS, cfg) cfg, tlsConfig := setupTLS(t, tc.useTLS, cfg)
clus := NewClusterV3(t, &cfg) clus := integration.NewClusterV3(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
kv := setupClient(t, tc.clientURLPattern, clus, tlsConfig) kv := setupClient(t, tc.clientURLPattern, clus, tlsConfig)
@ -118,11 +119,11 @@ func TestAuthority(t *testing.T) {
} }
} }
func setupTLS(t *testing.T, useTLS bool, cfg ClusterConfig) (ClusterConfig, *tls.Config) { func setupTLS(t *testing.T, useTLS bool, cfg integration.ClusterConfig) (integration.ClusterConfig, *tls.Config) {
t.Helper() t.Helper()
if useTLS { if useTLS {
cfg.ClientTLS = &testTLSInfo cfg.ClientTLS = &integration.TestTLSInfo
tlsConfig, err := testTLSInfo.ClientConfig() tlsConfig, err := integration.TestTLSInfo.ClientConfig()
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -131,7 +132,7 @@ func setupTLS(t *testing.T, useTLS bool, cfg ClusterConfig) (ClusterConfig, *tls
return cfg, nil return cfg, nil
} }
func setupClient(t *testing.T, endpointPattern string, clus *ClusterV3, tlsConfig *tls.Config) *clientv3.Client { func setupClient(t *testing.T, endpointPattern string, clus *integration.ClusterV3, tlsConfig *tls.Config) *clientv3.Client {
t.Helper() t.Helper()
endpoints := templateEndpoints(t, endpointPattern, clus) endpoints := templateEndpoints(t, endpointPattern, clus)
kv, err := clientv3.New(clientv3.Config{ kv, err := clientv3.New(clientv3.Config{
@ -146,13 +147,13 @@ func setupClient(t *testing.T, endpointPattern string, clus *ClusterV3, tlsConfi
return kv return kv
} }
func templateEndpoints(t *testing.T, pattern string, clus *ClusterV3) []string { func templateEndpoints(t *testing.T, pattern string, clus *integration.ClusterV3) []string {
t.Helper() t.Helper()
endpoints := []string{} endpoints := []string{}
for _, m := range clus.Members { for _, m := range clus.Members {
ent := pattern ent := pattern
if strings.Contains(ent, "%d") { if strings.Contains(ent, "%d") {
ent = fmt.Sprintf(ent, GrpcPortNumber(m.UniqNumber, m.MemberNumber)) ent = fmt.Sprintf(ent, integration.GrpcPortNumber(m.UniqNumber, m.MemberNumber))
} }
if strings.Contains(ent, "%s") { if strings.Contains(ent, "%s") {
ent = fmt.Sprintf(ent, m.Name) ent = fmt.Sprintf(ent, m.Name)
@ -165,11 +166,11 @@ func templateEndpoints(t *testing.T, pattern string, clus *ClusterV3) []string {
return endpoints return endpoints
} }
func templateAuthority(t *testing.T, pattern string, m *member) string { func templateAuthority(t *testing.T, pattern string, m *integration.Member) string {
t.Helper() t.Helper()
authority := pattern authority := pattern
if strings.Contains(authority, "%d") { if strings.Contains(authority, "%d") {
authority = fmt.Sprintf(authority, GrpcPortNumber(m.UniqNumber, m.MemberNumber)) authority = fmt.Sprintf(authority, integration.GrpcPortNumber(m.UniqNumber, m.MemberNumber))
} }
if strings.Contains(authority, "%s") { if strings.Contains(authority, "%s") {
authority = fmt.Sprintf(authority, m.Name) authority = fmt.Sprintf(authority, m.Name)
@ -180,7 +181,7 @@ func templateAuthority(t *testing.T, pattern string, m *member) string {
return authority return authority
} }
func assertAuthority(t *testing.T, expectedAuthority string, clus *ClusterV3) { func assertAuthority(t *testing.T, expectedAuthority string, clus *integration.ClusterV3) {
t.Helper() t.Helper()
requestsFound := 0 requestsFound := 0
for _, m := range clus.Members { for _, m := range clus.Members {

15
tests/integration/lazy_cluster.go
View File

@ -22,6 +22,7 @@ import (
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
"go.etcd.io/etcd/client/pkg/v3/transport" "go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// Infrastructure to provision a single shared cluster for tests - only // Infrastructure to provision a single shared cluster for tests - only
@ -42,7 +43,7 @@ type LazyCluster interface {
EndpointsV3() []string EndpointsV3() []string
// Cluster - calls to this method might initialize the cluster. // Cluster - calls to this method might initialize the cluster.
Cluster() *ClusterV3 Cluster() *integration.ClusterV3
// Transport - call to this method might initialize the cluster. // Transport - call to this method might initialize the cluster.
Transport() *http.Transport Transport() *http.Transport
@ -53,8 +54,8 @@ type LazyCluster interface {
} }
type lazyCluster struct { type lazyCluster struct {
cfg ClusterConfig cfg integration.ClusterConfig
cluster *ClusterV3 cluster *integration.ClusterV3
transport *http.Transport transport *http.Transport
once sync.Once once sync.Once
tb testutil.TB tb testutil.TB
@ -64,12 +65,12 @@ type lazyCluster struct {
// NewLazyCluster returns a new test cluster handler that gets created on the // NewLazyCluster returns a new test cluster handler that gets created on the
// first call to GetEndpoints() or GetTransport() // first call to GetEndpoints() or GetTransport()
func NewLazyCluster() LazyCluster { func NewLazyCluster() LazyCluster {
return NewLazyClusterWithConfig(ClusterConfig{Size: 1}) return NewLazyClusterWithConfig(integration.ClusterConfig{Size: 1})
} }
// NewLazyClusterWithConfig returns a new test cluster handler that gets created // NewLazyClusterWithConfig returns a new test cluster handler that gets created
// on the first call to GetEndpoints() or GetTransport() // on the first call to GetEndpoints() or GetTransport()
func NewLazyClusterWithConfig(cfg ClusterConfig) LazyCluster { func NewLazyClusterWithConfig(cfg integration.ClusterConfig) LazyCluster {
tb, closer := testutil.NewTestingTBProthesis("lazy_cluster") tb, closer := testutil.NewTestingTBProthesis("lazy_cluster")
return &lazyCluster{cfg: cfg, tb: tb, closer: closer} return &lazyCluster{cfg: cfg, tb: tb, closer: closer}
} }
@ -81,7 +82,7 @@ func (lc *lazyCluster) mustLazyInit() {
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
lc.cluster = NewClusterV3(lc.tb, &lc.cfg) lc.cluster = integration.NewClusterV3(lc.tb, &lc.cfg)
}) })
} }
@ -105,7 +106,7 @@ func (lc *lazyCluster) EndpointsV3() []string {
return lc.Cluster().Client(0).Endpoints() return lc.Cluster().Client(0).Endpoints()
} }
func (lc *lazyCluster) Cluster() *ClusterV3 { func (lc *lazyCluster) Cluster() *integration.ClusterV3 {
lc.mustLazyInit() lc.mustLazyInit()
return lc.cluster return lc.cluster
} }

37
tests/integration/member_test.go
View File

@ -23,52 +23,53 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go.etcd.io/etcd/client/v2" "go.etcd.io/etcd/client/v2"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestPauseMember(t *testing.T) { func TestPauseMember(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := NewCluster(t, 5) c := integration.NewCluster(t, 5)
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
for i := 0; i < 5; i++ { for i := 0; i < 5; i++ {
c.Members[i].Pause() c.Members[i].Pause()
membs := append([]*member{}, c.Members[:i]...) membs := append([]*integration.Member{}, c.Members[:i]...)
membs = append(membs, c.Members[i+1:]...) membs = append(membs, c.Members[i+1:]...)
c.waitLeader(t, membs) c.WaitMembersForLeader(t, membs)
clusterMustProgress(t, membs) clusterMustProgress(t, membs)
c.Members[i].Resume() c.Members[i].Resume()
} }
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
func TestRestartMember(t *testing.T) { func TestRestartMember(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
c := newCluster(t, &ClusterConfig{Size: 3, UseBridge: true}) c := integration.NewClusterFromConfig(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
c.Launch(t) c.Launch(t)
defer c.Terminate(t) defer c.Terminate(t)
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
c.Members[i].Stop(t) c.Members[i].Stop(t)
membs := append([]*member{}, c.Members[:i]...) membs := append([]*integration.Member{}, c.Members[:i]...)
membs = append(membs, c.Members[i+1:]...) membs = append(membs, c.Members[i+1:]...)
c.waitLeader(t, membs) c.WaitMembersForLeader(t, membs)
clusterMustProgress(t, membs) clusterMustProgress(t, membs)
err := c.Members[i].Restart(t) err := c.Members[i].Restart(t)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
c.waitLeader(t, c.Members) c.WaitMembersForLeader(t, c.Members)
clusterMustProgress(t, c.Members) clusterMustProgress(t, c.Members)
} }
func TestLaunchDuplicateMemberShouldFail(t *testing.T) { func TestLaunchDuplicateMemberShouldFail(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
size := 3 size := 3
c := NewCluster(t, size) c := integration.NewCluster(t, size)
m := c.Members[0].Clone(t) m := c.Members[0].Clone(t)
var err error var err error
m.DataDir, err = ioutil.TempDir(t.TempDir(), "etcd") m.DataDir, err = ioutil.TempDir(t.TempDir(), "etcd")
@ -87,8 +88,8 @@ func TestLaunchDuplicateMemberShouldFail(t *testing.T) {
} }
func TestSnapshotAndRestartMember(t *testing.T) { func TestSnapshotAndRestartMember(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
m := mustNewMember(t, memberConfig{name: "snapAndRestartTest", useBridge: true}) m := integration.MustNewMember(t, integration.MemberConfig{Name: "snapAndRestartTest", UseBridge: true})
m.SnapshotCount = 100 m.SnapshotCount = 100
m.Launch() m.Launch()
defer m.Terminate(t) defer m.Terminate(t)
@ -97,9 +98,9 @@ func TestSnapshotAndRestartMember(t *testing.T) {
resps := make([]*client.Response, 120) resps := make([]*client.Response, 120)
var err error var err error
for i := 0; i < 120; i++ { for i := 0; i < 120; i++ {
cc := MustNewHTTPClient(t, []string{m.URL()}, nil) cc := integration.MustNewHTTPClient(t, []string{m.URL()}, nil)
kapi := client.NewKeysAPI(cc) kapi := client.NewKeysAPI(cc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
key := fmt.Sprintf("foo%d", i) key := fmt.Sprintf("foo%d", i)
resps[i], err = kapi.Create(ctx, "/"+key, "bar") resps[i], err = kapi.Create(ctx, "/"+key, "bar")
if err != nil { if err != nil {
@ -112,9 +113,9 @@ func TestSnapshotAndRestartMember(t *testing.T) {
m.WaitOK(t) m.WaitOK(t)
for i := 0; i < 120; i++ { for i := 0; i < 120; i++ {
cc := MustNewHTTPClient(t, []string{m.URL()}, nil) cc := integration.MustNewHTTPClient(t, []string{m.URL()}, nil)
kapi := client.NewKeysAPI(cc) kapi := client.NewKeysAPI(cc)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) ctx, cancel := context.WithTimeout(context.Background(), integration.RequestTimeout)
key := fmt.Sprintf("foo%d", i) key := fmt.Sprintf("foo%d", i)
resp, err := kapi.Get(ctx, "/"+key, nil) resp, err := kapi.Get(ctx, "/"+key, nil)
if err != nil { if err != nil {

21
tests/integration/metrics_test.go
View File

@ -25,12 +25,13 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/client/pkg/v3/transport" "go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/server/v3/storage" "go.etcd.io/etcd/server/v3/storage"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestMetricDbSizeBoot checks that the db size metric is set on boot. // TestMetricDbSizeBoot checks that the db size metric is set on boot.
func TestMetricDbSizeBoot(t *testing.T) { func TestMetricDbSizeBoot(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
v, err := clus.Members[0].Metric("etcd_debugging_mvcc_db_total_size_in_bytes") v, err := clus.Members[0].Metric("etcd_debugging_mvcc_db_total_size_in_bytes")
@ -49,12 +50,12 @@ func TestMetricDbSizeDefrag(t *testing.T) {
// testMetricDbSizeDefrag checks that the db size metric is set after defrag. // testMetricDbSizeDefrag checks that the db size metric is set after defrag.
func testMetricDbSizeDefrag(t *testing.T, name string) { func testMetricDbSizeDefrag(t *testing.T, name string) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
mc := toGRPC(clus.Client(0)).Maintenance mc := integration.ToGRPC(clus.Client(0)).Maintenance
// expand the db size // expand the db size
numPuts := 25 // large enough to write more than 1 page numPuts := 25 // large enough to write more than 1 page
@ -163,8 +164,8 @@ func testMetricDbSizeDefrag(t *testing.T, name string) {
} }
func TestMetricQuotaBackendBytes(t *testing.T) { func TestMetricQuotaBackendBytes(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
qs, err := clus.Members[0].Metric("etcd_server_quota_backend_bytes") qs, err := clus.Members[0].Metric("etcd_server_quota_backend_bytes")
@ -181,8 +182,8 @@ func TestMetricQuotaBackendBytes(t *testing.T) {
} }
func TestMetricsHealth(t *testing.T) { func TestMetricsHealth(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
tr, err := transport.NewTransport(transport.TLSInfo{}, 5*time.Second) tr, err := transport.NewTransport(transport.TLSInfo{}, 5*time.Second)

44
tests/integration/network_partition_test.go
View File

@ -18,12 +18,14 @@ import (
"fmt" "fmt"
"testing" "testing"
"time" "time"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestNetworkPartition5MembersLeaderInMinority(t *testing.T) { func TestNetworkPartition5MembersLeaderInMinority(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 5}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 5})
defer clus.Terminate(t) defer clus.Terminate(t)
leadIndex := clus.WaitLeader(t) leadIndex := clus.WaitLeader(t)
@ -32,20 +34,20 @@ func TestNetworkPartition5MembersLeaderInMinority(t *testing.T) {
minority := []int{leadIndex, (leadIndex + 1) % 5} minority := []int{leadIndex, (leadIndex + 1) % 5}
majority := []int{(leadIndex + 2) % 5, (leadIndex + 3) % 5, (leadIndex + 4) % 5} majority := []int{(leadIndex + 2) % 5, (leadIndex + 3) % 5, (leadIndex + 4) % 5}
minorityMembers := getMembersByIndexSlice(clus.cluster, minority) minorityMembers := getMembersByIndexSlice(clus.Cluster, minority)
majorityMembers := getMembersByIndexSlice(clus.cluster, majority) majorityMembers := getMembersByIndexSlice(clus.Cluster, majority)
// network partition (bi-directional) // network partition (bi-directional)
injectPartition(t, minorityMembers, majorityMembers) injectPartition(t, minorityMembers, majorityMembers)
// minority leader must be lost // minority leader must be lost
clus.waitNoLeader(minorityMembers) clus.WaitMembersNoLeader(minorityMembers)
// wait extra election timeout // wait extra election timeout
time.Sleep(2 * majorityMembers[0].ElectionTimeout()) time.Sleep(2 * majorityMembers[0].ElectionTimeout())
// new leader must be from majority // new leader must be from majority
clus.waitLeader(t, majorityMembers) clus.WaitMembersForLeader(t, majorityMembers)
// recover network partition (bi-directional) // recover network partition (bi-directional)
recoverPartition(t, minorityMembers, majorityMembers) recoverPartition(t, minorityMembers, majorityMembers)
@ -69,9 +71,9 @@ func TestNetworkPartition5MembersLeaderInMajority(t *testing.T) {
} }
func testNetworkPartition5MembersLeaderInMajority(t *testing.T) error { func testNetworkPartition5MembersLeaderInMajority(t *testing.T) error {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 5}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 5})
defer clus.Terminate(t) defer clus.Terminate(t)
leadIndex := clus.WaitLeader(t) leadIndex := clus.WaitLeader(t)
@ -80,21 +82,21 @@ func testNetworkPartition5MembersLeaderInMajority(t *testing.T) error {
majority := []int{leadIndex, (leadIndex + 1) % 5, (leadIndex + 2) % 5} majority := []int{leadIndex, (leadIndex + 1) % 5, (leadIndex + 2) % 5}
minority := []int{(leadIndex + 3) % 5, (leadIndex + 4) % 5} minority := []int{(leadIndex + 3) % 5, (leadIndex + 4) % 5}
majorityMembers := getMembersByIndexSlice(clus.cluster, majority) majorityMembers := getMembersByIndexSlice(clus.Cluster, majority)
minorityMembers := getMembersByIndexSlice(clus.cluster, minority) minorityMembers := getMembersByIndexSlice(clus.Cluster, minority)
// network partition (bi-directional) // network partition (bi-directional)
injectPartition(t, majorityMembers, minorityMembers) injectPartition(t, majorityMembers, minorityMembers)
// minority leader must be lost // minority leader must be lost
clus.waitNoLeader(minorityMembers) clus.WaitMembersNoLeader(minorityMembers)
// wait extra election timeout // wait extra election timeout
time.Sleep(2 * majorityMembers[0].ElectionTimeout()) time.Sleep(2 * majorityMembers[0].ElectionTimeout())
// leader must be hold in majority // leader must be hold in majority
leadIndex2 := clus.waitLeader(t, majorityMembers) leadIndex2 := clus.WaitMembersForLeader(t, majorityMembers)
leadID, leadID2 := clus.Members[leadIndex].s.ID(), majorityMembers[leadIndex2].s.ID() leadID, leadID2 := clus.Members[leadIndex].Server.ID(), majorityMembers[leadIndex2].Server.ID()
if leadID != leadID2 { if leadID != leadID2 {
return fmt.Errorf("unexpected leader change from %s, got %s", leadID, leadID2) return fmt.Errorf("unexpected leader change from %s, got %s", leadID, leadID2)
} }
@ -108,9 +110,9 @@ func testNetworkPartition5MembersLeaderInMajority(t *testing.T) error {
} }
func TestNetworkPartition4Members(t *testing.T) { func TestNetworkPartition4Members(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 4}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 4})
defer clus.Terminate(t) defer clus.Terminate(t)
leadIndex := clus.WaitLeader(t) leadIndex := clus.WaitLeader(t)
@ -119,8 +121,8 @@ func TestNetworkPartition4Members(t *testing.T) {
groupA := []int{leadIndex, (leadIndex + 1) % 4} groupA := []int{leadIndex, (leadIndex + 1) % 4}
groupB := []int{(leadIndex + 2) % 4, (leadIndex + 3) % 4} groupB := []int{(leadIndex + 2) % 4, (leadIndex + 3) % 4}
leaderPartition := getMembersByIndexSlice(clus.cluster, groupA) leaderPartition := getMembersByIndexSlice(clus.Cluster, groupA)
followerPartition := getMembersByIndexSlice(clus.cluster, groupB) followerPartition := getMembersByIndexSlice(clus.Cluster, groupB)
// network partition (bi-directional) // network partition (bi-directional)
injectPartition(t, leaderPartition, followerPartition) injectPartition(t, leaderPartition, followerPartition)
@ -137,21 +139,21 @@ func TestNetworkPartition4Members(t *testing.T) {
clusterMustProgress(t, clus.Members) clusterMustProgress(t, clus.Members)
} }
func getMembersByIndexSlice(clus *cluster, idxs []int) []*member { func getMembersByIndexSlice(clus *integration.Cluster, idxs []int) []*integration.Member {
ms := make([]*member, len(idxs)) ms := make([]*integration.Member, len(idxs))
for i, idx := range idxs { for i, idx := range idxs {
ms[i] = clus.Members[idx] ms[i] = clus.Members[idx]
} }
return ms return ms
} }
func injectPartition(t *testing.T, src, others []*member) { func injectPartition(t *testing.T, src, others []*integration.Member) {
for _, m := range src { for _, m := range src {
m.InjectPartition(t, others...) m.InjectPartition(t, others...)
} }
} }
func recoverPartition(t *testing.T, src, others []*member) { func recoverPartition(t *testing.T, src, others []*integration.Member) {
for _, m := range src { for _, m := range src {
m.RecoverPartition(t, others...) m.RecoverPartition(t, others...)
} }

10
tests/integration/proxy/grpcproxy/cluster_test.go
View File

@ -23,7 +23,7 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/proxy/grpcproxy" "go.etcd.io/etcd/server/v3/proxy/grpcproxy"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
"go.uber.org/zap" "go.uber.org/zap"
@ -31,9 +31,9 @@ import (
) )
func TestClusterProxyMemberList(t *testing.T) { func TestClusterProxyMemberList(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cts := newClusterProxyServer(zaptest.NewLogger(t), []string{clus.Members[0].GRPCURL()}, t) cts := newClusterProxyServer(zaptest.NewLogger(t), []string{clus.Members[0].GRPCURL()}, t)
@ -43,7 +43,7 @@ func TestClusterProxyMemberList(t *testing.T) {
Endpoints: []string{cts.caddr}, Endpoints: []string{cts.caddr},
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
} }
client, err := integration.NewClient(t, cfg) client, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatalf("err %v, want nil", err) t.Fatalf("err %v, want nil", err)
} }
@ -95,7 +95,7 @@ func newClusterProxyServer(lg *zap.Logger, endpoints []string, t *testing.T) *cl
Endpoints: endpoints, Endpoints: endpoints,
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
} }
client, err := integration.NewClient(t, cfg) client, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

11
tests/integration/proxy/grpcproxy/kv_test.go
View File

@ -23,15 +23,14 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/proxy/grpcproxy" "go.etcd.io/etcd/server/v3/proxy/grpcproxy"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
func TestKVProxyRange(t *testing.T) { func TestKVProxyRange(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvts := newKVProxyServer([]string{clus.Members[0].GRPCURL()}, t) kvts := newKVProxyServer([]string{clus.Members[0].GRPCURL()}, t)
@ -42,7 +41,7 @@ func TestKVProxyRange(t *testing.T) {
Endpoints: []string{kvts.l.Addr().String()}, Endpoints: []string{kvts.l.Addr().String()},
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
} }
client, err := integration.NewClient(t, cfg) client, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatalf("err = %v, want nil", err) t.Fatalf("err = %v, want nil", err)
} }
@ -71,7 +70,7 @@ func newKVProxyServer(endpoints []string, t *testing.T) *kvproxyTestServer {
Endpoints: endpoints, Endpoints: endpoints,
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
} }
client, err := integration.NewClient(t, cfg) client, err := integration2.NewClient(t, cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

6
tests/integration/proxy/grpcproxy/register_test.go
View File

@ -21,14 +21,14 @@ import (
clientv3 "go.etcd.io/etcd/client/v3" clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/naming/endpoints" "go.etcd.io/etcd/client/v3/naming/endpoints"
"go.etcd.io/etcd/server/v3/proxy/grpcproxy" "go.etcd.io/etcd/server/v3/proxy/grpcproxy"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
) )
func TestRegister(t *testing.T) { func TestRegister(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)
paddr := clus.Members[0].GRPCURL() paddr := clus.Members[0].GRPCURL()

10
tests/integration/snapshot/member_test.go
View File

@ -24,14 +24,14 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/embed" "go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/server/v3/etcdserver" "go.etcd.io/etcd/server/v3/etcdserver"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestSnapshotV3RestoreMultiMemberAdd ensures that multiple members // TestSnapshotV3RestoreMultiMemberAdd ensures that multiple members
// can boot into the same cluster after being restored from a same // can boot into the same cluster after being restored from a same
// snapshot file, and also be able to add another member to the cluster. // snapshot file, and also be able to add another member to the cluster.
func TestSnapshotV3RestoreMultiMemberAdd(t *testing.T) { func TestSnapshotV3RestoreMultiMemberAdd(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
kvs := []kv{{"foo1", "bar1"}, {"foo2", "bar2"}, {"foo3", "bar3"}} kvs := []kv{{"foo1", "bar1"}, {"foo2", "bar2"}, {"foo3", "bar3"}}
dbPath := createSnapshotFile(t, kvs) dbPath := createSnapshotFile(t, kvs)
@ -48,7 +48,7 @@ func TestSnapshotV3RestoreMultiMemberAdd(t *testing.T) {
// wait for health interval + leader election // wait for health interval + leader election
time.Sleep(etcdserver.HealthInterval + 2*time.Second) time.Sleep(etcdserver.HealthInterval + 2*time.Second)
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{cURLs[0].String()}}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{cURLs[0].String()}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -63,7 +63,7 @@ func TestSnapshotV3RestoreMultiMemberAdd(t *testing.T) {
// wait for membership reconfiguration apply // wait for membership reconfiguration apply
time.Sleep(testutil.ApplyTimeout) time.Sleep(testutil.ApplyTimeout)
cfg := integration.NewEmbedConfig(t, "3") cfg := integration2.NewEmbedConfig(t, "3")
cfg.InitialClusterToken = testClusterTkn cfg.InitialClusterToken = testClusterTkn
cfg.ClusterState = "existing" cfg.ClusterState = "existing"
cfg.LCUrls, cfg.ACUrls = newCURLs, newCURLs cfg.LCUrls, cfg.ACUrls = newCURLs, newCURLs
@ -88,7 +88,7 @@ func TestSnapshotV3RestoreMultiMemberAdd(t *testing.T) {
t.Fatalf("failed to start the newly added etcd member") t.Fatalf("failed to start the newly added etcd member")
} }
cli2, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{newCURLs[0].String()}}) cli2, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{newCURLs[0].String()}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

22
tests/integration/snapshot/v3_snapshot_test.go
View File

@ -29,7 +29,7 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/etcdutl/v3/snapshot" "go.etcd.io/etcd/etcdutl/v3/snapshot"
"go.etcd.io/etcd/server/v3/embed" "go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap/zapcore" "go.uber.org/zap/zapcore"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
) )
@ -37,7 +37,7 @@ import (
// TestSnapshotV3RestoreSingle tests single node cluster restoring // TestSnapshotV3RestoreSingle tests single node cluster restoring
// from a snapshot file. // from a snapshot file.
func TestSnapshotV3RestoreSingle(t *testing.T) { func TestSnapshotV3RestoreSingle(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
kvs := []kv{{"foo1", "bar1"}, {"foo2", "bar2"}, {"foo3", "bar3"}} kvs := []kv{{"foo1", "bar1"}, {"foo2", "bar2"}, {"foo3", "bar3"}}
dbPath := createSnapshotFile(t, kvs) dbPath := createSnapshotFile(t, kvs)
@ -45,7 +45,7 @@ func TestSnapshotV3RestoreSingle(t *testing.T) {
urls := newEmbedURLs(clusterN * 2) urls := newEmbedURLs(clusterN * 2)
cURLs, pURLs := urls[:clusterN], urls[clusterN:] cURLs, pURLs := urls[:clusterN], urls[clusterN:]
cfg := integration.NewEmbedConfig(t, "s1") cfg := integration2.NewEmbedConfig(t, "s1")
cfg.InitialClusterToken = testClusterTkn cfg.InitialClusterToken = testClusterTkn
cfg.ClusterState = "existing" cfg.ClusterState = "existing"
cfg.LCUrls, cfg.ACUrls = cURLs, cURLs cfg.LCUrls, cfg.ACUrls = cURLs, cURLs
@ -82,7 +82,7 @@ func TestSnapshotV3RestoreSingle(t *testing.T) {
} }
var cli *clientv3.Client var cli *clientv3.Client
cli, err = integration.NewClient(t, clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}}) cli, err = integration2.NewClient(t, clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -103,7 +103,7 @@ func TestSnapshotV3RestoreSingle(t *testing.T) {
// can boot into the same cluster after being restored from a same // can boot into the same cluster after being restored from a same
// snapshot file. // snapshot file.
func TestSnapshotV3RestoreMulti(t *testing.T) { func TestSnapshotV3RestoreMulti(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
kvs := []kv{{"foo1", "bar1"}, {"foo2", "bar2"}, {"foo3", "bar3"}} kvs := []kv{{"foo1", "bar1"}, {"foo2", "bar2"}, {"foo3", "bar3"}}
dbPath := createSnapshotFile(t, kvs) dbPath := createSnapshotFile(t, kvs)
@ -119,7 +119,7 @@ func TestSnapshotV3RestoreMulti(t *testing.T) {
time.Sleep(time.Second) time.Sleep(time.Second)
for i := 0; i < clusterN; i++ { for i := 0; i < clusterN; i++ {
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: []string{cURLs[i].String()}}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: []string{cURLs[i].String()}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -139,8 +139,8 @@ func TestSnapshotV3RestoreMulti(t *testing.T) {
// TestCorruptedBackupFileCheck tests if we can correctly identify a corrupted backup file. // TestCorruptedBackupFileCheck tests if we can correctly identify a corrupted backup file.
func TestCorruptedBackupFileCheck(t *testing.T) { func TestCorruptedBackupFileCheck(t *testing.T) {
dbPath := integration.MustAbsPath("testdata/corrupted_backup.db") dbPath := integration2.MustAbsPath("testdata/corrupted_backup.db")
integration.BeforeTest(t) integration2.BeforeTest(t)
if _, err := os.Stat(dbPath); err != nil { if _, err := os.Stat(dbPath); err != nil {
t.Fatalf("test file [%s] does not exist: %v", dbPath, err) t.Fatalf("test file [%s] does not exist: %v", dbPath, err)
} }
@ -175,7 +175,7 @@ func createSnapshotFile(t *testing.T, kvs []kv) string {
urls := newEmbedURLs(clusterN * 2) urls := newEmbedURLs(clusterN * 2)
cURLs, pURLs := urls[:clusterN], urls[clusterN:] cURLs, pURLs := urls[:clusterN], urls[clusterN:]
cfg := integration.NewEmbedConfig(t, "default") cfg := integration2.NewEmbedConfig(t, "default")
cfg.ClusterState = "new" cfg.ClusterState = "new"
cfg.LCUrls, cfg.ACUrls = cURLs, cURLs cfg.LCUrls, cfg.ACUrls = cURLs, cURLs
cfg.LPUrls, cfg.APUrls = pURLs, pURLs cfg.LPUrls, cfg.APUrls = pURLs, pURLs
@ -194,7 +194,7 @@ func createSnapshotFile(t *testing.T, kvs []kv) string {
} }
ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}} ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}}
cli, err := integration.NewClient(t, ccfg) cli, err := integration2.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -234,7 +234,7 @@ func restoreCluster(t *testing.T, clusterN int, dbPath string) (
cfgs := make([]*embed.Config, clusterN) cfgs := make([]*embed.Config, clusterN)
for i := 0; i < clusterN; i++ { for i := 0; i < clusterN; i++ {
cfg := integration.NewEmbedConfig(t, fmt.Sprintf("m%d", i)) cfg := integration2.NewEmbedConfig(t, fmt.Sprintf("m%d", i))
cfg.InitialClusterToken = testClusterTkn cfg.InitialClusterToken = testClusterTkn
cfg.ClusterState = "existing" cfg.ClusterState = "existing"
cfg.LCUrls, cfg.ACUrls = []url.URL{cURLs[i]}, []url.URL{cURLs[i]} cfg.LCUrls, cfg.ACUrls = []url.URL{cURLs[i]}, []url.URL{cURLs[i]}

5
tests/integration/testing_test.go
View File

@ -15,12 +15,13 @@
package integration_test package integration_test
import ( import (
"go.etcd.io/etcd/tests/v3/integration"
"testing" "testing"
integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestBeforeTestWithoutLeakDetection(t *testing.T) { func TestBeforeTestWithoutLeakDetection(t *testing.T) {
integration.BeforeTest(t, integration.WithoutGoLeakDetection(), integration.WithoutSkipInShort()) integration2.BeforeTest(t, integration2.WithoutGoLeakDetection(), integration2.WithoutSkipInShort())
// Intentional leak that should get ignored // Intentional leak that should get ignored
go func() { go func() {

5
tests/integration/utl_wal_version_test.go
View File

@ -21,6 +21,7 @@ import (
"github.com/coreos/go-semver/semver" "github.com/coreos/go-semver/semver"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap" "go.uber.org/zap"
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
@ -33,7 +34,7 @@ import (
func TestEtcdVersionFromWAL(t *testing.T) { func TestEtcdVersionFromWAL(t *testing.T) {
testutil.SkipTestIfShortMode(t, testutil.SkipTestIfShortMode(t,
"Wal creation tests are depending on embedded etcd server so are integration-level tests.") "Wal creation tests are depending on embedded etcd server so are integration-level tests.")
cfg := NewEmbedConfig(t, "default") cfg := integration.NewEmbedConfig(t, "default")
srv, err := embed.StartEtcd(cfg) srv, err := embed.StartEtcd(cfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -45,7 +46,7 @@ func TestEtcdVersionFromWAL(t *testing.T) {
} }
ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}} ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}}
cli, err := NewClient(t, ccfg) cli, err := integration.NewClient(t, ccfg)
if err != nil { if err != nil {
srv.Close() srv.Close()
t.Fatal(err) t.Fatal(err)

49
tests/integration/v2_http_kv_test.go
View File

@ -27,11 +27,12 @@ import (
"time" "time"
"go.etcd.io/etcd/client/pkg/v3/transport" "go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
func TestV2Set(t *testing.T) { func TestV2Set(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -92,8 +93,8 @@ func TestV2Set(t *testing.T) {
} }
func TestV2CreateUpdate(t *testing.T) { func TestV2CreateUpdate(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -228,8 +229,8 @@ func TestV2CreateUpdate(t *testing.T) {
} }
func TestV2CAS(t *testing.T) { func TestV2CAS(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -376,8 +377,8 @@ func TestV2CAS(t *testing.T) {
} }
func TestV2Delete(t *testing.T) { func TestV2Delete(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -476,8 +477,8 @@ func TestV2Delete(t *testing.T) {
} }
func TestV2CAD(t *testing.T) { func TestV2CAD(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -576,8 +577,8 @@ func TestV2CAD(t *testing.T) {
} }
func TestV2Unique(t *testing.T) { func TestV2Unique(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -643,8 +644,8 @@ func TestV2Unique(t *testing.T) {
} }
func TestV2Get(t *testing.T) { func TestV2Get(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -741,8 +742,8 @@ func TestV2Get(t *testing.T) {
} }
func TestV2QuorumGet(t *testing.T) { func TestV2QuorumGet(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -839,8 +840,8 @@ func TestV2QuorumGet(t *testing.T) {
} }
func TestV2Watch(t *testing.T) { func TestV2Watch(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -877,8 +878,8 @@ func TestV2Watch(t *testing.T) {
} }
func TestV2WatchWithIndex(t *testing.T) { func TestV2WatchWithIndex(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -944,8 +945,8 @@ func TestV2WatchWithIndex(t *testing.T) {
} }
func TestV2WatchKeyInDir(t *testing.T) { func TestV2WatchKeyInDir(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)
@ -1005,8 +1006,8 @@ func TestV2WatchKeyInDir(t *testing.T) {
} }
func TestV2Head(t *testing.T) { func TestV2Head(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cl := NewCluster(t, 1) cl := integration.NewCluster(t, 1)
cl.Launch(t) cl.Launch(t)
defer cl.Terminate(t) defer cl.Terminate(t)

4
tests/integration/v2store/store_tag_not_v2v3_test.go
View File

@ -23,7 +23,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2store" "go.etcd.io/etcd/server/v3/etcdserver/api/v2store"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
type v2TestStore struct { type v2TestStore struct {
@ -41,7 +41,7 @@ func newTestStore(t *testing.T, ns ...string) StoreCloser {
// Ensure that the store can recover from a previously saved state. // Ensure that the store can recover from a previously saved state.
func TestStoreRecover(t *testing.T) { func TestStoreRecover(t *testing.T) {
integration.BeforeTest(t) integration2.BeforeTest(t)
s := newTestStore(t) s := newTestStore(t)
defer s.Close() defer s.Close()
var eidx uint64 = 4 var eidx uint64 = 4

8
tests/integration/v2store/store_tag_v2v3_test.go
View File

@ -22,20 +22,20 @@ import (
"go.etcd.io/etcd/server/v3/etcdserver/api/v2store" "go.etcd.io/etcd/server/v3/etcdserver/api/v2store"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2v3" "go.etcd.io/etcd/server/v3/etcdserver/api/v2v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
type v2v3TestStore struct { type v2v3TestStore struct {
v2store.Store v2store.Store
clus *integration.ClusterV3 clus *integration2.ClusterV3
t *testing.T t *testing.T
} }
func (s *v2v3TestStore) Close() { s.clus.Terminate(s.t) } func (s *v2v3TestStore) Close() { s.clus.Terminate(s.t) }
func newTestStore(t *testing.T, ns ...string) StoreCloser { func newTestStore(t *testing.T, ns ...string) StoreCloser {
integration.BeforeTest(t) integration2.BeforeTest(t)
clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}) clus := integration2.NewClusterV3(t, &integration2.ClusterConfig{Size: 1})
return &v2v3TestStore{ return &v2v3TestStore{
v2v3.NewStore(clus.Client(0), "/v2/"), v2v3.NewStore(clus.Client(0), "/v2/"),
clus, clus,

18
tests/integration/v2store/store_v2v3_test.go
View File

@ -21,15 +21,15 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2store" "go.etcd.io/etcd/server/v3/etcdserver/api/v2store"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2v3" "go.etcd.io/etcd/server/v3/etcdserver/api/v2v3"
"go.etcd.io/etcd/tests/v3/integration" integration2 "go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TODO: fix tests // TODO: fix tests
func runWithCluster(t testing.TB, runner func(testing.TB, []string)) { func runWithCluster(t testing.TB, runner func(testing.TB, []string)) {
integration.BeforeTest(t) integration2.BeforeTest(t)
cfg := integration.ClusterConfig{Size: 1} cfg := integration2.ClusterConfig{Size: 1}
clus := integration.NewClusterV3(t, &cfg) clus := integration2.NewClusterV3(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
endpoints := []string{clus.Client(0).Endpoints()[0]} endpoints := []string{clus.Client(0).Endpoints()[0]}
runner(t, endpoints) runner(t, endpoints)
@ -38,7 +38,7 @@ func runWithCluster(t testing.TB, runner func(testing.TB, []string)) {
func TestCreateKV(t *testing.T) { runWithCluster(t, testCreateKV) } func TestCreateKV(t *testing.T) { runWithCluster(t, testCreateKV) }
func testCreateKV(t testing.TB, endpoints []string) { func testCreateKV(t testing.TB, endpoints []string) {
integration.BeforeTest(t) integration2.BeforeTest(t)
testCases := []struct { testCases := []struct {
key string key string
value string value string
@ -54,7 +54,7 @@ func testCreateKV(t testing.TB, endpoints []string) {
//{key: "hello", value: "3", unique: true, wantKeyMatch: false}, //{key: "hello", value: "3", unique: true, wantKeyMatch: false},
} }
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: endpoints}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: endpoints})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -102,7 +102,7 @@ func testSetKV(t testing.TB, endpoints []string) {
{key: "/sdir/set", value: "4", wantIndexMatch: false}, {key: "/sdir/set", value: "4", wantIndexMatch: false},
} }
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: endpoints}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: endpoints})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -130,7 +130,7 @@ func testSetKV(t testing.TB, endpoints []string) {
func TestCreateSetDir(t *testing.T) { runWithCluster(t, testCreateSetDir) } func TestCreateSetDir(t *testing.T) { runWithCluster(t, testCreateSetDir) }
func testCreateSetDir(t testing.TB, endpoints []string) { func testCreateSetDir(t testing.TB, endpoints []string) {
integration.BeforeTest(t) integration2.BeforeTest(t)
testCases := []struct { testCases := []struct {
dir string dir string
}{ }{
@ -138,7 +138,7 @@ func testCreateSetDir(t testing.TB, endpoints []string) {
{dir: "/ddir/1/2/3"}, {dir: "/ddir/1/2/3"},
} }
cli, err := integration.NewClient(t, clientv3.Config{Endpoints: endpoints}) cli, err := integration2.NewClient(t, clientv3.Config{Endpoints: endpoints})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

29
tests/integration/v3_alarm_test.go
View File

@ -27,24 +27,25 @@ import (
"go.etcd.io/etcd/pkg/v3/traceutil" "go.etcd.io/etcd/pkg/v3/traceutil"
"go.etcd.io/etcd/server/v3/storage/backend" "go.etcd.io/etcd/server/v3/storage/backend"
"go.etcd.io/etcd/server/v3/storage/mvcc" "go.etcd.io/etcd/server/v3/storage/mvcc"
"go.etcd.io/etcd/tests/v3/framework/integration"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
) )
// TestV3StorageQuotaApply tests the V3 server respects quotas during apply // TestV3StorageQuotaApply tests the V3 server respects quotas during apply
func TestV3StorageQuotaApply(t *testing.T) { func TestV3StorageQuotaApply(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
quotasize := int64(16 * os.Getpagesize()) quotasize := int64(16 * os.Getpagesize())
clus := NewClusterV3(t, &ClusterConfig{Size: 2, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 2, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc0 := toGRPC(clus.Client(0)).KV kvc0 := integration.ToGRPC(clus.Client(0)).KV
kvc1 := toGRPC(clus.Client(1)).KV kvc1 := integration.ToGRPC(clus.Client(1)).KV
// Set a quota on one node // Set a quota on one node
clus.Members[0].QuotaBackendBytes = quotasize clus.Members[0].QuotaBackendBytes = quotasize
clus.Members[0].Stop(t) clus.Members[0].Stop(t)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
waitForRestart(t, kvc0) waitForRestart(t, kvc0)
key := []byte("abc") key := []byte("abc")
@ -73,7 +74,7 @@ func TestV3StorageQuotaApply(t *testing.T) {
stopc := time.After(5 * time.Second) stopc := time.After(5 * time.Second)
for { for {
req := &pb.AlarmRequest{Action: pb.AlarmRequest_GET} req := &pb.AlarmRequest{Action: pb.AlarmRequest_GET}
resp, aerr := clus.Members[0].s.Alarm(context.TODO(), req) resp, aerr := clus.Members[0].Server.Alarm(context.TODO(), req)
if aerr != nil { if aerr != nil {
t.Fatal(aerr) t.Fatal(aerr)
} }
@ -87,7 +88,7 @@ func TestV3StorageQuotaApply(t *testing.T) {
} }
} }
ctx, cancel := context.WithTimeout(context.TODO(), RequestWaitTimeout) ctx, cancel := context.WithTimeout(context.TODO(), integration.RequestWaitTimeout)
defer cancel() defer cancel()
// small quota machine should reject put // small quota machine should reject put
@ -103,7 +104,7 @@ func TestV3StorageQuotaApply(t *testing.T) {
// reset large quota node to ensure alarm persisted // reset large quota node to ensure alarm persisted
clus.Members[1].Stop(t) clus.Members[1].Stop(t)
clus.Members[1].Restart(t) clus.Members[1].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
if _, err := kvc1.Put(context.TODO(), &pb.PutRequest{Key: key, Value: smallbuf}); err == nil { if _, err := kvc1.Put(context.TODO(), &pb.PutRequest{Key: key, Value: smallbuf}); err == nil {
t.Fatalf("alarmed instance should reject put after reset") t.Fatalf("alarmed instance should reject put after reset")
@ -112,12 +113,12 @@ func TestV3StorageQuotaApply(t *testing.T) {
// TestV3AlarmDeactivate ensures that space alarms can be deactivated so puts go through. // TestV3AlarmDeactivate ensures that space alarms can be deactivated so puts go through.
func TestV3AlarmDeactivate(t *testing.T) { func TestV3AlarmDeactivate(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
mt := toGRPC(clus.RandClient()).Maintenance mt := integration.ToGRPC(clus.RandClient()).Maintenance
alarmReq := &pb.AlarmRequest{ alarmReq := &pb.AlarmRequest{
MemberID: 123, MemberID: 123,
@ -146,8 +147,8 @@ func TestV3AlarmDeactivate(t *testing.T) {
} }
func TestV3CorruptAlarm(t *testing.T) { func TestV3CorruptAlarm(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
var wg sync.WaitGroup var wg sync.WaitGroup

73
tests/integration/v3_auth_test.go
View File

@ -26,18 +26,19 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestV3AuthEmptyUserGet ensures that a get with an empty user will return an empty user error. // TestV3AuthEmptyUserGet ensures that a get with an empty user will return an empty user error.
func TestV3AuthEmptyUserGet(t *testing.T) { func TestV3AuthEmptyUserGet(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.TODO(), 30*time.Second) ctx, cancel := context.WithTimeout(context.TODO(), 30*time.Second)
defer cancel() defer cancel()
api := toGRPC(clus.Client(0)) api := integration.ToGRPC(clus.Client(0))
authSetupRoot(t, api.Auth) authSetupRoot(t, api.Auth)
_, err := api.KV.Range(ctx, &pb.RangeRequest{Key: []byte("abc")}) _, err := api.KV.Range(ctx, &pb.RangeRequest{Key: []byte("abc")})
@ -49,13 +50,13 @@ func TestV3AuthEmptyUserGet(t *testing.T) {
// TestV3AuthTokenWithDisable tests that auth won't crash if // TestV3AuthTokenWithDisable tests that auth won't crash if
// given a valid token when authentication is disabled // given a valid token when authentication is disabled
func TestV3AuthTokenWithDisable(t *testing.T) { func TestV3AuthTokenWithDisable(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
authSetupRoot(t, toGRPC(clus.Client(0)).Auth) authSetupRoot(t, integration.ToGRPC(clus.Client(0)).Auth)
c, cerr := NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "root", Password: "123"}) c, cerr := integration.NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "root", Password: "123"})
if cerr != nil { if cerr != nil {
t.Fatal(cerr) t.Fatal(cerr)
} }
@ -81,11 +82,11 @@ func TestV3AuthTokenWithDisable(t *testing.T) {
} }
func TestV3AuthRevision(t *testing.T) { func TestV3AuthRevision(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
api := toGRPC(clus.Client(0)) api := integration.ToGRPC(clus.Client(0))
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
presp, perr := api.KV.Put(ctx, &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}) presp, perr := api.KV.Put(ctx, &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")})
@ -109,25 +110,25 @@ func TestV3AuthRevision(t *testing.T) {
// TestV3AuthWithLeaseRevokeWithRoot ensures that granted leases // TestV3AuthWithLeaseRevokeWithRoot ensures that granted leases
// with root user be revoked after TTL. // with root user be revoked after TTL.
func TestV3AuthWithLeaseRevokeWithRoot(t *testing.T) { func TestV3AuthWithLeaseRevokeWithRoot(t *testing.T) {
testV3AuthWithLeaseRevokeWithRoot(t, ClusterConfig{Size: 1}) testV3AuthWithLeaseRevokeWithRoot(t, integration.ClusterConfig{Size: 1})
} }
// TestV3AuthWithLeaseRevokeWithRootJWT creates a lease with a JWT-token enabled cluster. // TestV3AuthWithLeaseRevokeWithRootJWT creates a lease with a JWT-token enabled cluster.
// And tests if server is able to revoke expiry lease item. // And tests if server is able to revoke expiry lease item.
func TestV3AuthWithLeaseRevokeWithRootJWT(t *testing.T) { func TestV3AuthWithLeaseRevokeWithRootJWT(t *testing.T) {
testV3AuthWithLeaseRevokeWithRoot(t, ClusterConfig{Size: 1, AuthToken: defaultTokenJWT}) testV3AuthWithLeaseRevokeWithRoot(t, integration.ClusterConfig{Size: 1, AuthToken: integration.DefaultTokenJWT})
} }
func testV3AuthWithLeaseRevokeWithRoot(t *testing.T, ccfg ClusterConfig) { func testV3AuthWithLeaseRevokeWithRoot(t *testing.T, ccfg integration.ClusterConfig) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ccfg) clus := integration.NewClusterV3(t, &ccfg)
defer clus.Terminate(t) defer clus.Terminate(t)
api := toGRPC(clus.Client(0)) api := integration.ToGRPC(clus.Client(0))
authSetupRoot(t, api.Auth) authSetupRoot(t, api.Auth)
rootc, cerr := NewClient(t, clientv3.Config{ rootc, cerr := integration.NewClient(t, clientv3.Config{
Endpoints: clus.Client(0).Endpoints(), Endpoints: clus.Client(0).Endpoints(),
Username: "root", Username: "root",
Password: "123", Password: "123",
@ -177,8 +178,8 @@ type user struct {
} }
func TestV3AuthWithLeaseRevoke(t *testing.T) { func TestV3AuthWithLeaseRevoke(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
users := []user{ users := []user{
@ -190,11 +191,11 @@ func TestV3AuthWithLeaseRevoke(t *testing.T) {
end: "k2", end: "k2",
}, },
} }
authSetupUsers(t, toGRPC(clus.Client(0)).Auth, users) authSetupUsers(t, integration.ToGRPC(clus.Client(0)).Auth, users)
authSetupRoot(t, toGRPC(clus.Client(0)).Auth) authSetupRoot(t, integration.ToGRPC(clus.Client(0)).Auth)
rootc, cerr := NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "root", Password: "123"}) rootc, cerr := integration.NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "root", Password: "123"})
if cerr != nil { if cerr != nil {
t.Fatal(cerr) t.Fatal(cerr)
} }
@ -211,7 +212,7 @@ func TestV3AuthWithLeaseRevoke(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
userc, cerr := NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "user1", Password: "user1-123"}) userc, cerr := integration.NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "user1", Password: "user1-123"})
if cerr != nil { if cerr != nil {
t.Fatal(cerr) t.Fatal(cerr)
} }
@ -223,8 +224,8 @@ func TestV3AuthWithLeaseRevoke(t *testing.T) {
} }
func TestV3AuthWithLeaseAttach(t *testing.T) { func TestV3AuthWithLeaseAttach(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
users := []user{ users := []user{
@ -243,17 +244,17 @@ func TestV3AuthWithLeaseAttach(t *testing.T) {
end: "k4", end: "k4",
}, },
} }
authSetupUsers(t, toGRPC(clus.Client(0)).Auth, users) authSetupUsers(t, integration.ToGRPC(clus.Client(0)).Auth, users)
authSetupRoot(t, toGRPC(clus.Client(0)).Auth) authSetupRoot(t, integration.ToGRPC(clus.Client(0)).Auth)
user1c, cerr := NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "user1", Password: "user1-123"}) user1c, cerr := integration.NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "user1", Password: "user1-123"})
if cerr != nil { if cerr != nil {
t.Fatal(cerr) t.Fatal(cerr)
} }
defer user1c.Close() defer user1c.Close()
user2c, cerr := NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "user2", Password: "user2-123"}) user2c, cerr := integration.NewClient(t, clientv3.Config{Endpoints: clus.Client(0).Endpoints(), Username: "user2", Password: "user2-123"})
if cerr != nil { if cerr != nil {
t.Fatal(cerr) t.Fatal(cerr)
} }
@ -335,8 +336,8 @@ func authSetupRoot(t *testing.T, auth pb.AuthClient) {
} }
func TestV3AuthNonAuthorizedRPCs(t *testing.T) { func TestV3AuthNonAuthorizedRPCs(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
nonAuthedKV := clus.Client(0).KV nonAuthedKV := clus.Client(0).KV
@ -348,7 +349,7 @@ func TestV3AuthNonAuthorizedRPCs(t *testing.T) {
t.Fatalf("couldn't put key (%v)", err) t.Fatalf("couldn't put key (%v)", err)
} }
authSetupRoot(t, toGRPC(clus.Client(0)).Auth) authSetupRoot(t, integration.ToGRPC(clus.Client(0)).Auth)
respput, err := nonAuthedKV.Put(context.TODO(), key, val) respput, err := nonAuthedKV.Put(context.TODO(), key, val)
if !eqErrGRPC(err, rpctypes.ErrGRPCUserEmpty) { if !eqErrGRPC(err, rpctypes.ErrGRPCUserEmpty) {
@ -358,13 +359,13 @@ func TestV3AuthNonAuthorizedRPCs(t *testing.T) {
func TestV3AuthOldRevConcurrent(t *testing.T) { func TestV3AuthOldRevConcurrent(t *testing.T) {
t.Skip() // TODO(jingyih): re-enable the test when #10408 is fixed. t.Skip() // TODO(jingyih): re-enable the test when #10408 is fixed.
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
authSetupRoot(t, toGRPC(clus.Client(0)).Auth) authSetupRoot(t, integration.ToGRPC(clus.Client(0)).Auth)
c, cerr := NewClient(t, clientv3.Config{ c, cerr := integration.NewClient(t, clientv3.Config{
Endpoints: clus.Client(0).Endpoints(), Endpoints: clus.Client(0).Endpoints(),
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
Username: "root", Username: "root",

31
tests/integration/v3_election_test.go
View File

@ -22,20 +22,21 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestElectionWait tests if followers can correctly wait for elections. // TestElectionWait tests if followers can correctly wait for elections.
func TestElectionWait(t *testing.T) { func TestElectionWait(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
leaders := 3 leaders := 3
followers := 3 followers := 3
var clients []*clientv3.Client var clients []*clientv3.Client
newClient := MakeMultiNodeClients(t, clus, &clients) newClient := integration.MakeMultiNodeClients(t, clus, &clients)
defer func() { defer func() {
CloseClients(t, clients) integration.CloseClients(t, clients)
}() }()
electedc := make(chan string) electedc := make(chan string)
@ -108,8 +109,8 @@ func TestElectionWait(t *testing.T) {
// TestElectionFailover tests that an election will // TestElectionFailover tests that an election will
func TestElectionFailover(t *testing.T) { func TestElectionFailover(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
cctx, cancel := context.WithCancel(context.TODO()) cctx, cancel := context.WithCancel(context.TODO())
@ -119,7 +120,7 @@ func TestElectionFailover(t *testing.T) {
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
var err error var err error
ss[i], err = concurrency.NewSession(clus.clients[i]) ss[i], err = concurrency.NewSession(clus.Clients[i])
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
@ -176,8 +177,8 @@ func TestElectionFailover(t *testing.T) {
// TestElectionSessionRelock ensures that campaigning twice on the same election // TestElectionSessionRelock ensures that campaigning twice on the same election
// with the same lock will Proclaim instead of deadlocking. // with the same lock will Proclaim instead of deadlocking.
func TestElectionSessionRecampaign(t *testing.T) { func TestElectionSessionRecampaign(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
@ -209,8 +210,8 @@ func TestElectionSessionRecampaign(t *testing.T) {
// of bug #6278. https://github.com/etcd-io/etcd/issues/6278 // of bug #6278. https://github.com/etcd-io/etcd/issues/6278
// //
func TestElectionOnPrefixOfExistingKey(t *testing.T) { func TestElectionOnPrefixOfExistingKey(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
@ -236,8 +237,8 @@ func TestElectionOnPrefixOfExistingKey(t *testing.T) {
// in a new session with the same lease id) does not result in loss of // in a new session with the same lease id) does not result in loss of
// leadership. // leadership.
func TestElectionOnSessionRestart(t *testing.T) { func TestElectionOnSessionRestart(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
@ -283,8 +284,8 @@ func TestElectionOnSessionRestart(t *testing.T) {
// TestElectionObserveCompacted checks that observe can tolerate // TestElectionObserveCompacted checks that observe can tolerate
// a leader key with a modrev less than the compaction revision. // a leader key with a modrev less than the compaction revision.
func TestElectionObserveCompacted(t *testing.T) { func TestElectionObserveCompacted(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)

15
tests/integration/v3_grpc_inflight_test.go
View File

@ -22,6 +22,7 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
@ -30,12 +31,12 @@ import (
// TestV3MaintenanceDefragmentInflightRange ensures inflight range requests // TestV3MaintenanceDefragmentInflightRange ensures inflight range requests
// does not panic the mvcc backend while defragment is running. // does not panic the mvcc backend while defragment is running.
func TestV3MaintenanceDefragmentInflightRange(t *testing.T) { func TestV3MaintenanceDefragmentInflightRange(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
kvc := toGRPC(cli).KV kvc := integration.ToGRPC(cli).KV
if _, err := kvc.Put(context.Background(), &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}); err != nil { if _, err := kvc.Put(context.Background(), &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -48,7 +49,7 @@ func TestV3MaintenanceDefragmentInflightRange(t *testing.T) {
kvc.Range(ctx, &pb.RangeRequest{Key: []byte("foo")}) kvc.Range(ctx, &pb.RangeRequest{Key: []byte("foo")})
}() }()
mvc := toGRPC(cli).Maintenance mvc := integration.ToGRPC(cli).Maintenance
mvc.Defragment(context.Background(), &pb.DefragmentRequest{}) mvc.Defragment(context.Background(), &pb.DefragmentRequest{})
cancel() cancel()
@ -60,12 +61,12 @@ func TestV3MaintenanceDefragmentInflightRange(t *testing.T) {
// They are either finished or canceled, but never crash the backend. // They are either finished or canceled, but never crash the backend.
// See https://github.com/etcd-io/etcd/issues/7322 for more detail. // See https://github.com/etcd-io/etcd/issues/7322 for more detail.
func TestV3KVInflightRangeRequests(t *testing.T) { func TestV3KVInflightRangeRequests(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
kvc := toGRPC(cli).KV kvc := integration.ToGRPC(cli).KV
if _, err := kvc.Put(context.Background(), &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}); err != nil { if _, err := kvc.Put(context.Background(), &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}); err != nil {
t.Fatal(err) t.Fatal(err)

227
tests/integration/v3_grpc_test.go
View File

@ -30,6 +30,7 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/pkg/v3/transport" "go.etcd.io/etcd/client/pkg/v3/transport"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
@ -37,14 +38,14 @@ import (
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
) )
// TestV3PutOverwrite puts a key with the v3 api to a random cluster member, // TestV3PutOverwrite puts a key with the v3 api to a random Cluster member,
// overwrites it, then checks that the change was applied. // overwrites it, then checks that the change was applied.
func TestV3PutOverwrite(t *testing.T) { func TestV3PutOverwrite(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
key := []byte("foo") key := []byte("foo")
reqput := &pb.PutRequest{Key: key, Value: []byte("bar"), PrevKv: true} reqput := &pb.PutRequest{Key: key, Value: []byte("bar"), PrevKv: true}
@ -88,26 +89,26 @@ func TestV3PutOverwrite(t *testing.T) {
// TestPutRestart checks if a put after an unrelated member restart succeeds // TestPutRestart checks if a put after an unrelated member restart succeeds
func TestV3PutRestart(t *testing.T) { func TestV3PutRestart(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kvIdx := rand.Intn(3) kvIdx := rand.Intn(3)
kvc := toGRPC(clus.Client(kvIdx)).KV kvc := integration.ToGRPC(clus.Client(kvIdx)).KV
stopIdx := kvIdx stopIdx := kvIdx
for stopIdx == kvIdx { for stopIdx == kvIdx {
stopIdx = rand.Intn(3) stopIdx = rand.Intn(3)
} }
clus.clients[stopIdx].Close() clus.Clients[stopIdx].Close()
clus.Members[stopIdx].Stop(t) clus.Members[stopIdx].Stop(t)
clus.Members[stopIdx].Restart(t) clus.Members[stopIdx].Restart(t)
c, cerr := NewClientV3(clus.Members[stopIdx]) c, cerr := integration.NewClientV3(clus.Members[stopIdx])
if cerr != nil { if cerr != nil {
t.Fatalf("cannot create client: %v", cerr) t.Fatalf("cannot create client: %v", cerr)
} }
clus.clients[stopIdx] = c clus.Clients[stopIdx] = c
ctx, cancel := context.WithTimeout(context.TODO(), 10*time.Second) ctx, cancel := context.WithTimeout(context.TODO(), 10*time.Second)
defer cancel() defer cancel()
@ -120,11 +121,11 @@ func TestV3PutRestart(t *testing.T) {
// TestV3CompactCurrentRev ensures keys are present when compacting on current revision. // TestV3CompactCurrentRev ensures keys are present when compacting on current revision.
func TestV3CompactCurrentRev(t *testing.T) { func TestV3CompactCurrentRev(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
preq := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} preq := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
if _, err := kvc.Put(context.Background(), preq); err != nil { if _, err := kvc.Put(context.Background(), preq); err != nil {
@ -154,12 +155,12 @@ func TestV3CompactCurrentRev(t *testing.T) {
// TestV3HashKV ensures that multiple calls of HashKV on same node return same hash and compact rev. // TestV3HashKV ensures that multiple calls of HashKV on same node return same hash and compact rev.
func TestV3HashKV(t *testing.T) { func TestV3HashKV(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
mvc := toGRPC(clus.RandClient()).Maintenance mvc := integration.ToGRPC(clus.RandClient()).Maintenance
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
resp, err := kvc.Put(context.Background(), &pb.PutRequest{Key: []byte("foo"), Value: []byte(fmt.Sprintf("bar%d", i))}) resp, err := kvc.Put(context.Background(), &pb.PutRequest{Key: []byte("foo"), Value: []byte(fmt.Sprintf("bar%d", i))})
@ -202,12 +203,12 @@ func TestV3HashKV(t *testing.T) {
} }
func TestV3TxnTooManyOps(t *testing.T) { func TestV3TxnTooManyOps(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
maxTxnOps := uint(128) maxTxnOps := uint(128)
clus := NewClusterV3(t, &ClusterConfig{Size: 3, MaxTxnOps: maxTxnOps}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, MaxTxnOps: maxTxnOps})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
// unique keys // unique keys
i := new(int) i := new(int)
@ -278,8 +279,8 @@ func TestV3TxnTooManyOps(t *testing.T) {
} }
func TestV3TxnDuplicateKeys(t *testing.T) { func TestV3TxnDuplicateKeys(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
putreq := &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: &pb.PutRequest{Key: []byte("abc"), Value: []byte("def")}}} putreq := &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: &pb.PutRequest{Key: []byte("abc"), Value: []byte("def")}}}
@ -323,7 +324,7 @@ func TestV3TxnDuplicateKeys(t *testing.T) {
}, },
} }
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
tests := []struct { tests := []struct {
txnSuccess []*pb.RequestOp txnSuccess []*pb.RequestOp
@ -396,11 +397,11 @@ func TestV3TxnDuplicateKeys(t *testing.T) {
// Testv3TxnRevision tests that the transaction header revision is set as expected. // Testv3TxnRevision tests that the transaction header revision is set as expected.
func TestV3TxnRevision(t *testing.T) { func TestV3TxnRevision(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
pr := &pb.PutRequest{Key: []byte("abc"), Value: []byte("def")} pr := &pb.PutRequest{Key: []byte("abc"), Value: []byte("def")}
presp, err := kvc.Put(context.TODO(), pr) presp, err := kvc.Put(context.TODO(), pr)
if err != nil { if err != nil {
@ -447,11 +448,11 @@ func TestV3TxnRevision(t *testing.T) {
// Testv3TxnCmpHeaderRev tests that the txn header revision is set as expected // Testv3TxnCmpHeaderRev tests that the txn header revision is set as expected
// when compared to the Succeeded field in the txn response. // when compared to the Succeeded field in the txn response.
func TestV3TxnCmpHeaderRev(t *testing.T) { func TestV3TxnCmpHeaderRev(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
// Concurrently put a key with a txn comparing on it. // Concurrently put a key with a txn comparing on it.
@ -503,8 +504,8 @@ func TestV3TxnCmpHeaderRev(t *testing.T) {
// TestV3TxnRangeCompare tests range comparisons in txns // TestV3TxnRangeCompare tests range comparisons in txns
func TestV3TxnRangeCompare(t *testing.T) { func TestV3TxnRangeCompare(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
// put keys, named by expected revision // put keys, named by expected revision
@ -598,7 +599,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
}, },
} }
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
for i, tt := range tests { for i, tt := range tests {
txn := &pb.TxnRequest{} txn := &pb.TxnRequest{}
txn.Compare = append(txn.Compare, &tt.cmp) txn.Compare = append(txn.Compare, &tt.cmp)
@ -614,11 +615,11 @@ func TestV3TxnRangeCompare(t *testing.T) {
// TestV3TxnNested tests nested txns follow paths as expected. // TestV3TxnNested tests nested txns follow paths as expected.
func TestV3TxnNestedPath(t *testing.T) { func TestV3TxnNestedPath(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
cmpTrue := &pb.Compare{ cmpTrue := &pb.Compare{
Result: pb.Compare_EQUAL, Result: pb.Compare_EQUAL,
@ -667,17 +668,17 @@ func TestV3TxnNestedPath(t *testing.T) {
// TestV3PutIgnoreValue ensures that writes with ignore_value overwrites with previous key-value pair. // TestV3PutIgnoreValue ensures that writes with ignore_value overwrites with previous key-value pair.
func TestV3PutIgnoreValue(t *testing.T) { func TestV3PutIgnoreValue(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
key, val := []byte("foo"), []byte("bar") key, val := []byte("foo"), []byte("bar")
putReq := pb.PutRequest{Key: key, Value: val} putReq := pb.PutRequest{Key: key, Value: val}
// create lease // create lease
lc := toGRPC(clus.RandClient()).Lease lc := integration.ToGRPC(clus.RandClient()).Lease
lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -800,15 +801,15 @@ func TestV3PutIgnoreValue(t *testing.T) {
// TestV3PutIgnoreLease ensures that writes with ignore_lease uses previous lease for the key overwrites. // TestV3PutIgnoreLease ensures that writes with ignore_lease uses previous lease for the key overwrites.
func TestV3PutIgnoreLease(t *testing.T) { func TestV3PutIgnoreLease(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
// create lease // create lease
lc := toGRPC(clus.RandClient()).Lease lc := integration.ToGRPC(clus.RandClient()).Lease
lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -940,11 +941,11 @@ func TestV3PutIgnoreLease(t *testing.T) {
// TestV3PutMissingLease ensures that a Put on a key with a bogus lease fails. // TestV3PutMissingLease ensures that a Put on a key with a bogus lease fails.
func TestV3PutMissingLease(t *testing.T) { func TestV3PutMissingLease(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
key := []byte("foo") key := []byte("foo")
preq := &pb.PutRequest{Key: key, Lease: 123456} preq := &pb.PutRequest{Key: key, Lease: 123456}
tests := []func(){ tests := []func(){
@ -1011,7 +1012,7 @@ func TestV3PutMissingLease(t *testing.T) {
// TestV3DeleteRange tests various edge cases in the DeleteRange API. // TestV3DeleteRange tests various edge cases in the DeleteRange API.
func TestV3DeleteRange(t *testing.T) { func TestV3DeleteRange(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
tests := []struct { tests := []struct {
name string name string
@ -1069,8 +1070,8 @@ func TestV3DeleteRange(t *testing.T) {
for i, tt := range tests { for i, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
defer clus.Terminate(t) defer clus.Terminate(t)
ks := tt.keySet ks := tt.keySet
@ -1123,11 +1124,11 @@ func TestV3DeleteRange(t *testing.T) {
// TestV3TxnInvalidRange tests that invalid ranges are rejected in txns. // TestV3TxnInvalidRange tests that invalid ranges are rejected in txns.
func TestV3TxnInvalidRange(t *testing.T) { func TestV3TxnInvalidRange(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
preq := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} preq := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
@ -1166,12 +1167,12 @@ func TestV3TxnInvalidRange(t *testing.T) {
} }
func TestV3TooLargeRequest(t *testing.T) { func TestV3TooLargeRequest(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
// 2MB request value // 2MB request value
largeV := make([]byte, 2*1024*1024) largeV := make([]byte, 2*1024*1024)
@ -1185,13 +1186,13 @@ func TestV3TooLargeRequest(t *testing.T) {
// TestV3Hash tests hash. // TestV3Hash tests hash.
func TestV3Hash(t *testing.T) { func TestV3Hash(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
kvc := toGRPC(cli).KV kvc := integration.ToGRPC(cli).KV
m := toGRPC(cli).Maintenance m := integration.ToGRPC(cli).Maintenance
preq := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} preq := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
@ -1210,12 +1211,12 @@ func TestV3Hash(t *testing.T) {
// TestV3HashRestart ensures that hash stays the same after restart. // TestV3HashRestart ensures that hash stays the same after restart.
func TestV3HashRestart(t *testing.T) { func TestV3HashRestart(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.RandClient() cli := clus.RandClient()
resp, err := toGRPC(cli).Maintenance.Hash(context.Background(), &pb.HashRequest{}) resp, err := integration.ToGRPC(cli).Maintenance.Hash(context.Background(), &pb.HashRequest{})
if err != nil || resp.Hash == 0 { if err != nil || resp.Hash == 0 {
t.Fatalf("couldn't hash (%v, hash %d)", err, resp.Hash) t.Fatalf("couldn't hash (%v, hash %d)", err, resp.Hash)
} }
@ -1223,12 +1224,12 @@ func TestV3HashRestart(t *testing.T) {
clus.Members[0].Stop(t) clus.Members[0].Stop(t)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
waitForRestart(t, kvc) waitForRestart(t, kvc)
cli = clus.RandClient() cli = clus.RandClient()
resp, err = toGRPC(cli).Maintenance.Hash(context.Background(), &pb.HashRequest{}) resp, err = integration.ToGRPC(cli).Maintenance.Hash(context.Background(), &pb.HashRequest{})
if err != nil || resp.Hash == 0 { if err != nil || resp.Hash == 0 {
t.Fatalf("couldn't hash (%v, hash %d)", err, resp.Hash) t.Fatalf("couldn't hash (%v, hash %d)", err, resp.Hash)
} }
@ -1241,10 +1242,10 @@ func TestV3HashRestart(t *testing.T) {
// TestV3StorageQuotaAPI tests the V3 server respects quotas at the API layer // TestV3StorageQuotaAPI tests the V3 server respects quotas at the API layer
func TestV3StorageQuotaAPI(t *testing.T) { func TestV3StorageQuotaAPI(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
quotasize := int64(16 * os.Getpagesize()) quotasize := int64(16 * os.Getpagesize())
clus := NewClusterV3(t, &ClusterConfig{Size: 3, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
// Set a quota on one node // Set a quota on one node
clus.Members[0].QuotaBackendBytes = quotasize clus.Members[0].QuotaBackendBytes = quotasize
@ -1252,7 +1253,7 @@ func TestV3StorageQuotaAPI(t *testing.T) {
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
waitForRestart(t, kvc) waitForRestart(t, kvc)
key := []byte("abc") key := []byte("abc")
@ -1288,7 +1289,7 @@ func TestV3StorageQuotaAPI(t *testing.T) {
} }
func TestV3RangeRequest(t *testing.T) { func TestV3RangeRequest(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
tests := []struct { tests := []struct {
name string name string
@ -1508,10 +1509,10 @@ func TestV3RangeRequest(t *testing.T) {
for i, tt := range tests { for i, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
for _, k := range tt.putKeys { for _, k := range tt.putKeys {
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
req := &pb.PutRequest{Key: []byte(k), Value: []byte("bar")} req := &pb.PutRequest{Key: []byte(k), Value: []byte("bar")}
if _, err := kvc.Put(context.TODO(), req); err != nil { if _, err := kvc.Put(context.TODO(), req); err != nil {
t.Fatalf("#%d: couldn't put key (%v)", i, err) t.Fatalf("#%d: couldn't put key (%v)", i, err)
@ -1519,7 +1520,7 @@ func TestV3RangeRequest(t *testing.T) {
} }
for j, req := range tt.reqs { for j, req := range tt.reqs {
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
resp, err := kvc.Range(context.TODO(), &req) resp, err := kvc.Range(context.TODO(), &req)
if err != nil { if err != nil {
t.Errorf("#%d.%d: Range error: %v", i, j, err) t.Errorf("#%d.%d: Range error: %v", i, j, err)
@ -1550,24 +1551,24 @@ func TestV3RangeRequest(t *testing.T) {
} }
} }
func newClusterV3NoClients(t *testing.T, cfg *ClusterConfig) *ClusterV3 { func newClusterV3NoClients(t *testing.T, cfg *integration.ClusterConfig) *integration.ClusterV3 {
cfg.UseGRPC = true cfg.UseGRPC = true
clus := &ClusterV3{cluster: NewClusterByConfig(t, cfg)} clus := &integration.ClusterV3{Cluster: integration.NewClusterByConfig(t, cfg)}
clus.Launch(t) clus.Launch(t)
return clus return clus
} }
// TestTLSGRPCRejectInsecureClient checks that connection is rejected if server is TLS but not client. // TestTLSGRPCRejectInsecureClient checks that connection is rejected if server is TLS but not client.
func TestTLSGRPCRejectInsecureClient(t *testing.T) { func TestTLSGRPCRejectInsecureClient(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cfg := ClusterConfig{Size: 3, ClientTLS: &testTLSInfo} cfg := integration.ClusterConfig{Size: 3, ClientTLS: &integration.TestTLSInfo}
clus := newClusterV3NoClients(t, &cfg) clus := newClusterV3NoClients(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
// nil out TLS field so client will use an insecure connection // nil out TLS field so client will use an insecure connection
clus.Members[0].ClientTLSInfo = nil clus.Members[0].ClientTLSInfo = nil
client, err := NewClientV3(clus.Members[0]) client, err := integration.NewClientV3(clus.Members[0])
if err != nil && err != context.DeadlineExceeded { if err != nil && err != context.DeadlineExceeded {
t.Fatalf("unexpected error (%v)", err) t.Fatalf("unexpected error (%v)", err)
} else if client == nil { } else if client == nil {
@ -1582,7 +1583,7 @@ func TestTLSGRPCRejectInsecureClient(t *testing.T) {
go func() { go func() {
ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second) ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
_, perr := toGRPC(client).KV.Put(ctx, reqput) _, perr := integration.ToGRPC(client).KV.Put(ctx, reqput)
cancel() cancel()
donec <- perr donec <- perr
}() }()
@ -1594,16 +1595,16 @@ func TestTLSGRPCRejectInsecureClient(t *testing.T) {
// TestTLSGRPCRejectSecureClient checks that connection is rejected if client is TLS but not server. // TestTLSGRPCRejectSecureClient checks that connection is rejected if client is TLS but not server.
func TestTLSGRPCRejectSecureClient(t *testing.T) { func TestTLSGRPCRejectSecureClient(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cfg := ClusterConfig{Size: 3} cfg := integration.ClusterConfig{Size: 3}
clus := newClusterV3NoClients(t, &cfg) clus := newClusterV3NoClients(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
clus.Members[0].ClientTLSInfo = &testTLSInfo clus.Members[0].ClientTLSInfo = &integration.TestTLSInfo
clus.Members[0].DialOptions = []grpc.DialOption{grpc.WithBlock()} clus.Members[0].DialOptions = []grpc.DialOption{grpc.WithBlock()}
clus.Members[0].grpcURL = strings.Replace(clus.Members[0].grpcURL, "http://", "https://", 1) clus.Members[0].GrpcURL = strings.Replace(clus.Members[0].GrpcURL, "http://", "https://", 1)
client, err := NewClientV3(clus.Members[0]) client, err := integration.NewClientV3(clus.Members[0])
if client != nil || err == nil { if client != nil || err == nil {
client.Close() client.Close()
t.Fatalf("expected no client") t.Fatalf("expected no client")
@ -1614,20 +1615,20 @@ func TestTLSGRPCRejectSecureClient(t *testing.T) {
// TestTLSGRPCAcceptSecureAll checks that connection is accepted if both client and server are TLS // TestTLSGRPCAcceptSecureAll checks that connection is accepted if both client and server are TLS
func TestTLSGRPCAcceptSecureAll(t *testing.T) { func TestTLSGRPCAcceptSecureAll(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cfg := ClusterConfig{Size: 3, ClientTLS: &testTLSInfo} cfg := integration.ClusterConfig{Size: 3, ClientTLS: &integration.TestTLSInfo}
clus := newClusterV3NoClients(t, &cfg) clus := newClusterV3NoClients(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
client, err := NewClientV3(clus.Members[0]) client, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatalf("expected tls client (%v)", err) t.Fatalf("expected tls client (%v)", err)
} }
defer client.Close() defer client.Close()
reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
if _, err := toGRPC(client).KV.Put(context.TODO(), reqput); err != nil { if _, err := integration.ToGRPC(client).KV.Put(context.TODO(), reqput); err != nil {
t.Fatalf("unexpected error on put over tls (%v)", err) t.Fatalf("unexpected error on put over tls (%v)", err)
} }
} }
@ -1656,11 +1657,11 @@ func TestTLSReloadAtomicReplace(t *testing.T) {
defer os.RemoveAll(certsDirExp) defer os.RemoveAll(certsDirExp)
cloneFunc := func() transport.TLSInfo { cloneFunc := func() transport.TLSInfo {
tlsInfo, terr := copyTLSFiles(testTLSInfo, certsDir) tlsInfo, terr := copyTLSFiles(integration.TestTLSInfo, certsDir)
if terr != nil { if terr != nil {
t.Fatal(terr) t.Fatal(terr)
} }
if _, err = copyTLSFiles(testTLSInfoExpired, certsDirExp); err != nil { if _, err = copyTLSFiles(integration.TestTLSInfoExpired, certsDirExp); err != nil {
t.Fatal(err) t.Fatal(err)
} }
return tlsInfo return tlsInfo
@ -1702,19 +1703,19 @@ func TestTLSReloadCopy(t *testing.T) {
defer os.RemoveAll(certsDir) defer os.RemoveAll(certsDir)
cloneFunc := func() transport.TLSInfo { cloneFunc := func() transport.TLSInfo {
tlsInfo, terr := copyTLSFiles(testTLSInfo, certsDir) tlsInfo, terr := copyTLSFiles(integration.TestTLSInfo, certsDir)
if terr != nil { if terr != nil {
t.Fatal(terr) t.Fatal(terr)
} }
return tlsInfo return tlsInfo
} }
replaceFunc := func() { replaceFunc := func() {
if _, err = copyTLSFiles(testTLSInfoExpired, certsDir); err != nil { if _, err = copyTLSFiles(integration.TestTLSInfoExpired, certsDir); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
revertFunc := func() { revertFunc := func() {
if _, err = copyTLSFiles(testTLSInfo, certsDir); err != nil { if _, err = copyTLSFiles(integration.TestTLSInfo, certsDir); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
@ -1732,19 +1733,19 @@ func TestTLSReloadCopyIPOnly(t *testing.T) {
defer os.RemoveAll(certsDir) defer os.RemoveAll(certsDir)
cloneFunc := func() transport.TLSInfo { cloneFunc := func() transport.TLSInfo {
tlsInfo, terr := copyTLSFiles(testTLSInfoIP, certsDir) tlsInfo, terr := copyTLSFiles(integration.TestTLSInfoIP, certsDir)
if terr != nil { if terr != nil {
t.Fatal(terr) t.Fatal(terr)
} }
return tlsInfo return tlsInfo
} }
replaceFunc := func() { replaceFunc := func() {
if _, err = copyTLSFiles(testTLSInfoExpiredIP, certsDir); err != nil { if _, err = copyTLSFiles(integration.TestTLSInfoExpiredIP, certsDir); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
revertFunc := func() { revertFunc := func() {
if _, err = copyTLSFiles(testTLSInfoIP, certsDir); err != nil { if _, err = copyTLSFiles(integration.TestTLSInfoIP, certsDir); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
@ -1757,13 +1758,13 @@ func testTLSReload(
replaceFunc func(), replaceFunc func(),
revertFunc func(), revertFunc func(),
useIP bool) { useIP bool) {
BeforeTest(t) integration.BeforeTest(t)
// 1. separate copies for TLS assets modification // 1. separate copies for TLS assets modification
tlsInfo := cloneFunc() tlsInfo := cloneFunc()
// 2. start cluster with valid certs // 2. start cluster with valid certs
clus := NewClusterV3(t, &ClusterConfig{ clus := integration.NewClusterV3(t, &integration.ClusterConfig{
Size: 1, Size: 1,
PeerTLS: &tlsInfo, PeerTLS: &tlsInfo,
ClientTLS: &tlsInfo, ClientTLS: &tlsInfo,
@ -1785,7 +1786,7 @@ func testTLSReload(
t.Log(err) t.Log(err)
continue continue
} }
cli, cerr := NewClient(t, clientv3.Config{ cli, cerr := integration.NewClient(t, clientv3.Config{
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},
Endpoints: []string{clus.Members[0].GRPCURL()}, Endpoints: []string{clus.Members[0].GRPCURL()},
DialTimeout: time.Second, DialTimeout: time.Second,
@ -1820,7 +1821,7 @@ func testTLSReload(
if terr != nil { if terr != nil {
t.Fatal(terr) t.Fatal(terr)
} }
cl, cerr := NewClient(t, clientv3.Config{ cl, cerr := integration.NewClient(t, clientv3.Config{
Endpoints: []string{clus.Members[0].GRPCURL()}, Endpoints: []string{clus.Members[0].GRPCURL()},
DialTimeout: 5 * time.Second, DialTimeout: 5 * time.Second,
TLS: tls, TLS: tls,
@ -1832,46 +1833,46 @@ func testTLSReload(
} }
func TestGRPCRequireLeader(t *testing.T) { func TestGRPCRequireLeader(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cfg := ClusterConfig{Size: 3} cfg := integration.ClusterConfig{Size: 3}
clus := newClusterV3NoClients(t, &cfg) clus := newClusterV3NoClients(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
clus.Members[1].Stop(t) clus.Members[1].Stop(t)
clus.Members[2].Stop(t) clus.Members[2].Stop(t)
client, err := NewClientV3(clus.Members[0]) client, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatalf("cannot create client: %v", err) t.Fatalf("cannot create client: %v", err)
} }
defer client.Close() defer client.Close()
// wait for election timeout, then member[0] will not have a leader. // wait for election timeout, then member[0] will not have a leader.
time.Sleep(time.Duration(3*electionTicks) * tickDuration) time.Sleep(time.Duration(3*integration.ElectionTicks) * integration.TickDuration)
md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader) md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader)
ctx := metadata.NewOutgoingContext(context.Background(), md) ctx := metadata.NewOutgoingContext(context.Background(), md)
reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
if _, err := toGRPC(client).KV.Put(ctx, reqput); rpctypes.ErrorDesc(err) != rpctypes.ErrNoLeader.Error() { if _, err := integration.ToGRPC(client).KV.Put(ctx, reqput); rpctypes.ErrorDesc(err) != rpctypes.ErrNoLeader.Error() {
t.Errorf("err = %v, want %v", err, rpctypes.ErrNoLeader) t.Errorf("err = %v, want %v", err, rpctypes.ErrNoLeader)
} }
} }
func TestGRPCStreamRequireLeader(t *testing.T) { func TestGRPCStreamRequireLeader(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
cfg := ClusterConfig{Size: 3, UseBridge: true} cfg := integration.ClusterConfig{Size: 3, UseBridge: true}
clus := newClusterV3NoClients(t, &cfg) clus := newClusterV3NoClients(t, &cfg)
defer clus.Terminate(t) defer clus.Terminate(t)
client, err := NewClientV3(clus.Members[0]) client, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatalf("failed to create client (%v)", err) t.Fatalf("failed to create client (%v)", err)
} }
defer client.Close() defer client.Close()
wAPI := toGRPC(client).Watch wAPI := integration.ToGRPC(client).Watch
md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader) md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader)
ctx := metadata.NewOutgoingContext(context.Background(), md) ctx := metadata.NewOutgoingContext(context.Background(), md)
wStream, err := wAPI.Watch(ctx) wStream, err := wAPI.Watch(ctx)
@ -1901,8 +1902,8 @@ func TestGRPCStreamRequireLeader(t *testing.T) {
clus.Members[1].Restart(t) clus.Members[1].Restart(t)
clus.Members[2].Restart(t) clus.Members[2].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
time.Sleep(time.Duration(2*electionTicks) * tickDuration) time.Sleep(time.Duration(2*integration.ElectionTicks) * integration.TickDuration)
// new stream should also be OK now after we restarted the other members // new stream should also be OK now after we restarted the other members
wStream, err = wAPI.Watch(ctx) wStream, err = wAPI.Watch(ctx)
@ -1922,7 +1923,7 @@ func TestGRPCStreamRequireLeader(t *testing.T) {
// TestV3LargeRequests ensures that configurable MaxRequestBytes works as intended. // TestV3LargeRequests ensures that configurable MaxRequestBytes works as intended.
func TestV3LargeRequests(t *testing.T) { func TestV3LargeRequests(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
tests := []struct { tests := []struct {
maxRequestBytes uint maxRequestBytes uint
valueSize int valueSize int
@ -1936,9 +1937,9 @@ func TestV3LargeRequests(t *testing.T) {
} }
for i, test := range tests { for i, test := range tests {
t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) { t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
clus := NewClusterV3(t, &ClusterConfig{Size: 1, MaxRequestBytes: test.maxRequestBytes}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, MaxRequestBytes: test.maxRequestBytes})
defer clus.Terminate(t) defer clus.Terminate(t)
kvcli := toGRPC(clus.Client(0)).KV kvcli := integration.ToGRPC(clus.Client(0)).KV
reqput := &pb.PutRequest{Key: []byte("foo"), Value: make([]byte, test.valueSize)} reqput := &pb.PutRequest{Key: []byte("foo"), Value: make([]byte, test.valueSize)}
_, err := kvcli.Put(context.TODO(), reqput) _, err := kvcli.Put(context.TODO(), reqput)
if !eqErrGRPC(err, test.expectError) { if !eqErrGRPC(err, test.expectError) {

5
tests/integration/v3_health_test.go
View File

@ -18,13 +18,14 @@ import (
"context" "context"
"testing" "testing"
"go.etcd.io/etcd/tests/v3/framework/integration"
healthpb "google.golang.org/grpc/health/grpc_health_v1" healthpb "google.golang.org/grpc/health/grpc_health_v1"
) )
func TestHealthCheck(t *testing.T) { func TestHealthCheck(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := healthpb.NewHealthClient(clus.RandClient().ActiveConnection()) cli := healthpb.NewHealthClient(clus.RandClient().ActiveConnection())

5
tests/integration/v3_kv_test.go
View File

@ -6,13 +6,14 @@ import (
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/namespace" "go.etcd.io/etcd/client/v3/namespace"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestKVWithEmptyValue ensures that a get/delete with an empty value, and with WithFromKey/WithPrefix function will return an empty error. // TestKVWithEmptyValue ensures that a get/delete with an empty value, and with WithFromKey/WithPrefix function will return an empty error.
func TestKVWithEmptyValue(t *testing.T) { func TestKVWithEmptyValue(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
client := clus.RandClient() client := clus.RandClient()

59
tests/integration/v3_leadership_test.go
View File

@ -23,6 +23,7 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/tests/v3/framework/integration"
"golang.org/x/sync/errgroup" "golang.org/x/sync/errgroup"
) )
@ -30,13 +31,13 @@ func TestMoveLeader(t *testing.T) { testMoveLeader(t, true) }
func TestMoveLeaderService(t *testing.T) { testMoveLeader(t, false) } func TestMoveLeaderService(t *testing.T) { testMoveLeader(t, false) }
func testMoveLeader(t *testing.T, auto bool) { func testMoveLeader(t *testing.T, auto bool) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
oldLeadIdx := clus.WaitLeader(t) oldLeadIdx := clus.WaitLeader(t)
oldLeadID := uint64(clus.Members[oldLeadIdx].s.ID()) oldLeadID := uint64(clus.Members[oldLeadIdx].Server.ID())
// ensure followers go through leader transition while leadership transfer // ensure followers go through leader transition while leadership transfer
idc := make(chan uint64) idc := make(chan uint64)
@ -45,23 +46,23 @@ func testMoveLeader(t *testing.T, auto bool) {
for i := range clus.Members { for i := range clus.Members {
if oldLeadIdx != i { if oldLeadIdx != i {
go func(m *member) { go func(m *integration.Member) {
select { select {
case idc <- checkLeaderTransition(m, oldLeadID): case idc <- integration.CheckLeaderTransition(m, oldLeadID):
case <-stopc: case <-stopc:
} }
}(clus.Members[i]) }(clus.Members[i])
} }
} }
target := uint64(clus.Members[(oldLeadIdx+1)%3].s.ID()) target := uint64(clus.Members[(oldLeadIdx+1)%3].Server.ID())
if auto { if auto {
err := clus.Members[oldLeadIdx].s.TransferLeadership() err := clus.Members[oldLeadIdx].Server.TransferLeadership()
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
} else { } else {
mvc := toGRPC(clus.Client(oldLeadIdx)).Maintenance mvc := integration.ToGRPC(clus.Client(oldLeadIdx)).Maintenance
_, err := mvc.MoveLeader(context.TODO(), &pb.MoveLeaderRequest{TargetID: target}) _, err := mvc.MoveLeader(context.TODO(), &pb.MoveLeaderRequest{TargetID: target})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -98,17 +99,17 @@ func testMoveLeader(t *testing.T, auto bool) {
// TestMoveLeaderError ensures that request to non-leader fail. // TestMoveLeaderError ensures that request to non-leader fail.
func TestMoveLeaderError(t *testing.T) { func TestMoveLeaderError(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
oldLeadIdx := clus.WaitLeader(t) oldLeadIdx := clus.WaitLeader(t)
followerIdx := (oldLeadIdx + 1) % 3 followerIdx := (oldLeadIdx + 1) % 3
target := uint64(clus.Members[(oldLeadIdx+2)%3].s.ID()) target := uint64(clus.Members[(oldLeadIdx+2)%3].Server.ID())
mvc := toGRPC(clus.Client(followerIdx)).Maintenance mvc := integration.ToGRPC(clus.Client(followerIdx)).Maintenance
_, err := mvc.MoveLeader(context.TODO(), &pb.MoveLeaderRequest{TargetID: target}) _, err := mvc.MoveLeader(context.TODO(), &pb.MoveLeaderRequest{TargetID: target})
if !eqErrGRPC(err, rpctypes.ErrGRPCNotLeader) { if !eqErrGRPC(err, rpctypes.ErrGRPCNotLeader) {
t.Errorf("err = %v, want %v", err, rpctypes.ErrGRPCNotLeader) t.Errorf("err = %v, want %v", err, rpctypes.ErrGRPCNotLeader)
@ -117,9 +118,9 @@ func TestMoveLeaderError(t *testing.T) {
// TestMoveLeaderToLearnerError ensures that leader transfer to learner member will fail. // TestMoveLeaderToLearnerError ensures that leader transfer to learner member will fail.
func TestMoveLeaderToLearnerError(t *testing.T) { func TestMoveLeaderToLearnerError(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// we have to add and launch learner member after initial cluster was created, because // we have to add and launch learner member after initial cluster was created, because
@ -128,10 +129,10 @@ func TestMoveLeaderToLearnerError(t *testing.T) {
learners, err := clus.GetLearnerMembers() learners, err := clus.GetLearnerMembers()
if err != nil { if err != nil {
t.Fatalf("failed to get the learner members in cluster: %v", err) t.Fatalf("failed to get the learner members in Cluster: %v", err)
} }
if len(learners) != 1 { if len(learners) != 1 {
t.Fatalf("added 1 learner to cluster, got %d", len(learners)) t.Fatalf("added 1 learner to Cluster, got %d", len(learners))
} }
learnerID := learners[0].ID learnerID := learners[0].ID
@ -150,19 +151,19 @@ func TestMoveLeaderToLearnerError(t *testing.T) {
// TestTransferLeadershipWithLearner ensures TransferLeadership does not timeout due to learner is // TestTransferLeadershipWithLearner ensures TransferLeadership does not timeout due to learner is
// automatically picked by leader as transferee. // automatically picked by leader as transferee.
func TestTransferLeadershipWithLearner(t *testing.T) { func TestTransferLeadershipWithLearner(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
clus.AddAndLaunchLearnerMember(t) clus.AddAndLaunchLearnerMember(t)
learners, err := clus.GetLearnerMembers() learners, err := clus.GetLearnerMembers()
if err != nil { if err != nil {
t.Fatalf("failed to get the learner members in cluster: %v", err) t.Fatalf("failed to get the learner members in Cluster: %v", err)
} }
if len(learners) != 1 { if len(learners) != 1 {
t.Fatalf("added 1 learner to cluster, got %d", len(learners)) t.Fatalf("added 1 learner to Cluster, got %d", len(learners))
} }
leaderIdx := clus.WaitLeader(t) leaderIdx := clus.WaitLeader(t)
@ -170,7 +171,7 @@ func TestTransferLeadershipWithLearner(t *testing.T) {
go func() { go func() {
// note that this cluster has 1 leader and 1 learner. TransferLeadership should return nil. // note that this cluster has 1 leader and 1 learner. TransferLeadership should return nil.
// Leadership transfer is skipped in cluster with 1 voting member. // Leadership transfer is skipped in cluster with 1 voting member.
errCh <- clus.Members[leaderIdx].s.TransferLeadership() errCh <- clus.Members[leaderIdx].Server.TransferLeadership()
}() }()
select { select {
case err := <-errCh: case err := <-errCh:
@ -183,10 +184,10 @@ func TestTransferLeadershipWithLearner(t *testing.T) {
} }
func TestFirstCommitNotification(t *testing.T) { func TestFirstCommitNotification(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
ctx := context.Background() ctx := context.Background()
clusterSize := 3 clusterSize := 3
cluster := NewClusterV3(t, &ClusterConfig{Size: clusterSize}) cluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: clusterSize})
defer cluster.Terminate(t) defer cluster.Terminate(t)
oldLeaderIdx := cluster.WaitLeader(t) oldLeaderIdx := cluster.WaitLeader(t)
@ -197,7 +198,7 @@ func TestFirstCommitNotification(t *testing.T) {
notifiers := make(map[int]<-chan struct{}, clusterSize) notifiers := make(map[int]<-chan struct{}, clusterSize)
for i, clusterMember := range cluster.Members { for i, clusterMember := range cluster.Members {
notifiers[i] = clusterMember.s.FirstCommitInTermNotify() notifiers[i] = clusterMember.Server.FirstCommitInTermNotify()
} }
_, err := oldLeaderClient.MoveLeader(context.Background(), newLeaderId) _, err := oldLeaderClient.MoveLeader(context.Background(), newLeaderId)
@ -215,7 +216,7 @@ func TestFirstCommitNotification(t *testing.T) {
} }
// It's guaranteed now that leader contains the 'foo'->'bar' index entry. // It's guaranteed now that leader contains the 'foo'->'bar' index entry.
leaderAppliedIndex := cluster.Members[newLeaderIdx].s.AppliedIndex() leaderAppliedIndex := cluster.Members[newLeaderIdx].Server.AppliedIndex()
ctx, cancel := context.WithTimeout(ctx, 5*time.Second) ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel() defer cancel()
@ -238,13 +239,13 @@ func TestFirstCommitNotification(t *testing.T) {
func checkFirstCommitNotification( func checkFirstCommitNotification(
ctx context.Context, ctx context.Context,
t testing.TB, t testing.TB,
member *member, member *integration.Member,
leaderAppliedIndex uint64, leaderAppliedIndex uint64,
notifier <-chan struct{}, notifier <-chan struct{},
) error { ) error {
// wait until server applies all the changes of leader // wait until server applies all the changes of leader
for member.s.AppliedIndex() < leaderAppliedIndex { for member.Server.AppliedIndex() < leaderAppliedIndex {
t.Logf("member.s.AppliedIndex():%v <= leaderAppliedIndex:%v", member.s.AppliedIndex(), leaderAppliedIndex) t.Logf("member.Server.AppliedIndex():%v <= leaderAppliedIndex:%v", member.Server.AppliedIndex(), leaderAppliedIndex)
select { select {
case <-ctx.Done(): case <-ctx.Done():
return ctx.Err() return ctx.Err()
@ -262,7 +263,7 @@ func checkFirstCommitNotification(
) )
} }
default: default:
t.Logf("member.s.AppliedIndex():%v >= leaderAppliedIndex:%v", member.s.AppliedIndex(), leaderAppliedIndex) t.Logf("member.Server.AppliedIndex():%v >= leaderAppliedIndex:%v", member.Server.AppliedIndex(), leaderAppliedIndex)
return fmt.Errorf( return fmt.Errorf(
"notification was not triggered, member ID: %d", "notification was not triggered, member ID: %d",
member.ID(), member.ID(),

205
tests/integration/v3_lease_test.go
View File

@ -24,6 +24,7 @@ import (
"go.etcd.io/etcd/api/v3/mvccpb" "go.etcd.io/etcd/api/v3/mvccpb"
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes" "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
"go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata" "google.golang.org/grpc/metadata"
@ -34,13 +35,13 @@ import (
// to the primary lessor, refresh the leases and start to manage leases. // to the primary lessor, refresh the leases and start to manage leases.
// TODO: use customized clock to make this test go faster? // TODO: use customized clock to make this test go faster?
func TestV3LeasePromote(t *testing.T) { func TestV3LeasePromote(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
// create lease // create lease
lresp, err := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 3}) lresp, err := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 3})
ttl := time.Duration(lresp.TTL) * time.Second ttl := time.Duration(lresp.TTL) * time.Second
afterGrant := time.Now() afterGrant := time.Now()
if err != nil { if err != nil {
@ -54,19 +55,19 @@ func TestV3LeasePromote(t *testing.T) {
time.Sleep(time.Until(afterGrant.Add(ttl - time.Second))) time.Sleep(time.Until(afterGrant.Add(ttl - time.Second)))
// kill the current leader, all leases should be refreshed. // kill the current leader, all leases should be refreshed.
toStop := clus.waitLeader(t, clus.Members) toStop := clus.WaitMembersForLeader(t, clus.Members)
beforeStop := time.Now() beforeStop := time.Now()
clus.Members[toStop].Stop(t) clus.Members[toStop].Stop(t)
var toWait []*member var toWait []*integration.Member
for i, m := range clus.Members { for i, m := range clus.Members {
if i != toStop { if i != toStop {
toWait = append(toWait, m) toWait = append(toWait, m)
} }
} }
clus.waitLeader(t, toWait) clus.WaitMembersForLeader(t, toWait)
clus.Members[toStop].Restart(t) clus.Members[toStop].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
afterReelect := time.Now() afterReelect := time.Now()
// ensure lease is refreshed by waiting for a "long" time. // ensure lease is refreshed by waiting for a "long" time.
@ -96,9 +97,9 @@ func TestV3LeasePromote(t *testing.T) {
// TestV3LeaseRevoke ensures a key is deleted once its lease is revoked. // TestV3LeaseRevoke ensures a key is deleted once its lease is revoked.
func TestV3LeaseRevoke(t *testing.T) { func TestV3LeaseRevoke(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testLeaseRemoveLeasedKey(t, func(clus *ClusterV3, leaseID int64) error { testLeaseRemoveLeasedKey(t, func(clus *integration.ClusterV3, leaseID int64) error {
lc := toGRPC(clus.RandClient()).Lease lc := integration.ToGRPC(clus.RandClient()).Lease
_, err := lc.LeaseRevoke(context.TODO(), &pb.LeaseRevokeRequest{ID: leaseID}) _, err := lc.LeaseRevoke(context.TODO(), &pb.LeaseRevokeRequest{ID: leaseID})
return err return err
}) })
@ -106,12 +107,12 @@ func TestV3LeaseRevoke(t *testing.T) {
// TestV3LeaseGrantById ensures leases may be created by a given id. // TestV3LeaseGrantById ensures leases may be created by a given id.
func TestV3LeaseGrantByID(t *testing.T) { func TestV3LeaseGrantByID(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// create fixed lease // create fixed lease
lresp, err := toGRPC(clus.RandClient()).Lease.LeaseGrant( lresp, err := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(
context.TODO(), context.TODO(),
&pb.LeaseGrantRequest{ID: 1, TTL: 1}) &pb.LeaseGrantRequest{ID: 1, TTL: 1})
if err != nil { if err != nil {
@ -122,7 +123,7 @@ func TestV3LeaseGrantByID(t *testing.T) {
} }
// create duplicate fixed lease // create duplicate fixed lease
_, err = toGRPC(clus.RandClient()).Lease.LeaseGrant( _, err = integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(
context.TODO(), context.TODO(),
&pb.LeaseGrantRequest{ID: 1, TTL: 1}) &pb.LeaseGrantRequest{ID: 1, TTL: 1})
if !eqErrGRPC(err, rpctypes.ErrGRPCLeaseExist) { if !eqErrGRPC(err, rpctypes.ErrGRPCLeaseExist) {
@ -130,7 +131,7 @@ func TestV3LeaseGrantByID(t *testing.T) {
} }
// create fresh fixed lease // create fresh fixed lease
lresp, err = toGRPC(clus.RandClient()).Lease.LeaseGrant( lresp, err = integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(
context.TODO(), context.TODO(),
&pb.LeaseGrantRequest{ID: 2, TTL: 1}) &pb.LeaseGrantRequest{ID: 2, TTL: 1})
if err != nil { if err != nil {
@ -143,13 +144,13 @@ func TestV3LeaseGrantByID(t *testing.T) {
// TestV3LeaseExpire ensures a key is deleted once a key expires. // TestV3LeaseExpire ensures a key is deleted once a key expires.
func TestV3LeaseExpire(t *testing.T) { func TestV3LeaseExpire(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testLeaseRemoveLeasedKey(t, func(clus *ClusterV3, leaseID int64) error { testLeaseRemoveLeasedKey(t, func(clus *integration.ClusterV3, leaseID int64) error {
// let lease lapse; wait for deleted key // let lease lapse; wait for deleted key
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
defer cancel() defer cancel()
wStream, err := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, err := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -195,9 +196,9 @@ func TestV3LeaseExpire(t *testing.T) {
// TestV3LeaseKeepAlive ensures keepalive keeps the lease alive. // TestV3LeaseKeepAlive ensures keepalive keeps the lease alive.
func TestV3LeaseKeepAlive(t *testing.T) { func TestV3LeaseKeepAlive(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testLeaseRemoveLeasedKey(t, func(clus *ClusterV3, leaseID int64) error { testLeaseRemoveLeasedKey(t, func(clus *integration.ClusterV3, leaseID int64) error {
lc := toGRPC(clus.RandClient()).Lease lc := integration.ToGRPC(clus.RandClient()).Lease
lreq := &pb.LeaseKeepAliveRequest{ID: leaseID} lreq := &pb.LeaseKeepAliveRequest{ID: leaseID}
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
defer cancel() defer cancel()
@ -229,11 +230,11 @@ func TestV3LeaseKeepAlive(t *testing.T) {
// TestV3LeaseCheckpoint ensures a lease checkpoint results in a remaining TTL being persisted // TestV3LeaseCheckpoint ensures a lease checkpoint results in a remaining TTL being persisted
// across leader elections. // across leader elections.
func TestV3LeaseCheckpoint(t *testing.T) { func TestV3LeaseCheckpoint(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
var ttl int64 = 300 var ttl int64 = 300
leaseInterval := 2 * time.Second leaseInterval := 2 * time.Second
clus := NewClusterV3(t, &ClusterConfig{ clus := integration.NewClusterV3(t, &integration.ClusterConfig{
Size: 3, Size: 3,
EnableLeaseCheckpoint: true, EnableLeaseCheckpoint: true,
LeaseCheckpointInterval: leaseInterval, LeaseCheckpointInterval: leaseInterval,
@ -244,7 +245,7 @@ func TestV3LeaseCheckpoint(t *testing.T) {
// create lease // create lease
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
defer cancel() defer cancel()
c := toGRPC(clus.RandClient()) c := integration.ToGRPC(clus.RandClient())
lresp, err := c.Lease.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: ttl}) lresp, err := c.Lease.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: ttl})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -257,10 +258,10 @@ func TestV3LeaseCheckpoint(t *testing.T) {
leaderId := clus.WaitLeader(t) leaderId := clus.WaitLeader(t)
leader := clus.Members[leaderId] leader := clus.Members[leaderId]
leader.Stop(t) leader.Stop(t)
time.Sleep(time.Duration(3*electionTicks) * tickDuration) time.Sleep(time.Duration(3*integration.ElectionTicks) * integration.TickDuration)
leader.Restart(t) leader.Restart(t)
newLeaderId := clus.WaitLeader(t) newLeaderId := clus.WaitLeader(t)
c2 := toGRPC(clus.Client(newLeaderId)) c2 := integration.ToGRPC(clus.Client(newLeaderId))
time.Sleep(250 * time.Millisecond) time.Sleep(250 * time.Millisecond)
@ -284,14 +285,14 @@ func TestV3LeaseCheckpoint(t *testing.T) {
// TestV3LeaseExists creates a lease on a random client and confirms it exists in the cluster. // TestV3LeaseExists creates a lease on a random client and confirms it exists in the cluster.
func TestV3LeaseExists(t *testing.T) { func TestV3LeaseExists(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
// create lease // create lease
ctx0, cancel0 := context.WithCancel(context.Background()) ctx0, cancel0 := context.WithCancel(context.Background())
defer cancel0() defer cancel0()
lresp, err := toGRPC(clus.RandClient()).Lease.LeaseGrant( lresp, err := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(
ctx0, ctx0,
&pb.LeaseGrantRequest{TTL: 30}) &pb.LeaseGrantRequest{TTL: 30})
if err != nil { if err != nil {
@ -308,8 +309,8 @@ func TestV3LeaseExists(t *testing.T) {
// TestV3LeaseLeases creates leases and confirms list RPC fetches created ones. // TestV3LeaseLeases creates leases and confirms list RPC fetches created ones.
func TestV3LeaseLeases(t *testing.T) { func TestV3LeaseLeases(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx0, cancel0 := context.WithCancel(context.Background()) ctx0, cancel0 := context.WithCancel(context.Background())
@ -318,7 +319,7 @@ func TestV3LeaseLeases(t *testing.T) {
// create leases // create leases
ids := []int64{} ids := []int64{}
for i := 0; i < 5; i++ { for i := 0; i < 5; i++ {
lresp, err := toGRPC(clus.RandClient()).Lease.LeaseGrant( lresp, err := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(
ctx0, ctx0,
&pb.LeaseGrantRequest{TTL: 30}) &pb.LeaseGrantRequest{TTL: 30})
if err != nil { if err != nil {
@ -330,7 +331,7 @@ func TestV3LeaseLeases(t *testing.T) {
ids = append(ids, lresp.ID) ids = append(ids, lresp.ID)
} }
lresp, err := toGRPC(clus.RandClient()).Lease.LeaseLeases( lresp, err := integration.ToGRPC(clus.RandClient()).Lease.LeaseLeases(
context.Background(), context.Background(),
&pb.LeaseLeasesRequest{}) &pb.LeaseLeasesRequest{})
if err != nil { if err != nil {
@ -358,8 +359,8 @@ func TestV3LeaseTimeToLiveStress(t *testing.T) {
} }
func testLeaseStress(t *testing.T, stresser func(context.Context, pb.LeaseClient) error) { func testLeaseStress(t *testing.T, stresser func(context.Context, pb.LeaseClient) error) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@ -368,7 +369,7 @@ func testLeaseStress(t *testing.T, stresser func(context.Context, pb.LeaseClient
for i := 0; i < 30; i++ { for i := 0; i < 30; i++ {
for j := 0; j < 3; j++ { for j := 0; j < 3; j++ {
go func(i int) { errc <- stresser(ctx, toGRPC(clus.Client(i)).Lease) }(j) go func(i int) { errc <- stresser(ctx, integration.ToGRPC(clus.Client(i)).Lease) }(j)
} }
} }
@ -429,8 +430,8 @@ func stressLeaseTimeToLive(tctx context.Context, lc pb.LeaseClient) (reterr erro
} }
func TestV3PutOnNonExistLease(t *testing.T) { func TestV3PutOnNonExistLease(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
@ -438,7 +439,7 @@ func TestV3PutOnNonExistLease(t *testing.T) {
badLeaseID := int64(0x12345678) badLeaseID := int64(0x12345678)
putr := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar"), Lease: badLeaseID} putr := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar"), Lease: badLeaseID}
_, err := toGRPC(clus.RandClient()).KV.Put(ctx, putr) _, err := integration.ToGRPC(clus.RandClient()).KV.Put(ctx, putr)
if !eqErrGRPC(err, rpctypes.ErrGRPCLeaseNotFound) { if !eqErrGRPC(err, rpctypes.ErrGRPCLeaseNotFound) {
t.Errorf("err = %v, want %v", err, rpctypes.ErrGRPCLeaseNotFound) t.Errorf("err = %v, want %v", err, rpctypes.ErrGRPCLeaseNotFound)
} }
@ -447,13 +448,13 @@ func TestV3PutOnNonExistLease(t *testing.T) {
// TestV3GetNonExistLease ensures client retrieving nonexistent lease on a follower doesn't result node panic // TestV3GetNonExistLease ensures client retrieving nonexistent lease on a follower doesn't result node panic
// related issue https://github.com/etcd-io/etcd/issues/6537 // related issue https://github.com/etcd-io/etcd/issues/6537
func TestV3GetNonExistLease(t *testing.T) { func TestV3GetNonExistLease(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
defer cancel() defer cancel()
lc := toGRPC(clus.RandClient()).Lease lc := integration.ToGRPC(clus.RandClient()).Lease
lresp, err := lc.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: 10}) lresp, err := lc.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: 10})
if err != nil { if err != nil {
t.Errorf("failed to create lease %v", err) t.Errorf("failed to create lease %v", err)
@ -468,12 +469,12 @@ func TestV3GetNonExistLease(t *testing.T) {
Keys: true, Keys: true,
} }
for _, client := range clus.clients { for _, client := range clus.Clients {
// quorum-read to ensure revoke completes before TimeToLive // quorum-read to ensure revoke completes before TimeToLive
if _, err := toGRPC(client).KV.Range(ctx, &pb.RangeRequest{Key: []byte("_")}); err != nil { if _, err := integration.ToGRPC(client).KV.Range(ctx, &pb.RangeRequest{Key: []byte("_")}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
resp, err := toGRPC(client).Lease.LeaseTimeToLive(ctx, leaseTTLr) resp, err := integration.ToGRPC(client).Lease.LeaseTimeToLive(ctx, leaseTTLr)
if err != nil { if err != nil {
t.Fatalf("expected non nil error, but go %v", err) t.Fatalf("expected non nil error, but go %v", err)
} }
@ -485,8 +486,8 @@ func TestV3GetNonExistLease(t *testing.T) {
// TestV3LeaseSwitch tests a key can be switched from one lease to another. // TestV3LeaseSwitch tests a key can be switched from one lease to another.
func TestV3LeaseSwitch(t *testing.T) { func TestV3LeaseSwitch(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
key := "foo" key := "foo"
@ -494,34 +495,34 @@ func TestV3LeaseSwitch(t *testing.T) {
// create lease // create lease
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
defer cancel() defer cancel()
lresp1, err1 := toGRPC(clus.RandClient()).Lease.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: 30}) lresp1, err1 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: 30})
if err1 != nil { if err1 != nil {
t.Fatal(err1) t.Fatal(err1)
} }
lresp2, err2 := toGRPC(clus.RandClient()).Lease.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: 30}) lresp2, err2 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(ctx, &pb.LeaseGrantRequest{TTL: 30})
if err2 != nil { if err2 != nil {
t.Fatal(err2) t.Fatal(err2)
} }
// attach key on lease1 then switch it to lease2 // attach key on lease1 then switch it to lease2
put1 := &pb.PutRequest{Key: []byte(key), Lease: lresp1.ID} put1 := &pb.PutRequest{Key: []byte(key), Lease: lresp1.ID}
_, err := toGRPC(clus.RandClient()).KV.Put(ctx, put1) _, err := integration.ToGRPC(clus.RandClient()).KV.Put(ctx, put1)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
put2 := &pb.PutRequest{Key: []byte(key), Lease: lresp2.ID} put2 := &pb.PutRequest{Key: []byte(key), Lease: lresp2.ID}
_, err = toGRPC(clus.RandClient()).KV.Put(ctx, put2) _, err = integration.ToGRPC(clus.RandClient()).KV.Put(ctx, put2)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
// revoke lease1 should not remove key // revoke lease1 should not remove key
_, err = toGRPC(clus.RandClient()).Lease.LeaseRevoke(ctx, &pb.LeaseRevokeRequest{ID: lresp1.ID}) _, err = integration.ToGRPC(clus.RandClient()).Lease.LeaseRevoke(ctx, &pb.LeaseRevokeRequest{ID: lresp1.ID})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
rreq := &pb.RangeRequest{Key: []byte("foo")} rreq := &pb.RangeRequest{Key: []byte("foo")}
rresp, err := toGRPC(clus.RandClient()).KV.Range(context.TODO(), rreq) rresp, err := integration.ToGRPC(clus.RandClient()).KV.Range(context.TODO(), rreq)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -530,11 +531,11 @@ func TestV3LeaseSwitch(t *testing.T) {
} }
// revoke lease2 should remove key // revoke lease2 should remove key
_, err = toGRPC(clus.RandClient()).Lease.LeaseRevoke(ctx, &pb.LeaseRevokeRequest{ID: lresp2.ID}) _, err = integration.ToGRPC(clus.RandClient()).Lease.LeaseRevoke(ctx, &pb.LeaseRevokeRequest{ID: lresp2.ID})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
rresp, err = toGRPC(clus.RandClient()).KV.Range(context.TODO(), rreq) rresp, err = integration.ToGRPC(clus.RandClient()).KV.Range(context.TODO(), rreq)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -547,14 +548,14 @@ func TestV3LeaseSwitch(t *testing.T) {
// election timeout after it loses its quorum. And the new leader extends the TTL of // election timeout after it loses its quorum. And the new leader extends the TTL of
// the lease to at least TTL + election timeout. // the lease to at least TTL + election timeout.
func TestV3LeaseFailover(t *testing.T) { func TestV3LeaseFailover(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
toIsolate := clus.waitLeader(t, clus.Members) toIsolate := clus.WaitMembersForLeader(t, clus.Members)
lc := toGRPC(clus.Client(toIsolate)).Lease lc := integration.ToGRPC(clus.Client(toIsolate)).Lease
// create lease // create lease
lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 5}) lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 5})
@ -595,7 +596,7 @@ func TestV3LeaseFailover(t *testing.T) {
} }
clus.Members[toIsolate].Resume() clus.Members[toIsolate].Resume()
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
// lease should not expire at the last received expire deadline. // lease should not expire at the last received expire deadline.
time.Sleep(time.Until(expectedExp) - 500*time.Millisecond) time.Sleep(time.Until(expectedExp) - 500*time.Millisecond)
@ -608,12 +609,12 @@ func TestV3LeaseFailover(t *testing.T) {
// TestV3LeaseRequireLeader ensures that a Recv will get a leader // TestV3LeaseRequireLeader ensures that a Recv will get a leader
// loss error if there is no leader. // loss error if there is no leader.
func TestV3LeaseRequireLeader(t *testing.T) { func TestV3LeaseRequireLeader(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
lc := toGRPC(clus.Client(0)).Lease lc := integration.ToGRPC(clus.Client(0)).Lease
clus.Members[1].Stop(t) clus.Members[1].Stop(t)
clus.Members[2].Stop(t) clus.Members[2].Stop(t)
@ -648,13 +649,13 @@ const fiveMinTTL int64 = 300
// TestV3LeaseRecoverAndRevoke ensures that revoking a lease after restart deletes the attached key. // TestV3LeaseRecoverAndRevoke ensures that revoking a lease after restart deletes the attached key.
func TestV3LeaseRecoverAndRevoke(t *testing.T) { func TestV3LeaseRecoverAndRevoke(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
lsc := toGRPC(clus.Client(0)).Lease lsc := integration.ToGRPC(clus.Client(0)).Lease
lresp, err := lsc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: fiveMinTTL}) lresp, err := lsc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: fiveMinTTL})
if err != nil { if err != nil {
@ -671,16 +672,16 @@ func TestV3LeaseRecoverAndRevoke(t *testing.T) {
// restart server and ensure lease still exists // restart server and ensure lease still exists
clus.Members[0].Stop(t) clus.Members[0].Stop(t)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
// overwrite old client with newly dialed connection // overwrite old client with newly dialed connection
// otherwise, error with "grpc: RPC failed fast due to transport failure" // otherwise, error with "grpc: RPC failed fast due to transport failure"
nc, err := NewClientV3(clus.Members[0]) nc, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
kvc = toGRPC(nc).KV kvc = integration.ToGRPC(nc).KV
lsc = toGRPC(nc).Lease lsc = integration.ToGRPC(nc).Lease
defer nc.Close() defer nc.Close()
// revoke should delete the key // revoke should delete the key
@ -699,13 +700,13 @@ func TestV3LeaseRecoverAndRevoke(t *testing.T) {
// TestV3LeaseRevokeAndRecover ensures that revoked key stays deleted after restart. // TestV3LeaseRevokeAndRecover ensures that revoked key stays deleted after restart.
func TestV3LeaseRevokeAndRecover(t *testing.T) { func TestV3LeaseRevokeAndRecover(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
lsc := toGRPC(clus.Client(0)).Lease lsc := integration.ToGRPC(clus.Client(0)).Lease
lresp, err := lsc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: fiveMinTTL}) lresp, err := lsc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: fiveMinTTL})
if err != nil { if err != nil {
@ -728,15 +729,15 @@ func TestV3LeaseRevokeAndRecover(t *testing.T) {
// restart server and ensure revoked key doesn't exist // restart server and ensure revoked key doesn't exist
clus.Members[0].Stop(t) clus.Members[0].Stop(t)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
// overwrite old client with newly dialed connection // overwrite old client with newly dialed connection
// otherwise, error with "grpc: RPC failed fast due to transport failure" // otherwise, error with "grpc: RPC failed fast due to transport failure"
nc, err := NewClientV3(clus.Members[0]) nc, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
kvc = toGRPC(nc).KV kvc = integration.ToGRPC(nc).KV
defer nc.Close() defer nc.Close()
rresp, err := kvc.Range(context.TODO(), &pb.RangeRequest{Key: []byte("foo")}) rresp, err := kvc.Range(context.TODO(), &pb.RangeRequest{Key: []byte("foo")})
@ -751,13 +752,13 @@ func TestV3LeaseRevokeAndRecover(t *testing.T) {
// TestV3LeaseRecoverKeyWithDetachedLease ensures that revoking a detached lease after restart // TestV3LeaseRecoverKeyWithDetachedLease ensures that revoking a detached lease after restart
// does not delete the key. // does not delete the key.
func TestV3LeaseRecoverKeyWithDetachedLease(t *testing.T) { func TestV3LeaseRecoverKeyWithDetachedLease(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
lsc := toGRPC(clus.Client(0)).Lease lsc := integration.ToGRPC(clus.Client(0)).Lease
lresp, err := lsc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: fiveMinTTL}) lresp, err := lsc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: fiveMinTTL})
if err != nil { if err != nil {
@ -780,16 +781,16 @@ func TestV3LeaseRecoverKeyWithDetachedLease(t *testing.T) {
// restart server and ensure lease still exists // restart server and ensure lease still exists
clus.Members[0].Stop(t) clus.Members[0].Stop(t)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
// overwrite old client with newly dialed connection // overwrite old client with newly dialed connection
// otherwise, error with "grpc: RPC failed fast due to transport failure" // otherwise, error with "grpc: RPC failed fast due to transport failure"
nc, err := NewClientV3(clus.Members[0]) nc, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
kvc = toGRPC(nc).KV kvc = integration.ToGRPC(nc).KV
lsc = toGRPC(nc).Lease lsc = integration.ToGRPC(nc).Lease
defer nc.Close() defer nc.Close()
// revoke the detached lease // revoke the detached lease
@ -807,13 +808,13 @@ func TestV3LeaseRecoverKeyWithDetachedLease(t *testing.T) {
} }
func TestV3LeaseRecoverKeyWithMutipleLease(t *testing.T) { func TestV3LeaseRecoverKeyWithMutipleLease(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.Client(0)).KV kvc := integration.ToGRPC(clus.Client(0)).KV
lsc := toGRPC(clus.Client(0)).Lease lsc := integration.ToGRPC(clus.Client(0)).Lease
var leaseIDs []int64 var leaseIDs []int64
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
@ -835,7 +836,7 @@ func TestV3LeaseRecoverKeyWithMutipleLease(t *testing.T) {
// restart server and ensure lease still exists // restart server and ensure lease still exists
clus.Members[0].Stop(t) clus.Members[0].Stop(t)
clus.Members[0].Restart(t) clus.Members[0].Restart(t)
clus.waitLeader(t, clus.Members) clus.WaitMembersForLeader(t, clus.Members)
for i, leaseID := range leaseIDs { for i, leaseID := range leaseIDs {
if !leaseExist(t, clus, leaseID) { if !leaseExist(t, clus, leaseID) {
t.Errorf("#%d: unexpected lease not exists", i) t.Errorf("#%d: unexpected lease not exists", i)
@ -844,12 +845,12 @@ func TestV3LeaseRecoverKeyWithMutipleLease(t *testing.T) {
// overwrite old client with newly dialed connection // overwrite old client with newly dialed connection
// otherwise, error with "grpc: RPC failed fast due to transport failure" // otherwise, error with "grpc: RPC failed fast due to transport failure"
nc, err := NewClientV3(clus.Members[0]) nc, err := integration.NewClientV3(clus.Members[0])
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
kvc = toGRPC(nc).KV kvc = integration.ToGRPC(nc).KV
lsc = toGRPC(nc).Lease lsc = integration.ToGRPC(nc).Lease
defer nc.Close() defer nc.Close()
// revoke the old lease // revoke the old lease
@ -881,9 +882,9 @@ func TestV3LeaseRecoverKeyWithMutipleLease(t *testing.T) {
} }
// acquireLeaseAndKey creates a new lease and creates an attached key. // acquireLeaseAndKey creates a new lease and creates an attached key.
func acquireLeaseAndKey(clus *ClusterV3, key string) (int64, error) { func acquireLeaseAndKey(clus *integration.ClusterV3, key string) (int64, error) {
// create lease // create lease
lresp, err := toGRPC(clus.RandClient()).Lease.LeaseGrant( lresp, err := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(
context.TODO(), context.TODO(),
&pb.LeaseGrantRequest{TTL: 1}) &pb.LeaseGrantRequest{TTL: 1})
if err != nil { if err != nil {
@ -894,7 +895,7 @@ func acquireLeaseAndKey(clus *ClusterV3, key string) (int64, error) {
} }
// attach to key // attach to key
put := &pb.PutRequest{Key: []byte(key), Lease: lresp.ID} put := &pb.PutRequest{Key: []byte(key), Lease: lresp.ID}
if _, err := toGRPC(clus.RandClient()).KV.Put(context.TODO(), put); err != nil { if _, err := integration.ToGRPC(clus.RandClient()).KV.Put(context.TODO(), put); err != nil {
return 0, err return 0, err
} }
return lresp.ID, nil return lresp.ID, nil
@ -902,8 +903,8 @@ func acquireLeaseAndKey(clus *ClusterV3, key string) (int64, error) {
// testLeaseRemoveLeasedKey performs some action while holding a lease with an // testLeaseRemoveLeasedKey performs some action while holding a lease with an
// attached key "foo", then confirms the key is gone. // attached key "foo", then confirms the key is gone.
func testLeaseRemoveLeasedKey(t *testing.T, act func(*ClusterV3, int64) error) { func testLeaseRemoveLeasedKey(t *testing.T, act func(*integration.ClusterV3, int64) error) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
leaseID, err := acquireLeaseAndKey(clus, "foo") leaseID, err := acquireLeaseAndKey(clus, "foo")
@ -917,7 +918,7 @@ func testLeaseRemoveLeasedKey(t *testing.T, act func(*ClusterV3, int64) error) {
// confirm no key // confirm no key
rreq := &pb.RangeRequest{Key: []byte("foo")} rreq := &pb.RangeRequest{Key: []byte("foo")}
rresp, err := toGRPC(clus.RandClient()).KV.Range(context.TODO(), rreq) rresp, err := integration.ToGRPC(clus.RandClient()).KV.Range(context.TODO(), rreq)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -926,8 +927,8 @@ func testLeaseRemoveLeasedKey(t *testing.T, act func(*ClusterV3, int64) error) {
} }
} }
func leaseExist(t *testing.T, clus *ClusterV3, leaseID int64) bool { func leaseExist(t *testing.T, clus *integration.ClusterV3, leaseID int64) bool {
l := toGRPC(clus.RandClient()).Lease l := integration.ToGRPC(clus.RandClient()).Lease
_, err := l.LeaseGrant(context.Background(), &pb.LeaseGrantRequest{ID: leaseID, TTL: 5}) _, err := l.LeaseGrant(context.Background(), &pb.LeaseGrantRequest{ID: leaseID, TTL: 5})
if err == nil { if err == nil {

25
tests/integration/v3_stm_test.go
View File

@ -24,13 +24,14 @@ import (
"go.etcd.io/etcd/client/pkg/v3/testutil" "go.etcd.io/etcd/client/pkg/v3/testutil"
v3 "go.etcd.io/etcd/client/v3" v3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/client/v3/concurrency" "go.etcd.io/etcd/client/v3/concurrency"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestSTMConflict tests that conflicts are retried. // TestSTMConflict tests that conflicts are retried.
func TestSTMConflict(t *testing.T) { func TestSTMConflict(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
etcdc := clus.RandClient() etcdc := clus.RandClient()
@ -96,9 +97,9 @@ func TestSTMConflict(t *testing.T) {
// TestSTMPutNewKey confirms a STM put on a new key is visible after commit. // TestSTMPutNewKey confirms a STM put on a new key is visible after commit.
func TestSTMPutNewKey(t *testing.T) { func TestSTMPutNewKey(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
etcdc := clus.RandClient() etcdc := clus.RandClient()
@ -123,9 +124,9 @@ func TestSTMPutNewKey(t *testing.T) {
// TestSTMAbort tests that an aborted txn does not modify any keys. // TestSTMAbort tests that an aborted txn does not modify any keys.
func TestSTMAbort(t *testing.T) { func TestSTMAbort(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
etcdc := clus.RandClient() etcdc := clus.RandClient()
@ -154,9 +155,9 @@ func TestSTMAbort(t *testing.T) {
// TestSTMSerialize tests that serialization is honored when serializable. // TestSTMSerialize tests that serialization is honored when serializable.
func TestSTMSerialize(t *testing.T) { func TestSTMSerialize(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
etcdc := clus.RandClient() etcdc := clus.RandClient()
@ -217,9 +218,9 @@ func TestSTMSerialize(t *testing.T) {
// TestSTMApplyOnConcurrentDeletion ensures that concurrent key deletion // TestSTMApplyOnConcurrentDeletion ensures that concurrent key deletion
// fails the first GET revision comparison within STM; trigger retry. // fails the first GET revision comparison within STM; trigger retry.
func TestSTMApplyOnConcurrentDeletion(t *testing.T) { func TestSTMApplyOnConcurrentDeletion(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
etcdc := clus.RandClient() etcdc := clus.RandClient()
@ -266,9 +267,9 @@ func TestSTMApplyOnConcurrentDeletion(t *testing.T) {
} }
func TestSTMSerializableSnapshotPut(t *testing.T) { func TestSTMSerializableSnapshotPut(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
cli := clus.Client(0) cli := clus.Client(0)

9
tests/integration/v3_tls_test.go
View File

@ -21,6 +21,7 @@ import (
"time" "time"
"go.etcd.io/etcd/client/v3" "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/framework/integration"
"google.golang.org/grpc" "google.golang.org/grpc"
) )
@ -30,7 +31,7 @@ func TestTLSClientCipherSuitesMismatch(t *testing.T) { testTLSCipherSuites(t, fa
// testTLSCipherSuites ensures mismatching client-side cipher suite // testTLSCipherSuites ensures mismatching client-side cipher suite
// fail TLS handshake with the server. // fail TLS handshake with the server.
func testTLSCipherSuites(t *testing.T, valid bool) { func testTLSCipherSuites(t *testing.T, valid bool) {
BeforeTest(t) integration.BeforeTest(t)
cipherSuites := []uint16{ cipherSuites := []uint16{
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
@ -40,21 +41,21 @@ func testTLSCipherSuites(t *testing.T, valid bool) {
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
} }
srvTLS, cliTLS := testTLSInfo, testTLSInfo srvTLS, cliTLS := integration.TestTLSInfo, integration.TestTLSInfo
if valid { if valid {
srvTLS.CipherSuites, cliTLS.CipherSuites = cipherSuites, cipherSuites srvTLS.CipherSuites, cliTLS.CipherSuites = cipherSuites, cipherSuites
} else { } else {
srvTLS.CipherSuites, cliTLS.CipherSuites = cipherSuites[:2], cipherSuites[2:] srvTLS.CipherSuites, cliTLS.CipherSuites = cipherSuites[:2], cipherSuites[2:]
} }
clus := NewClusterV3(t, &ClusterConfig{Size: 1, ClientTLS: &srvTLS}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, ClientTLS: &srvTLS})
defer clus.Terminate(t) defer clus.Terminate(t)
cc, err := cliTLS.ClientConfig() cc, err := cliTLS.ClientConfig()
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
cli, cerr := NewClient(t, clientv3.Config{ cli, cerr := integration.NewClient(t, clientv3.Config{
Endpoints: []string{clus.Members[0].GRPCURL()}, Endpoints: []string{clus.Members[0].GRPCURL()},
DialTimeout: time.Second, DialTimeout: time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()}, DialOptions: []grpc.DialOption{grpc.WithBlock()},

19
tests/integration/v3_watch_restore_test.go
View File

@ -21,13 +21,14 @@ import (
"time" "time"
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// MustFetchNotEmptyMetric attempts to fetch given 'metric' from 'member', // MustFetchNotEmptyMetric attempts to fetch given 'metric' from 'member',
// waiting for not-empty value or 'timeout'. // waiting for not-empty value or 'timeout'.
func MustFetchNotEmptyMetric(tb testing.TB, member *member, metric string, timeout <-chan time.Time) string { func MustFetchNotEmptyMetric(tb testing.TB, member *integration.Member, metric string, timeout <-chan time.Time) string {
metricValue := "" metricValue := ""
tick := time.Tick(tickDuration) tick := time.Tick(integration.TickDuration)
for metricValue == "" { for metricValue == "" {
tb.Logf("Waiting for metric: %v", metric) tb.Logf("Waiting for metric: %v", metric)
select { select {
@ -50,9 +51,9 @@ func MustFetchNotEmptyMetric(tb testing.TB, member *member, metric string, timeo
// that were created in synced watcher group in the first place. // that were created in synced watcher group in the first place.
// TODO: fix panic with gRPC proxy "panic: watcher current revision should not exceed current revision" // TODO: fix panic with gRPC proxy "panic: watcher current revision should not exceed current revision"
func TestV3WatchRestoreSnapshotUnsync(t *testing.T) { func TestV3WatchRestoreSnapshotUnsync(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{ clus := integration.NewClusterV3(t, &integration.ClusterConfig{
Size: 3, Size: 3,
SnapshotCount: 10, SnapshotCount: 10,
SnapshotCatchUpEntries: 5, SnapshotCatchUpEntries: 5,
@ -62,7 +63,7 @@ func TestV3WatchRestoreSnapshotUnsync(t *testing.T) {
// spawn a watcher before shutdown, and put it in synced watcher // spawn a watcher before shutdown, and put it in synced watcher
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, errW := toGRPC(clus.Client(0)).Watch.Watch(ctx) wStream, errW := integration.ToGRPC(clus.Client(0)).Watch.Watch(ctx)
if errW != nil { if errW != nil {
t.Fatal(errW) t.Fatal(errW)
} }
@ -79,13 +80,13 @@ func TestV3WatchRestoreSnapshotUnsync(t *testing.T) {
} }
clus.Members[0].InjectPartition(t, clus.Members[1:]...) clus.Members[0].InjectPartition(t, clus.Members[1:]...)
initialLead := clus.waitLeader(t, clus.Members[1:]) initialLead := clus.WaitMembersForLeader(t, clus.Members[1:])
t.Logf("elected lead: %v", clus.Members[initialLead].s.ID()) t.Logf("elected lead: %v", clus.Members[initialLead].Server.ID())
t.Logf("sleeping for 2 seconds") t.Logf("sleeping for 2 seconds")
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
t.Logf("sleeping for 2 seconds DONE") t.Logf("sleeping for 2 seconds DONE")
kvc := toGRPC(clus.Client(1)).KV kvc := integration.ToGRPC(clus.Client(1)).KV
// to trigger snapshot from the leader to the stopped follower // to trigger snapshot from the leader to the stopped follower
for i := 0; i < 15; i++ { for i := 0; i < 15; i++ {
@ -98,7 +99,7 @@ func TestV3WatchRestoreSnapshotUnsync(t *testing.T) {
// trigger snapshot send from leader to this slow follower // trigger snapshot send from leader to this slow follower
// which then calls watchable store Restore // which then calls watchable store Restore
clus.Members[0].RecoverPartition(t, clus.Members[1:]...) clus.Members[0].RecoverPartition(t, clus.Members[1:]...)
// We don't expect leadership change here, just recompute the leader's index // We don't expect leadership change here, just recompute the leader'Server index
// within clus.Members list. // within clus.Members list.
lead := clus.WaitLeader(t) lead := clus.WaitLeader(t)

127
tests/integration/v3_watch_test.go
View File

@ -27,11 +27,12 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/api/v3/mvccpb" "go.etcd.io/etcd/api/v3/mvccpb"
"go.etcd.io/etcd/server/v3/etcdserver/api/v3rpc" "go.etcd.io/etcd/server/v3/etcdserver/api/v3rpc"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestV3WatchFromCurrentRevision tests Watch APIs from current revision. // TestV3WatchFromCurrentRevision tests Watch APIs from current revision.
func TestV3WatchFromCurrentRevision(t *testing.T) { func TestV3WatchFromCurrentRevision(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
tests := []struct { tests := []struct {
name string name string
@ -206,10 +207,10 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
for i, tt := range tests { for i, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
wAPI := toGRPC(clus.RandClient()).Watch wAPI := integration.ToGRPC(clus.RandClient()).Watch
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, err := wAPI.Watch(ctx) wStream, err := wAPI.Watch(ctx)
@ -243,7 +244,7 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
ch := make(chan struct{}, 1) ch := make(chan struct{}, 1)
go func() { go func() {
for _, k := range tt.putKeys { for _, k := range tt.putKeys {
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
req := &pb.PutRequest{Key: []byte(k), Value: []byte("bar")} req := &pb.PutRequest{Key: []byte(k), Value: []byte("bar")}
if _, err := kvc.Put(context.TODO(), req); err != nil { if _, err := kvc.Put(context.TODO(), req); err != nil {
t.Errorf("#%d: couldn't put key (%v)", i, err) t.Errorf("#%d: couldn't put key (%v)", i, err)
@ -291,12 +292,12 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
// TestV3WatchFutureRevision tests Watch APIs from a future revision. // TestV3WatchFutureRevision tests Watch APIs from a future revision.
func TestV3WatchFutureRevision(t *testing.T) { func TestV3WatchFutureRevision(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
wAPI := toGRPC(clus.RandClient()).Watch wAPI := integration.ToGRPC(clus.RandClient()).Watch
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, err := wAPI.Watch(ctx) wStream, err := wAPI.Watch(ctx)
@ -322,7 +323,7 @@ func TestV3WatchFutureRevision(t *testing.T) {
t.Fatalf("create %v, want %v", cresp.Created, true) t.Fatalf("create %v, want %v", cresp.Created, true)
} }
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
for { for {
req := &pb.PutRequest{Key: wkey, Value: []byte("bar")} req := &pb.PutRequest{Key: wkey, Value: []byte("bar")}
resp, rerr := kvc.Put(context.TODO(), req) resp, rerr := kvc.Put(context.TODO(), req)
@ -352,12 +353,12 @@ func TestV3WatchFutureRevision(t *testing.T) {
// TestV3WatchWrongRange tests wrong range does not create watchers. // TestV3WatchWrongRange tests wrong range does not create watchers.
func TestV3WatchWrongRange(t *testing.T) { func TestV3WatchWrongRange(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
wAPI := toGRPC(clus.RandClient()).Watch wAPI := integration.ToGRPC(clus.RandClient()).Watch
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, err := wAPI.Watch(ctx) wStream, err := wAPI.Watch(ctx)
@ -397,23 +398,23 @@ func TestV3WatchWrongRange(t *testing.T) {
// TestV3WatchCancelSynced tests Watch APIs cancellation from synced map. // TestV3WatchCancelSynced tests Watch APIs cancellation from synced map.
func TestV3WatchCancelSynced(t *testing.T) { func TestV3WatchCancelSynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchCancel(t, 0) testV3WatchCancel(t, 0)
} }
// TestV3WatchCancelUnsynced tests Watch APIs cancellation from unsynced map. // TestV3WatchCancelUnsynced tests Watch APIs cancellation from unsynced map.
func TestV3WatchCancelUnsynced(t *testing.T) { func TestV3WatchCancelUnsynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchCancel(t, 1) testV3WatchCancel(t, 1)
} }
func testV3WatchCancel(t *testing.T, startRev int64) { func testV3WatchCancel(t *testing.T, startRev int64) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, errW := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, errW := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if errW != nil { if errW != nil {
t.Fatalf("wAPI.Watch error: %v", errW) t.Fatalf("wAPI.Watch error: %v", errW)
} }
@ -448,7 +449,7 @@ func testV3WatchCancel(t *testing.T, startRev int64) {
t.Errorf("cresp.Canceled got = %v, want = true", cresp.Canceled) t.Errorf("cresp.Canceled got = %v, want = true", cresp.Canceled)
} }
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
if _, err := kvc.Put(context.TODO(), &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}); err != nil { if _, err := kvc.Put(context.TODO(), &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}); err != nil {
t.Errorf("couldn't put key (%v)", err) t.Errorf("couldn't put key (%v)", err)
} }
@ -463,13 +464,13 @@ func testV3WatchCancel(t *testing.T, startRev int64) {
// TestV3WatchCurrentPutOverlap ensures current watchers receive all events with // TestV3WatchCurrentPutOverlap ensures current watchers receive all events with
// overlapping puts. // overlapping puts.
func TestV3WatchCurrentPutOverlap(t *testing.T) { func TestV3WatchCurrentPutOverlap(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, wErr := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, wErr := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if wErr != nil { if wErr != nil {
t.Fatalf("wAPI.Watch error: %v", wErr) t.Fatalf("wAPI.Watch error: %v", wErr)
} }
@ -482,7 +483,7 @@ func TestV3WatchCurrentPutOverlap(t *testing.T) {
wg.Add(1) wg.Add(1)
go func() { go func() {
defer wg.Done() defer wg.Done()
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
req := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")} req := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
if _, err := kvc.Put(context.TODO(), req); err != nil { if _, err := kvc.Put(context.TODO(), req); err != nil {
t.Errorf("couldn't put key (%v)", err) t.Errorf("couldn't put key (%v)", err)
@ -547,15 +548,15 @@ func TestV3WatchCurrentPutOverlap(t *testing.T) {
// TestV3WatchEmptyKey ensures synced watchers see empty key PUTs as PUT events // TestV3WatchEmptyKey ensures synced watchers see empty key PUTs as PUT events
func TestV3WatchEmptyKey(t *testing.T) { func TestV3WatchEmptyKey(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
ws, werr := toGRPC(clus.RandClient()).Watch.Watch(ctx) ws, werr := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if werr != nil { if werr != nil {
t.Fatal(werr) t.Fatal(werr)
} }
@ -570,7 +571,7 @@ func TestV3WatchEmptyKey(t *testing.T) {
} }
// put a key with empty value // put a key with empty value
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
preq := &pb.PutRequest{Key: []byte("foo")} preq := &pb.PutRequest{Key: []byte("foo")}
if _, err := kvc.Put(context.TODO(), preq); err != nil { if _, err := kvc.Put(context.TODO(), preq); err != nil {
t.Fatal(err) t.Fatal(err)
@ -593,12 +594,12 @@ func TestV3WatchEmptyKey(t *testing.T) {
} }
func TestV3WatchMultipleWatchersSynced(t *testing.T) { func TestV3WatchMultipleWatchersSynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchMultipleWatchers(t, 0) testV3WatchMultipleWatchers(t, 0)
} }
func TestV3WatchMultipleWatchersUnsynced(t *testing.T) { func TestV3WatchMultipleWatchersUnsynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchMultipleWatchers(t, 1) testV3WatchMultipleWatchers(t, 1)
} }
@ -607,14 +608,14 @@ func TestV3WatchMultipleWatchersUnsynced(t *testing.T) {
// that matches all watchers, and another key that matches only // that matches all watchers, and another key that matches only
// one watcher to test if it receives expected events. // one watcher to test if it receives expected events.
func testV3WatchMultipleWatchers(t *testing.T, startRev int64) { func testV3WatchMultipleWatchers(t *testing.T, startRev int64) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, errW := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, errW := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if errW != nil { if errW != nil {
t.Fatalf("wAPI.Watch error: %v", errW) t.Fatalf("wAPI.Watch error: %v", errW)
} }
@ -698,23 +699,23 @@ func testV3WatchMultipleWatchers(t *testing.T, startRev int64) {
} }
func TestV3WatchMultipleEventsTxnSynced(t *testing.T) { func TestV3WatchMultipleEventsTxnSynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchMultipleEventsTxn(t, 0) testV3WatchMultipleEventsTxn(t, 0)
} }
func TestV3WatchMultipleEventsTxnUnsynced(t *testing.T) { func TestV3WatchMultipleEventsTxnUnsynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchMultipleEventsTxn(t, 1) testV3WatchMultipleEventsTxn(t, 1)
} }
// testV3WatchMultipleEventsTxn tests Watch APIs when it receives multiple events. // testV3WatchMultipleEventsTxn tests Watch APIs when it receives multiple events.
func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) { func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, wErr := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, wErr := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if wErr != nil { if wErr != nil {
t.Fatalf("wAPI.Watch error: %v", wErr) t.Fatalf("wAPI.Watch error: %v", wErr)
} }
@ -729,7 +730,7 @@ func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) {
t.Fatalf("create response failed: resp=%v, err=%v", resp, err) t.Fatalf("create response failed: resp=%v, err=%v", resp, err)
} }
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
txn := pb.TxnRequest{} txn := pb.TxnRequest{}
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
ru := &pb.RequestOp{} ru := &pb.RequestOp{}
@ -791,11 +792,11 @@ func (evs eventsSortByKey) Less(i, j int) bool {
} }
func TestV3WatchMultipleEventsPutUnsynced(t *testing.T) { func TestV3WatchMultipleEventsPutUnsynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
if _, err := kvc.Put(context.TODO(), &pb.PutRequest{Key: []byte("foo0"), Value: []byte("bar")}); err != nil { if _, err := kvc.Put(context.TODO(), &pb.PutRequest{Key: []byte("foo0"), Value: []byte("bar")}); err != nil {
t.Fatalf("couldn't put key (%v)", err) t.Fatalf("couldn't put key (%v)", err)
@ -806,7 +807,7 @@ func TestV3WatchMultipleEventsPutUnsynced(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, wErr := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, wErr := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if wErr != nil { if wErr != nil {
t.Fatalf("wAPI.Watch error: %v", wErr) t.Fatalf("wAPI.Watch error: %v", wErr)
} }
@ -870,22 +871,22 @@ func TestV3WatchMultipleEventsPutUnsynced(t *testing.T) {
} }
func TestV3WatchMultipleStreamsSynced(t *testing.T) { func TestV3WatchMultipleStreamsSynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchMultipleStreams(t, 0) testV3WatchMultipleStreams(t, 0)
} }
func TestV3WatchMultipleStreamsUnsynced(t *testing.T) { func TestV3WatchMultipleStreamsUnsynced(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
testV3WatchMultipleStreams(t, 1) testV3WatchMultipleStreams(t, 1)
} }
// testV3WatchMultipleStreams tests multiple watchers on the same key on multiple streams. // testV3WatchMultipleStreams tests multiple watchers on the same key on multiple streams.
func testV3WatchMultipleStreams(t *testing.T, startRev int64) { func testV3WatchMultipleStreams(t *testing.T, startRev int64) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
wAPI := toGRPC(clus.RandClient()).Watch wAPI := integration.ToGRPC(clus.RandClient()).Watch
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
streams := make([]pb.Watch_WatchClient, 5) streams := make([]pb.Watch_WatchClient, 5)
for i := range streams { for i := range streams {
@ -983,13 +984,13 @@ func TestWatchWithProgressNotify(t *testing.T) {
testInterval := 3 * time.Second testInterval := 3 * time.Second
defer func() { v3rpc.SetProgressReportInterval(oldpi) }() defer func() { v3rpc.SetProgressReportInterval(oldpi) }()
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 3}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 3})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
wStream, wErr := toGRPC(clus.RandClient()).Watch.Watch(ctx) wStream, wErr := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if wErr != nil { if wErr != nil {
t.Fatalf("wAPI.Watch error: %v", wErr) t.Fatalf("wAPI.Watch error: %v", wErr)
} }
@ -1033,12 +1034,12 @@ func TestWatchWithProgressNotify(t *testing.T) {
// TestV3WatcMultiOpenhClose opens many watchers concurrently on multiple streams. // TestV3WatcMultiOpenhClose opens many watchers concurrently on multiple streams.
func TestV3WatchClose(t *testing.T) { func TestV3WatchClose(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1, UseBridge: true}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t) defer clus.Terminate(t)
c := clus.Client(0) c := clus.Client(0)
wapi := toGRPC(c).Watch wapi := integration.ToGRPC(c).Watch
var wg sync.WaitGroup var wg sync.WaitGroup
wg.Add(100) wg.Add(100)
@ -1068,15 +1069,15 @@ func TestV3WatchClose(t *testing.T) {
// TestV3WatchWithFilter ensures watcher filters out the events correctly. // TestV3WatchWithFilter ensures watcher filters out the events correctly.
func TestV3WatchWithFilter(t *testing.T) { func TestV3WatchWithFilter(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
ws, werr := toGRPC(clus.RandClient()).Watch.Watch(ctx) ws, werr := integration.ToGRPC(clus.RandClient()).Watch.Watch(ctx)
if werr != nil { if werr != nil {
t.Fatal(werr) t.Fatal(werr)
} }
@ -1103,7 +1104,7 @@ func TestV3WatchWithFilter(t *testing.T) {
}() }()
// put a key with empty value // put a key with empty value
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
preq := &pb.PutRequest{Key: []byte("foo")} preq := &pb.PutRequest{Key: []byte("foo")}
if _, err := kvc.Put(context.TODO(), preq); err != nil { if _, err := kvc.Put(context.TODO(), preq); err != nil {
t.Fatal(err) t.Fatal(err)
@ -1137,8 +1138,8 @@ func TestV3WatchWithFilter(t *testing.T) {
} }
func TestV3WatchWithPrevKV(t *testing.T) { func TestV3WatchWithPrevKV(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
wctx, wcancel := context.WithCancel(context.Background()) wctx, wcancel := context.WithCancel(context.Background())
@ -1158,12 +1159,12 @@ func TestV3WatchWithPrevKV(t *testing.T) {
vals: []string{"first", "second"}, vals: []string{"first", "second"},
}} }}
for i, tt := range tests { for i, tt := range tests {
kvc := toGRPC(clus.RandClient()).KV kvc := integration.ToGRPC(clus.RandClient()).KV
if _, err := kvc.Put(context.TODO(), &pb.PutRequest{Key: []byte(tt.key), Value: []byte(tt.vals[0])}); err != nil { if _, err := kvc.Put(context.TODO(), &pb.PutRequest{Key: []byte(tt.key), Value: []byte(tt.vals[0])}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
ws, werr := toGRPC(clus.RandClient()).Watch.Watch(wctx) ws, werr := integration.ToGRPC(clus.RandClient()).Watch.Watch(wctx)
if werr != nil { if werr != nil {
t.Fatal(werr) t.Fatal(werr)
} }
@ -1211,9 +1212,9 @@ func TestV3WatchWithPrevKV(t *testing.T) {
// TestV3WatchCancellation ensures that watch cancellation frees up server resources. // TestV3WatchCancellation ensures that watch cancellation frees up server resources.
func TestV3WatchCancellation(t *testing.T) { func TestV3WatchCancellation(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
@ -1239,7 +1240,7 @@ func TestV3WatchCancellation(t *testing.T) {
} }
var expected string var expected string
if ThroughProxy { if integration.ThroughProxy {
// grpc proxy has additional 2 watches open // grpc proxy has additional 2 watches open
expected = "3" expected = "3"
} else { } else {
@ -1253,9 +1254,9 @@ func TestV3WatchCancellation(t *testing.T) {
// TestV3WatchCloseCancelRace ensures that watch close doesn't decrement the watcher total too far. // TestV3WatchCloseCancelRace ensures that watch close doesn't decrement the watcher total too far.
func TestV3WatchCloseCancelRace(t *testing.T) { func TestV3WatchCloseCancelRace(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
@ -1278,7 +1279,7 @@ func TestV3WatchCloseCancelRace(t *testing.T) {
} }
var expected string var expected string
if ThroughProxy { if integration.ThroughProxy {
// grpc proxy has additional 2 watches open // grpc proxy has additional 2 watches open
expected = "2" expected = "2"
} else { } else {

21
tests/integration/v3election_grpc_test.go
View File

@ -22,25 +22,26 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
epb "go.etcd.io/etcd/server/v3/etcdserver/api/v3election/v3electionpb" epb "go.etcd.io/etcd/server/v3/etcdserver/api/v3election/v3electionpb"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestV3ElectionCampaign checks that Campaign will not give // TestV3ElectionCampaign checks that Campaign will not give
// simultaneous leadership to multiple campaigners. // simultaneous leadership to multiple campaigners.
func TestV3ElectionCampaign(t *testing.T) { func TestV3ElectionCampaign(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lease1, err1 := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lease1, err1 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err1 != nil { if err1 != nil {
t.Fatal(err1) t.Fatal(err1)
} }
lease2, err2 := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lease2, err2 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err2 != nil { if err2 != nil {
t.Fatal(err2) t.Fatal(err2)
} }
lc := toGRPC(clus.Client(0)).Election lc := integration.ToGRPC(clus.Client(0)).Election
req1 := &epb.CampaignRequest{Name: []byte("foo"), Lease: lease1.ID, Value: []byte("abc")} req1 := &epb.CampaignRequest{Name: []byte("foo"), Lease: lease1.ID, Value: []byte("abc")}
l1, lerr1 := lc.Campaign(context.TODO(), req1) l1, lerr1 := lc.Campaign(context.TODO(), req1)
if lerr1 != nil { if lerr1 != nil {
@ -89,11 +90,11 @@ func TestV3ElectionCampaign(t *testing.T) {
// TestV3ElectionObserve checks that an Observe stream receives // TestV3ElectionObserve checks that an Observe stream receives
// proclamations from different leaders uninterrupted. // proclamations from different leaders uninterrupted.
func TestV3ElectionObserve(t *testing.T) { func TestV3ElectionObserve(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lc := toGRPC(clus.Client(0)).Election lc := integration.ToGRPC(clus.Client(0)).Election
// observe leadership events // observe leadership events
observec := make(chan struct{}, 1) observec := make(chan struct{}, 1)
@ -125,7 +126,7 @@ func TestV3ElectionObserve(t *testing.T) {
t.Fatalf("observe stream took too long to start") t.Fatalf("observe stream took too long to start")
} }
lease1, err1 := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lease1, err1 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err1 != nil { if err1 != nil {
t.Fatal(err1) t.Fatal(err1)
} }
@ -139,7 +140,7 @@ func TestV3ElectionObserve(t *testing.T) {
go func() { go func() {
defer close(leader2c) defer close(leader2c)
lease2, err2 := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lease2, err2 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err2 != nil { if err2 != nil {
t.Error(err2) t.Error(err2)
} }

11
tests/integration/v3lock_grpc_test.go
View File

@ -21,25 +21,26 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb" pb "go.etcd.io/etcd/api/v3/etcdserverpb"
lockpb "go.etcd.io/etcd/server/v3/etcdserver/api/v3lock/v3lockpb" lockpb "go.etcd.io/etcd/server/v3/etcdserver/api/v3lock/v3lockpb"
"go.etcd.io/etcd/tests/v3/framework/integration"
) )
// TestV3LockLockWaiter tests that a client will wait for a lock, then acquire it // TestV3LockLockWaiter tests that a client will wait for a lock, then acquire it
// once it is unlocked. // once it is unlocked.
func TestV3LockLockWaiter(t *testing.T) { func TestV3LockLockWaiter(t *testing.T) {
BeforeTest(t) integration.BeforeTest(t)
clus := NewClusterV3(t, &ClusterConfig{Size: 1}) clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
defer clus.Terminate(t) defer clus.Terminate(t)
lease1, err1 := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lease1, err1 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err1 != nil { if err1 != nil {
t.Fatal(err1) t.Fatal(err1)
} }
lease2, err2 := toGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30}) lease2, err2 := integration.ToGRPC(clus.RandClient()).Lease.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 30})
if err2 != nil { if err2 != nil {
t.Fatal(err2) t.Fatal(err2)
} }
lc := toGRPC(clus.Client(0)).Lock lc := integration.ToGRPC(clus.Client(0)).Lock
l1, lerr1 := lc.Lock(context.TODO(), &lockpb.LockRequest{Name: []byte("foo"), Lease: lease1.ID}) l1, lerr1 := lc.Lock(context.TODO(), &lockpb.LockRequest{Name: []byte("foo"), Lease: lease1.ID})
if lerr1 != nil { if lerr1 != nil {
t.Fatal(lerr1) t.Fatal(lerr1)