zttp/middleware_test.go at master · muhammadzkralla/zttp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package zttp

import (
	"strings"
	"testing"
)

// Test middleware
func TestMiddleware(t *testing.T) {
	app := NewApp()

	// Global middleware
	app.Use(func(req *Req, res *Res, next func()) {
		res.Send("GlobalMiddleware\n")
		next()
	})

	// Path-specific middleware
	app.Use("/api", func(req *Req, res *Res, next func()) {
		res.Send("ApiMiddleware\n")
		next()
	})

	// /test should only trigger global middleware
	app.Get("/test", func(req *Req, res *Res) {
		res.Send("Handler: /test")
	})

	// /api should trigger both global and /api middleware
	app.Get("/api", func(req *Req, res *Res) {
		res.Send("Handler: /api")
	})

	tests := []struct {
		name             string
		path             string
		shouldContain    []string
		shouldNotContain []string
	}{
		{
			name:             "global middleware only",
			path:             "/test",
			shouldContain:    []string{"GlobalMiddleware", "Handler: /test"},
			shouldNotContain: []string{"ApiMiddleware"},
		},
		{
			name:             "both global and path-specific middleware",
			path:             "/api",
			shouldContain:    []string{"GlobalMiddleware", "ApiMiddleware", "Handler: /api"},
			shouldNotContain: []string{},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			response := mockRequest(app, "GET", tt.path, "")

			for _, expected := range tt.shouldContain {
				if !strings.Contains(response, expected) {
					t.Errorf("Expected response to contain '%s' for path '%s', got: %s",
						expected, tt.path, response)
				}
			}

			for _, unexpected := range tt.shouldNotContain {
				if strings.Contains(response, unexpected) {
					t.Errorf("Expected response NOT to contain '%s' for path '%s', got: %s",
						unexpected, tt.path, response)
				}
			}
		})
	}
}

// Test app (global) middlewares matching vs router (local) middlewares matching
func TestRouterMiddlewares(t *testing.T) {
	app := NewApp()

	// Global middleware
	app.Use(func(req *Req, res *Res, next func()) {
		res.Header("GlobalMiddleware", "true")
		next()
	})

	router := app.NewRouter("/api/v1")

	// Router middleware
	router.Use(func(req *Req, res *Res, next func()) {
		res.Header("RouterMiddleware", "true")
		next()
	})

	router.Get("/test", func(req *Req, res *Res) {
		res.Status(200).Send("")
	})

	app.Get("/test", func(req *Req, res *Res) {
		res.Status(200).Send("")
	})

	tests := []struct {
		name             string
		path             string
		shouldContain    []string
		shouldNotContain []string
	}{
		{
			name:             "router with both middlewares",
			path:             "/api/v1/test",
			shouldContain:    []string{"GlobalMiddleware", "RouterMiddleware"},
			shouldNotContain: []string{},
		},
		{
			name:             "app route with only global middleware",
			path:             "/test",
			shouldContain:    []string{"GlobalMiddleware"},
			shouldNotContain: []string{"RouterMiddleware"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			response := mockRequest(app, "GET", tt.path, "")

			for _, expected := range tt.shouldContain {
				if !strings.Contains(response, expected) {
					t.Errorf("Expected response to contain '%s' for path '%s', got: %s",
						expected, tt.path, response)
				}
			}

			for _, unexpected := range tt.shouldNotContain {
				if strings.Contains(response, unexpected) {
					t.Errorf("Expected response NOT to contain '%s' for path '%s', got: %s",
						unexpected, tt.path, response)
				}
			}
		})
	}
}