1
2
3
4 package tester
5
6 import (
7 "net/http"
8 "net/http/httptest"
9 "strings"
10 "testing"
11
12 "github.com/gin-contrib/sessions"
13 "github.com/gin-gonic/gin"
14 )
15
16 type storeFactory func(*testing.T) sessions.Store
17
18 const sessionName = "mysession"
19
20 const ok = "ok"
21
22 func init() {
23 gin.SetMode(gin.TestMode)
24 }
25
26 func GetSet(t *testing.T, newStore storeFactory) {
27 r := gin.Default()
28 r.Use(sessions.Sessions(sessionName, newStore(t)))
29
30 r.GET("/set", func(c *gin.Context) {
31 session := sessions.Default(c)
32 session.Set("key", ok)
33 _ = session.Save()
34 c.String(http.StatusOK, ok)
35 })
36
37 r.GET("/get", func(c *gin.Context) {
38 session := sessions.Default(c)
39 if session.Get("key") != ok {
40 t.Error("Session writing failed")
41 }
42 _ = session.Save()
43 c.String(http.StatusOK, ok)
44 })
45
46 res1 := httptest.NewRecorder()
47 req1, _ := http.NewRequest("GET", "/set", nil)
48 r.ServeHTTP(res1, req1)
49
50 res2 := httptest.NewRecorder()
51 req2, _ := http.NewRequest("GET", "/get", nil)
52 copyCookies(req2, res1)
53 r.ServeHTTP(res2, req2)
54 }
55
56 func DeleteKey(t *testing.T, newStore storeFactory) {
57 r := gin.Default()
58 r.Use(sessions.Sessions(sessionName, newStore(t)))
59
60 r.GET("/set", func(c *gin.Context) {
61 session := sessions.Default(c)
62 session.Set("key", ok)
63 _ = session.Save()
64 c.String(http.StatusOK, ok)
65 })
66
67 r.GET("/delete", func(c *gin.Context) {
68 session := sessions.Default(c)
69 session.Delete("key")
70 _ = session.Save()
71 c.String(http.StatusOK, ok)
72 })
73
74 r.GET("/get", func(c *gin.Context) {
75 session := sessions.Default(c)
76 if session.Get("key") != nil {
77 t.Error("Session deleting failed")
78 }
79 _ = session.Save()
80 c.String(http.StatusOK, ok)
81 })
82
83 res1 := httptest.NewRecorder()
84 req1, _ := http.NewRequest("GET", "/set", nil)
85 r.ServeHTTP(res1, req1)
86
87 res2 := httptest.NewRecorder()
88 req2, _ := http.NewRequest("GET", "/delete", nil)
89 copyCookies(req2, res1)
90 r.ServeHTTP(res2, req2)
91
92 res3 := httptest.NewRecorder()
93 req3, _ := http.NewRequest("GET", "/get", nil)
94 copyCookies(req3, res2)
95 r.ServeHTTP(res3, req3)
96 }
97
98 func Flashes(t *testing.T, newStore storeFactory) {
99 r := gin.Default()
100 store := newStore(t)
101 r.Use(sessions.Sessions(sessionName, store))
102
103 r.GET("/set", func(c *gin.Context) {
104 session := sessions.Default(c)
105 session.AddFlash(ok)
106 _ = session.Save()
107 c.String(http.StatusOK, ok)
108 })
109
110 r.GET("/flash", func(c *gin.Context) {
111 session := sessions.Default(c)
112 l := len(session.Flashes())
113 if l != 1 {
114 t.Error("Flashes count does not equal 1. Equals ", l)
115 }
116 _ = session.Save()
117 c.String(http.StatusOK, ok)
118 })
119
120 r.GET("/check", func(c *gin.Context) {
121 session := sessions.Default(c)
122 l := len(session.Flashes())
123 if l != 0 {
124 t.Error("flashes count is not 0 after reading. Equals ", l)
125 }
126 _ = session.Save()
127 c.String(http.StatusOK, ok)
128 })
129
130 res1 := httptest.NewRecorder()
131 req1, _ := http.NewRequest("GET", "/set", nil)
132 r.ServeHTTP(res1, req1)
133
134 res2 := httptest.NewRecorder()
135 req2, _ := http.NewRequest("GET", "/flash", nil)
136 copyCookies(req2, res1)
137 r.ServeHTTP(res2, req2)
138
139 res3 := httptest.NewRecorder()
140 req3, _ := http.NewRequest("GET", "/check", nil)
141 copyCookies(req3, res2)
142 r.ServeHTTP(res3, req3)
143 }
144
145 func Clear(t *testing.T, newStore storeFactory) {
146 data := map[string]string{
147 "key": "val",
148 "foo": "bar",
149 }
150 r := gin.Default()
151 store := newStore(t)
152 r.Use(sessions.Sessions(sessionName, store))
153
154 r.GET("/set", func(c *gin.Context) {
155 session := sessions.Default(c)
156 for k, v := range data {
157 session.Set(k, v)
158 }
159 session.Clear()
160 _ = session.Save()
161 c.String(http.StatusOK, ok)
162 })
163
164 r.GET("/check", func(c *gin.Context) {
165 session := sessions.Default(c)
166 for k, v := range data {
167 if session.Get(k) == v {
168 t.Fatal("Session clear failed")
169 }
170 }
171 _ = session.Save()
172 c.String(http.StatusOK, ok)
173 })
174
175 res1 := httptest.NewRecorder()
176 req1, _ := http.NewRequest("GET", "/set", nil)
177 r.ServeHTTP(res1, req1)
178
179 res2 := httptest.NewRecorder()
180 req2, _ := http.NewRequest("GET", "/check", nil)
181 copyCookies(req2, res1)
182 r.ServeHTTP(res2, req2)
183 }
184
185 func Options(t *testing.T, newStore storeFactory) {
186 r := gin.Default()
187 store := newStore(t)
188 store.Options(sessions.Options{
189 Domain: "localhost",
190 })
191 r.Use(sessions.Sessions(sessionName, store))
192
193 r.GET("/domain", func(c *gin.Context) {
194 session := sessions.Default(c)
195 session.Set("key", ok)
196 session.Options(sessions.Options{
197 Path: "/foo/bar/bat",
198 })
199 _ = session.Save()
200 c.String(http.StatusOK, ok)
201 })
202 r.GET("/path", func(c *gin.Context) {
203 session := sessions.Default(c)
204 session.Set("key", ok)
205 _ = session.Save()
206 c.String(http.StatusOK, ok)
207 })
208 r.GET("/set", func(c *gin.Context) {
209 session := sessions.Default(c)
210 session.Set("key", ok)
211 _ = session.Save()
212 c.String(http.StatusOK, ok)
213 })
214 r.GET("/expire", func(c *gin.Context) {
215 session := sessions.Default(c)
216 session.Options(sessions.Options{
217 MaxAge: -1,
218 })
219 _ = session.Save()
220 c.String(http.StatusOK, ok)
221 })
222 r.GET("/check", func(c *gin.Context) {
223 session := sessions.Default(c)
224 val := session.Get("key")
225 if val != nil {
226 t.Fatal("Session expiration failed")
227 }
228 c.String(http.StatusOK, ok)
229 })
230
231 testOptionSameSitego(t, r)
232
233 res1 := httptest.NewRecorder()
234 req1, _ := http.NewRequest("GET", "/domain", nil)
235 r.ServeHTTP(res1, req1)
236
237 res2 := httptest.NewRecorder()
238 req2, _ := http.NewRequest("GET", "/path", nil)
239 r.ServeHTTP(res2, req2)
240
241 res3 := httptest.NewRecorder()
242 req3, _ := http.NewRequest("GET", "/set", nil)
243 r.ServeHTTP(res3, req3)
244
245 res4 := httptest.NewRecorder()
246 req4, _ := http.NewRequest("GET", "/expire", nil)
247 r.ServeHTTP(res4, req4)
248
249 res5 := httptest.NewRecorder()
250 req5, _ := http.NewRequest("GET", "/check", nil)
251 r.ServeHTTP(res5, req5)
252
253 for _, c := range res1.Header().Values("Set-Cookie") {
254 s := strings.Split(c, ";")
255 if s[1] != " Path=/foo/bar/bat" {
256 t.Error("Error writing path with options:", s[1])
257 }
258 }
259
260 for _, c := range res2.Header().Values("Set-Cookie") {
261 s := strings.Split(c, ";")
262 if s[1] != " Domain=localhost" {
263 t.Error("Error writing domain with options:", s[1])
264 }
265 }
266 }
267
268 func Many(t *testing.T, newStore storeFactory) {
269 r := gin.Default()
270 sessionNames := []string{"a", "b"}
271
272 r.Use(sessions.SessionsMany(sessionNames, newStore(t)))
273
274 r.GET("/set", func(c *gin.Context) {
275 sessionA := sessions.DefaultMany(c, "a")
276 sessionA.Set("hello", "world")
277 _ = sessionA.Save()
278
279 sessionB := sessions.DefaultMany(c, "b")
280 sessionB.Set("foo", "bar")
281 _ = sessionB.Save()
282 c.String(http.StatusOK, ok)
283 })
284
285 r.GET("/get", func(c *gin.Context) {
286 sessionA := sessions.DefaultMany(c, "a")
287 if sessionA.Get("hello") != "world" {
288 t.Error("Session writing failed")
289 }
290 _ = sessionA.Save()
291
292 sessionB := sessions.DefaultMany(c, "b")
293 if sessionB.Get("foo") != "bar" {
294 t.Error("Session writing failed")
295 }
296 _ = sessionB.Save()
297 c.String(http.StatusOK, ok)
298 })
299
300 res1 := httptest.NewRecorder()
301 req1, _ := http.NewRequest("GET", "/set", nil)
302 r.ServeHTTP(res1, req1)
303
304 res2 := httptest.NewRecorder()
305 req2, _ := http.NewRequest("GET", "/get", nil)
306 header := ""
307 for _, x := range res1.Header()["Set-Cookie"] {
308 header += strings.Split(x, ";")[0] + "; \n"
309 }
310 req2.Header.Set("Cookie", header)
311 r.ServeHTTP(res2, req2)
312 }
313
314 func copyCookies(req *http.Request, res *httptest.ResponseRecorder) {
315 req.Header.Set("Cookie", strings.Join(res.Header().Values("Set-Cookie"), "; "))
316 }
317
View as plain text