const assert = require('node:assert/strict'); const Module = require('node:module'); const path = require('node:path'); const test = require('node:test'); const registerConfigPath = path.resolve(__dirname, '../src/register-config.js'); const { registerContract } = require('../src/hook-contract'); const { readStatusMapping, resolvePsStateId } = require('../src/status-mapper'); const STATUS_A = '507f191e810c19729de860ea'; const STATUS_B = '507f191e810c19729de860eb'; function loadConfigModule({ states = [], cachedStates = [], saved = {}, providers = 1, failPs = false, failOrbito = false } = {}) { let blocks; const store = { 'connection.apiUrl': 'https://shop.test', 'connection.apiKey': 'secret', 'connection.versionCode': '8', 'runtime.psStates': cachedStates, ...saved, }; const hooks = new Map(); const requests = []; for (let i = 0; i < providers; i++) { registerContract({ getInstanceId: () => `order-provider-${i}`, getModuleInfo: () => ({ code: 'alternative/orders' }), registerHook: (name, handler) => hooks.set(name, [...(hooks.get(name) || []), handler]), }, 'orders.status.search', async () => { if (failOrbito) throw new Error('Status service offline'); return { results: [{ _id: STATUS_A, name: 'Do nadania' }, { _id: STATUS_B, name: 'Wysłane' }] }; }); } const Config = { PropertyType: { INFO: 'info', STRING: 'string' }, DisplayFormat: { URL: 'url', SECRET: 'secret' }, registerConfigBlocks: async value => { blocks = value; }, get: async (key, fallback) => Object.hasOwn(store, key) ? store[key] : fallback, getAll: async () => ({ ...store }), set: async (key, value) => { store[key] = value; }, }; const originalLoad = Module._load; Module._load = function(request, parent, isMain) { if (request === '@orbito/api-lib') return { Config, Core: { execHook: async (name, request) => { requests.push({ name, request }); return Promise.all((hooks.get(name) || []).map(handler => handler.call({ caller: { moduleCode: 'core/prestashop', instanceId: 'shop-instance' }, }, request))); } }, Log: { info() {}, warn() {} }, }; if (request === './PrestaApi') return class PrestashopApi { async getStatuses() { if (failPs) throw new Error('Shop offline'); return states; } }; if (request === './utils') return { isLegacyApi: () => false }; if (request === './shop-icon') return { ensureShopIcon: async () => {} }; return originalLoad.call(this, request, parent, isMain); }; for (const file of ['../src/register-config', '../src/status-config', '../src/module-config']) { delete require.cache[require.resolve(file)]; } let loaded, loadConfig, initializeOutboundMapping; try { loaded = require(registerConfigPath); ({ loadConfig, initializeOutboundMapping } = require('../src/module-config')); } finally { Module._load = originalLoad; } return { ...loaded, store, requests, loadConfig, initializeOutboundMapping, Config, register: async () => { await loaded.registerPrestashopConfigBlocks(); return blocks; }, }; } test('mapping rows are Orbito statuses, with fresh local PrestaShop options obtained through the selected hook provider', async () => { const module = loadConfigModule({ cachedStates: [{ id: 2, name: 'Stara nazwa', color: '#000000' }], states: [{ id: '2', name: 'Nowa nazwa', color: '#00ff00', deleted: '0' }], saved: { 'mapping.state_2': STATUS_A }, }); const blocks = await module.register(); const schema = await blocks.mapping.schema(); assert.equal(schema[`orbito_${STATUS_A}`].name.pl, 'Do nadania'); assert.equal(module.store[`mapping.orbito_${STATUS_A}`], '2'); assert.deepEqual(schema[`orbito_${STATUS_A}`].options, { values: [{ id: '2', label: 'Nowa nazwa (PS #2)' }] }); assert.equal(schema.state_2, undefined); assert.deepEqual(module.store['runtime.psStates'], [{ id: 2, name: 'Nowa nazwa', color: '#00ff00' }]); assert.equal(module.requests[1].request.targetInstanceId, 'order-provider-0'); assert.equal(module.store['mapping.state_2'], STATUS_A); assert.equal(module.store[`mapping.orbito_${STATUS_A}`], '2'); }); test('two Orbito statuses can be saved and loaded with the same PrestaShop target without changing legacy data', async () => { const module = loadConfigModule({ saved: { 'mapping.state_2': STATUS_A } }); const params = { [`orbito_${STATUS_A}`]: '2', [`orbito_${STATUS_B}`]: '2' }; const errors = []; module.validateOutboundMapping(params, { addError: (...args) => errors.push(args) }); assert.deepEqual(errors, []); for (const [field, value] of Object.entries(params)) module.store[`mapping.${field}`] = value; const config = await module.loadConfig(); assert.equal(resolvePsStateId(STATUS_A, config.statusMapping), 2); assert.equal(resolvePsStateId(STATUS_B, config.statusMapping), 2); assert.equal(module.store['mapping.state_2'], STATUS_A); }); test('missing shop statuses and missing Orbito statuses retain their assignments and visible IDs', async () => { const missingId = '507f191e810c19729de860ec'; const module = loadConfigModule({ saved: { 'mapping.state_99': missingId } }); const schema = await (await module.register()).mapping.schema(); assert.match(schema[`orbito_${missingId}`].name.pl, new RegExp(missingId)); assert.equal(module.store[`mapping.orbito_${missingId}`], '99'); assert.ok(schema[`orbito_${missingId}`].options.values.some(option => option.id === '99')); assert.equal(resolvePsStateId(missingId, (await module.loadConfig()).statusMapping), 99); }); for (const options of [{ providers: 0 }, { providers: 2 }, { failOrbito: true }]) { test(`unavailable or ambiguous status provider is visible and preserves mapping: ${JSON.stringify(options)}`, async () => { const module = loadConfigModule({ ...options, saved: { 'mapping.state_2': STATUS_A, 'import.orderStatus': STATUS_A } }); const blocks = await module.register(); const schema = await blocks.mapping.schema(); assert.match(schema.statusWarning.name.pl, /Nie udało się pobrać/); assert.equal(module.store[`mapping.orbito_${STATUS_A}`], '2'); if (options.providers !== undefined) assert.ok(module.requests.every(request => request.name.endsWith('.providers'))); const importSchema = await blocks.import.schema(); assert.match(importSchema.statusWarning.name.pl, /Nie udało się pobrać/); assert.equal(importSchema.orderStatus.options.values[0].id, STATUS_A); assert.equal(module.store['mapping.state_2'], STATUS_A); }); } test('a shop outage shows cached names and never clears the mapping', async () => { const module = loadConfigModule({ failPs: true, cachedStates: [{ id: 2, name: 'Oczekujące' }], saved: { 'mapping.state_2': STATUS_A } }); const schema = await (await module.register()).mapping.schema(); assert.match(schema.refreshWarning.name.pl, /Shop offline/); assert.equal(module.store[`mapping.orbito_${STATUS_A}`], '2'); assert.equal(schema[`orbito_${STATUS_A}`].options.values[0].label, 'Oczekujące (PS #2)'); }); test('legacy conflicts keep every target and require an explicit choice before save', async () => { const module = loadConfigModule({ saved: { 'mapping.state_2': STATUS_A, 'mapping.state_3': STATUS_A } }); const schema = await (await module.register()).mapping.schema(); const field = `orbito_${STATUS_A}`; assert.equal(module.store[`mapping.${field}`], 'legacy_conflict'); assert.match(schema[field].options.values[0].label, /#2, #3/); const errors = []; module.validateOutboundMapping({ [field]: module.store[`mapping.${field}`] }, { addError: (...args) => errors.push(args) }); assert.equal(errors[0][0], field); assert.throws(() => resolvePsStateId(STATUS_A, readStatusMapping(module.store)), /kilku statusów/); module.store[`mapping.${field}`] = '3'; assert.equal(resolvePsStateId(STATUS_A, (await module.loadConfig()).statusMapping), 3); assert.equal(module.store['mapping.state_2'], STATUS_A); assert.equal(module.store['mapping.state_3'], STATUS_A); }); test('connection validates the shop time zone and defaults to Europe/Warsaw', async () => { const module = loadConfigModule({ states: [{ id: '2', name: 'New' }] }); const blocks = await module.register(); assert.equal(blocks.connection.schema.timeZone.default, 'Europe/Warsaw'); const errors = []; const report = { addError: (field, message) => errors.push({ field, message }) }; const connection = { apiUrl: 'https://shop.test', apiKey: 'secret' }; await blocks.connection.validate({ ...connection, timeZone: 'Not/AZone' }, report); assert.deepEqual(errors.map(error => error.field), ['timeZone']); errors.length = 0; for (const timeZone of ['', 'Europe/Warsaw', 'UTC', 'Europe/London']) { await blocks.connection.validate({ ...connection, timeZone }, report); } assert.deepEqual(errors, []); }); test('config loading applies Warsaw to existing installations and passes a saved shop zone to jobs', async () => { let savedTimeZone; const originalLoad = Module._load; Module._load = function(request, parent, isMain) { if (request === '@orbito/api-lib') return { Config: { getAll: async () => ({}), get: async (key, fallback) => key === 'connection.timeZone' ? savedTimeZone ?? fallback : fallback, } }; return originalLoad.call(this, request, parent, isMain); }; let loadConfig; try { delete require.cache[require.resolve('../src/module-config')]; ({ loadConfig } = require('../src/module-config')); } finally { Module._load = originalLoad; } assert.equal((await loadConfig()).timeZone, 'Europe/Warsaw'); savedTimeZone = ' '; assert.equal((await loadConfig()).timeZone, 'Europe/Warsaw'); savedTimeZone = ' Europe/London '; assert.equal((await loadConfig()).timeZone, 'Europe/London'); }); test('additive migration resumes after a failed write, preserves empty overrides and is idempotent', async () => { const module = loadConfigModule({ saved: { 'mapping.state_2': STATUS_A, 'mapping.state_7': STATUS_B } }); const originalSet = module.Config.set; let writes = 0; module.Config.set = async (key, value) => { if (++writes === 2) throw new Error('Interrupted write'); return originalSet(key, value); }; await assert.rejects(module.initializeOutboundMapping, /Interrupted write/); assert.equal(module.store[`mapping.orbito_${STATUS_A}`], '2'); assert.equal(Object.hasOwn(module.store, `mapping.orbito_${STATUS_B}`), false); module.store[`mapping.orbito_${STATUS_A}`] = ''; module.Config.set = originalSet; await module.initializeOutboundMapping(); assert.equal(module.store[`mapping.orbito_${STATUS_A}`], ''); assert.equal(module.store[`mapping.orbito_${STATUS_B}`], '7'); const saved = structuredClone(module.store); await module.initializeOutboundMapping(); assert.deepEqual(module.store, saved); const schema = await (await module.register()).mapping.schema(); assert.equal(schema[`orbito_${STATUS_A}`].default, undefined); assert.equal(resolvePsStateId(STATUS_A, (await module.loadConfig()).statusMapping), null); }); test('separate shop instances keep their own target IDs and options', async () => { const a = loadConfigModule({ states: [{ id: 2, name: 'Sklep A' }], saved: { 'mapping.state_2': STATUS_A } }); const blocksA = await a.register(); const b = loadConfigModule({ states: [{ id: 7, name: 'Sklep B' }], saved: { 'mapping.state_7': STATUS_A } }); const blocksB = await b.register(); const schemaA = await blocksA.mapping.schema(); const schemaB = await blocksB.mapping.schema(); assert.deepEqual(schemaA[`orbito_${STATUS_A}`].options.values, [{ id: '2', label: 'Sklep A (PS #2)' }]); assert.deepEqual(schemaB[`orbito_${STATUS_A}`].options.values, [{ id: '7', label: 'Sklep B (PS #7)' }]); assert.equal(a.store[`mapping.orbito_${STATUS_A}`], '2'); assert.equal(b.store[`mapping.orbito_${STATUS_A}`], '7'); });