feat: add framework-agnostic mock context for testing

README.md

@@ -363,3 +363,50 @@
 
 [gin-gonic-issue]: https://github.com/gin-gonic/gin/issues/155
 [contributors-url]: https://github.com/go-fuego/fuego/graphs/contributors
+
+## Testing with Mock Context
+
+Fuego provides a framework-agnostic mock context for testing your controllers. This allows you to test your business logic without depending on specific web frameworks.
+
+### Basic Usage
+
+```go
+func TestMyController(t *testing.T) {
+    // Create a mock context with your request body type
+    ctx := fuego.NewMockContext[UserRequest]()
+
+    // Set up test data
+    ctx.SetBody(UserRequest{
+        Name: "John Doe",
+        Email: "john@example.com",
+    })
+
+    // Add query parameters if needed
+    ctx.SetURLValues(url.Values{
+        "filter": []string{"active"},
+    })
+
+    // Add path parameters
+    ctx.SetPathParam("id", "123")
+
+    // Call your controller
+    result, err := MyController(ctx)
+
+    // Assert results
+    assert.NoError(t, err)
+    assert.Equal(t, expectedResult, result)
+}
+```
+
+### Features
+
+The mock context supports:
+
+- Type-safe request bodies with generics
+- URL query parameters
+- Path parameters
+- Headers
+- Custom context values
+- Request/Response objects
+
+This makes it easy to test your controllers without worrying about HTTP mechanics or framework specifics.

mock_context.go

@@ -0,0 +1,105 @@
+package fuego
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+)
+
+// MockContext provides a framework-agnostic implementation of ContextWithBody
+// for testing purposes. It allows testing controllers without depending on
+// specific web frameworks like Gin or Echo.
+type MockContext[B any] struct {
+	body       B
+	urlValues  url.Values
+	headers    http.Header
+	pathParams map[string]string
+	ctx        context.Context
+	response   http.ResponseWriter
+	request    *http.Request
+}
+
+// NewMockContext creates a new MockContext instance with initialized maps
+// for URL values, headers, and path parameters. It uses context.Background()
+// as the default context.
+func NewMockContext[B any]() *MockContext[B] {
+	return &MockContext[B]{
+		urlValues:  make(url.Values),
+		headers:    make(http.Header),
+		pathParams: make(map[string]string),
+		ctx:        context.Background(),
+	}
+}
+
+// Body returns the previously set body value. This method always returns
+// nil as the error value, as the mock context doesn't perform actual
+// deserialization.
+func (m *MockContext[B]) Body() (B, error) {
+	return m.body, nil
+}
+
+// SetBody stores the provided body value for later retrieval via Body().
+// This is typically used in tests to simulate request bodies.
+func (m *MockContext[B]) SetBody(body B) {
+	m.body = body
+}
+
+// URLValues returns the mock URL values
+func (m *MockContext[B]) URLValues() url.Values {
+	return m.urlValues
+}
+
+// SetURLValues sets the mock URL values
+func (m *MockContext[B]) SetURLValues(values url.Values) {
+	m.urlValues = values
+}
+
+// Header returns the mock headers
+func (m *MockContext[B]) Header() http.Header {
+	return m.headers
+}
+
+// SetHeader sets a mock header
+func (m *MockContext[B]) SetHeader(key, value string) {
+	m.headers.Set(key, value)
+}
+
+// PathParam returns a mock path parameter
+func (m *MockContext[B]) PathParam(name string) string {
+	return m.pathParams[name]
+}
+
+// SetPathParam sets a mock path parameter
+func (m *MockContext[B]) SetPathParam(name, value string) {
+	m.pathParams[name] = value
+}
+
+// Context returns the mock context
+func (m *MockContext[B]) Context() context.Context {
+	return m.ctx
+}
+
+// SetContext sets the mock context
+func (m *MockContext[B]) SetContext(ctx context.Context) {
+	m.ctx = ctx
+}
+
+// Response returns the mock response writer
+func (m *MockContext[B]) Response() http.ResponseWriter {
+	return m.response
+}
+
+// SetResponse sets the mock response writer
+func (m *MockContext[B]) SetResponse(w http.ResponseWriter) {
+	m.response = w
+}
+
+// Request returns the mock request
+func (m *MockContext[B]) Request() *http.Request {
+	return m.request
+}
+
+// SetRequest sets the mock request
+func (m *MockContext[B]) SetRequest(r *http.Request) {
+	m.request = r
+} 

mock_context_test.go

@@ -0,0 +1,74 @@
+package fuego
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type TestBody struct {
+	Name string `json:"name"`
+	Age  int    `json:"age"`
+}
+
+func TestMockContext(t *testing.T) {
+	// Create a new mock context
+	ctx := NewMockContext[TestBody]()
+
+	// Test body
+	body := TestBody{
+		Name: "John",
+		Age:  30,
+	}
+	ctx.SetBody(body)
+	gotBody, err := ctx.Body()
+	assert.NoError(t, err)
+	assert.Equal(t, body, gotBody)
+
+	// Test URL values
+	values := url.Values{
+		"key": []string{"value"},
+	}
+	ctx.SetURLValues(values)
+	assert.Equal(t, values, ctx.URLValues())
+
+	// Test headers
+	ctx.SetHeader("Content-Type", "application/json")
+	assert.Equal(t, "application/json", ctx.Header().Get("Content-Type"))
+
+	// Test path params
+	ctx.SetPathParam("id", "123")
+	assert.Equal(t, "123", ctx.PathParam("id"))
+}
+
+func TestMockContextAdvanced(t *testing.T) {
+	// Test with custom context
+	ctx := NewMockContext[TestBody]()
+	customCtx := context.WithValue(context.Background(), "key", "value")
+	ctx.SetContext(customCtx)
+	assert.Equal(t, "value", ctx.Context().Value("key"))
+
+	// Test with request/response
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "/test", nil)
+	ctx.SetResponse(w)
+	ctx.SetRequest(r)
+	assert.Equal(t, w, ctx.Response())
+	assert.Equal(t, r, ctx.Request())
+
+	// Test multiple headers
+	ctx.SetHeader("X-Test-1", "value1")
+	ctx.SetHeader("X-Test-2", "value2")
+	assert.Equal(t, "value1", ctx.Header().Get("X-Test-1"))
+	assert.Equal(t, "value2", ctx.Header().Get("X-Test-2"))
+
+	// Test multiple path params
+	ctx.SetPathParam("id", "123")
+	ctx.SetPathParam("category", "books")
+	assert.Equal(t, "123", ctx.PathParam("id"))
+	assert.Equal(t, "books", ctx.PathParam("category"))
+}