ducky/subscriptions
ducky/subscriptions/subscription_store_test.go
Implement PostgreSQL support, drop subscription IDs. Create a Postgres object that wraps database/sql, so we can attach methods to it and fulfill interfaces. Create a postgres_init.sql script that will create the subscriptions table in a PostgreSQL database. Make our period type fulfill the driver.Valuer and driver.Scanner types, so it can be stored in and retrieved from SQL databases. Create a SubscriptionStats type, and add a method to our subscriptionStore interface that will allow us to retrieve current stats about the Subscriptions it is storing. Deprecated the ID property of our Subscription type, and use the Subscription.UserID property instead as our primary key. Subscriptions should be unique per user and we generally will want to access Subscriptions in the context of the User they belong to, so the UserID is a better primary key. This also means we removed the getSubscriptionByUserID method (and implementations) from our subscriptionStore, as getSubscriptions now fills that role. Implement our getSubscriptionStats method in the memstore. Implement the subscriptionStore interface on our new Postgres type. Run the subscription store tests on our Postgres type, as well, if the PG_TEST_DB environment variable is set. Round all our timestamps in our tests to the nearest millisecond, as Postgres silently truncates all timestamps to the nearest millisecond, and it was causing false test failures. Remove the tests for our getSubscriptionStoreByUser method, as that was removed.
1 package subscriptions
3 import (
4 "os"
5 "strconv"
6 "testing"
7 "time"
9 "code.secondbit.org/uuid.hg"
10 )
12 const (
13 subscriptionChangeStripeCustomer = 1 << iota
14 subscriptionChangeAmount
15 subscriptionChangePeriod
16 subscriptionChangeBeginCharging
17 subscriptionChangeLastCharged
18 subscriptionChangeLastNotified
19 subscriptionChangeInLockout
20 )
22 func init() {
23 if os.Getenv("PG_TEST_DB") != "" {
24 p, err := NewPostgres(os.Getenv("PG_TEST_DB"))
25 if err != nil {
26 panic(err)
27 }
28 testSubscriptionStores = append(testSubscriptionStores, p)
29 }
30 }
32 var testSubscriptionStores = []subscriptionStore{
33 NewMemstore(),
34 }
36 func compareSubscriptions(sub1, sub2 Subscription) (bool, string, interface{}, interface{}) {
37 if !sub1.UserID.Equal(sub2.UserID) {
38 return false, "UserID", sub1.UserID, sub2.UserID
39 }
40 if sub1.StripeCustomer != sub2.StripeCustomer {
41 return false, "StripeCustomer", sub1.StripeCustomer, sub2.StripeCustomer
42 }
43 if sub1.Amount != sub2.Amount {
44 return false, "Amount", sub1.Amount, sub2.Amount
45 }
46 if sub1.Period != sub2.Period {
47 return false, "Period", sub1.Period, sub2.Period
48 }
49 if !sub1.Created.Equal(sub2.Created) {
50 return false, "Created", sub1.Created, sub2.Created
51 }
52 if !sub1.BeginCharging.Equal(sub2.BeginCharging) {
53 return false, "BeginCharging", sub1.BeginCharging, sub2.BeginCharging
54 }
55 if !sub1.LastCharged.Equal(sub2.LastCharged) {
56 return false, "LastCharged", sub1.LastCharged, sub2.LastCharged
57 }
58 if !sub1.LastNotified.Equal(sub2.LastNotified) {
59 return false, "LastNotified", sub1.LastNotified, sub2.LastNotified
60 }
61 if sub1.InLockout != sub2.InLockout {
62 return false, "InLockout", sub1.InLockout, sub2.InLockout
63 }
64 return true, "", nil, nil
65 }
67 func subscriptionMapContains(subscriptionMap map[string]Subscription, subscriptions ...Subscription) (bool, []Subscription) {
68 var missing []Subscription
69 for _, sub := range subscriptions {
70 if _, ok := subscriptionMap[sub.UserID.String()]; !ok {
71 missing = append(missing, sub)
72 }
73 }
74 if len(missing) > 0 {
75 return false, missing
76 }
77 return true, missing
78 }
80 func TestCreateSubscription(t *testing.T) {
81 for _, store := range testSubscriptionStores {
82 err := store.reset()
83 if err != nil {
84 t.Fatalf("Error resetting %T: %+v\n", store, err)
85 }
86 customerID := uuid.NewID()
87 sub := Subscription{
88 UserID: customerID,
89 StripeCustomer: "stripeCustomer1",
90 Amount: 200,
91 Period: MonthlyPeriod,
92 Created: time.Now().Round(time.Millisecond),
93 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour),
94 }
95 err = store.createSubscription(sub)
96 if err != nil {
97 t.Errorf("Error creating subscription in %T: %+v\n", store, err)
98 }
99 retrieved, err := store.getSubscriptions([]uuid.ID{sub.UserID})
100 if err != nil {
101 t.Errorf("Error retrieving subscription from %T: %+v\n", store, err)
102 }
103 if _, returned := retrieved[sub.UserID.String()]; !returned {
104 t.Errorf("Error retrieving subscription from %T: %s wasn't in the results.", store, sub.UserID)
105 }
106 ok, field, expected, result := compareSubscriptions(sub, retrieved[sub.UserID.String()])
107 if !ok {
108 t.Errorf("Expected %s to be %v, got %v from %T\n", field, expected, result, store)
109 }
110 err = store.createSubscription(sub)
111 if err != ErrSubscriptionAlreadyExists {
112 t.Errorf("Unexpected error creating subscription in %T (wanted %+v): %+v\n", store, ErrSubscriptionAlreadyExists, err)
113 }
114 sub.UserID = uuid.NewID()
115 err = store.createSubscription(sub)
116 if err != ErrStripeCustomerAlreadyExists {
117 t.Errorf("Unexpected error creating subscription in %T (wanted %+v): %#+v\n", store, ErrStripeCustomerAlreadyExists, err)
118 }
119 sub.StripeCustomer = "stripeCustomer2"
120 err = store.createSubscription(sub)
121 if err != nil {
122 t.Errorf("Error creating subscription in %T: %+v\n", store, err)
123 }
124 }
125 }
127 func TestUpdateSubscription(t *testing.T) {
128 variations := 1 << 7
129 sub := Subscription{
130 UserID: uuid.NewID(),
131 StripeCustomer: "default",
132 Amount: -1,
133 Period: MonthlyPeriod,
134 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
135 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
136 LastCharged: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
137 LastNotified: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
138 InLockout: true,
139 }
140 sub2 := Subscription{
141 UserID: uuid.NewID(),
142 StripeCustomer: "stripeCustomer2",
143 Amount: -2,
144 Period: MonthlyPeriod,
145 Created: time.Now().Round(time.Millisecond),
146 BeginCharging: time.Now().Round(time.Millisecond),
147 LastCharged: time.Now().Round(time.Millisecond),
148 LastNotified: time.Now().Round(time.Millisecond),
149 InLockout: false,
150 }
152 for i := 1; i < variations; i++ {
153 var stripeCustomer string
154 var amount int
155 var inLockout bool
156 var per period
157 var beginCharging, lastCharged, lastNotified time.Time
159 change := SubscriptionChange{}
160 empty := change.IsEmpty()
161 if !empty {
162 t.Errorf("Expected empty to be %t, was %t\n", true, empty)
163 }
164 expectation := sub
165 result := sub
166 strI := strconv.Itoa(i)
168 if i&subscriptionChangeStripeCustomer != 0 {
169 stripeCustomer = "stripeCustomer-" + strI
170 change.StripeCustomer = &stripeCustomer
171 expectation.StripeCustomer = stripeCustomer
172 }
174 if i&subscriptionChangeAmount != 0 {
175 amount = i
176 change.Amount = &amount
177 expectation.Amount = amount
178 }
180 if i&subscriptionChangePeriod != 0 {
181 per = period("period-" + strI)
182 change.Period = &per
183 expectation.Period = per
184 }
186 if i&subscriptionChangeBeginCharging != 0 {
187 beginCharging = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
188 change.BeginCharging = &beginCharging
189 expectation.BeginCharging = beginCharging
190 }
192 if i&subscriptionChangeLastCharged != 0 {
193 lastCharged = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
194 change.LastCharged = &lastCharged
195 expectation.LastCharged = lastCharged
196 }
198 if i&subscriptionChangeLastNotified != 0 {
199 lastNotified = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
200 change.LastNotified = &lastNotified
201 expectation.LastNotified = lastNotified
202 }
204 if i&subscriptionChangeInLockout != 0 {
205 inLockout = i%2 == 0
206 change.InLockout = &inLockout
207 expectation.InLockout = inLockout
208 }
210 empty = change.IsEmpty()
211 if empty {
212 t.Errorf("Expected empty to be %t, was %t\n", false, empty)
213 }
215 result.ApplyChange(change)
216 match, field, expected, got := compareSubscriptions(expectation, result)
217 if !match {
218 t.Errorf("Expected field `%s` to be `%v`, got `%v`\n", field, expected, got)
219 }
220 for _, store := range testSubscriptionStores {
221 err := store.reset()
222 if err != nil {
223 t.Fatalf("Error resetting %T: %+v\n", store, err)
224 }
225 err = store.createSubscription(sub)
226 if err != nil {
227 t.Fatalf("Error saving subscription in %T: %s\n", store, err)
228 }
229 err = store.updateSubscription(sub.UserID, change)
230 if err != nil {
231 t.Errorf("Error updating subscription in %T: %s\n", store, err)
232 }
233 retrieved, err := store.getSubscriptions([]uuid.ID{sub.UserID})
234 if err != nil {
235 t.Errorf("Error getting subscription from %T: %s\n", store, err)
236 }
237 ok, missing := subscriptionMapContains(retrieved, sub)
238 if !ok {
239 t.Errorf("Expected to retrieve %s from %T, but missing was %+v\n", sub.UserID.String(), store, missing)
240 }
241 match, field, expected, got = compareSubscriptions(expectation, retrieved[sub.UserID.String()])
242 if !match {
243 t.Errorf("Expected field `%s` to be `%v`, got `%v` from %T\n", field, expected, got, store)
244 }
245 }
246 }
247 for _, store := range testSubscriptionStores {
248 err := store.reset()
249 if err != nil {
250 t.Fatalf("Error resetting %T: %+v\n", store, err)
251 }
252 err = store.createSubscription(sub)
253 if err != nil {
254 t.Fatalf("Error saving subscription in %T: %+v\n", store, err)
255 }
256 err = store.createSubscription(sub2)
257 if err != nil {
258 t.Fatalf("Error saving subscription in %T: %+v\n", store, err)
259 }
260 change := SubscriptionChange{}
261 err = store.updateSubscription(sub.UserID, change)
262 if err != ErrSubscriptionChangeEmpty {
263 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionChangeEmpty, err, store)
264 }
265 stripeCustomer := sub2.StripeCustomer
266 change.StripeCustomer = &stripeCustomer
267 err = store.updateSubscription(uuid.NewID(), change)
268 if err != ErrSubscriptionNotFound {
269 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
270 }
271 err = store.updateSubscription(sub.UserID, change)
272 if err != ErrStripeCustomerAlreadyExists {
273 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrStripeCustomerAlreadyExists, err, store)
274 }
275 }
276 }
278 func TestDeleteSubscription(t *testing.T) {
279 for _, store := range testSubscriptionStores {
280 err := store.reset()
281 if err != nil {
282 t.Fatalf("Error resetting %T: %+v\n", store, err)
283 }
284 sub1 := Subscription{
285 UserID: uuid.NewID(),
286 StripeCustomer: "stripeCustomer1",
287 }
288 sub2 := Subscription{
289 UserID: uuid.NewID(),
290 StripeCustomer: "stripeCustomer2",
291 }
292 err = store.createSubscription(sub1)
293 if err != nil {
294 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
295 }
296 err = store.createSubscription(sub2)
297 if err != nil {
298 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
299 }
300 err = store.deleteSubscription(sub1.UserID)
301 if err != nil {
302 t.Fatalf("Error deleting %+v in %T: %+v\n", sub1, store, err)
303 }
304 retrieved, err := store.getSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID})
305 if err != nil {
306 t.Errorf("Error retrieving subscriptions from %T: %+v\n", store, err)
307 }
308 ok, missing := subscriptionMapContains(retrieved, sub1)
309 if ok {
310 t.Errorf("Expected not to retrieve %s from %T, but missing was %+v\n", sub1.UserID.String(), store, missing)
311 }
312 ok, missing = subscriptionMapContains(retrieved, sub2)
313 if !ok {
314 t.Errorf("Expected to retrieve %s from %T, but missing was %+v\n", sub2.UserID.String(), store, missing)
315 }
316 err = store.deleteSubscription(sub1.UserID)
317 if err != ErrSubscriptionNotFound {
318 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
319 }
320 }
321 }
323 func TestListSubscriptionsLastChargedBefore(t *testing.T) {
324 for _, store := range testSubscriptionStores {
325 err := store.reset()
326 if err != nil {
327 t.Fatalf("Error resetting %T: %+v\n", store, err)
328 }
329 sub1 := Subscription{
330 UserID: uuid.NewID(),
331 StripeCustomer: "stripeCustomer1",
332 Amount: 200,
333 Period: MonthlyPeriod,
334 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -24 * 32),
335 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
336 LastCharged: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
337 }
338 sub2 := Subscription{
339 UserID: uuid.NewID(),
340 StripeCustomer: "stripeCustomer2",
341 Amount: 300,
342 Period: MonthlyPeriod,
343 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -24 * 61),
344 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour * -24 * 31),
345 LastCharged: time.Now().Round(time.Millisecond).Add(time.Hour * -24 * 31),
346 }
347 sub3 := Subscription{
348 UserID: uuid.NewID(),
349 StripeCustomer: "stripeCustomer3",
350 Amount: 100,
351 Period: MonthlyPeriod,
352 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -1),
353 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour * 31),
354 LastCharged: time.Time{},
355 }
356 err = store.createSubscription(sub1)
357 if err != nil {
358 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
359 }
360 err = store.createSubscription(sub2)
361 if err != nil {
362 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
363 }
364 err = store.createSubscription(sub3)
365 if err != nil {
366 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
367 }
368 t.Logf("sub1: %+v\n", sub1)
369 t.Logf("sub2: %+v\n", sub2)
370 t.Logf("sub3: %+v\n", sub3)
371 // subscriptions last charged before right now
372 // should be sub1, sub2, and sub3
373 results, err := store.listSubscriptionsLastChargedBefore(time.Now().Round(time.Millisecond))
374 if err != nil {
375 t.Errorf("Unexpected error listing subscriptions in %T: %+v\n", store, err)
376 }
377 if len(results) != 3 {
378 t.Errorf("Expected three results from %T, got %+v\n", store, results)
379 }
380 ok, field, expected, result := compareSubscriptions(sub3, results[0])
381 if !ok {
382 t.Errorf("Expected %s in pos 0 to be %+v, got %+v from %T", field, expected, result, store)
383 }
384 ok, field, expected, result = compareSubscriptions(sub2, results[1])
385 if !ok {
386 t.Errorf("Expected %s in pos 1 to be %+v, got %+v from %T", field, expected, result, store)
387 }
388 ok, field, expected, result = compareSubscriptions(sub1, results[2])
389 if !ok {
390 t.Errorf("Expected %s in pos 2 to be %+v, got %+v from %T", field, expected, result, store)
391 }
392 // subscriptions last charged before a week ago
393 // should be sub2, sub3
394 results, err = store.listSubscriptionsLastChargedBefore(time.Now().Round(time.Millisecond).Add(time.Hour * -24 * 7))
395 if err != nil {
396 t.Errorf("Unexpected error listing subscriptions in %T: %+v\n", store, err)
397 }
398 if len(results) != 2 {
399 t.Errorf("Expected two results from %T, got %+v\n", store, results)
400 }
401 ok, field, expected, result = compareSubscriptions(sub3, results[0])
402 if !ok {
403 t.Errorf("Expected %s in pos 0 to be %+v, got %+v from %T", field, expected, result, store)
404 }
405 ok, field, expected, result = compareSubscriptions(sub2, results[1])
406 if !ok {
407 t.Errorf("Expected %s in pos 1 to be %+v, got %+v from %T", field, expected, result, store)
408 }
409 // subscriptions last charged before 32 days ago
410 // should be sub3
411 results, err = store.listSubscriptionsLastChargedBefore(time.Now().Round(time.Millisecond).Add(time.Hour * -24 * 32))
412 if err != nil {
413 t.Errorf("Unexpected error listing subscriptions in %T: %+v\n", store, err)
414 }
415 if len(results) != 1 {
416 t.Errorf("Expected one result from %T, got %+v\n", store, results)
417 }
418 ok, field, expected, result = compareSubscriptions(sub3, results[0])
419 if !ok {
420 t.Errorf("Expected %s in pos 0 to be %+v, got %+v from %T", field, expected, result, store)
421 }
422 }
423 }
425 func TestGetSubscriptions(t *testing.T) {
426 for _, store := range testSubscriptionStores {
427 err := store.reset()
428 if err != nil {
429 t.Fatalf("Error resetting %T: %+v\n", store, err)
430 }
431 sub1 := Subscription{
432 UserID: uuid.NewID(),
433 StripeCustomer: "stripeCustomer1",
434 Amount: 200,
435 Period: MonthlyPeriod,
436 Created: time.Now().Round(time.Millisecond),
437 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour),
438 }
439 sub2 := Subscription{
440 UserID: uuid.NewID(),
441 StripeCustomer: "stripeCustomer2",
442 Amount: 300,
443 Period: MonthlyPeriod,
444 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -720),
445 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour*-720 + time.Hour*2),
446 LastCharged: time.Now().Round(time.Millisecond),
447 }
448 sub3 := Subscription{
449 UserID: uuid.NewID(),
450 StripeCustomer: "stripeCustomer3",
451 Amount: 100,
452 Period: MonthlyPeriod,
453 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -1440),
454 BeginCharging: time.Now().Round(time.Millisecond).Add(time.Hour * -1440),
455 LastNotified: time.Now().Round(time.Millisecond).Add(time.Hour * -720),
456 InLockout: true,
457 }
458 err = store.createSubscription(sub1)
459 if err != nil {
460 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
461 }
462 err = store.createSubscription(sub2)
463 if err != nil {
464 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
465 }
466 err = store.createSubscription(sub3)
467 if err != nil {
468 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
469 }
470 retrieved, err := store.getSubscriptions([]uuid.ID{})
471 if err != ErrNoSubscriptionID {
472 t.Errorf("Error retrieving no subscriptions from %T. Expected %+v, got %+v\n", store, ErrNoSubscriptionID, err)
473 }
474 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.UserID})
475 if err != nil {
476 t.Errorf("Error retrieving %s from %T: %+v\n", sub1.UserID, store, err)
477 }
478 ok, missing := subscriptionMapContains(retrieved, sub1)
479 if !ok {
480 t.Logf("Results: %+v\n", retrieved)
481 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
482 }
483 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID})
484 if err != nil {
485 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub1.UserID, sub2.UserID, store, err)
486 }
487 ok, missing = subscriptionMapContains(retrieved, sub1, sub2)
488 if !ok {
489 t.Logf("Results: %+v\n", retrieved)
490 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
491 }
492 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.UserID, sub3.UserID})
493 if err != nil {
494 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub1.UserID, sub3.UserID, store, err)
495 }
496 ok, missing = subscriptionMapContains(retrieved, sub1, sub3)
497 if !ok {
498 t.Logf("Results: %+v\n", retrieved)
499 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
500 }
501 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID, sub3.UserID})
502 if err != nil {
503 t.Errorf("Error retrieving %s, %s, and %s from %T: %+v\n", sub1.UserID, sub2.UserID, sub3.UserID, store, err)
504 }
505 ok, missing = subscriptionMapContains(retrieved, sub1, sub2, sub3)
506 if !ok {
507 t.Logf("Results: %+v\n", retrieved)
508 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
509 }
510 retrieved, err = store.getSubscriptions([]uuid.ID{sub2.UserID})
511 if err != nil {
512 t.Errorf("Error retrieving %s from %T: %+v\n", sub2.UserID, store, err)
513 }
514 ok, missing = subscriptionMapContains(retrieved, sub2)
515 if !ok {
516 t.Logf("Results: %+v\n", retrieved)
517 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
518 }
519 retrieved, err = store.getSubscriptions([]uuid.ID{sub2.UserID, sub3.UserID})
520 if err != nil {
521 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub2.UserID, sub3.UserID, store, err)
522 }
523 ok, missing = subscriptionMapContains(retrieved, sub2, sub3)
524 if !ok {
525 t.Logf("Results: %+v\n", retrieved)
526 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
527 }
528 retrieved, err = store.getSubscriptions([]uuid.ID{sub3.UserID})
529 if err != nil {
530 t.Errorf("Error retrieving %s from %T: %+v\n", sub3.UserID, store, err)
531 }
532 ok, missing = subscriptionMapContains(retrieved, sub3)
533 if !ok {
534 t.Logf("Results: %+v\n", retrieved)
535 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
536 }
537 retrieved, err = store.getSubscriptions([]uuid.ID{uuid.NewID()})
538 if err != nil {
539 t.Errorf("Error retrieving non-existent ID from %T: %+v\n", store, err)
540 }
541 if len(retrieved) != 0 {
542 t.Errorf("Expected no results, %T returned %+v\n", store, retrieved)
543 }
544 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID, uuid.NewID(), sub3.UserID})
545 if err != nil {
546 t.Errorf("Error retrieving non-existent ID from %T: %+v\n", store, err)
547 }
548 if len(retrieved) != 3 {
549 t.Errorf("Expected 3 results, %T returned %+v\n", store, retrieved)
550 }
551 ok, missing = subscriptionMapContains(retrieved, sub1, sub2, sub3)
552 if !ok {
553 t.Logf("Results: %+v\n", retrieved)
554 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
555 }
556 }
557 }