Add comprehensive testing and performance examples with test suites

## New Examples Added:
- **Testing cookbook**: Complete testing guide with unit, integration, and validation tests
- **Performance cookbook**: Benchmarking, profiling, and load testing examples

## Modernization Updates:
- Fixed hardcoded Echo/3.0 version to Echo/4.11 in middleware example
- Added environment variable support for JWT secrets in authentication examples

## Test Coverage Added:
- **hello-world**: Basic functionality and benchmark tests
- **middleware**: Stats middleware and server header tests
- **graceful-shutdown**: Integration tests for shutdown behavior
- **jwt/custom-claims**: Comprehensive JWT authentication testing
- **testing**: Meta-example showing how to test Echo applications
- **performance**: Benchmark and performance validation tests

## Enhanced Development Experience:
- Updated Makefile with new commands: test-cookbook, benchmark, test-cover
- Added dependency management and cleanup targets
- Created individual go.mod files for complex examples

## Test Commands Available:
- `make test-cookbook` - Run all cookbook tests
- `make benchmark` - Run performance benchmarks
- `make test-cover` - Generate coverage reports
- `make deps` - Install test dependencies

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: vishr

Makefile

@@ -1,7 +1,47 @@
 test:
 	go test -race ./...
 
+test-cookbook:
+	@echo "Running tests for cookbook examples..."
+	@for dir in cookbook/*/; do \
+		if [ -f "$$dir/server_test.go" ]; then \
+			echo "Testing $$dir..."; \
+			(cd "$$dir" && go test -v ./...) || exit 1; \
+		fi; \
+	done
+
+test-verbose:
+	go test -race -v ./...
+
+test-cover:
+	go test -race -coverprofile=coverage.out ./...
+	go tool cover -html=coverage.out -o coverage.html
+
+benchmark:
+	@echo "Running benchmarks for cookbook examples..."
+	@for dir in cookbook/*/; do \
+		if [ -f "$$dir/server_test.go" ]; then \
+			echo "Benchmarking $$dir..."; \
+			(cd "$$dir" && go test -bench=. -benchmem) || true; \
+		fi; \
+	done
+
 serve:
 	docker run --rm -it --name echo-docs -v ${CURDIR}/website:/home/app -w /home/app -p 3000:3000 -u node node:lts /bin/bash -c "npm install && npm start -- --host=0.0.0.0"
 
-.PHONY: test serve
+deps:
+	@echo "Installing test dependencies for cookbook examples..."
+	@for dir in cookbook/*/; do \
+		if [ -f "$$dir/go.mod" ]; then \
+			echo "Installing deps for $$dir..."; \
+			(cd "$$dir" && go mod tidy && go mod download) || exit 1; \
+		fi; \
+	done
+
+clean:
+	@echo "Cleaning test artifacts..."
+	find . -name "coverage.out" -delete
+	find . -name "coverage.html" -delete
+	find . -name "*.prof" -delete
+
+.PHONY: test test-cookbook test-verbose test-cover benchmark serve deps clean

cookbook/graceful-shutdown/server_test.go

@@ -0,0 +1,163 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGracefulShutdown(t *testing.T) {
+	// Skip in short mode as this test takes time
+	if testing.Short() {
+		t.Skip("Skipping graceful shutdown test in short mode")
+	}
+
+	// Setup Echo server
+	e := echo.New()
+	e.HideBanner = true
+
+	// Add the test endpoint that sleeps
+	e.GET("/", func(c echo.Context) error {
+		time.Sleep(5 * time.Second)
+		return c.JSON(http.StatusOK, "OK")
+	})
+
+	// Start server in a goroutine
+	serverErr := make(chan error, 1)
+	go func() {
+		if err := e.Start(":0"); err != nil && err != http.ErrServerClosed {
+			serverErr <- err
+		}
+	}()
+
+	// Wait a moment for server to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Get the actual port the server is listening on
+	address := e.Listener.Addr().String()
+
+	// Start a request that will take 5 seconds
+	requestDone := make(chan bool, 1)
+	go func() {
+		client := &http.Client{Timeout: 10 * time.Second}
+		resp, err := client.Get(fmt.Sprintf("http://%s/", address))
+		if err == nil {
+			resp.Body.Close()
+			if resp.StatusCode == http.StatusOK {
+				requestDone <- true
+				return
+			}
+		}
+		requestDone <- false
+	}()
+
+	// Wait a bit then initiate shutdown
+	time.Sleep(100 * time.Millisecond)
+
+	// Test graceful shutdown
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	shutdownErr := make(chan error, 1)
+	go func() {
+		shutdownErr <- e.Shutdown(ctx)
+	}()
+
+	// Wait for either server error or shutdown completion
+	select {
+	case err := <-serverErr:
+		t.Fatalf("Server failed to start: %v", err)
+	case err := <-shutdownErr:
+		require.NoError(t, err, "Server shutdown should not error")
+	case <-time.After(15 * time.Second):
+		t.Fatal("Test timeout - shutdown took too long")
+	}
+
+	// Verify the long-running request completed successfully
+	select {
+	case success := <-requestDone:
+		assert.True(t, success, "Long-running request should complete successfully during graceful shutdown")
+	case <-time.After(2 * time.Second):
+		t.Error("Long-running request did not complete in time")
+	}
+}
+
+func TestServerBasicFunctionality(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	e.HideBanner = true
+
+	// Add the endpoint from the main example
+	e.GET("/", func(c echo.Context) error {
+		time.Sleep(5 * time.Second)
+		return c.JSON(http.StatusOK, "OK")
+	})
+
+	// Start server
+	go func() {
+		e.Start(":0")
+	}()
+
+	// Wait for server to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Test basic functionality (without waiting for full response)
+	address := e.Listener.Addr().String()
+	client := &http.Client{Timeout: 1 * time.Second}
+
+	// This will timeout, but we're just testing that the connection is established
+	_, err := client.Get(fmt.Sprintf("http://%s/", address))
+
+	// We expect a timeout error since the handler sleeps for 5 seconds
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "timeout")
+
+	// Cleanup
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+	e.Shutdown(ctx)
+}
+
+func TestShutdownWithoutActiveRequests(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	e.HideBanner = true
+
+	e.GET("/quick", func(c echo.Context) error {
+		return c.JSON(http.StatusOK, "Quick response")
+	})
+
+	// Start server
+	go func() {
+		e.Start(":0")
+	}()
+
+	// Wait for server to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Make a quick request
+	address := e.Listener.Addr().String()
+	client := &http.Client{Timeout: 1 * time.Second}
+	resp, err := client.Get(fmt.Sprintf("http://%s/quick", address))
+
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	resp.Body.Close()
+
+	// Shutdown should be quick with no active requests
+	start := time.Now()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	err = e.Shutdown(ctx)
+	duration := time.Since(start)
+
+	assert.NoError(t, err)
+	assert.Less(t, duration, 1*time.Second, "Shutdown without active requests should be quick")
+}

cookbook/hello-world/server_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHelloWorld(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Handler
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!\n")
+	}
+
+	// Assertions
+	if assert.NoError(t, handler(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+		assert.Equal(t, "Hello, World!\n", rec.Body.String())
+	}
+}
+
+func TestHelloWorldIntegration(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	e.GET("/", func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!\n")
+	})
+
+	// Test request
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	// Assertions
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.Equal(t, "Hello, World!\n", rec.Body.String())
+	assert.Equal(t, "text/plain; charset=UTF-8", rec.Header().Get("Content-Type"))
+}
+
+func BenchmarkHelloWorld(b *testing.B) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!\n")
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = handler(c)
+	}
+}