domma-cms 1.6.34 → 1.6.35

package/plugins/shopping-cart/tests/commission.test.js

@@ -0,0 +1,90 @@
+/**
+ * Platform commission: the pure rules, then a real sale with config/commission.json written as the manager would
+ * (in the domma-cms checkout `make test` runs in - removed again after).
+ */
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import Fastify from 'fastify';
+import shoppingCart from '../plugin.js';
+import {cleanRates, commissionFor, orderType, rateFor, rateText} from '../lib/commission.js';
+
+const FILE = path.resolve('config/commission.json');
+const PLUGINS = path.resolve('config/plugins.json');
+const DIRS = ['shop-products', 'shop-orders'].map(c => path.resolve('content/collections', c));
+let savedFile;
+let savedPlugins;
+let app;
+
+before(async () => {
+    savedFile = await fs.readFile(FILE, 'utf8').catch(() => null);
+    savedPlugins = await fs.readFile(PLUGINS, 'utf8').catch(() => null);
+    for (const d of DIRS) await fs.rm(d, {recursive: true, force: true});
+    delete globalThis[Symbol.for('domma.shopping-cart')];
+    app = Fastify();
+    await app.register(shoppingCart, {auth: {authenticate: async (req) => { req.user = {id: 'a', role: 'admin'}; }, requirePermission: () => async () => {}}, settings: {}, hooks: {registerShortcode() {}}});
+});
+
+after(async () => {
+    await app?.close();
+    for (const d of DIRS) await fs.rm(d, {recursive: true, force: true});
+    if (savedFile === null) await fs.rm(FILE, {force: true}); else await fs.writeFile(FILE, savedFile);
+    if (savedPlugins === null) await fs.rm(PLUGINS, {force: true}); else await fs.writeFile(PLUGINS, savedPlugins);
+});
+
+const call = async (method, url, body) => {
+    const res = await app.inject({method, url, payload: body});
+    let json = null;
+    try { json = res.json(); } catch { /* not JSON */ }
+    return {status: res.statusCode, body: json, text: res.body};
+};
+
+test('commission: rates cleaned, the kind of sale, per-sale amounts', () => {
+    const {rates} = cleanRates({rates: {default: {percent: 2, fixed: 20}, takeaway: {percent: '3.5'}, shop: {percent: -1}, junk: {percent: 9}}});
+    assert.deepEqual(rates, {default: {percent: 2, fixed: 20}, takeaway: {percent: 3.5, fixed: 0}});
+    assert.equal(orderType({data: {ref: 'takeaway:x'}}), 'takeaway');
+    assert.equal(orderType({data: {ref: 'purchase-1'}}), 'addons');
+    assert.equal(orderType({data: {}}), 'shop');
+    assert.deepEqual(rateFor('shop', rates), {percent: 2, fixed: 20}, 'no rate of its own: the default');
+    assert.deepEqual(commissionFor({data: {total: 2150}}, rates, 'T'), {type: 'shop', base: 2150, percent: 2, fixed: 20, amount: 43 + 20, at: 'T'});
+    assert.equal(commissionFor({data: {total: 2150, ref: 'takeaway:x'}}, rates).amount, 75, '3.5% of £21.50, rounded');
+    assert.equal(commissionFor({data: {total: 0}}, rates), null, 'a free order carries none');
+    assert.equal(commissionFor({data: {total: 10}}, rates).amount, 10, 'never more than the sale');
+    assert.equal(commissionFor({data: {total: 1000}}, {}), null, 'no rates: none');
+    assert.equal(rateText({percent: 2, fixed: 20}), '2% + £0.20 per sale');
+});
+
+test('commission: stored on the sale when paid, at that day\'s rate; returned with a refund; in Sales and the CSV', async () => {
+    await call('PUT', '/settings', {offlineEnabled: true, countries: ['GB']});
+    const mug = (await call('POST', '/products', {name: 'Mug', price: 1000, status: 'active', shippable: false})).body;
+    const buy = async () => (await call('POST', '/checkout', {lines: [{productId: mug.id, qty: 2}], provider: 'offline', customer: {name: 'Ann', email: 'ann@example.test'}})).body.orderId;
+
+    // No file yet: a sale carries no commission.
+    let id = await buy();
+    let o = (await call('PUT', `/orders/${id}/status`, {status: 'paid'})).body;
+    assert.equal(o.data.commission, undefined);
+
+    // The manager writes the rate; the next sale has it (no restart).
+    await fs.writeFile(FILE, JSON.stringify({rates: {default: {percent: 5, fixed: 10}}, updatedAt: '2026-10-12T00:00:00Z', by: 'super'}));
+    id = await buy();
+    o = (await call('PUT', `/orders/${id}/status`, {status: 'paid'})).body;
+    assert.deepEqual([o.data.commission.amount, o.data.commission.percent, o.data.commission.type], [110, 5, 'shop']);
+    // A later rate leaves it as it was.
+    await new Promise(r => setTimeout(r, 15));
+    await fs.writeFile(FILE, JSON.stringify({rates: {default: {percent: 50}}}));
+    o = (await call('PUT', `/orders/${id}/status`, {status: 'fulfilled'})).body;
+    assert.equal(o.data.commission.amount, 110);
+    const s = (await call('GET', '/settings')).body.commission;
+    assert.deepEqual([s.set, s.rates[0].text], [true, '50% per sale']);
+    // Refunded: returned.
+    o = (await call('POST', `/orders/${id}/refund`, {})).body.order;
+    assert.deepEqual([o.data.commission.reversed, o.data.commission.amount], [true, 110]);
+    const r = (await call('GET', '/sales?range=year')).body;
+    assert.deepEqual([r.totals.commission, r.totals.commissionBack, r.totals.commissionNet], [110, 110, 0]);
+    const csv = (await call('GET', '/sales.csv?range=year')).text;
+    assert.ok(csv.split('\r\n')[0].endsWith('Commission,Commission rate'));
+    // The customer never sees it.
+    const receipt = (await call('GET', `/order/${id}?t=${o.data.token}`)).body;
+    assert.ok(!('commission' in receipt));
+});

package/plugins/shopping-cart/tests/sales.test.js

@@ -0,0 +1,73 @@
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {dateIn, periodOf, periodsBetween, rangeFor, salesCsv, salesReport, sourceOf} from '../lib/sales.js';
+
+const order = (n, {status = 'paid', paidAt, refundedAt, ref = '', provider = 'stripe', lines, adjustments = [], delivery = 'none', ext} = {}) => {
+    const subtotal = lines.reduce((s, l) => s + l.lineTotal, 0);
+    const total = subtotal + adjustments.filter(a => !a.included).reduce((s, a) => s + a.amount, 0);
+    return {id: `o${n}`, meta: {createdAt: paidAt}, data: {number: 1000 + n, status, paidAt, refundedAt, ref, provider, lines, adjustments, subtotal, total, delivery, ext,
+        customer: {name: `Customer ${n}`}}};
+};
+
+const ORDERS = [
+    // A Shop order with delivery and a discount, paid late on 1 Oct UK time (still 1 Oct in London, 23:30 BST = 22:30Z).
+    order(1, {paidAt: '2026-10-01T22:30:00Z', lines: [{productId: 'mug', qty: 2, lineTotal: 2000}],
+        adjustments: [{stage: 'discount', amount: -200}, {stage: 'shipping', amount: 395}, {stage: 'tax', amount: 366, included: true}]}),
+    // Just after midnight UK time on 2 Oct (23:10Z on 1 Oct): a London date of 2 Oct.
+    order(2, {paidAt: '2026-10-01T23:10:00Z', provider: 'offline', lines: [{productId: 'ebook', qty: 1, lineTotal: 900}],
+        ext: {'shopping-cart-pro': {downloads: [{productId: 'ebook'}]}}}),
+    // Takeaway, delivered.
+    order(3, {paidAt: '2026-10-03T18:00:00Z', ref: 'takeaway:abc', delivery: 'ship', lines: [{productId: '', custom: true, qty: 1, lineTotal: 1900}],
+        adjustments: [{stage: 'shipping', amount: 250}]}),
+    // Paid 4 Oct, refunded 9 Oct.
+    order(4, {status: 'refunded', paidAt: '2026-10-04T12:00:00Z', refundedAt: '2026-10-09T09:00:00Z', lines: [{productId: 'mug', qty: 1, lineTotal: 1000}]}),
+    // Never paid: not a sale.
+    order(5, {status: 'pending', paidAt: '2026-10-05T12:00:00Z', lines: [{productId: 'mug', qty: 1, lineTotal: 1000}]}),
+    // Another add-on's sale (Cards Pro credits).
+    order(6, {paidAt: '2026-10-06T12:00:00Z', ref: 'purchase-9', provider: 'free', lines: [{productId: 'credits', qty: 1, lineTotal: 0}]})
+];
+
+test('sales: dates in the shop\'s zone, periods, ranges', () => {
+    assert.equal(dateIn('2026-10-01T23:10:00Z', 'Europe/London'), '2026-10-02');
+    assert.equal(dateIn('2026-10-01T23:10:00Z', 'UTC'), '2026-10-01');
+    assert.equal(periodOf('2026-10-08', 'week'), '2026-10-05', 'weeks start on Monday');
+    assert.equal(periodOf('2026-10-08', 'month'), '2026-10-01');
+    assert.deepEqual(periodsBetween('2026-09-28', '2026-10-12', 'week'), ['2026-09-28', '2026-10-05', '2026-10-12']);
+    assert.deepEqual(periodsBetween('2026-11-15', '2027-01-02', 'month'), ['2026-11-01', '2026-12-01', '2027-01-01']);
+    assert.deepEqual(rangeFor('lastmonth', '2026-10-12'), {from: '2026-09-01', to: '2026-09-30'});
+    assert.deepEqual(rangeFor('week', '2026-10-12'), {from: '2026-10-12', to: '2026-10-12'});
+    assert.deepEqual(rangeFor('last7', '2026-10-12'), {from: '2026-10-06', to: '2026-10-12'});
+});
+
+test('sales: sources, figures, refunds on their own day, payment methods', () => {
+    assert.deepEqual(ORDERS.slice(0, 3).map(o => sourceOf(o, o.data.lines[0])), ['shop', 'downloads', 'takeaway']);
+    assert.equal(sourceOf(ORDERS[5], ORDERS[5].data.lines[0]), 'addons');
+    const r = salesReport(ORDERS, {from: '2026-10-01', to: '2026-10-12', by: 'day'});
+    assert.equal(r.totals.orders, 5, 'the unpaid one is not a sale');
+    assert.equal(r.totals.takings, 2195 + 900 + 2150 + 1000 + 0);
+    assert.deepEqual([r.totals.discount, r.totals.delivery, r.totals.taxIncluded, r.totals.refunds, r.totals.refundCount], [200, 645, 366, 1000, 1]);
+    assert.equal(r.totals.net, r.totals.takings - 1000);
+    const src = Object.fromEntries(r.sources.map(s => [s.key, s.amount]));
+    assert.deepEqual(src, {shop: 3000, downloads: 900, takeaway: 1900, addons: 0});
+    assert.deepEqual(r.takeaway, {collect: 0, deliver: 1});
+    assert.equal(r.methods[0].key, 'stripe');
+    const day = (d) => r.periods.find(p => p.period === d);
+    assert.equal(day('2026-10-01').takings, 2195);
+    assert.equal(day('2026-10-02').takings, 900, 'paid after midnight in London');
+    assert.equal(day('2026-10-09').refunds, 1000);
+    assert.equal(r.periods.length, 12, 'empty days are there too');
+    // A range that holds only the refund: no sale, the refund still counts.
+    const later = salesReport(ORDERS, {from: '2026-10-08', to: '2026-10-10'});
+    assert.deepEqual([later.totals.orders, later.totals.refunds, later.totals.net], [0, 1000, -1000]);
+});
+
+test('sales: the CSV, one row per order, quoted where it must be', () => {
+    const csv = salesCsv([...ORDERS, order(7, {paidAt: '2026-10-07T12:00:00Z', lines: [{productId: 'x', qty: 1, lineTotal: 500}]})].map(o => (o.id === 'o7' ? {...o, data: {...o.data, customer: {name: 'Smith, "Jo"'}}} : o)),
+        {from: '2026-10-01', to: '2026-10-12'});
+    const rows = csv.trim().split('\r\n');
+    assert.equal(rows[0].split(',')[0], 'Order');
+    assert.equal(rows.length, 1 + 6);
+    assert.ok(rows.some(r => r.startsWith('#1001,2026-10-01,paid,,Shop,Card (Stripe),Customer 1,20.00,2.00,3.95,0.00,3.66,21.95')));
+    assert.ok(rows.some(r => r.includes('"Smith, ""Jo"""')));
+    assert.ok(rows.some(r => r.startsWith('#1004,2026-10-04,refunded,2026-10-09')));
+});