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
|
package httperr_test
import (
"errors"
"net/http"
"net/http/httptest"
"testing"
"github.com/alecthomas/assert/v2"
"go.jolheiser.com/ugit/internal/http/httperr"
)
func successHandler(w http.ResponseWriter, r *http.Request) error {
w.WriteHeader(http.StatusOK)
return nil
}
func errorHandler(w http.ResponseWriter, r *http.Request) error {
return errors.New("test error")
}
func statusErrorHandler(status int) func(w http.ResponseWriter, r *http.Request) error {
return func(w http.ResponseWriter, r *http.Request) error {
return httperr.Status(errors.New("test error"), status)
}
}
func TestHandler_Success(t *testing.T) {
handler := httperr.Handler(successHandler)
req := httptest.NewRequest("GET", "/", nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req)
assert.Equal(t, http.StatusOK, recorder.Code)
}
func TestHandler_Error(t *testing.T) {
handler := httperr.Handler(errorHandler)
req := httptest.NewRequest("GET", "/", nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req)
assert.Equal(t, http.StatusInternalServerError, recorder.Code)
}
func TestHandler_StatusError(t *testing.T) {
testCases := []struct {
name string
status int
expectedStatus int
}{
{
name: "not found",
status: http.StatusNotFound,
expectedStatus: http.StatusNotFound,
},
{
name: "bad request",
status: http.StatusBadRequest,
expectedStatus: http.StatusBadRequest,
},
{
name: "unauthorized",
status: http.StatusUnauthorized,
expectedStatus: http.StatusUnauthorized,
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
handler := httperr.Handler(statusErrorHandler(tc.status))
req := httptest.NewRequest("GET", "/", nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req)
assert.Equal(t, tc.expectedStatus, recorder.Code)
})
}
}
type unwrapper interface {
Unwrap() error
}
func TestError(t *testing.T) {
originalErr := errors.New("original error")
httpErr := httperr.Error(originalErr)
assert.Equal(t, originalErr.Error(), httpErr.Error())
unwrapper, ok := any(httpErr).(unwrapper)
assert.True(t, ok)
assert.Equal(t, originalErr, unwrapper.Unwrap())
}
func TestStatus(t *testing.T) {
originalErr := errors.New("original error")
httpErr := httperr.Status(originalErr, http.StatusNotFound)
assert.Equal(t, originalErr.Error(), httpErr.Error())
unwrapper, ok := any(httpErr).(unwrapper)
assert.True(t, ok)
assert.Equal(t, originalErr, unwrapper.Unwrap())
handler := httperr.Handler(func(w http.ResponseWriter, r *http.Request) error {
return httpErr
})
req := httptest.NewRequest("GET", "/", nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req)
assert.Equal(t, http.StatusNotFound, recorder.Code)
}
|