Add some integration tests to test buffer consistency.

Signed-off-by: Siyuan Zhang <sizhang@google.com>
etcd-io · Jan 3, 2024 · c6fc7bb · c6fc7bb
1 parent 3ff51d8
commit c6fc7bb
Show file tree

Hide file tree

Showing 3 changed files with 118 additions and 1 deletion.
diff --git a/tests/framework/integration/cluster.go b/tests/framework/integration/cluster.go
@@ -142,7 +142,8 @@ type ClusterConfig struct {
 	AuthToken    string
 	AuthTokenTTL uint
 
-	QuotaBackendBytes int64
+	QuotaBackendBytes    int64
+	BackendBatchInterval time.Duration
 
 	MaxTxnOps              uint
 	MaxRequestBytes        uint
@@ -271,6 +272,7 @@ func (c *Cluster) mustNewMember(t testutil.TB) *Member {
 			PeerTLS:                             c.Cfg.PeerTLS,
 			ClientTLS:                           c.Cfg.ClientTLS,
 			QuotaBackendBytes:                   c.Cfg.QuotaBackendBytes,
+			BackendBatchInterval:                c.Cfg.BackendBatchInterval,
 			MaxTxnOps:                           c.Cfg.MaxTxnOps,
 			MaxRequestBytes:                     c.Cfg.MaxRequestBytes,
 			SnapshotCount:                       c.Cfg.SnapshotCount,
@@ -598,6 +600,7 @@ type MemberConfig struct {
 	AuthToken                   string
 	AuthTokenTTL                uint
 	QuotaBackendBytes           int64
+	BackendBatchInterval        time.Duration
 	MaxTxnOps                   uint
 	MaxRequestBytes             uint
 	SnapshotCount               uint64
@@ -671,6 +674,7 @@ func MustNewMember(t testutil.TB, mcfg MemberConfig) *Member {
 	m.TickMs = uint(framecfg.TickDuration / time.Millisecond)
 	m.PreVote = true
 	m.QuotaBackendBytes = mcfg.QuotaBackendBytes
+	m.BackendBatchInterval = mcfg.BackendBatchInterval
 	m.MaxTxnOps = mcfg.MaxTxnOps
 	if m.MaxTxnOps == 0 {
 		m.MaxTxnOps = embed.DefaultMaxTxnOps

diff --git a/tests/integration/clientv3/user_test.go b/tests/integration/clientv3/user_test.go
@@ -55,6 +55,66 @@ func TestUserError(t *testing.T) {
 	}
 }
 
+func TestAddUserAfterDelete(t *testing.T) {
+	integration2.BeforeTest(t)
+
+	clus := integration2.NewCluster(t, &integration2.ClusterConfig{Size: 1})
+	defer clus.Terminate(t)
+
+	authapi := clus.RandClient()
+	authSetupRoot(t, authapi.Auth)
+	cfg := clientv3.Config{
+		Endpoints:   authapi.Endpoints(),
+		DialTimeout: 5 * time.Second,
+		DialOptions: []grpc.DialOption{grpc.WithBlock()},
+	}
+	cfg.Username, cfg.Password = "root", "123"
+	authed, err := integration2.NewClient(t, cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer authed.Close()
+
+	// add user
+	if _, err = authed.UserAdd(context.TODO(), "foo", "bar"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = authapi.Authenticate(context.TODO(), "foo", "bar"); err != nil {
+		t.Fatal(err)
+	}
+	// delete user
+	if _, err = authed.UserDelete(context.TODO(), "foo"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = authed.Authenticate(context.TODO(), "foo", "bar"); err == nil {
+		t.Errorf("expect Authenticate error for old password")
+	}
+	// add user back
+	if _, err = authed.UserAdd(context.TODO(), "foo", "bar"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = authed.Authenticate(context.TODO(), "foo", "bar"); err != nil {
+		t.Fatal(err)
+	}
+	// change password
+	if _, err = authed.UserChangePassword(context.TODO(), "foo", "bar2"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = authed.UserChangePassword(context.TODO(), "foo", "bar1"); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err = authed.Authenticate(context.TODO(), "foo", "bar"); err == nil {
+		t.Errorf("expect Authenticate error for old password")
+	}
+	if _, err = authed.Authenticate(context.TODO(), "foo", "bar2"); err == nil {
+		t.Errorf("expect Authenticate error for old password")
+	}
+	if _, err = authed.Authenticate(context.TODO(), "foo", "bar1"); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestUserErrorAuth(t *testing.T) {
 	integration2.BeforeTest(t)
 

diff --git a/tests/integration/member_test.go b/tests/integration/member_test.go
@@ -18,9 +18,13 @@ import (
 	"context"
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 
+	"go.etcd.io/etcd/server/v3/etcdserver"
+	"go.etcd.io/etcd/server/v3/storage/backend"
+	"go.etcd.io/etcd/server/v3/storage/schema"
 	"go.etcd.io/etcd/tests/v3/framework/integration"
 )
 
@@ -115,3 +119,52 @@ func TestSnapshotAndRestartMember(t *testing.T) {
 		}
 	}
 }
+
+func TestRemoveMember(t *testing.T) {
+	integration.BeforeTest(t)
+	c := integration.NewCluster(t, &integration.ClusterConfig{Size: 3, UseBridge: true, BackendBatchInterval: 1000 * time.Second})
+	defer c.Terminate(t)
+	time.Sleep(etcdserver.HealthInterval)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	_, err := c.Members[2].Client.MemberRemove(ctx, uint64(c.Members[0].Server.MemberId()))
+	cancel()
+
+	if err != nil {
+		t.Fatalf("should accept removing member: %s", err)
+	}
+	c.Members[0].Stop(t)
+	time.Sleep(etcdserver.HealthInterval)
+
+	checkMemberCount(t, c.Members[1], 2)
+	checkMemberCount(t, c.Members[2], 2)
+}
+
+func checkMemberCount(t *testing.T, m *integration.Member, expectedMemberCount int) {
+	memberCount := mustReadMemberCountFromBackend(t, m.Server.Backend())
+	if memberCount != expectedMemberCount {
+		t.Errorf("Expect MemberCountFromBackend=%d, got %d", expectedMemberCount, memberCount)
+	}
+	membersResp, err := m.Client.MemberList(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(membersResp.Members) != expectedMemberCount {
+		t.Errorf("Expect len(MemberList)=%d, got %d", expectedMemberCount, len(membersResp.Members))
+	}
+}
+
+func mustReadMemberCountFromBackend(t *testing.T, be backend.Backend) int {
+	tx := be.ReadTx()
+	tx.RLock()
+	defer tx.RUnlock()
+	count := 0
+	err := tx.UnsafeForEach(schema.Members, func(k, v []byte) error {
+		count++
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return count
+}