104f84f252
As discussed with the product team we want to enforce kebab-case file names for all files, with the exception of files which export a single class, in which case they should be PascalCase and reflect the class which they export. This will help find classes faster, and should push better naming for them too. Some files and packages have been excluded from this linting, specifically when a library or framework depends on the naming of a file for the functionality e.g. Ember, knex-migrator, adapter-manager
387 lines
16 KiB
JavaScript
387 lines
16 KiB
JavaScript
const knex = require('knex').default;
|
|
const assert = require('assert');
|
|
const SubscriptionStatsService = require('../../lib/SubscriptionStatsService');
|
|
|
|
describe('SubscriptionStatsService', function () {
|
|
describe('getSubscriptionHistory', function () {
|
|
/** @type {import('knex').Knex} */
|
|
let db;
|
|
|
|
beforeEach(async function () {
|
|
db = knex({
|
|
client: 'sqlite3',
|
|
useNullAsDefault: true,
|
|
connection: {
|
|
filename: ':memory:'
|
|
}
|
|
});
|
|
await db.schema.createTable('products', function (table) {
|
|
table.string('id');
|
|
});
|
|
await db.schema.createTable('stripe_products', function (table) {
|
|
table.string('stripe_product_id');
|
|
table.string('product_id');
|
|
});
|
|
await db.schema.createTable('stripe_prices', function (table) {
|
|
table.string('id');
|
|
table.string('stripe_price_id');
|
|
table.string('stripe_product_id');
|
|
table.string('interval');
|
|
});
|
|
await db.schema.createTable('members_paid_subscription_events', function (table) {
|
|
table.string('type');
|
|
table.string('from_plan');
|
|
table.string('to_plan');
|
|
table.integer('mrr_delta');
|
|
table.date('created_at');
|
|
});
|
|
await db.schema.createTable('members_stripe_customers_subscriptions', function (table) {
|
|
table.string('id');
|
|
table.string('stripe_price_id');
|
|
table.integer('mrr');
|
|
});
|
|
});
|
|
|
|
afterEach(async function () {
|
|
await db.destroy();
|
|
});
|
|
|
|
/**
|
|
* @typedef {object} TierCadence
|
|
* @prop {string} tier
|
|
* @prop {string} cadence
|
|
* @prop {number} mrr
|
|
*/
|
|
|
|
/**
|
|
* @typedef {object} MockedTier
|
|
* @prop {TierCadence} monthly
|
|
* @prop {TierCadence} yearly
|
|
**/
|
|
|
|
/**
|
|
* @param {string[]} tiers
|
|
* @returns {Promise<Object<string, MockedTier>>}
|
|
**/
|
|
async function createTiers(tiers) {
|
|
/** @type {Object<string, MockedTier>} */
|
|
const results = {};
|
|
let i = 1;
|
|
for (const tier of tiers) {
|
|
await db('products').insert({id: tier});
|
|
await db('stripe_products').insert({
|
|
product_id: tier,
|
|
stripe_product_id: `stripe_product_${tier}`
|
|
});
|
|
await db('stripe_prices').insert({
|
|
id: `stripe_price_month_${tier}`,
|
|
stripe_price_id: `stripe_price_month_${tier}`,
|
|
stripe_product_id: `stripe_product_${tier}`,
|
|
interval: 'month'
|
|
});
|
|
await db('stripe_prices').insert({
|
|
id: `stripe_price_year_${tier}`,
|
|
stripe_price_id: `stripe_price_year_${tier}`,
|
|
stripe_product_id: `stripe_product_${tier}`,
|
|
interval: 'year'
|
|
});
|
|
results[tier] = {
|
|
monthly: {
|
|
tier: tier,
|
|
cadence: 'month',
|
|
mrr: 100 * i
|
|
},
|
|
yearly: {
|
|
tier: tier,
|
|
cadence: 'year',
|
|
mrr: 80 * i
|
|
}
|
|
};
|
|
i += 1;
|
|
}
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* @typedef {object} FakeEvent
|
|
* @prop {string} id
|
|
* @prop {string} type
|
|
* @prop {string|null} tier
|
|
* @prop {string|null} cadence
|
|
* @prop {number|null} mrr
|
|
**/
|
|
|
|
/**
|
|
* @param {string} type
|
|
* @returns {(id: string, attr?: any) => FakeEvent}
|
|
**/
|
|
const createEvent = type => (id, attr = {}) => Object.assign({tier: null, cadence: null, mrr: null}, attr, {id, type});
|
|
|
|
/**
|
|
* @param {FakeEvent[][]} days
|
|
**/
|
|
async function insertEvents(days) {
|
|
const {DateTime} = require('luxon');
|
|
/** @type {Object<string, FakeEvent[]>}*/
|
|
const subscriptions = {};
|
|
const toInsert = [];
|
|
for (let index = 0; index < days.length; index++) {
|
|
const events = days[index];
|
|
const day = DateTime.fromISO('1970-01-01').plus({days: index}).toISODate();
|
|
toInsert.push(...events.map(function (event) {
|
|
let last = event;
|
|
if (!subscriptions[event.id] || !subscriptions[event.id][0]) {
|
|
subscriptions[event.id] = [event];
|
|
} else {
|
|
last = subscriptions[event.id][0];
|
|
subscriptions[event.id] = [event].concat(subscriptions[event.id]);
|
|
}
|
|
|
|
let fromPlan = null;
|
|
let toPlan = null;
|
|
let mrr = 0;
|
|
|
|
switch (event.type) {
|
|
case 'created':
|
|
fromPlan = null;
|
|
toPlan = `stripe_price_${event.cadence}_${event.tier}`;
|
|
mrr = event.mrr;
|
|
break;
|
|
case 'canceled':
|
|
fromPlan = `stripe_price_${last.cadence}_${last.tier}`;
|
|
toPlan = `stripe_price_${last.cadence}_${last.tier}`;
|
|
mrr = -last.mrr;
|
|
break;
|
|
case 'reactivated':
|
|
fromPlan = `stripe_price_${last.cadence}_${last.tier}`;
|
|
toPlan = `stripe_price_${last.cadence}_${last.tier}`;
|
|
mrr = last.mrr;
|
|
break;
|
|
case 'updated':
|
|
fromPlan = `stripe_price_${last.cadence}_${last.tier}`;
|
|
toPlan = `stripe_price_${event.cadence}_${event.tier}`;
|
|
mrr = event.mrr - last.mrr;
|
|
break;
|
|
}
|
|
|
|
if (!event.tier) {
|
|
event.tier = last.tier;
|
|
}
|
|
|
|
if (!event.cadence) {
|
|
event.cadence = last.cadence;
|
|
}
|
|
|
|
if (!event.mrr) {
|
|
event.mrr = last.mrr;
|
|
}
|
|
|
|
return {
|
|
type: event.type,
|
|
from_plan: fromPlan,
|
|
to_plan: toPlan,
|
|
mrr_delta: mrr,
|
|
created_at: day
|
|
};
|
|
}));
|
|
}
|
|
|
|
await db('members_paid_subscription_events').insert(toInsert);
|
|
|
|
const subscriptionsToInsert = Object.keys(subscriptions).map((id) => {
|
|
const event = subscriptions[id][0];
|
|
let cadence = event.cadence;
|
|
let tier = event.tier;
|
|
if (!event.tier) {
|
|
cadence = subscriptions[id][1].cadence;
|
|
tier = subscriptions[id][1].tier;
|
|
}
|
|
return {
|
|
id,
|
|
stripe_price_id: `stripe_price_${cadence}_${tier}`,
|
|
mrr: event.type !== 'canceled' ? event.mrr : 0
|
|
};
|
|
});
|
|
|
|
await db('members_stripe_customers_subscriptions').insert(subscriptionsToInsert);
|
|
}
|
|
|
|
it('Responds with correct data', async function () {
|
|
const tiers = await createTiers(['basic', 'advanced']);
|
|
|
|
const NEW = createEvent('created');
|
|
const CANCEL = createEvent('canceled');
|
|
|
|
const events = [
|
|
[NEW('A', tiers.basic.monthly), NEW('B', tiers.advanced.yearly)],
|
|
[CANCEL('B'), NEW('C', tiers.advanced.monthly)],
|
|
[CANCEL('A'), NEW('D', tiers.basic.monthly)]
|
|
];
|
|
|
|
await insertEvents(events);
|
|
|
|
const stats = new SubscriptionStatsService({knex: db});
|
|
|
|
const results = await stats.getSubscriptionHistory();
|
|
|
|
/**
|
|
* @param {string} tier
|
|
* @param {string} cadence
|
|
* @param {string} date
|
|
*
|
|
* @returns {(result: import('../../lib/subscriptions').SubscriptionHistoryEntry) => boolean}
|
|
**/
|
|
const finder = (tier, cadence, date) => (result) => {
|
|
return result.tier === tier && result.cadence === cadence && result.date === date;
|
|
};
|
|
|
|
const firstDayBasicMonthly = results.data.find(finder('basic', 'month', '1970-01-01'));
|
|
const firstDayAdvancedYearly = results.data.find(finder('advanced', 'year', '1970-01-01'));
|
|
const secondDayAdvancedYearly = results.data.find(finder('advanced', 'year', '1970-01-02'));
|
|
const secondDayAdvancedMonthly = results.data.find(finder('advanced', 'month', '1970-01-02'));
|
|
const thirdDayBasicMonthly = results.data.find(finder('basic', 'month', '1970-01-03'));
|
|
|
|
assert(firstDayBasicMonthly);
|
|
assert(firstDayBasicMonthly.positive_delta === 1);
|
|
assert(firstDayBasicMonthly.negative_delta === 0);
|
|
assert(firstDayBasicMonthly.signups === 1);
|
|
assert(firstDayBasicMonthly.cancellations === 0);
|
|
assert(firstDayBasicMonthly.count === 1);
|
|
|
|
assert(firstDayAdvancedYearly);
|
|
assert(firstDayAdvancedYearly.positive_delta === 1);
|
|
assert(firstDayAdvancedYearly.negative_delta === 0);
|
|
assert(firstDayAdvancedYearly.signups === 1);
|
|
assert(firstDayAdvancedYearly.cancellations === 0);
|
|
assert(firstDayAdvancedYearly.count === 1);
|
|
|
|
assert(secondDayAdvancedYearly);
|
|
assert(secondDayAdvancedYearly.positive_delta === 0);
|
|
assert(secondDayAdvancedYearly.negative_delta === 1);
|
|
assert(secondDayAdvancedYearly.signups === 0);
|
|
assert(secondDayAdvancedYearly.cancellations === 1);
|
|
assert(secondDayAdvancedYearly.count === 0);
|
|
|
|
assert(secondDayAdvancedMonthly);
|
|
assert(secondDayAdvancedMonthly.positive_delta === 1);
|
|
assert(secondDayAdvancedMonthly.negative_delta === 0);
|
|
assert(secondDayAdvancedMonthly.signups === 1);
|
|
assert(secondDayAdvancedMonthly.cancellations === 0);
|
|
assert(secondDayAdvancedMonthly.count === 1);
|
|
|
|
assert(thirdDayBasicMonthly);
|
|
assert(thirdDayBasicMonthly.positive_delta === 1);
|
|
assert(thirdDayBasicMonthly.negative_delta === 1);
|
|
assert(thirdDayBasicMonthly.signups === 1);
|
|
assert(thirdDayBasicMonthly.cancellations === 1);
|
|
assert(thirdDayBasicMonthly.count === 1);
|
|
});
|
|
|
|
it('Correctly handles upgrades', async function () {
|
|
const tiers = await createTiers(['basic', 'beyond']);
|
|
|
|
const CREATE = createEvent('created');
|
|
const UPDATE = createEvent('updated');
|
|
const REACTIVATE = createEvent('reactivated');
|
|
const CANCEL = createEvent('canceled');
|
|
|
|
const events = [
|
|
[
|
|
CREATE('A', tiers.beyond.yearly),
|
|
CREATE('B', tiers.basic.yearly),
|
|
CANCEL('B'),
|
|
CREATE('C', tiers.beyond.monthly),
|
|
UPDATE('C', tiers.basic.monthly),
|
|
REACTIVATE('B'),
|
|
UPDATE('B', tiers.beyond.yearly)
|
|
],
|
|
[
|
|
CREATE('D', tiers.beyond.monthly),
|
|
CREATE('E', tiers.basic.yearly),
|
|
CREATE('F', tiers.beyond.yearly)
|
|
]
|
|
];
|
|
|
|
await insertEvents(events);
|
|
|
|
const stats = new SubscriptionStatsService({knex: db});
|
|
|
|
const result = await stats.getSubscriptionHistory();
|
|
|
|
// Check totals
|
|
assert(result.meta.totals.find(item => item.tier === 'basic' && item.cadence === 'month').count = 1);
|
|
assert(result.meta.totals.find(item => item.tier === 'basic' && item.cadence === 'year').count = 1);
|
|
assert(result.meta.totals.find(item => item.tier === 'beyond' && item.cadence === 'month').count = 1);
|
|
assert(result.meta.totals.find(item => item.tier === 'beyond' && item.cadence === 'year').count = 3);
|
|
|
|
/**
|
|
* @param {string} tier
|
|
* @param {string} cadence
|
|
* @param {string} date
|
|
*
|
|
* @returns {(result: import('../../lib/subscriptions').SubscriptionHistoryEntry) => boolean}
|
|
**/
|
|
const finder = (tier, cadence, date) => (resultItem) => {
|
|
return resultItem.tier === tier && resultItem.cadence === cadence && resultItem.date === date;
|
|
};
|
|
|
|
const days = [{
|
|
basic: {
|
|
monthly: result.data.find(finder('basic', 'month', '1970-01-01')),
|
|
yearly: result.data.find(finder('basic', 'year', '1970-01-01'))
|
|
},
|
|
beyond: {
|
|
monthly: result.data.find(finder('beyond', 'month', '1970-01-01')),
|
|
yearly: result.data.find(finder('beyond', 'year', '1970-01-01'))
|
|
}
|
|
}, {
|
|
basic: {
|
|
monthly: result.data.find(finder('basic', 'month', '1970-01-02')),
|
|
yearly: result.data.find(finder('basic', 'year', '1970-01-02'))
|
|
},
|
|
beyond: {
|
|
monthly: result.data.find(finder('beyond', 'month', '1970-01-02')),
|
|
yearly: result.data.find(finder('beyond', 'year', '1970-01-02'))
|
|
}
|
|
}];
|
|
|
|
// First day
|
|
assert.equal(days[0].basic.monthly.positive_delta, 1);
|
|
assert.equal(days[0].basic.monthly.negative_delta, 0);
|
|
assert.equal(days[0].basic.monthly.signups, 0); // We only have a subscription that switched tier
|
|
assert.equal(days[0].basic.monthly.cancellations, 0);
|
|
|
|
assert.equal(days[0].basic.yearly.positive_delta, 2);
|
|
assert.equal(days[0].basic.yearly.negative_delta, 2);
|
|
assert.equal(days[0].basic.yearly.signups, 2);
|
|
assert.equal(days[0].basic.yearly.cancellations, 1);
|
|
|
|
assert.equal(days[0].beyond.monthly.positive_delta, 1);
|
|
assert.equal(days[0].beyond.monthly.negative_delta, 1);
|
|
assert.equal(days[0].beyond.monthly.signups, 1);
|
|
assert.equal(days[0].beyond.monthly.cancellations, 0);
|
|
|
|
assert.equal(days[0].beyond.yearly.positive_delta, 2);
|
|
assert.equal(days[0].beyond.yearly.negative_delta, 0);
|
|
assert.equal(days[0].beyond.yearly.signups, 1);
|
|
assert.equal(days[0].beyond.yearly.cancellations, 0);
|
|
|
|
// Second day
|
|
assert.equal(days[1].basic.yearly.positive_delta, 1);
|
|
assert.equal(days[1].basic.yearly.negative_delta, 0);
|
|
assert.equal(days[1].basic.yearly.signups, 1);
|
|
assert.equal(days[1].basic.yearly.cancellations, 0);
|
|
|
|
assert.equal(days[1].beyond.monthly.positive_delta, 1);
|
|
assert.equal(days[1].beyond.monthly.negative_delta, 0);
|
|
assert.equal(days[1].beyond.monthly.signups, 1);
|
|
assert.equal(days[1].beyond.monthly.cancellations, 0);
|
|
|
|
assert.equal(days[1].beyond.yearly.positive_delta, 1);
|
|
assert.equal(days[1].beyond.yearly.negative_delta, 0);
|
|
assert.equal(days[1].beyond.yearly.signups, 1);
|
|
assert.equal(days[1].beyond.yearly.cancellations, 0);
|
|
});
|
|
});
|
|
});
|