test(router): add test case for RouteNotFound handler in groups

Add TestRouterRouteNotFoundHandlerInGroup to verify that a RouteNotFound
handler registered at root or group level is correctly invoked when a
route exists but the HTTP method is not registered (issue #2485).

Test scenarios covered:
- Root-level RouteNotFound fires for group sub-path with wrong method
- Group-level RouteNotFound fires for group sub-path with wrong method
- Root-level handler fires when no group-level handler defined
- Falls back to methodNotAllowedHandler when no RouteNotFound registered

Signed-off-by: lyydsheep <2230561977@qq.com>

Author: lyydsheep

router_test.go

@@ -3621,6 +3621,100 @@ func TestPathValues_GetOr(t *testing.T) {
 	}
 }
 
+// TestRouterRouteNotFoundHandlerInGroup verifies that a RouteNotFound handler registered
+// at a parent (root or group) level is properly invoked for sub-paths when the route exists
+// but the HTTP method is not registered. This is the scenario described in issue #2485.
+func TestRouterRouteNotFoundHandlerInGroup(t *testing.T) {
+	var testCases = []struct {
+		name              string
+		whenMethod        string
+		whenURL           string
+		expectHandlerID   string
+		expectCode        int
+		registerRootNotFound bool
+		registerGroupNotFound bool
+	}{
+		{
+			name:                 "root RouteNotFound handler fires for group sub-path with wrong method",
+			whenMethod:           http.MethodPost,
+			whenURL:              "/api/users",
+			expectHandlerID:      "root-not-found",
+			registerRootNotFound: true,
+		},
+		{
+			name:                  "group RouteNotFound handler fires for group sub-path with wrong method",
+			whenMethod:            http.MethodPost,
+			whenURL:               "/api/users",
+			expectHandlerID:       "group-not-found",
+			registerGroupNotFound: true,
+		},
+		{
+			name:                 "root RouteNotFound fires when no group-level handler defined",
+			whenMethod:           http.MethodDelete,
+			whenURL:              "/api/items/123",
+			expectHandlerID:      "root-not-found",
+			registerRootNotFound: true,
+		},
+		{
+			name:       "fallback to methodNotAllowed when no RouteNotFound handler defined",
+			whenMethod: http.MethodPost,
+			whenURL:    "/api/users",
+			// no RouteNotFound registered → method not allowed
+			expectHandlerID: "method-not-allowed",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			e := New()
+			handlerID := ""
+
+			// Register a GET route inside a group
+			g := e.Group("/api")
+			g.GET("/users", func(c *Context) error {
+				handlerID = "users-get"
+				return nil
+			})
+			g.GET("/items/:id", func(c *Context) error {
+				handlerID = "items-get"
+				return nil
+			})
+
+			// Optionally register RouteNotFound at root level
+			if tc.registerRootNotFound {
+				e.RouteNotFound("/*", func(c *Context) error {
+					handlerID = "root-not-found"
+					return nil
+				})
+			}
+
+			// Optionally register RouteNotFound at group level
+			if tc.registerGroupNotFound {
+				g.RouteNotFound("/*", func(c *Context) error {
+					handlerID = "group-not-found"
+					return nil
+				})
+			}
+
+			req := httptest.NewRequest(tc.whenMethod, tc.whenURL, nil)
+			rec := httptest.NewRecorder()
+			c := e.NewContext(req, rec)
+			handler := e.router.Route(c)
+
+			_ = handler(c)
+
+			if tc.expectHandlerID == "method-not-allowed" {
+				// When no RouteNotFound is registered, the default methodNotAllowedHandler fires.
+				// It returns ErrMethodNotAllowed; handlerID will remain empty.
+				assert.Empty(t, handlerID, "expected no custom handler to fire")
+			} else {
+				assert.Equal(t, tc.expectHandlerID, handlerID,
+					"wrong handler fired for method=%s path=%s", tc.whenMethod, tc.whenURL)
+			}
+		})
+	}
+}
+
 func BenchmarkRouterStaticRoutes(b *testing.B) {
 	benchmarkRouterRoutes(b, staticRoutes, staticRoutes)
 }