Skip to content

Commit

Permalink
Merge pull request #13812 from endocrimes/dani/leases
Browse files Browse the repository at this point in the history 
Migrate e2e Lease tests to common
  • Loading branch information
@serathius
serathius authored Mar 18, 2022
2 parents 34f0ab4 + 87740f6 commit 1b208aa
Show file tree
Hide file tree
Showing 11 changed files with 513 additions and 221 deletions.
2 changes: 1 addition & 1 deletion tests/common/compact_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,7 +47,7 @@ func TestCompact(t *testing.T) {
testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
var kvs = []testutils.KV{{Key: "key", Val: "val1"}, {Key: "key", Val: "val2"}, {Key: "key", Val: "val3"}}
for i := range kvs {
if err := clus.Client().Put(kvs[i].Key, kvs[i].Val); err != nil {
if err := clus.Client().Put(kvs[i].Key, kvs[i].Val, config.PutOptions{}); err != nil {
t.Fatalf("compactTest #%d: put kv error (%v)", i, err)
}
}
Expand Down
2 changes: 1 addition & 1 deletion tests/common/defrag_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ func TestDefragOnline(t *testing.T) {
defer clus.Close()
var kvs = []testutils.KV{{Key: "key", Val: "val1"}, {Key: "key", Val: "val2"}, {Key: "key", Val: "val3"}}
for i := range kvs {
if err := clus.Client().Put(kvs[i].Key, kvs[i].Val); err != nil {
if err := clus.Client().Put(kvs[i].Key, kvs[i].Val, config.PutOptions{}); err != nil {
t.Fatalf("compactTest #%d: put kv error (%v)", i, err)
}
}
Expand Down
6 changes: 3 additions & 3 deletions tests/common/kv_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -60,7 +60,7 @@ func TestKVPut(t *testing.T) {
testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
key, value := "foo", "bar"

if err := cc.Put(key, value); err != nil {
if err := cc.Put(key, value, config.PutOptions{}); err != nil {
t.Fatalf("count not put key %q, err: %s", key, err)
}
resp, err := cc.Get(key, config.GetOptions{Serializable: true})
Expand Down Expand Up @@ -123,7 +123,7 @@ func TestKVGet(t *testing.T) {
)

for i := range kvs {
if err := cc.Put(kvs[i], "bar"); err != nil {
if err := cc.Put(kvs[i], "bar", config.PutOptions{}); err != nil {
t.Fatalf("count not put key %q, err: %s", kvs[i], err)
}
}
Expand Down Expand Up @@ -246,7 +246,7 @@ func TestKVDelete(t *testing.T) {
}
for _, tt := range tests {
for i := range kvs {
if err := cc.Put(kvs[i], "bar"); err != nil {
if err := cc.Put(kvs[i], "bar", config.PutOptions{}); err != nil {
t.Fatalf("count not put key %q, err: %s", kvs[i], err)
}
}
Expand Down
322 changes: 322 additions & 0 deletions tests/common/lease_test.go
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,322 @@
// Copyright 2022 The etcd Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package common

import (
"testing"
"time"

"github.com/stretchr/testify/require"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/framework/config"
"go.etcd.io/etcd/tests/v3/framework/testutils"
)

func TestLeaseGrantTimeToLive(t *testing.T) {
testRunner.BeforeTest(t)

tcs := []struct {
name string
config config.ClusterConfig
}{
{
name: "NoTLS",
config: config.ClusterConfig{ClusterSize: 1},
},
{
name: "PeerTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.ManualTLS},
},
{
name: "PeerAutoTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.AutoTLS},
},
{
name: "ClientTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.ManualTLS},
},
{
name: "ClientAutoTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.AutoTLS},
},
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
clus := testRunner.NewCluster(t, tc.config)
defer clus.Close()
cc := clus.Client()

testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
ttl := int64(10)
leaseResp, err := cc.Grant(ttl)
require.NoError(t, err)

ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{})
require.NoError(t, err)
require.Equal(t, ttl, ttlResp.GrantedTTL)
})
})
}
}

func TestLeaseGrantAndList(t *testing.T) {
testRunner.BeforeTest(t)

tcs := []struct {
name string
config config.ClusterConfig
}{
{
name: "NoTLS",
config: config.ClusterConfig{ClusterSize: 1},
},
{
name: "PeerTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.ManualTLS},
},
{
name: "PeerAutoTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.AutoTLS},
},
{
name: "ClientTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.ManualTLS},
},
{
name: "ClientAutoTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.AutoTLS},
},
}
for _, tc := range tcs {
nestedCases := []struct {
name string
leaseCount int
}{
{
name: "no_leases",
leaseCount: 0,
},
{
name: "one_lease",
leaseCount: 1,
},
{
name: "many_leases",
leaseCount: 3,
},
}

for _, nc := range nestedCases {
t.Run(tc.name+"/"+nc.name, func(t *testing.T) {
clus := testRunner.NewCluster(t, tc.config)
defer clus.Close()
cc := clus.Client()

testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
createdLeases := []clientv3.LeaseID{}
for i := 0; i < nc.leaseCount; i++ {
leaseResp, err := cc.Grant(10)
require.NoError(t, err)
createdLeases = append(createdLeases, leaseResp.ID)
}

resp, err := cc.LeaseList()
require.NoError(t, err)
require.Len(t, resp.Leases, nc.leaseCount)

returnedLeases := make([]clientv3.LeaseID, 0, nc.leaseCount)
for _, status := range resp.Leases {
returnedLeases = append(returnedLeases, status.ID)
}

require.ElementsMatch(t, createdLeases, returnedLeases)
})
})
}
}
}

func TestLeaseGrantTimeToLiveExpired(t *testing.T) {
testRunner.BeforeTest(t)

tcs := []struct {
name string
config config.ClusterConfig
}{
{
name: "NoTLS",
config: config.ClusterConfig{ClusterSize: 1},
},
{
name: "PeerTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.ManualTLS},
},
{
name: "PeerAutoTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.AutoTLS},
},
{
name: "ClientTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.ManualTLS},
},
{
name: "ClientAutoTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.AutoTLS},
},
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
clus := testRunner.NewCluster(t, tc.config)
defer clus.Close()
cc := clus.Client()

testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
leaseResp, err := cc.Grant(2)
require.NoError(t, err)

err = cc.Put("foo", "bar", config.PutOptions{LeaseID: leaseResp.ID})
require.NoError(t, err)

getResp, err := cc.Get("foo", config.GetOptions{})
require.NoError(t, err)
require.Equal(t, int64(1), getResp.Count)

time.Sleep(3 * time.Second)

ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{})
require.NoError(t, err)
require.Equal(t, int64(-1), ttlResp.TTL)

getResp, err = cc.Get("foo", config.GetOptions{})
require.NoError(t, err)
// Value should expire with the lease
require.Equal(t, int64(0), getResp.Count)
})
})
}
}

func TestLeaseGrantKeepAliveOnce(t *testing.T) {
testRunner.BeforeTest(t)

tcs := []struct {
name string
config config.ClusterConfig
}{
{
name: "NoTLS",
config: config.ClusterConfig{ClusterSize: 1},
},
{
name: "PeerTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.ManualTLS},
},
{
name: "PeerAutoTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.AutoTLS},
},
{
name: "ClientTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.ManualTLS},
},
{
name: "ClientAutoTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.AutoTLS},
},
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
clus := testRunner.NewCluster(t, tc.config)
defer clus.Close()
cc := clus.Client()

testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
leaseResp, err := cc.Grant(2)
require.NoError(t, err)

_, err = cc.LeaseKeepAliveOnce(leaseResp.ID)
require.NoError(t, err)

time.Sleep(2 * time.Second) // Wait for the original lease to expire

ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{})
require.NoError(t, err)
// We still have a lease!
require.Greater(t, int64(2), ttlResp.TTL)
})
})
}
}

func TestLeaseGrantRevoke(t *testing.T) {
testRunner.BeforeTest(t)

tcs := []struct {
name string
config config.ClusterConfig
}{
{
name: "NoTLS",
config: config.ClusterConfig{ClusterSize: 1},
},
{
name: "PeerTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.ManualTLS},
},
{
name: "PeerAutoTLS",
config: config.ClusterConfig{ClusterSize: 3, PeerTLS: config.AutoTLS},
},
{
name: "ClientTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.ManualTLS},
},
{
name: "ClientAutoTLS",
config: config.ClusterConfig{ClusterSize: 1, ClientTLS: config.AutoTLS},
},
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
clus := testRunner.NewCluster(t, tc.config)
defer clus.Close()
cc := clus.Client()

testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
leaseResp, err := cc.Grant(20)
require.NoError(t, err)

err = cc.Put("foo", "bar", config.PutOptions{LeaseID: leaseResp.ID})
require.NoError(t, err)

getResp, err := cc.Get("foo", config.GetOptions{})
require.NoError(t, err)
require.Equal(t, int64(1), getResp.Count)

_, err = cc.LeaseRevoke(leaseResp.ID)
require.NoError(t, err)

ttlResp, err := cc.TimeToLive(leaseResp.ID, config.LeaseOption{})
require.NoError(t, err)
require.Equal(t, int64(-1), ttlResp.TTL)

getResp, err = cc.Get("foo", config.GetOptions{})
require.NoError(t, err)
// Value should expire with the lease
require.Equal(t, int64(0), getResp.Count)
})
})
}
}
Loading

0 comments on commit 1b208aa

Please sign in to comment.