Ref/want err from err expected (#82)

consistent naming for test values using 'want' instead of 'expect/ed'

cli/cmd/init_test.go

@@ -77,7 +77,7 @@ func TestInitialize(t *testing.T) {
 		privKey               string
 		vpnHandler            vpnHandler
 		initVPN               bool
-		errExpected           bool
+		wantErr               bool
 	}{
 		"initialize some gcp instances": {
 			existingState: testGcpState,
@@ -112,33 +112,33 @@ func TestInitialize(t *testing.T) {
 			client: &fakeProtoClient{
 				respClient: &fakeActivationRespClient{responses: testActivationResps},
 			},
-			waiter:      &stubStatusWaiter{},
-			vpnHandler:  &stubVPNHandler{applyErr: someErr},
-			initVPN:     true,
-			privKey:     testKey,
-			errExpected: true,
+			waiter:     &stubStatusWaiter{},
+			vpnHandler: &stubVPNHandler{applyErr: someErr},
+			initVPN:    true,
+			privKey:    testKey,
+			wantErr:    true,
 		},
 		"invalid create vpn config": {
 			existingState: testAzureState,
 			client: &fakeProtoClient{
 				respClient: &fakeActivationRespClient{responses: testActivationResps},
 			},
-			waiter:      &stubStatusWaiter{},
-			vpnHandler:  &stubVPNHandler{createErr: someErr},
-			initVPN:     true,
-			privKey:     testKey,
-			errExpected: true,
+			waiter:     &stubStatusWaiter{},
+			vpnHandler: &stubVPNHandler{createErr: someErr},
+			initVPN:    true,
+			privKey:    testKey,
+			wantErr:    true,
 		},
 		"invalid write vpn config": {
 			existingState: testAzureState,
 			client: &fakeProtoClient{
 				respClient: &fakeActivationRespClient{responses: testActivationResps},
 			},
-			waiter:      &stubStatusWaiter{},
-			vpnHandler:  &stubVPNHandler{marshalErr: someErr},
-			initVPN:     true,
-			privKey:     testKey,
-			errExpected: true,
+			waiter:     &stubStatusWaiter{},
+			vpnHandler: &stubVPNHandler{marshalErr: someErr},
+			initVPN:    true,
+			privKey:    testKey,
+			wantErr:    true,
 		},
 		"no state exists": {
 			existingState: state.ConstellationState{},
@@ -146,18 +146,18 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"no instances to pick one": {
 			existingState: state.ConstellationState{
 				EC2Instances:     ec2.Instances{},
 				EC2SecurityGroup: "sg-test",
 			},
-			client:      &stubProtoClient{},
-			waiter:      &stubStatusWaiter{},
-			privKey:     testKey,
-			vpnHandler:  &stubVPNHandler{},
-			errExpected: true,
+			client:     &stubProtoClient{},
+			waiter:     &stubStatusWaiter{},
+			privKey:    testKey,
+			vpnHandler: &stubVPNHandler{},
+			wantErr:    true,
 		},
 		"public key to short": {
 			existingState: testGcpState,
@@ -165,7 +165,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       base64.StdEncoding.EncodeToString([]byte("tooShortKey")),
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"public key to long": {
 			existingState: testGcpState,
@@ -173,7 +173,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       base64.StdEncoding.EncodeToString([]byte("thisWireguardKeyIsToLongAndHasTooManyBytes")),
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"public key not base64": {
 			existingState: testGcpState,
@@ -181,7 +181,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       "this is not base64 encoded",
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail Connect": {
 			existingState: testGcpState,
@@ -189,7 +189,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail Activate": {
 			existingState: testGcpState,
@@ -197,7 +197,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail respClient WriteLogStream": {
 			existingState: testGcpState,
@@ -205,7 +205,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail respClient getKubeconfig": {
 			existingState: testGcpState,
@@ -213,7 +213,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail respClient getCoordinatorVpnKey": {
 			existingState: testGcpState,
@@ -221,7 +221,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail respClient getClientVpnIp": {
 			existingState: testGcpState,
@@ -229,7 +229,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail respClient getOwnerID": {
 			existingState: testGcpState,
@@ -237,7 +237,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail respClient getClusterID": {
 			existingState: testGcpState,
@@ -245,7 +245,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail to wait for required status": {
 			existingState: testGcpState,
@@ -253,7 +253,7 @@ func TestInitialize(t *testing.T) {
 			waiter:        &stubStatusWaiter{waitForAllErr: someErr},
 			privKey:       testKey,
 			vpnHandler:    &stubVPNHandler{},
-			errExpected:   true,
+			wantErr:       true,
 		},
 		"fail to create service account": {
 			existingState:         testGcpState,
@@ -262,7 +262,7 @@ func TestInitialize(t *testing.T) {
 			waiter:                &stubStatusWaiter{},
 			privKey:               testKey,
 			vpnHandler:            &stubVPNHandler{},
-			errExpected:           true,
+			wantErr:               true,
 		},
 	}
 
@@ -294,7 +294,7 @@ func TestInitialize(t *testing.T) {
 
 			err := initialize(ctx, cmd, tc.client, &tc.serviceAccountCreator, fileHandler, tc.waiter, tc.vpnHandler)
 
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				require.NoError(err)
@@ -343,28 +343,28 @@ func TestIpsToEndpoints(t *testing.T) {
 
 func TestInitCompletion(t *testing.T) {
 	testCases := map[string]struct {
-		args            []string
-		toComplete      string
-		resultExpected  []string
-		shellCDExpected cobra.ShellCompDirective
+		args        []string
+		toComplete  string
+		wantResult  []string
+		wantShellCD cobra.ShellCompDirective
 	}{
 		"first arg": {
-			args:            []string{},
-			toComplete:      "hello",
-			resultExpected:  []string{},
-			shellCDExpected: cobra.ShellCompDirectiveDefault,
+			args:        []string{},
+			toComplete:  "hello",
+			wantResult:  []string{},
+			wantShellCD: cobra.ShellCompDirectiveDefault,
 		},
 		"secnod arg": {
-			args:            []string{"23"},
-			toComplete:      "/test/h",
-			resultExpected:  []string{},
-			shellCDExpected: cobra.ShellCompDirectiveError,
+			args:        []string{"23"},
+			toComplete:  "/test/h",
+			wantResult:  []string{},
+			wantShellCD: cobra.ShellCompDirectiveError,
 		},
 		"third arg": {
-			args:            []string{"./file", "sth"},
-			toComplete:      "./file",
-			resultExpected:  []string{},
-			shellCDExpected: cobra.ShellCompDirectiveError,
+			args:        []string{"./file", "sth"},
+			toComplete:  "./file",
+			wantResult:  []string{},
+			wantShellCD: cobra.ShellCompDirectiveError,
 		},
 	}
 
@@ -374,8 +374,8 @@ func TestInitCompletion(t *testing.T) {
 
 			cmd := &cobra.Command{}
 			result, shellCD := initCompletion(cmd, tc.args, tc.toComplete)
-			assert.Equal(tc.resultExpected, result)
-			assert.Equal(tc.shellCDExpected, shellCD)
+			assert.Equal(tc.wantResult, result)
+			assert.Equal(tc.wantShellCD, shellCD)
 		})
 	}
 }
@@ -406,55 +406,55 @@ func TestReadOrGeneratedMasterSecret(t *testing.T) {
 		filecontent string
 		createFile  bool
 		fs          func() afero.Fs
-		errExpected bool
+		wantErr     bool
 	}{
 		"file with secret exists": {
 			filename:    "someSecret",
 			filecontent: base64.StdEncoding.EncodeToString([]byte("ConstellationSecret")),
 			createFile:  true,
 			fs:          afero.NewMemMapFs,
-			errExpected: false,
+			wantErr:     false,
 		},
 		"no file given": {
 			filename:    "",
 			filecontent: "",
 			fs:          afero.NewMemMapFs,
-			errExpected: false,
+			wantErr:     false,
 		},
 		"file does not exist": {
 			filename:    "nonExistingSecret",
 			filecontent: "",
 			createFile:  false,
 			fs:          afero.NewMemMapFs,
-			errExpected: true,
+			wantErr:     true,
 		},
 		"file is empty": {
 			filename:    "emptySecret",
 			filecontent: "",
 			createFile:  true,
 			fs:          afero.NewMemMapFs,
-			errExpected: true,
+			wantErr:     true,
 		},
 		"secret too short": {
 			filename:    "shortSecret",
 			filecontent: base64.StdEncoding.EncodeToString([]byte("short")),
 			createFile:  true,
 			fs:          afero.NewMemMapFs,
-			errExpected: true,
+			wantErr:     true,
 		},
 		"secret not encoded": {
 			filename:    "unencodedSecret",
 			filecontent: "Constellation",
 			createFile:  true,
 			fs:          afero.NewMemMapFs,
-			errExpected: true,
+			wantErr:     true,
 		},
 		"file not writeable": {
 			filename:    "",
 			filecontent: "",
 			createFile:  false,
 			fs:          func() afero.Fs { return afero.NewReadOnlyFs(afero.NewMemMapFs()) },
-			errExpected: true,
+			wantErr:     true,
 		},
 	}
 
@@ -472,7 +472,7 @@ func TestReadOrGeneratedMasterSecret(t *testing.T) {
 			var out bytes.Buffer
 			secret, err := readOrGeneratedMasterSecret(&out, fileHandler, tc.filename)
 
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)

cli/cmd/terminate_test.go

@@ -15,8 +15,8 @@ import (
 
 func TestTerminateCmdArgumentValidation(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"no args":         {[]string{}, false},
 		"some args":       {[]string{"hello", "test"}, true},
@@ -30,7 +30,7 @@ func TestTerminateCmdArgumentValidation(t *testing.T) {
 			cmd := newTerminateCmd()
 			err := cmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)

cli/cmd/userinteraction_test.go

@@ -30,8 +30,8 @@ func TestAskToConfirm(t *testing.T) {
 	}
 
 	testCases := map[string]struct {
-		input       string
-		expectedErr error
+		input   string
+		wantErr error
 	}{
 		"user confirms":                       {"y\n", nil},
 		"user confirms long":                  {"yes\n", nil},
@@ -53,7 +53,7 @@ func TestAskToConfirm(t *testing.T) {
 			cmd.SetIn(in)
 
 			err := cmd.Execute()
-			assert.ErrorIs(err, tc.expectedErr)
+			assert.ErrorIs(err, tc.wantErr)
 
 			output, err := io.ReadAll(out)
 			assert.NoError(err)
@@ -66,10 +66,10 @@ func TestWarnAboutPCRs(t *testing.T) {
 	zero := []byte("00000000000000000000000000000000")
 
 	testCases := map[string]struct {
-		pcrs             map[uint32][]byte
-		dontWarnInit     bool
-		expectedWarnings []string
-		errExpected      bool
+		pcrs         map[uint32][]byte
+		dontWarnInit bool
+		wantWarnings []string
+		wantErr      bool
 	}{
 		"no warnings": {
 			pcrs: map[uint32][]byte{
@@ -114,7 +114,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 				11: zero,
 				12: zero,
 			},
-			expectedWarnings: []string{"BIOS"},
+			wantWarnings: []string{"BIOS"},
 		},
 		"warn for OPROM": {
 			pcrs: map[uint32][]byte{
@@ -128,7 +128,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 				11: zero,
 				12: zero,
 			},
-			expectedWarnings: []string{"OPROM"},
+			wantWarnings: []string{"OPROM"},
 		},
 		"warn for MBR": {
 			pcrs: map[uint32][]byte{
@@ -142,7 +142,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 				11: zero,
 				12: zero,
 			},
-			expectedWarnings: []string{"MBR"},
+			wantWarnings: []string{"MBR"},
 		},
 		"warn for kernel": {
 			pcrs: map[uint32][]byte{
@@ -156,7 +156,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 				11: zero,
 				12: zero,
 			},
-			expectedWarnings: []string{"kernel"},
+			wantWarnings: []string{"kernel"},
 		},
 		"warn for initrd": {
 			pcrs: map[uint32][]byte{
@@ -170,7 +170,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 				11: zero,
 				12: zero,
 			},
-			expectedWarnings: []string{"initrd"},
+			wantWarnings: []string{"initrd"},
 		},
 		"warn for initialization": {
 			pcrs: map[uint32][]byte{
@@ -184,8 +184,8 @@ func TestWarnAboutPCRs(t *testing.T) {
 				9:  zero,
 				11: zero,
 			},
-			dontWarnInit:     false,
-			expectedWarnings: []string{"initialization"},
+			dontWarnInit: false,
+			wantWarnings: []string{"initialization"},
 		},
 		"don't warn for initialization": {
 			pcrs: map[uint32][]byte{
@@ -203,7 +203,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 		},
 		"multi warning": {
 			pcrs: map[uint32][]byte{},
-			expectedWarnings: []string{
+			wantWarnings: []string{
 				"BIOS",
 				"OPROM",
 				"MBR",
@@ -216,7 +216,7 @@ func TestWarnAboutPCRs(t *testing.T) {
 			pcrs: map[uint32][]byte{
 				0: []byte("000"),
 			},
-			errExpected: true,
+			wantErr: true,
 		},
 	}
 
@@ -231,14 +231,14 @@ func TestWarnAboutPCRs(t *testing.T) {
 			cmd.SetErr(&errOut)
 
 			err := warnAboutPCRs(cmd, tc.pcrs, !tc.dontWarnInit)
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
-				if len(tc.expectedWarnings) == 0 {
+				if len(tc.wantWarnings) == 0 {
 					assert.Empty(errOut.String())
 				} else {
-					for _, warning := range tc.expectedWarnings {
+					for _, warning := range tc.wantWarnings {
 						assert.Contains(errOut.String(), warning)
 					}
 				}

cli/cmd/validargs_test.go

@@ -9,8 +9,8 @@ import (
 
 func TestIsIntArg(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"valid int 1":                {[]string{"1"}, false},
 		"valid int 2":                {[]string{"42"}, false},
@@ -31,7 +31,7 @@ func TestIsIntArg(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -42,8 +42,8 @@ func TestIsIntArg(t *testing.T) {
 
 func TestIsIntGreaterArg(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"valid int 1":                  {[]string{"13"}, false},
 		"valid int 2":                  {[]string{"42"}, false},
@@ -61,7 +61,7 @@ func TestIsIntGreaterArg(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -72,8 +72,8 @@ func TestIsIntGreaterArg(t *testing.T) {
 
 func TestIsIntGreaterZeroArg(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"valid int 1":                {[]string{"13"}, false},
 		"valid int 2":                {[]string{"42"}, false},
@@ -91,7 +91,7 @@ func TestIsIntGreaterZeroArg(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -102,8 +102,8 @@ func TestIsIntGreaterZeroArg(t *testing.T) {
 
 func TestIsEC2InstanceType(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"is instance type 1":    {[]string{"4xl"}, false},
 		"is instance type 2":    {[]string{"12xlarge", "something else"}, false},
@@ -119,7 +119,7 @@ func TestIsEC2InstanceType(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -130,8 +130,8 @@ func TestIsEC2InstanceType(t *testing.T) {
 
 func TestIsGCPInstanceType(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"is instance type 1":    {[]string{"n2d-standard-4"}, false},
 		"is instance type 2":    {[]string{"n2d-standard-16", "something else"}, false},
@@ -147,7 +147,7 @@ func TestIsGCPInstanceType(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -158,8 +158,8 @@ func TestIsGCPInstanceType(t *testing.T) {
 
 func TestIsAzureInstanceType(t *testing.T) {
 	testCases := map[string]struct {
-		args      []string
-		expectErr bool
+		args    []string
+		wantErr bool
 	}{
 		"is instance type 1":    {[]string{"Standard_DC2as_v5"}, false},
 		"is instance type 2":    {[]string{"Standard_DC8as_v5", "something else"}, false},
@@ -175,7 +175,7 @@ func TestIsAzureInstanceType(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -189,7 +189,7 @@ func TestIsInstanceTypeForProvider(t *testing.T) {
 		typePos     int
 		providerPos int
 		args        []string
-		expectErr   bool
+		wantErr     bool
 	}{
 		"valid gcp type 1":          {1, 0, []string{"gcp", "n2d-standard-4"}, false},
 		"valid gcp type 2":          {1, 0, []string{"gcp", "n2d-standard-16", "foo"}, false},
@@ -213,7 +213,7 @@ func TestIsInstanceTypeForProvider(t *testing.T) {
 
 			err := testCmd.ValidateArgs(tc.args)
 
-			if tc.expectErr {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)

cli/cmd/verify_azure_test.go

@@ -11,29 +11,29 @@ import (
 
 func TestGetAzureValidator(t *testing.T) {
 	testCases := map[string]struct {
-		ownerID     string
-		clusterID   string
-		errExpected bool
+		ownerID   string
+		clusterID string
+		wantErr   bool
 	}{
 		"no input": {
-			ownerID:     "",
-			clusterID:   "",
-			errExpected: true,
+			ownerID:   "",
+			clusterID: "",
+			wantErr:   true,
 		},
 		"unencoded secret ID": {
-			ownerID:     "owner-id",
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: true,
+			ownerID:   "owner-id",
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   true,
 		},
 		"unencoded cluster ID": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   "unique-id",
-			errExpected: true,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: "unique-id",
+			wantErr:   true,
 		},
 		"correct input": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: false,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   false,
 		},
 	}
 
@@ -56,7 +56,7 @@ func TestGetAzureValidator(t *testing.T) {
 				0: []byte("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"),
 				1: []byte("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"),
 			})
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)

cli/cmd/verify_gcp_noncvm_test.go

@@ -11,29 +11,29 @@ import (
 
 func TestGetGCPNonCVMValidator(t *testing.T) {
 	testCases := map[string]struct {
-		ownerID     string
-		clusterID   string
-		errExpected bool
+		ownerID   string
+		clusterID string
+		wantErr   bool
 	}{
 		"no input": {
-			ownerID:     "",
-			clusterID:   "",
-			errExpected: true,
+			ownerID:   "",
+			clusterID: "",
+			wantErr:   true,
 		},
 		"unencoded secret ID": {
-			ownerID:     "owner-id",
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: true,
+			ownerID:   "owner-id",
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   true,
 		},
 		"unencoded cluster ID": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   "unique-id",
-			errExpected: true,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: "unique-id",
+			wantErr:   true,
 		},
 		"correct input": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: false,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   false,
 		},
 	}
 
@@ -53,7 +53,7 @@ func TestGetGCPNonCVMValidator(t *testing.T) {
 			cmd.SetErr(&errOut)
 
 			_, err := getGCPNonCVMValidator(cmd, map[uint32][]byte{})
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)

cli/cmd/verify_gcp_test.go

@@ -11,29 +11,29 @@ import (
 
 func TestGetGCPValidator(t *testing.T) {
 	testCases := map[string]struct {
-		ownerID     string
-		clusterID   string
-		errExpected bool
+		ownerID   string
+		clusterID string
+		wantErr   bool
 	}{
 		"no input": {
-			ownerID:     "",
-			clusterID:   "",
-			errExpected: true,
+			ownerID:   "",
+			clusterID: "",
+			wantErr:   true,
 		},
 		"unencoded secret ID": {
-			ownerID:     "owner-id",
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: true,
+			ownerID:   "owner-id",
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   true,
 		},
 		"unencoded cluster ID": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   "unique-id",
-			errExpected: true,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: "unique-id",
+			wantErr:   true,
 		},
 		"correct input": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: false,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   false,
 		},
 	}
 
@@ -56,7 +56,7 @@ func TestGetGCPValidator(t *testing.T) {
 				0: []byte("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"),
 				1: []byte("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"),
 			})
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)

cli/cmd/verify_test.go

@@ -23,40 +23,40 @@ import (
 
 func TestVerify(t *testing.T) {
 	testCases := map[string]struct {
-		connErr     error
-		checkErr    error
-		state       state.State
-		errExpected bool
+		connErr  error
+		checkErr error
+		state    state.State
+		wantErr  bool
 	}{
 		"connection error": {
-			connErr:     errors.New("connection error"),
-			checkErr:    nil,
-			state:       0,
-			errExpected: true,
+			connErr:  errors.New("connection error"),
+			checkErr: nil,
+			state:    0,
+			wantErr:  true,
 		},
 		"check error": {
-			connErr:     nil,
-			checkErr:    errors.New("check error"),
-			state:       0,
-			errExpected: true,
+			connErr:  nil,
+			checkErr: errors.New("check error"),
+			state:    0,
+			wantErr:  true,
 		},
 		"check error, rpc status": {
-			connErr:     nil,
-			checkErr:    rpcStatus.Error(codes.Unavailable, "check error"),
-			state:       0,
-			errExpected: true,
+			connErr:  nil,
+			checkErr: rpcStatus.Error(codes.Unavailable, "check error"),
+			state:    0,
+			wantErr:  true,
 		},
 		"verify on worker node": {
-			connErr:     nil,
-			checkErr:    nil,
-			state:       state.IsNode,
-			errExpected: false,
+			connErr:  nil,
+			checkErr: nil,
+			state:    state.IsNode,
+			wantErr:  false,
 		},
 		"verify on master node": {
-			connErr:     nil,
-			checkErr:    nil,
-			state:       state.ActivatingNodes,
-			errExpected: false,
+			connErr:  nil,
+			checkErr: nil,
+			state:    state.ActivatingNodes,
+			wantErr:  false,
 		},
 	}
 
@@ -81,7 +81,7 @@ func TestVerify(t *testing.T) {
 			}
 			err := verify(ctx, &out, "", []atls.Validator{gcp.NewValidator(pcrs)}, verifier)
 
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -130,29 +130,29 @@ func (c *stubPeerStatusClient) GetState(ctx context.Context, in *pubproto.GetSta
 
 func TestPrepareValidator(t *testing.T) {
 	testCases := map[string]struct {
-		ownerID     string
-		clusterID   string
-		errExpected bool
+		ownerID   string
+		clusterID string
+		wantErr   bool
 	}{
 		"no input": {
-			ownerID:     "",
-			clusterID:   "",
-			errExpected: true,
+			ownerID:   "",
+			clusterID: "",
+			wantErr:   true,
 		},
 		"unencoded secret ID": {
-			ownerID:     "owner-id",
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: true,
+			ownerID:   "owner-id",
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   true,
 		},
 		"unencoded cluster ID": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   "unique-id",
-			errExpected: true,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: "unique-id",
+			wantErr:   true,
 		},
 		"correct input": {
-			ownerID:     base64.StdEncoding.EncodeToString([]byte("owner-id")),
-			clusterID:   base64.StdEncoding.EncodeToString([]byte("unique-id")),
-			errExpected: false,
+			ownerID:   base64.StdEncoding.EncodeToString([]byte("owner-id")),
+			clusterID: base64.StdEncoding.EncodeToString([]byte("unique-id")),
+			wantErr:   false,
 		},
 	}
 
@@ -177,7 +177,7 @@ func TestPrepareValidator(t *testing.T) {
 			}
 
 			err := prepareValidator(cmd, pcrs)
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
@@ -204,60 +204,60 @@ func TestAddOrSkipPcr(t *testing.T) {
 	}
 
 	testCases := map[string]struct {
-		pcrMap          map[uint32][]byte
-		pcrIndex        uint32
-		encoded         string
-		expectedEntries int
-		errExpected     bool
+		pcrMap      map[uint32][]byte
+		pcrIndex    uint32
+		encoded     string
+		wantEntries int
+		wantErr     bool
 	}{
 		"empty input, empty map": {
-			pcrMap:          emptyMap,
-			pcrIndex:        10,
-			encoded:         "",
-			expectedEntries: 0,
-			errExpected:     false,
+			pcrMap:      emptyMap,
+			pcrIndex:    10,
+			encoded:     "",
+			wantEntries: 0,
+			wantErr:     false,
 		},
 		"empty input, default map": {
-			pcrMap:          defaultMap,
-			pcrIndex:        10,
-			encoded:         "",
-			expectedEntries: len(defaultMap),
-			errExpected:     false,
+			pcrMap:      defaultMap,
+			pcrIndex:    10,
+			encoded:     "",
+			wantEntries: len(defaultMap),
+			wantErr:     false,
 		},
 		"correct input, empty map": {
-			pcrMap:          emptyMap,
-			pcrIndex:        10,
-			encoded:         base64.StdEncoding.EncodeToString([]byte("Constellation")),
-			expectedEntries: 1,
-			errExpected:     false,
+			pcrMap:      emptyMap,
+			pcrIndex:    10,
+			encoded:     base64.StdEncoding.EncodeToString([]byte("Constellation")),
+			wantEntries: 1,
+			wantErr:     false,
 		},
 		"correct input, default map": {
-			pcrMap:          defaultMap,
-			pcrIndex:        10,
-			encoded:         base64.StdEncoding.EncodeToString([]byte("Constellation")),
-			expectedEntries: len(defaultMap) + 1,
-			errExpected:     false,
+			pcrMap:      defaultMap,
+			pcrIndex:    10,
+			encoded:     base64.StdEncoding.EncodeToString([]byte("Constellation")),
+			wantEntries: len(defaultMap) + 1,
+			wantErr:     false,
 		},
 		"unencoded input, empty map": {
-			pcrMap:          emptyMap,
-			pcrIndex:        10,
-			encoded:         "Constellation",
-			expectedEntries: 0,
-			errExpected:     true,
+			pcrMap:      emptyMap,
+			pcrIndex:    10,
+			encoded:     "Constellation",
+			wantEntries: 0,
+			wantErr:     true,
 		},
 		"unencoded input, default map": {
-			pcrMap:          defaultMap,
-			pcrIndex:        10,
-			encoded:         "Constellation",
-			expectedEntries: len(defaultMap),
-			errExpected:     true,
+			pcrMap:      defaultMap,
+			pcrIndex:    10,
+			encoded:     "Constellation",
+			wantEntries: len(defaultMap),
+			wantErr:     true,
 		},
 		"empty input at occupied index": {
-			pcrMap:          defaultMap,
-			pcrIndex:        0,
-			encoded:         "",
-			expectedEntries: len(defaultMap) - 1,
-			errExpected:     false,
+			pcrMap:      defaultMap,
+			pcrIndex:    0,
+			encoded:     "",
+			wantEntries: len(defaultMap) - 1,
+			wantErr:     false,
 		},
 	}
 
@@ -272,12 +272,12 @@ func TestAddOrSkipPcr(t *testing.T) {
 
 			err := addOrSkipPCR(res, tc.pcrIndex, tc.encoded)
 
-			if tc.errExpected {
+			if tc.wantErr {
 				assert.Error(err)
 			} else {
 				assert.NoError(err)
 			}
-			assert.Len(res, tc.expectedEntries)
+			assert.Len(res, tc.wantEntries)
 			for _, v := range res {
 				assert.Len(v, 32)
 			}
@@ -287,28 +287,28 @@ func TestAddOrSkipPcr(t *testing.T) {
 
 func TestVerifyCompletion(t *testing.T) {
 	testCases := map[string]struct {
-		args            []string
-		toComplete      string
-		resultExpected  []string
-		shellCDExpected cobra.ShellCompDirective
+		args        []string
+		toComplete  string
+		wantResult  []string
+		wantShellCD cobra.ShellCompDirective
 	}{
 		"first arg": {
-			args:            []string{},
-			toComplete:      "192.0.2.1",
-			resultExpected:  []string{},
-			shellCDExpected: cobra.ShellCompDirectiveNoFileComp,
+			args:        []string{},
+			toComplete:  "192.0.2.1",
+			wantResult:  []string{},
+			wantShellCD: cobra.ShellCompDirectiveNoFileComp,
 		},
 		"second arg": {
-			args:            []string{"192.0.2.1"},
-			toComplete:      "443",
-			resultExpected:  []string{},
-			shellCDExpected: cobra.ShellCompDirectiveNoFileComp,
+			args:        []string{"192.0.2.1"},
+			toComplete:  "443",
+			wantResult:  []string{},
+			wantShellCD: cobra.ShellCompDirectiveNoFileComp,
 		},
 		"third arg": {
-			args:            []string{"192.0.2.1", "443"},
-			toComplete:      "./file",
-			resultExpected:  []string{},
-			shellCDExpected: cobra.ShellCompDirectiveError,
+			args:        []string{"192.0.2.1", "443"},
+			toComplete:  "./file",
+			wantResult:  []string{},
+			wantShellCD: cobra.ShellCompDirectiveError,
 		},
 	}
 
@@ -318,8 +318,8 @@ func TestVerifyCompletion(t *testing.T) {
 
 			cmd := &cobra.Command{}
 			result, shellCD := verifyCompletion(cmd, tc.args, tc.toComplete)
-			assert.Equal(tc.resultExpected, result)
-			assert.Equal(tc.shellCDExpected, shellCD)
+			assert.Equal(tc.wantResult, result)
+			assert.Equal(tc.wantShellCD, shellCD)
 		})
 	}
 }