Router/router_test.go

package router

import (
	"net/http"
	"net/http/httptest"
	"testing"

	assert "git.sharkk.net/Go/Assert"
)

func TestRootPath(t *testing.T) {
	r := New()
	r.Get("/", func(w Res, r Req, params []string) {})

	_, _, found := r.Lookup("GET", "/")
	assert.True(t, found)
}

func TestStaticPath(t *testing.T) {
	r := New()
	r.Get("/users/all", func(w Res, r Req, params []string) {})

	_, _, found := r.Lookup("GET", "/users/all")
	assert.True(t, found)
}

func TestSingleParameter(t *testing.T) {
	r := New()

	called := false
	r.Get("/users/[id]", func(w Res, r Req, params []string) {
		called = true
		assert.Equal(t, params[0], "123")
	})

	h, params, found := r.Lookup("GET", "/users/123")
	assert.True(t, found)
	h.Serve(nil, nil, params)
	assert.True(t, called)
}

func TestMultipleParameters(t *testing.T) {
	r := New()

	called := false
	r.Get("/users/[id]/posts/[postId]", func(w Res, r Req, params []string) {
		called = true
		assert.Equal(t, params[0], "123")
		assert.Equal(t, params[1], "456")
	})

	h, params, found := r.Lookup("GET", "/users/123/posts/456")
	assert.True(t, found)
	h.Serve(nil, nil, params)
	assert.True(t, called)
}

func TestNonExistentPath(t *testing.T) {
	r := New()
	r.Get("/users/[id]", func(w Res, r Req, params []string) {})

	_, _, found := r.Lookup("GET", "/posts/123")
	assert.False(t, found)
}

func TestWrongMethod(t *testing.T) {
	r := New()
	r.Get("/users/[id]", func(w Res, r Req, params []string) {})

	_, _, found := r.Lookup("POST", "/users/123")
	assert.False(t, found)
}

func TestTrailingSlash(t *testing.T) {
	r := New()

	called := false
	r.Get("/users/[id]", func(w Res, r Req, params []string) {
		called = true
		assert.Equal(t, params[0], "123")
	})

	h, params, found := r.Lookup("GET", "/users/123/")
	assert.True(t, found)
	h.Serve(nil, nil, params)
	assert.True(t, called)
}

func TestDifferentMethods(t *testing.T) {
	r := New()

	handler := func(w Res, r Req, params []string) {}

	r.Get("/test", handler)
	r.Post("/test", handler)
	r.Put("/test", handler)
	r.Patch("/test", handler)
	r.Delete("/test", handler)

	methods := []string{"GET", "POST", "PUT", "PATCH", "DELETE"}
	for _, method := range methods {
		t.Run(method, func(t *testing.T) {
			_, _, found := r.Lookup(method, "/test")
			assert.True(t, found)
		})
	}
}

func TestWildcardPath(t *testing.T) {
	r := New()

	t.Run("simple wildcard", func(t *testing.T) {
		called := false
		err := r.Get("/files/*path", func(w Res, r Req, params []string) {
			called = true
			assert.Equal(t, params[0], "docs/report.pdf")
		})
		assert.Nil(t, err)

		h, params, found := r.Lookup("GET", "/files/docs/report.pdf")
		assert.True(t, found)
		h.Serve(nil, nil, params)
		assert.True(t, called)
	})

	t.Run("wildcard with empty path", func(t *testing.T) {
		called := false
		err := r.Get("/download/*filepath", func(w Res, r Req, params []string) {
			called = true
			assert.Equal(t, params[0], "")
		})
		assert.Nil(t, err)

		h, params, found := r.Lookup("GET", "/download/")
		assert.True(t, found)
		h.Serve(nil, nil, params)
		assert.True(t, called)
	})

	t.Run("wildcard with parameter", func(t *testing.T) {
		called := false
		err := r.Get("/users/[id]/*action", func(w Res, r Req, params []string) {
			called = true
			assert.Equal(t, params[0], "123")
			assert.Equal(t, params[1], "settings/profile/avatar")
		})
		assert.Nil(t, err)

		h, params, found := r.Lookup("GET", "/users/123/settings/profile/avatar")
		assert.True(t, found)
		h.Serve(nil, nil, params)
		assert.True(t, called)
	})

	t.Run("multiple wildcards not allowed", func(t *testing.T) {
		err := r.Get("/api/*version/*path", func(w Res, r Req, params []string) {})
		assert.NotNil(t, err)
	})

	t.Run("non-last wildcard not allowed", func(t *testing.T) {
		err := r.Get("/api/*version/users", func(w Res, r Req, params []string) {})
		assert.NotNil(t, err)
	})
}

// Middleware Tests
func TestMiddleware(t *testing.T) {
	t.Run("global middleware", func(t *testing.T) {
		r := New()

		executed := false
		r.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				executed = true
				next(w, r, params)
			})
		})

		r.Get("/test", func(w Res, r Req, params []string) {})

		h, params, found := r.Lookup("GET", "/test")
		assert.True(t, found)
		h.Serve(nil, nil, params)
		assert.True(t, executed)
	})

	t.Run("multiple middleware", func(t *testing.T) {
		r := New()

		// Track middleware execution order
		order := []int{}

		r.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				order = append(order, 1)
				next.Serve(nil, nil, params)
				order = append(order, 4)
			})
		})

		r.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				order = append(order, 2)
				next.Serve(nil, nil, params)
				order = append(order, 3)
			})
		})

		r.Get("/test", func(w Res, r Req, params []string) {
			order = append(order, 0)
		})

		h, params, found := r.Lookup("GET", "/test")
		assert.True(t, found)
		h.Serve(nil, nil, params)

		// Check middleware execution order (first middleware wraps second)
		assert.Equal(t, len(order), 5)
		assert.Equal(t, order[0], 1) // First middleware enter
		assert.Equal(t, order[1], 2) // Second middleware enter
		assert.Equal(t, order[2], 0) // Handler
		assert.Equal(t, order[3], 3) // Second middleware exit
		assert.Equal(t, order[4], 4) // First middleware exit
	})

	t.Run("route-specific middleware", func(t *testing.T) {
		r := New()

		executed := false

		middleware := func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				executed = true
				next.Serve(nil, nil, params)
			})
		}

		r.WithMiddleware(middleware).Get("/test", func(w Res, r Req, params []string) {})

		h, params, found := r.Lookup("GET", "/test")
		assert.True(t, found)
		h.Serve(nil, nil, params)
		assert.True(t, executed)
	})
}

// Group Tests
func TestGroup(t *testing.T) {
	t.Run("simple group", func(t *testing.T) {
		r := New()

		// Create API group
		api := r.Group("/api")
		api.Get("/users", func(w Res, r Req, params []string) {})

		h, params, found := r.Lookup("GET", "/api/users")
		assert.True(t, found)
		h.Serve(nil, nil, params)
	})

	t.Run("nested groups", func(t *testing.T) {
		r := New()

		// Create nested groups
		api := r.Group("/api")
		v1 := api.Group("/v1")
		v1.Get("/users", func(w Res, r Req, params []string) {})

		h, params, found := r.Lookup("GET", "/api/v1/users")
		assert.True(t, found)
		h.Serve(nil, nil, params)
	})

	t.Run("group middleware", func(t *testing.T) {
		r := New()
		executed := false

		// Create group with middleware
		api := r.Group("/api")
		api.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				executed = true
				next.Serve(nil, nil, params)
			})
		})

		api.Get("/users", func(w Res, r Req, params []string) {})

		h, params, found := r.Lookup("GET", "/api/users")
		assert.True(t, found)
		h.Serve(nil, nil, params)
		assert.True(t, executed)
	})

	t.Run("nested group middleware", func(t *testing.T) {
		r := New()
		order := []int{}

		// Create group with middleware
		api := r.Group("/api")
		api.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				order = append(order, 1)
				next.Serve(nil, nil, params)
			})
		})

		// Create nested group with additional middleware
		v1 := api.Group("/v1")
		v1.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				order = append(order, 2)
				next.Serve(nil, nil, params)
			})
		})

		v1.Get("/users", func(w Res, r Req, params []string) {
			order = append(order, 3)
		})

		h, params, found := r.Lookup("GET", "/api/v1/users")
		assert.True(t, found)
		h.Serve(nil, nil, params)

		// Check middleware execution order
		assert.Equal(t, len(order), 3)
		assert.Equal(t, order[0], 1) // First middleware (from api group)
		assert.Equal(t, order[1], 2) // Second middleware (from v1 group)
		assert.Equal(t, order[2], 3) // Handler
	})

	t.Run("route-specific middleware in group", func(t *testing.T) {
		r := New()
		order := []int{}

		// Create group with middleware
		api := r.Group("/api")
		api.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				order = append(order, 1)
				next.Serve(nil, nil, params)
			})
		})

		// Add route with specific middleware
		api.WithMiddleware(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				order = append(order, 2)
				next.Serve(nil, nil, params)
			})
		}).Get("/users", func(w Res, r Req, params []string) {
			order = append(order, 3)
		})

		h, params, found := r.Lookup("GET", "/api/users")
		assert.True(t, found)
		h.Serve(nil, nil, params)

		// Check middleware execution order
		assert.Equal(t, len(order), 3)
		assert.Equal(t, order[0], 1) // Group middleware
		assert.Equal(t, order[1], 2) // Route-specific middleware
		assert.Equal(t, order[2], 3) // Handler
	})
}

// Benchmarks
func BenchmarkRouterLookup(b *testing.B) {
	r := New()
	handler := func(w Res, r Req, params []string) {}

	// Setup routes for benchmarking
	r.Get("/", handler)
	r.Get("/users/all", handler)
	r.Get("/users/[id]", handler)
	r.Get("/users/[id]/posts/[postId]", handler)

	b.Run("root", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/")
		}
	})

	b.Run("static", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/users/all")
		}
	})

	b.Run("single_param", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/users/123")
		}
	})

	b.Run("multi_param", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/users/123/posts/456")
		}
	})

	b.Run("not_found", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/nonexistent/path")
		}
	})
}

func BenchmarkParallelLookup(b *testing.B) {
	r := New()
	handler := func(w Res, r Req, params []string) {}

	r.Get("/users/[id]", handler)
	r.Get("/posts/[id]/comments", handler)
	r.Get("/products/[category]/[id]", handler)

	b.RunParallel(func(pb *testing.PB) {
		i := 0
		for pb.Next() {
			switch i % 3 {
			case 0:
				r.Lookup("GET", "/users/123")
			case 1:
				r.Lookup("GET", "/posts/456/comments")
			case 2:
				r.Lookup("GET", "/products/electronics/789")
			}
			i++
		}
	})
}

func BenchmarkWildcardLookup(b *testing.B) {
	r := New()
	handler := func(w Res, r Req, params []string) {}

	// Setup routes for benchmarking
	r.Get("/files/*path", handler)
	r.Get("/users/[id]/*action", handler)

	b.Run("simple_wildcard", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/files/documents/reports/2024/q1.pdf")
		}
	})

	b.Run("wildcard_with_param", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/users/123/settings/profile/avatar")
		}
	})
}

func BenchmarkMiddleware(b *testing.B) {
	passthrough := func(next Handler) Handler {
		return Handler(func(w Res, r Req, params []string) {
			next.Serve(nil, nil, params)
		})
	}

	b.Run("no_middleware", func(b *testing.B) {
		r := New()
		r.Get("/test", func(w Res, r Req, params []string) {})

		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			h, params, _ := r.Lookup("GET", "/test")
			h.Serve(nil, nil, params)
		}
	})

	b.Run("one_middleware", func(b *testing.B) {
		r := New()
		r.Use(passthrough)
		r.Get("/test", func(w Res, r Req, params []string) {})

		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			h, params, _ := r.Lookup("GET", "/test")
			h.Serve(nil, nil, params)
		}
	})

	b.Run("five_middleware", func(b *testing.B) {
		r := New()
		for range 5 {
			r.Use(passthrough)
		}
		r.Get("/test", func(w Res, r Req, params []string) {})

		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			h, params, _ := r.Lookup("GET", "/test")
			h.Serve(nil, nil, params)
		}
	})
}

func BenchmarkGroups(b *testing.B) {
	handler := func(w Res, r Req, params []string) {}

	b.Run("flat_route", func(b *testing.B) {
		r := New()
		r.Get("/api/v1/users", handler)

		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/api/v1/users")
		}
	})

	b.Run("grouped_route", func(b *testing.B) {
		r := New()
		api := r.Group("/api")
		v1 := api.Group("/v1")
		v1.Get("/users", handler)

		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			r.Lookup("GET", "/api/v1/users")
		}
	})

	b.Run("grouped_route_with_middleware", func(b *testing.B) {
		r := New()
		api := r.Group("/api")
		api.Use(func(next Handler) Handler {
			return Handler(func(w Res, r Req, params []string) {
				next.Serve(nil, nil, params)
			})
		})
		v1 := api.Group("/v1")
		v1.Get("/users", handler)

		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			h, params, _ := r.Lookup("GET", "/api/v1/users")
			h.Serve(nil, nil, params)
		}
	})
}

func BenchmarkNetHttpServer(b *testing.B) {
	r := New()

	// Set up test routes
	r.Get("/", func(w Res, r Req, params []string) {
		// No-op for benchmarking
	})
	r.Get("/users/all", func(w Res, r Req, params []string) {
		// No-op for benchmarking
	})
	r.Get("/users/[id]", func(w Res, r Req, params []string) {
		// No-op for benchmarking
	})

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

	// Create HTTP client
	client := &http.Client{
		Transport: &http.Transport{
			DisableKeepAlives: false,
		},
	}

	b.Run("root", func(b *testing.B) {
		url := server.URL + "/"
		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			resp, err := client.Get(url)
			if err != nil {
				b.Fatal(err)
			}
			resp.Body.Close()
		}
	})

	b.Run("static_path", func(b *testing.B) {
		url := server.URL + "/users/all"
		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			resp, err := client.Get(url)
			if err != nil {
				b.Fatal(err)
			}
			resp.Body.Close()
		}
	})

	b.Run("param_path", func(b *testing.B) {
		url := server.URL + "/users/123"
		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			resp, err := client.Get(url)
			if err != nil {
				b.Fatal(err)
			}
			resp.Body.Close()
		}
	})
}

func BenchmarkComparison(b *testing.B) {
	// Custom router setup
	customRouter := New()
	handler := func(w Res, r Req, params []string) {}

	customRouter.Get("/", handler)
	customRouter.Get("/users/all", handler)
	customRouter.Get("/users/[id]", handler)
	customRouter.Get("/users/[id]/posts/[postId]", handler)

	// Standard mux setup
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w Res, r Req) {})
	mux.HandleFunc("/users/all", func(w Res, r Req) {})
	mux.HandleFunc("/users/", func(w Res, r Req) {}) // Best equivalent for dynamic routes

	// Root path
	b.Run("root_path", func(b *testing.B) {
		b.Run("custom", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				customRouter.Lookup("GET", "/")
			}
		})
		b.Run("mux", func(b *testing.B) {
			req, _ := http.NewRequest("GET", "/", nil)
			for i := 0; i < b.N; i++ {
				mux.ServeHTTP(nil, req)
			}
		})
	})

	// Static path
	b.Run("static_path", func(b *testing.B) {
		b.Run("custom", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				customRouter.Lookup("GET", "/users/all")
			}
		})
		b.Run("mux", func(b *testing.B) {
			req, _ := http.NewRequest("GET", "/users/all", nil)
			for i := 0; i < b.N; i++ {
				mux.ServeHTTP(nil, req)
			}
		})
	})

	// Dynamic path
	b.Run("dynamic_path", func(b *testing.B) {
		b.Run("custom", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				customRouter.Lookup("GET", "/users/123")
			}
		})
		b.Run("mux", func(b *testing.B) {
			req, _ := http.NewRequest("GET", "/users/123", nil)
			for i := 0; i < b.N; i++ {
				mux.ServeHTTP(nil, req)
			}
		})
	})

	// Not found
	b.Run("not_found", func(b *testing.B) {
		b.Run("custom", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				customRouter.Lookup("GET", "/nonexistent/path")
			}
		})
		b.Run("mux", func(b *testing.B) {
			req, _ := http.NewRequest("GET", "/nonexistent/path", nil)
			for i := 0; i < b.N; i++ {
				mux.ServeHTTP(nil, req)
			}
		})
	})
}