refactor: use MockExecute and assert.EqualError in tests

kangasta · kangasta · commit 0ad7546c307a · 2022-07-01T11:43:39.000+03:00
Using assert.EqualError instead of assert.Errorf fixes error message validation.
diff --git a/internal/commands/account/show_test.go b/internal/commands/account/show_test.go
@@ -1,18 +1,16 @@
 package account
 
 import (
-	"bytes"
 	"testing"
 
 	"github.com/jedib0t/go-pretty/v6/text"
 
 	"github.com/UpCloudLtd/upcloud-cli/internal/commands"
 	"github.com/UpCloudLtd/upcloud-cli/internal/config"
 	smock "github.com/UpCloudLtd/upcloud-cli/internal/mock"
-	"github.com/UpCloudLtd/upcloud-cli/internal/output"
+	"github.com/UpCloudLtd/upcloud-cli/internal/mockexecute"
 
 	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud"
-	"github.com/gemalto/flume"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -58,13 +56,9 @@ func TestShowCommand(t *testing.T) {
 	conf.Viper().Set(config.KeyOutput, config.ValueOutputHuman)
 
 	command := commands.BuildCommand(testCmd, nil, conf)
-	out, err := command.(commands.NoArgumentCommand).ExecuteWithoutArguments(commands.NewExecutor(conf, mService, flume.New("test")))
-	assert.NoError(t, err)
+	output, err := mockexecute.MockExecute(command, mService, conf)
 
-	buf := bytes.NewBuffer(nil)
-	err = output.Render(buf, conf, out)
 	assert.NoError(t, err)
-	assert.Equal(t, expected, buf.String())
-
+	assert.Equal(t, expected, output)
 	mService.AssertNumberOfCalls(t, "GetAccount", 1)
 }
diff --git a/internal/commands/database/plans_test.go b/internal/commands/database/plans_test.go
@@ -1,17 +1,15 @@
 package database
 
 import (
-	"bytes"
 	"strings"
 	"testing"
 
 	"github.com/UpCloudLtd/upcloud-cli/internal/commands"
 	"github.com/UpCloudLtd/upcloud-cli/internal/config"
 	smock "github.com/UpCloudLtd/upcloud-cli/internal/mock"
-	"github.com/UpCloudLtd/upcloud-cli/internal/output"
+	"github.com/UpCloudLtd/upcloud-cli/internal/mockexecute"
 
 	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud"
-	"github.com/gemalto/flume"
 	"github.com/jedib0t/go-pretty/v6/text"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -38,16 +36,10 @@ func TestDatabasePlans_SortedHumanOutput(t *testing.T) {
 
 	command := commands.BuildCommand(PlansCommand(), nil, conf)
 
-	res, err := command.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, &mService, flume.New("test")), "pg")
-
-	assert.Nil(t, err)
-
-	buf := bytes.NewBuffer(nil)
-	err = output.Render(buf, conf, res)
-	output := buf.String()
+	command.Cobra().SetArgs([]string{"pg"})
+	output, err := mockexecute.MockExecute(command, &mService, conf)
 
 	assert.NoError(t, err)
-
 	assert.Less(t, strings.Index(output, "test-plan-1"), strings.Index(output, "test-plan-2"))
 	assert.Less(t, strings.Index(output, "test-plan-2"), strings.Index(output, "test-plan-3"))
 	assert.Less(t, strings.Index(output, "test-plan-3"), strings.Index(output, "test-plan-4"))
diff --git a/internal/commands/network/delete_test.go b/internal/commands/network/delete_test.go
@@ -43,7 +43,7 @@ func TestDeleteCommand(t *testing.T) {
 			_, err = c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, &mService, flume.New("test")), test.arg)
 
 			if test.error != "" {
-				assert.Errorf(t, err, test.error)
+				assert.EqualError(t, err, test.error)
 			} else {
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
 			}
diff --git a/internal/commands/networkinterface/create_test.go b/internal/commands/networkinterface/create_test.go
@@ -127,7 +127,7 @@ func TestCreateCommand(t *testing.T) {
 			_, err = c.(commands.SingleArgumentCommand).ExecuteSingleArgument(commands.NewExecutor(conf, &mService, flume.New("test")), server.UUID)
 
 			if test.error != "" {
-				assert.Errorf(t, err, test.error)
+				assert.EqualError(t, err, test.error)
 			} else {
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
 			}
diff --git a/internal/commands/networkinterface/delete_test.go b/internal/commands/networkinterface/delete_test.go
@@ -35,12 +35,12 @@ func TestDeleteCommand(t *testing.T) {
 		{
 			name:  "server is missing",
 			flags: []string{"--index", "4"},
-			error: "at least one server uuid is required",
+			error: "single server uuid is required",
 		},
 		{
 			name:  "index is missing",
 			arg:   server.UUID,
-			error: "index is required",
+			error: "interface index is required",
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
@@ -57,7 +57,7 @@ func TestDeleteCommand(t *testing.T) {
 			_, err = c.(commands.SingleArgumentCommand).ExecuteSingleArgument(commands.NewExecutor(conf, &mService, flume.New("test")), test.arg)
 
 			if test.error != "" {
-				assert.Errorf(t, err, test.error)
+				assert.EqualError(t, err, test.error)
 			} else {
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
 			}
diff --git a/internal/commands/networkinterface/modify_test.go b/internal/commands/networkinterface/modify_test.go
@@ -77,7 +77,7 @@ func TestModifyCommand(t *testing.T) {
 			_, err = c.(commands.SingleArgumentCommand).ExecuteSingleArgument(commands.NewExecutor(conf, &mService, flume.New("test")), server.UUID)
 
 			if test.error != "" {
-				assert.Errorf(t, err, test.error)
+				assert.EqualError(t, err, test.error)
 			} else {
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
 			}
diff --git a/internal/commands/serverfirewall/create_test.go b/internal/commands/serverfirewall/create_test.go
@@ -101,8 +101,7 @@ func TestCreateFirewallRuleCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(cc, &mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, "CreateFirewallRule", 1)
diff --git a/internal/commands/serverstorage/attach_test.go b/internal/commands/serverstorage/attach_test.go
@@ -118,8 +118,7 @@ func TestAttachStorageCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(c, mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
diff --git a/internal/commands/serverstorage/detach_test.go b/internal/commands/serverstorage/detach_test.go
@@ -76,8 +76,7 @@ func TestDetachCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(c, mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
diff --git a/internal/commands/storage/backup_create_test.go b/internal/commands/storage/backup_create_test.go
@@ -72,8 +72,7 @@ func TestCreateBackupCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(c, mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
diff --git a/internal/commands/storage/clone_test.go b/internal/commands/storage/clone_test.go
@@ -98,8 +98,7 @@ func TestCloneCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(c, mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
diff --git a/internal/commands/storage/create_test.go b/internal/commands/storage/create_test.go
@@ -117,8 +117,7 @@ func TestCreateCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(c, mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, 1)
diff --git a/internal/commands/storage/modify_test.go b/internal/commands/storage/modify_test.go
@@ -102,8 +102,7 @@ func TestModifyCommandExistingBackupRule(t *testing.T) {
 			_, err = c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, mService, flume.New("test")), test1.storage.UUID)
 
 			if test1.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test1.error, err.Error())
+				assert.EqualError(t, err, test1.error)
 			} else {
 				assert.Nil(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, test1.methodCalls)
@@ -153,8 +152,7 @@ func TestModifyCommandExistingBackupRule(t *testing.T) {
 			_, err = c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, mService, flume.New("test")), test2.storage.UUID)
 
 			if test2.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test2.error, err.Error())
+				assert.EqualError(t, err, test2.error)
 			} else {
 				assert.Nil(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, test2.methodCalls)
@@ -221,8 +219,7 @@ func TestModifyCommandExistingBackupRule(t *testing.T) {
 			_, err = c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, mService, flume.New("test")), test3.storage.UUID)
 
 			if test3.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test3.error, err.Error())
+				assert.EqualError(t, err, test3.error)
 			} else {
 				assert.Nil(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, test3.methodCalls)
diff --git a/internal/commands/storage/templatize_test.go b/internal/commands/storage/templatize_test.go
@@ -76,8 +76,7 @@ func TestTemplatizeCommand(t *testing.T) {
 			_, err := mockexecute.MockExecute(c, mService, conf)
 
 			if test.error != "" {
-				assert.Error(t, err)
-				assert.Equal(t, test.error, err.Error())
+				assert.EqualError(t, err, test.error)
 			} else {
 				assert.NoError(t, err)
 				mService.AssertNumberOfCalls(t, targetMethod, 1)

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ func TestDeleteCommand(t *testing.T) {`
`43`	`43`	`_, err = c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, &mService, flume.New("test")), test.arg)`
`44`	`44`
`45`	`45`	`if test.error != "" {`
`46`		`- assert.Errorf(t, err, test.error)`
	`46`	`+ assert.EqualError(t, err, test.error)`
`47`	`47`	`} else {`
`48`	`48`	`mService.AssertNumberOfCalls(t, targetMethod, 1)`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ func TestCreateCommand(t *testing.T) {`
`127`	`127`	`_, err = c.(commands.SingleArgumentCommand).ExecuteSingleArgument(commands.NewExecutor(conf, &mService, flume.New("test")), server.UUID)`
`128`	`128`
`129`	`129`	`if test.error != "" {`
`130`		`- assert.Errorf(t, err, test.error)`
	`130`	`+ assert.EqualError(t, err, test.error)`
`131`	`131`	`} else {`
`132`	`132`	`mService.AssertNumberOfCalls(t, targetMethod, 1)`
`133`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ func TestModifyCommand(t *testing.T) {`
`77`	`77`	`_, err = c.(commands.SingleArgumentCommand).ExecuteSingleArgument(commands.NewExecutor(conf, &mService, flume.New("test")), server.UUID)`
`78`	`78`
`79`	`79`	`if test.error != "" {`
`80`		`- assert.Errorf(t, err, test.error)`
	`80`	`+ assert.EqualError(t, err, test.error)`
`81`	`81`	`} else {`
`82`	`82`	`mService.AssertNumberOfCalls(t, targetMethod, 1)`
`83`	`83`	`}`