ducky/subscriptions
ducky/subscriptions/subscription_store_test.go
Make it possible to create a user without payment details. We want a new subscription flow, in which the system (not the user) is responsible for creating a subscription when a new profile is created. This is to prevent issues where a user has an account, but no subscription. This is bad because the free trial starts ticking from the day the subscription is created, so we should try to make the subscription and account creation get created as close to each other as possible. Our plan is to instead have the authd service fire off an NSQ event when an auth.Profile is created, which a subscription listener will be listening for. When that happens, the listener will use the subscription API to create a subscription. Then the user will update the subscription with their payment info and the plan they want to use. To accomplish this, we changed the way things were handled. The SubscriptionRequest type, along with its Validate method, were removed. Instead, we get the SubscriptionChange type which handles both the creation of a subscription and the updating of a subscription. We also added an endpoint for patching subscriptions, useful for adding the StripeSubscription or updating the plan. By default, every subscription is created with a "Pending" plan which has a 31 day free trial. This is so we can detect users that haven't actually set up their subscription yet, but their free trial is still timed correctly. We changed the way we handle scopes, creating actual auth.Scope instances instead of just declaring an ID for them. This is useful when we have a client, for example. With this change, we lose all the validation we had on creating a Subscription, and we need to rewrite that validation logic. This is because we no longer have a specific type for "creating a subscription", so we can't just call a validate method. We should have a helper method validateCreateRequest(change SubscriptionChange) that will return the API errors we want, so it's easier to unit test. We should really be restricting the CreateSubscriptionHandler to ScopeSubscriptionAdmin, anyways, since Subscriptions should only ever be created by the system tools or administrators. We created a PatchSubscriptionHandler that exposes an interface to updating properties of a Subscription. It allows users to update their own Subscriptions or requires the ScopeSubscriptionAdmin scope before allowing you to update another user's Subscription. It, likewise, needs validation still. We also added the concept of "system-controlled properties" of the SubscriptionChange type, which only admins or the system tools can update. We updated our planOptions to distinguish between plans that do and do not need administrative credentials to be chosen. Our free and pending plans are available to administrators only. We updated our StripeChange object to be better organised (separating out the system and user-controlled properties), and we added a StripeSource and Email property, so the Stripe part can be better managed, and all our requests can be made using just this type. This required updating our SubscriptionChange.IsEmpty helper, which has been updated (along with its tests) and it passes all tests. To replace our SubscriptionRequest.Validate helper, we created a ChangingSystemProperties helper (which returns the system-controlled properties being changed as a slice of JSON pointers, fit for use in error messages) and an IsAcceptablePlan helper, which returns true if the plan exists and the user has the authority to select it. We also updated our stripe helpers to remove the CreateStripeSubscription (we create one when we create the customer) and create an UpdateStripeSubscription instead. It does what you'd think it does. We also added some comments to New, so it at least has some notes about how it's meant to be used and why. Now it just creates the customer in stripe, then creates a Subscription based on that customer. We also updated our StripeSubscriptionChange helper to detect when the StripeSubscription property changed.
1 package subscriptions
3 import (
4 "os"
5 "strconv"
6 "testing"
7 "time"
9 "code.secondbit.org/uuid.hg"
10 )
12 const (
13 subscriptionChangeStripeSource = 1 << iota
14 subscriptionChangeEmail
15 subscriptionChangeStripeSubscription
16 subscriptionChangePlan
17 subscriptionChangeStatus
18 subscriptionChangeCanceling
19 subscriptionChangeTrialStart
20 subscriptionChangeTrialEnd
21 subscriptionChangePeriodStart
22 subscriptionChangePeriodEnd
23 subscriptionChangeCanceledAt
24 subscriptionChangeFailedChargeAttempts
25 subscriptionChangeLastFailedCharge
26 subscriptionChangeLastNotified
27 )
29 func init() {
30 if os.Getenv("PG_TEST_DB") != "" {
31 p, err := NewPostgres(os.Getenv("PG_TEST_DB"))
32 if err != nil {
33 panic(err)
34 }
35 testSubscriptionStores = append(testSubscriptionStores, p)
36 }
37 }
39 var testSubscriptionStores = []SubscriptionStore{
40 NewMemstore(),
41 }
43 func compareSubscriptions(sub1, sub2 Subscription) (bool, string, interface{}, interface{}) {
44 if !sub1.UserID.Equal(sub2.UserID) {
45 return false, "UserID", sub1.UserID, sub2.UserID
46 }
47 if sub1.StripeSubscription != sub2.StripeSubscription {
48 return false, "StripeSubscription", sub1.StripeSubscription, sub2.StripeSubscription
49 }
50 if sub1.Plan != sub2.Plan {
51 return false, "Plan", sub1.Plan, sub2.Plan
52 }
53 if sub1.Status != sub2.Status {
54 return false, "Status", sub1.Status, sub2.Status
55 }
56 if sub1.Canceling != sub2.Canceling {
57 return false, "Canceling", sub1.Canceling, sub2.Canceling
58 }
59 if !sub1.Created.Equal(sub2.Created) {
60 return false, "Created", sub1.Created, sub2.Created
61 }
62 if !sub1.TrialStart.Equal(sub2.TrialStart) {
63 return false, "TrialStart", sub1.TrialStart, sub2.TrialStart
64 }
65 if !sub1.TrialEnd.Equal(sub2.TrialEnd) {
66 return false, "TrialEnd", sub1.TrialEnd, sub2.TrialEnd
67 }
68 if !sub1.PeriodStart.Equal(sub2.PeriodStart) {
69 return false, "PeriodStart", sub1.PeriodStart, sub2.PeriodStart
70 }
71 if !sub1.PeriodEnd.Equal(sub2.PeriodEnd) {
72 return false, "PeriodEnd", sub1.PeriodEnd, sub2.PeriodEnd
73 }
74 if !sub1.CanceledAt.Equal(sub2.CanceledAt) {
75 return false, "CanceledAt", sub1.CanceledAt, sub2.CanceledAt
76 }
77 if sub1.FailedChargeAttempts != sub2.FailedChargeAttempts {
78 return false, "FailedChargeAttempts", sub1.FailedChargeAttempts, sub2.FailedChargeAttempts
79 }
80 if !sub1.LastFailedCharge.Equal(sub2.LastFailedCharge) {
81 return false, "LastFailedCharge", sub1.LastFailedCharge, sub2.LastFailedCharge
82 }
83 if !sub1.LastNotified.Equal(sub2.LastNotified) {
84 return false, "LastNotified", sub1.LastNotified, sub2.LastNotified
85 }
86 return true, "", nil, nil
87 }
89 func subscriptionMapContains(subscriptionMap map[string]Subscription, subscriptions ...Subscription) (bool, []Subscription) {
90 var missing []Subscription
91 for _, sub := range subscriptions {
92 if _, ok := subscriptionMap[sub.UserID.String()]; !ok {
93 missing = append(missing, sub)
94 }
95 }
96 if len(missing) > 0 {
97 return false, missing
98 }
99 return true, missing
100 }
102 func compareSubscriptionStats(stat1, stat2 SubscriptionStats) (bool, string, interface{}, interface{}) {
103 if stat1.Number != stat2.Number {
104 return false, "Number", stat1.Number, stat2.Number
105 }
106 if stat1.Canceling != stat2.Canceling {
107 return false, "Canceling", stat1.Canceling, stat2.Canceling
108 }
109 if stat1.Failing != stat2.Failing {
110 return false, "Failing", stat1.Failing, stat2.Failing
111 }
112 if len(stat1.Plans) != len(stat2.Plans) {
113 return false, "Plans", stat1.Plans, stat2.Plans
114 }
115 for key, count := range stat1.Plans {
116 count2, ok := stat2.Plans[key]
117 if !ok {
118 return false, "Plans", stat1.Plans, stat2.Plans
119 }
120 if count != count2 {
121 return false, "Plans", stat1.Plans, stat2.Plans
122 }
123 }
124 return true, "", nil, nil
125 }
127 func TestCreateSubscription(t *testing.T) {
128 for _, store := range testSubscriptionStores {
129 err := store.Reset()
130 if err != nil {
131 t.Fatalf("Error resetting %T: %+v\n", store, err)
132 }
133 customerID := uuid.NewID()
134 sub := Subscription{
135 UserID: customerID,
136 StripeSubscription: "stripeSubscription1",
137 Created: time.Now().Round(time.Millisecond),
138 TrialStart: time.Now().Round(time.Millisecond),
139 TrialEnd: time.Now().Round(time.Millisecond).Add(time.Hour * 24 * 31),
140 }
141 err = store.CreateSubscription(sub)
142 if err != nil {
143 t.Errorf("Error creating subscription in %T: %+v\n", store, err)
144 }
145 retrieved, err := store.GetSubscriptions([]uuid.ID{sub.UserID})
146 if err != nil {
147 t.Errorf("Error retrieving subscription from %T: %+v\n", store, err)
148 }
149 if _, returned := retrieved[sub.UserID.String()]; !returned {
150 t.Errorf("Error retrieving subscription from %T: %s wasn't in the results.", store, sub.UserID)
151 }
152 ok, field, expected, result := compareSubscriptions(sub, retrieved[sub.UserID.String()])
153 if !ok {
154 t.Errorf("Expected %s to be %v, got %v from %T\n", field, expected, result, store)
155 }
156 err = store.CreateSubscription(sub)
157 if err != ErrSubscriptionAlreadyExists {
158 t.Errorf("Unexpected error creating subscription in %T (wanted %+v): %+v\n", store, ErrSubscriptionAlreadyExists, err)
159 }
160 sub.UserID = uuid.NewID()
161 err = store.CreateSubscription(sub)
162 if err != ErrStripeSubscriptionAlreadyExists {
163 t.Errorf("Unexpected error creating subscription in %T (wanted %+v): %#+v\n", store, ErrStripeSubscriptionAlreadyExists, err)
164 }
165 sub.StripeSubscription = "stripeSubscription2"
166 err = store.CreateSubscription(sub)
167 if err != nil {
168 t.Errorf("Error creating subscription in %T: %+v\n", store, err)
169 }
170 }
171 }
173 func TestUpdateSubscription(t *testing.T) {
174 variations := 1 << 14
175 sub := Subscription{
176 UserID: uuid.NewID(),
177 StripeSubscription: "default",
178 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -24 * -32),
179 TrialStart: time.Now().Round(time.Millisecond).Add(time.Hour * -24 * -32),
180 TrialEnd: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
181 LastNotified: time.Now().Round(time.Millisecond).Add(time.Hour * -24),
182 }
183 sub2 := Subscription{
184 UserID: uuid.NewID(),
185 StripeSubscription: "stripeSubscription2",
186 Created: time.Now().Round(time.Millisecond),
187 TrialStart: time.Now().Round(time.Millisecond),
188 TrialEnd: time.Now().Round(time.Millisecond),
189 LastNotified: time.Now().Round(time.Millisecond),
190 }
192 for _, store := range testSubscriptionStores {
193 err := store.Reset()
194 if err != nil {
195 t.Fatalf("Error resetting %T: %+v\n", store, err)
196 }
197 err = store.CreateSubscription(sub)
198 if err != nil {
199 t.Fatalf("Error saving subscription in %T: %s\n", store, err)
200 }
201 for i := 1; i < variations; i++ {
202 var stripeSource, email, stripeSubscription, plan, status string
203 var canceling bool
204 var failedChargeAttempts int
205 var trialStart, trialEnd, periodStart, periodEnd, canceledAt, lastFailedCharge, lastNotified time.Time
207 change := SubscriptionChange{}
208 empty := change.IsEmpty()
209 if !empty {
210 t.Errorf("Expected empty to be %t, was %t\n", true, empty)
211 }
212 result := sub
213 strI := strconv.Itoa(i)
215 if i&subscriptionChangeStripeSource != 0 {
216 stripeSource = "stripeSource-" + strI
217 change.StripeSource = &stripeSource
218 }
220 if i&subscriptionChangeEmail != 0 {
221 email = "email-" + strI
222 change.Email = &email
223 }
225 if i&subscriptionChangeStripeSubscription != 0 {
226 stripeSubscription = "stripeSubscription-" + strI
227 change.StripeSubscription = &stripeSubscription
228 sub.StripeSubscription = stripeSubscription
229 }
231 if i&subscriptionChangePlan != 0 {
232 plan = "plan-" + strI
233 change.Plan = &plan
234 sub.Plan = plan
235 }
237 if i&subscriptionChangeStatus != 0 {
238 status = "status-" + strI
239 change.Status = &status
240 sub.Status = status
241 }
243 if i&subscriptionChangeCanceling != 0 {
244 canceling = i%2 == 0
245 change.Canceling = &canceling
246 sub.Canceling = canceling
247 }
249 if i&subscriptionChangeTrialStart != 0 {
250 trialStart = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
251 change.TrialStart = &trialStart
252 sub.TrialStart = trialStart
253 }
255 if i&subscriptionChangeTrialEnd != 0 {
256 trialEnd = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
257 change.TrialEnd = &trialEnd
258 sub.TrialEnd = trialEnd
259 }
261 if i&subscriptionChangePeriodStart != 0 {
262 periodStart = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
263 change.PeriodStart = &periodStart
264 sub.PeriodStart = periodStart
265 }
267 if i&subscriptionChangePeriodEnd != 0 {
268 periodEnd = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
269 change.PeriodEnd = &periodEnd
270 sub.PeriodEnd = periodEnd
271 }
273 if i&subscriptionChangeCanceledAt != 0 {
274 canceledAt = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
275 change.CanceledAt = &canceledAt
276 sub.CanceledAt = canceledAt
277 }
279 if i&subscriptionChangeFailedChargeAttempts != 0 {
280 failedChargeAttempts = i
281 change.FailedChargeAttempts = &failedChargeAttempts
282 sub.FailedChargeAttempts = failedChargeAttempts
283 }
285 if i&subscriptionChangeLastFailedCharge != 0 {
286 lastFailedCharge = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
287 change.LastFailedCharge = &lastFailedCharge
288 sub.LastFailedCharge = lastFailedCharge
289 }
291 if i&subscriptionChangeLastNotified != 0 {
292 lastNotified = time.Now().Round(time.Millisecond).Add(time.Hour * time.Duration(i))
293 change.LastNotified = &lastNotified
294 sub.LastNotified = lastNotified
295 }
297 empty = change.IsEmpty()
298 if empty {
299 t.Errorf("Expected empty to be %t, was %t\n", false, empty)
300 }
302 result.ApplyChange(change)
303 match, field, expected, got := compareSubscriptions(sub, result)
304 if !match {
305 t.Errorf("Expected field `%s` to be `%v`, got `%v`\n", field, expected, got)
306 }
307 err = store.UpdateSubscription(sub.UserID, change)
308 if err != nil {
309 t.Errorf("Error updating subscription in %T: %s\n", store, err)
310 }
311 retrieved, err := store.GetSubscriptions([]uuid.ID{sub.UserID})
312 if err != nil {
313 t.Errorf("Error getting subscription from %T: %s\n", store, err)
314 }
315 ok, missing := subscriptionMapContains(retrieved, sub)
316 if !ok {
317 t.Errorf("Expected to retrieve %s from %T, but missing was %+v\n", sub.UserID.String(), store, missing)
318 }
319 match, field, expected, got = compareSubscriptions(sub, retrieved[sub.UserID.String()])
320 if !match {
321 t.Errorf("Expected field `%s` to be `%v`, got `%v` from %T\n", field, expected, got, store)
322 }
323 sub = result
324 }
326 err = store.CreateSubscription(sub2)
327 if err != nil {
328 t.Fatalf("Error saving subscription in %T: %+v\n", store, err)
329 }
330 change := SubscriptionChange{}
331 err = store.UpdateSubscription(sub.UserID, change)
332 if err != ErrSubscriptionChangeEmpty {
333 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionChangeEmpty, err, store)
334 }
335 stripeSubscription := sub2.StripeSubscription
336 change.StripeSubscription = &stripeSubscription
337 err = store.UpdateSubscription(uuid.NewID(), change)
338 if err != ErrSubscriptionNotFound {
339 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
340 }
341 err = store.UpdateSubscription(sub.UserID, change)
342 if err != ErrStripeSubscriptionAlreadyExists {
343 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrStripeSubscriptionAlreadyExists, err, store)
344 }
345 }
346 }
348 func TestDeleteSubscription(t *testing.T) {
349 for _, store := range testSubscriptionStores {
350 err := store.Reset()
351 if err != nil {
352 t.Fatalf("Error resetting %T: %+v\n", store, err)
353 }
354 sub1 := Subscription{
355 UserID: uuid.NewID(),
356 StripeSubscription: "stripeSubscription1",
357 }
358 sub2 := Subscription{
359 UserID: uuid.NewID(),
360 StripeSubscription: "stripeSubscription2",
361 }
362 err = store.CreateSubscription(sub1)
363 if err != nil {
364 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
365 }
366 err = store.CreateSubscription(sub2)
367 if err != nil {
368 t.Fatalf("Error creating %+v in %T: %+v\n", sub2, store, err)
369 }
370 err = store.DeleteSubscription(sub1.UserID)
371 if err != nil {
372 t.Fatalf("Error deleting %+v in %T: %+v\n", sub1, store, err)
373 }
374 retrieved, err := store.GetSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID})
375 if err != nil {
376 t.Errorf("Error retrieving subscriptions from %T: %+v\n", store, err)
377 }
378 ok, missing := subscriptionMapContains(retrieved, sub1)
379 if ok {
380 t.Errorf("Expected not to retrieve %s from %T, but missing was %+v\n", sub1.UserID.String(), store, missing)
381 }
382 ok, missing = subscriptionMapContains(retrieved, sub2)
383 if !ok {
384 t.Errorf("Expected to retrieve %s from %T, but missing was %+v\n", sub2.UserID.String(), store, missing)
385 }
386 err = store.DeleteSubscription(sub1.UserID)
387 if err != ErrSubscriptionNotFound {
388 t.Errorf("Expected err to be %+v, but got %+v from %T\n", ErrSubscriptionNotFound, err, store)
389 }
390 }
391 }
393 func TestGetSubscriptions(t *testing.T) {
394 for _, store := range testSubscriptionStores {
395 err := store.Reset()
396 if err != nil {
397 t.Fatalf("Error resetting %T: %+v\n", store, err)
398 }
399 sub1 := Subscription{
400 UserID: uuid.NewID(),
401 StripeSubscription: "stripeSubscription1",
402 Plan: "plan1",
403 Created: time.Now().Round(time.Millisecond),
404 TrialStart: time.Now().Round(time.Millisecond),
405 TrialEnd: time.Now().Round(time.Millisecond).Add(time.Hour * 24 * 32),
406 }
407 sub2 := Subscription{
408 UserID: uuid.NewID(),
409 StripeSubscription: "stripeSubscription2",
410 Plan: "plan2",
411 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -720),
412 TrialStart: time.Now().Round(time.Millisecond).Add(time.Hour * -720),
413 TrialEnd: time.Now().Round(time.Millisecond),
414 }
415 sub3 := Subscription{
416 UserID: uuid.NewID(),
417 StripeSubscription: "stripeSubscription3",
418 Plan: "plan3",
419 Created: time.Now().Round(time.Millisecond).Add(time.Hour * -1440),
420 TrialStart: time.Now().Round(time.Millisecond).Add(time.Hour * -1440),
421 TrialEnd: time.Now().Round(time.Millisecond).Add(time.Hour * -720),
422 PeriodStart: time.Now().Round(time.Millisecond).Add(time.Hour * -720),
423 PeriodEnd: time.Now().Round(time.Millisecond),
424 Status: "unpaid",
425 }
426 err = store.CreateSubscription(sub1)
427 if err != nil {
428 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
429 }
430 err = store.CreateSubscription(sub2)
431 if err != nil {
432 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
433 }
434 err = store.CreateSubscription(sub3)
435 if err != nil {
436 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
437 }
438 retrieved, err := store.GetSubscriptions([]uuid.ID{})
439 if err != ErrNoSubscriptionID {
440 t.Errorf("Error retrieving no subscriptions from %T. Expected %+v, got %+v\n", store, ErrNoSubscriptionID, err)
441 }
442 retrieved, err = store.GetSubscriptions([]uuid.ID{sub1.UserID})
443 if err != nil {
444 t.Errorf("Error retrieving %s from %T: %+v\n", sub1.UserID, store, err)
445 }
446 ok, missing := subscriptionMapContains(retrieved, sub1)
447 if !ok {
448 t.Logf("Results: %+v\n", retrieved)
449 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
450 }
451 retrieved, err = store.GetSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID})
452 if err != nil {
453 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub1.UserID, sub2.UserID, store, err)
454 }
455 ok, missing = subscriptionMapContains(retrieved, sub1, sub2)
456 if !ok {
457 t.Logf("Results: %+v\n", retrieved)
458 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
459 }
460 retrieved, err = store.GetSubscriptions([]uuid.ID{sub1.UserID, sub3.UserID})
461 if err != nil {
462 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub1.UserID, sub3.UserID, store, err)
463 }
464 ok, missing = subscriptionMapContains(retrieved, sub1, sub3)
465 if !ok {
466 t.Logf("Results: %+v\n", retrieved)
467 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
468 }
469 retrieved, err = store.GetSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID, sub3.UserID})
470 if err != nil {
471 t.Errorf("Error retrieving %s, %s, and %s from %T: %+v\n", sub1.UserID, sub2.UserID, sub3.UserID, store, err)
472 }
473 ok, missing = subscriptionMapContains(retrieved, sub1, sub2, sub3)
474 if !ok {
475 t.Logf("Results: %+v\n", retrieved)
476 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
477 }
478 retrieved, err = store.GetSubscriptions([]uuid.ID{sub2.UserID})
479 if err != nil {
480 t.Errorf("Error retrieving %s from %T: %+v\n", sub2.UserID, store, err)
481 }
482 ok, missing = subscriptionMapContains(retrieved, sub2)
483 if !ok {
484 t.Logf("Results: %+v\n", retrieved)
485 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
486 }
487 retrieved, err = store.GetSubscriptions([]uuid.ID{sub2.UserID, sub3.UserID})
488 if err != nil {
489 t.Errorf("Error retrieving %s and %s from %T: %+v\n", sub2.UserID, sub3.UserID, store, err)
490 }
491 ok, missing = subscriptionMapContains(retrieved, sub2, sub3)
492 if !ok {
493 t.Logf("Results: %+v\n", retrieved)
494 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
495 }
496 retrieved, err = store.GetSubscriptions([]uuid.ID{sub3.UserID})
497 if err != nil {
498 t.Errorf("Error retrieving %s from %T: %+v\n", sub3.UserID, store, err)
499 }
500 ok, missing = subscriptionMapContains(retrieved, sub3)
501 if !ok {
502 t.Logf("Results: %+v\n", retrieved)
503 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
504 }
505 retrieved, err = store.GetSubscriptions([]uuid.ID{uuid.NewID()})
506 if err != nil {
507 t.Errorf("Error retrieving non-existent ID from %T: %+v\n", store, err)
508 }
509 if len(retrieved) != 0 {
510 t.Errorf("Expected no results, %T returned %+v\n", store, retrieved)
511 }
512 retrieved, err = store.GetSubscriptions([]uuid.ID{sub1.UserID, sub2.UserID, uuid.NewID(), sub3.UserID})
513 if err != nil {
514 t.Errorf("Error retrieving non-existent ID from %T: %+v\n", store, err)
515 }
516 if len(retrieved) != 3 {
517 t.Errorf("Expected 3 results, %T returned %+v\n", store, retrieved)
518 }
519 ok, missing = subscriptionMapContains(retrieved, sub1, sub2, sub3)
520 if !ok {
521 t.Logf("Results: %+v\n", retrieved)
522 t.Errorf("Expected %+v to be in the results, was not for %T.\n", missing, store)
523 }
524 }
525 }
527 func TestGetSubscriptionStats(t *testing.T) {
528 for _, store := range testSubscriptionStores {
529 err := store.Reset()
530 if err != nil {
531 t.Fatalf("Error resetting %T: %+v\n", store, err)
532 }
533 sub1 := Subscription{
534 UserID: uuid.NewID(),
535 StripeSubscription: "stripeSubscription1",
536 Plan: "plan1",
537 Canceling: true,
538 }
539 sub2 := Subscription{
540 UserID: uuid.NewID(),
541 StripeSubscription: "stripeSubscription2",
542 Plan: "plan2",
543 Status: "past_due",
544 }
545 err = store.CreateSubscription(sub1)
546 if err != nil {
547 t.Fatalf("Error creating %+v in %T: %+v\n", sub1, store, err)
548 }
549 stats, err := store.GetSubscriptionStats()
550 if err != nil {
551 t.Errorf("Error getting stats from %T: %+v\n", store, err)
552 }
553 ok, field, expected, results := compareSubscriptionStats(SubscriptionStats{
554 Number: 1,
555 Canceling: 1,
556 Failing: 0,
557 Plans: map[string]int64{
558 "plan1": 1,
559 },
560 }, stats)
561 if !ok {
562 t.Errorf("Expected %s to be %+v, got %+v from %T\n", field, expected, results, store)
563 }
564 err = store.CreateSubscription(sub2)
565 if err != nil {
566 t.Fatalf("Error creating %+v in %T: %+v\n", sub2, store, err)
567 }
568 stats, err = store.GetSubscriptionStats()
569 if err != nil {
570 t.Errorf("Error getting status from %T: %+v\n", store, err)
571 }
572 ok, field, expected, results = compareSubscriptionStats(SubscriptionStats{
573 Number: 2,
574 Canceling: 1,
575 Failing: 1,
576 Plans: map[string]int64{
577 "plan1": 1,
578 "plan2": 1,
579 },
580 }, stats)
581 if !ok {
582 t.Errorf("Expected %s to be %+v, got %+v from %T\n", field, expected, results, store)
583 }
584 err = store.DeleteSubscription(sub1.UserID)
585 if err != nil {
586 t.Errorf("Error deleting subscription from %T: %+v\n", store, err)
587 }
588 stats, err = store.GetSubscriptionStats()
589 if err != nil {
590 t.Errorf("Error getting status from %T: %+v\n", store, err)
591 }
592 ok, field, expected, results = compareSubscriptionStats(SubscriptionStats{
593 Number: 1,
594 Canceling: 0,
595 Failing: 1,
596 Plans: map[string]int64{
597 "plan2": 1,
598 },
599 }, stats)
600 if !ok {
601 t.Errorf("Expected %s to be %+v, got %+v from %T\n", field, expected, results, store)
602 }
603 }
604 }