mirror of
https://github.com/edgelesssys/constellation.git
synced 2025-11-13 00:50:38 -05:00
Ref/want err from err expected (#82)
consistent naming for test values using 'want' instead of 'expect/ed'
This commit is contained in:
datosh
GitHub
parent
6265b307af
commit
51068abc27
91 changed files with 2319 additions and 2319 deletions
|
|
@ -34,78 +34,78 @@ func TestActivateAsCoordinator(t *testing.T) {
|
|||
testNode1 := newStubPeer("192.0.2.11", []byte{1, 2, 3})
|
||||
testNode2 := newStubPeer("192.0.2.12", []byte{2, 3, 4})
|
||||
testNode3 := newStubPeer("192.0.2.13", []byte{3, 4, 5})
|
||||
expectedNode1 := peer.Peer{PublicIP: "192.0.2.11", VPNIP: "10.118.0.11", VPNPubKey: []byte{1, 2, 3}, Role: role.Node}
|
||||
expectedNode2 := peer.Peer{PublicIP: "192.0.2.12", VPNIP: "10.118.0.12", VPNPubKey: []byte{2, 3, 4}, Role: role.Node}
|
||||
expectedNode3 := peer.Peer{PublicIP: "192.0.2.13", VPNIP: "10.118.0.13", VPNPubKey: []byte{3, 4, 5}, Role: role.Node}
|
||||
expectedCoord := peer.Peer{PublicIP: "192.0.2.1", VPNIP: "10.118.0.1", VPNPubKey: coordinatorPubKey, Role: role.Coordinator}
|
||||
wantNode1 := peer.Peer{PublicIP: "192.0.2.11", VPNIP: "10.118.0.11", VPNPubKey: []byte{1, 2, 3}, Role: role.Node}
|
||||
wantNode2 := peer.Peer{PublicIP: "192.0.2.12", VPNIP: "10.118.0.12", VPNPubKey: []byte{2, 3, 4}, Role: role.Node}
|
||||
wantNode3 := peer.Peer{PublicIP: "192.0.2.13", VPNIP: "10.118.0.13", VPNPubKey: []byte{3, 4, 5}, Role: role.Node}
|
||||
wantCoord := peer.Peer{PublicIP: "192.0.2.1", VPNIP: "10.118.0.1", VPNPubKey: coordinatorPubKey, Role: role.Coordinator}
|
||||
adminPeer := peer.Peer{VPNPubKey: []byte{7, 8, 9}, Role: role.Admin}
|
||||
|
||||
testCases := map[string]struct {
|
||||
nodes []*stubPeer
|
||||
state state.State
|
||||
switchToPersistentStoreErr error
|
||||
expectErr bool
|
||||
expectedPeers []peer.Peer
|
||||
expectedState state.State
|
||||
wantErr bool
|
||||
wantPeers []peer.Peer
|
||||
wantState state.State
|
||||
adminVPNIP string
|
||||
}{
|
||||
"0 nodes": {
|
||||
state: state.AcceptingInit,
|
||||
expectedPeers: []peer.Peer{expectedCoord},
|
||||
expectedState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.11",
|
||||
state: state.AcceptingInit,
|
||||
wantPeers: []peer.Peer{wantCoord},
|
||||
wantState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.11",
|
||||
},
|
||||
"1 node": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.AcceptingInit,
|
||||
expectedPeers: []peer.Peer{expectedCoord, expectedNode1},
|
||||
expectedState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.12",
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.AcceptingInit,
|
||||
wantPeers: []peer.Peer{wantCoord, wantNode1},
|
||||
wantState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.12",
|
||||
},
|
||||
"2 nodes": {
|
||||
nodes: []*stubPeer{testNode1, testNode2},
|
||||
state: state.AcceptingInit,
|
||||
expectedPeers: []peer.Peer{expectedCoord, expectedNode1, expectedNode2},
|
||||
expectedState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.13",
|
||||
nodes: []*stubPeer{testNode1, testNode2},
|
||||
state: state.AcceptingInit,
|
||||
wantPeers: []peer.Peer{wantCoord, wantNode1, wantNode2},
|
||||
wantState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.13",
|
||||
},
|
||||
"3 nodes": {
|
||||
nodes: []*stubPeer{testNode1, testNode2, testNode3},
|
||||
state: state.AcceptingInit,
|
||||
expectedPeers: []peer.Peer{expectedCoord, expectedNode1, expectedNode2, expectedNode3},
|
||||
expectedState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.14",
|
||||
nodes: []*stubPeer{testNode1, testNode2, testNode3},
|
||||
state: state.AcceptingInit,
|
||||
wantPeers: []peer.Peer{wantCoord, wantNode1, wantNode2, wantNode3},
|
||||
wantState: state.ActivatingNodes,
|
||||
adminVPNIP: "10.118.0.14",
|
||||
},
|
||||
"already activated": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
expectedState: state.ActivatingNodes,
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
wantState: state.ActivatingNodes,
|
||||
},
|
||||
"wrong peer kind": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.IsNode,
|
||||
expectErr: true,
|
||||
expectedState: state.IsNode,
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.IsNode,
|
||||
wantErr: true,
|
||||
wantState: state.IsNode,
|
||||
},
|
||||
"node activation error": {
|
||||
nodes: []*stubPeer{testNode1, {activateErr: someErr}, testNode3},
|
||||
state: state.AcceptingInit,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
nodes: []*stubPeer{testNode1, {activateErr: someErr}, testNode3},
|
||||
state: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
"node join error": {
|
||||
nodes: []*stubPeer{testNode1, {joinErr: someErr}, testNode3},
|
||||
state: state.AcceptingInit,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
nodes: []*stubPeer{testNode1, {joinErr: someErr}, testNode3},
|
||||
state: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
"SwitchToPersistentStore error": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.AcceptingInit,
|
||||
switchToPersistentStoreErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -162,9 +162,9 @@ func TestActivateAsCoordinator(t *testing.T) {
|
|||
StorageUri: kms.NoStoreURI,
|
||||
}, stream)
|
||||
|
||||
assert.Equal(tc.expectedState, core.state)
|
||||
assert.Equal(tc.wantState, core.state)
|
||||
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -188,7 +188,7 @@ func TestActivateAsCoordinator(t *testing.T) {
|
|||
assert.Equal(vpnIP, core.vpnIP)
|
||||
// construct full list of expected peers
|
||||
adminPeer.VPNIP = tc.adminVPNIP
|
||||
assert.Equal(append(tc.expectedPeers, adminPeer), core.peers)
|
||||
assert.Equal(append(tc.wantPeers, adminPeer), core.peers)
|
||||
assert.Equal(autoscalingNodeGroups, core.autoscalingNodeGroups)
|
||||
assert.Equal(keyEncryptionKeyID, core.kekID)
|
||||
assert.Equal([]role.Role{role.Coordinator}, core.persistNodeStateRoles)
|
||||
|
|
@ -201,52 +201,52 @@ func TestActivateAdditionalNodes(t *testing.T) {
|
|||
testNode1 := newStubPeer("192.0.2.11", []byte{1, 2, 3})
|
||||
testNode2 := newStubPeer("192.0.2.12", []byte{2, 3, 4})
|
||||
testNode3 := newStubPeer("192.0.2.13", []byte{3, 4, 5})
|
||||
expectedNode1 := peer.Peer{PublicIP: "192.0.2.11", VPNIP: "10.118.0.11", VPNPubKey: []byte{1, 2, 3}, Role: role.Node}
|
||||
expectedNode2 := peer.Peer{PublicIP: "192.0.2.12", VPNIP: "10.118.0.12", VPNPubKey: []byte{2, 3, 4}, Role: role.Node}
|
||||
expectedNode3 := peer.Peer{PublicIP: "192.0.2.13", VPNIP: "10.118.0.13", VPNPubKey: []byte{3, 4, 5}, Role: role.Node}
|
||||
wantNode1 := peer.Peer{PublicIP: "192.0.2.11", VPNIP: "10.118.0.11", VPNPubKey: []byte{1, 2, 3}, Role: role.Node}
|
||||
wantNode2 := peer.Peer{PublicIP: "192.0.2.12", VPNIP: "10.118.0.12", VPNPubKey: []byte{2, 3, 4}, Role: role.Node}
|
||||
wantNode3 := peer.Peer{PublicIP: "192.0.2.13", VPNIP: "10.118.0.13", VPNPubKey: []byte{3, 4, 5}, Role: role.Node}
|
||||
|
||||
testCases := map[string]struct {
|
||||
nodes []*stubPeer
|
||||
state state.State
|
||||
expectErr bool
|
||||
expectedPeers []peer.Peer
|
||||
nodes []*stubPeer
|
||||
state state.State
|
||||
wantErr bool
|
||||
wantPeers []peer.Peer
|
||||
}{
|
||||
"0 nodes": {
|
||||
state: state.ActivatingNodes,
|
||||
},
|
||||
"1 node": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.ActivatingNodes,
|
||||
expectedPeers: []peer.Peer{expectedNode1},
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.ActivatingNodes,
|
||||
wantPeers: []peer.Peer{wantNode1},
|
||||
},
|
||||
"2 nodes": {
|
||||
nodes: []*stubPeer{testNode1, testNode2},
|
||||
state: state.ActivatingNodes,
|
||||
expectedPeers: []peer.Peer{expectedNode1, expectedNode2},
|
||||
nodes: []*stubPeer{testNode1, testNode2},
|
||||
state: state.ActivatingNodes,
|
||||
wantPeers: []peer.Peer{wantNode1, wantNode2},
|
||||
},
|
||||
"3 nodes": {
|
||||
nodes: []*stubPeer{testNode1, testNode2, testNode3},
|
||||
state: state.ActivatingNodes,
|
||||
expectedPeers: []peer.Peer{expectedNode1, expectedNode2, expectedNode3},
|
||||
nodes: []*stubPeer{testNode1, testNode2, testNode3},
|
||||
state: state.ActivatingNodes,
|
||||
wantPeers: []peer.Peer{wantNode1, wantNode2, wantNode3},
|
||||
},
|
||||
"uninitialized": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
expectErr: true,
|
||||
nodes: []*stubPeer{testNode1},
|
||||
wantErr: true,
|
||||
},
|
||||
"wrong peer kind": {
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.IsNode,
|
||||
expectErr: true,
|
||||
nodes: []*stubPeer{testNode1},
|
||||
state: state.IsNode,
|
||||
wantErr: true,
|
||||
},
|
||||
"node activation error": {
|
||||
nodes: []*stubPeer{testNode1, {activateErr: someErr}, testNode3},
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
nodes: []*stubPeer{testNode1, {activateErr: someErr}, testNode3},
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
},
|
||||
"node join error": {
|
||||
nodes: []*stubPeer{testNode1, {joinErr: someErr}, testNode3},
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
nodes: []*stubPeer{testNode1, {joinErr: someErr}, testNode3},
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -283,7 +283,7 @@ func TestActivateAdditionalNodes(t *testing.T) {
|
|||
require.NoError(core.InitializeStoreIPs())
|
||||
stream := &stubActivateAdditionalNodesServer{}
|
||||
err := api.ActivateAdditionalNodes(&pubproto.ActivateAdditionalNodesRequest{NodePublicIps: nodePublicIPs}, stream)
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -296,7 +296,7 @@ func TestActivateAdditionalNodes(t *testing.T) {
|
|||
}
|
||||
|
||||
// Core is updated
|
||||
assert.Equal(tc.expectedPeers, core.peers)
|
||||
assert.Equal(tc.wantPeers, core.peers)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -316,7 +316,7 @@ func TestAssemblePeerStruct(t *testing.T) {
|
|||
|
||||
vpnIP, err := core.GetVPNIP()
|
||||
require.NoError(err)
|
||||
expected := peer.Peer{
|
||||
want := peer.Peer{
|
||||
PublicIP: "192.0.2.1",
|
||||
VPNIP: vpnIP,
|
||||
VPNPubKey: vpnPubKey,
|
||||
|
|
@ -325,7 +325,7 @@ func TestAssemblePeerStruct(t *testing.T) {
|
|||
|
||||
actual, err := api.assemblePeerStruct(vpnIP, role.Coordinator)
|
||||
require.NoError(err)
|
||||
assert.Equal(expected, actual)
|
||||
assert.Equal(want, actual)
|
||||
}
|
||||
|
||||
type stubPeer struct {
|
||||
|
|
@ -452,28 +452,28 @@ func TestRequestStateDiskKey(t *testing.T) {
|
|||
dataKey []byte
|
||||
getDataKeyErr error
|
||||
pushKeyErr error
|
||||
errExpected bool
|
||||
wantErr bool
|
||||
}{
|
||||
"success": {
|
||||
state: state.ActivatingNodes,
|
||||
dataKey: defaultKey,
|
||||
},
|
||||
"Coordinator in wrong state": {
|
||||
state: state.IsNode,
|
||||
dataKey: defaultKey,
|
||||
errExpected: true,
|
||||
state: state.IsNode,
|
||||
dataKey: defaultKey,
|
||||
wantErr: true,
|
||||
},
|
||||
"GetDataKey fails": {
|
||||
state: state.ActivatingNodes,
|
||||
dataKey: defaultKey,
|
||||
getDataKeyErr: someErr,
|
||||
errExpected: true,
|
||||
wantErr: true,
|
||||
},
|
||||
"key pushing fails": {
|
||||
state: state.ActivatingNodes,
|
||||
dataKey: defaultKey,
|
||||
pushKeyErr: someErr,
|
||||
errExpected: true,
|
||||
state: state.ActivatingNodes,
|
||||
dataKey: defaultKey,
|
||||
pushKeyErr: someErr,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -515,7 +515,7 @@ func TestRequestStateDiskKey(t *testing.T) {
|
|||
api := New(zaptest.NewLogger(t), core, &net.Dialer{}, nil, dummyValidator{}, nil, getPeerFromContext)
|
||||
|
||||
_, err = api.RequestStateDiskKey(ctx, &pubproto.RequestStateDiskKeyRequest{})
|
||||
if tc.errExpected {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
} else {
|
||||
assert.NoError(err)
|
||||
|
|
|
|||
|
|
@ -30,39 +30,39 @@ func TestActivateAsAdditionalCoordinator(t *testing.T) {
|
|||
testCases := map[string]struct {
|
||||
coordinators stubPeer
|
||||
state state.State
|
||||
expectedState state.State
|
||||
wantState state.State
|
||||
vpnapi stubVPNAPI
|
||||
expectErr bool
|
||||
wantErr bool
|
||||
switchToPersistentStoreErr error
|
||||
k8sJoinargsErr error
|
||||
k8sCertKeyErr error
|
||||
}{
|
||||
"basic": {
|
||||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
expectedState: state.ActivatingNodes,
|
||||
vpnapi: stubVPN,
|
||||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
wantState: state.ActivatingNodes,
|
||||
vpnapi: stubVPN,
|
||||
},
|
||||
"already activated": {
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
expectedState: state.ActivatingNodes,
|
||||
vpnapi: stubVPN,
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
wantState: state.ActivatingNodes,
|
||||
vpnapi: stubVPN,
|
||||
},
|
||||
"SwitchToPersistentStore error": {
|
||||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
switchToPersistentStoreErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
vpnapi: stubVPN,
|
||||
},
|
||||
"GetK8SJoinArgs error": {
|
||||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
switchToPersistentStoreErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
vpnapi: stubVPN,
|
||||
k8sJoinargsErr: someErr,
|
||||
},
|
||||
|
|
@ -70,8 +70,8 @@ func TestActivateAsAdditionalCoordinator(t *testing.T) {
|
|||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
switchToPersistentStoreErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
vpnapi: stubVPN,
|
||||
k8sCertKeyErr: someErr,
|
||||
},
|
||||
|
|
@ -113,9 +113,9 @@ func TestActivateAsAdditionalCoordinator(t *testing.T) {
|
|||
ClusterId: core.clusterID,
|
||||
})
|
||||
|
||||
assert.Equal(tc.expectedState, core.state)
|
||||
assert.Equal(tc.wantState, core.state)
|
||||
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -135,21 +135,21 @@ func TestTriggerCoordinatorUpdate(t *testing.T) {
|
|||
peers []peer.Peer
|
||||
state state.State
|
||||
getUpdateErr error
|
||||
expectErr bool
|
||||
wantErr bool
|
||||
}{
|
||||
"basic": {
|
||||
peers: peers,
|
||||
state: state.ActivatingNodes,
|
||||
},
|
||||
"not activated": {
|
||||
peers: peers,
|
||||
state: state.AcceptingInit,
|
||||
expectErr: true,
|
||||
peers: peers,
|
||||
state: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
},
|
||||
"wrong peer kind": {
|
||||
peers: peers,
|
||||
state: state.IsNode,
|
||||
expectErr: true,
|
||||
peers: peers,
|
||||
state: state.IsNode,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -168,7 +168,7 @@ func TestTriggerCoordinatorUpdate(t *testing.T) {
|
|||
api := New(logger, core, dialer, nil, nil, nil, nil)
|
||||
|
||||
_, err := api.TriggerCoordinatorUpdate(context.Background(), &pubproto.TriggerCoordinatorUpdateRequest{})
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -194,33 +194,33 @@ func TestActivateAdditionalCoordinators(t *testing.T) {
|
|||
state state.State
|
||||
activateErr error
|
||||
getPublicKeyErr error
|
||||
expectErr bool
|
||||
expectedState state.State
|
||||
wantErr bool
|
||||
wantState state.State
|
||||
}{
|
||||
"basic": {
|
||||
coordinators: testCoord1,
|
||||
state: state.ActivatingNodes,
|
||||
expectedState: state.ActivatingNodes,
|
||||
coordinators: testCoord1,
|
||||
state: state.ActivatingNodes,
|
||||
wantState: state.ActivatingNodes,
|
||||
},
|
||||
"Activation Err": {
|
||||
coordinators: testCoord1,
|
||||
state: state.ActivatingNodes,
|
||||
expectedState: state.ActivatingNodes,
|
||||
activateErr: someErr,
|
||||
expectErr: true,
|
||||
coordinators: testCoord1,
|
||||
state: state.ActivatingNodes,
|
||||
wantState: state.ActivatingNodes,
|
||||
activateErr: someErr,
|
||||
wantErr: true,
|
||||
},
|
||||
"Not in exprected state": {
|
||||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
expectedState: state.AcceptingInit,
|
||||
expectErr: true,
|
||||
coordinators: testCoord1,
|
||||
state: state.AcceptingInit,
|
||||
wantState: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
},
|
||||
"getPeerPublicKey error": {
|
||||
coordinators: testCoord1,
|
||||
state: state.ActivatingNodes,
|
||||
expectedState: state.ActivatingNodes,
|
||||
wantState: state.ActivatingNodes,
|
||||
getPublicKeyErr: someErr,
|
||||
expectErr: true,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -254,9 +254,9 @@ func TestActivateAdditionalCoordinators(t *testing.T) {
|
|||
|
||||
_, err := api.ActivateAdditionalCoordinator(context.Background(), &pubproto.ActivateAdditionalCoordinatorRequest{CoordinatorPublicIp: tc.coordinators.peer.PublicIP})
|
||||
|
||||
assert.Equal(tc.expectedState, core.state)
|
||||
assert.Equal(tc.wantState, core.state)
|
||||
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -272,7 +272,7 @@ func TestGetPeerVPNPublicKey(t *testing.T) {
|
|||
testCases := map[string]struct {
|
||||
coordinator stubPeer
|
||||
getVPNPubKeyErr error
|
||||
expectErr bool
|
||||
wantErr bool
|
||||
}{
|
||||
"basic": {
|
||||
coordinator: testCoord,
|
||||
|
|
@ -280,7 +280,7 @@ func TestGetPeerVPNPublicKey(t *testing.T) {
|
|||
"Activation Err": {
|
||||
coordinator: testCoord,
|
||||
getVPNPubKeyErr: someErr,
|
||||
expectErr: true,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -304,7 +304,7 @@ func TestGetPeerVPNPublicKey(t *testing.T) {
|
|||
|
||||
resp, err := api.GetPeerVPNPublicKey(context.Background(), &pubproto.GetPeerVPNPublicKeyRequest{})
|
||||
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,75 +35,75 @@ func TestActivateAsNode(t *testing.T) {
|
|||
getUpdateErr error
|
||||
setVPNIPErr error
|
||||
messageSequenceOverride []string
|
||||
expectErr bool
|
||||
expectedState state.State
|
||||
wantErr bool
|
||||
wantState state.State
|
||||
}{
|
||||
"basic": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
expectedState: state.NodeWaitingForClusterJoin,
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
wantState: state.NodeWaitingForClusterJoin,
|
||||
},
|
||||
"already activated": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.IsNode,
|
||||
expectErr: true,
|
||||
expectedState: state.IsNode,
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.IsNode,
|
||||
wantErr: true,
|
||||
wantState: state.IsNode,
|
||||
},
|
||||
"wrong peer kind": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
expectedState: state.ActivatingNodes,
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
wantState: state.ActivatingNodes,
|
||||
},
|
||||
"GetUpdate error": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
getUpdateErr: someErr,
|
||||
expectedState: state.NodeWaitingForClusterJoin,
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
getUpdateErr: someErr,
|
||||
wantState: state.NodeWaitingForClusterJoin,
|
||||
},
|
||||
"SetVPNIP error": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
setVPNIPErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
setVPNIPErr: someErr,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
"no messages sent to node": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
messageSequenceOverride: []string{},
|
||||
expectErr: true,
|
||||
expectedState: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
wantState: state.AcceptingInit,
|
||||
},
|
||||
"only initial message sent to node": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
messageSequenceOverride: []string{"initialRequest"},
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
"wrong initial message sent to node": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
messageSequenceOverride: []string{"stateDiskKey"},
|
||||
expectErr: true,
|
||||
expectedState: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
wantState: state.AcceptingInit,
|
||||
},
|
||||
"initial message sent twice to node": {
|
||||
initialPeers: []peer.Peer{peer1},
|
||||
updatedPeers: []peer.Peer{peer2},
|
||||
state: state.AcceptingInit,
|
||||
messageSequenceOverride: []string{"initialRequest", "initialRequest"},
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -146,9 +146,9 @@ func TestActivateAsNode(t *testing.T) {
|
|||
defer pubserver.GracefulStop()
|
||||
|
||||
_, nodeVPNPubKey, err := activateNode(require, dialer, messageSequence, nodeIP, "9000", nodeVPNIP, peer.ToPubProto(tc.initialPeers), ownerID, clusterID, stateDiskKey)
|
||||
assert.Equal(tc.expectedState, cor.state)
|
||||
assert.Equal(tc.wantState, cor.state)
|
||||
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -184,27 +184,27 @@ func TestTriggerNodeUpdate(t *testing.T) {
|
|||
peers []peer.Peer
|
||||
state state.State
|
||||
getUpdateErr error
|
||||
expectErr bool
|
||||
wantErr bool
|
||||
}{
|
||||
"basic": {
|
||||
peers: peers,
|
||||
state: state.IsNode,
|
||||
},
|
||||
"not activated": {
|
||||
peers: peers,
|
||||
state: state.AcceptingInit,
|
||||
expectErr: true,
|
||||
peers: peers,
|
||||
state: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
},
|
||||
"wrong peer kind": {
|
||||
peers: peers,
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
peers: peers,
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
},
|
||||
"GetUpdate error": {
|
||||
peers: peers,
|
||||
state: state.IsNode,
|
||||
getUpdateErr: someErr,
|
||||
expectErr: true,
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -229,7 +229,7 @@ func TestTriggerNodeUpdate(t *testing.T) {
|
|||
defer vserver.GracefulStop()
|
||||
|
||||
_, err := api.TriggerNodeUpdate(context.Background(), &pubproto.TriggerNodeUpdateRequest{})
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
@ -252,34 +252,34 @@ func TestJoinCluster(t *testing.T) {
|
|||
state state.State
|
||||
getJoinArgsErr error
|
||||
joinClusterErr error
|
||||
expectErr bool
|
||||
expectedState state.State
|
||||
wantErr bool
|
||||
wantState state.State
|
||||
}{
|
||||
"basic": {
|
||||
state: state.NodeWaitingForClusterJoin,
|
||||
expectedState: state.IsNode,
|
||||
state: state.NodeWaitingForClusterJoin,
|
||||
wantState: state.IsNode,
|
||||
},
|
||||
"not activated": {
|
||||
state: state.AcceptingInit,
|
||||
expectErr: true,
|
||||
expectedState: state.AcceptingInit,
|
||||
state: state.AcceptingInit,
|
||||
wantErr: true,
|
||||
wantState: state.AcceptingInit,
|
||||
},
|
||||
"wrong peer kind": {
|
||||
state: state.ActivatingNodes,
|
||||
expectErr: true,
|
||||
expectedState: state.ActivatingNodes,
|
||||
state: state.ActivatingNodes,
|
||||
wantErr: true,
|
||||
wantState: state.ActivatingNodes,
|
||||
},
|
||||
"GetK8sJoinArgs error": {
|
||||
state: state.NodeWaitingForClusterJoin,
|
||||
getJoinArgsErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.NodeWaitingForClusterJoin,
|
||||
wantErr: true,
|
||||
wantState: state.NodeWaitingForClusterJoin,
|
||||
},
|
||||
"JoinCluster error": {
|
||||
state: state.NodeWaitingForClusterJoin,
|
||||
joinClusterErr: someErr,
|
||||
expectErr: true,
|
||||
expectedState: state.Failed,
|
||||
wantErr: true,
|
||||
wantState: state.Failed,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -309,9 +309,9 @@ func TestJoinCluster(t *testing.T) {
|
|||
|
||||
_, err := api.JoinCluster(context.Background(), &pubproto.JoinClusterRequest{CoordinatorVpnIp: "192.0.2.1"})
|
||||
|
||||
assert.Equal(tc.expectedState, core.state)
|
||||
assert.Equal(tc.wantState, core.state)
|
||||
|
||||
if tc.expectErr {
|
||||
if tc.wantErr {
|
||||
assert.Error(err)
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,14 +23,14 @@ func TestGetRecoveryPeerFromContext(t *testing.T) {
|
|||
assert := assert.New(t)
|
||||
testIP := "192.0.2.1"
|
||||
testPort := 1234
|
||||
expectedPeer := net.JoinHostPort(testIP, "9000")
|
||||
wantPeer := net.JoinHostPort(testIP, "9000")
|
||||
|
||||
addr := &net.TCPAddr{IP: net.ParseIP(testIP), Port: testPort}
|
||||
ctx := grpcpeer.NewContext(context.Background(), &grpcpeer.Peer{Addr: addr})
|
||||
|
||||
peer, err := GetRecoveryPeerFromContext(ctx)
|
||||
assert.NoError(err)
|
||||
assert.Equal(expectedPeer, peer)
|
||||
assert.Equal(wantPeer, peer)
|
||||
|
||||
_, err = GetRecoveryPeerFromContext(context.Background())
|
||||
assert.Error(err)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue