example_test.go

package httpx_test

import (
	"context"
	"fmt"
	"net/http"
	"net/http/httptest"
	"net/url"

	"github.com/quentinalbertone/httpx"
)

// ExampleNewRouter demonstrates basic usage of the httpx router.
func ExampleNewRouter() {
	// Create a new router with default logging and error handling
	router := httpx.NewRouter(nil, nil)

	// Add a simple GET route
	router.GET("/hello", func(w http.ResponseWriter, r *http.Request) error {
		return httpx.JSON(w, http.StatusOK, map[string]string{
			"message": "Hello, World!",
		})
	})

	// Create a test server
	server := httptest.NewServer(router)
	defer server.Close()

	// Make a request to test the route
	resp, err := http.Get(server.URL + "/hello")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	fmt.Println("Status:", resp.StatusCode)
	fmt.Println("Content-Type:", resp.Header.Get("Content-Type"))
	// Output:
	// Status: 200
	// Content-Type: application/json
}

// ExampleGroup demonstrates route grouping and middleware.
func ExampleGroup() {
	router := httpx.NewRouter(nil, nil)

	// Create an API group with a common prefix
	api := router.Group("/api")

	// Create a v1 subgroup
	v1 := api.Group("/v1")

	// Add routes to the v1 group
	v1.GET("/users", func(w http.ResponseWriter, r *http.Request) error {
		users := []map[string]interface{}{
			{"id": 1, "name": "Alice"},
			{"id": 2, "name": "Bob"},
		}
		return httpx.JSON(w, http.StatusOK, users)
	})

	v1.POST("/users", func(w http.ResponseWriter, r *http.Request) error {
		return httpx.JSON(w, http.StatusCreated, map[string]string{
			"message": "User created",
		})
	})

	server := httptest.NewServer(router)
	defer server.Close()

	// Test the grouped route
	resp, err := http.Get(server.URL + "/api/v1/users")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	fmt.Println("Status:", resp.StatusCode)
	// Output:
	// Status: 200

}

// ExampleNext demonstrates middleware usage with the Next function.
func ExampleNext() {
	// Custom middleware that adds a header
	headerMiddleware := func(w http.ResponseWriter, r *http.Request) error {
		w.Header().Set("X-Custom-Header", "middleware-value")
		// Call the next handler in the chain
		return httpx.Next(w, r)
	}

	router := httpx.NewRouter(nil, nil)

	// Add a route with middleware
	router.GET("/protected", headerMiddleware, func(w http.ResponseWriter, r *http.Request) error {
		return httpx.JSON(w, http.StatusOK, map[string]string{
			"message": "This response has a custom header",
		})
	})

	server := httptest.NewServer(router)
	defer server.Close()

	resp, err := http.Get(server.URL + "/protected")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	fmt.Println("Custom Header:", resp.Header.Get("X-Custom-Header"))
	// Output:
	// Custom Header: middleware-value
}

// ExampleJSON demonstrates the JSON utility function.
func ExampleJSON() {
	handler := func(w http.ResponseWriter, r *http.Request) error {
		data := struct {
			Message string `json:"message"`
			Count   int    `json:"count"`
		}{
			Message: "Hello from JSON",
			Count:   42,
		}
		return httpx.JSON(w, http.StatusOK, data)
	}

	// Create a test request
	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()

	// Call the handler
	err := handler(w, req)
	if err != nil {
		panic(err)
	}

	resp := w.Result()
	fmt.Println("Status:", resp.StatusCode)
	fmt.Println("Content-Type:", resp.Header.Get("Content-Type"))
	// Output:
	// Status: 200
	// Content-Type: application/json
}

// ExampleListenAndServe demonstrates how to start an HTTP server with graceful
// shutdown and a CORS middleware applied globally via WithHTTPMiddleware.
func ExampleListenAndServe() {

	// Create a router with routes
	router := httpx.NewRouter(nil, nil)

	router.GET("/api/users", func(w http.ResponseWriter, r *http.Request) error {
		return httpx.JSON(w, http.StatusOK, []string{"Alice", "Bob"})
	})

	// CORSMiddleware sets CORS headers on every response and handles preflight requests.
	corsMiddleware := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.Header().Set("Access-Control-Allow-Origin", "*")
			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

			// Handle preflight requests
			if r.Method == http.MethodOptions {
				w.WriteHeader(http.StatusOK)
				return
			}

			next.ServeHTTP(w, r)
		})
	}

	// Configure the server with custom settings
	serverConf := func(server *http.Server) {
		server.Addr = ":8080"
		// You can set other server options here:
		// server.ReadTimeout = 5 * time.Second
		// server.WriteTimeout = 10 * time.Second
		// server.IdleTimeout = 120 * time.Second
	}

	// Start the server with CORS enabled globally.
	// WithHTTPMiddleware wraps the server's handler so it applies to all
	// requests, including those that don't match any route.
	ctx := context.Background()
	if err := httpx.ListenAndServe(ctx, router,
		serverConf,
		httpx.WithHTTPMiddleware(corsMiddleware),
	); err != nil {
		fmt.Printf("Server error: %v\n", err)
	}
}

// ExampleDecodeQueryParams_nestedStruct demonstrates using DecodeQueryParams with nested structs.
func ExampleDecodeQueryParams_nestedStruct() {
	// Define structs with nested structure
	type Location struct {
		City    string `query:"city"`
		Country string `query:"country"`
	}

	type User struct {
		Name     string   `query:"name"`
		Age      int      `query:"age"`
		Location Location `query:"loc"`
	}

	// Parse a URL with nested query parameters
	u, _ := url.Parse("https://api.example.com/users?name=Alice&age=30&loc.city=Paris&loc.country=France")

	// Decode query parameters into the struct
	var filter User
	err := httpx.DecodeQueryParams(*u, &filter)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	// Use the decoded values
	fmt.Printf("Name: %s\n", filter.Name)
	fmt.Printf("Age: %d\n", filter.Age)
	fmt.Printf("City: %s\n", filter.Location.City)
	fmt.Printf("Country: %s\n", filter.Location.Country)

	// Output:
	// Name: Alice
	// Age: 30
	// City: Paris
	// Country: France
}