Refactor environment tag (#3)

* refactor environment tag to be set as property on CFTagManager struct

* update module to get space information based on the instance

* refactor code to look up extra resources where possible

* rename NameResolver -> ResourceGEtter

* refactor test

* add unit test for getting service instances

* create ResourceGUIDs struct for arguments

* update unit tests

* stub out unit tests

* update unit tests

* refactor code

* update interface

* update ResourceGUIDs struct properties to be exported

cf.go

@@ -8,9 +8,10 @@ import (
 	"github.com/cloudfoundry-community/go-cfclient/v3/resource"
 )
 
-type NameResolver interface {
-	getOrganizationName(organizationGUID string) (string, error)
-	getSpaceName(spaceGUID string) (string, error)
+type ResourceGetter interface {
+	getOrganization(organizationGUID string) (*resource.Organization, error)
+	getSpace(spaceGUID string) (*resource.Space, error)
+	getServiceInstance(instanceGUID string) (*resource.ServiceInstance, error)
 }
 
 type OrganizationGetter interface {
@@ -21,16 +22,21 @@ type SpaceGetter interface {
 	Get(ctx context.Context, guid string) (*resource.Space, error)
 }
 
-type cfNameResolver struct {
-	Organizations OrganizationGetter
-	Spaces        SpaceGetter
+type ServiceInstanceGetter interface {
+	Get(ctx context.Context, guid string) (*resource.ServiceInstance, error)
 }
 
-func newCFNameResolver(
+type cfResourceGetter struct {
+	Organizations    OrganizationGetter
+	Spaces           SpaceGetter
+	ServiceInstances ServiceInstanceGetter
+}
+
+func newCFResourceGetter(
 	cfApiUrl string,
 	cfApiClientId string,
 	cfApiClientSecret string,
-) (*cfNameResolver, error) {
+) (*cfResourceGetter, error) {
 	cfg, err := config.NewClientSecret(
 		cfApiUrl,
 		cfApiClientId,
@@ -43,24 +49,33 @@ func newCFNameResolver(
 	if err != nil {
 		return nil, err
 	}
-	return &cfNameResolver{
-		Organizations: cf.Organizations,
-		Spaces:        cf.Spaces,
+	return &cfResourceGetter{
+		Organizations:    cf.Organizations,
+		Spaces:           cf.Spaces,
+		ServiceInstances: cf.ServiceInstances,
 	}, nil
 }
 
-func (c *cfNameResolver) getOrganizationName(organizationGUID string) (string, error) {
+func (c *cfResourceGetter) getOrganization(organizationGUID string) (*resource.Organization, error) {
 	organization, err := c.Organizations.Get(context.Background(), organizationGUID)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-	return organization.Name, nil
+	return organization, nil
 }
 
-func (c *cfNameResolver) getSpaceName(spaceGUID string) (string, error) {
+func (c *cfResourceGetter) getSpace(spaceGUID string) (*resource.Space, error) {
 	space, err := c.Spaces.Get(context.Background(), spaceGUID)
 	if err != nil {
-		return "", err
+		return nil, err
+	}
+	return space, nil
+}
+
+func (c *cfResourceGetter) getServiceInstance(instanceGUID string) (*resource.ServiceInstance, error) {
+	instance, err := c.ServiceInstances.Get(context.Background(), instanceGUID)
+	if err != nil {
+		return nil, err
 	}
-	return space.Name, nil
+	return instance, nil
 }

cf_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/cloudfoundry-community/go-cfclient/v3/resource"
+	"github.com/google/go-cmp/cmp"
 )
 
 type mockOrganizations struct {
@@ -45,67 +46,88 @@ func (s *mockSpaces) Get(ctx context.Context, guid string) (*resource.Space, err
 	}, nil
 }
 
-func TestGetOrganizationName(t *testing.T) {
+type mockServiceInstances struct {
+	getServiceInstanceErr error
+	instanceName          string
+	instanceGUID          string
+}
+
+func (si *mockServiceInstances) Get(ctx context.Context, guid string) (*resource.ServiceInstance, error) {
+	if si.getServiceInstanceErr != nil {
+		return nil, si.getServiceInstanceErr
+	}
+	if guid != si.instanceGUID {
+		return nil, fmt.Errorf("guid argument: %s does not match expected guid: %s", guid, si.instanceGUID)
+	}
+	return &resource.ServiceInstance{
+		Name: si.instanceName,
+	}, nil
+}
+
+func TestGetOrganization(t *testing.T) {
 	testCases := map[string]struct {
-		cfClientWrapper          *cfNameResolver
-		expectedOrganizationName string
-		expectedErr              error
-		organizationGuid         string
+		cfResourceGetter     *cfResourceGetter
+		expectedOrganization *resource.Organization
+		expectedErr          error
+		organizationGuid     string
 	}{
 		"success": {
-			cfClientWrapper: &cfNameResolver{
+			cfResourceGetter: &cfResourceGetter{
 				Organizations: &mockOrganizations{
 					organizationName: "org-1",
 					organizationGuid: "guid-1",
 				},
-				Spaces: &mockSpaces{},
 			},
-			organizationGuid:         "guid-1",
-			expectedOrganizationName: "org-1",
+			organizationGuid: "guid-1",
+			expectedOrganization: &resource.Organization{
+				Name: "org-1",
+			},
 		},
 		"error": {
-			cfClientWrapper: &cfNameResolver{
-				Organizations: &mockOrganizations{},
-				Spaces:        &mockSpaces{},
+			cfResourceGetter: &cfResourceGetter{
+				Organizations: &mockOrganizations{
+					getOrganizationErr: errors.New("error getting organization"),
+				},
 			},
 			expectedErr: errors.New("error getting organization"),
 		},
 	}
 
 	for name, test := range testCases {
 		t.Run(name, func(t *testing.T) {
-			organizationName, err := test.cfClientWrapper.getOrganizationName(test.organizationGuid)
-			if organizationName != test.expectedOrganizationName {
-				t.Fatalf("expected organization name: %s, got: %s", test.expectedOrganizationName, organizationName)
+			organization, err := test.cfResourceGetter.getOrganization(test.organizationGuid)
+			if !cmp.Equal(organization, test.expectedOrganization) {
+				t.Errorf(cmp.Diff(organization, test.expectedOrganization))
 			}
-			if err != nil && err.Error() != test.expectedErr.Error() {
+			if (test.expectedErr != nil && err == nil) ||
+				(err != nil && err.Error() != test.expectedErr.Error()) {
 				t.Fatalf("expected error: %s, got: %s", test.expectedErr, err)
 			}
 		})
 	}
 }
 
-func TestGetSpaceName(t *testing.T) {
+func TestGetSpace(t *testing.T) {
 	testCases := map[string]struct {
-		cfClientWrapper   *cfNameResolver
-		expectedSpaceName string
-		expectedErr       error
-		spaceGuid         string
+		cfResourceGetter *cfResourceGetter
+		expectedSpace    *resource.Space
+		expectedErr      error
+		spaceGuid        string
 	}{
 		"success": {
-			cfClientWrapper: &cfNameResolver{
-				Organizations: &mockOrganizations{},
+			cfResourceGetter: &cfResourceGetter{
 				Spaces: &mockSpaces{
-					spaceName: "plan-1",
+					spaceName: "space-1",
 					spaceGuid: "guid-1",
 				},
 			},
-			spaceGuid:         "guid-1",
-			expectedSpaceName: "plan-1",
+			spaceGuid: "guid-1",
+			expectedSpace: &resource.Space{
+				Name: "space-1",
+			},
 		},
 		"error": {
-			cfClientWrapper: &cfNameResolver{
-				Organizations: &mockOrganizations{},
+			cfResourceGetter: &cfResourceGetter{
 				Spaces: &mockSpaces{
 					getSpaceErr: errors.New("error getting space"),
 				},
@@ -116,11 +138,55 @@ func TestGetSpaceName(t *testing.T) {
 
 	for name, test := range testCases {
 		t.Run(name, func(t *testing.T) {
-			spaceName, err := test.cfClientWrapper.getSpaceName(test.spaceGuid)
-			if spaceName != test.expectedSpaceName {
-				t.Fatalf("expected space name: %s, got: %s", test.expectedSpaceName, spaceName)
+			space, err := test.cfResourceGetter.getSpace(test.spaceGuid)
+			if !cmp.Equal(space, test.expectedSpace) {
+				t.Errorf(cmp.Diff(space, test.expectedSpace))
+			}
+			if (test.expectedErr != nil && err == nil) ||
+				(err != nil && err.Error() != test.expectedErr.Error()) {
+				t.Fatalf("expected error: %s, got: %s", test.expectedErr, err)
+			}
+		})
+	}
+}
+
+func TestGetServiceInstance(t *testing.T) {
+	testCases := map[string]struct {
+		cfResourceGetter        *cfResourceGetter
+		expectedServiceInstance *resource.ServiceInstance
+		expectedErr             error
+		instanceGUID            string
+	}{
+		"success": {
+			cfResourceGetter: &cfResourceGetter{
+				ServiceInstances: &mockServiceInstances{
+					instanceName: "instance-1",
+					instanceGUID: "guid-1",
+				},
+			},
+			instanceGUID: "guid-1",
+			expectedServiceInstance: &resource.ServiceInstance{
+				Name: "instance-1",
+			},
+		},
+		"error": {
+			cfResourceGetter: &cfResourceGetter{
+				ServiceInstances: &mockServiceInstances{
+					getServiceInstanceErr: errors.New("error getting instance"),
+				},
+			},
+			expectedErr: errors.New("error getting instance"),
+		},
+	}
+
+	for name, test := range testCases {
+		t.Run(name, func(t *testing.T) {
+			instance, err := test.cfResourceGetter.getServiceInstance(test.instanceGUID)
+			if !cmp.Equal(instance, test.expectedServiceInstance) {
+				t.Errorf(cmp.Diff(instance, test.expectedServiceInstance))
 			}
-			if err != nil && err.Error() != test.expectedErr.Error() {
+			if (test.expectedErr != nil && err == nil) ||
+				(err != nil && err.Error() != test.expectedErr.Error()) {
 				t.Fatalf("expected error: %s, got: %s", test.expectedErr, err)
 			}
 		})