feat(lb): add name resolver and argument completion

Author: kangasta

internal/commands/loadbalancer/show.go

@@ -2,7 +2,9 @@ package loadbalancer
 
 import (
 	"github.com/UpCloudLtd/upcloud-cli/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/internal/completion"
 	"github.com/UpCloudLtd/upcloud-cli/internal/output"
+	"github.com/UpCloudLtd/upcloud-cli/internal/resolver"
 	"github.com/UpCloudLtd/upcloud-cli/internal/ui"
 	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud/request"
 	"github.com/jedib0t/go-pretty/v6/text"
@@ -22,8 +24,8 @@ func ShowCommand() commands.Command {
 
 type showCommand struct {
 	*commands.BaseCommand
-	// resolver.CachingLoadBalancer
-	// completion.LoadBalancer
+	resolver.CachingLoadBalancer
+	completion.LoadBalancer
 }
 
 // Execute implements commands.MultipleArgumentCommand

internal/completion/loadbalancer.go

@@ -0,0 +1,28 @@
+package completion
+
+import (
+	"github.com/UpCloudLtd/upcloud-cli/internal/service"
+	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud/request"
+	"github.com/spf13/cobra"
+)
+
+// LoadBalancer implements argument completion for load balancers, by uuid or name.
+type LoadBalancer struct {
+}
+
+// make sure LoadBalancer implements the interface
+var _ Provider = LoadBalancer{}
+
+// CompleteArgument implements completion.Provider
+func (s LoadBalancer) CompleteArgument(svc service.AllServices, toComplete string) ([]string, cobra.ShellCompDirective) {
+	loadbalancers, err := svc.GetLoadBalancers(&request.GetLoadBalancersRequest{})
+	if err != nil {
+		return None(toComplete)
+	}
+	var vals []string
+	for _, lb := range loadbalancers {
+		vals = append(vals, lb.UUID, lb.Name)
+	}
+
+	return MatchStringPrefix(vals, toComplete, true), cobra.ShellCompDirectiveNoFileComp
+}

internal/completion/loadbalancer_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 mockLoadBalancers = []upcloud.LoadBalancer{
+	{Name: "asd-1", UUID: "abcdef"},
+	{Name: "asd-2", UUID: "abcghi"},
+	{Name: "qwe-1", UUID: "jklmno"},
+}
+
+func TestLoadBalancer_CompleteArgument(t *testing.T) {
+	for _, test := range []struct {
+		name              string
+		complete          string
+		expectedMatches   []string
+		expectedDirective cobra.ShellCompDirective
+	}{
+		{name: "Name/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: "Name - one match", complete: "qwe", expectedMatches: []string{"qwe-1"}, expectedDirective: cobra.ShellCompDirectiveNoFileComp},
+		{name: "Name - 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("GetLoadBalancers", mock.Anything).Return(mockLoadBalancers, nil)
+			completions, directive := completion.LoadBalancer{}.CompleteArgument(mService, test.complete)
+			assert.Equal(t, test.expectedMatches, completions)
+			assert.Equal(t, test.expectedDirective, directive)
+		})
+	}
+}
+
+func TestLoadBalancer_CompleteArgumentServiceFail(t *testing.T) {
+	mService := new(smock.Service)
+	mService.On("GetLoadBalancers", mock.Anything).Return(nil, fmt.Errorf("MOCKFAIL"))
+	completions, directive := completion.LoadBalancer{}.CompleteArgument(mService, "asd")
+	assert.Nil(t, completions)
+	assert.Equal(t, cobra.ShellCompDirectiveDefault, directive)
+}

internal/mock/mock.go

@@ -647,7 +647,11 @@ func (m *Service) WaitForManagedDatabaseState(r *request.WaitForManagedDatabaseS
 }
 
 func (m *Service) GetLoadBalancers(r *request.GetLoadBalancersRequest) ([]upcloud.LoadBalancer, error) {
-	return nil, nil
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].([]upcloud.LoadBalancer), args.Error(1)
 }
 
 func (m *Service) GetLoadBalancer(r *request.GetLoadBalancerRequest) (*upcloud.LoadBalancer, error) {

internal/resolver/loadbalancer.go

@@ -0,0 +1,40 @@
+package resolver
+
+import (
+	internal "github.com/UpCloudLtd/upcloud-cli/internal/service"
+	"github.com/UpCloudLtd/upcloud-go-api/v4/upcloud/request"
+)
+
+// CachingLoadBalancer implements resolver for servers, caching the results
+type CachingLoadBalancer struct{}
+
+// make sure we implement the ResolutionProvider interface
+var _ ResolutionProvider = CachingLoadBalancer{}
+
+// Get implements ResolutionProvider.Get
+func (s CachingLoadBalancer) Get(svc internal.AllServices) (Resolver, error) {
+	loadbalancers, err := svc.GetLoadBalancers(&request.GetLoadBalancersRequest{})
+	if err != nil {
+		return nil, err
+	}
+	return func(arg string) (uuid string, err error) {
+		rv := ""
+		for _, lb := range loadbalancers {
+			if lb.Name == arg || lb.UUID == arg {
+				if rv != "" {
+					return "", AmbiguousResolutionError(arg)
+				}
+				rv = lb.UUID
+			}
+		}
+		if rv != "" {
+			return rv, nil
+		}
+		return "", NotFoundError(arg)
+	}, nil
+}
+
+// PositionalArgumentHelp implements resolver.ResolutionProvider
+func (s CachingLoadBalancer) PositionalArgumentHelp() string {
+	return "<UUID/Name...>" //nolint:goconst
+}

internal/resolver/loadbalancer_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 mockLoadBalancers = []upcloud.LoadBalancer{
+	{Name: "asd", UUID: "abcdef"},
+	{Name: "asd", UUID: "abcghi"},
+	{Name: "qwe", UUID: "jklmno"},
+}
+
+func TestLoadBalancerResolution(t *testing.T) {
+	t.Run("UUID", func(t *testing.T) {
+		mService := &smock.Service{}
+		mService.On("GetLoadBalancers", mock.Anything).Return(mockLoadBalancers, nil)
+		res := resolver.CachingLoadBalancer{}
+		argResolver, err := res.Get(mService)
+		assert.NoError(t, err)
+		for _, db := range mockLoadBalancers {
+			resolved, err := argResolver(db.UUID)
+			assert.NoError(t, err)
+			assert.Equal(t, db.UUID, resolved)
+		}
+
+		// Make sure caching works, eg. we didn't call GetLoadBalancers more than once
+		mService.AssertNumberOfCalls(t, "GetLoadBalancers", 1)
+	})
+
+	t.Run("Name", func(t *testing.T) {
+		mService := &smock.Service{}
+		mService.On("GetLoadBalancers", mock.Anything).Return(mockLoadBalancers, nil)
+		res := resolver.CachingLoadBalancer{}
+		argResolver, err := res.Get(mService)
+		assert.NoError(t, err)
+
+		db := mockLoadBalancers[2]
+		resolved, err := argResolver(db.Name)
+		assert.NoError(t, err)
+		assert.Equal(t, db.UUID, resolved)
+		// Make sure caching works, eg. we didn't call GetLoadBalancers more than once
+		mService.AssertNumberOfCalls(t, "GetLoadBalancers", 1)
+	})
+
+	t.Run("Failures", func(t *testing.T) {
+		mService := &smock.Service{}
+		mService.On("GetLoadBalancers", mock.Anything).Return(mockLoadBalancers, nil)
+
+		res := resolver.CachingLoadBalancer{}
+		argResolver, err := res.Get(mService)
+		assert.NoError(t, err)
+		var resolved string
+
+		// Ambigous Name
+		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 GetLoadBalancers more than once
+		mService.AssertNumberOfCalls(t, "GetLoadBalancers", 1)
+	})
+}
+
+func TestFailingLoadBalancerResolution(t *testing.T) {
+	mService := &smock.Service{}
+	mService.On("GetLoadBalancers", mock.Anything).Return(nil, errors.New("MOCKERROR"))
+	res := resolver.CachingLoadBalancer{}
+	argResolver, err := res.Get(mService)
+	assert.EqualError(t, err, "MOCKERROR")
+	assert.Nil(t, argResolver)
+}