forked from gojek/fiber
-
Notifications
You must be signed in to change notification settings - Fork 0
/
dispatcher_test.go
118 lines (96 loc) · 2.82 KB
/
dispatcher_test.go
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
package http_test
import (
"bytes"
"errors"
"io/ioutil"
"net/http"
"testing"
"github.com/gojek/fiber"
fiberHTTP "github.com/gojek/fiber/http"
testUtilsHttp "github.com/gojek/fiber/internal/testutils/http"
"github.com/gojek/fiber/protocol"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
)
type unsupportedRequest struct {
*fiber.CachedPayload
}
func (r *unsupportedRequest) Protocol() protocol.Protocol {
return protocol.HTTP
}
func (r *unsupportedRequest) Clone() (fiber.Request, error) {
panic("not implemented")
}
func (r *unsupportedRequest) OperationName() string {
panic("not implemented")
}
func (r *unsupportedRequest) Transform(_ fiber.Backend) (fiber.Request, error) {
panic("not implemented")
}
func (r *unsupportedRequest) Header() map[string][]string {
panic("not implemented")
}
type MockHTTPClient struct {
mock.Mock
}
func (h *MockHTTPClient) Do(req *http.Request) (*http.Response, error) {
args := h.Called(req)
return args.Get(0).(*http.Response), args.Error(1)
}
type dispatcherTestCase struct {
name string
request fiber.Request
response *http.Response
error error
expected fiber.Response
}
func (tt dispatcherTestCase) mockClient() *MockHTTPClient {
mockClient := new(MockHTTPClient)
if httpReq, ok := tt.request.(*fiberHTTP.Request); ok {
mockClient.On("Do", httpReq.Request).Once().Return(tt.response, tt.error)
}
return mockClient
}
func TestNewDispatcher(t *testing.T) {
mockClient := new(MockHTTPClient)
dispatcher, err := fiberHTTP.NewDispatcher(mockClient)
assert.NoError(t, err)
assert.NotNil(t, dispatcher, "dispatcher should not be null")
dispatcher, err = fiberHTTP.NewDispatcher(nil)
assert.Errorf(t, err, "client can not be nil")
assert.Nil(t, dispatcher)
}
func TestDispatcher_Do(t *testing.T) {
suite := []dispatcherTestCase{
{
name: "valid response",
request: testUtilsHttp.MockReq("POST", "localhost:8080/dispatcher", ""),
response: &http.Response{
StatusCode: 200,
Body: ioutil.NopCloser(bytes.NewReader([]byte("OK response"))),
},
expected: testUtilsHttp.MockResp(200, "OK response", nil, nil),
},
{
name: "invalid response",
request: testUtilsHttp.MockReq("POST", "localhost:8080/dispatcher", ""),
error: errors.New("http: nil Request.URL"),
expected: fiber.NewErrorResponse(errors.New("http: nil Request.URL")),
},
{
name: "unsupported request",
request: &unsupportedRequest{},
expected: fiber.NewErrorResponse(
errors.New("fiber: http.Dispatcher supports only http.Request type of requests")),
},
}
for _, tt := range suite {
t.Run(tt.name, func(t *testing.T) {
mockClient := tt.mockClient()
dispatcher, _ := fiberHTTP.NewDispatcher(mockClient)
resp := dispatcher.Do(tt.request)
assert.Equal(t, tt.expected, resp)
mockClient.AssertExpectations(t)
})
}
}