Refactor file names and remove unused code

Author: ShocOne

httpclient/httpclient_api_handler.go

@@ -1,4 +1,4 @@
-// api_handler.go
+// httpclient_api_handler.go
 package httpclient
 
 import (

httpclient/httpclient_api_handler_test.go

@@ -0,0 +1,112 @@
+// httpclient_api_handler.go
+package httpclient
+
+import (
+	"errors"
+	"net/http"
+	"testing"
+
+	"github.com/deploymenttheory/go-api-http-client/apihandlers/graph"
+	"github.com/deploymenttheory/go-api-http-client/apihandlers/jamfpro"
+	"github.com/deploymenttheory/go-api-http-client/logger"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+// NewMockAPIHandler creates a new instance of MockAPIHandler.
+func NewMockAPIHandler() *MockAPIHandler {
+	return &MockAPIHandler{}
+}
+
+// Implement each method of the APIHandler interface on MockAPIHandler.
+
+func (m *MockAPIHandler) ConstructAPIResourceEndpoint(instanceName string, endpointPath string, log logger.Logger) string {
+	args := m.Called(instanceName, endpointPath, log)
+	return args.String(0)
+}
+
+func (m *MockAPIHandler) ConstructAPIAuthEndpoint(instanceName string, endpointPath string, log logger.Logger) string {
+	args := m.Called(instanceName, endpointPath, log)
+	return args.String(0)
+}
+
+func (m *MockAPIHandler) MarshalRequest(body interface{}, method string, endpoint string, log logger.Logger) ([]byte, error) {
+	args := m.Called(body, method, endpoint, log)
+	return args.Get(0).([]byte), args.Error(1)
+}
+
+func (m *MockAPIHandler) MarshalMultipartRequest(fields map[string]string, files map[string]string, log logger.Logger) ([]byte, string, error) {
+	args := m.Called(fields, files, log)
+	return args.Get(0).([]byte), args.String(1), args.Error(2)
+}
+
+func (m *MockAPIHandler) HandleAPISuccessResponse(resp *http.Response, out interface{}, log logger.Logger) error {
+	args := m.Called(resp, out, log)
+	return args.Error(0)
+}
+
+func (m *MockAPIHandler) HandleAPIErrorResponse(resp *http.Response, out interface{}, log logger.Logger) error {
+	args := m.Called(resp, out, log)
+	return args.Error(0)
+}
+
+func TestConstructAPIResourceEndpoint(t *testing.T) {
+	mockLogger := new(logger.MockLogger)
+	mockAPIHandler := NewMockAPIHandler()
+	instanceName := "testInstance"
+	endpointPath := "/testEndpoint"
+
+	expectedEndpoint := "https://testInstance.apiendpoint.com/testEndpoint"
+
+	// Setup expectations
+	mockAPIHandler.On("ConstructAPIResourceEndpoint", instanceName, endpointPath, mockLogger).Return(expectedEndpoint)
+
+	// Call the method
+	endpoint := mockAPIHandler.ConstructAPIResourceEndpoint(instanceName, endpointPath, mockLogger)
+
+	// Assertions
+	assert.Equal(t, expectedEndpoint, endpoint, "The constructed API resource endpoint did not match the expected value")
+
+	// Verify that the expectations were met
+	mockAPIHandler.AssertExpectations(t)
+}
+
+// TestLoadAPIHandler verifies the functionality of the LoadAPIHandler function in the httpclient package.
+// This function is designed to return the appropriate APIHandler implementation based on the provided apiType argument.
+// The test cases cover the following scenarios:
+// 1. Loading a JamfPro API handler by providing "jamfpro" as the apiType.
+// 2. Loading a Graph API handler by providing "graph" as the apiType.
+// 3. Handling an unsupported API type by providing an unknown apiType, which should result in an error.
+func TestLoadAPIHandler(t *testing.T) {
+	mockLogger := new(MockLogger)
+	tests := []struct {
+		name     string
+		apiType  string
+		wantType interface{}
+		wantErr  bool
+	}{
+		{"Load JamfPro Handler", "jamfpro", &jamfpro.JamfAPIHandler{}, false},
+		{"Load Graph Handler", "graph", &graph.GraphAPIHandler{}, false},
+		{"Unsupported API Type", "unknown", nil, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.wantErr {
+				mockLogger.On("Error", mock.Anything, mock.Anything).Return(errors.New("Unsupported API type")).Once()
+			} else {
+				mockLogger.On("Info", mock.Anything, mock.Anything).Once()
+			}
+
+			got, err := LoadAPIHandler(tt.apiType, mockLogger)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.IsType(t, tt.wantType, got)
+			}
+
+			mockLogger.AssertExpectations(t)
+		})
+	}
+}

httpclient/httpclient_mocklogger.go

@@ -0,0 +1,61 @@
+// httpclient_mocklogger.go
+package httpclient
+
+import (
+	"github.com/deploymenttheory/go-api-http-client/logger"
+	"github.com/stretchr/testify/mock"
+	"go.uber.org/zap"
+)
+
+// MockLogger is a mock type for the logger.Logger interface used in the httpclient package.
+type MockLogger struct {
+	mock.Mock
+}
+
+// Ensure MockLogger implements the logger.Logger interface.
+var _ logger.Logger = (*MockLogger)(nil)
+
+// NewMockLogger creates a new instance of MockLogger.
+func NewMockLogger() *MockLogger {
+	return &MockLogger{}
+}
+
+// Define all methods from the logger.Logger interface with mock implementations.
+func (m *MockLogger) SetLevel(level logger.LogLevel) {
+	m.Called(level)
+}
+
+func (m *MockLogger) Debug(msg string, fields ...zap.Field) {
+	m.Called(msg, fields)
+}
+
+func (m *MockLogger) Info(msg string, fields ...zap.Field) {
+	m.Called(msg, fields)
+}
+
+func (m *MockLogger) Warn(msg string, fields ...zap.Field) {
+	m.Called(msg, fields)
+}
+
+func (m *MockLogger) Error(msg string, fields ...zap.Field) error {
+	args := m.Called(msg, fields)
+	return args.Error(0)
+}
+
+func (m *MockLogger) Panic(msg string, fields ...zap.Field) {
+	m.Called(msg, fields)
+}
+
+func (m *MockLogger) Fatal(msg string, fields ...zap.Field) {
+	m.Called(msg, fields)
+}
+
+func (m *MockLogger) With(fields ...zap.Field) logger.Logger {
+	args := m.Called(fields)
+	return args.Get(0).(logger.Logger)
+}
+
+func (m *MockLogger) GetLogLevel() logger.LogLevel {
+	args := m.Called()
+	return args.Get(0).(logger.LogLevel)
+}

httpclient/httpclient_rate_handler_test.go

@@ -7,15 +7,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/deploymenttheory/go-api-http-client/logger"
 	"github.com/stretchr/testify/assert"
 )
 
-// mockLogger is a minimal implementation of the logger.Logger interface for testing
-type mockLogger struct{}
-
-func (m *mockLogger) Debug(msg string, fields ...interface{}) {}
-
 // TestCalculateBackoff tests the backoff calculation for various retry counts
 func TestCalculateBackoff(t *testing.T) {
 	tests := []struct {
@@ -85,7 +79,7 @@ func TestParseRateLimitHeaders(t *testing.T) {
 				resp.Header.Add(k, v)
 			}
 
-			wait := parseRateLimitHeaders(resp, logger.NewMockLogger())
+			wait := parseRateLimitHeaders(resp, NewMockLogger())
 
 			// Allow a small margin of error due to processing time
 			assert.InDelta(t, tt.expectedWait, wait, float64(1*time.Second), "Wait duration should be within expected range")

logger/zaplogger_logger.go

@@ -10,19 +10,6 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
-// Logger interface with structured logging capabilities at various levels.
-type Logger interface {
-	SetLevel(level LogLevel)
-	Debug(msg string, fields ...zapcore.Field)
-	Info(msg string, fields ...zapcore.Field)
-	Warn(msg string, fields ...zapcore.Field)
-	Error(msg string, fields ...zapcore.Field) error
-	Panic(msg string, fields ...zapcore.Field)
-	Fatal(msg string, fields ...zapcore.Field)
-	With(fields ...zapcore.Field) Logger
-	GetLogLevel() LogLevel
-}
-
 // defaultLogger is an implementation of the Logger interface using Uber's zap logging library.
 // It provides structured, leveled logging capabilities. The logLevel field controls the verbosity
 // of the logs that this logger will produce, allowing filtering of logs based on their importance.
@@ -37,6 +24,19 @@ func (d *defaultLogger) SetLevel(level LogLevel) {
 	d.logLevel = level
 }
 
+// Logger interface with structured logging capabilities at various levels.
+type Logger interface {
+	SetLevel(level LogLevel)
+	Debug(msg string, fields ...zapcore.Field)
+	Info(msg string, fields ...zapcore.Field)
+	Warn(msg string, fields ...zapcore.Field)
+	Error(msg string, fields ...zapcore.Field) error
+	Panic(msg string, fields ...zapcore.Field)
+	Fatal(msg string, fields ...zapcore.Field)
+	With(fields ...zapcore.Field) Logger
+	GetLogLevel() LogLevel
+}
+
 // With adds contextual key-value pairs to the logger, returning a new logger instance with the context.
 // This is useful for creating a logger with common fields that should be included in all subsequent log entries.
 func (d *defaultLogger) With(fields ...zapcore.Field) Logger {

logger/zaplogger_logger_test.go

@@ -16,19 +16,6 @@ import (
 // It allows overriding os.Exit in tests to prevent exiting the test runner.
 var osExit = os.Exit
 
-// MockLogger is a mock type for the Logger interface, embedding a *zap.Logger to satisfy the type requirement.
-type MockLogger struct {
-	mock.Mock
-	*zap.Logger
-}
-
-// NewMockLogger creates a new instance of MockLogger with an embedded no-op *zap.Logger.
-func NewMockLogger() *MockLogger {
-	return &MockLogger{
-		Logger: zap.NewNop(),
-	}
-}
-
 // TestDefaultLogger_SetLevel tests the SetLevel method of defaultLogger
 func TestDefaultLogger_SetLevel(t *testing.T) {
 	logger := zap.NewNop()

logger/zaplogger_mocklogger.go

@@ -0,0 +1,20 @@
+// zaplogger_mocklogger.go
+package logger
+
+import (
+	"github.com/stretchr/testify/mock"
+	"go.uber.org/zap"
+)
+
+// MockLogger is a mock type for the Logger interface, embedding a *zap.Logger to satisfy the type requirement.
+type MockLogger struct {
+	mock.Mock
+	*zap.Logger
+}
+
+// NewMockLogger creates a new instance of MockLogger with an embedded no-op *zap.Logger.
+func NewMockLogger() *MockLogger {
+	return &MockLogger{
+		Logger: zap.NewNop(),
+	}
+}