chore(database): add unit tests for database arg resolving and shell completion

Author: kangasta

internal/completion/database_test.go

@@ -0,0 +1,50 @@
+package completion_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/UpCloudLtd/upcloud-cli/internal/completion"
+	smock "github.com/UpCloudLtd/upcloud-cli/internal/mock"
+	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud"
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+var mockDatabases = []upcloud.ManagedDatabase{
+	{Title: "asd-1", UUID: "abcdef"},
+	{Title: "asd-2", UUID: "abcghi"},
+	{Title: "qwe-1", UUID: "jklmno"},
+}
+
+func TestDatabase_CompleteArgument(t *testing.T) {
+	for _, test := range []struct {
+		name              string
+		complete          string
+		expectedMatches   []string
+		expectedDirective cobra.ShellCompDirective
+	}{
+		{name: "Title/UUID - no match", complete: "pqr", expectedMatches: []string(nil), expectedDirective: cobra.ShellCompDirectiveNoFileComp},
+		{name: "UUID - single match", complete: "jkl", expectedMatches: []string{"jklmno"}, expectedDirective: cobra.ShellCompDirectiveNoFileComp},
+		{name: "UUID - multiple matches", complete: "abc", expectedMatches: []string{"abcdef", "abcghi"}, expectedDirective: cobra.ShellCompDirectiveNoFileComp},
+		{name: "Title - one match", complete: "qwe", expectedMatches: []string{"qwe-1"}, expectedDirective: cobra.ShellCompDirectiveNoFileComp},
+		{name: "Title - multiple matches", complete: "asd", expectedMatches: []string{"asd-1", "asd-2"}, expectedDirective: cobra.ShellCompDirectiveNoFileComp},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			mService := new(smock.Service)
+			mService.On("GetManagedDatabases", mock.Anything).Return(mockDatabases, nil)
+			completions, directive := completion.Database{}.CompleteArgument(mService, test.complete)
+			assert.Equal(t, test.expectedMatches, completions)
+			assert.Equal(t, test.expectedDirective, directive)
+		})
+	}
+}
+
+func TestDatabase_CompleteArgumentServiceFail(t *testing.T) {
+	mService := new(smock.Service)
+	mService.On("GetManagedDatabases", mock.Anything).Return(nil, fmt.Errorf("MOCKFAIL"))
+	completions, directive := completion.Database{}.CompleteArgument(mService, "asd")
+	assert.Nil(t, completions)
+	assert.Equal(t, cobra.ShellCompDirectiveDefault, directive)
+}

internal/mock/mock.go

@@ -575,7 +575,11 @@ func (m *Service) GetManagedDatabase(r *request.GetManagedDatabaseRequest) (*upc
 }
 
 func (m *Service) GetManagedDatabases(r *request.GetManagedDatabasesRequest) ([]upcloud.ManagedDatabase, error) {
-	return nil, nil
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].([]upcloud.ManagedDatabase), args.Error(1)
 }
 
 func (m *Service) GetManagedDatabaseConnections(r *request.GetManagedDatabaseConnectionsRequest) ([]upcloud.ManagedDatabaseConnection, error) {

internal/resolver/database_test.go

@@ -0,0 +1,90 @@
+package resolver_test
+
+import (
+	"errors"
+	"testing"
+
+	smock "github.com/UpCloudLtd/upcloud-cli/internal/mock"
+	"github.com/UpCloudLtd/upcloud-cli/internal/resolver"
+
+	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+var mockDatabases = []upcloud.ManagedDatabase{
+	{Title: "asd", UUID: "abcdef"},
+	{Title: "asd", UUID: "abcghi"},
+	{Title: "qwe", UUID: "jklmno"},
+}
+
+func TestDatabaseResolution(t *testing.T) {
+	t.Run("UUID", func(t *testing.T) {
+		mService := &smock.Service{}
+		mService.On("GetManagedDatabases", mock.Anything).Return(mockDatabases, nil)
+		res := resolver.CachingDatabase{}
+		argResolver, err := res.Get(mService)
+		assert.NoError(t, err)
+		for _, db := range mockDatabases {
+			resolved, err := argResolver(db.UUID)
+			assert.NoError(t, err)
+			assert.Equal(t, db.UUID, resolved)
+		}
+
+		// Make sure caching works, eg. we didn't call GetManagedDatabases more than once
+		mService.AssertNumberOfCalls(t, "GetManagedDatabases", 1)
+	})
+
+	t.Run("Title", func(t *testing.T) {
+		mService := &smock.Service{}
+		mService.On("GetManagedDatabases", mock.Anything).Return(mockDatabases, nil)
+		res := resolver.CachingDatabase{}
+		argResolver, err := res.Get(mService)
+		assert.NoError(t, err)
+
+		db := mockDatabases[2]
+		resolved, err := argResolver(db.Title)
+		assert.NoError(t, err)
+		assert.Equal(t, db.UUID, resolved)
+		// Make sure caching works, eg. we didn't call GetManagedDatabases more than once
+		mService.AssertNumberOfCalls(t, "GetManagedDatabases", 1)
+	})
+
+	t.Run("Failures", func(t *testing.T) {
+		mService := &smock.Service{}
+		mService.On("GetManagedDatabases", mock.Anything).Return(mockDatabases, nil)
+
+		res := resolver.CachingDatabase{}
+		argResolver, err := res.Get(mService)
+		assert.NoError(t, err)
+		var resolved string
+
+		// Ambigous title
+		resolved, err = argResolver("asd")
+		if !assert.Error(t, err) {
+			t.FailNow()
+		}
+		assert.ErrorIs(t, err, resolver.AmbiguousResolutionError("asd"))
+		assert.Equal(t, "", resolved)
+
+		// Not found
+		resolved, err = argResolver("not-found")
+		if !assert.Error(t, err) {
+			t.FailNow()
+		}
+		assert.ErrorIs(t, err, resolver.NotFoundError("not-found"))
+		assert.Equal(t, "", resolved)
+
+		// Make sure caching works, eg. we didn't call GetManagedDatabases more than once
+		mService.AssertNumberOfCalls(t, "GetManagedDatabases", 1)
+	})
+}
+
+func TestFailingDatabaseResolution(t *testing.T) {
+	mService := &smock.Service{}
+	mService.On("GetManagedDatabases", mock.Anything).Return(nil, errors.New("MOCKERROR"))
+	res := resolver.CachingDatabase{}
+	argResolver, err := res.Get(mService)
+	assert.EqualError(t, err, "MOCKERROR")
+	assert.Nil(t, argResolver)
+}