creation of a new functionality for testing in the quick platform, Qtest. The core functions of Quick and Ctx were refactored.

The PATCH and OPTIONS methods were created.

Author: jeffotoni

README.md

@@ -32,8 +32,6 @@
 | 📚 Docs                                           | yes  | 🟡     | 40%        |
 
 
-
-
 ## 🗺️| Development Rodmap
 
 | Task   | Progress |
@@ -94,21 +92,19 @@
 | Documentation Tests Examples PKG Go | 45.% |
 | Test Coverage go test -cover | 74.6% |
 | Regex feature coverage, but possibilities | 0.% |
-| Develop for OPTIONS METHOD | 0.% |
+| Develop for OPTIONS METHOD | 100% |
 | Develop for CONNECT METHOD [See more](https://www.rfc-editor.org/rfc/rfc9110.html#name-connect) | 0.% |
 | Develop method for ListenAndServeTLS (http2) | 0.% |
-| Develop Static Files support | 0.% |
-| Create a CLI (Command Line Interface) Quick. | 0.% |
+| Develop Static Files support | 100% |
 | WebSocket Support | 0.% |
 | Rate Limiter Support                              | 0.%       |
 | Template Engines                                  | 0.%       |
 | Documentation Tests Examples PKG Go   | 45. %   |
 | Test coverage go test -cover   | 75.5%   |
 | Coverage of Regex resources, but possibilities   | 0.%   |
-| Develop for METHOD OPTIONS   | 0.%   |
+| Develop for METHOD OPTIONS   | 100%   |
 | Develop for CONNECT METHOD [See more](https://www.rfc-editor.org/rfc/rfc9110.html#name-connect)   | 0.%   |
 | Develop method for ListenAndServeTLS (http2) | 0.%   |
-| Develops Static Files support   | 0.%   |
 | Create a CLI (Command Line Interface) Quick.   | 0.%   |
 
 
@@ -1018,6 +1014,75 @@ func main() {
 ```
 ---
 
+# Qtest - HTTP Testing Utility for Quick Framework
+
+Qtest is an **advanced HTTP testing function** designed to simplify route validation within the **Quick** framework. It enables seamless testing of simulated HTTP requests using `httptest`, supporting:
+
+- **Custom HTTP methods** (`GET`, `POST`, `PUT`, `DELETE`, etc.).
+- **Custom headers**.
+- **Query parameters**.
+- **Request body**.
+- **Cookies**.
+- **Built-in validation methods** for status codes, headers, and response bodies.
+
+## 📌 Overview
+The `Qtest` function takes a `QuickTestOptions` struct containing request parameters, executes the request, and returns a `QtestReturn` object, which provides methods for analyzing and validating the result.
+
+
+```go
+func TestQTest_Options_POST(t *testing.T) {
+    // start Quick
+    q := New()
+
+    // Define the POST route
+    q.Post("/v1/user/api", func(c *Ctx) error {
+        c.Set("Content-Type", "application/json") // Simplified header setting
+        return c.Status(StatusOK).String(`{"message":"Success"}`)
+    })
+
+    // Configure test parameters
+    opts := QuickTestOptions{
+        Method: "POST",
+        URI:    "/v1/user/api",
+        QueryParams: map[string]string{
+            "param1": "value1",
+            "param2": "value2",
+        },
+        Body: []byte(`{"key":"value"}`),
+        Headers: map[string]string{
+            "Content-Type": "application/json",
+        },
+        Cookies: []*http.Cookie{
+            {Name: "session", Value: "abc123"},
+        },
+        LogDetails: true, // Enables detailed logging
+    }
+
+    // Execute test
+    result, err := q.Qtest(opts)
+    if err != nil {
+        t.Fatalf("Error in Qtest: %v", err)
+    }
+
+    // Validations
+    if err := result.AssertStatus(StatusOK); err != nil {
+        t.Errorf("Status assertion failed: %v", err)
+    }
+
+    if err := result.AssertHeader("Content-Type", "application/json"); err != nil {
+        t.Errorf("Header assertion failed: %v", err)
+    }
+
+    if err := result.AssertBodyContains("Success"); err != nil {
+        t.Errorf("Body assertion failed: %v", err)
+    }
+}
+```
+
+🚀 **More details here [Qtest - Quick](https://github.com/jeffotoni/quick/tree/main/quickTest)**
+
+---
+
 ## 📚| More Examples
 
 This directory contains practical examples of the Quick Framework, a fast and lightweight web framework developed in Go. The examples are organized in separate folders, each containing a complete example of using the framework in a simple web application. If you have some interesting example of using the Quick Framework, feel free to send a pull request with your contribution. The Quick Framework example repository can be found at [here](https://github.com/jeffotoni/quick/tree/main/example).

ctx_test.go

@@ -1,6 +1,7 @@
 package quick
 
 import (
+	"bytes"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -205,6 +206,31 @@ func TestCtx_BodyString(t *testing.T) {
 	}
 }
 
+func TestCtx_Methods_JSON(t *testing.T) {
+
+	q := New()
+
+	q.Post("/json", func(c *Ctx) error {
+		data := map[string]string{"message": "Hello, JSON!"}
+		return c.JSON(data)
+	})
+
+	data, err := q.QuickTest("POST", "/json", nil)
+	if err != nil {
+		t.Errorf("Error during QuickTest: %v", err)
+		return
+	}
+
+	if data.StatusCode() != http.StatusOK {
+		t.Errorf("Expected status %d, got %d", http.StatusOK, data.StatusCode())
+	}
+
+	expected := `{"message":"Hello, JSON!"}`
+	if !bytes.Equal(bytes.TrimSpace(data.Body()), []byte(expected)) {
+		t.Errorf("Expected JSON body '%s', got '%s'", expected, data.BodyStr())
+	}
+}
+
 func TestCtx_JSON(t *testing.T) {
 	type fields struct {
 		Response  http.ResponseWriter

quick.go

@@ -147,75 +147,106 @@ func (q *Quick) Use(mw any, nf ...string) {
 	q.mws2 = append(q.mws2, mw)
 }
 
-// Get function is an HTTP route with the GET method on the Quick server
-// The result will Get(pattern string, handlerFunc HandleFunc)
-func (q *Quick) Get(pattern string, handlerFunc HandleFunc) {
-	path, params, partternExist := extractParamsPattern(pattern)
-
+// registerRoute is a helper function to centralize route registration logic.
+func (q *Quick) registerRoute(method, pattern string, handlerFunc HandleFunc) {
+	path, params, patternExist := extractParamsPattern(pattern)
+	formattedPath := concat.String(strings.ToLower(method)+"#", pattern)
 	route := Route{
-		Pattern: partternExist,
+		Pattern: patternExist,
 		Path:    path,
 		Params:  params,
-		handler: extractParamsGet(q, path, params, handlerFunc),
-		Method:  MethodGet,
+		handler: extractHandler(q, method, path, params, handlerFunc),
+		Method:  method,
 	}
+
 	q.appendRoute(&route)
-	q.mux.HandleFunc(path, route.handler)
+	q.mux.HandleFunc(formattedPath, route.handler)
+}
+
+// Get function is an HTTP route with the GET method on the Quick server
+// The result will Get(pattern string, handlerFunc HandleFunc)
+func (q *Quick) Get(pattern string, handlerFunc HandleFunc) {
+	q.registerRoute(MethodGet, pattern, handlerFunc)
 }
 
 // Post function registers an HTTP route with the POST method on the Quick server
 // The result will Post(pattern string, handlerFunc HandleFunc)
 func (q *Quick) Post(pattern string, handlerFunc HandleFunc) {
-	_, params, partternExist := extractParamsPattern(pattern)
-	pathPost := concat.String("post#", pattern)
-
-	route := Route{
-		Pattern: partternExist,
-		Params:  params,
-		Path:    pattern,
-		handler: extractParamsPost(q, handlerFunc),
-		Method:  MethodPost,
-	}
-
-	q.appendRoute(&route)
-	q.mux.HandleFunc(pathPost, route.handler)
+	q.registerRoute(MethodPost, pattern, handlerFunc)
 }
 
 // Put function registers an HTTP route with the PUT method on the Quick server.
 // The result will Put(pattern string, handlerFunc HandleFunc)
 func (q *Quick) Put(pattern string, handlerFunc HandleFunc) {
-	_, params, partternExist := extractParamsPattern(pattern)
-
-	pathPut := concat.String("put#", pattern)
-
-	route := Route{
-		Pattern: partternExist,
-		Path:    pattern,
-		handler: extractParamsPut(q, handlerFunc),
-		Method:  MethodPut,
-		Params:  params,
-	}
-
-	q.appendRoute(&route)
-	q.mux.HandleFunc(pathPut, route.handler)
+	q.registerRoute(MethodPut, pattern, handlerFunc)
 }
 
 // Delete function registers an HTTP route with the DELETE method on the Quick server.
 // The result will Delete(pattern string, handlerFunc HandleFunc)
 func (q *Quick) Delete(pattern string, handlerFunc HandleFunc) {
-	_, params, partternExist := extractParamsPattern(pattern)
-	pathDelete := concat.String("delete#", pattern)
+	q.registerRoute(MethodDelete, pattern, handlerFunc)
+}
 
-	route := Route{
-		Pattern: partternExist,
-		Path:    pattern,
-		Params:  params,
-		handler: extractParamsDelete(q, handlerFunc),
-		Method:  MethodDelete,
+// Path function registers an HTTP route with the PATH method on the Quick server.
+// The result will Path(pattern string, handlerFunc HandleFunc)
+func (q *Quick) Patch(pattern string, handlerFunc HandleFunc) {
+	q.registerRoute(MethodPatch, pattern, handlerFunc)
+}
+
+// Options function registers an HTTP route with the Options method on the Quick server.
+// The result will Options(pattern string, handlerFunc HandleFunc)
+func (q *Quick) Options(pattern string, handlerFunc HandleFunc) {
+	q.registerRoute(MethodOptions, pattern, handlerFunc)
+}
+
+// Generic handler extractor to minimize repeated logic across HTTP methods
+// The result will extractHandler(q *Quick, method, path, params string, handlerFunc HandleFunc) http.HandlerFunc
+func extractHandler(q *Quick, method, path, params string, handlerFunc HandleFunc) http.HandlerFunc {
+	switch method {
+	case MethodGet:
+		return extractParamsGet(q, path, params, handlerFunc)
+	case MethodPost:
+		return extractParamsPost(q, handlerFunc)
+	case MethodPut:
+		return extractParamsPut(q, handlerFunc)
+	case MethodDelete:
+		return extractParamsDelete(q, handlerFunc)
+	case MethodPatch:
+		return extractParamsPatch(q, handlerFunc) // same as PUT
+	case MethodOptions:
+		return extractParamsOptions(q, method, path, handlerFunc)
 	}
+	return nil
+}
 
-	q.appendRoute(&route)
-	q.mux.HandleFunc(pathDelete, route.handler)
+func extractParamsPatch(q *Quick, handlerFunc HandleFunc) http.HandlerFunc {
+	return extractParamsPut(q, handlerFunc)
+}
+
+// extractParamsOptions processes an HTTP request for a dynamic route, extracting query parameters, headers, and handling the request using the provided handler function
+// The result will extractParamsOptions(q *Quick, method, path string, handlerFunc HandleFunc) http.HandlerFunc
+func extractParamsOptions(q *Quick, method, path string, handlerFunc HandleFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Define allowed HTTP methods
+		allowMethods := []string{MethodGet, MethodPost, MethodPut, MethodDelete, MethodPatch, MethodOptions}
+		w.Header().Set("Allow", strings.Join(allowMethods, ", "))
+
+		// Add CORS headers
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", strings.Join(allowMethods, ", "))
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
+
+		// If a handlerFunc exists, execute it
+		if handlerFunc != nil {
+			err := handlerFunc(&Ctx{Response: w, Request: r})
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+		} else {
+			w.WriteHeader(http.StatusNoContent) // Use 204 if no body is needed
+		}
+	}
 }
 
 // extractHeaders extracts all headers from an HTTP request and returns them