pager_test.gno
8.40 Kb · 281 lines
1package pager
2
3import (
4 "testing"
5
6 "gno.land/p/demo/avl"
7 "gno.land/p/demo/uassert"
8 "gno.land/p/demo/ufmt"
9 "gno.land/p/demo/urequire"
10)
11
12func TestPager_GetPage(t *testing.T) {
13 // Create a new AVL tree and populate it with some key-value pairs.
14 tree := avl.NewTree()
15 tree.Set("a", 1)
16 tree.Set("b", 2)
17 tree.Set("c", 3)
18 tree.Set("d", 4)
19 tree.Set("e", 5)
20
21 t.Run("normal ordering", func(t *testing.T) {
22 // Create a new pager.
23 pager := NewPager(tree, 10, false)
24
25 // Define test cases.
26 tests := []struct {
27 pageNumber int
28 pageSize int
29 expected []Item
30 }{
31 {1, 2, []Item{{Key: "a", Value: 1}, {Key: "b", Value: 2}}},
32 {2, 2, []Item{{Key: "c", Value: 3}, {Key: "d", Value: 4}}},
33 {3, 2, []Item{{Key: "e", Value: 5}}},
34 {1, 3, []Item{{Key: "a", Value: 1}, {Key: "b", Value: 2}, {Key: "c", Value: 3}}},
35 {2, 3, []Item{{Key: "d", Value: 4}, {Key: "e", Value: 5}}},
36 {1, 5, []Item{{Key: "a", Value: 1}, {Key: "b", Value: 2}, {Key: "c", Value: 3}, {Key: "d", Value: 4}, {Key: "e", Value: 5}}},
37 {2, 5, []Item{}},
38 }
39
40 for _, tt := range tests {
41 page := pager.GetPageWithSize(tt.pageNumber, tt.pageSize)
42
43 uassert.Equal(t, len(tt.expected), len(page.Items))
44
45 for i, item := range page.Items {
46 uassert.Equal(t, tt.expected[i].Key, item.Key)
47 uassert.Equal(t, tt.expected[i].Value, item.Value)
48 }
49 }
50 })
51
52 t.Run("reversed ordering", func(t *testing.T) {
53 // Create a new pager.
54 pager := NewPager(tree, 10, true)
55
56 // Define test cases.
57 tests := []struct {
58 pageNumber int
59 pageSize int
60 expected []Item
61 }{
62 {1, 2, []Item{{Key: "e", Value: 5}, {Key: "d", Value: 4}}},
63 {2, 2, []Item{{Key: "c", Value: 3}, {Key: "b", Value: 2}}},
64 {3, 2, []Item{{Key: "a", Value: 1}}},
65 {1, 3, []Item{{Key: "e", Value: 5}, {Key: "d", Value: 4}, {Key: "c", Value: 3}}},
66 {2, 3, []Item{{Key: "b", Value: 2}, {Key: "a", Value: 1}}},
67 {1, 5, []Item{{Key: "e", Value: 5}, {Key: "d", Value: 4}, {Key: "c", Value: 3}, {Key: "b", Value: 2}, {Key: "a", Value: 1}}},
68 {2, 5, []Item{}},
69 }
70
71 for _, tt := range tests {
72 page := pager.GetPageWithSize(tt.pageNumber, tt.pageSize)
73
74 uassert.Equal(t, len(tt.expected), len(page.Items))
75
76 for i, item := range page.Items {
77 uassert.Equal(t, tt.expected[i].Key, item.Key)
78 uassert.Equal(t, tt.expected[i].Value, item.Value)
79 }
80 }
81 })
82}
83
84func TestPager_GetPageByPath(t *testing.T) {
85 // Create a new AVL tree and populate it with some key-value pairs.
86 tree := avl.NewTree()
87 for i := 0; i < 50; i++ {
88 tree.Set(ufmt.Sprintf("key%d", i), i)
89 }
90
91 // Create a new pager.
92 pager := NewPager(tree, 10, false)
93
94 // Define test cases.
95 tests := []struct {
96 rawURL string
97 expectedPage int
98 expectedSize int
99 }{
100 {"/r/foo:bar/baz?size=10&page=1", 1, 10},
101 {"/r/foo:bar/baz?size=10&page=2", 2, 10},
102 {"/r/foo:bar/baz?page=3", 3, pager.DefaultPageSize},
103 {"/r/foo:bar/baz?size=20", 1, 20},
104 {"/r/foo:bar/baz", 1, pager.DefaultPageSize},
105 }
106
107 for _, tt := range tests {
108 page, err := pager.GetPageByPath(tt.rawURL)
109 urequire.NoError(t, err, ufmt.Sprintf("GetPageByPath(%s) returned error: %v", tt.rawURL, err))
110
111 uassert.Equal(t, tt.expectedPage, page.PageNumber)
112 uassert.Equal(t, tt.expectedSize, page.PageSize)
113 }
114}
115
116func TestPage_Picker(t *testing.T) {
117 // Create a new AVL tree and populate it with some key-value pairs.
118 tree := avl.NewTree()
119 tree.Set("a", 1)
120 tree.Set("b", 2)
121 tree.Set("c", 3)
122 tree.Set("d", 4)
123 tree.Set("e", 5)
124
125 // Create a new pager.
126 pager := NewPager(tree, 10, false)
127
128 // Define test cases.
129 tests := []struct {
130 pageNumber int
131 pageSize int
132 path string
133 expected string
134 }{
135 {1, 2, "/test", "**1** | [2](?page=2) | [3](?page=3)"},
136 {2, 2, "/test", "[1](?page=1) | **2** | [3](?page=3)"},
137 {3, 2, "/test", "[1](?page=1) | [2](?page=2) | **3**"},
138 {1, 2, "/test?foo=bar", "**1** | [2](?page=2&foo=bar) | [3](?page=3&foo=bar)"},
139 }
140
141 for _, tt := range tests {
142 page := pager.GetPageWithSize(tt.pageNumber, tt.pageSize)
143
144 ui := page.Picker(tt.path)
145 uassert.Equal(t, tt.expected, ui)
146 }
147}
148
149func TestPager_UI_WithManyPages(t *testing.T) {
150 // Create a new AVL tree and populate it with many key-value pairs.
151 tree := avl.NewTree()
152 for i := 0; i < 100; i++ {
153 tree.Set(ufmt.Sprintf("key%d", i), i)
154 }
155
156 // Create a new pager.
157 pager := NewPager(tree, 10, false)
158
159 // Define test cases for a large number of pages.
160 tests := []struct {
161 pageNumber int
162 pageSize int
163 path string
164 expected string
165 }{
166 {1, 10, "/test", "**1** | [2](?page=2) | [3](?page=3) | … | [10](?page=10)"},
167 {2, 10, "/test", "[1](?page=1) | **2** | [3](?page=3) | [4](?page=4) | … | [10](?page=10)"},
168 {3, 10, "/test", "[1](?page=1) | [2](?page=2) | **3** | [4](?page=4) | [5](?page=5) | … | [10](?page=10)"},
169 {4, 10, "/test", "[1](?page=1) | [2](?page=2) | [3](?page=3) | **4** | [5](?page=5) | [6](?page=6) | … | [10](?page=10)"},
170 {5, 10, "/test", "[1](?page=1) | … | [3](?page=3) | [4](?page=4) | **5** | [6](?page=6) | [7](?page=7) | … | [10](?page=10)"},
171 {6, 10, "/test", "[1](?page=1) | … | [4](?page=4) | [5](?page=5) | **6** | [7](?page=7) | [8](?page=8) | … | [10](?page=10)"},
172 {7, 10, "/test", "[1](?page=1) | … | [5](?page=5) | [6](?page=6) | **7** | [8](?page=8) | [9](?page=9) | [10](?page=10)"},
173 {8, 10, "/test", "[1](?page=1) | … | [6](?page=6) | [7](?page=7) | **8** | [9](?page=9) | [10](?page=10)"},
174 {9, 10, "/test", "[1](?page=1) | … | [7](?page=7) | [8](?page=8) | **9** | [10](?page=10)"},
175 {10, 10, "/test", "[1](?page=1) | … | [8](?page=8) | [9](?page=9) | **10**"},
176 }
177
178 for _, tt := range tests {
179 page := pager.GetPageWithSize(tt.pageNumber, tt.pageSize)
180
181 ui := page.Picker(tt.path)
182 uassert.Equal(t, tt.expected, ui)
183 }
184}
185
186func TestPager_ParseQuery(t *testing.T) {
187 // Create a new AVL tree and populate it with some key-value pairs.
188 tree := avl.NewTree()
189 tree.Set("a", 1)
190 tree.Set("b", 2)
191 tree.Set("c", 3)
192 tree.Set("d", 4)
193 tree.Set("e", 5)
194
195 // Create a new pager.
196 pager := NewPager(tree, 10, false)
197
198 // Define test cases.
199 tests := []struct {
200 rawURL string
201 expectedPage int
202 expectedSize int
203 expectedError bool
204 }{
205 {"/r/foo:bar/baz?size=2&page=1", 1, 2, false},
206 {"/r/foo:bar/baz?size=3&page=2", 2, 3, false},
207 {"/r/foo:bar/baz?size=5&page=3", 3, 5, false},
208 {"/r/foo:bar/baz?page=2", 2, pager.DefaultPageSize, false},
209 {"/r/foo:bar/baz?size=3", 1, 3, false},
210 {"/r/foo:bar/baz", 1, pager.DefaultPageSize, false},
211 {"/r/foo:bar/baz?size=0&page=0", 1, pager.DefaultPageSize, false},
212 }
213
214 for _, tt := range tests {
215 page, size, err := pager.ParseQuery(tt.rawURL)
216 if tt.expectedError {
217 uassert.Error(t, err, ufmt.Sprintf("ParseQuery(%s) expected error but got none", tt.rawURL))
218 } else {
219 urequire.NoError(t, err, ufmt.Sprintf("ParseQuery(%s) returned error: %v", tt.rawURL, err))
220 uassert.Equal(t, tt.expectedPage, page, ufmt.Sprintf("ParseQuery(%s) returned page %d, expected %d", tt.rawURL, page, tt.expectedPage))
221 uassert.Equal(t, tt.expectedSize, size, ufmt.Sprintf("ParseQuery(%s) returned size %d, expected %d", tt.rawURL, size, tt.expectedSize))
222 }
223 }
224}
225
226func TestPage_PickerQueryParamPreservation(t *testing.T) {
227 tree := avl.NewTree()
228 for i := 1; i <= 6; i++ {
229 tree.Set(ufmt.Sprintf("key%d", i), i)
230 }
231
232 pager := NewPager(tree, 2, false)
233
234 tests := []struct {
235 name string
236 pageNumber int
237 path string
238 expected string
239 }{
240 {
241 name: "single query param",
242 pageNumber: 1,
243 path: "/test?foo=bar",
244 expected: "**1** | [2](?page=2&foo=bar) | [3](?page=3&foo=bar)",
245 },
246 {
247 name: "multiple query params",
248 pageNumber: 2,
249 path: "/test?foo=bar&baz=qux",
250 expected: "[1](?page=1&baz=qux&foo=bar) | **2** | [3](?page=3&baz=qux&foo=bar)",
251 },
252 {
253 name: "overwrite existing page param",
254 pageNumber: 1,
255 path: "/test?param1=value1&page=999¶m2=value2",
256 expected: "**1** | [2](?page=2¶m1=value1¶m2=value2) | [3](?page=3¶m1=value1¶m2=value2)",
257 },
258 {
259 name: "empty query string",
260 pageNumber: 2,
261 path: "/test",
262 expected: "[1](?page=1) | **2** | [3](?page=3)",
263 },
264 {
265 name: "query string with only page param",
266 pageNumber: 2,
267 path: "/test?page=2",
268 expected: "[1](?page=1) | **2** | [3](?page=3)",
269 },
270 }
271
272 for _, tt := range tests {
273 t.Run(tt.name, func(t *testing.T) {
274 page := pager.GetPageWithSize(tt.pageNumber, 2)
275 result := page.Picker(tt.path)
276 if result != tt.expected {
277 t.Errorf("\nwant: %s\ngot: %s", tt.expected, result)
278 }
279 })
280 }
281}
