1 package utils
2
3 import (
4 "bytes"
5 "encoding/json"
6 "io"
7 "net/http"
8 "strings"
9 "testing"
10
11 "github.com/stretchr/testify/assert"
12
13 "edge-infra.dev/pkg/edge/api/graph/model"
14 )
15
16 const login = "/login"
17
18 func TestNewMockHTTPTestServer(t *testing.T) {
19 mockServer := NewMockHTTPTestServer()
20 assert.NotNil(t, mockServer)
21 }
22
23 func TestAddTestServer(t *testing.T) {
24 mockServer := NewMockHTTPTestServer()
25 assert.NotNil(t, mockServer)
26 defer mockServer.Close()
27 assert.NotNil(t, mockServer.Server)
28 }
29
30 func TestNotAllowedContentType(t *testing.T) {
31 mockServer := NewMockHTTPTestServer()
32 assert.NotNil(t, mockServer)
33 defer mockServer.Close()
34 assert.NotNil(t, mockServer.Server)
35 route := &Route{
36 Name: "Login",
37 Method: http.MethodPost,
38 Path: login,
39 Callback: func(w http.ResponseWriter, _ *http.Request) {
40 w.WriteHeader(http.StatusOK)
41 _, _ = w.Write([]byte("login route"))
42 },
43 }
44 mockServer.AddAllowedContentType("application/xml")
45 mockServer.AddRoute(route)
46 assert.Equal(t, len(mockServer.Routes), 1)
47 resp, err := http.Post(mockServer.Server.URL+login, "application/json", nil)
48 assert.NoError(t, err)
49 assert.Equal(t, resp.StatusCode, http.StatusBadRequest)
50 defer resp.Body.Close()
51 _, err = io.ReadAll(resp.Body)
52 assert.NoError(t, err)
53 }
54
55 func TestAddRoute(t *testing.T) {
56 mockServer := NewMockHTTPTestServer()
57 assert.NotNil(t, mockServer)
58 defer mockServer.Close()
59 assert.NotNil(t, mockServer.Server)
60 route := &Route{
61 Name: "Login",
62 Method: http.MethodPost,
63 Path: login,
64 Callback: func(w http.ResponseWriter, _ *http.Request) {
65 w.WriteHeader(http.StatusOK)
66 _, _ = w.Write([]byte("login route"))
67 },
68 }
69 mockServer.AddAllowedContentType("application/json")
70 mockServer.AddRoute(route)
71 assert.Equal(t, len(mockServer.Routes), 1)
72 resp, err := http.Post(mockServer.Server.URL+login, "application/json", nil)
73 assert.NoError(t, err)
74 defer resp.Body.Close()
75 body, err := io.ReadAll(resp.Body)
76 assert.NoError(t, err)
77 assert.Equal(t, string(body), "login route")
78 }
79
80 func TestPost(t *testing.T) {
81 mockServer := NewMockHTTPTestServer()
82 assert.NotNil(t, mockServer)
83 defer mockServer.Close()
84 assert.NotNil(t, mockServer.Server)
85 mockServer.AddAllowedContentType("application/json")
86 mockServer.AddNotFound(NotFound)
87 mockServer.Post("Login", login, func(w http.ResponseWriter, _ *http.Request) {
88 w.WriteHeader(http.StatusOK)
89 _, _ = w.Write([]byte("login route"))
90 }, nil)
91 assert.Equal(t, len(mockServer.Routes), 1)
92 resp, err := http.Post(mockServer.Server.URL+login, "application/json", nil)
93 assert.NoError(t, err)
94 defer resp.Body.Close()
95 body, err := io.ReadAll(resp.Body)
96 assert.NoError(t, err)
97 assert.Equal(t, string(body), "login route")
98 }
99
100 func TestGet(t *testing.T) {
101 mockServer := NewMockHTTPTestServer()
102 assert.NotNil(t, mockServer)
103 defer mockServer.Close()
104 assert.NotNil(t, mockServer.Server)
105 mockServer.AddAllowedContentType("application/json")
106 mockServer.AddNotFound(NotFound)
107 mockServer.Get("Get User", "/user", func(w http.ResponseWriter, _ *http.Request) {
108 user := &model.User{
109 Username: "Test",
110 FamilyName: "John",
111 GivenName: "Doe",
112 }
113 data, err := json.Marshal(user)
114 if err != nil {
115 w.WriteHeader(http.StatusBadRequest)
116 _, _ = w.Write([]byte(nil))
117 return
118 }
119 w.WriteHeader(http.StatusOK)
120 _, err = w.Write(data)
121 assert.NoError(t, err)
122 }, nil)
123 assert.Equal(t, len(mockServer.Routes), 1)
124 client := &http.Client{}
125 req, err := http.NewRequest(http.MethodGet, mockServer.Server.URL+"/user", nil)
126 req.Header.Add("Content-Type", "application/json")
127 assert.NoError(t, err)
128 resp, err := client.Do(req)
129 assert.NoError(t, err)
130 defer resp.Body.Close()
131 assert.NoError(t, err)
132 body, err := io.ReadAll(resp.Body)
133 assert.NoError(t, err)
134 userResp := &model.User{}
135 err = json.Unmarshal(body, userResp)
136 assert.NoError(t, err)
137 assert.Equal(t, userResp.Username, "Test")
138 assert.Equal(t, userResp.GivenName, "Doe")
139 assert.Equal(t, userResp.FamilyName, "John")
140 }
141
142 func TestPut(t *testing.T) {
143 mockServer := NewMockHTTPTestServer()
144 assert.NotNil(t, mockServer)
145 defer mockServer.Close()
146 assert.NotNil(t, mockServer.Server)
147 mockServer.AddAllowedContentType("application/json")
148 mockServer.AddNotFound(NotFound)
149 actualUser := &model.User{
150 Username: "Test",
151 FamilyName: "John",
152 GivenName: "Doe",
153 }
154 mockServer.Put("Get User", "/update-user", func(w http.ResponseWriter, r *http.Request) {
155 defer r.Body.Close()
156 requestBody, err := io.ReadAll(r.Body)
157 assert.NoError(t, err)
158 requestUser := &model.User{}
159 err = json.Unmarshal(requestBody, requestUser)
160 assert.NoError(t, err)
161 actualUser.Username = requestUser.Username
162 actualUser.FamilyName = ""
163 actualUser.GivenName = ""
164 data, err := json.Marshal(actualUser)
165 if err != nil {
166 w.WriteHeader(http.StatusBadRequest)
167 _, _ = w.Write([]byte(nil))
168 return
169 }
170 w.WriteHeader(http.StatusOK)
171 _, err = w.Write(data)
172 assert.NoError(t, err)
173 }, nil)
174 assert.Equal(t, len(mockServer.Routes), 1)
175 requestBuffer := &bytes.Buffer{}
176 requestUser := &model.User{
177 Username: "Test 1",
178 }
179 err := json.NewEncoder(requestBuffer).Encode(requestUser)
180 assert.NoError(t, err)
181 client := &http.Client{}
182 req, err := http.NewRequest(http.MethodPut, mockServer.Server.URL+"/update-user", requestBuffer)
183 req.Header.Add("Content-Type", "application/json")
184 assert.NoError(t, err)
185 resp, err := client.Do(req)
186 assert.NoError(t, err)
187 defer resp.Body.Close()
188 assert.NoError(t, err)
189 body, err := io.ReadAll(resp.Body)
190 assert.NoError(t, err)
191 userResp := &model.User{}
192 err = json.Unmarshal(body, userResp)
193 assert.NoError(t, err)
194 assert.Equal(t, userResp.Username, "Test 1")
195 assert.Equal(t, userResp.GivenName, "")
196 assert.Equal(t, userResp.FamilyName, "")
197 }
198
199 func TestPatch(t *testing.T) {
200 mockServer := NewMockHTTPTestServer()
201 assert.NotNil(t, mockServer)
202 defer mockServer.Close()
203 assert.NotNil(t, mockServer.Server)
204 mockServer.AddAllowedContentType("application/json")
205 mockServer.AddNotFound(NotFound)
206 actualUser := &model.User{
207 Username: "Test",
208 FamilyName: "John",
209 GivenName: "Doe",
210 }
211 mockServer.Patch("Get User", "/update-user", func(w http.ResponseWriter, r *http.Request) {
212 defer r.Body.Close()
213 requestBody, err := io.ReadAll(r.Body)
214 assert.NoError(t, err)
215 requestUser := &model.User{}
216 err = json.Unmarshal(requestBody, requestUser)
217 assert.NoError(t, err)
218 actualUser.Username = requestUser.Username
219 data, err := json.Marshal(actualUser)
220 if err != nil {
221 w.WriteHeader(http.StatusBadRequest)
222 _, _ = w.Write([]byte(nil))
223 return
224 }
225 w.WriteHeader(http.StatusOK)
226 _, err = w.Write(data)
227 assert.NoError(t, err)
228 }, nil)
229 assert.Equal(t, len(mockServer.Routes), 1)
230 requestBuffer := &bytes.Buffer{}
231 requestUser := &model.User{
232 Username: "Test 1",
233 }
234 err := json.NewEncoder(requestBuffer).Encode(requestUser)
235 assert.NoError(t, err)
236 client := &http.Client{}
237 req, err := http.NewRequest(http.MethodPatch, mockServer.Server.URL+"/update-user", requestBuffer)
238 req.Header.Add("Content-Type", "application/json")
239 assert.NoError(t, err)
240 resp, err := client.Do(req)
241 assert.NoError(t, err)
242 defer resp.Body.Close()
243 assert.NoError(t, err)
244 body, err := io.ReadAll(resp.Body)
245 assert.NoError(t, err)
246 userResp := &model.User{}
247 err = json.Unmarshal(body, userResp)
248 assert.NoError(t, err)
249 assert.Equal(t, userResp.Username, "Test 1")
250 assert.Equal(t, userResp.GivenName, actualUser.GivenName)
251 assert.Equal(t, userResp.FamilyName, actualUser.FamilyName)
252 }
253
254 func TestAny(t *testing.T) {
255 mockServer := NewMockHTTPTestServer()
256 assert.NotNil(t, mockServer)
257 defer mockServer.Close()
258 assert.NotNil(t, mockServer.Server)
259 mockServer.AddAllowedContentType("application/json")
260 mockServer.AddNotFound(NotFound)
261 mockServer.Any("Get User Profile", func(w http.ResponseWriter, _ *http.Request) {
262 w.WriteHeader(http.StatusOK)
263 _, _ = w.Write([]byte("login route"))
264 }, func(_ http.ResponseWriter, r *http.Request) bool {
265 return strings.HasPrefix(r.URL.String(), "/user/profile/")
266 })
267 assert.Equal(t, len(mockServer.Routes), 1)
268 assert.Equal(t, len(mockServer.Routes), 1)
269 client := &http.Client{}
270 req, err := http.NewRequest(http.MethodGet, mockServer.Server.URL+"/user/profile/2355", nil)
271 req.Header.Add("Content-Type", "application/json")
272 assert.NoError(t, err)
273 resp, err := client.Do(req)
274 assert.NoError(t, err)
275 defer resp.Body.Close()
276 assert.NoError(t, err)
277 body, err := io.ReadAll(resp.Body)
278 assert.NoError(t, err)
279 assert.Equal(t, string(body), "login route")
280 }
281
282 func TestReadFormData(t *testing.T) {
283 resp := make(map[string]string, 0)
284 err := readFormData([]byte("token=test-okta-access-token&token_type_hint=access_token"), resp)
285 assert.NoError(t, err)
286 assert.Equal(t, resp["token"], "test-okta-access-token")
287 assert.Equal(t, resp["token_type_hint"], "access_token")
288 }
289
View as plain text