package pubapi import ( "context" "errors" "net" "testing" "github.com/edgelesssys/constellation/coordinator/peer" "github.com/edgelesssys/constellation/coordinator/pubapi/pubproto" "github.com/edgelesssys/constellation/coordinator/role" "github.com/edgelesssys/constellation/coordinator/state" "github.com/edgelesssys/constellation/coordinator/util/grpcutil" "github.com/edgelesssys/constellation/coordinator/util/testdialer" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" kubeadm "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3" ) func TestActivateAsAdditionalCoordinator(t *testing.T) { coordinatorPubKey := []byte{6, 7, 8} testCoord1 := stubPeer{peer: peer.Peer{PublicIP: "192.0.2.11", VPNPubKey: []byte{1, 2, 3}, VPNIP: "10.118.0.1", Role: role.Coordinator}} stubVPN := stubVPNAPI{joinArgs: kubeadm.BootstrapTokenDiscovery{ APIServerEndpoint: "endp", Token: "token", CACertHashes: []string{"dis"}, }} someErr := errors.New("some error") testCases := map[string]struct { coordinators stubPeer state state.State wantState state.State vpnapi stubVPNAPI wantErr bool switchToPersistentStoreErr error k8sJoinargsErr error k8sCertKeyErr error }{ "basic": { coordinators: testCoord1, state: state.AcceptingInit, wantState: state.ActivatingNodes, vpnapi: stubVPN, }, "already activated": { state: state.ActivatingNodes, wantErr: true, wantState: state.ActivatingNodes, vpnapi: stubVPN, }, "SwitchToPersistentStore error": { coordinators: testCoord1, state: state.AcceptingInit, switchToPersistentStoreErr: someErr, wantErr: true, wantState: state.Failed, vpnapi: stubVPN, }, "GetK8SJoinArgs error": { coordinators: testCoord1, state: state.AcceptingInit, switchToPersistentStoreErr: someErr, wantErr: true, wantState: state.Failed, vpnapi: stubVPN, k8sJoinargsErr: someErr, }, "GetK8SCertificateKeyErr error": { coordinators: testCoord1, state: state.AcceptingInit, switchToPersistentStoreErr: someErr, wantErr: true, wantState: state.Failed, vpnapi: stubVPN, k8sCertKeyErr: someErr, }, } for name, tc := range testCases { t.Run(name, func(t *testing.T) { assert := assert.New(t) require := require.New(t) tc.vpnapi.getJoinArgsErr = tc.k8sJoinargsErr tc.vpnapi.getK8SCertKeyErr = tc.k8sCertKeyErr core := &fakeCore{ state: tc.state, vpnPubKey: coordinatorPubKey, switchToPersistentStoreErr: tc.switchToPersistentStoreErr, kubeconfig: []byte("kubeconfig"), ownerID: []byte("ownerID"), clusterID: []byte("clusterID"), } netDialer := testdialer.NewBufconnDialer() dialer := grpcutil.NewDialer(fakeValidator{}, netDialer) getPublicIPAddr := func() (string, error) { return "192.0.2.1", nil } api := New(zaptest.NewLogger(t), core, dialer, stubVPNAPIServer{}, getPublicIPAddr, nil) defer api.Close() // spawn vpnServer vpnapiServer := tc.vpnapi.newServer() go vpnapiServer.Serve(netDialer.GetListener(net.JoinHostPort(tc.coordinators.peer.VPNIP, vpnAPIPort))) defer vpnapiServer.GracefulStop() _, err := api.ActivateAsAdditionalCoordinator(context.Background(), &pubproto.ActivateAsAdditionalCoordinatorRequest{ AssignedVpnIp: "10.118.0.2", ActivatingCoordinatorData: peer.ToPubProto([]peer.Peer{tc.coordinators.peer})[0], OwnerId: core.ownerID, ClusterId: core.clusterID, }) assert.Equal(tc.wantState, core.state) if tc.wantErr { assert.Error(err) return } require.NoError(err) }) } } func TestTriggerCoordinatorUpdate(t *testing.T) { // someErr := errors.New("failed") peers := []peer.Peer{ {PublicIP: "192.0.2.11:2000", VPNIP: "192.0.2.21", VPNPubKey: []byte{1, 2, 3}}, {PublicIP: "192.0.2.12:2000", VPNIP: "192.0.2.22", VPNPubKey: []byte{2, 3, 4}}, } testCases := map[string]struct { peers []peer.Peer state state.State getUpdateErr error wantErr bool }{ "basic": { peers: peers, state: state.ActivatingNodes, }, "not activated": { peers: peers, state: state.AcceptingInit, wantErr: true, }, "wrong peer kind": { peers: peers, state: state.IsNode, wantErr: true, }, } for name, tc := range testCases { t.Run(name, func(t *testing.T) { assert := assert.New(t) require := require.New(t) logger := zaptest.NewLogger(t) core := &fakeCore{ state: tc.state, peers: tc.peers, } dialer := grpcutil.NewDialer(fakeValidator{}, nil) api := New(logger, core, dialer, nil, nil, nil) _, err := api.TriggerCoordinatorUpdate(context.Background(), &pubproto.TriggerCoordinatorUpdateRequest{}) if tc.wantErr { assert.Error(err) return } require.NoError(err) // second update should be a noop _, err = api.TriggerCoordinatorUpdate(context.Background(), &pubproto.TriggerCoordinatorUpdateRequest{}) require.NoError(err) require.Len(core.updatedPeers, 1) assert.Equal(tc.peers, core.updatedPeers[0]) }) } } func TestActivateAdditionalCoordinators(t *testing.T) { someErr := errors.New("failed") coordinatorPubKey := []byte{6, 7, 8} testCoord1 := stubPeer{peer: peer.Peer{PublicIP: "192.0.2.11", VPNPubKey: []byte{1, 2, 3}, VPNIP: "10.118.0.1", Role: role.Coordinator}} testCases := map[string]struct { coordinators stubPeer state state.State activateErr error getPublicKeyErr error wantErr bool wantState state.State }{ "basic": { coordinators: testCoord1, state: state.ActivatingNodes, wantState: state.ActivatingNodes, }, "Activation Err": { coordinators: testCoord1, state: state.ActivatingNodes, wantState: state.ActivatingNodes, activateErr: someErr, wantErr: true, }, "Not in exprected state": { coordinators: testCoord1, state: state.AcceptingInit, wantState: state.AcceptingInit, wantErr: true, }, "getPeerPublicKey error": { coordinators: testCoord1, state: state.ActivatingNodes, wantState: state.ActivatingNodes, getPublicKeyErr: someErr, wantErr: true, }, } for name, tc := range testCases { t.Run(name, func(t *testing.T) { assert := assert.New(t) require := require.New(t) core := &fakeCore{ state: tc.state, vpnPubKey: coordinatorPubKey, kubeconfig: []byte("kubeconfig"), ownerID: []byte("ownerID"), clusterID: []byte("clusterID"), } netDialer := testdialer.NewBufconnDialer() dialer := grpcutil.NewDialer(fakeValidator{}, netDialer) getPublicIPAddr := func() (string, error) { return "192.0.2.1", nil } api := New(zaptest.NewLogger(t), core, dialer, stubVPNAPIServer{}, getPublicIPAddr, nil) defer api.Close() // spawn coordinator tc.coordinators.activateErr = tc.activateErr tc.coordinators.getPubKeyErr = tc.getPublicKeyErr server := tc.coordinators.newServer() go server.Serve(netDialer.GetListener(net.JoinHostPort(tc.coordinators.peer.PublicIP, endpointAVPNPort))) defer server.GracefulStop() _, err := api.ActivateAdditionalCoordinator(context.Background(), &pubproto.ActivateAdditionalCoordinatorRequest{CoordinatorPublicIp: tc.coordinators.peer.PublicIP}) assert.Equal(tc.wantState, core.state) if tc.wantErr { assert.Error(err) return } require.NoError(err) }) } } func TestGetPeerVPNPublicKey(t *testing.T) { someErr := errors.New("failed") testCoord := stubPeer{peer: peer.Peer{PublicIP: "192.0.2.11", VPNPubKey: []byte{1, 2, 3}, VPNIP: "10.118.0.1", Role: role.Coordinator}} testCases := map[string]struct { coordinator stubPeer getVPNPubKeyErr error wantErr bool }{ "basic": { coordinator: testCoord, }, "Activation Err": { coordinator: testCoord, getVPNPubKeyErr: someErr, wantErr: true, }, } for name, tc := range testCases { t.Run(name, func(t *testing.T) { assert := assert.New(t) require := require.New(t) core := &fakeCore{ vpnPubKey: tc.coordinator.peer.VPNPubKey, getvpnPubKeyErr: tc.getVPNPubKeyErr, } dialer := grpcutil.NewDialer(fakeValidator{}, testdialer.NewBufconnDialer()) getPublicIPAddr := func() (string, error) { return "192.0.2.1", nil } api := New(zaptest.NewLogger(t), core, dialer, stubVPNAPIServer{}, getPublicIPAddr, nil) defer api.Close() resp, err := api.GetPeerVPNPublicKey(context.Background(), &pubproto.GetPeerVPNPublicKeyRequest{}) if tc.wantErr { assert.Error(err) return } require.NoError(err) assert.Equal(tc.coordinator.peer.VPNPubKey, resp.CoordinatorPubKey) }) } }