route_overwrite_extensive_test.go

package ming

import (
	"fmt"
	"testing"

	"github.com/valyala/fasthttp"
)

// TestExtensiveRouteOverwrite performs a comprehensive test of route overwriting behavior
func TestExtensiveRouteOverwrite(t *testing.T) {
	// Create a router instance
	router := New()
	
	// ==========================================
	// Test 1: Static route overwrite
	// ==========================================
	t.Run("StaticRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		
		// Register first handler
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
		}
		
		// Register second handler with same path
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
		}
		
		// Set both handlers
		router.Get("/api/products", firstHandler)
		router.Get("/api/products", secondHandler)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/api/products")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called, got %s", handlerCalled)
		}
		
		// Print debug info
		fmt.Println("[StaticRouteOverwrite] Handler called:", handlerCalled)
	})
	
	// ==========================================
	// Test 2: Parameter route overwrite 
	// ==========================================
	t.Run("ParameterRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		var paramValue string
		
		// Register first handler
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
			paramValue = Param(ctx, "id")
		}
		
		// Register second handler with same path
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
			paramValue = Param(ctx, "id")
		}
		
		// Set both handlers
		router.Post("/api/users/{id}", firstHandler)
		router.Post("/api/users/{id}", secondHandler)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("POST")
		ctx.Request.SetRequestURI("/api/users/42")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called, got %s", handlerCalled)
		}
		
		if paramValue != "42" {
			t.Errorf("Expected param value '42', got '%s'", paramValue)
		}
		
		// Print debug info
		fmt.Println("[ParameterRouteOverwrite] Handler called:", handlerCalled, "Param:", paramValue)
	})
	
	// ==========================================
	// Test 3: Regex parameter route overwrite
	// ==========================================
	t.Run("RegexParameterRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		var paramValue string
		
		// Register first handler
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
			paramValue = Param(ctx, "id")
		}
		
		// Register second handler with same path
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
			paramValue = Param(ctx, "id")
		}
		
		// Set both handlers with regex constraint
		router.Put("/api/posts/{id:[0-9]+}", firstHandler)
		router.Put("/api/posts/{id:[0-9]+}", secondHandler)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("PUT")
		ctx.Request.SetRequestURI("/api/posts/123")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called, got %s", handlerCalled)
		}
		
		if paramValue != "123" {
			t.Errorf("Expected param value '123', got '%s'", paramValue)
		}
		
		// Print debug info
		fmt.Println("[RegexParameterRouteOverwrite] Handler called:", handlerCalled, "Param:", paramValue)
	})
	
	// ==========================================
	// Test 4: Mixed route overwrite (one with regex, one without)
	// ==========================================
	t.Run("MixedParameterRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		var paramValue string
		
		// Register first handler without regex constraint
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
			paramValue = Param(ctx, "id")
		}
		
		// Register second handler with regex constraint
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
			paramValue = Param(ctx, "id")
		}
		
		// Set both handlers
		router.Delete("/products/{id}", firstHandler)
		router.Delete("/products/{id:[0-9]+}", secondHandler)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("DELETE")
		ctx.Request.SetRequestURI("/products/777")
		router.Handler(ctx)
		
		// Check result - the second handler should be used
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called, got %s", handlerCalled)
		}
		
		if paramValue != "777" {
			t.Errorf("Expected param value '777', got '%s'", paramValue)
		}
		
		// Print debug info
		fmt.Println("[MixedParameterRouteOverwrite] Handler called:", handlerCalled, "Param:", paramValue)
	})
	
	// ==========================================
	// Test 5: Multiple parameters route overwrite
	// ==========================================
	t.Run("MultipleParametersRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		var userID, postID string
		
		// Register first handler
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
			userID = Param(ctx, "userId")
			postID = Param(ctx, "postId")
		}
		
		// Register second handler with same path
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
			userID = Param(ctx, "userId")
			postID = Param(ctx, "postId")
		}
		
		// Set both handlers
		router.Get("/users/{userId}/posts/{postId}", firstHandler)
		router.Get("/users/{userId}/posts/{postId}", secondHandler)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/users/123/posts/456")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called, got %s", handlerCalled)
		}
		
		if userID != "123" || postID != "456" {
			t.Errorf("Expected params userId='123', postId='456', got '%s', '%s'", userID, postID)
		}
		
		// Print debug info
		fmt.Println("[MultipleParametersRouteOverwrite] Handler called:", handlerCalled, 
			"UserID:", userID, "PostID:", postID)
	})
	
	// ==========================================
	// Test 6: Optional parameter route overwrite
	// ==========================================
	t.Run("OptionalParameterRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		var format string
		
		// Skip this test if optional parameters are not working correctly
		handler, _, _ := router.trees["GET"].getValue("/api/", "GET")
		if handler == nil {
			t.Skip("Optional parameters not working yet, skipping test")
		}
		
		// Register first handler
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
			format = Param(ctx, "format")
			if format == "" {
				format = "default"
			}
		}
		
		// Register second handler with same path
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
			format = Param(ctx, "format")
			if format == "" {
				format = "default"
			}
		}
		
		// Set both handlers
		router.Get("/api/report{format?}", firstHandler)
		router.Get("/api/report{format?}", secondHandler)
		
		// Simulate request with format
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/api/report.json")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called with format, got %s", handlerCalled)
		}
		
		if format != ".json" {
			t.Errorf("Expected format '.json', got '%s'", format)
		}
		
		// Reset for next test
		handlerCalled = ""
		format = ""
		
		// Simulate request without format
		ctx = &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/api/report")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called without format, got %s", handlerCalled)
		}
		
		if format != "default" {
			t.Errorf("Expected default format, got '%s'", format)
		}
		
		// Print debug info
		fmt.Println("[OptionalParameterRouteOverwrite] Handler called:", handlerCalled, "Format:", format)
	})
	
	// ==========================================
	// Test 7: Catch-all parameter route overwrite
	// ==========================================
	t.Run("CatchAllParameterRouteOverwrite", func(t *testing.T) {
		var handlerCalled string
		var path string
		
		// Skip this test if catch-all parameters are not working correctly
		handler, _, _ := router.trees["GET"].getValue("/static/test.txt", "GET")
		if handler == nil {
			t.Skip("Catch-all parameters not working yet, skipping test")
		}
		
		// Register first handler
		firstHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "first"
			path = Param(ctx, "filepath")
		}
		
		// Register second handler with same path
		secondHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "second"
			path = Param(ctx, "filepath")
		}
		
		// Set both handlers
		router.Get("/static/{filepath:*}", firstHandler)
		router.Get("/static/{filepath:*}", secondHandler)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/static/css/style.css")
		router.Handler(ctx)
		
		// Check result
		if handlerCalled != "second" {
			t.Errorf("Expected second handler to be called, got %s", handlerCalled)
		}
		
		if path != "css/style.css" {
			t.Errorf("Expected path 'css/style.css', got '%s'", path)
		}
		
		// Print debug info
		fmt.Println("[CatchAllParameterRouteOverwrite] Handler called:", handlerCalled, "Path:", path)
	})
	
	// ==========================================
	// Test 8: ALL method overwrite with specific method
	// ==========================================
	t.Run("AllMethodOverwriteWithSpecific", func(t *testing.T) {
		var handlerCalled string
		
		// Register ALL handler first
		allHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "all"
		}
		
		// Register specific method handler second
		getHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "get"
		}
		
		// Set both handlers
		router.All("/ping", allHandler)
		router.Get("/ping", getHandler)
		
		// Simulate GET request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/ping")
		router.Handler(ctx)
		
		// Check GET result
		if handlerCalled != "get" {
			t.Errorf("Expected get handler to be called, got %s", handlerCalled)
		}
		
		// Reset for POST test
		handlerCalled = ""
		
		// Simulate POST request
		ctx = &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("POST")
		ctx.Request.SetRequestURI("/ping")
		router.Handler(ctx)
		
		// Check POST result - should use ALL handler
		if handlerCalled != "all" {
			t.Errorf("Expected all handler to be called for POST, got %s", handlerCalled)
		}
		
		// Print debug info
		fmt.Println("[AllMethodOverwriteWithSpecific] Handler called:", handlerCalled)
	})
	
	// ==========================================
	// Test 9: Specific method overwrite with ALL method
	// ==========================================
	t.Run("SpecificMethodOverwriteWithAll", func(t *testing.T) {
		var handlerCalled string
		
		// Register specific method handler first
		getHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "get"
		}
		
		// Register ALL handler second
		allHandler := func(ctx *fasthttp.RequestCtx) {
			handlerCalled = "all"
		}
		
		// Set both handlers
		router.Get("/health", getHandler)
		router.All("/health", allHandler)
		
		// Simulate GET request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/health")
		router.Handler(ctx)
		
		// Check GET result - should use GET handler despite ALL being registered later
		if handlerCalled != "get" {
			t.Errorf("Expected get handler to be called, got %s", handlerCalled)
		}
		
		// Reset for POST test
		handlerCalled = ""
		
		// Simulate POST request
		ctx = &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("POST") 
		ctx.Request.SetRequestURI("/health")
		router.Handler(ctx)
		
		// Check POST result - should use ALL handler
		if handlerCalled != "all" {
			t.Errorf("Expected all handler to be called for POST, got %s", handlerCalled)
		}
		
		// Print debug info
		fmt.Println("[SpecificMethodOverwriteWithAll] Handler called:", handlerCalled)
	})
	
	// ==========================================
	// Test 10: Multiple overwrites in sequence
	// ==========================================
	t.Run("MultipleOverwritesInSequence", func(t *testing.T) {
		var handlerCalled string
		
		// Register multiple handlers in sequence
		handler1 := func(ctx *fasthttp.RequestCtx) { handlerCalled = "first" }
		handler2 := func(ctx *fasthttp.RequestCtx) { handlerCalled = "second" }
		handler3 := func(ctx *fasthttp.RequestCtx) { handlerCalled = "third" }
		handler4 := func(ctx *fasthttp.RequestCtx) { handlerCalled = "fourth" }
		
		// Set handlers in sequence
		router.Get("/sequence", handler1)
		router.Get("/sequence", handler2)
		router.Get("/sequence", handler3)
		router.Get("/sequence", handler4)
		
		// Simulate request
		ctx := &fasthttp.RequestCtx{}
		ctx.Request.Header.SetMethod("GET")
		ctx.Request.SetRequestURI("/sequence")
		router.Handler(ctx)
		
		// Check result - should use last registered handler
		if handlerCalled != "fourth" {
			t.Errorf("Expected fourth handler to be called, got %s", handlerCalled)
		}
		
		// Print debug info
		fmt.Println("[MultipleOverwritesInSequence] Handler called:", handlerCalled)
	})
}