fix: RouteNotFound handler fallback to root handler for groups with middleware

When a group has middleware, the RouteNotFound handler registered at the
root level is now properly used as a fallback. Previously, groups with
middleware would always use the default NotFoundHandler instead of
falling back to the root's custom RouteNotFound handler.

This fix:
- Adds a routeNotFoundHandler field to Echo to store the root handler
- Modifies group.Use() to use a fallback handler that checks for the
  root's RouteNotFound handler at request time
- Updates tests to reflect the new expected behavior

Fixes #2485

Signed-off-by: majiayu000 <[email protected]>

Author: majiayu000

echo.go

@@ -105,6 +105,10 @@ type Echo struct {
 	Debug             bool
 	HideBanner        bool
 	HidePort          bool
+
+	// routeNotFoundHandler is the handler registered via RouteNotFound for "/*" path.
+	// It is used as a fallback for groups with middleware that don't have their own RouteNotFound handler.
+	routeNotFoundHandler HandlerFunc
 }
 
 // Route contains a handler and information for matching against requests.
@@ -542,6 +546,10 @@ func (e *Echo) TRACE(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
 //
 // Example: `e.RouteNotFound("/*", func(c echo.Context) error { return c.NoContent(http.StatusNotFound) })`
 func (e *Echo) RouteNotFound(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
+	// Store the handler for "/*" path so it can be used as fallback for groups with middleware
+	if path == "/*" || path == "*" {
+		e.routeNotFoundHandler = h
+	}
 	return e.Add(RouteNotFound, path, h, m...)
 }
 

group.go

@@ -28,8 +28,17 @@ func (g *Group) Use(middleware ...MiddlewareFunc) {
 	// are only executed if they are added to the Router with route.
 	// So we register catch all route (404 is a safe way to emulate route match) for this group and now during routing the
 	// Router would find route to match our request path and therefore guarantee the middleware(s) will get executed.
-	g.RouteNotFound("", NotFoundHandler)
-	g.RouteNotFound("/*", NotFoundHandler)
+	//
+	// We use a fallback handler that checks for a root-level RouteNotFound handler at request time.
+	// This allows the root's custom 404 handler to be used as fallback for groups.
+	fallbackNotFoundHandler := func(c Context) error {
+		if g.echo.routeNotFoundHandler != nil {
+			return g.echo.routeNotFoundHandler(c)
+		}
+		return NotFoundHandler(c)
+	}
+	g.RouteNotFound("", fallbackNotFoundHandler)
+	g.RouteNotFound("/*", fallbackNotFoundHandler)
 }
 
 // CONNECT implements `Echo#CONNECT()` for sub-routes within the Group.

group_test.go

@@ -204,17 +204,17 @@ func TestGroup_RouteNotFoundWithMiddleware(t *testing.T) {
 			expectCode:     http.StatusNotFound,
 		},
 		{
-			name:           "ok, default group 404 handler is called with middleware",
+			name:           "ok, root 404 handler is used as fallback with middleware",
 			givenCustom404: false,
 			whenURL:        "/group/test3",
-			expectBody:     "{\"message\":\"Not Found\"}\n",
+			expectBody:     "GET /group/*",
 			expectCode:     http.StatusNotFound,
 		},
 		{
-			name:           "ok, (no slash) default group 404 handler is called with middleware",
+			name:           "ok, (no slash) root 404 handler is used as fallback with middleware",
 			givenCustom404: false,
 			whenURL:        "/group",
-			expectBody:     "{\"message\":\"Not Found\"}\n",
+			expectBody:     "GET /group",
 			expectCode:     http.StatusNotFound,
 		},
 	}
@@ -257,3 +257,25 @@ func TestGroup_RouteNotFoundWithMiddleware(t *testing.T) {
 		})
 	}
 }
+
+func TestGroup_RouteNotFoundWithMiddleware_NoRootHandler(t *testing.T) {
+	e := New()
+
+	middlewareCalled := false
+	g := e.Group("/group")
+	g.Use(func(next HandlerFunc) HandlerFunc {
+		return func(c Context) error {
+			middlewareCalled = true
+			return next(c)
+		}
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/group/unknown", nil)
+	rec := httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	assert.True(t, middlewareCalled)
+	assert.Equal(t, http.StatusNotFound, rec.Code)
+	assert.Equal(t, "{\"message\":\"Not Found\"}\n", rec.Body.String())
+}