ducky/subscriptions
2015-06-11
Child:f1a22fc2321d
ducky/subscriptions/subscription_store_test.go
First implementation of datastore interface. Define Subscriptions, and the SubscriptionChange type that can modify Subscriptions. Define the subscriptionStore, which describes how Subscriptions are to be created, retrieved, updated, and deleted in/from the storage backend they're stored in. Create a Memstore implementation of the subscriptionStore, which stores all our data in-memory, for use in testing. Write tests to cover the subscriptionStore interface, testing the entire Memstore. We'll plug future storage backends into these tests, to make sure they all behave the same, and to exercise each storage backend without requiring a suite of tests for each. At this point, we have 100% test coverage and no complaints from golint or go vet. I expect it's all downhill from here.
1 package subscriptions
3 import (
4 "strconv"
5 "testing"
6 "time"
8 "code.secondbit.org/uuid.hg"
9 )
11 const (
12 subscriptionChangeStripeCustomer = 1 << iota
13 subscriptionChangeAmount
14 subscriptionChangePeriod
15 subscriptionChangeBeginCharging
16 subscriptionChangeLastCharged
17 subscriptionChangeLastNotified
18 subscriptionChangeInLockout
19 )
21 var testSubscriptionStores = []subscriptionStore{
22 NewMemstore(),
23 }
25 func compareSubscriptions(sub1, sub2 Subscription) (bool, string, interface{}, interface{}) {
26 if !sub1.ID.Equal(sub2.ID) {
27 return false, "ID", sub1.ID, sub2.ID
28 }
29 if !sub1.UserID.Equal(sub2.UserID) {
30 return false, "UserID", sub1.UserID, sub2.UserID
31 }
32 if sub1.StripeCustomer != sub2.StripeCustomer {
33 return false, "StripeCustomer", sub1.StripeCustomer, sub2.StripeCustomer
34 }
35 if sub1.Amount != sub2.Amount {
36 return false, "Amount", sub1.Amount, sub2.Amount
37 }
38 if sub1.Period != sub2.Period {
39 return false, "Period", sub1.Period, sub2.Period
40 }
41 if !sub1.Created.Equal(sub2.Created) {
42 return false, "Created", sub1.Created, sub2.Created
43 }
44 if !sub1.BeginCharging.Equal(sub2.BeginCharging) {
45 return false, "BeginCharging", sub1.BeginCharging, sub2.BeginCharging
46 }
47 if !sub1.LastCharged.Equal(sub2.LastCharged) {
48 return false, "LastCharged", sub1.LastCharged, sub2.LastCharged
49 }
50 if !sub1.LastNotified.Equal(sub2.LastNotified) {
51 return false, "LastNotified", sub1.LastNotified, sub2.LastNotified
52 }
53 if sub1.InLockout != sub2.InLockout {
54 return false, "InLockout", sub1.InLockout, sub2.InLockout
55 }
56 return true, "", nil, nil
57 }
59 func subscriptionMapContains(subscriptionMap map[string]Subscription, subscriptions ...Subscription) (bool, []Subscription) {
60 var missing []Subscription
61 for _, sub := range subscriptions {
62 if _, ok := subscriptionMap[sub.ID.String()]; !ok {
63 missing = append(missing, sub)
64 }
65 }
66 if len(missing) > 0 {
67 return false, missing
68 }
69 return true, missing
70 }
72 func TestCreateSubscription(t *testing.T) {
73 for _, store := range testSubscriptionStores {
74 err := store.reset()
75 if err != nil {
76 t.Fatalf("Error resetting %T: %+v\n", store, err)
77 }
78 customerID := uuid.NewID()
79 sub := Subscription{
80 ID: uuid.NewID(),
81 UserID: customerID,
82 StripeCustomer: "stripeCustomer1",
83 Amount: 200,
84 Period: MonthlyPeriod,
85 Created: time.Now(),
86 BeginCharging: time.Now().Add(time.Hour),
87 }
88 err = store.createSubscription(sub)
89 if err != nil {
90 t.Errorf("Error creating subscription in %T: %+v\n", store, err)
91 }
92 retrieved, err := store.getSubscriptions([]uuid.ID{sub.ID})
93 if err != nil {
94 t.Errorf("Error retrieving subscription from %T: %+v\n", store, err)
95 }
96 if _, returned := retrieved[sub.ID.String()]; !returned {
97 t.Errorf("Error retrieving subscription from %T: %s wasn't in the results.", store, sub.ID)
98 }
99 ok, field, expected, result := compareSubscriptions(sub, retrieved[sub.ID.String()])
100 if !ok {
101 t.Errorf("Expected %s to be %v, got %v from %T\n", field, expected, result, store)
102 }
103 err = store.createSubscription(sub)
104 if err != ErrSubscriptionAlreadyExists {
105 t.Errorf("Unexpected error creating subscription in %T (wanted %+v): %+v\n", store, ErrSubscriptionAlreadyExists, err)
106 }
107 sub.ID = uuid.NewID()
108 err = store.createSubscription(sub)
109 if err != ErrStripeCustomerAlreadyExists {
110 t.Errorf("Unexpected error creating subscription in %T (wanted %+v): %+v\n", store, ErrStripeCustomerAlreadyExists, err)
111 }
112 sub.StripeCustomer = "stripeCustomer2"
113 err = store.createSubscription(sub)
114 if err != nil {
115 t.Errorf("Error creating subscription in %T: %+v\n", store, err)
116 }
117 }
118 }
120 func TestUpdateSubscription(t *testing.T) {
121 variations := 1 << 7
122 sub := Subscription{
123 ID: uuid.NewID(),
124 UserID: uuid.NewID(),
125 StripeCustomer: "default",
126 Amount: -1,
127 Period: MonthlyPeriod,
128 Created: time.Now().Add(time.Hour * -24),
129 BeginCharging: time.Now().Add(time.Hour * -24),
130 LastCharged: time.Now().Add(time.Hour * -24),
131 LastNotified: time.Now().Add(time.Hour * -24),
132 InLockout: true,
133 }
134 sub2 := Subscription{
135 ID: uuid.NewID(),
136 UserID: uuid.NewID(),
137 StripeCustomer: "stripeCustomer2",
138 Amount: -2,
139 Period: MonthlyPeriod,
140 Created: time.Now(),
141 BeginCharging: time.Now(),
142 LastCharged: time.Now(),
143 LastNotified: time.Now(),
144 InLockout: false,
145 }
147 for i := 1; i < variations; i++ {
148 var stripeCustomer string
149 var amount int
150 var inLockout bool
151 var per period
152 var beginCharging, lastCharged, lastNotified time.Time
154 change := SubscriptionChange{}
155 empty := change.IsEmpty()
156 if !empty {
157 t.Errorf("Expected empty to be %t, was %t\n", true, empty)
158 }
159 expectation := sub
160 result := sub
161 strI := strconv.Itoa(i)
163 if i&subscriptionChangeStripeCustomer != 0 {
164 stripeCustomer = "stripeCustomer-" + strI
165 change.StripeCustomer = &stripeCustomer
166 expectation.StripeCustomer = stripeCustomer
167 }
169 if i&subscriptionChangeAmount != 0 {
170 amount = i
171 change.Amount = &amount
172 expectation.Amount = amount
173 }
175 if i&subscriptionChangePeriod != 0 {
176 per = period("period-" + strI)
177 change.Period = &per
178 expectation.Period = per
179 }
181 if i&subscriptionChangeBeginCharging != 0 {
182 beginCharging = time.Now().Add(time.Hour * time.Duration(i))
183 change.BeginCharging = &beginCharging
184 expectation.BeginCharging = beginCharging
185 }
187 if i&subscriptionChangeLastCharged != 0 {
188 lastCharged = time.Now().Add(time.Hour * time.Duration(i))
189 change.LastCharged = &lastCharged
190 expectation.LastCharged = lastCharged
191 }
193 if i&subscriptionChangeLastNotified != 0 {
194 lastNotified = time.Now().Add(time.Hour * time.Duration(i))
195 change.LastNotified = &lastNotified
196 expectation.LastNotified = lastNotified
197 }
199 if i&subscriptionChangeInLockout != 0 {
200 inLockout = i%2 == 0
201 change.InLockout = &inLockout
202 expectation.InLockout = inLockout
203 }
205 empty = change.IsEmpty()
206 if empty {
207 t.Errorf("Expected empty to be %t, was %t\n", false, empty)
208 }
210 result.ApplyChange(change)
211 match, field, expected, got := compareSubscriptions(expectation, result)
212 if !match {
213 t.Errorf("Expected field `%s` to be `%v`, got `%v`\n", field, expected, got)
214 }
215 for _, store := range testSubscriptionStores {
216 err := store.reset()
217 if err != nil {
218 t.Fatalf("Error resetting %T: %+v\n", store, err)
219 }
220 err = store.createSubscription(sub)
221 if err != nil {
222 t.Fatalf("Error saving subscription in %T: %s\n", store, err)
223 }
224 err = store.updateSubscription(sub.ID, change)
225 if err != nil {
226 t.Errorf("Error updating subscription in %T: %s\n", store, err)
227 }
228 retrieved, err := store.getSubscriptions([]uuid.ID{sub.ID})
229 if err != nil {
230 t.Errorf("Error getting subscription from %T: %s\n", store, err)
231 }
232 ok, missing := subscriptionMapContains(retrieved, sub)
233 if !ok {
234 t.Errorf("Expected to retrieve %s from %T, but missing was %+v\n", sub.ID.String(), store, missing)
235 }
236 match, field, expected, got = compareSubscriptions(expectation, retrieved[sub.ID.String()])
237 if !match {
238 t.Errorf("Expected field `%s` to be `%v`, got `%v` from %T\n", field, expected, got, store)
239 }
240 }
241 }
242 for _, store := range testSubscriptionStores {
243 err := store.reset()
244 if err != nil {
245 t.Fatalf("Error resetting %T: %+v\n", store, err)
246 }
247 err = store.createSubscription(sub)
248 if err != nil {
249 t.Fatalf("Error saving subscription in %T: %+v\n", store, err)
250 }
251 err = store.createSubscription(sub2)
252 if err != nil {
253 t.Fatalf("Error saving subscription in %T: %+v\n", store, err)
254 }
255 change := SubscriptionChange{}
256 err = store.updateSubscription(sub.ID, change)
257 if err != ErrSubscriptionChangeEmpty {
258 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionChangeEmpty, err, store)
259 }
260 stripeCustomer := sub2.StripeCustomer
261 change.StripeCustomer = &stripeCustomer
262 err = store.updateSubscription(uuid.NewID(), change)
263 if err != ErrSubscriptionNotFound {
264 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
265 }
266 err = store.updateSubscription(sub.ID, change)
267 if err != ErrStripeCustomerAlreadyExists {
268 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrStripeCustomerAlreadyExists, err, store)
269 }
270 }
271 }
273 func TestDeleteSubscription(t *testing.T) {
274 for _, store := range testSubscriptionStores {
275 err := store.reset()
276 if err != nil {
277 t.Fatalf("Error resetting %T: %+v\n", store, err)
278 }
279 sub1 := Subscription{
280 ID: uuid.NewID(),
281 UserID: uuid.NewID(),
282 StripeCustomer: "stripeCustomer1",
283 }
284 sub2 := Subscription{
285 ID: uuid.NewID(),
286 UserID: uuid.NewID(),
287 StripeCustomer: "stripeCustomer2",
288 }
289 err = store.createSubscription(sub1)
290 if err != nil {
291 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
292 }
293 err = store.createSubscription(sub2)
294 if err != nil {
295 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
296 }
297 err = store.deleteSubscription(sub1.ID)
298 if err != nil {
299 t.Fatalf("Error deleting %+v in %T: %+v\n", sub1, store, err)
300 }
301 retrieved, err := store.getSubscriptions([]uuid.ID{sub1.ID, sub2.ID})
302 if err != nil {
303 t.Errorf("Error retrieving subscriptions from %T: %+v\n", store, err)
304 }
305 ok, missing := subscriptionMapContains(retrieved, sub1)
306 if ok {
307 t.Errorf("Expected not to retrieve %s from %T, but missing was %+v\n", sub1.ID.String(), store, missing)
308 }
309 ok, missing = subscriptionMapContains(retrieved, sub2)
310 if !ok {
311 t.Errorf("Expected to retrieve %s from %T, but missing was %+v\n", sub2.ID.String(), store, missing)
312 }
313 _, err = store.getSubscriptionByUser(sub1.UserID)
314 if err != ErrSubscriptionNotFound {
315 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
316 }
317 err = store.deleteSubscription(sub1.ID)
318 if err != ErrSubscriptionNotFound {
319 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
320 }
321 }
322 }
324 func TestListSubscriptionsLastChargedBefore(t *testing.T) {
325 for _, store := range testSubscriptionStores {
326 err := store.reset()
327 if err != nil {
328 t.Fatalf("Error resetting %T: %+v\n", store, err)
329 }
330 sub1 := Subscription{
331 ID: uuid.NewID(),
332 UserID: uuid.NewID(),
333 StripeCustomer: "stripeCustomer1",
334 Amount: 200,
335 Period: MonthlyPeriod,
336 Created: time.Now().Add(time.Hour * -24 * 32),
337 BeginCharging: time.Now().Add(time.Hour * -24),
338 LastCharged: time.Now().Add(time.Hour * -24),
339 }
340 sub2 := Subscription{
341 ID: uuid.NewID(),
342 UserID: uuid.NewID(),
343 StripeCustomer: "stripeCustomer2",
344 Amount: 300,
345 Period: MonthlyPeriod,
346 Created: time.Now().Add(time.Hour * -24 * 61),
347 BeginCharging: time.Now().Add(time.Hour * -24 * 31),
348 LastCharged: time.Now().Add(time.Hour * -24 * 31),
349 }
350 sub3 := Subscription{
351 ID: uuid.NewID(),
352 UserID: uuid.NewID(),
353 StripeCustomer: "stripeCustomer3",
354 Amount: 100,
355 Period: MonthlyPeriod,
356 Created: time.Now().Add(time.Hour * -1),
357 BeginCharging: time.Now().Add(time.Hour * 31),
358 LastCharged: time.Time{},
359 }
360 err = store.createSubscription(sub1)
361 if err != nil {
362 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
363 }
364 err = store.createSubscription(sub2)
365 if err != nil {
366 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
367 }
368 err = store.createSubscription(sub3)
369 if err != nil {
370 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
371 }
372 t.Logf("sub1: %+v\n", sub1)
373 t.Logf("sub2: %+v\n", sub2)
374 t.Logf("sub3: %+v\n", sub3)
375 // subscriptions last charged before right now
376 // should be sub1, sub2, and sub3
377 results, err := store.listSubscriptionsLastChargedBefore(time.Now())
378 if err != nil {
379 t.Errorf("Unexpected error listing subscriptions in %T: %+v\n", store, err)
380 }
381 if len(results) != 3 {
382 t.Errorf("Expected three results from %T, got %+v\n", store, results)
383 }
384 ok, field, expected, result := compareSubscriptions(sub3, results[0])
385 if !ok {
386 t.Errorf("Expected %s in pos 0 to be %+v, got %+v from %T", field, expected, result, store)
387 }
388 ok, field, expected, result = compareSubscriptions(sub2, results[1])
389 if !ok {
390 t.Errorf("Expected %s in pos 1 to be %+v, got %+v from %T", field, expected, result, store)
391 }
392 ok, field, expected, result = compareSubscriptions(sub1, results[2])
393 if !ok {
394 t.Errorf("Expected %s in pos 2 to be %+v, got %+v from %T", field, expected, result, store)
395 }
396 // subscriptions last charged before a week ago
397 // should be sub2, sub3
398 results, err = store.listSubscriptionsLastChargedBefore(time.Now().Add(time.Hour * -24 * 7))
399 if err != nil {
400 t.Errorf("Unexpected error listing subscriptions in %T: %+v\n", store, err)
401 }
402 if len(results) != 2 {
403 t.Errorf("Expected two results from %T, got %+v\n", store, results)
404 }
405 ok, field, expected, result = compareSubscriptions(sub3, results[0])
406 if !ok {
407 t.Errorf("Expected %s in pos 0 to be %+v, got %+v from %T", field, expected, result, store)
408 }
409 ok, field, expected, result = compareSubscriptions(sub2, results[1])
410 if !ok {
411 t.Errorf("Expected %s in pos 1 to be %+v, got %+v from %T", field, expected, result, store)
412 }
413 // subscriptions last charged before 32 days ago
414 // should be sub3
415 results, err = store.listSubscriptionsLastChargedBefore(time.Now().Add(time.Hour * -24 * 32))
416 if err != nil {
417 t.Errorf("Unexpected error listing subscriptions in %T: %+v\n", store, err)
418 }
419 if len(results) != 1 {
420 t.Errorf("Expected one result from %T, got %+v\n", store, results)
421 }
422 ok, field, expected, result = compareSubscriptions(sub3, results[0])
423 if !ok {
424 t.Errorf("Expected %s in pos 0 to be %+v, got %+v from %T", field, expected, result, store)
425 }
426 }
427 }
429 func TestGetSubscriptions(t *testing.T) {
430 for _, store := range testSubscriptionStores {
431 err := store.reset()
432 if err != nil {
433 t.Fatalf("Error resetting %T: %+v\n", store, err)
434 }
435 sub1 := Subscription{
436 ID: uuid.NewID(),
437 UserID: uuid.NewID(),
438 StripeCustomer: "stripeCustomer1",
439 Amount: 200,
440 Period: MonthlyPeriod,
441 Created: time.Now(),
442 BeginCharging: time.Now().Add(time.Hour),
443 }
444 sub2 := Subscription{
445 ID: uuid.NewID(),
446 UserID: uuid.NewID(),
447 StripeCustomer: "stripeCustomer2",
448 Amount: 300,
449 Period: MonthlyPeriod,
450 Created: time.Now().Add(time.Hour * -720),
451 BeginCharging: time.Now().Add(time.Hour*-720 + time.Hour*2),
452 LastCharged: time.Now(),
453 }
454 sub3 := Subscription{
455 ID: uuid.NewID(),
456 UserID: uuid.NewID(),
457 StripeCustomer: "stripeCustomer3",
458 Amount: 100,
459 Period: MonthlyPeriod,
460 Created: time.Now().Add(time.Hour * -1440),
461 BeginCharging: time.Now().Add(time.Hour * -1440),
462 LastNotified: time.Now().Add(time.Hour * -720),
463 InLockout: true,
464 }
465 err = store.createSubscription(sub1)
466 if err != nil {
467 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
468 }
469 err = store.createSubscription(sub2)
470 if err != nil {
471 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
472 }
473 err = store.createSubscription(sub3)
474 if err != nil {
475 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
476 }
477 retrieved, err := store.getSubscriptions([]uuid.ID{})
478 if err != ErrNoSubscriptionID {
479 t.Errorf("Error retrieving no subscriptions from %T. Expected %+v, got %+v\n", store, ErrNoSubscriptionID, err)
480 }
481 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.ID})
482 if err != nil {
483 t.Errorf("Error retrieving %s from %T: %+v\n", sub1.ID, store, err)
484 }
485 ok, missing := subscriptionMapContains(retrieved, sub1)
486 if !ok {
487 t.Logf("Results: %+v\n", retrieved)
488 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
489 }
490 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.ID, sub2.ID})
491 if err != nil {
492 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub1.ID, sub2.ID, store, err)
493 }
494 ok, missing = subscriptionMapContains(retrieved, sub1, sub2)
495 if !ok {
496 t.Logf("Results: %+v\n", retrieved)
497 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
498 }
499 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.ID, sub3.ID})
500 if err != nil {
501 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub1.ID, sub3.ID, store, err)
502 }
503 ok, missing = subscriptionMapContains(retrieved, sub1, sub3)
504 if !ok {
505 t.Logf("Results: %+v\n", retrieved)
506 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
507 }
508 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.ID, sub2.ID, sub3.ID})
509 if err != nil {
510 t.Errorf("Error retrieving %s, %s, and %s from %T: %+v\n", sub1.ID, sub2.ID, sub3.ID, store, err)
511 }
512 ok, missing = subscriptionMapContains(retrieved, sub1, sub2, sub3)
513 if !ok {
514 t.Logf("Results: %+v\n", retrieved)
515 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
516 }
517 retrieved, err = store.getSubscriptions([]uuid.ID{sub2.ID})
518 if err != nil {
519 t.Errorf("Error retrieving %s from %T: %+v\n", sub2.ID, store, err)
520 }
521 ok, missing = subscriptionMapContains(retrieved, sub2)
522 if !ok {
523 t.Logf("Results: %+v\n", retrieved)
524 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
525 }
526 retrieved, err = store.getSubscriptions([]uuid.ID{sub2.ID, sub3.ID})
527 if err != nil {
528 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub2.ID, sub3.ID, store, err)
529 }
530 ok, missing = subscriptionMapContains(retrieved, sub2, sub3)
531 if !ok {
532 t.Logf("Results: %+v\n", retrieved)
533 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
534 }
535 retrieved, err = store.getSubscriptions([]uuid.ID{sub3.ID})
536 if err != nil {
537 t.Errorf("Error retrieving %s from %T: %+v\n", sub3.ID, store, err)
538 }
539 ok, missing = subscriptionMapContains(retrieved, sub3)
540 if !ok {
541 t.Logf("Results: %+v\n", retrieved)
542 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
543 }
544 retrieved, err = store.getSubscriptions([]uuid.ID{uuid.NewID()})
545 if err != nil {
546 t.Errorf("Error retrieving non-existent ID from %T: %+v\n", store, err)
547 }
548 if len(retrieved) != 0 {
549 t.Errorf("Expected no results, %T returned %+v\n", store, retrieved)
550 }
551 retrieved, err = store.getSubscriptions([]uuid.ID{sub1.ID, sub2.ID, uuid.NewID(), sub3.ID})
552 if err != nil {
553 t.Errorf("Error retrieving non-existent ID from %T: %+v\n", store, err)
554 }
555 if len(retrieved) != 3 {
556 t.Errorf("Expected 3 results, %T returned %+v\n", store, retrieved)
557 }
558 ok, missing = subscriptionMapContains(retrieved, sub1, sub2, sub3)
559 if !ok {
560 t.Logf("Results: %+v\n", retrieved)
561 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
562 }
563 }
564 }
566 func TestGetSubscriptionByUser(t *testing.T) {
567 for _, store := range testSubscriptionStores {
568 err := store.reset()
569 if err != nil {
570 t.Fatalf("Error resetting %T: %+v\n", store, err)
571 }
572 sub1 := Subscription{
573 ID: uuid.NewID(),
574 UserID: uuid.NewID(),
575 StripeCustomer: "stripeCustomer1",
576 }
577 sub2 := Subscription{
578 ID: uuid.NewID(),
579 UserID: uuid.NewID(),
580 StripeCustomer: "stripeCustomer2",
581 }
582 sub3 := Subscription{
583 ID: uuid.NewID(),
584 UserID: uuid.NewID(),
585 StripeCustomer: "stripeCustomer3",
586 }
587 err = store.createSubscription(sub1)
588 if err != nil {
589 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
590 }
591 err = store.createSubscription(sub2)
592 if err != nil {
593 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
594 }
595 err = store.createSubscription(sub3)
596 if err != nil {
597 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
598 }
599 retrieved, err := store.getSubscriptionByUser(sub1.UserID)
600 if err != nil {
601 t.Errorf("Error retrieving subscription %+v from %T: %+v\n", sub1, store, err)
602 }
603 ok, field, expected, result := compareSubscriptions(sub1, retrieved)
604 if !ok {
605 t.Errorf("Expected %s to be %+v, but was %+v in %T\n", field, expected, result, store)
606 }
607 retrieved, err = store.getSubscriptionByUser(sub2.UserID)
608 if err != nil {
609 t.Errorf("Error retrieving subscription %+v from %T: %+v\n", sub2, store, err)
610 }
611 ok, field, expected, result = compareSubscriptions(sub2, retrieved)
612 if !ok {
613 t.Errorf("Expected %s to be %+v, but was %+v in %T\n", field, expected, result, store)
614 }
615 retrieved, err = store.getSubscriptionByUser(sub3.UserID)
616 if err != nil {
617 t.Errorf("Error retrieving subscription %+v from %T: %+v\n", sub3, store, err)
618 }
619 ok, field, expected, result = compareSubscriptions(sub3, retrieved)
620 if !ok {
621 t.Errorf("Expected %s to be %+v, but was %+v in %T\n", field, expected, result, store)
622 }
623 retrieved, err = store.getSubscriptionByUser(uuid.NewID())
624 if err != ErrSubscriptionNotFound {
625 t.Errorf("Expected err to be %+v, got %+v from %T\n", ErrSubscriptionNotFound, err, store)
626 }
627 }
628 }