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
|
package denco_test
import (
"context"
"fmt"
"io"
"net/http"
"net/http/httptest"
"testing"
"github.com/go-openapi/runtime/middleware/denco"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func testHandlerFunc(w http.ResponseWriter, r *http.Request, params denco.Params) {
fmt.Fprintf(w, "method: %s, path: %s, params: %v", r.Method, r.URL.Path, params)
}
func TestMux(t *testing.T) {
mux := denco.NewMux()
handler, err := mux.Build([]denco.Handler{
mux.GET("/", testHandlerFunc),
mux.GET("/user/:name", testHandlerFunc),
mux.POST("/user/:name", testHandlerFunc),
mux.HEAD("/user/:name", testHandlerFunc),
mux.PUT("/user/:name", testHandlerFunc),
mux.Handler(http.MethodGet, "/user/handler", testHandlerFunc),
mux.Handler(http.MethodPost, "/user/handler", testHandlerFunc),
mux.Handler(http.MethodPut, "/user/inference", testHandlerFunc),
})
require.NoError(t, err)
server := httptest.NewServer(handler)
defer server.Close()
for _, v := range []struct {
status int
method, path, expected string
}{
{http.StatusOK, http.MethodGet, "/", "method: GET, path: /, params: []"},
{http.StatusOK, http.MethodGet, "/user/alice", "method: GET, path: /user/alice, params: [{name alice}]"},
{http.StatusOK, http.MethodPost, "/user/bob", "method: POST, path: /user/bob, params: [{name bob}]"},
{http.StatusOK, http.MethodHead, "/user/alice", ""},
{http.StatusOK, http.MethodPut, "/user/bob", "method: PUT, path: /user/bob, params: [{name bob}]"},
{http.StatusNotFound, http.MethodPost, "/", "404 page not found\n"},
{http.StatusNotFound, http.MethodGet, "/unknown", "404 page not found\n"},
{http.StatusNotFound, http.MethodPost, "/user/alice/1", "404 page not found\n"},
{http.StatusOK, http.MethodGet, "/user/handler", "method: GET, path: /user/handler, params: []"},
{http.StatusOK, http.MethodPost, "/user/handler", "method: POST, path: /user/handler, params: []"},
{http.StatusOK, http.MethodPut, "/user/inference", "method: PUT, path: /user/inference, params: []"},
} {
req, err := http.NewRequestWithContext(context.Background(), v.method, server.URL+v.path, nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
require.NoError(t, err)
actual := string(body)
expected := v.expected
assert.Equalf(t, v.status, res.StatusCode, "for method %s in path %s", v.method, v.path)
assert.Equalf(t, expected, actual, "for method %s in path %s", v.method, v.path)
}
}
func TestNotFound(t *testing.T) {
mux := denco.NewMux()
handler, err := mux.Build([]denco.Handler{})
require.NoError(t, err)
server := httptest.NewServer(handler)
defer server.Close()
origNotFound := denco.NotFound
defer func() {
denco.NotFound = origNotFound
}()
denco.NotFound = func(w http.ResponseWriter, r *http.Request, params denco.Params) {
w.WriteHeader(http.StatusServiceUnavailable)
fmt.Fprintf(w, "method: %s, path: %s, params: %v", r.Method, r.URL.Path, params)
}
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, server.URL, nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
require.NoError(t, err)
actual := string(body)
expected := "method: GET, path: /, params: []"
assert.Equal(t, http.StatusServiceUnavailable, res.StatusCode)
assert.Equal(t, expected, actual)
}
|
