1 package middleware
2
3 import (
4 "reflect"
5 "testing"
6 )
7
8 func TestOrderedIDsAdd(t *testing.T) {
9 o := newOrderedIDs()
10
11 noError(t, o.Add(&mockIder{"first"}, After))
12 noError(t, o.Add(&mockIder{"second"}, After))
13 noError(t, o.Add(&mockIder{"third"}, After))
14 noError(t, o.Add(&mockIder{"real-first"}, Before))
15
16 if err := o.Add(&mockIder{""}, After); err == nil {
17 t.Errorf("expect error adding empty ID, got none")
18 }
19 if err := o.Add(&mockIder{"second"}, After); err == nil {
20 t.Errorf("expect error adding duplicate, got none")
21 }
22 if err := o.Add(&mockIder{"unique"}, 123); err == nil {
23 t.Errorf("expect error add unknown relative position, got none")
24 }
25
26 expectIDs := []string{"real-first", "first", "second", "third"}
27
28 if e, a := expectIDs, o.List(); !reflect.DeepEqual(e, a) {
29 t.Errorf("expect %v order, got %v", e, a)
30 }
31 }
32
33 func TestOrderedIDsInsert(t *testing.T) {
34 o := newOrderedIDs()
35
36 noError(t, o.Add(&mockIder{"first"}, After))
37 noError(t, o.Insert(&mockIder{"third"}, "first", After))
38 noError(t, o.Insert(&mockIder{"second"}, "third", Before))
39 noError(t, o.Insert(&mockIder{"real-first"}, "first", Before))
40 noError(t, o.Insert(&mockIder{"not-yet-last"}, "second", After))
41 noError(t, o.Insert(&mockIder{"last"}, "third", After))
42
43 if err := o.Insert(&mockIder{""}, "first", After); err == nil {
44 t.Errorf("expect error insert empty ID, got none")
45 }
46 if err := o.Insert(&mockIder{"second"}, "", After); err == nil {
47 t.Errorf("expect error insert with empty relative ID, got none")
48 }
49 if err := o.Insert(&mockIder{"second"}, "third", After); err == nil {
50 t.Errorf("expect error insert duplicate, got none")
51 }
52 if err := o.Insert(&mockIder{"unique"}, "not-found", After); err == nil {
53 t.Errorf("expect error insert not found relative ID, got none")
54 }
55 if err := o.Insert(&mockIder{"unique"}, "first", 123); err == nil {
56 t.Errorf("expect error insert unknown relative position, got none")
57 }
58
59 expectIDs := []string{"real-first", "first", "second", "not-yet-last", "third", "last"}
60 if e, a := expectIDs, o.List(); !reflect.DeepEqual(e, a) {
61 t.Errorf("expect %v order, got %v", e, a)
62 }
63 }
64
65 func TestOrderedIDsGet(t *testing.T) {
66 o := newOrderedIDs()
67
68 noError(t, o.Add(&mockIder{"first"}, After))
69 noError(t, o.Add(&mockIder{"second"}, After))
70
71 f, ok := o.Get("not-found")
72 if ok || f != nil {
73 t.Fatalf("expect id not to be found, but was")
74 }
75
76 f, ok = o.Get("first")
77 if !ok {
78 t.Fatalf("expect id to be found, was not")
79 }
80 if e, a := "first", f.ID(); e != a {
81 t.Errorf("expect %v id, got %v", e, a)
82 }
83 }
84
85 func TestOrderedIDsSwap(t *testing.T) {
86 o := newOrderedIDs()
87
88 noError(t, o.Add(&mockIder{"first"}, After))
89 noError(t, o.Add(&mockIder{"second"}, After))
90 noError(t, o.Add(&mockIder{"third"}, After))
91
92 if _, err := o.Swap("first", &mockIder{""}); err == nil {
93 t.Errorf("expect error swap empty ID, got none")
94 }
95 if _, err := o.Swap("", &mockIder{"second"}); err == nil {
96 t.Errorf("expect error swap with empty relative ID, got none")
97 }
98
99 if _, err := o.Swap("not-exists", &mockIder{"last"}); err == nil {
100 t.Errorf("expect error swap not-exists ID, got none")
101 }
102 if _, err := o.Swap("second", &mockIder{"first"}); err == nil {
103 t.Errorf("expect error swap to existing ID, got none")
104 }
105
106 r, err := o.Swap("second", &mockIder{"otherSecond"})
107 noError(t, err)
108 if r == nil {
109 t.Fatalf("expect removed item to be returned")
110 }
111 if e, a := "second", r.ID(); e != a {
112 t.Errorf("expect %v removed ider, got %v", e, a)
113 }
114
115 expectIDs := []string{"first", "otherSecond", "third"}
116 if e, a := expectIDs, o.List(); !reflect.DeepEqual(e, a) {
117 t.Errorf("expect %v order, got %v", e, a)
118 }
119 }
120
121 func TestOrderedIDsRemove(t *testing.T) {
122 o := newOrderedIDs()
123 firstIder := &mockIder{"first"}
124 noError(t, o.Add(firstIder, After))
125 noError(t, o.Insert(&mockIder{"third"}, "first", After))
126 if removed, err := o.Remove("first"); err != nil {
127 t.Errorf("expect no error, got %v", err)
128 } else if removed != firstIder {
129 t.Error("removed ider did not match expected")
130 }
131 noError(t, o.Insert(&mockIder{"last"}, "third", After))
132
133 if _, err := o.Remove(""); err == nil {
134 t.Errorf("expect error remove empty ID, got none")
135 }
136 if _, err := o.Remove("not-exists"); err == nil {
137 t.Errorf("expect error remove not exists ID, got none")
138 }
139
140 expectIDs := []string{"third", "last"}
141 if e, a := expectIDs, o.List(); !reflect.DeepEqual(e, a) {
142 t.Errorf("expect %v order, got %v", e, a)
143 }
144 }
145
146 func TestOrderedIDsClear(t *testing.T) {
147 o := newOrderedIDs()
148
149 noError(t, o.Add(&mockIder{"first"}, After))
150 noError(t, o.Add(&mockIder{"second"}, After))
151
152 o.Clear()
153
154 noError(t, o.Add(&mockIder{"third"}, After))
155 noError(t, o.Add(&mockIder{"fourth"}, After))
156
157 expectIDs := []string{"third", "fourth"}
158 if e, a := expectIDs, o.List(); !reflect.DeepEqual(e, a) {
159 t.Errorf("expect %v order, got %v", e, a)
160 }
161 }
162
163 func TestOrderedIDsGetOrder(t *testing.T) {
164 o := newOrderedIDs()
165
166 noError(t, o.Add(&mockIder{"first"}, After))
167 noError(t, o.Add(&mockIder{"second"}, After))
168 noError(t, o.Add(&mockIder{"third"}, After))
169 noError(t, o.Add(&mockIder{"real-first"}, Before))
170
171 expectIDs := []string{"real-first", "first", "second", "third"}
172 if e, a := expectIDs, o.List(); !reflect.DeepEqual(e, a) {
173 t.Errorf("expect %v order, got %v", e, a)
174 }
175
176 actualOrder := o.GetOrder()
177
178 if e, a := len(expectIDs), len(actualOrder); e != a {
179 t.Errorf("expect %v IDs, got %v", e, a)
180 }
181
182 compareGetOrder(t, expectIDs, actualOrder)
183 }
184
185 func TestRelativeOrder_insert(t *testing.T) {
186 var ro relativeOrder
187
188 if err := ro.insert(0, After); err != nil {
189 t.Errorf("expect no error, got %v", err)
190 }
191 if err := ro.insert(0, Before); err != nil {
192 t.Errorf("expect no error, got %v", err)
193 }
194
195 if len(ro.order) > 0 {
196 t.Errorf("expect slice to be empty")
197 }
198
199 if err := ro.insert(0, After, "foo"); err != nil {
200 t.Errorf("expect no error, got %v", err)
201 }
202 if err := ro.insert(0, After, "bar"); err != nil {
203 t.Errorf("expect no error, got %v", err)
204 }
205 if err := ro.insert(1, After, "baz"); err != nil {
206 t.Errorf("expect no error, got %v", err)
207 }
208 if err := ro.insert(1, Before, "fob"); err != nil {
209 t.Errorf("expect no error, got %v", err)
210 }
211 if err := ro.insert(3, Before, "bas"); err != nil {
212 t.Errorf("expect no error, got %v", err)
213 }
214 if err := ro.insert(3, After, "bat"); err != nil {
215 t.Errorf("expect no error, got %v", err)
216 }
217 if err := ro.insert(0, 1024, "zzz"); err == nil {
218 t.Error("expect error, got nil")
219 }
220
221 expect := []string{"foo", "fob", "bar", "bas", "bat", "baz"}
222 if !reflect.DeepEqual(expect, ro.order) {
223 t.Errorf("%v != %v", expect, ro.order)
224 }
225 }
226
227 func compareGetOrder(t *testing.T, expected []string, actual []interface{}) {
228 t.Helper()
229 for _, eID := range expected {
230 var found bool
231 for _, aIder := range actual {
232 if e, a := eID, aIder.(ider).ID(); e == a {
233 if found {
234 t.Errorf("expect only one %v, got more", e)
235 }
236 found = true
237 }
238 }
239 if !found {
240 t.Errorf("expect to find %v, did not", eID)
241 }
242 }
243 }
244
View as plain text