Merge pull request #8 from ncode/juliano/moar_tests

tests

Author: ncode

cmd/run.go

@@ -70,7 +70,7 @@ example: tagit run -s my-super-service -x '/tmp/tag-role.sh'
 			os.Exit(1)
 		}
 
-		t := tagit.New(consulClient, &tagit.CmdExecutor{}, serviceID, script, validInterval, tagPrefix)
+		t := tagit.New(tagit.NewConsulAPIWrapper(consulClient), &tagit.CmdExecutor{}, serviceID, script, validInterval, tagPrefix)
 		t.Run()
 	},
 }

go.mod

@@ -8,10 +8,12 @@ require (
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.8.0
 	github.com/spf13/viper v1.18.2
+	github.com/stretchr/testify v1.8.4
 )
 
 require (
 	github.com/armon/go-metrics v0.4.1 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/fatih/color v1.16.0 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
@@ -30,6 +32,7 @@ require (
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect

pkg/tagit/tagit.go

@@ -25,7 +25,28 @@ type TagIt struct {
 
 // ConsulClient is an interface for the Consul client.
 type ConsulClient interface {
-	Agent() *api.Agent
+	Agent() ConsulAgent
+}
+
+// ConsulClientAgent is an interface for the Consul agent.
+type ConsulAgent interface {
+	Services() (map[string]*api.AgentService, error)
+	ServiceRegister(*api.AgentServiceRegistration) error
+}
+
+// ConsulAPIWrapper wraps the Consul API client to conform to the ConsulClient interface.
+type ConsulAPIWrapper struct {
+	client *api.Client
+}
+
+// NewConsulAPIWrapper creates a new instance of ConsulAPIWrapper.
+func NewConsulAPIWrapper(client *api.Client) *ConsulAPIWrapper {
+	return &ConsulAPIWrapper{client: client}
+}
+
+// Agent returns an object that conforms to the ConsulAgent interface.
+func (w *ConsulAPIWrapper) Agent() ConsulAgent {
+	return w.client.Agent()
 }
 
 // CommandExecutor is an interface for running commands.
@@ -82,42 +103,48 @@ func (t *TagIt) runScript() ([]byte, error) {
 func (t *TagIt) updateServiceTags() error {
 	service, err := t.getService()
 	if err != nil {
-		return err
+		return fmt.Errorf("error getting service: %w", err)
 	}
-	registration := t.copyServiceToRegistration(service)
-	log.WithFields(log.Fields{
-		"service": t.ServiceID,
-		"tags":    registration.Tags,
-	}).Debug("current service tags")
-	out, err := t.runScript()
+
+	newTags, err := t.generateNewTags()
 	if err != nil {
-		return err
+		return fmt.Errorf("error generating new tags: %w", err)
 	}
 
-	var tags []string
-	for _, tag := range strings.Fields(string(out)) {
-		tags = append(tags, fmt.Sprintf("%s-%s", t.TagPrefix, tag))
+	if err := t.updateConsulService(service, newTags); err != nil {
+		return fmt.Errorf("error updating service in Consul: %w", err)
 	}
 
-	updatedTags, shouldTag := t.needsTag(registration.Tags, tags)
+	return nil
+}
+
+// generateNewTags runs the script and generates new tags.
+func (t *TagIt) generateNewTags() ([]string, error) {
+	out, err := t.runScript()
+	if err != nil {
+		return nil, err
+	}
+	return t.parseScriptOutput(out), nil
+}
+
+// updateConsulService updates the service in Consul with the new tags.
+func (t *TagIt) updateConsulService(service *api.AgentService, newTags []string) error {
+	registration := t.copyServiceToRegistration(service)
+	updatedTags, shouldTag := t.needsTag(registration.Tags, newTags)
 	if shouldTag {
 		registration.Tags = updatedTags
-		log.WithFields(log.Fields{
-			"service": t.ServiceID,
-			"tags":    registration.Tags,
-		}).Info("updating service tags")
-		err = t.client.Agent().ServiceRegister(registration)
-		if err != nil {
-			return err
-		}
-	} else {
-		log.WithFields(log.Fields{
-			"service": t.ServiceID,
-			"tags":    registration.Tags,
-		}).Debug("no changes to service tags")
+		return t.client.Agent().ServiceRegister(registration)
 	}
+	return nil
+}
 
-	return err
+// parseScriptOutput parses the script output and generates tags.
+func (t *TagIt) parseScriptOutput(output []byte) []string {
+	var tags []string
+	for _, tag := range strings.Fields(string(output)) {
+		tags = append(tags, fmt.Sprintf("%s-%s", t.TagPrefix, tag))
+	}
+	return tags
 }
 
 // CleanupServiceTags cleans up the service tags added by tagit.

pkg/tagit/tagit_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/hashicorp/consul/api"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDiffTags(t *testing.T) {
@@ -290,13 +291,27 @@ func TestRunScript(t *testing.T) {
 	}
 }
 
-// MockConsulClient is a mock implementation of the ConsulClient interface
-type MockConsulClient struct{}
+// MockConsulClient implements the ConsulClient interface for testing.
+type MockConsulClient struct {
+	MockAgent *MockAgent
+}
+
+func (m *MockConsulClient) Agent() ConsulAgent {
+	return m.MockAgent
+}
+
+// MockAgent simulates the Agent part of the Consul client.
+type MockAgent struct {
+	ServicesFunc        func() (map[string]*api.AgentService, error)
+	ServiceRegisterFunc func(reg *api.AgentServiceRegistration) error
+}
+
+func (m *MockAgent) Services() (map[string]*api.AgentService, error) {
+	return m.ServicesFunc()
+}
 
-// TODO: Implement the Agent method properly so that we can test the rest of the methods
-func (m *MockConsulClient) Agent() *api.Agent {
-	// Return a mock *api.Agent if needed
-	return &api.Agent{}
+func (m *MockAgent) ServiceRegister(reg *api.AgentServiceRegistration) error {
+	return m.ServiceRegisterFunc(reg)
 }
 
 func TestNew(t *testing.T) {
@@ -321,3 +336,186 @@ func TestNew(t *testing.T) {
 		t.Errorf("Expected ServiceID to be 'test-service', got '%s'", tagit.ServiceID)
 	}
 }
+
+func TestGetService(t *testing.T) {
+	tests := []struct {
+		name             string
+		serviceID        string
+		mockServicesData map[string]*api.AgentService
+		mockServicesErr  error
+		expectErr        bool
+		expectService    *api.AgentService
+	}{
+		{
+			name:      "Service Found",
+			serviceID: "test-service",
+			mockServicesData: map[string]*api.AgentService{
+				"test-service": {
+					ID:      "test-service",
+					Service: "test",
+					Tags:    []string{"tag1", "tag2"},
+				},
+			},
+			expectErr:     false,
+			expectService: &api.AgentService{ID: "test-service", Service: "test", Tags: []string{"tag1", "tag2"}},
+		},
+		{
+			name:             "Service Not Found",
+			serviceID:        "nonexistent-service",
+			mockServicesData: map[string]*api.AgentService{},
+			expectErr:        true,
+			expectService:    nil,
+		},
+		{
+			name:            "Consul Client Error",
+			serviceID:       "test-service",
+			mockServicesErr: fmt.Errorf("consul client error"),
+			expectErr:       true,
+			expectService:   nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockConsulClient := &MockConsulClient{
+				MockAgent: &MockAgent{
+					ServicesFunc: func() (map[string]*api.AgentService, error) {
+						return tt.mockServicesData, tt.mockServicesErr
+					},
+				},
+			}
+			tagit := New(mockConsulClient, nil, tt.serviceID, "", 0, "")
+
+			service, err := tagit.getService()
+
+			if tt.expectErr && err == nil {
+				t.Errorf("Expected an error but got none")
+			} else if !tt.expectErr && err != nil {
+				t.Errorf("Did not expect an error but got: %v", err)
+			}
+
+			if !reflect.DeepEqual(service, tt.expectService) {
+				t.Errorf("Expected service: %v, got: %v", tt.expectService, service)
+			}
+		})
+	}
+}
+
+func TestGenerateNewTags(t *testing.T) {
+	tests := []struct {
+		name       string
+		script     string
+		mockOutput string
+		mockError  error
+		want       []string
+		wantErr    bool
+	}{
+		{
+			name:       "Valid Script Output",
+			script:     "echo tag1 tag2",
+			mockOutput: "tag1 tag2",
+			want:       []string{"tag-tag1", "tag-tag2"},
+			wantErr:    false,
+		},
+		{
+			name:      "Script Execution Error",
+			script:    "someinvalidcommand",
+			mockError: fmt.Errorf("command failed"),
+			want:      nil,
+			wantErr:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockExecutor := &MockCommandExecutor{
+				MockOutput: []byte(tt.mockOutput),
+				MockError:  tt.mockError,
+			}
+			tagit := TagIt{Script: tt.script, commandExecutor: mockExecutor, TagPrefix: "tag"}
+
+			got, err := tagit.generateNewTags()
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("generateNewTags() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("generateNewTags() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestUpdateConsulService(t *testing.T) {
+	tests := []struct {
+		name            string
+		existingTags    []string
+		newTags         []string
+		mockRegisterErr error
+		expectUpdate    bool
+		expectErr       bool
+	}{
+		{
+			name:         "Update Needed",
+			existingTags: []string{"tag1", "tag2"},
+			newTags:      []string{"tag1", "tag3"},
+			expectUpdate: true,
+			expectErr:    false,
+		},
+		{
+			name:         "No Update Needed",
+			existingTags: []string{"tag1", "tag2"},
+			newTags:      []string{"tag1", "tag2"},
+			expectUpdate: false,
+			expectErr:    false,
+		},
+		{
+			name:            "Consul Register Error",
+			existingTags:    []string{"tag1", "tag2"},
+			newTags:         []string{"tag1", "tag3"},
+			mockRegisterErr: fmt.Errorf("consul error"),
+			expectUpdate:    true,
+			expectErr:       true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			service := &api.AgentService{Tags: tt.existingTags}
+			mockConsulClient := &MockConsulClient{
+				MockAgent: &MockAgent{
+					ServiceRegisterFunc: func(reg *api.AgentServiceRegistration) error {
+						return tt.mockRegisterErr
+					},
+				},
+			}
+			tagit := TagIt{client: mockConsulClient}
+
+			err := tagit.updateConsulService(service, tt.newTags)
+			if (err != nil) != tt.expectErr {
+				t.Fatalf("updateConsulService() error = %v, wantErr %v", err, tt.expectErr)
+			}
+		})
+	}
+}
+
+func TestNewConsulAPIWrapper(t *testing.T) {
+	// Mock Consul API client
+	consulClient, err := api.NewClient(api.DefaultConfig())
+	if err != nil {
+		t.Fatalf("Failed to create Consul client: %v", err)
+	}
+
+	// Test NewConsulAPIWrapper
+	wrapper := NewConsulAPIWrapper(consulClient)
+
+	// Assert that wrapper is not nil
+	assert.NotNil(t, wrapper, "NewConsulAPIWrapper returned nil")
+
+	// Assert that wrapper implements ConsulClient interface
+	_, isConsulClient := interface{}(wrapper).(ConsulClient)
+	assert.True(t, isConsulClient, "NewConsulAPIWrapper does not implement ConsulClient interface")
+
+	// Optionally, assert that wrapper's Agent method returns a ConsulAgent
+	_, isConsulAgent := wrapper.Agent().(ConsulAgent)
+	assert.True(t, isConsulAgent, "Wrapper's Agent method does not return a ConsulAgent")
+}