@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/dist/esm/new/utils/transformers.test.js

@@ -1,469 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { buildDatasourceName, transformFromServerPayload, transformToServerPayload, } from './transformers';
-const TransformFromServerPayload = suite('transformFromServerPayload');
-TransformFromServerPayload.before.each(() => {
-    sinon.restore();
-});
-TransformFromServerPayload('cleans up orphaned fields from INCLUDE_COLUMNS', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-            AMOUNT: { genesisType: 'DOUBLE' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    INCLUDE_COLUMNS: ['COUNTERPARTY_NAME', 'AMOUNT', 'NAME'], // NAME is orphaned
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    assert.equal((_a = cleanedConfig.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 2);
-    assert.ok((_b = cleanedConfig.INCLUDE_COLUMNS) === null || _b === void 0 ? void 0 : _b.includes('COUNTERPARTY_NAME'));
-    assert.ok((_c = cleanedConfig.INCLUDE_COLUMNS) === null || _c === void 0 ? void 0 : _c.includes('AMOUNT'));
-    assert.ok(!((_d = cleanedConfig.INCLUDE_COLUMNS) === null || _d === void 0 ? void 0 : _d.includes('NAME')));
-}));
-TransformFromServerPayload('cleans up orphaned fields from COLUMN_RENAMES', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-            AMOUNT: { genesisType: 'DOUBLE' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    COLUMN_RENAMES: {
-                        COUNTERPARTY_NAME: 'Counterparty Name',
-                        AMOUNT: 'Amount',
-                        NAME: 'Old Name', // orphaned
-                    },
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    assert.equal(Object.keys(cleanedConfig.COLUMN_RENAMES || {}).length, 2);
-    assert.equal((_a = cleanedConfig.COLUMN_RENAMES) === null || _a === void 0 ? void 0 : _a['COUNTERPARTY_NAME'], 'Counterparty Name');
-    assert.equal((_b = cleanedConfig.COLUMN_RENAMES) === null || _b === void 0 ? void 0 : _b['AMOUNT'], 'Amount');
-    assert.ok(!((_c = cleanedConfig.COLUMN_RENAMES) === null || _c === void 0 ? void 0 : _c['NAME']));
-}));
-TransformFromServerPayload('cleans up orphaned fields from COLUMN_FORMATS', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-            AMOUNT: { genesisType: 'DOUBLE' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    COLUMN_FORMATS: {
-                        COUNTERPARTY_NAME: 'text',
-                        AMOUNT: '#,##0.00',
-                        NAME: 'text', // orphaned
-                    },
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    assert.equal(Object.keys(cleanedConfig.COLUMN_FORMATS || {}).length, 2);
-    assert.equal((_a = cleanedConfig.COLUMN_FORMATS) === null || _a === void 0 ? void 0 : _a['COUNTERPARTY_NAME'], 'text');
-    assert.equal((_b = cleanedConfig.COLUMN_FORMATS) === null || _b === void 0 ? void 0 : _b['AMOUNT'], '#,##0.00');
-    assert.ok(!((_c = cleanedConfig.COLUMN_FORMATS) === null || _c === void 0 ? void 0 : _c['NAME']));
-}));
-TransformFromServerPayload('cleans up orphaned fields from COLUMN_TRANSFORMS', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-            AMOUNT: { genesisType: 'DOUBLE' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    COLUMN_TRANSFORMS: {
-                        COUNTERPARTY_NAME: { TYPE: 'BINARY_EXPRESSION', LEFT: {}, OPERATION: 'AND', RIGHT: {} },
-                        AMOUNT: { TYPE: 'METHOD_EXPRESSION', METHOD: 'TRIM', PARAMETERS: [] },
-                        NAME: { TYPE: 'BINARY_EXPRESSION', LEFT: {}, OPERATION: 'AND', RIGHT: {} }, // orphaned
-                    },
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    assert.equal(Object.keys(cleanedConfig.COLUMN_TRANSFORMS || {}).length, 2);
-    assert.ok((_a = cleanedConfig.COLUMN_TRANSFORMS) === null || _a === void 0 ? void 0 : _a['COUNTERPARTY_NAME']);
-    assert.ok((_b = cleanedConfig.COLUMN_TRANSFORMS) === null || _b === void 0 ? void 0 : _b['AMOUNT']);
-    assert.ok(!((_c = cleanedConfig.COLUMN_TRANSFORMS) === null || _c === void 0 ? void 0 : _c['NAME']));
-}));
-TransformFromServerPayload('handles schema fetch failure gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockGetSchema = sinon.stub();
-    const consoleWarnStub = sinon.stub(console, 'warn');
-    mockGetSchema.rejects(new Error('Schema fetch failed'));
-    const originalConfig = {
-        INCLUDE_COLUMNS: ['NAME', 'AMOUNT'],
-        COLUMN_RENAMES: { NAME: 'Name' },
-    };
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: originalConfig,
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    // Should keep original config when schema fetch fails
-    assert.equal(JSON.stringify(cleanedConfig), JSON.stringify(originalConfig));
-    assert.ok(consoleWarnStub.calledOnce);
-    assert.ok(consoleWarnStub.calledWithMatch(sinon.match.string, sinon.match.instanceOf(Error)));
-    consoleWarnStub.restore();
-}));
-TransformFromServerPayload('handles multiple datasources independently', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    const mockGetSchema = sinon.stub();
-    mockGetSchema
-        .onFirstCall()
-        .resolves({
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-        },
-    })
-        .onSecondCall()
-        .resolves({
-        properties: {
-            TRADE_ID: { genesisType: 'STRING' },
-        },
-    });
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    INCLUDE_COLUMNS: ['COUNTERPARTY_NAME', 'NAME'], // NAME is orphaned
-                },
-            },
-            {
-                KEY: 'TRADE',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'TRADE',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    INCLUDE_COLUMNS: ['TRADE_ID', 'OLD_FIELD'], // OLD_FIELD is orphaned
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const counterpartyKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const tradeKey = buildDatasourceName('TRADE', 'TRADE', 'REQ_REP');
-    assert.equal((_a = result.datasourceConfig[counterpartyKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 1);
-    assert.ok((_b = result.datasourceConfig[counterpartyKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _b === void 0 ? void 0 : _b.includes('COUNTERPARTY_NAME'));
-    assert.equal((_c = result.datasourceConfig[tradeKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _c === void 0 ? void 0 : _c.length, 1);
-    assert.ok((_d = result.datasourceConfig[tradeKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _d === void 0 ? void 0 : _d.includes('TRADE_ID'));
-}));
-TransformFromServerPayload('handles empty transformer configuration', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    assert.equal(JSON.stringify(cleanedConfig), JSON.stringify({}));
-}));
-TransformFromServerPayload('handles missing schema properties', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const mockGetSchema = sinon.stub();
-    const schemaWithoutProperties = {};
-    mockGetSchema.resolves(schemaWithoutProperties);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    INCLUDE_COLUMNS: ['NAME', 'AMOUNT'],
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    // All fields should be removed when schema has no properties
-    assert.equal((_a = cleanedConfig.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 0);
-}));
-TransformFromServerPayload('preserves base config correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        DESCRIPTION: 'Test Description',
-        OUTPUT_FORMAT: 'CSV',
-        FILE_NAME: 'test.csv',
-        AUTO_DISPATCH: true,
-        DESTINATION_IDS: ['dest1', 'dest2'],
-        OUTPUT_DIRECTORY: '/reports',
-        DOCUMENT_TEMPLATE_ID: 'template-123',
-        SCHEDULES: [
-            {
-                CRON_EXPRESSION: '0 0 0 * * ?',
-                TIME_ZONE: 'UTC',
-            },
-        ],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-            },
-        ],
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    assert.equal(result.baseConfig.ID, 'test-id');
-    assert.equal(result.baseConfig.NAME, 'Test Report');
-    assert.equal(result.baseConfig.DESCRIPTION, 'Test Description');
-    assert.equal(result.baseConfig.OUTPUT_FORMAT, 'CSV');
-    assert.equal(result.baseConfig.FILE_NAME, 'test.csv');
-    assert.equal(result.baseConfig.AUTO_DISPATCH, true);
-    assert.equal(JSON.stringify(result.baseConfig.DESTINATION_IDS), JSON.stringify(['dest1', 'dest2']));
-    assert.equal(result.baseConfig.OUTPUT_DIRECTORY, '/reports');
-    assert.equal(result.baseConfig.DOCUMENT_TEMPLATE_ID, 'template-123');
-    assert.ok(result.baseConfig.SCHEDULE);
-    assert.equal((_a = result.baseConfig.SCHEDULE) === null || _a === void 0 ? void 0 : _a.CRON_EXPRESSION, '0 0 0 * * ?');
-    assert.equal((_b = result.baseConfig.SCHEDULE) === null || _b === void 0 ? void 0 : _b.TIME_ZONE, 'UTC');
-}));
-TransformFromServerPayload('handles all transformer config types together', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f;
-    const mockGetSchema = sinon.stub();
-    const validSchema = {
-        properties: {
-            COUNTERPARTY_NAME: { genesisType: 'STRING' },
-            AMOUNT: { genesisType: 'DOUBLE' },
-        },
-    };
-    mockGetSchema.resolves(validSchema);
-    const payload = {
-        ID: 'test-id',
-        NAME: 'Test Report',
-        SCHEDULES: [],
-        DATA_SOURCES: [
-            {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {
-                    INCLUDE_COLUMNS: ['COUNTERPARTY_NAME', 'AMOUNT', 'NAME'], // NAME orphaned
-                    COLUMN_RENAMES: {
-                        COUNTERPARTY_NAME: 'Counterparty',
-                        NAME: 'Old Name', // orphaned
-                    },
-                    COLUMN_FORMATS: {
-                        AMOUNT: '#,##0.00',
-                        NAME: 'text', // orphaned
-                    },
-                    COLUMN_TRANSFORMS: {
-                        COUNTERPARTY_NAME: { TYPE: 'BINARY_EXPRESSION', LEFT: {}, OPERATION: 'AND', RIGHT: {} },
-                        NAME: { TYPE: 'METHOD_EXPRESSION', METHOD: 'TRIM', PARAMETERS: [] }, // orphaned
-                    },
-                    ROW_FILTERS: {
-                        TYPE: 'PREDICATE_EXPRESSION',
-                        OPERATION: 'AND',
-                        EXPRESSIONS: [],
-                    },
-                },
-            },
-        ],
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-    };
-    const result = yield transformFromServerPayload(payload, mockGetSchema);
-    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
-    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
-    // INCLUDE_COLUMNS should only have valid fields
-    assert.equal((_a = cleanedConfig.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 2);
-    assert.ok((_b = cleanedConfig.INCLUDE_COLUMNS) === null || _b === void 0 ? void 0 : _b.includes('COUNTERPARTY_NAME'));
-    assert.ok((_c = cleanedConfig.INCLUDE_COLUMNS) === null || _c === void 0 ? void 0 : _c.includes('AMOUNT'));
-    // COLUMN_RENAMES should only have valid fields
-    assert.equal(Object.keys(cleanedConfig.COLUMN_RENAMES || {}).length, 1);
-    assert.equal((_d = cleanedConfig.COLUMN_RENAMES) === null || _d === void 0 ? void 0 : _d['COUNTERPARTY_NAME'], 'Counterparty');
-    // COLUMN_FORMATS should only have valid fields
-    assert.equal(Object.keys(cleanedConfig.COLUMN_FORMATS || {}).length, 1);
-    assert.equal((_e = cleanedConfig.COLUMN_FORMATS) === null || _e === void 0 ? void 0 : _e['AMOUNT'], '#,##0.00');
-    // COLUMN_TRANSFORMS should only have valid fields
-    assert.equal(Object.keys(cleanedConfig.COLUMN_TRANSFORMS || {}).length, 1);
-    assert.ok((_f = cleanedConfig.COLUMN_TRANSFORMS) === null || _f === void 0 ? void 0 : _f['COUNTERPARTY_NAME']);
-    // ROW_FILTERS should be preserved
-    assert.ok(cleanedConfig.ROW_FILTERS);
-}));
-TransformFromServerPayload.run();
-const TransformToServerPayload = suite('transformToServerPayload');
-TransformToServerPayload('omits grouping fields when strategy is NONE', () => {
-    const state = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: '/reports',
-        },
-        datasourceConfig: {
-            REQ_REP_COUNTERPARTY_COUNTERPARTY: {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-        },
-    };
-    const result = transformToServerPayload(state);
-    const ds = result.DATA_SOURCES[0];
-    assert.equal(ds.KEY, 'COUNTERPARTY');
-    assert.ok(!('GROUPING_STRATEGY' in ds));
-    assert.ok(!('GROUP_KEY' in ds));
-});
-TransformToServerPayload('includes grouping fields when strategy is not NONE', () => {
-    const state = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: '/reports',
-        },
-        datasourceConfig: {
-            REQ_REP_COUNTERPARTY_COUNTERPARTY: {
-                KEY: 'COUNTERPARTY',
-                INPUT_TYPE: 'REQ_REP',
-                NAME: 'COUNTERPARTY',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'MULTI_SHEET',
-                GROUP_KEY: 'some_key',
-            },
-        },
-    };
-    const result = transformToServerPayload(state);
-    const ds = result.DATA_SOURCES[0];
-    assert.equal(ds.KEY, 'COUNTERPARTY');
-    assert.equal(ds.GROUPING_STRATEGY, 'MULTI_SHEET');
-    assert.equal(ds.GROUP_KEY, 'some_key');
-});
-TransformToServerPayload.run();

package/dist/esm/new/utils/validators.test.js

@@ -1,139 +0,0 @@
-import { assert, suite } from '@genesislcap/foundation-testing';
-import { validateDatasourceConfig } from './validators';
-const ValidateDatasourceConfig = suite('validateDatasourceConfig');
-ValidateDatasourceConfig('returns error when no datasources configured', () => {
-    const config = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: 'test',
-        },
-        datasourceConfig: {},
-    };
-    const result = validateDatasourceConfig(config);
-    assert.equal(result.k, 'err');
-    if (result.k === 'err') {
-        assert.ok(result.info.includes('At least one datasource needs to be configured'));
-    }
-});
-ValidateDatasourceConfig('returns ok when single datasource configured', () => {
-    const config = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: 'test',
-            OUTPUT_FORMAT: 'CSV',
-        },
-        datasourceConfig: {
-            REQ_REP_testSource_testAlias: {
-                KEY: 'testAlias',
-                NAME: 'testSource',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-        },
-    };
-    const result = validateDatasourceConfig(config);
-    assert.equal(result.k, 'ok');
-});
-ValidateDatasourceConfig('returns ok when multiple datasources and PDF format', () => {
-    const config = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: 'test',
-            OUTPUT_FORMAT: 'PDF',
-            DOCUMENT_TEMPLATE_ID: 'template1',
-        },
-        datasourceConfig: {
-            REQ_REP_source1_alias1: {
-                KEY: 'alias1',
-                NAME: 'source1',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-            REQ_REP_source2_alias2: {
-                KEY: 'alias2',
-                NAME: 'source2',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-        },
-    };
-    const result = validateDatasourceConfig(config);
-    assert.equal(result.k, 'ok');
-});
-ValidateDatasourceConfig('returns ok when multiple datasources and CSV format with template', () => {
-    const config = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: 'test',
-            OUTPUT_FORMAT: 'CSV',
-            DOCUMENT_TEMPLATE_ID: 'template1',
-        },
-        datasourceConfig: {
-            REQ_REP_source1_alias1: {
-                KEY: 'alias1',
-                NAME: 'source1',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-            REQ_REP_source2_alias2: {
-                KEY: 'alias2',
-                NAME: 'source2',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-        },
-    };
-    const result = validateDatasourceConfig(config);
-    assert.equal(result.k, 'ok');
-});
-ValidateDatasourceConfig('returns error when multiple datasources and CSV format without template', () => {
-    const config = {
-        baseConfig: {
-            DESTINATION_IDS: [],
-            OUTPUT_DIRECTORY: 'test',
-            OUTPUT_FORMAT: 'CSV',
-            DOCUMENT_TEMPLATE_ID: undefined,
-        },
-        datasourceConfig: {
-            REQ_REP_source1_alias1: {
-                KEY: 'alias1',
-                NAME: 'source1',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-            REQ_REP_source2_alias2: {
-                KEY: 'alias2',
-                NAME: 'source2',
-                INPUT_TYPE: 'REQ_REP',
-                OUTPUT_TYPE: 'TABLE',
-                TRANSFORMER_CONFIGURATION: {},
-                GROUPING_STRATEGY: 'NONE',
-                GROUP_KEY: null,
-            },
-        },
-    };
-    const result = validateDatasourceConfig(config);
-    assert.equal(result.k, 'err');
-    if (result.k === 'err') {
-        assert.ok(result.info.some((err) => err.includes('You cannot select more than one datasource')));
-    }
-});
-ValidateDatasourceConfig.run();

package/dist/esm/old/main/main.test.js

@@ -1,5 +0,0 @@
-import { assert, test } from '@genesislcap/foundation-testing';
-test('baseline', () => {
-    assert.is(true, true, 'Something is very wrong!');
-});
-test.run();

package/dist/esm/old/utils/filterObjectArray.test.js

@@ -1,46 +0,0 @@
-import { suite, assert } from '@genesislcap/foundation-testing';
-import { filterObjectArray } from './filterObjectArray';
-const accesor = 'id';
-const baseArray = [{ id: '1' }, { id: '2' }, { id: '3' }];
-const FilterObjectArray = suite('filterObjectArray()');
-FilterObjectArray('should return an array of the desired objects', () => {
-    const removalArray = [{ id: '2' }];
-    const result = filterObjectArray(accesor, baseArray, removalArray);
-    assert.is(result.length, 2);
-    assert.is(result.findIndex((item) => item.id === '2'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '1'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '3'), -1);
-});
-FilterObjectArray('should return array with same entries as baseArray if removalArray is empty', () => {
-    const removalArray = [];
-    const result = filterObjectArray(accesor, baseArray, removalArray);
-    assert.is(result.length, 3);
-    assert.is.not(result.findIndex((item) => item.id === '1'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '2'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '3'), -1);
-});
-FilterObjectArray('should return same entries as baseArray if removalArray is empty', () => {
-    const removalArray = [];
-    const result = filterObjectArray(accesor, baseArray, removalArray);
-    assert.is(result.length, 3);
-    assert.is.not(result.findIndex((item) => item.id === '1'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '2'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '3'), -1);
-});
-FilterObjectArray('should return same entries as baseArray if removalArray object cannot be found', () => {
-    const removalArray = [{ id: 'this does not exist' }];
-    const result = filterObjectArray(accesor, baseArray, removalArray);
-    assert.is(result.length, 3);
-    assert.is.not(result.findIndex((item) => item.id === '1'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '2'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '3'), -1);
-});
-FilterObjectArray('should return original array if no accesor provided', () => {
-    const removalArray = [{ id: '2' }];
-    const result = filterObjectArray(undefined, baseArray, removalArray);
-    assert.is(result.length, 3);
-    assert.is.not(result.findIndex((item) => item.id === '1'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '2'), -1);
-    assert.is.not(result.findIndex((item) => item.id === '3'), -1);
-});
-FilterObjectArray.run();