(feat) start moving things to a factory to simplify the test

Author: ncode

pkg/consul/factory.go

@@ -0,0 +1,102 @@
+/*
+Copyright © 2025 Juliano Martinez <[email protected]>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package consul
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/consul/api"
+)
+
+// ConsulClient is an interface for the Consul client.
+type ConsulClient interface {
+	Agent() ConsulAgent
+}
+
+// ConsulAgent is an interface for the Consul agent.
+type ConsulAgent interface {
+	Service(string, *api.QueryOptions) (*api.AgentService, *api.QueryMeta, 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()
+}
+
+// ClientFactory is an interface for creating Consul clients
+type ClientFactory interface {
+	NewClient(address, token string) (ConsulClient, error)
+}
+
+// DefaultFactory creates real Consul clients
+type DefaultFactory struct{}
+
+// NewClient creates a new Consul client with the given configuration
+func (f *DefaultFactory) NewClient(address, token string) (ConsulClient, error) {
+	config := api.DefaultConfig()
+	config.Address = address
+	config.Token = token
+
+	client, err := api.NewClient(config)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create Consul client: %w", err)
+	}
+
+	return NewConsulAPIWrapper(client), nil
+}
+
+// MockFactory creates mock Consul clients for testing
+type MockFactory struct {
+	MockClient ConsulClient
+	MockError  error
+}
+
+// NewClient returns the mock client or error
+func (f *MockFactory) NewClient(address, token string) (ConsulClient, error) {
+	if f.MockError != nil {
+		return nil, f.MockError
+	}
+	return f.MockClient, nil
+}
+
+// Factory is the global factory instance (can be overridden for testing)
+var Factory ClientFactory = &DefaultFactory{}
+
+// SetFactory allows tests to inject a mock factory
+func SetFactory(f ClientFactory) {
+	Factory = f
+}
+
+// ResetFactory resets to the default factory
+func ResetFactory() {
+	Factory = &DefaultFactory{}
+}
+
+// CreateClient is a convenience function that uses the global factory
+func CreateClient(address, token string) (ConsulClient, error) {
+	return Factory.NewClient(address, token)
+}

pkg/consul/factory_test.go

@@ -0,0 +1,123 @@
+package consul
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/consul/api"
+	"github.com/stretchr/testify/assert"
+)
+
+// MockConsulClient for testing
+type MockConsulClient struct {
+	MockAgent *MockAgent
+}
+
+func (m *MockConsulClient) Agent() ConsulAgent {
+	return m.MockAgent
+}
+
+type MockAgent struct {
+	ServiceFunc         func(serviceID string, q *api.QueryOptions) (*api.AgentService, *api.QueryMeta, error)
+	ServiceRegisterFunc func(reg *api.AgentServiceRegistration) error
+}
+
+func (m *MockAgent) Service(serviceID string, q *api.QueryOptions) (*api.AgentService, *api.QueryMeta, error) {
+	if m.ServiceFunc != nil {
+		return m.ServiceFunc(serviceID, q)
+	}
+	return nil, nil, nil
+}
+
+func (m *MockAgent) ServiceRegister(reg *api.AgentServiceRegistration) error {
+	if m.ServiceRegisterFunc != nil {
+		return m.ServiceRegisterFunc(reg)
+	}
+	return nil
+}
+
+func TestDefaultFactory(t *testing.T) {
+	factory := &DefaultFactory{}
+
+	// Test with valid configuration
+	// Note: This will actually try to connect to Consul, so it might fail
+	// in environments without Consul running
+	t.Run("Create client with valid config", func(t *testing.T) {
+		client, err := factory.NewClient("127.0.0.1:8500", "test-token")
+		// We expect this to succeed in creating a client object,
+		// even if Consul isn't actually running
+		assert.NoError(t, err)
+		assert.NotNil(t, client)
+	})
+}
+
+func TestMockFactory(t *testing.T) {
+	t.Run("Returns mock client", func(t *testing.T) {
+		mockClient := &MockConsulClient{
+			MockAgent: &MockAgent{},
+		}
+		factory := &MockFactory{
+			MockClient: mockClient,
+		}
+
+		client, err := factory.NewClient("any-address", "any-token")
+		assert.NoError(t, err)
+		assert.Equal(t, mockClient, client)
+	})
+
+	t.Run("Returns error when configured", func(t *testing.T) {
+		expectedErr := fmt.Errorf("connection failed")
+		factory := &MockFactory{
+			MockError: expectedErr,
+		}
+
+		client, err := factory.NewClient("any-address", "any-token")
+		assert.Error(t, err)
+		assert.Equal(t, expectedErr, err)
+		assert.Nil(t, client)
+	})
+}
+
+func TestGlobalFactory(t *testing.T) {
+	// Save original factory
+	originalFactory := Factory
+	defer func() {
+		Factory = originalFactory
+	}()
+
+	t.Run("Default factory is set", func(t *testing.T) {
+		ResetFactory()
+		_, ok := Factory.(*DefaultFactory)
+		assert.True(t, ok, "Default factory should be DefaultFactory type")
+	})
+
+	t.Run("Can set mock factory", func(t *testing.T) {
+		mockFactory := &MockFactory{
+			MockClient: &MockConsulClient{},
+		}
+		SetFactory(mockFactory)
+		assert.Equal(t, mockFactory, Factory)
+	})
+
+	t.Run("CreateClient uses global factory", func(t *testing.T) {
+		mockClient := &MockConsulClient{
+			MockAgent: &MockAgent{},
+		}
+		mockFactory := &MockFactory{
+			MockClient: mockClient,
+		}
+		SetFactory(mockFactory)
+
+		client, err := CreateClient("test-addr", "test-token")
+		assert.NoError(t, err)
+		assert.Equal(t, mockClient, client)
+	})
+
+	t.Run("ResetFactory restores default", func(t *testing.T) {
+		mockFactory := &MockFactory{}
+		SetFactory(mockFactory)
+		ResetFactory()
+		_, ok := Factory.(*DefaultFactory)
+		assert.True(t, ok, "Factory should be reset to DefaultFactory")
+	})
+}