Update mock logger functions to handle edge cases

ShocOne · ShocOne · commit 926b6dba2d1c · 2024-04-01T00:17:31.000+01:00
diff --git a/mocklogger/mocklogger.go b/mocklogger/mocklogger.go
@@ -0,0 +1,152 @@
+package mocklogger
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/deploymenttheory/go-api-http-client/logger" // Assuming this is the package where Logger interface is defined
+	"github.com/stretchr/testify/mock"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// 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
+	logLevel logger.LogLevel
+}
+
+// NewMockLogger creates a new instance of MockLogger with an embedded no-op *zap.Logger.
+func NewMockLogger() *MockLogger {
+	return &MockLogger{
+		Logger: zap.NewNop(),
+	}
+}
+
+// Ensure MockLogger implements the logger.Logger interface from the logger package
+var _ logger.Logger = (*MockLogger)(nil)
+
+func (m *MockLogger) GetLogLevel() logger.LogLevel {
+	args := m.Called()
+	if args.Get(0) != nil { // Check if the Called method has a return value
+		return args.Get(0).(logger.LogLevel)
+	}
+	return logger.LogLevelNone // Return LogLevelNone if no specific log level is set
+}
+
+func (m *MockLogger) SetLevel(level logger.LogLevel) {
+	m.logLevel = level
+	m.Called(level)
+}
+
+func (m *MockLogger) With(fields ...zapcore.Field) logger.Logger {
+	m.Called(fields)
+	// This is a mock implementation; adjust as necessary for your tests
+	return m
+}
+
+// Debug logs a message at the Debug level.
+func (m *MockLogger) Debug(msg string, fields ...zapcore.Field) {
+	m.Called(msg, fields)
+	if m.logLevel <= logger.LogLevelDebug {
+		fmt.Printf("[DEBUG] %s\n", msg)
+	}
+}
+
+// Info logs a message at the Info level.
+func (m *MockLogger) Info(msg string, fields ...zapcore.Field) {
+	m.Called(msg, fields)
+	if m.logLevel <= logger.LogLevelInfo {
+		fmt.Printf("[INFO] %s\n", msg)
+	}
+}
+
+// Error logs a message at the Error level and returns an error.
+func (m *MockLogger) Error(msg string, fields ...zapcore.Field) error {
+	m.Called(msg, fields)
+	if m.logLevel <= logger.LogLevelError {
+		fmt.Printf("[ERROR] %s\n", msg)
+	}
+	return errors.New(msg)
+}
+
+// Warn logs a message at the Warn level.
+func (m *MockLogger) Warn(msg string, fields ...zapcore.Field) {
+	m.Called(msg, fields)
+	if m.logLevel <= logger.LogLevelWarn {
+		fmt.Printf("[WARN] %s\n", msg)
+	}
+}
+
+// Panic logs a message at the Panic level and then panics.
+func (m *MockLogger) Panic(msg string, fields ...zapcore.Field) {
+	m.Called(msg, fields)
+	if m.logLevel <= logger.LogLevelPanic {
+		fmt.Printf("[PANIC] %s\n", msg)
+		panic(msg)
+	}
+}
+
+// Fatal logs a message at the Fatal level and then calls os.Exit(1).
+func (m *MockLogger) Fatal(msg string, fields ...zapcore.Field) {
+	m.Called(msg, fields)
+	if m.logLevel <= logger.LogLevelFatal {
+		fmt.Printf("[FATAL] %s\n", msg)
+		os.Exit(1)
+	}
+}
+
+// LogRequestStart logs the start of an HTTP request.
+func (m *MockLogger) LogRequestStart(event string, requestID string, userID string, method string, url string, headers map[string][]string) {
+	m.Called(event, requestID, userID, method, url, headers)
+	// Mock logging implementation...
+}
+
+// LogRequestEnd logs the end of an HTTP request.
+func (m *MockLogger) LogRequestEnd(event string, method string, url string, statusCode int, duration time.Duration) {
+	m.Called(event, method, url, statusCode, duration)
+	// Mock logging implementation...
+}
+
+// LogError logs an error event.
+func (m *MockLogger) LogError(event string, method string, url string, statusCode int, serverStatusMessage string, err error, rawResponse string) {
+	m.Called(event, method, url, statusCode, serverStatusMessage, err, rawResponse)
+	// Mock logging implementation...
+}
+
+// Example for LogAuthTokenError:
+func (m *MockLogger) LogAuthTokenError(event string, method string, url string, statusCode int, err error) {
+	m.Called(event, method, url, statusCode, err)
+	// Mock logging implementation...
+}
+
+// LogCookies logs information about cookies.
+func (m *MockLogger) LogCookies(direction string, obj interface{}, method, url string) {
+	// Use the mock framework to record that LogCookies was called with the specified arguments
+	m.Called(direction, obj, method, url)
+	fmt.Printf("[COOKIES] Direction: %s, Object: %v, Method: %s, URL: %s\n", direction, obj, method, url)
+}
+
+// LogRetryAttempt logs a retry attempt.
+func (m *MockLogger) LogRetryAttempt(event string, method string, url string, attempt int, reason string, waitDuration time.Duration, err error) {
+	m.Called(event, method, url, attempt, reason, waitDuration, err)
+	// Mock logging implementation...
+	fmt.Printf("[RETRY ATTEMPT] Event: %s, Method: %s, URL: %s, Attempt: %d, Reason: %s, Wait Duration: %s, Error: %v\n", event, method, url, attempt, reason, waitDuration, err)
+}
+
+// LogRateLimiting logs rate limiting events.
+func (m *MockLogger) LogRateLimiting(event string, method string, url string, retryAfter string, waitDuration time.Duration) {
+	m.Called(event, method, url, retryAfter, waitDuration)
+	// Mock logging implementation...
+	fmt.Printf("[RATE LIMITING] Event: %s, Method: %s, URL: %s, Retry After: %s, Wait Duration: %s\n", event, method, url, retryAfter, waitDuration)
+}
+
+// LogResponse logs HTTP responses.
+func (m *MockLogger) LogResponse(event string, method string, url string, statusCode int, responseBody string, responseHeaders map[string][]string, duration time.Duration) {
+	m.Called(event, method, url, statusCode, responseBody, responseHeaders, duration)
+	// Mock logging implementation...
+	fmt.Printf("[RESPONSE] Event: %s, Method: %s, URL: %s, Status Code: %d, Response Body: %s, Response Headers: %v, Duration: %s\n", event, method, url, statusCode, responseBody, responseHeaders, duration)
+}
diff --git a/redirecthandler/redirecthandler_test.go b/redirecthandler/redirecthandler_test.go
@@ -0,0 +1,121 @@
+package redirecthandler
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/deploymenttheory/go-api-http-client/mocklogger"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRedirectHandler_CheckRedirect(t *testing.T) {
+	mockLogger := mocklogger.NewMockLogger()
+
+	// Set the mock logger to capture logs at all levels
+	mockLogger.SetLevel(mocklogger.LogLevelDebug)
+
+	redirectHandler := NewRedirectHandler(mockLogger, 10)
+
+	reqURL, _ := url.Parse("http://example.com")
+	req := &http.Request{URL: reqURL, Method: http.MethodPost}
+	resp := &http.Response{
+		Status:     "303 See Other",
+		StatusCode: http.StatusSeeOther,
+		Header:     http.Header{"Location": []string{"http://example.com/new"}},
+	}
+
+	t.Run("Redirect Loop Detection", func(t *testing.T) {
+		redirectHandler.VisitedURLs = map[string]int{"http://example.com": 1}
+		err := redirectHandler.checkRedirect(req, []*http.Request{{}, {}})
+		assert.Equal(t, http.ErrUseLastResponse, err)
+		// Verify that a warning log for redirect loop was recorded
+		assert.Contains(t, mockLogger.Calls[0].Arguments.String(0), "Detected redirect loop")
+	})
+
+	t.Run("Maximum Redirects Reached", func(t *testing.T) {
+		redirectHandler.VisitedURLs = map[string]int{}
+		redirectHandler.MaxRedirects = 1
+		err := redirectHandler.checkRedirect(req, []*http.Request{{}, {}})
+		assert.Equal(t, http.ErrUseLastResponse, err)
+		// Verify that a warning log for max redirects was recorded
+		assert.Contains(t, mockLogger.Calls[1].Arguments.String(0), "Stopped after maximum redirects")
+	})
+
+	t.Run("Resolve Relative Redirects", func(t *testing.T) {
+		redirectHandler.MaxRedirects = 10
+		err := redirectHandler.checkRedirect(req, []*http.Request{{}, {}})
+		assert.Nil(t, err)
+		assert.Equal(t, "http://example.com/new", req.URL.String())
+	})
+
+	t.Run("Cross-Domain Security Measures", func(t *testing.T) {
+		reqURL, _ = url.Parse("http://example.com")
+		req = &http.Request{URL: reqURL, Method: http.MethodPost}
+		resp.Header.Set("Location", "http://anotherdomain.com/new")
+		err := redirectHandler.checkRedirect(req, []*http.Request{{}, {}})
+		assert.Nil(t, err)
+		// Ensure sensitive headers are removed and corresponding log is recorded
+		assert.Empty(t, req.Header.Get("Authorization"))
+		assert.Contains(t, mockLogger.Calls[2].Arguments.String(0), "Removed sensitive header")
+	})
+
+	t.Run("Handling 303 See Other", func(t *testing.T) {
+		reqURL, _ = url.Parse("http://example.com")
+		req = &http.Request{URL: reqURL, Method: http.MethodPost}
+		resp.Header.Set("Location", "http://example.com/new")
+		err := redirectHandler.checkRedirect(req, []*http.Request{{}, {}})
+		assert.Nil(t, err)
+		assert.Equal(t, http.MethodGet, req.Method)
+		// Ensure no body, no GetBody, correct ContentLength, no Content-Type header, and a log is recorded
+		assert.Nil(t, req.Body)
+		assert.Nil(t, req.GetBody)
+		assert.Equal(t, int64(0), req.ContentLength)
+		assert.Empty(t, req.Header.Get("Content-Type"))
+		assert.Contains(t, mockLogger.Calls[3].Arguments.String(0), "Changed request method to GET")
+	})
+}
+
+func TestRedirectHandler_ResolveRedirectURL(t *testing.T) {
+	redirectHandler := RedirectHandler{}
+
+	t.Run("Absolute URL", func(t *testing.T) {
+		reqURL, _ := url.Parse("http://example.com")
+		redirectURL, _ := url.Parse("http://newexample.com/path")
+		newReqURL, err := redirectHandler.resolveRedirectURL(reqURL, redirectURL)
+		assert.Nil(t, err)
+		assert.Equal(t, redirectURL.String(), newReqURL.String())
+	})
+
+	t.Run("Relative URL", func(t *testing.T) {
+		reqURL, _ := url.Parse("http://example.com/current")
+		redirectURL, _ := url.Parse("/newpath")
+		newReqURL, err := redirectHandler.resolveRedirectURL(reqURL, redirectURL)
+		assert.Nil(t, err)
+		assert.Equal(t, "http://example.com/newpath", newReqURL.String())
+	})
+
+	t.Run("Relative URL with Query and Fragment", func(t *testing.T) {
+		reqURL, _ := url.Parse("http://example.com/current?param=value#fragment")
+		redirectURL, _ := url.Parse("newpath?newparam=newvalue#newfragment")
+		newReqURL, err := redirectHandler.resolveRedirectURL(reqURL, redirectURL)
+		assert.Nil(t, err)
+		assert.Equal(t, "http://example.com/newpath?newparam=newvalue#newfragment", newReqURL.String())
+	})
+}
+
+func TestRedirectHandler_SecureRequest(t *testing.T) {
+	mockLogger := mocklogger.NewMockLogger()
+	mockLogger.SetLevel(mocklogger.LogLevelDebug)
+
+	redirectHandler := RedirectHandler{Logger: mockLogger}
+	req := &http.Request{Header: http.Header{"Authorization": []string{"token"}, "Cookie": []string{"session"}}}
+
+	t.Run("Secure Cross-Domain Redirect", func(t *testing.T) {
+		redirectHandler.secureRequest(req)
+		// Ensure sensitive headers are removed and log messages were recorded
+		assert.Empty(t, req.Header.Get("Authorization"))
+		assert.Empty(t, req.Header.Get("Cookie"))
+		assert.Contains(t, mockLogger.Calls[0].Arguments.String(0), "Removed sensitive header")
+	})
+}
