tests: refactor middleware test cases

bot_test.go

@@ -374,10 +374,17 @@ func TestBotOnError(t *testing.T) {
 }
 
 func TestBotMiddleware(t *testing.T) {
-	t.Run("call order", func(t *testing.T) {
+	t.Run("calling order", func(t *testing.T) {
 		var trace []string
 
-		mwTrace := func(name string) MiddlewareFunc {
+		handler := func(name string) HandlerFunc {
+			return func(c Context) error {
+				trace = append(trace, name)
+				return nil
+			}
+		}
+
+		middleware := func(name string) MiddlewareFunc {
 			return func(next HandlerFunc) HandlerFunc {
 				return func(c Context) error {
 					trace = append(trace, name+":in")
@@ -392,85 +399,85 @@ func TestBotMiddleware(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		b.Use(mwTrace("global-1"), mwTrace("global-2"))
 
-		b.Handle("/a", func(c Context) error {
+		b.Use(middleware("global1"), middleware("global2"))
-			trace = append(trace, "/a")
+		b.Handle("/a", handler("/a"), middleware("handler1a"), middleware("handler2a"))
-			return nil
-		}, mwTrace("handler-1-a"), mwTrace("handler-2-a"))
 
 		group := b.Group()
-		group.Use(mwTrace("group-1"), mwTrace("group-2"))
+		group.Use(middleware("group1"), middleware("group2"))
-
+		group.Handle("/b", handler("/b"), middleware("handler1b"))
-		group.Handle("/b", func(c Context) error {
-			trace = append(trace, "/b")
-			return nil
-		}, mwTrace("handler-1-b"))
-
-		b.ProcessUpdate(Update{Message: &Message{Text: "/a"}})
 
-		expectedOrder := []string{
+		b.ProcessUpdate(Update{
-			"global-1:in", "global-2:in",
+			Message: &Message{Text: "/a"},
-			"handler-1-a:in", "handler-2-a:in",
+		})
+		assert.Equal(t, []string{
+			"global1:in", "global2:in",
+			"handler1a:in", "handler2a:in",
 			"/a",
-			"handler-2-a:out", "handler-1-a:out",
+			"handler2a:out", "handler1a:out",
-			"global-2:out", "global-1:out",
+			"global2:out", "global1:out",
-		}
+		}, trace)
-		assert.Equal(t, expectedOrder, trace)
 
 		trace = trace[:0]
-		b.ProcessUpdate(Update{Message: &Message{Text: "/b"}})
 
-		expectedOrder = []string{
+		b.ProcessUpdate(Update{
-			"global-1:in", "global-2:in",
+			Message: &Message{Text: "/b"},
-			"group-1:in", "group-2:in",
+		})
-			"handler-1-b:in",
+		assert.Equal(t, []string{
+			"global1:in", "global2:in",
+			"group1:in", "group2:in",
+			"handler1b:in",
 			"/b",
-			"handler-1-b:out",
+			"handler1b:out",
-			"group-2:out", "group-1:out",
+			"group2:out", "group1:out",
-			"global-2:out", "global-1:out",
+			"global2:out", "global1:out",
-		}
+		}, trace)
-		assert.Equal(t, expectedOrder, trace)
 	})
 
-	fatalMiddleware := func(next HandlerFunc) HandlerFunc {
+	fatal := func(next HandlerFunc) HandlerFunc {
 		return func(c Context) error {
-			t.Fatal("fatalMiddleware should not be called")
+			t.Fatal("fatal middleware should not be called")
 			return nil
 		}
 	}
-	nopMiddleware := func(next HandlerFunc) HandlerFunc {
+
-		return func(c Context) error { return next(c) }
+	nop := func(next HandlerFunc) HandlerFunc {
+		return func(c Context) error {
+			return next(c)
+		}
 	}
 
-	t.Run("handler middleware is not clobbered when combined with global middleware", func(t *testing.T) {
+	t.Run("combining with global middleware", func(t *testing.T) {
 		b, err := NewBot(Settings{Synchronous: true, Offline: true})
 		if err != nil {
 			t.Fatal(err)
 		}
-		// Pre-allocate middleware slice to make sure it has extra capacity after group-level middleware is added.
+
+		// Pre-allocate middleware slice to make sure
+		// it has extra capacity after group-level middleware is added.
 		b.group.middleware = make([]MiddlewareFunc, 0, 2)
-		b.Use(nopMiddleware)
+		b.Use(nop)
 
-		b.Handle("/a", func(c Context) error { return nil }, nopMiddleware)
+		b.Handle("/a", func(c Context) error { return nil }, nop)
-		b.Handle("/b", func(c Context) error { return nil }, fatalMiddleware)
+		b.Handle("/b", func(c Context) error { return nil }, fatal)
 
 		b.ProcessUpdate(Update{Message: &Message{Text: "/a"}})
 	})
 
-	t.Run("handler middleware is not clobbered when combined with group middleware", func(t *testing.T) {
+	t.Run("combining with group middleware", func(t *testing.T) {
 		b, err := NewBot(Settings{Synchronous: true, Offline: true})
 		if err != nil {
 			t.Fatal(err)
 		}
 
 		g := b.Group()
-		// Pre-allocate middleware slice to make sure it has extra capacity after group-level middleware is added.
+		// Pre-allocate middleware slice to make sure
+		// it has extra capacity after group-level middleware is added.
 		g.middleware = make([]MiddlewareFunc, 0, 2)
-		g.Use(nopMiddleware)
+		g.Use(nop)
 
-		g.Handle("/a", func(c Context) error { return nil }, nopMiddleware)
+		g.Handle("/a", func(c Context) error { return nil }, nop)
-		g.Handle("/b", func(c Context) error { return nil }, fatalMiddleware)
+		g.Handle("/b", func(c Context) error { return nil }, fatal)
 
 		b.ProcessUpdate(Update{Message: &Message{Text: "/a"}})
 	})