Merge pull request #109 from deploymenttheory/dev

+ documentation for cookiejar

Author: ShocOne

README.md

@@ -18,6 +18,8 @@ This client leverages API-specific SDKs to provide a comprehensive and consisten
 - **API Handler Interface**: Provides a flexible and extensible way to interact with different APIs, including encoding and decoding requests and responses, managing authentication endpoints, and handling API-specific logic.
 - **Configuration via JSON or Environment Variables**: The Go API HTTP Client supports configuration via JSON files or environment variables, providing flexibility in defining authentication credentials, API endpoints, logging settings, and other parameters.
 
+- **Cookie Jar Support**: Incorporates an optional cookie jar to manage cookies effortlessly across requests, enhancing session management and statefulness with APIs that require cookie-based authentication or tracking. This feature allows for automatic storage and sending of cookies with subsequent requests, mirroring browser-like interaction with web services. It can be enabled or disabled based on configuration, providing flexibility in how stateful interactions are handled with the target API.
+
 ## API Handler
 
 The `APIHandler` interface abstracts the functionality needed to interact with various APIs, making the HTTP client adaptable to different API implementations. It includes methods for constructing resource and authentication endpoints, marshaling requests, handling responses, and managing API-specific headers.
@@ -86,6 +88,10 @@ Example configuration file (clientconfig.json):
     "LogOutputFormat": "console", // "console" / "json"
     "LogConsoleSeparator": " ", // " " / "\t" / "," / etc.
     "HideSensitiveData": true,  // true / false
+    "EnableDynamicRateLimiting": true, // true / false
+    "MaxRetryAttempts": 5,
+    "MaxConcurrentRequests": 3,
+    "EnableCookieJar": true // true / false
   }
 }
 ```

httpclient/httpclient_cookies.go

@@ -1,3 +1,4 @@
+// httpclient_cookies.go
 package httpclient
 
 import (
@@ -11,7 +12,7 @@ func RedactSensitiveCookies(cookies []*http.Cookie) []*http.Cookie {
 	// Define sensitive cookie names that should be redacted.
 	sensitiveCookieNames := map[string]bool{
 		"SessionID": true, // Example sensitive cookie name
-		// Add more sensitive cookie names as needed.
+		// More sensitive cookie names will be added as needed.
 	}
 
 	// Iterate over the cookies and redact sensitive ones.

httpclient/httpclient_cookies_test.go

@@ -0,0 +1,56 @@
+// httpclient_cookies_test.go
+package httpclient
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestRedactSensitiveCookies tests the RedactSensitiveCookies function to ensure it correctly redacts sensitive cookies.
+func TestRedactSensitiveCookies(t *testing.T) {
+	cookies := []*http.Cookie{
+		{Name: "SessionID", Value: "sensitive-value-1"},
+		{Name: "NonSensitiveCookie", Value: "non-sensitive-value"},
+		{Name: "AnotherSensitiveCookie", Value: "sensitive-value-2"},
+	}
+
+	redactedCookies := RedactSensitiveCookies(cookies)
+
+	// Define expected outcomes for each cookie.
+	expectedValues := map[string]string{
+		"SessionID":              "REDACTED",
+		"NonSensitiveCookie":     "non-sensitive-value",
+		"AnotherSensitiveCookie": "sensitive-value-2", // Assuming this is not in the sensitive list.
+	}
+
+	for _, cookie := range redactedCookies {
+		assert.Equal(t, expectedValues[cookie.Name], cookie.Value, "Cookie value should match expected redaction outcome")
+	}
+}
+
+// TestCookiesFromHeader tests the CookiesFromHeader function to ensure it can correctly parse cookies from HTTP headers.
+func TestCookiesFromHeader(t *testing.T) {
+	header := http.Header{
+		"Set-Cookie": []string{
+			"SessionID=sensitive-value; Path=/; HttpOnly",
+			"NonSensitiveCookie=non-sensitive-value; Path=/",
+		},
+	}
+
+	cookies := CookiesFromHeader(header)
+
+	// Define expected outcomes for each cookie.
+	expectedCookies := []*http.Cookie{
+		{Name: "SessionID", Value: "sensitive-value"},
+		{Name: "NonSensitiveCookie", Value: "non-sensitive-value"},
+	}
+
+	assert.Equal(t, len(expectedCookies), len(cookies), "Number of parsed cookies should match expected")
+
+	for i, expectedCookie := range expectedCookies {
+		assert.Equal(t, expectedCookie.Name, cookies[i].Name, "Cookie names should match")
+		assert.Equal(t, expectedCookie.Value, cookies[i].Value, "Cookie values should match")
+	}
+}

httpclient/httpclient_error_response_test.go

@@ -0,0 +1,82 @@
+// httpclient_error_response_test.go
+// This package provides utility functions and structures for handling and categorizing HTTP error responses.
+package httpclient
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestHandleAPIErrorResponse tests the handleAPIErrorResponse function with different types of error responses.
+func TestHandleAPIErrorResponse(t *testing.T) {
+	tests := []struct {
+		name           string
+		response       *http.Response
+		expectedAPIErr *APIError
+	}{
+		{
+			name: "Structured JSON Error",
+			response: &http.Response{
+				StatusCode: 400,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":{"code":"INVALID","message":"Invalid request"}}`)),
+			},
+			expectedAPIErr: &APIError{
+				StatusCode: 400,
+				Type:       "APIError",
+				Message:    "Invalid request",
+				Detail:     "",
+				Errors:     nil,
+				Raw:        `{"error":{"code":"INVALID","message":"Invalid request"}}`,
+			},
+		},
+		{
+			name: "Generic JSON Error",
+			response: &http.Response{
+				StatusCode: 500,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(bytes.NewBufferString(`{"message":"Internal server error","detail":"Error details"}`)),
+			},
+			expectedAPIErr: &APIError{
+				StatusCode: 500,
+				Type:       "APIError",
+				Message:    "Internal server error",
+				Detail:     "Error details",
+				Errors:     nil,
+				Raw:        `{"message":"Internal server error","detail":"Error details"}`,
+			},
+		},
+		{
+			name: "Non-JSON Error",
+			response: &http.Response{
+				StatusCode: 404,
+				Header:     http.Header{"Content-Type": []string{"text/html"}},
+				Body:       io.NopCloser(bytes.NewBufferString("<html>Not Found</html>")),
+			},
+			expectedAPIErr: &APIError{
+				StatusCode: 404,
+				Type:       "APIError",
+				Message:    "An error occurred",
+				Detail:     "",
+				Errors:     nil,
+				Raw:        "<html>Not Found</html>",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockLog := NewMockLogger()
+			apiError := handleAPIErrorResponse(tt.response, mockLog)
+
+			assert.Equal(t, tt.expectedAPIErr.StatusCode, apiError.StatusCode)
+			assert.Equal(t, tt.expectedAPIErr.Message, apiError.Message)
+			assert.Equal(t, tt.expectedAPIErr.Detail, apiError.Detail)
+			assert.Equal(t, tt.expectedAPIErr.Raw, apiError.Raw)
+		})
+	}
+}

httpclient/httpclient_version.go

@@ -4,7 +4,7 @@ package httpclient
 import "fmt"
 
 const (
-	SDKVersion    = "0.0.8"
+	SDKVersion    = "0.0.90"
 	UserAgentBase = "go-api-http-client"
 )
 

version/version.go

@@ -5,7 +5,7 @@ package version
 var AppName = "go-api-http-client"
 
 // Version holds the current version of the application
-var Version = "0.0.65"
+var Version = "0.0.91"
 
 // GetAppName returns the name of the application
 func GetAppName() string {