Skip to content

There can be more than Notion and Miro. AFFiNE(pronounced [ə‘fain]) is a next-gen knowledge base that brings planning, sorting and creating all together. Privacy first, open-source, customizable and ready to use.

test(server): payment tests (#6737)

forehalof566457dcf7d
diff --git a/packages/backend/server/src/plugins/payment/schedule.ts b/packages/backend/server/src/plugins/payment/schedule.ts
index 7a2439580e..0f9c744fde 100644
--- a/packages/backend/server/src/plugins/payment/schedule.ts
+++ b/packages/backend/server/src/plugins/payment/schedule.ts
@@ -197,7 +197,7 @@ export class ScheduleManager {
throw new Error('Unexpected subscription schedule status');
}
- // if current phase's plan matches target, and no coupon change, just release the schedule
+ // if current phase's plan matches target, just release the schedule
if (this.currentPhase.items[0].price === price) {
await this.stripe.subscriptionSchedules.release(this._schedule.id, {
idempotencyKey,
@@ -221,13 +221,8 @@ export class ScheduleManager {
items: [
{
price: price,
- quantity: 1,
},
],
- coupon:
- typeof this.currentPhase.coupon === 'string'
- ? this.currentPhase.coupon
- : this.currentPhase.coupon?.id ?? undefined,
},
],
},
diff --git a/packages/backend/server/src/plugins/payment/service.ts b/packages/backend/server/src/plugins/payment/service.ts
index fcdf6881b5..57fff9695c 100644
--- a/packages/backend/server/src/plugins/payment/service.ts
+++ b/packages/backend/server/src/plugins/payment/service.ts
@@ -164,7 +164,7 @@ export class SubscriptionService {
if (currentSubscription) {
throw new BadRequestException(
- `You've already subscripted to the ${plan} plan`
+ `You've already subscribed to the ${plan} plan`
);
}
@@ -181,7 +181,9 @@ export class SubscriptionService {
let discounts: Stripe.Checkout.SessionCreateParams['discounts'] = [];
- if (promotionCode) {
+ if (coupon) {
+ discounts = [{ coupon }];
+ } else if (promotionCode) {
const code = await this.getAvailablePromotionCode(
promotionCode,
customer.stripeCustomerId
@@ -189,8 +191,6 @@ export class SubscriptionService {
if (code) {
discounts = [{ promotion_code: code }];
}
- } else if (coupon) {
- discounts = [{ coupon }];
}
return await this.stripe.checkout.sessions.create(
@@ -241,7 +241,7 @@ export class SubscriptionService {
const subscriptionInDB = user?.subscriptions.find(s => s.plan === plan);
if (!subscriptionInDB) {
- throw new BadRequestException(`You didn't subscript to the ${plan} plan`);
+ throw new BadRequestException(`You didn't subscribe to the ${plan} plan`);
}
if (subscriptionInDB.canceledAt) {
@@ -260,8 +260,7 @@ export class SubscriptionService {
user,
await this.stripe.subscriptions.retrieve(
subscriptionInDB.stripeSubscriptionId
- ),
- false
+ )
);
} else {
// let customer contact support if they want to cancel immediately
@@ -295,7 +294,7 @@ export class SubscriptionService {
const subscriptionInDB = user?.subscriptions.find(s => s.plan === plan);
if (!subscriptionInDB) {
- throw new BadRequestException(`You didn't subscript to the ${plan} plan`);
+ throw new BadRequestException(`You didn't subscribe to the ${plan} plan`);
}
if (!subscriptionInDB.canceledAt) {
@@ -317,8 +316,7 @@ export class SubscriptionService {
user,
await this.stripe.subscriptions.retrieve(
subscriptionInDB.stripeSubscriptionId
- ),
- false
+ )
);
} else {
const subscription = await this.stripe.subscriptions.update(
@@ -351,12 +349,12 @@ export class SubscriptionService {
}
const subscriptionInDB = user?.subscriptions.find(s => s.plan === plan);
if (!subscriptionInDB) {
- throw new BadRequestException(`You didn't subscript to the ${plan} plan`);
+ throw new BadRequestException(`You didn't subscribe to the ${plan} plan`);
}
if (subscriptionInDB.canceledAt) {
throw new BadRequestException(
- 'Your subscription has already been canceled '
+ 'Your subscription has already been canceled'
);
}
@@ -415,7 +413,6 @@ export class SubscriptionService {
@OnEvent('customer.subscription.created')
@OnEvent('customer.subscription.updated')
async onSubscriptionChanges(subscription: Stripe.Subscription) {
- // webhook call may not in sequential order, get the latest status
subscription = await this.stripe.subscriptions.retrieve(subscription.id);
if (subscription.status === 'active') {
const user = await this.retrieveUserFromCustomer(
@@ -432,7 +429,6 @@ export class SubscriptionService {
@OnEvent('customer.subscription.deleted')
async onSubscriptionDeleted(subscription: Stripe.Subscription) {
- subscription = await this.stripe.subscriptions.retrieve(subscription.id);
const user = await this.retrieveUserFromCustomer(
typeof subscription.customer === 'string'
? subscription.customer
@@ -553,16 +549,8 @@ export class SubscriptionService {
private async saveSubscription(
user: User,
- subscription: Stripe.Subscription,
- fromWebhook = true
+ subscription: Stripe.Subscription
): Promise<UserSubscription> {
- // webhook events may not in sequential order
- // always fetch the latest subscription and save
- // see https://stripe.com/docs/webhooks#behaviors
- if (fromWebhook) {
- subscription = await this.stripe.subscriptions.retrieve(subscription.id);
- }
-
const price = subscription.items.data[0].price;
if (!price.lookup_key) {
throw new Error('Unexpected subscription with no key');
@@ -768,13 +756,12 @@ export class SubscriptionService {
});
if (plan === SubscriptionPlan.Pro) {
- const canHaveEADiscount = isEaUser && !subscribed;
+ const canHaveEADiscount =
+ isEaUser && !subscribed && recurring === SubscriptionRecurring.Yearly;
const price = await this.getPrice(
plan,
recurring,
- canHaveEADiscount && recurring === SubscriptionRecurring.Yearly
- ? SubscriptionPriceVariant.EA
- : undefined
+ canHaveEADiscount ? SubscriptionPriceVariant.EA : undefined
);
return {
price,
@@ -788,13 +775,12 @@ export class SubscriptionService {
EarlyAccessType.AI
);
- const canHaveEADiscount = isAIEaUser && !subscribed;
+ const canHaveEADiscount =
+ isAIEaUser && !subscribed && recurring === SubscriptionRecurring.Yearly;
const price = await this.getPrice(
plan,
recurring,
- canHaveEADiscount && recurring === SubscriptionRecurring.Yearly
- ? SubscriptionPriceVariant.EA
- : undefined
+ canHaveEADiscount ? SubscriptionPriceVariant.EA : undefined
);
return {
diff --git a/packages/backend/server/tests/payment/service.spec.ts b/packages/backend/server/tests/payment/service.spec.ts
new file mode 100644
index 0000000000..fca7618f3c
--- /dev/null
+++ b/packages/backend/server/tests/payment/service.spec.ts
@@ -0,0 +1,901 @@
+import { INestApplication } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+import ava, { TestFn } from 'ava';
+import Sinon from 'sinon';
+import Stripe from 'stripe';
+
+import { AppModule } from '../../src/app.module';
+import { CurrentUser } from '../../src/core/auth';
+import { AuthService } from '../../src/core/auth/service';
+import {
+ EarlyAccessType,
+ FeatureManagementService,
+} from '../../src/core/features';
+import { ConfigModule } from '../../src/fundamentals/config';
+import {
+ CouponType,
+ encodeLookupKey,
+ SubscriptionService,
+} from '../../src/plugins/payment/service';
+import {
+ SubscriptionPlan,
+ SubscriptionPriceVariant,
+ SubscriptionRecurring,
+ SubscriptionStatus,
+} from '../../src/plugins/payment/types';
+import { createTestingApp } from '../utils';
+
+const test = ava as TestFn<{
+ u1: CurrentUser;
+ db: PrismaClient;
+ app: INestApplication;
+ service: SubscriptionService;
+ stripe: Stripe;
+ feature: Sinon.SinonStubbedInstance<FeatureManagementService>;
+}>;
+
+test.beforeEach(async t => {
+ const { app } = await createTestingApp({
+ imports: [
+ ConfigModule.forRoot({
+ plugins: {
+ payment: {
+ stripe: {
+ keys: {
+ APIKey: '1',
+ webhookKey: '1',
+ },
+ },
+ },
+ },
+ }),
+ AppModule,
+ ],
+ tapModule: m => {
+ m.overrideProvider(FeatureManagementService).useValue(
+ Sinon.createStubInstance(FeatureManagementService)
+ );
+ },
+ });
+
+ t.context.stripe = app.get(Stripe);
+ t.context.service = app.get(SubscriptionService);
+ t.context.feature = app.get(FeatureManagementService);
+ t.context.db = app.get(PrismaClient);
+ t.context.app = app;
+
+ t.context.u1 = await app.get(AuthService).signUp('u1', '[email protected]', '1');
+ await t.context.db.userStripeCustomer.create({
+ data: {
+ userId: t.context.u1.id,
+ stripeCustomerId: 'cus_1',
+ },
+ });
+});
+
+test.afterEach.always(async t => {
+ await t.context.app.close();
+});
+
+const PRO_MONTHLY = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Monthly}`;
+const PRO_YEARLY = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Yearly}`;
+const PRO_EA_YEARLY = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Yearly}_${SubscriptionPriceVariant.EA}`;
+const AI_YEARLY = `${SubscriptionPlan.AI}_${SubscriptionRecurring.Yearly}`;
+const AI_YEARLY_EA = `${SubscriptionPlan.AI}_${SubscriptionRecurring.Yearly}_${SubscriptionPriceVariant.EA}`;
+
+const PRICES = {
+ [PRO_MONTHLY]: {
+ recurring: {
+ interval: 'month',
+ },
+ unit_amount: 799,
+ currency: 'usd',
+ lookup_key: PRO_MONTHLY,
+ },
+ [PRO_YEARLY]: {
+ recurring: {
+ interval: 'year',
+ },
+ unit_amount: 8100,
+ currency: 'usd',
+ lookup_key: PRO_YEARLY,
+ },
+ [PRO_EA_YEARLY]: {
+ recurring: {
+ interval: 'year',
+ },
+ unit_amount: 5000,
+ currency: 'usd',
+ lookup_key: PRO_EA_YEARLY,
+ },
+ [AI_YEARLY]: {
+ recurring: {
+ interval: 'year',
+ },
+ unit_amount: 10680,
+ currency: 'usd',
+ lookup_key: AI_YEARLY,
+ },
+ [AI_YEARLY_EA]: {
+ recurring: {
+ interval: 'year',
+ },
+ unit_amount: 9999,
+ currency: 'usd',
+ lookup_key: AI_YEARLY_EA,
+ },
+};
+
+const sub: Stripe.Subscription = {
+ id: 'sub_1',
+ object: 'subscription',
+ cancel_at_period_end: false,
+ canceled_at: null,
+ current_period_end: 1745654236,
+ current_period_start: 1714118236,
+ customer: 'cus_1',
+ items: {
+ object: 'list',
+ data: [
+ {
+ id: 'si_1',
+ // @ts-expect-error stub
+ price: {
+ id: 'price_1',
+ lookup_key: 'pro_monthly',
+ },
+ subscription: 'sub_1',
+ },
+ ],
+ },
+ status: 'active',
+ trial_end: null,
+ trial_start: null,
+ schedule: null,
+};
+
+// ============== prices ==============
+test('should list normal price for unauthenticated user', async t => {
+ const { service, stripe } = t.context;
+
+ // @ts-expect-error stub
+ Sinon.stub(stripe.subscriptions, 'list').resolves({ data: [] });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices();
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_YEARLY, AI_YEARLY])
+ );
+});
+
+test('should list normal prices for authenticated user', async t => {
+ const { feature, service, u1, stripe } = t.context;
+
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(false);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(false);
+
+ // @ts-expect-error stub
+ Sinon.stub(stripe.subscriptions, 'list').resolves({ data: [] });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices(u1);
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_YEARLY, AI_YEARLY])
+ );
+});
+
+test('should list early access prices for pro ea user', async t => {
+ const { feature, service, u1, stripe } = t.context;
+
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(true);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(false);
+
+ // @ts-expect-error stub
+ Sinon.stub(stripe.subscriptions, 'list').resolves({ data: [] });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices(u1);
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_EA_YEARLY, AI_YEARLY])
+ );
+});
+
+test('should list normal prices for pro ea user with old subscriptions', async t => {
+ const { feature, service, u1, stripe } = t.context;
+
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(true);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(false);
+
+ Sinon.stub(stripe.subscriptions, 'list').resolves({
+ data: [
+ {
+ id: 'sub_1',
+ status: 'canceled',
+ items: {
+ data: [
+ {
+ // @ts-expect-error stub
+ price: {
+ lookup_key: PRO_YEARLY,
+ },
+ },
+ ],
+ },
+ },
+ ],
+ });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices(u1);
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_YEARLY, AI_YEARLY])
+ );
+});
+
+test('should list early access prices for ai ea user', async t => {
+ const { feature, service, u1, stripe } = t.context;
+
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(false);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(true);
+
+ // @ts-expect-error stub
+ Sinon.stub(stripe.subscriptions, 'list').resolves({ data: [] });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices(u1);
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_YEARLY, AI_YEARLY_EA])
+ );
+});
+
+test('should list early access prices for pro and ai ea user', async t => {
+ const { feature, service, u1, stripe } = t.context;
+
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(true);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(true);
+
+ // @ts-expect-error stub
+ Sinon.stub(stripe.subscriptions, 'list').resolves({ data: [] });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices(u1);
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_EA_YEARLY, AI_YEARLY_EA])
+ );
+});
+
+test('should list normal prices for ai ea user with old subscriptions', async t => {
+ const { feature, service, u1, stripe } = t.context;
+
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(false);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(true);
+
+ Sinon.stub(stripe.subscriptions, 'list').resolves({
+ data: [
+ {
+ id: 'sub_1',
+ status: 'canceled',
+ items: {
+ data: [
+ {
+ // @ts-expect-error stub
+ price: {
+ lookup_key: AI_YEARLY,
+ },
+ },
+ ],
+ },
+ },
+ ],
+ });
+ // @ts-expect-error stub
+ Sinon.stub(stripe.prices, 'list').resolves({ data: Object.values(PRICES) });
+
+ const prices = await service.listPrices(u1);
+
+ t.is(prices.length, 3);
+ t.deepEqual(
+ new Set(prices.map(p => p.lookup_key)),
+ new Set([PRO_MONTHLY, PRO_YEARLY, AI_YEARLY])
+ );
+});
+
+// ============= end prices ================
+
+// ============= checkout ==================
+test('should throw if user has subscription already', async t => {
+ const { service, u1, db } = t.context;
+
+ await db.userSubscription.create({
+ data: {
+ userId: u1.id,
+ stripeSubscriptionId: 'sub_1',
+ plan: SubscriptionPlan.Pro,
+ recurring: SubscriptionRecurring.Monthly,
+ status: SubscriptionStatus.Active,
+ start: new Date(),
+ end: new Date(),
+ },
+ });
+
+ await t.throwsAsync(
+ () =>
+ service.createCheckoutSession({
+ user: u1,
+ recurring: SubscriptionRecurring.Monthly,
+ plan: SubscriptionPlan.Pro,
+ redirectUrl: '',
+ idempotencyKey: '',
+ }),
+ { message: "You've already subscribed to the pro plan" }
+ );
+});
+
+test('should get correct pro plan price for checking out', async t => {
+ const { service, u1, stripe, feature } = t.context;
+
+ const customer = {
+ userId: u1.id,
+ email: u1.email,
+ stripeCustomerId: 'cus_1',
+ createdAt: new Date(),
+ };
+
+ const subListStub = Sinon.stub(stripe.subscriptions, 'list');
+ // @ts-expect-error allow
+ Sinon.stub(service, 'getPrice').callsFake((plan, recurring, variant) => {
+ return encodeLookupKey(plan, recurring, variant);
+ });
+ // @ts-expect-error private member
+ const getAvailablePrice = service.getAvailablePrice.bind(service);
+
+ // non-ea user
+ {
+ feature.isEarlyAccessUser.resolves(false);
+ // @ts-expect-error stub
+ subListStub.resolves({ data: [] });
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.Pro,
+ SubscriptionRecurring.Monthly
+ );
+ t.deepEqual(ret, {
+ price: PRO_MONTHLY,
+ coupon: undefined,
+ });
+ }
+
+ // ea user, but monthly
+ {
+ feature.isEarlyAccessUser.resolves(true);
+ // @ts-expect-error stub
+ subListStub.resolves({ data: [] });
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.Pro,
+ SubscriptionRecurring.Monthly
+ );
+ t.deepEqual(ret, {
+ price: PRO_MONTHLY,
+ coupon: undefined,
+ });
+ }
+
+ // ea user, yearly
+ {
+ feature.isEarlyAccessUser.resolves(true);
+ // @ts-expect-error stub
+ subListStub.resolves({ data: [] });
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.Pro,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: PRO_EA_YEARLY,
+ coupon: CouponType.ProEarlyAccessOneYearFree,
+ });
+ }
+
+ // ea user, yearly recurring, but has old subscription
+ {
+ feature.isEarlyAccessUser.resolves(true);
+ subListStub.resolves({
+ data: [
+ {
+ id: 'sub_1',
+ status: 'canceled',
+ items: {
+ data: [
+ {
+ // @ts-expect-error stub
+ price: {
+ lookup_key: PRO_YEARLY,
+ },
+ },
+ ],
+ },
+ },
+ ],
+ });
+
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.Pro,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: PRO_YEARLY,
+ coupon: undefined,
+ });
+ }
+});
+
+test('should get correct ai plan price for checking out', async t => {
+ const { service, u1, stripe, feature } = t.context;
+
+ const customer = {
+ userId: u1.id,
+ email: u1.email,
+ stripeCustomerId: 'cus_1',
+ createdAt: new Date(),
+ };
+
+ const subListStub = Sinon.stub(stripe.subscriptions, 'list');
+ // @ts-expect-error allow
+ Sinon.stub(service, 'getPrice').callsFake((plan, recurring, variant) => {
+ return encodeLookupKey(plan, recurring, variant);
+ });
+ // @ts-expect-error private member
+ const getAvailablePrice = service.getAvailablePrice.bind(service);
+
+ // non-ea user
+ {
+ feature.isEarlyAccessUser.resolves(false);
+ // @ts-expect-error stub
+ subListStub.resolves({ data: [] });
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.AI,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: AI_YEARLY,
+ coupon: undefined,
+ });
+ }
+
+ // ea user
+ {
+ feature.isEarlyAccessUser.resolves(true);
+ // @ts-expect-error stub
+ subListStub.resolves({ data: [] });
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.AI,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: AI_YEARLY_EA,
+ coupon: CouponType.AIEarlyAccessOneYearFree,
+ });
+ }
+
+ // ea user, but has old subscription
+ {
+ feature.isEarlyAccessUser.resolves(true);
+ subListStub.resolves({
+ data: [
+ {
+ id: 'sub_1',
+ status: 'canceled',
+ items: {
+ data: [
+ {
+ // @ts-expect-error stub
+ price: {
+ lookup_key: AI_YEARLY,
+ },
+ },
+ ],
+ },
+ },
+ ],
+ });
+
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.AI,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: AI_YEARLY,
+ coupon: undefined,
+ });
+ }
+
+ // pro ea user
+ {
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(true);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(false);
+ // @ts-expect-error stub
+ subListStub.resolves({ data: [] });
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.AI,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: AI_YEARLY,
+ coupon: CouponType.ProEarlyAccessAIOneYearFree,
+ });
+ }
+
+ // pro ea user, but has old subscription
+ {
+ feature.isEarlyAccessUser.withArgs(u1.email).resolves(true);
+ feature.isEarlyAccessUser
+ .withArgs(u1.email, EarlyAccessType.AI)
+ .resolves(false);
+ subListStub.resolves({
+ data: [
+ {
+ id: 'sub_1',
+ status: 'canceled',
+ items: {
+ data: [
+ {
+ // @ts-expect-error stub
+ price: {
+ lookup_key: AI_YEARLY,
+ },
+ },
+ ],
+ },
+ },
+ ],
+ });
+
+ const ret = await getAvailablePrice(
+ customer,
+ SubscriptionPlan.AI,
+ SubscriptionRecurring.Yearly
+ );
+ t.deepEqual(ret, {
+ price: AI_YEARLY,
+ coupon: undefined,
+ });
+ }
+});
+
+test('should apply user coupon for checking out', async t => {
+ const { service, u1, stripe } = t.context;
+
+ const checkoutStub = Sinon.stub(stripe.checkout.sessions, 'create');
+ // @ts-expect-error private member
+ Sinon.stub(service, 'getAvailablePrice').resolves({
+ // @ts-expect-error type inference error
+ price: PRO_MONTHLY,
+ coupon: undefined,
+ });
+ // @ts-expect-error private member
+ Sinon.stub(service, 'getAvailablePromotionCode').resolves('promo_1');
+
+ await service.createCheckoutSession({
+ user: u1,
+ recurring: SubscriptionRecurring.Monthly,
+ plan: SubscriptionPlan.Pro,
+ redirectUrl: '',
+ idempotencyKey: '',
+ promotionCode: 'test',
+ });
+
+ t.true(checkoutStub.calledOnce);
+ const arg = checkoutStub.firstCall
+ .args[0] as Stripe.Checkout.SessionCreateParams;
+ t.deepEqual(arg.discounts, [{ promotion_code: 'promo_1' }]);
+});
+
+// =============== subscriptions ===============
+
+test('should be able to create subscription', async t => {
+ const { service, stripe, db, u1 } = t.context;
+
+ Sinon.stub(stripe.subscriptions, 'retrieve').resolves(sub as any);
+ await service.onSubscriptionChanges(sub);
+
+ const subInDB = await db.userSubscription.findFirst({
+ where: { userId: u1.id },
+ });
+
+ t.is(subInDB?.stripeSubscriptionId, sub.id);
+});
+
+test('should be able to update subscription', async t => {
+ const { service, stripe, db, u1 } = t.context;
+
+ const stub = Sinon.stub(stripe.subscriptions, 'retrieve').resolves(
+ sub as any
+ );
+ await service.onSubscriptionChanges(sub);
+
+ let subInDB = await db.userSubscription.findFirst({
+ where: { userId: u1.id },
+ });
+
+ t.is(subInDB?.stripeSubscriptionId, sub.id);
+
+ stub.resolves({
+ ...sub,
+ cancel_at_period_end: true,
+ canceled_at: 1714118236,
+ } as any);
+ await service.onSubscriptionChanges(sub);
+
+ subInDB = await db.userSubscription.findFirst({
+ where: { userId: u1.id },
+ });
+
+ t.is(subInDB?.status, SubscriptionStatus.Active);
+ t.is(subInDB?.canceledAt?.getTime(), 1714118236000);
+});
+
+test('should be able to delete subscription', async t => {
+ const { service, stripe, db, u1 } = t.context;
+
+ const stub = Sinon.stub(stripe.subscriptions, 'retrieve').resolves(
+ sub as any
+ );
+ await service.onSubscriptionChanges(sub);
+
+ let subInDB = await db.userSubscription.findFirst({
+ where: { userId: u1.id },
+ });
+
+ t.is(subInDB?.stripeSubscriptionId, sub.id);
+
+ stub.resolves({ ...sub, status: 'canceled' } as any);
+ await service.onSubscriptionChanges(sub);
+
+ subInDB = await db.userSubscription.findFirst({
+ where: { userId: u1.id },
+ });
+
+ t.is(subInDB, null);
+});
+
+test('should be able to cancel subscription', async t => {
+ const { service, db, u1, stripe } = t.context;
+
+ await db.userSubscription.create({
+ data: {
+ userId: u1.id,
+ stripeSubscriptionId: 'sub_1',
+ plan: SubscriptionPlan.Pro,
+ recurring: SubscriptionRecurring.Yearly,
+ status: SubscriptionStatus.Active,
+ start: new Date(),
+ end: new Date(),
+ },
+ });
+
+ const stub = Sinon.stub(stripe.subscriptions, 'update').resolves({
+ ...sub,
+ cancel_at_period_end: true,
+ canceled_at: 1714118236,
+ } as any);
+
+ const subInDB = await service.cancelSubscription(
+ '',
+ u1.id,
+ SubscriptionPlan.Pro
+ );
+
+ t.true(stub.calledOnceWith('sub_1', { cancel_at_period_end: true }));
+ t.is(subInDB.status, SubscriptionStatus.Active);
+ t.truthy(subInDB.canceledAt);
+});
+
+test('should be able to resume subscription', async t => {
+ const { service, db, u1, stripe } = t.context;
+
+ await db.userSubscription.create({
+ data: {
+ userId: u1.id,
+ stripeSubscriptionId: 'sub_1',
+ plan: SubscriptionPlan.Pro,
+ recurring: SubscriptionRecurring.Yearly,
+ status: SubscriptionStatus.Active,
+ start: new Date(),
+ end: new Date(Date.now() + 100000),
+ canceledAt: new Date(),
+ },
+ });
+
+ const stub = Sinon.stub(stripe.subscriptions, 'update').resolves(sub as any);
+
+ const subInDB = await service.resumeCanceledSubscription(
+ '',
+ u1.id,
+ SubscriptionPlan.Pro
+ );
+
+ t.true(stub.calledOnceWith('sub_1', { cancel_at_period_end: false }));
+ t.is(subInDB.status, SubscriptionStatus.Active);
+ t.falsy(subInDB.canceledAt);
+});
+
+const subscriptionSchedule: Stripe.SubscriptionSchedule = {
+ id: 'sub_sched_1',
+ customer: 'cus_1',
+ subscription: 'sub_1',
+ status: 'active',
+ phases: [
+ {
+ items: [
+ // @ts-expect-error mock
+ {
+ price: PRO_MONTHLY,
+ },
+ ],
+ start_date: 1714118236,
+ end_date: 1745654236,
+ },
+ ],
+};
+
+test('should be able to update recurring', async t => {
+ const { service, db, u1, stripe } = t.context;
+
+ await db.userSubscription.create({
+ data: {
+ userId: u1.id,
+ stripeSubscriptionId: 'sub_1',
+ plan: SubscriptionPlan.Pro,
+ recurring: SubscriptionRecurring.Monthly,
+ status: SubscriptionStatus.Active,
+ start: new Date(),
+ end: new Date(Date.now() + 100000),
+ },
+ });
+
+ // 1. turn a subscription into a subscription schedule
+ // 2. update the schedule
+ // 2.1 update the current phase with an end date
+ // 2.2 add a new phase with a start date
+
+ // @ts-expect-error private member
+ Sinon.stub(service, 'getPrice').resolves(PRO_YEARLY);
+ Sinon.stub(stripe.subscriptions, 'retrieve').resolves(sub as any);
+ Sinon.stub(stripe.subscriptionSchedules, 'create').resolves(
+ subscriptionSchedule as any
+ );
+ const stub = Sinon.stub(stripe.subscriptionSchedules, 'update');
+
+ await service.updateSubscriptionRecurring(
+ '',
+ u1.id,
+ SubscriptionPlan.Pro,
+ SubscriptionRecurring.Yearly
+ );
+
+ t.true(stub.calledOnce);
+ const arg = stub.firstCall.args;
+ t.is(arg[0], subscriptionSchedule.id);
+ t.deepEqual(arg[1], {
+ phases: [
+ {
+ items: [
+ {
+ price: PRO_MONTHLY,
+ },
+ ],
+ start_date: 1714118236,
+ end_date: 1745654236,
+ },
+ {
+ items: [
+ {
+ price: PRO_YEARLY,
+ },
+ ],
+ },
+ ],
+ });
+});
+
+test('should release the schedule if the new recurring is the same as the current phase', async t => {
+ const { service, db, u1, stripe } = t.context;
+
+ await db.userSubscription.create({
+ data: {
+ userId: u1.id,
+ stripeSubscriptionId: 'sub_1',
+ stripeScheduleId: 'sub_sched_1',
+ plan: SubscriptionPlan.Pro,
+ recurring: SubscriptionRecurring.Yearly,
+ status: SubscriptionStatus.Active,
+ start: new Date(),
+ end: new Date(Date.now() + 100000),
+ },
+ });
+
+ // @ts-expect-error private member
+ Sinon.stub(service, 'getPrice').resolves(PRO_MONTHLY);
+ Sinon.stub(stripe.subscriptions, 'retrieve').resolves({
+ ...sub,
+ schedule: subscriptionSchedule,
+ } as any);
+ Sinon.stub(stripe.subscriptionSchedules, 'retrieve').resolves(
+ subscriptionSchedule as any
+ );
+ const stub = Sinon.stub(stripe.subscriptionSchedules, 'release');
+
+ await service.updateSubscriptionRecurring(
+ '',
+ u1.id,
+ SubscriptionPlan.Pro,
+ SubscriptionRecurring.Monthly
+ );
+
+ t.true(stub.calledOnce);
+ t.is(stub.firstCall.args[0], subscriptionSchedule.id);
+});
+
+test('should operate with latest subscription status', async t => {
+ const { service, stripe } = t.context;
+
+ Sinon.stub(stripe.subscriptions, 'retrieve').resolves(sub as any);
+ // @ts-expect-error private member
+ const stub = Sinon.stub(service, 'saveSubscription');
+
+ // latest state come first
+ await service.onSubscriptionChanges(sub);
+ // old state come later
+ await service.onSubscriptionChanges({
+ ...sub,
+ status: 'canceled',
+ });
+
+ t.is(stub.callCount, 2);
+ t.deepEqual(stub.firstCall.args[1], sub);
+ t.deepEqual(stub.secondCall.args[1], sub);
+});