pager_test.gno
4.74 Kb · 204 lines
1package pager
2
3import (
4 "testing"
5
6 "gno.land/p/demo/uassert"
7 "gno.land/p/demo/urequire"
8)
9
10func TestPager(t *testing.T) {
11 cases := []struct {
12 name, uri, prevPath, nextPath, param string
13 offset, pageSize, page, pageCount int
14 hasPages bool
15 items []int
16 err error
17 }{
18 {
19 name: "page 1",
20 uri: "gno.land/r/demo/test:foo/bar?page=1&foo=bar",
21 items: []int{1, 2, 3, 4, 5, 6},
22 hasPages: true,
23 nextPath: "?foo=bar&page=2",
24 pageSize: 5,
25 page: 1,
26 pageCount: 2,
27 },
28 {
29 name: "page 2",
30 uri: "gno.land/r/demo/test:foo/bar?page=2&foo=bar",
31 items: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
32 hasPages: true,
33 prevPath: "?foo=bar&page=1",
34 nextPath: "",
35 offset: 5,
36 pageSize: 5,
37 page: 2,
38 pageCount: 2,
39 },
40 {
41 name: "custom query param",
42 uri: "gno.land/r/demo/test:foo/bar?current=2&foo=bar",
43 items: []int{1, 2, 3},
44 param: "current",
45 hasPages: true,
46 prevPath: "?current=1&foo=bar",
47 nextPath: "",
48 offset: 2,
49 pageSize: 2,
50 page: 2,
51 pageCount: 2,
52 },
53 {
54 name: "missing page",
55 uri: "gno.land/r/demo/test:foo/bar?page=3&foo=bar",
56 err: ErrInvalidPageNumber,
57 },
58 {
59 name: "invalid page zero",
60 uri: "gno.land/r/demo/test:foo/bar?page=0",
61 err: ErrInvalidPageNumber,
62 },
63 {
64 name: "invalid page number",
65 uri: "gno.land/r/demo/test:foo/bar?page=foo",
66 err: ErrInvalidPageNumber,
67 },
68 }
69
70 for _, tc := range cases {
71 t.Run(tc.name, func(t *testing.T) {
72 // Act
73 p, err := New(tc.uri, len(tc.items), WithPageSize(tc.pageSize), WithPageQueryParam(tc.param))
74
75 // Assert
76 if tc.err != nil {
77 urequire.ErrorIs(t, err, tc.err, "expected an error")
78 return
79 }
80
81 urequire.NoError(t, err, "expect no error")
82 uassert.Equal(t, len(tc.items), p.TotalItems(), "total items")
83 uassert.Equal(t, tc.page, p.Page(), "page number")
84 uassert.Equal(t, tc.pageCount, p.PageCount(), "number of pages")
85 uassert.Equal(t, tc.pageSize, p.PageSize(), "page size")
86 uassert.Equal(t, tc.prevPath, p.PrevPageURI(), "prev URL page")
87 uassert.Equal(t, tc.nextPath, p.NextPageURI(), "next URL page")
88 uassert.Equal(t, tc.hasPages, p.HasPages(), "has pages")
89 uassert.Equal(t, tc.offset, p.Offset(), "item offset")
90 })
91 }
92}
93
94func TestPagerIterate(t *testing.T) {
95 cases := []struct {
96 name, uri string
97 items, page []int
98 stop bool
99 }{
100 {
101 name: "page 1",
102 uri: "gno.land/r/demo/test:foo/bar?page=1",
103 items: []int{1, 2, 3, 4, 5, 6, 7},
104 page: []int{1, 2, 3},
105 },
106 {
107 name: "page 2",
108 uri: "gno.land/r/demo/test:foo/bar?page=2",
109 items: []int{1, 2, 3, 4, 5, 6, 7},
110 page: []int{4, 5, 6},
111 },
112 {
113 name: "page 3",
114 uri: "gno.land/r/demo/test:foo/bar?page=3",
115 items: []int{1, 2, 3, 4, 5, 6, 7},
116 page: []int{7},
117 },
118 {
119 name: "stop iteration",
120 uri: "gno.land/r/demo/test:foo/bar?page=1",
121 items: []int{1, 2, 3},
122 stop: true,
123 },
124 }
125
126 for _, tc := range cases {
127 t.Run(tc.name, func(t *testing.T) {
128 // Arrange
129 var (
130 items []int
131 p = MustNew(tc.uri, len(tc.items), WithPageSize(3))
132 )
133
134 // Act
135 stopped := p.Iterate(func(i int) bool {
136 if tc.stop {
137 return true
138 }
139
140 items = append(items, tc.items[i])
141 return false
142 })
143
144 // Assert
145 uassert.Equal(t, tc.stop, stopped)
146 urequire.Equal(t, len(tc.page), len(items), "expect iteration of the right number of items")
147
148 for i, v := range items {
149 urequire.Equal(t, tc.page[i], v, "expect iterated items to match")
150 }
151 })
152 }
153}
154
155func TestPicker(t *testing.T) {
156 pageSize := 3
157 cases := []struct {
158 name, uri, output string
159 totalItems int
160 }{
161 {
162 name: "one page",
163 uri: "gno.land/r/demo/test:foo/bar?page=1",
164 totalItems: 3,
165 output: "",
166 },
167 {
168 name: "two pages",
169 uri: "gno.land/r/demo/test:foo/bar?page=1",
170 totalItems: 4,
171 output: "\\- | page 1 of 2 | [»](?page=2)",
172 },
173 {
174 name: "three pages",
175 uri: "gno.land/r/demo/test:foo/bar?page=1",
176 totalItems: 7,
177 output: "\\- | page 1 of 3 | [»](?page=2)",
178 },
179 {
180 name: "three pages second page",
181 uri: "gno.land/r/demo/test:foo/bar?page=2",
182 totalItems: 7,
183 output: "[«](?page=1) | page 2 of 3 | [»](?page=3)",
184 },
185 {
186 name: "three pages third page",
187 uri: "gno.land/r/demo/test:foo/bar?page=3",
188 totalItems: 7,
189 output: "[«](?page=2) | page 3 of 3 | \\-",
190 },
191 }
192 for _, tc := range cases {
193 t.Run(tc.name, func(t *testing.T) {
194 // Arrange
195 p := MustNew(tc.uri, tc.totalItems, WithPageSize(pageSize))
196
197 // Act
198 output := Picker(p)
199
200 // Assert
201 uassert.Equal(t, tc.output, output)
202 })
203 }
204}
