luxolus
/
open-consul
2
0
Fork 0
Code Issues 1 Pull Requests Packages Releases Wiki Activity

Update retries that weren't using retry.R (#6146)

This commit is contained in:
Freddy 2019-07-16 14:47:45 -06:00 committed by GitHub
parent 9f7800e2f6
commit 99601aa3a7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 75 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
agent/consul/catalog_endpoint_test.go
View File

@ -1049,7 +1049,7 @@ func TestCatalog_ListNodes_StaleRead(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
if err := msgpackrpc.CallWithCodec(codec, "Catalog.ListNodes", &args, &out); err != nil { if err := msgpackrpc.CallWithCodec(codec, "Catalog.ListNodes", &args, &out); err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
found := false found := false

30
agent/coordinate_endpoint_test.go
View File

@ -84,17 +84,17 @@ func TestCoordinate_Nodes(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
obj, err := a.srv.CoordinateNodes(resp, req) obj, err := a.srv.CoordinateNodes(resp, req)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
// Check that coordinates are empty before registering a node // Check that coordinates are empty before registering a node
coordinates, ok := obj.(structs.Coordinates) coordinates, ok := obj.(structs.Coordinates)
if !ok { if !ok {
t.Fatalf("expected: structs.Coordinates, received: %+v", obj) r.Fatalf("expected: structs.Coordinates, received: %+v", obj)
} }
if len(coordinates) != 0 { if len(coordinates) != 0 {
t.Fatalf("coordinates should be empty, received: %v", coordinates) r.Fatalf("coordinates should be empty, received: %v", coordinates)
} }
}) })
@ -141,17 +141,17 @@ func TestCoordinate_Nodes(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
obj, err := a.srv.CoordinateNodes(resp, req) obj, err := a.srv.CoordinateNodes(resp, req)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
coordinates, ok := obj.(structs.Coordinates) coordinates, ok := obj.(structs.Coordinates)
if !ok { if !ok {
t.Fatalf("expected: structs.Coordinates, received: %+v", obj) r.Fatalf("expected: structs.Coordinates, received: %+v", obj)
} }
if len(coordinates) != 2 || if len(coordinates) != 2 ||
coordinates[0].Node != "bar" || coordinates[0].Node != "bar" ||
coordinates[1].Node != "foo" { coordinates[1].Node != "foo" {
t.Fatalf("expected: bar, foo recieved: %v", coordinates) r.Fatalf("expected: bar, foo recieved: %v", coordinates)
} }
}) })
// Filter on a nonexistent node segment // Filter on a nonexistent node segment
@ -160,15 +160,15 @@ func TestCoordinate_Nodes(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
obj, err := a.srv.CoordinateNodes(resp, req) obj, err := a.srv.CoordinateNodes(resp, req)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
coordinates, ok := obj.(structs.Coordinates) coordinates, ok := obj.(structs.Coordinates)
if !ok { if !ok {
t.Fatalf("expected: structs.Coordinates, received: %+v", obj) r.Fatalf("expected: structs.Coordinates, received: %+v", obj)
} }
if len(coordinates) != 0 { if len(coordinates) != 0 {
t.Fatalf("coordinates should be empty, received: %v", coordinates) r.Fatalf("coordinates should be empty, received: %v", coordinates)
} }
}) })
// Filter on a real node segment // Filter on a real node segment
@ -177,15 +177,15 @@ func TestCoordinate_Nodes(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
obj, err := a.srv.CoordinateNodes(resp, req) obj, err := a.srv.CoordinateNodes(resp, req)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
coordinates, ok := obj.(structs.Coordinates) coordinates, ok := obj.(structs.Coordinates)
if !ok { if !ok {
t.Fatalf("expected: structs.Coordinates, received: %+v", obj) r.Fatalf("expected: structs.Coordinates, received: %+v", obj)
} }
if len(coordinates) != 1 || coordinates[0].Node != "foo" { if len(coordinates) != 1 || coordinates[0].Node != "foo" {
t.Fatalf("expected: foo received: %v", coordinates) r.Fatalf("expected: foo received: %v", coordinates)
} }
}) })
// Make sure the empty filter works // Make sure the empty filter works
@ -194,15 +194,15 @@ func TestCoordinate_Nodes(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
obj, err := a.srv.CoordinateNodes(resp, req) obj, err := a.srv.CoordinateNodes(resp, req)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
coordinates, ok := obj.(structs.Coordinates) coordinates, ok := obj.(structs.Coordinates)
if !ok { if !ok {
t.Fatalf("expected: structs.Coordinates, received: %+v", obj) r.Fatalf("expected: structs.Coordinates, received: %+v", obj)
} }
if len(coordinates) != 1 || coordinates[0].Node != "bar" { if len(coordinates) != 1 || coordinates[0].Node != "bar" {
t.Fatalf("expected: bar received: %v", coordinates) r.Fatalf("expected: bar received: %v", coordinates)
} }
}) })
} }

59
agent/remote_exec_test.go
View File

@ -157,7 +157,9 @@ func testRemoteExecGetSpec(t *testing.T, hcl string, token string, shouldSucceed
t.Fatalf("err: %v", err) t.Fatalf("err: %v", err)
} }
key := "_rexec/" + event.Session + "/job" key := "_rexec/" + event.Session + "/job"
setKV(t, a.Agent, key, buf, token) if err := setKV(a.Agent, key, buf, token); err != nil {
t.Fatalf("err: %v", err)
}
var out remoteExecSpec var out remoteExecSpec
if shouldSucceed != a.remoteExecGetSpec(event, &out) { if shouldSucceed != a.remoteExecGetSpec(event, &out) {
@ -243,26 +245,26 @@ func testRemoteExecWrites(t *testing.T, hcl string, token string, shouldSucceed
} }
key := "_rexec/" + event.Session + "/" + a.Config.NodeName + "/ack" key := "_rexec/" + event.Session + "/" + a.Config.NodeName + "/ack"
d := getKV(t, a.Agent, key, token) d, err := getKV(a.Agent, key, token)
if d == nil || d.Session != event.Session { if d == nil || d.Session != event.Session || err != nil {
t.Fatalf("bad ack: %#v", d) t.Fatalf("bad ack: %#v", d)
} }
key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/out/00000" key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/out/00000"
d = getKV(t, a.Agent, key, token) d, err = getKV(a.Agent, key, token)
if d == nil || d.Session != event.Session || !bytes.Equal(d.Value, output) { if d == nil || d.Session != event.Session || !bytes.Equal(d.Value, output) || err != nil {
t.Fatalf("bad output: %#v", d) t.Fatalf("bad output: %#v", d)
} }
key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/out/0000a" key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/out/0000a"
d = getKV(t, a.Agent, key, token) d, err = getKV(a.Agent, key, token)
if d == nil || d.Session != event.Session || !bytes.Equal(d.Value, output) { if d == nil || d.Session != event.Session || !bytes.Equal(d.Value, output) || err != nil {
t.Fatalf("bad output: %#v", d) t.Fatalf("bad output: %#v", d)
} }
key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/exit" key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/exit"
d = getKV(t, a.Agent, key, token) d, err = getKV(a.Agent, key, token)
if d == nil || d.Session != event.Session || string(d.Value) != "1" { if d == nil || d.Session != event.Session || string(d.Value) != "1" || err != nil {
t.Fatalf("bad output: %#v", d) t.Fatalf("bad output: %#v", d)
} }
} }
@ -284,14 +286,16 @@ func testHandleRemoteExec(t *testing.T, command string, expectedSubstring string
} }
buf, err := json.Marshal(spec) buf, err := json.Marshal(spec)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
key := "_rexec/" + event.Session + "/job" key := "_rexec/" + event.Session + "/job"
setKV(t, a.Agent, key, buf, "") if err := setKV(a.Agent, key, buf, ""); err != nil {
r.Fatalf("err: %v", err)
}
buf, err = json.Marshal(event) buf, err = json.Marshal(event)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
msg := &UserEvent{ msg := &UserEvent{
ID: generateUUID(), ID: generateUUID(),
@ -303,24 +307,24 @@ func testHandleRemoteExec(t *testing.T, command string, expectedSubstring string
// Verify we have an ack // Verify we have an ack
key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/ack" key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/ack"
d := getKV(t, a.Agent, key, "") d, err := getKV(a.Agent, key, "")
if d == nil || d.Session != event.Session { if d == nil || d.Session != event.Session || err != nil {
t.Fatalf("bad ack: %#v", d) r.Fatalf("bad ack: %#v", d)
} }
// Verify we have output // Verify we have output
key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/out/00000" key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/out/00000"
d = getKV(t, a.Agent, key, "") d, err = getKV(a.Agent, key, "")
if d == nil || d.Session != event.Session || if d == nil || d.Session != event.Session ||
!bytes.Contains(d.Value, []byte(expectedSubstring)) { !bytes.Contains(d.Value, []byte(expectedSubstring)) || err != nil {
t.Fatalf("bad output: %#v", d) r.Fatalf("bad output: %#v", d)
} }
// Verify we have an exit code // Verify we have an exit code
key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/exit" key = "_rexec/" + event.Session + "/" + a.Config.NodeName + "/exit"
d = getKV(t, a.Agent, key, "") d, err = getKV(a.Agent, key, "")
if d == nil || d.Session != event.Session || string(d.Value) != expectedReturnCode { if d == nil || d.Session != event.Session || string(d.Value) != expectedReturnCode || err != nil {
t.Fatalf("bad output: %#v", d) r.Fatalf("bad output: %#v", d)
} }
}) })
} }
@ -371,7 +375,7 @@ func destroySession(t *testing.T, a *Agent, session string, token string) {
} }
} }
func setKV(t *testing.T, a *Agent, key string, val []byte, token string) { func setKV(a *Agent, key string, val []byte, token string) error {
write := structs.KVSRequest{ write := structs.KVSRequest{
Datacenter: a.config.Datacenter, Datacenter: a.config.Datacenter,
Op: api.KVSet, Op: api.KVSet,
@ -385,11 +389,12 @@ func setKV(t *testing.T, a *Agent, key string, val []byte, token string) {
} }
var success bool var success bool
if err := a.RPC("KVS.Apply", &write, &success); err != nil { if err := a.RPC("KVS.Apply", &write, &success); err != nil {
t.Fatalf("err: %v", err) return err
} }
return nil
} }
func getKV(t *testing.T, a *Agent, key string, token string) *structs.DirEntry { func getKV(a *Agent, key string, token string) (*structs.DirEntry, error) {
req := structs.KeyRequest{ req := structs.KeyRequest{
Datacenter: a.config.Datacenter, Datacenter: a.config.Datacenter,
Key: key, Key: key,
@ -399,10 +404,10 @@ func getKV(t *testing.T, a *Agent, key string, token string) *structs.DirEntry {
} }
var out structs.IndexedDirEntries var out structs.IndexedDirEntries
if err := a.RPC("KVS.Get", &req, &out); err != nil { if err := a.RPC("KVS.Get", &req, &out); err != nil {
t.Fatalf("err: %v", err) return nil, err
} }
if len(out.Entries) > 0 { if len(out.Entries) > 0 {
return out.Entries[0] return out.Entries[0], nil
} }
return nil return nil, nil
} }

6
api/acl_test.go
View File

@ -643,10 +643,10 @@ func TestAPI_RulesTranslate_FromToken(t *testing.T) {
// This relies on the token upgrade loop running in the background // This relies on the token upgrade loop running in the background
// to assign an accessor // to assign an accessor
retry.Run(t, func(t *retry.R) { retry.Run(t, func(r *retry.R) {
token, _, err := acl.TokenReadSelf(nil) token, _, err := acl.TokenReadSelf(nil)
require.NoError(t, err) require.NoError(r, err)
require.NotEqual(t, "", token.AccessorID) require.NotEqual(r, "", token.AccessorID)
accessor = token.AccessorID accessor = token.AccessorID
}) })
acl.c.config.Token = "root" acl.c.config.Token = "root"

22
api/catalog_test.go
View File

@ -342,10 +342,10 @@ func TestAPI_CatalogService_SingleTag(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
services, meta, err := catalog.Service("foo", "bar", nil) services, meta, err := catalog.Service("foo", "bar", nil)
require.NoError(t, err) require.NoError(r, err)
require.NotEqual(t, meta.LastIndex, 0) require.NotEqual(r, meta.LastIndex, 0)
require.Len(t, services, 1) require.Len(r, services, 1)
require.Equal(t, services[0].ServiceID, "foo1") require.Equal(r, services[0].ServiceID, "foo1")
}) })
} }
@ -380,23 +380,23 @@ func TestAPI_CatalogService_MultipleTags(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
services, meta, err := catalog.ServiceMultipleTags("foo", []string{"bar"}, nil) services, meta, err := catalog.ServiceMultipleTags("foo", []string{"bar"}, nil)
require.NoError(t, err) require.NoError(r, err)
require.NotEqual(t, meta.LastIndex, 0) require.NotEqual(r, meta.LastIndex, 0)
// Should be 2 services with the `bar` tag // Should be 2 services with the `bar` tag
require.Len(t, services, 2) require.Len(r, services, 2)
}) })
// Test searching with two tags (one result) // Test searching with two tags (one result)
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
services, meta, err := catalog.ServiceMultipleTags("foo", []string{"bar", "v2"}, nil) services, meta, err := catalog.ServiceMultipleTags("foo", []string{"bar", "v2"}, nil)
require.NoError(t, err) require.NoError(r, err)
require.NotEqual(t, meta.LastIndex, 0) require.NotEqual(r, meta.LastIndex, 0)
// Should be exactly 1 service, named "foo2" // Should be exactly 1 service, named "foo2"
require.Len(t, services, 1) require.Len(r, services, 1)
require.Equal(t, services[0].ServiceID, "foo2") require.Equal(r, services[0].ServiceID, "foo2")
}) })
} }

6
api/lock_test.go
View File

@ -109,10 +109,10 @@ func TestAPI_LockForceInvalidate(t *testing.T) {
// Should work // Should work
leaderCh, err := lock.Lock(nil) leaderCh, err := lock.Lock(nil)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
if leaderCh == nil { if leaderCh == nil {
t.Fatalf("not leader") r.Fatalf("not leader")
} }
defer lock.Unlock() defer lock.Unlock()
@ -127,7 +127,7 @@ func TestAPI_LockForceInvalidate(t *testing.T) {
select { select {
case <-leaderCh: case <-leaderCh:
case <-time.After(time.Second): case <-time.After(time.Second):
t.Fatalf("should not be leader") r.Fatalf("should not be leader")
} }
}) })
} }

12
api/operator_autopilot_test.go
View File

@ -46,10 +46,10 @@ func TestAPI_OperatorAutopilotCASConfiguration(t *testing.T) {
operator := c.Operator() operator := c.Operator()
config, err := operator.AutopilotGetConfiguration(nil) config, err := operator.AutopilotGetConfiguration(nil)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
if !config.CleanupDeadServers { if !config.CleanupDeadServers {
t.Fatalf("bad: %v", config) r.Fatalf("bad: %v", config)
} }
// Pass an invalid ModifyIndex // Pass an invalid ModifyIndex
@ -60,10 +60,10 @@ func TestAPI_OperatorAutopilotCASConfiguration(t *testing.T) {
} }
resp, err := operator.AutopilotCASConfiguration(newConf, nil) resp, err := operator.AutopilotCASConfiguration(newConf, nil)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
if resp { if resp {
t.Fatalf("bad: %v", resp) r.Fatalf("bad: %v", resp)
} }
} }
@ -75,10 +75,10 @@ func TestAPI_OperatorAutopilotCASConfiguration(t *testing.T) {
} }
resp, err := operator.AutopilotCASConfiguration(newConf, nil) resp, err := operator.AutopilotCASConfiguration(newConf, nil)
if err != nil { if err != nil {
t.Fatalf("err: %v", err) r.Fatalf("err: %v", err)
} }
if !resp { if !resp {
t.Fatalf("bad: %v", resp) r.Fatalf("bad: %v", resp)
} }
} }
}) })

9
command/connect/proxy/register_test.go
View File

@ -37,7 +37,6 @@ func TestRegisterMonitor_good(t *testing.T) {
func TestRegisterMonitor_heartbeat(t *testing.T) { func TestRegisterMonitor_heartbeat(t *testing.T) {
t.Parallel() t.Parallel()
require := require.New(t)
a := agent.NewTestAgent(t, t.Name(), ``) a := agent.NewTestAgent(t, t.Name(), ``)
defer a.Shutdown() defer a.Shutdown()
@ -49,11 +48,11 @@ func TestRegisterMonitor_heartbeat(t *testing.T) {
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {
// Get the check and verify that it is passing // Get the check and verify that it is passing
checks, err := client.Agent().Checks() checks, err := client.Agent().Checks()
require.NoError(err) require.NoError(r, err)
require.Contains(checks, m.checkID()) require.Contains(r, checks, m.checkID())
require.Equal("passing", checks[m.checkID()].Status) require.Equal(r, "passing", checks[m.checkID()].Status)
// Purposely fail the TTL check, verify it becomes healthy again // Purposely fail the TTL check, verify it becomes healthy again
require.NoError(client.Agent().FailTTL(m.checkID(), "")) require.NoError(r, client.Agent().FailTTL(m.checkID(), ""))
}) })
retry.Run(t, func(r *retry.R) { retry.Run(t, func(r *retry.R) {