contracts/support/body.go (2)

5-11: Add documentation for the interface and its methods.

The interface looks well-designed, but it's missing documentation. Consider adding package-level and method-level documentation to improve maintainability.

Here's a suggested improvement:

+// Body represents an interface for building HTTP request bodies with support for
+// both form fields and file uploads.
 type Body interface {
+	// SetFields sets multiple fields at once and returns the Body for chaining.
 	SetFields(fields map[string]any) Body
+	// SetField sets a single field with the given key and value, returns the Body for chaining.
 	SetField(key string, value any) Body
+	// GetField retrieves the value associated with the given key.
 	GetField(key string) any
+	// SetFile adds a file to be uploaded with the given field name and file path.
 	SetFile(fieldName, filePath string) Body
+	// Build constructs and returns the final request body as an io.Reader.
 	Build() (io.Reader, error)
 }

---

5-11: Consider enhancing the interface with additional utility methods.

The interface provides basic functionality but could benefit from additional methods to improve usability and robustness.

Consider adding these methods:

1. Reset() method to clear all fields and files
2. Validate() method to check field values before building
3. SetContentType(contentType string) to explicitly set the content type
4. HasFiles() bool to check if the body contains files

Example addition:

type Body interface {
    // ... existing methods ...
    
    // Reset clears all fields and files
    Reset() Body
    
    // Validate checks if all fields and files are valid
    Validate() error
    
    // SetContentType sets the content type for the body
    SetContentType(contentType string) Body
    
    // HasFiles returns true if the body contains files
    HasFiles() bool
}

support/http/body_test.go (2)

11-18: Consider adding more test cases for edge scenarios.

While the basic functionality is well tested, consider adding test cases for:

• Empty or nil values
• Overwriting existing fields
• Invalid field names or special characters
• Very large values

 func TestBodyImpl_SetField(t *testing.T) {
 	body := NewBody()
 
 	body.SetField("name", "Alice").SetField("age", 25)
+
+	// Test empty and nil values
+	body.SetField("empty", "").SetField("nil", nil)
+
+	// Test overwriting existing field
+	body.SetField("name", "Bob")
+
+	// Test special characters in field names
+	body.SetField("special@#$%", "value")
 
 	assert.Equal(t, "Alice", body.GetField("name"))
 	assert.Equal(t, 25, body.GetField("age"))
+	assert.Equal(t, "", body.GetField("empty"))
+	assert.Nil(t, body.GetField("nil"))
+	assert.Equal(t, "Bob", body.GetField("name"))
+	assert.Equal(t, "value", body.GetField("special@#$%"))
 }

---

20-36: Consider enhancing JSON body tests with complex data structures.

The current test covers basic JSON serialization well, but could be enhanced by testing:

• Nested objects
• Array values
• Complex data types
• Content-Type header verification (if applicable)

 func TestBodyImpl_Build_JSONBody(t *testing.T) {
 	body := NewBody()
-	body.SetField("name", "Alice").SetField("age", 25)
+	body.SetField("name", "Alice").
+		SetField("age", 25).
+		SetField("address", map[string]interface{}{
+			"street": "123 Main St",
+			"city":   "Example City",
+		}).
+		SetField("hobbies", []string{"reading", "coding"})
 
 	reader, err := body.Build()
 	assert.NoError(t, err)
 
+	// Verify Content-Type if applicable
+	contentType := body.GetContentType()
+	assert.Equal(t, "application/json", contentType)
+
 	buf := new(bytes.Buffer)
 	_, err = buf.ReadFrom(reader)
 	assert.NoError(t, err)
 
 	var result map[string]any
 	err = json.Unmarshal(buf.Bytes(), &result)
 	assert.NoError(t, err)
+
 	assert.Equal(t, "Alice", result["name"])
 	assert.Equal(t, float64(25), result["age"])
+	
+	address, ok := result["address"].(map[string]interface{})
+	assert.True(t, ok)
+	assert.Equal(t, "123 Main St", address["street"])
+	assert.Equal(t, "Example City", address["city"])
+
+	hobbies, ok := result["hobbies"].([]interface{})
+	assert.True(t, ok)
+	assert.Equal(t, []interface{}{"reading", "coding"}, hobbies)
 }

support/http/body.go (3)

18-21: Document that BodyImpl is not safe for concurrent use

BodyImpl contains mutable state with formValues and fileFields maps, which are not protected against concurrent access. If instances of BodyImpl are accessed by multiple goroutines, it could lead to data races. Consider adding documentation to indicate that BodyImpl is not thread-safe or implement synchronization if concurrent use is expected.

---

1-115: Add unit tests for BodyImpl methods

Unit tests are essential to ensure the correctness of the new BodyImpl struct and its methods. They help catch potential bugs and regression issues. Please add tests covering:

• Setting fields and files
• Building JSON and multipart bodies
• Error handling for file operations and JSON marshalling
• Edge cases such as empty inputs and invalid file paths

---

23-23: Add GoDoc comments to exported functions and methods

To improve code readability and maintainability, consider adding GoDoc comments to all exported functions and methods, such as NewBody, SetFields, SetField, GetField, SetFile, and Build. This will help other developers understand the purpose and usage of these functions.

Example:

// NewBody creates a new instance of BodyImpl.
func NewBody() support.Body {
    return &BodyImpl{
        formValues: make(map[string]any),
        fileFields: make(map[string]string),
    }
}

Also applies to: 30-30, 35-35, 40-40, 44-44, 49-49

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Check type handling in the implementation
# Expected: Find type assertions or validation in the implementation

# Look for type assertions or validation
rg -A 5 "type assertion|interface{}|any" --type go

# Look for panic handling related to type conversion
rg -A 5 "panic|recover" --type go

# Look for error handling patterns
ast-grep --pattern 'if err := $_; err != nil {
  $$$
}'

#!/bin/bash
# Search for Body interface implementations
ast-grep --pattern 'type $_ struct {
  $$$
}

func (r *$_) SetFields(fields map[string]any) $_ {
  $$$
}

func (r *$_) SetField(key string, value any) $_ {
  $$$
}

func (r *$_) GetField(key string) any {
  $$$
}

func (r *$_) SetFile(fieldName, filePath string) $_ {
  $$$
}

func (r *$_) Build() (io.Reader, error) {
  $$$
}'

#!/bin/bash
# Search for files implementing Body interface
rg -l "Body interface" --type go
rg -l "type.*struct.*SetFields.*SetField.*GetField.*SetFile.*Build" --type go

#!/bin/bash
# Search for Body implementation files
rg -l "implements.*Body" --type go
rg -l "support\.Body" --type go

# Look for the implementation details
rg "type \w+Body struct" --type go -A 20

#!/bin/bash
# Get the implementation details from body.go
cat support/http/body.go

contracts/support/http/body.go (3)

5-12: Consider enhancing the interface with additional error handling and validation methods.

The interface provides a good foundation but could benefit from additional methods for robustness:

1. GetField could benefit from error handling for missing keys
2. Consider adding methods for:
   • Checking field existence (e.g., HasField(key string) bool)
   • Removing fields/files
   • Validating file paths before setting them

Example enhancement:

 type Body interface {
 	Build() (Reader, error)
-	GetField(key string) any
+	GetField(key string) (any, error)
+	HasField(key string) bool
 	SetField(key string, value any) Body
 	SetFields(fields map[string]any) Body
 	SetFile(fieldName, filePath string) Body
 	SetFiles(files map[string]string) Body
+	RemoveField(key string) Body
+	RemoveFile(fieldName string) Body
 }

---

14-17: Consider enhancing the Reader interface and improving method naming.

The interface is clean but could benefit from:

1. Rename Reader() method to avoid redundancy with interface name (e.g., Read())
2. Add support for content length, which is often needed for HTTP requests

Example enhancement:

 type Reader interface {
-	Reader() io.Reader
+	Read() io.Reader
 	ContentType() string
+	ContentLength() int64
 }

---

1-17: Well-designed interface separation following SOLID principles.

The separation of concerns between Body (request building) and Reader (content access) interfaces is well thought out. This design:

1. Follows the Interface Segregation Principle
2. Enables different implementations for various body types (JSON, form, multipart)
3. Provides a clean abstraction for HTTP request body handling

Consider documenting the expected behavior of these interfaces in godoc format, especially regarding:

• Thread safety expectations
• Memory management (when are resources released)
• Expected implementation behavior for edge cases

support/http/reader.go (3)

9-12: Add documentation for the type and its fields.

While the implementation is clean, consider adding documentation comments to describe the type's purpose and field meanings.

+// readerImpl implements http.Reader interface to handle HTTP request body reading
 type readerImpl struct {
+	// body contains the actual content to be read
 	body        io.Reader
+	// contentType specifies the MIME type of the body content
 	contentType string
 }

---

14-19: Add input validation and documentation to the constructor.

Consider validating the input parameters and adding documentation to describe the function's purpose and parameters.

+// newReader creates a new http.Reader instance with the specified body and content type.
+// It returns nil if body is nil to prevent potential nil pointer dereferences.
 func newReader(body io.Reader, contentType string) http.Reader {
+	if body == nil {
+		return nil
+	}
 	return &readerImpl{
 		body:        body,
 		contentType: contentType,
 	}
 }

---

21-27: Add documentation to interface methods.

While the implementation is correct, consider adding documentation to clearly indicate interface compliance.

+// Reader returns the underlying io.Reader containing the body content.
+// Implements http.Reader interface.
 func (r *readerImpl) Reader() io.Reader {
 	return r.body
 }

+// ContentType returns the MIME type of the body content.
+// Implements http.Reader interface.
 func (r *readerImpl) ContentType() string {
 	return r.contentType
 }

support/http/body_test.go (1)

23-26: Add test case for GetField with a non-existent key

Adding a test to verify the behavior of GetField when retrieving a key that does not exist will help ensure consistent and expected behavior of the method.

You can add the following assertion:

assert.Nil(t, body.GetField("non_existent_key"))

support/http/body.go (2)

79-89: Body type override in SetFile and SetFiles methods

The methods SetFile and SetFiles set the bodyType to BodyTypeMultipart unconditionally. If the BodyType was intentionally set to another type before adding files, it will be overridden without notice. Consider adding a check or documenting this behavior to prevent unintentional overrides.

Apply this diff to set the bodyType to BodyTypeMultipart only if it's not already set:

 func (r *BodyImpl) SetFile(fieldName, filePath string) http.Body {
 	maps.Set(r.fileFields, fieldName, filePath)
-	r.bodyType = BodyTypeMultipart
+	if r.bodyType != BodyTypeMultipart {
+		r.bodyType = BodyTypeMultipart
+	}
 	return r
 }

 func (r *BodyImpl) SetFiles(files map[string]string) http.Body {
 	r.fileFields = collect.Merge(r.fileFields, files)
-	r.bodyType = BodyTypeMultipart
+	if r.bodyType != BodyTypeMultipart {
+		r.bodyType = BodyTypeMultipart
+	}
 	return r
 }

---

158-159: Handle potential errors from io.Copy in addFile

When copying file content using io.Copy, you might want to handle partial writes or log the number of bytes copied for debugging purposes. Currently, only the error is returned, which is acceptable, but being explicit can improve robustness.

Consider updating the code to check the number of bytes copied:

 _, err = io.Copy(part, file)
+if err != nil {
+	return err
+}
+// Optionally, log the number of bytes copied if needed
 return err

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Verify interface compliance and test coverage

# Test 1: Check if the interface is properly defined
echo "Checking interface definition..."
ast-grep --pattern 'type Reader interface {
  $$$
  Reader() io.Reader
  ContentType() string
  $$$
}'

# Test 2: Look for test files
echo "Checking for test coverage..."
fd -e go -g '*_test.go' --exec rg -l 'readerImpl'

# Test 3: Check usage patterns
echo "Checking usage patterns..."
rg -A 5 'newReader\(' 

#!/bin/bash
# Check for tests that might use the Reader interface or newReader indirectly
echo "Checking for related test files..."
fd -e go -g '*_test.go' --exec rg -l 'http\.Reader|ContentType\(\)|Reader\(\)'

# Check if there are any tests in the http package
echo "Checking for tests in http package..."
fd -e go -g '*_test.go' -p 'support/http'

#!/bin/bash
# Check the content of body_test.go
echo "Checking body_test.go content..."
cat support/http/body_test.go

# Also check for any indirect usage in validation tests
echo "Checking validation test usage..."
rg -A 5 'http\.Reader' validation/validator_test.go

#!/bin/bash
# Description: Verify that collect.Merge correctly merges two maps.

# Expected result: The merged map should contain all keys from both maps.

# Locate the implementation of collect.Merge
rg 'func Merge' -t go -A 5

# If collect.Merge is part of an external package, review the package documentation

#!/bin/bash
# Let's check the implementation of lo.Assign since collect.Merge uses it
rg 'github.com/samber/lo' -A 2 go.mod

# Also check for any tests that verify the merge behavior
rg 'func Test.*Merge' -t go -A 10 

+// newReader wraps the content with the specified content type into an http.Reader.
+func newReader(content io.Reader, contentType string) http.Reader {
+	return &readerImpl{
+		Reader:      content,
+		contentType: contentType,
+	}
+}
+
+type readerImpl struct {
+	io.Reader
+	contentType string
+}
+
+func (r *readerImpl) ContentType() string {
+	return r.contentType
+}

support/http/body_test.go (4)

16-34: Add test cases for edge cases in field operations.

While the basic functionality is well tested, consider adding the following test cases:

• Setting nil/empty maps
• Overwriting fields with different types
• Getting non-existent fields

 func TestBodySetFields(t *testing.T) {
+	t.Run("basic_fields", func(t *testing.T) {
 		body := NewBody().SetFields(map[string]any{
 			"name": "krishan",
 			"age":  22,
 			"role": "developer",
 		}).SetField("role", "admin")
 
 		assert.Equal(t, "krishan", body.GetField("name"))
 		assert.Equal(t, 22, body.GetField("age"))
 		assert.Equal(t, "admin", body.GetField("role"))
+	})
+
+	t.Run("nil_map", func(t *testing.T) {
+		body := NewBody().SetFields(nil)
+		assert.NotNil(t, body)
+	})
+
+	t.Run("type_conversion", func(t *testing.T) {
+		body := NewBody().
+			SetField("value", "123").
+			SetField("value", 123)
+		assert.Equal(t, 123, body.GetField("value"))
+	})
+
+	t.Run("non_existent_field", func(t *testing.T) {
+		body := NewBody()
+		assert.Nil(t, body.GetField("nonexistent"))
+	})
 }

---

36-53: Enhance JSON body tests with complex data structures.

Add test cases for:

• Nested objects
• Arrays/slices
• Null values

 func TestBuildJSONBody(t *testing.T) {
+	t.Run("simple_fields", func(t *testing.T) {
 		body := NewBody().
 			SetField("name", "krishan").
 			SetField("age", 22)
 
 		reader, err := body.Build()
 		assert.NoError(t, err)
 
 		buf := new(bytes.Buffer)
 		_, err = buf.ReadFrom(reader.Reader())
 		assert.NoError(t, err)
 
 		var result map[string]any
 		err = json.Unmarshal(buf.Bytes(), &result)
 		assert.NoError(t, err)
 		assert.Equal(t, "krishan", result["name"])
 		assert.Equal(t, float64(22), result["age"])
+	})
+
+	t.Run("complex_structure", func(t *testing.T) {
+		body := NewBody().
+			SetField("user", map[string]any{
+				"name": "krishan",
+				"address": map[string]any{
+					"city": "New York",
+				},
+			}).
+			SetField("tags", []string{"go", "test"}).
+			SetField("nullable", nil)
+
+		reader, err := body.Build()
+		assert.NoError(t, err)
+
+		buf := new(bytes.Buffer)
+		_, err = buf.ReadFrom(reader.Reader())
+		assert.NoError(t, err)
+
+		var result map[string]any
+		err = json.Unmarshal(buf.Bytes(), &result)
+		assert.NoError(t, err)
+
+		user := result["user"].(map[string]any)
+		assert.Equal(t, "krishan", user["name"])
+		address := user["address"].(map[string]any)
+		assert.Equal(t, "New York", address["city"])
+		assert.Equal(t, []any{"go", "test"}, result["tags"])
+		assert.Nil(t, result["nullable"])
+	})
 }

---

55-71: Add test cases for form data edge cases.

Add tests for:

• Multiple values for the same key
• Empty values

 func TestBuildFormBody(t *testing.T) {
+	t.Run("simple_fields", func(t *testing.T) {
 		body := NewBody(BodyTypeForm).
 			SetField("name", "krishan").
 			SetField("age", 22)
 
 		reader, err := body.Build()
 		assert.NoError(t, err)
 
 		buf := new(bytes.Buffer)
 		_, err = buf.ReadFrom(reader.Reader())
 		assert.NoError(t, err)
 
 		formData, err := url.ParseQuery(buf.String())
 		assert.NoError(t, err)
 		assert.Equal(t, "krishan", formData.Get("name"))
 		assert.Equal(t, "22", formData.Get("age"))
+	})
+
+	t.Run("array_fields", func(t *testing.T) {
+		body := NewBody(BodyTypeForm).
+			SetField("tags[]", []string{"go", "test"})
+
+		reader, err := body.Build()
+		assert.NoError(t, err)
+
+		buf := new(bytes.Buffer)
+		_, err = buf.ReadFrom(reader.Reader())
+		assert.NoError(t, err)
+
+		formData, err := url.ParseQuery(buf.String())
+		assert.NoError(t, err)
+		assert.Equal(t, []string{"go", "test"}, formData["tags[]"])
+	})
+
+	t.Run("empty_values", func(t *testing.T) {
+		body := NewBody(BodyTypeForm).
+			SetField("empty", "").
+			SetField("null", nil)
+
+		reader, err := body.Build()
+		assert.NoError(t, err)
+
+		buf := new(bytes.Buffer)
+		_, err = buf.ReadFrom(reader.Reader())
+		assert.NoError(t, err)
+
+		formData, err := url.ParseQuery(buf.String())
+		assert.NoError(t, err)
+		assert.Equal(t, "", formData.Get("empty"))
+		assert.Equal(t, "", formData.Get("null"))
+	})
 }

---

130-146: Expand special characters test coverage.

Add test cases for:

• Unicode characters
• Very long values
• URL-unsafe characters

 func TestBuildFormBodyWithSpecialCharacters(t *testing.T) {
+	t.Run("basic_special_chars", func(t *testing.T) {
 		body := NewBody(BodyTypeForm).
 			SetField("name", "krishan").
 			SetField("special_chars", "&=+?")
 
 		reader, err := body.Build()
 		assert.NoError(t, err)
 
 		buf := new(bytes.Buffer)
 		_, err = buf.ReadFrom(reader.Reader())
 		assert.NoError(t, err)
 
 		formData, err := url.ParseQuery(buf.String())
 		assert.NoError(t, err)
 		assert.Equal(t, "krishan", formData.Get("name"))
 		assert.Equal(t, "&=+?", formData.Get("special_chars"))
+	})
+
+	t.Run("unicode_and_unsafe_chars", func(t *testing.T) {
+		body := NewBody(BodyTypeForm).
+			SetField("unicode", "Hello, 世界").
+			SetField("unsafe", "!@#$%^&*(){}[]|\\:;\"'<>,./")
+
+		reader, err := body.Build()
+		assert.NoError(t, err)
+
+		buf := new(bytes.Buffer)
+		_, err = buf.ReadFrom(reader.Reader())
+		assert.NoError(t, err)
+
+		formData, err := url.ParseQuery(buf.String())
+		assert.NoError(t, err)
+		assert.Equal(t, "Hello, 世界", formData.Get("unicode"))
+		assert.Equal(t, "!@#$%^&*(){}[]|\\:;\"'<>,./", formData.Get("unsafe"))
+	})
+
+	t.Run("long_value", func(t *testing.T) {
+		longValue := strings.Repeat("a", 10000)
+		body := NewBody(BodyTypeForm).
+			SetField("long", longValue)
+
+		reader, err := body.Build()
+		assert.NoError(t, err)
+
+		buf := new(bytes.Buffer)
+		_, err = buf.ReadFrom(reader.Reader())
+		assert.NoError(t, err)
+
+		formData, err := url.ParseQuery(buf.String())
+		assert.NoError(t, err)
+		assert.Equal(t, longValue, formData.Get("long"))
+	})
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

support/http/body_test.go (4)

16-34: Add test cases for edge cases and concurrent access

While the basic functionality is covered, consider adding test cases for:

• Nil/empty values
• Zero values for different types
• Concurrent field access
• Field deletion/overwriting

 func TestBodySetFields(t *testing.T) {
+	t.Run("basic_fields", func(t *testing.T) {
 		body := NewBody().SetFields(map[string]any{
 			"name": "krishan",
 			"age":  22,
 			"role": "developer",
 		}).SetField("role", "admin")
 
 		assert.Equal(t, "krishan", body.GetField("name"))
 		assert.Equal(t, 22, body.GetField("age"))
 		assert.Equal(t, "admin", body.GetField("role"))
+	})
+
+	t.Run("edge_cases", func(t *testing.T) {
+		body := NewBody().SetFields(map[string]any{
+			"nil_value":   nil,
+			"empty_str":   "",
+			"zero_int":    0,
+			"empty_slice": []string{},
+		})
+
+		assert.Nil(t, body.GetField("nil_value"))
+		assert.Empty(t, body.GetField("empty_str"))
+		assert.Zero(t, body.GetField("zero_int"))
+		assert.Empty(t, body.GetField("empty_slice"))
+	})
 }

---

36-112: Add content type validation in body building tests

While the body building functionality is tested, consider adding assertions to validate the correct Content-Type headers:

• For JSON: application/json
• For Form: application/x-www-form-urlencoded
• For Multipart: multipart/form-data with boundary

 func TestBuildJSONBody(t *testing.T) {
 	reader, err := body.Build()
 	assert.NoError(t, err)
+	assert.Equal(t, "application/json", reader.ContentType())

 	// ... rest of the test
 }

 func TestBuildFormBody(t *testing.T) {
 	reader, err := body.Build()
 	assert.NoError(t, err)
+	assert.Equal(t, "application/x-www-form-urlencoded", reader.ContentType())

 	// ... rest of the test
 }

---

132-148: Expand special character testing

Consider adding more edge cases for special character handling:

• Unicode characters
• Very long field values
• Empty field names
• Special characters in field names

 func TestBuildFormBodyWithSpecialCharacters(t *testing.T) {
+	t.Run("basic_special_chars", func(t *testing.T) {
 		body := NewBody(BodyTypeForm).
 			SetField("name", "krishan").
 			SetField("special_chars", "&=+?")
 
 		// ... existing test code
+	})
+
+	t.Run("extended_special_chars", func(t *testing.T) {
+		body := NewBody(BodyTypeForm).
+			SetField("unicode_field", "🚀✨").
+			SetField("long_value", strings.Repeat("a", 1000)).
+			SetField("special_field_name!@#", "value").
+			SetField("", "empty_key")
+
+		reader, err := body.Build()
+		assert.NoError(t, err)
+
+		// ... verify form data
+	})
 }

---

1-148: Overall assessment: Good foundation, needs enhancement

The test suite provides good basic coverage of the HTTP body implementation. However, to ensure robustness, consider:

1. Adding concurrent access tests
2. Expanding error scenario coverage
3. Adding more edge cases
4. Validating content types
5. Testing with larger payloads

These enhancements will help ensure the implementation is production-ready.

Configuration used: CodeRabbit UI
Review profile: CHILL