Subchapter 46.42

Donations Test

Post Detail

Tag Page

Wix Blog

136 more in the appendix

Donations Test

Source

references/donations/tests/donations.test.mjs

JavaScript258 lines15 KB

1// Compose the same shared + vertical files that deploy.cjs copies. Network is always mocked.
2// node --test skills/wix-vibe-headless/references/donations/tests/donations.test.mjs
3import test, { after } from 'node:test';
4import assert from 'node:assert/strict';
5import { cp, mkdtemp, writeFile, readFile, rm } from 'node:fs/promises';
6import { tmpdir } from 'node:os';
7import { join } from 'node:path';
8import

donations.test.mjs on GitHub

{ pathToFileURL }

from

'node:url'

;

import { runInNewContext } from 'node:vm';

import { createHash } from 'node:crypto';

const transportSource = await readFile(new URL('../../shared/app/rest/wix-client.js', import.meta.url), 'utf8');

const donationSource = await readFile(new URL('../app/rest/wix-donations.js', import.meta.url), 'utf8');

const legacyTransportSource = transportSource

.replace('export const WIX_API_SUPPORTS_STRICT_PAYMENT_ERRORS = true;\n', '')

.replace(', throwOnPaymentRequired?: boolean', '')

.replace(', throwOnPaymentRequired = false', '')

.replace('res.status === 402 && !throwOnPaymentRequired', 'res.status === 402');

const moduleUrl = source => `data:text/javascript;base64,${Buffer.from(source).toString('base64')}`;

function helperWithTransport(source) {

const standalone = source

.replace('export { WIX_CLIENT_ID } from "./wix-config.js";', '')

.replace('import { WIX_CLIENT_ID } from "./wix-config.js";', 'const WIX_CLIENT_ID = "public-test-client";');

return import(moduleUrl(donationSource.replace("'./wix-client.js'", JSON.stringify(moduleUrl(standalone)))));

}

async function deployFixture(existingTransport, verticals = ['donations']) {

const script = await readFile(new URL('../../../install/deploy.cjs', import.meta.url), 'utf8');

const ref = '/app/.agents/skills/wix-vibe-headless/references';

const files = new Map([

[`${ref}/shared/app/rest/wix-client.js`, transportSource],

[`${ref}/shared/app/rest/wix-config.js`, 'export const WIX_CLIENT_ID = "<YOUR-CLIENT-ID>";\nexport const WIX_METASITE_ID = "<YOUR-SITE-ID>";'],

[`${ref}/donations/app/rest/wix-donations.js`, donationSource],

[`${ref}/cms/app/rest/wix-cms.js`, 'export const fixture = true;'],

]);

if (existingTransport !== undefined) files.set('/app/src/rest/wix-client.js', existingTransport);

const copies = [];

const writes = [];

let result;

const fs = {

existsSync: path => files.has(path) || [...files.keys()].some(file => file.startsWith(`${path}/`)),

cpSync: (from, to, options = {}) => {

copies.push({ from, to, options });

const entries = [...files].filter(([path]) => path === from || path.startsWith(`${from}/`));

assert.ok(entries.length, `Missing copy source: ${from}`);

for (const [path, source] of entries) {

const destination = `${to}${path.slice(from.length)}`;

if (!files.has(destination) || options.force !== false) files.set(destination, source);

}

},

mkdirSync: () => {},

writeFileSync: (path, source) => { writes.push(path); files.set(path, source); },

readFileSync: path => { assert.ok(files.has(path), `Missing fixture file: ${path}`); return files.get(path); },

};

const process = { argv: ['node', 'deploy.cjs', ...verticals, '--client-id', 'test-client', '--metasite-id', 'test-site'], exitCode: 0 };

runInNewContext(script, {

require: name => {

if (name === 'fs') return fs;

assert.equal(name, 'crypto');

return { createHash };

},

process,

console: { log: value => { result = JSON.parse(value); } },

});

return { result, files, copies, writes, exitCode: process.exitCode };

}

const fixture = await mkdtemp(join(tmpdir(), 'wix-donation-contract-'));

await cp(new URL('../../shared/app/', import.meta.url), fixture, { recursive: true });

await cp(new URL('../app/', import.meta.url), fixture, { recursive: true });

await writeFile(join(fixture, 'package.json'), '{"type":"module"}');

await writeFile(join(fixture, 'rest/wix-config.js'), 'export const WIX_CLIENT_ID = "public-test-client";');

const api = await import(pathToFileURL(join(fixture, 'rest/wix-donations.js')));

const transport = await import(pathToFileURL(join(fixture, 'rest/wix-client.js')));

const originalFetch = globalThis.fetch;

const originalWindow = globalThis.window;

const storage = new Map();

globalThis.window = { location: { origin: 'https://donor.example.test' }, localStorage: {

getItem: key => storage.get(key) ?? null, setItem: (key, value) => storage.set(key, value), removeItem: key => storage.delete(key),

} };

after(async () => { globalThis.fetch = originalFetch; globalThis.window = originalWindow; await rm(fixture, { recursive: true, force: true }); });

const campaign = {

id: 'campaign-id', status: 'COLLECTING', donationFrequencies: ['ONE_TIME', 'MONTH'],

predefinedDonationAmounts: [{ id: 'preset-id', price: { amount: '25.00' } }],

customAmountEnabled: true, customAmountOptions: { minimum: { amount: '5.00' }, maximum: { amount: '1000' } },

askDonorCoverFee: true, commentsEnabled: true,

};

const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });

function mockRequests(override = () => undefined) {

const calls = [];

globalThis.fetch = async (url, options) => {

const path = new URL(url).pathname;

const body = options.body ? JSON.parse(options.body) : undefined;

calls.push({ path, body, options });

const overridden = override(path, body);

if (overridden) return overridden;

if (path === '/oauth2/token') return json({ access_token: 'visitor-test-token', refresh_token: 'test-refresh', expires_in: 3600 });

if (path.endsWith('/campaign-id')) return json({ donationCampaign: campaign });

if (path === '/ecom/v2/carts') return json({ cart: { id: 'cart-id' } });

if (path === '/_api/redirects-api/v1/redirect-session') return json({ redirectSession: { fullUrl: 'https://checkout.example.test/session' } });

throw new Error(`Unexpected test request: ${path}`);

};

return calls;

}

test('one-time flow uses one visitor, one standalone cart and one redirect; no V1 checkout', async () => {

const calls = mockRequests();

assert.equal(await api.donationCheckoutUrl('campaign-id', { amount: '25', frequency: 'ONE_TIME' }), 'https://checkout.example.test/session');

const businessCalls = calls.filter(call => call.path !== '/oauth2/token');

assert.deepEqual(businessCalls.map(call => call.path), [

'/donation-campaigns/v2/donation-campaigns/campaign-id', '/ecom/v2/carts', '/_api/redirects-api/v1/redirect-session',

]);

assert.ok(businessCalls.every(call => call.options.headers.Authorization === 'visitor-test-token'));

assert.deepEqual(businessCalls[1].body.catalogItems[0].catalogReference.options, { amount: 25 });

assert.deepEqual(businessCalls[2].body, { ecomCheckout: { checkoutId: 'cart-id' }, callbacks: {

postFlowUrl: 'https://donor.example.test/donate/campaign-id', thankYouPageUrl: 'https://donor.example.test/donate/thank-you',

} });

});

test('recurrence, fees and note preserve donor choices without double-charging the fee', () => {

const body = api.donationCartBody(campaign, { amount: '37.50', frequency: 'MONTH', coverFee: true, note: ' A message ' });

assert.deepEqual(body.catalogItems[0].catalogReference.options, { amount: 37.5, frequency: 'MONTH', donorCoveringFees: true });

assert.equal(body.cart.note, 'A message');

});

test('selection validation respects campaign settings and permits correction', () => {

for (const amount of ['', 'oops', 0, -1, Infinity, true, null, {}, 1, 1001]) {

assert.throws(() => api.donationCartBody(campaign, { amount }));

}

assert.equal(api.donationCartBody(campaign, { amount: 10 }).catalogItems[0].catalogReference.options.amount, 10);

assert.throws(() => api.donationCartBody(campaign, { amount: 25, frequency: 'YEAR' }), /offered/);

assert.throws(() => api.donationCartBody({ ...campaign, customAmountEnabled: false }, { amount: 10 }), /suggested/);

assert.throws(() => api.donationCartBody({ ...campaign, archived: true }, { amount: 25 }), /not accepting/);

assert.throws(() => api.donationCartBody({ ...campaign, commentsEnabled: false }, { amount: 25, note: 'A note' }), /not enabled/);

assert.throws(() => api.donationCartBody({ ...campaign, askDonorCoverFee: false }, { amount: 25, coverFee: true }), /not offered/);

});

test('bad cart options preserve the HTTP error and never attempt a redirect', async () => {

const errorBody = { details: { applicationError: { code: 'ITEM_NOT_FOUND_IN_CATALOG' } } };

const calls = mockRequests(path => path === '/ecom/v2/carts' ? json(errorBody, 400) : undefined);

await assert.rejects(api.donationCheckoutUrl('campaign-id', { amount: 25 }), error => {

assert.equal(error.status, 400); assert.deepEqual(error.body, errorBody); assert.equal(error.stage, 'cart'); return true;

});

assert.equal(calls.filter(call => call.path.includes('redirect-session')).length, 0);

});

test('redirect failure retains the known cart and does not silently create a second cart', async () => {

const calls = mockRequests(path => path.includes('redirect-session') ? json({ message: 'Origin not allowed' }, 403) : undefined);

await assert.rejects(api.donationCheckoutUrl('campaign-id', { amount: 25 }), error => {

assert.equal(error.status, 403); assert.equal(error.stage, 'redirect'); assert.equal(error.cartId, 'cart-id'); return true;

});

assert.equal(calls.filter(call => call.path === '/ecom/v2/carts').length, 1);

});

test('Donations retains a payment-required error body instead of returning undefined', async () => {

const errorBody = { message: 'Payment setup required', code: 'PAYMENT_REQUIRED' };

mockRequests(() => json(errorBody, 402));

await assert.rejects(transport.wixApiRequest('/a-test-read', { throwOnPaymentRequired: true }), error => {

assert.equal(error.status, 402); assert.deepEqual(error.body, errorBody); return true;

});

test('the shared transport keeps its existing 402 behavior for other verticals', async () => {

mockRequests(() => json({ message: 'Payment setup required' }, 402));

const originalWarn = console.warn;

const warnings = [];

console.warn = message => warnings.push(message);

try {

assert.equal(await transport.wixApiRequest('/a-test-read'), undefined);

assert.equal(warnings.length, 1);

} finally {

console.warn = originalWarn;

}

});

test('query errors do not become empty campaigns; nextCursor is returned on success', async () => {

mockRequests(path => path.endsWith('/query') ? json({ message: 'Permission denied' }, 403) : undefined);

await assert.rejects(api.queryDonationCampaigns(), error => error.status === 403);

mockRequests(path => path.endsWith('/query') ? json({ donationCampaigns: [campaign], pagingMetadata: { cursors: { next: 'next-page' } } }) : undefined);

assert.deepEqual(await api.queryDonationCampaigns(), { campaigns: [campaign], nextCursor: 'next-page' });

});

test('absent campaigns differ from denied access; unavailable metrics stay errors', async () => {

mockRequests(() => json({ message: 'Missing' }, 404));

assert.equal(await api.getDonationCampaign('missing-id'), null);

mockRequests(() => json({ message: 'Permission denied' }, 403));

await assert.rejects(api.getDonationCampaign('campaign-id'), error => error.status === 403);

await assert.rejects(api.getDonationCampaignMetrics('campaign-id'), error => error.status === 403);

});

test('platform deploy copies the new donation helper alongside the shared transport', async () => {

const { result, files, copies, exitCode } = await deployFixture();

assert.deepEqual(result.verticals, ['donations']);

assert.equal(result.error, undefined);

assert.equal(exitCode, 0);

assert.equal(result.donationsTransport, 'from_shared_tree');

assert.ok(copies.some(copy => copy.from.endsWith('/shared/app') && copy.to === '/app/src'));

assert.ok(copies.some(copy => copy.from.endsWith('/donations/app') && copy.to === '/app/src'));

assert.equal(files.get('/app/src/rest/wix-client.js'), transportSource);

assert.equal(files.get('/app/src/rest/wix-donations.js'), donationSource);

assert.equal(result.wixConfig, 'written');

});

test('incremental deployment upgrades only the exact shipped legacy transport and preserves 402 details', async () => {

assert.equal(createHash('sha256').update(legacyTransportSource).digest('hex'), '10d53e5e06ac3da62f93d41cfd618b6169c5bb1a5ba07fb58ec7700aad42889e');

const { result, files, copies, exitCode } = await deployFixture(legacyTransportSource);

assert.equal(exitCode, 0);

assert.equal(result.donationsTransport, 'upgraded_unmodified_legacy');

assert.equal(files.get('/app/src/rest/wix-client.js'), transportSource);

assert.equal(copies.filter(copy => copy.to === '/app/src/rest/wix-client.js' && copy.options.force === true).length, 1);

const upgraded = await helperWithTransport(files.get('/app/src/rest/wix-client.js'));

const errorBody = { code: 'PAYMENT_REQUIRED', message: 'Payment setup required' };

mockRequests(() => json(errorBody, 402));

await assert.rejects(upgraded.queryDonationCampaigns(), error => error.status === 402 && error.body.code === errorBody.code);

});

test('customized incompatible transport fails deployment preflight without any writes', async () => {

const customized = `${legacyTransportSource}\n// User-owned customization.\n`;

const { result, files, copies, writes, exitCode } = await deployFixture(customized);

assert.equal(exitCode, 1);

assert.deepEqual(result.verticals, []);

assert.match(result.error, /customized or incompatible.*left unchanged.*Merge strict payment-error support/);

assert.equal(files.get('/app/src/rest/wix-client.js'), customized);

assert.equal(files.has('/app/src/rest/wix-donations.js'), false);

assert.equal(copies.length, 0);

assert.equal(writes.length, 0);

});

test('compatible customized transport is kept byte-for-byte on a Donations deploy', async () => {

const customized = `${transportSource}\n// User-owned customization.\n`;

const { result, files, copies, exitCode } = await deployFixture(customized);

assert.equal(exitCode, 0);

assert.equal(result.donationsTransport, 'already_supported');

assert.equal(files.get('/app/src/rest/wix-client.js'), customized);

assert.equal(copies.some(copy => copy.to === '/app/src/rest/wix-client.js'), false);

});

test('non-Donations deployment leaves the legacy transport untouched', async () => {

const { result, files, copies, exitCode } = await deployFixture(legacyTransportSource, ['cms']);

assert.equal(exitCode, 0);

assert.deepEqual(result.verticals, ['cms']);

assert.equal(result.donationsTransport, undefined);

assert.equal(files.get('/app/src/rest/wix-client.js'), legacyTransportSource);

assert.equal(copies.some(copy => copy.to === '/app/src/rest/wix-client.js'), false);

});

test('manual copying with a legacy transport fails actionably before making a network request', async () => {

const incompatible = await helperWithTransport(legacyTransportSource);

const calls = mockRequests();

await assert.rejects(incompatible.queryDonationCampaigns(), error => {

assert.equal(error.code, 'DONATIONS_TRANSPORT_UPGRADE_REQUIRED');

assert.match(error.message, /Re-run the Donations deploy step.*customized src\/rest\/wix-client\.js/);

return true;

});

assert.equal(calls.length, 0);

});