@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/dist/esm/new/main/edit-config/datasource-config/datasources-config-container.helpers.test.js

@@ -1,268 +0,0 @@
-import { __awaiter } from "tslib";
-import { logger } from '@genesislcap/foundation-comms';
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { actions, selectors } from '../../../store';
-import { createNewDatasourceConfig, findFirstValidDatasource, getDatasources, } from './datasources-config-container.helpers';
-const GetDatasources = suite('getDatasources()');
-GetDatasources.before.each(() => {
-    sinon.restore();
-});
-// GetDatasources('should combine REQ_REP and DATA_PIPELINE datasources', async () => {
-// const mockConnect = {
-// request: sinon.stub(),
-// };
-//
-// // Stub the REQ_REP response
-// mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-// REPLY: [{ DATASOURCE_NAME: 'ReqRep1' }, { DATASOURCE_NAME: 'ReqRep2' }],
-// });
-//
-// // Stub the DATA_PIPELINE response
-// mockConnect.request.withArgs('REPORTING_DATA_PIPELINES', { REQUEST: {} }).resolves({
-// REPLY: [{ NAME: 'Pipeline1' }, { NAME: 'Pipeline2' }],
-// });
-//
-// const result = await getDatasources(mockConnect as Connect);
-//
-// assert.equal(result.length, 4);
-// assert.equal(result[0], { name: 'ReqRep1', inputType: 'REQ_REP' });
-// assert.equal(result[1], { name: 'ReqRep2', inputType: 'REQ_REP' });
-// assert.equal(result[2], { name: 'Pipeline1', inputType: 'DATA_PIPELINE' });
-// assert.equal(result[3], { name: 'Pipeline2', inputType: 'DATA_PIPELINE' });
-// assert.ok(mockConnect.request.calledTwice);
-// });
-GetDatasources('should throw error when REQ_REP request fails', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        request: sinon.stub(),
-    };
-    mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-        REPLY: null,
-    });
-    try {
-        yield getDatasources(mockConnect);
-        assert.unreachable('Should have thrown an error');
-    }
-    catch (error) {
-        assert.instance(error, Error);
-        assert.is(error.message, 'REQ_REP request');
-    }
-}));
-// GetDatasources('should throw error when DATA_PIPELINE request fails', async () => {
-// const mockConnect = {
-// request: sinon.stub(),
-// };
-//
-// mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-// REPLY: [{ DATASOURCE_NAME: 'ReqRep1' }],
-// });
-//
-// mockConnect.request.withArgs('REPORTING_DATA_PIPELINES', { REQUEST: {} }).resolves({
-// REPLY: null,
-// });
-//
-// try {
-// await getDatasources(mockConnect as Connect);
-// assert.unreachable('Should have thrown an error');
-// } catch (error) {
-// assert.instance(error, Error);
-// assert.is(error.message, 'DATA_PIPELINE request');
-// }
-// });
-GetDatasources('should handle empty responses', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        request: sinon.stub(),
-    };
-    mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-        REPLY: [],
-    });
-    // mockConnect.request.withArgs('REPORTING_DATA_PIPELINES', { REQUEST: {} }).resolves({
-    // REPLY: [],
-    // });
-    //
-    const result = yield getDatasources(mockConnect);
-    assert.equal(result.length, 0);
-    // assert.ok(mockConnect.request.calledTwice);
-    assert.ok(mockConnect.request.calledOnce);
-}));
-GetDatasources.run();
-const FindFirstValidDatasource = suite('findFirstValidDatasource()');
-FindFirstValidDatasource.before.each(() => {
-    sinon.restore();
-});
-FindFirstValidDatasource('should return first valid datasource with schema', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockSchema = { properties: { someProperty: 'value' } };
-    const getSchemaStub = sinon.stub().resolves(mockSchema);
-    const validDatasources = [
-        { name: 'TEST_SOURCE', inputType: 'REQ_REP' },
-    ];
-    const result = yield findFirstValidDatasource(getSchemaStub)(validDatasources);
-    assert.equal(result.KEY, 'TEST_SOURCE');
-    assert.equal(result.INPUT_TYPE, 'REQ_REP');
-    assert.equal(result.schema, mockSchema);
-    assert.ok(getSchemaStub.calledOnce);
-    assert.ok(getSchemaStub.calledWith('TEST_SOURCE'));
-}));
-FindFirstValidDatasource('should try next datasource if first fails', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockSchema = { properties: { someProperty: 'value' } };
-    const getSchemaStub = sinon.stub();
-    getSchemaStub.onFirstCall().rejects(new Error('Failed'));
-    getSchemaStub.onSecondCall().resolves(mockSchema);
-    const validDatasources = [
-        { name: 'FAILED_SOURCE', inputType: 'REQ_REP' },
-        { name: 'VALID_SOURCE', inputType: 'DATA_PIPELINE' },
-    ];
-    const result = yield findFirstValidDatasource(getSchemaStub)(validDatasources);
-    assert.equal(result.KEY, 'VALID_SOURCE');
-    assert.equal(result.INPUT_TYPE, 'DATA_PIPELINE');
-    assert.equal(result.schema, mockSchema);
-    assert.ok(getSchemaStub.calledTwice);
-}));
-FindFirstValidDatasource('should throw error if no valid datasources found', () => __awaiter(void 0, void 0, void 0, function* () {
-    const getSchemaStub = sinon.stub().rejects(new Error('Failed'));
-    const validDatasources = [
-        { name: 'FAILED_SOURCE', inputType: 'REQ_REP' },
-    ];
-    try {
-        yield findFirstValidDatasource(getSchemaStub)(validDatasources);
-        assert.unreachable('Should have thrown an error');
-    }
-    catch (error) {
-        assert.instance(error, Error);
-        assert.equal(error.message, 'No valid datasources found');
-    }
-    assert.ok(getSchemaStub.calledOnce);
-}));
-FindFirstValidDatasource('should skip schema without properties', () => __awaiter(void 0, void 0, void 0, function* () {
-    const invalidSchema = { properties: null };
-    const validSchema = { properties: { someProperty: 'value' } };
-    const getSchemaStub = sinon.stub();
-    getSchemaStub.onFirstCall().resolves(invalidSchema);
-    getSchemaStub.onSecondCall().resolves(validSchema);
-    const validDatasources = [
-        { name: 'INVALID_SCHEMA', inputType: 'REQ_REP' },
-        { name: 'VALID_SCHEMA', inputType: 'DATA_PIPELINE' },
-    ];
-    const result = yield findFirstValidDatasource(getSchemaStub)(validDatasources);
-    assert.equal(result.KEY, 'VALID_SCHEMA');
-    assert.equal(result.INPUT_TYPE, 'DATA_PIPELINE');
-    assert.equal(result.schema, validSchema);
-    assert.ok(getSchemaStub.calledTwice);
-}));
-FindFirstValidDatasource.run();
-const CreateNewDatasourceConfig = suite('createNewDatasourceConfig()');
-CreateNewDatasourceConfig.before.each(() => {
-    sinon.restore();
-});
-CreateNewDatasourceConfig('should exit when no valid datasources are available', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
-    const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-        REQ_REP_testSource_testSource: {
-            KEY: 'testSource',
-            NAME: 'testSource',
-            INPUT_TYPE: 'REQ_REP',
-            OUTPUT_TYPE: 'TABLE',
-            TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-            GROUPING_STRATEGY: 'NONE',
-            GROUP_KEY: null,
-        },
-    });
-    const loggerStub = sinon.stub(logger, 'error');
-    const getSchemaStub = sinon.stub().resolves({});
-    yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.ok(getAllConfigSetStub.calledOnce);
-    assert.ok(loggerStub.calledWith('No datasources available to create new config from'));
-    assert.ok(!getSchemaStub.called);
-}));
-CreateNewDatasourceConfig('should exit when trying to add multiple datasources with CSV format', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
-    const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-        REQ_REP_existingSource_existingAlias: {
-            KEY: 'existingAlias',
-            NAME: 'existingSource',
-            INPUT_TYPE: 'REQ_REP',
-            OUTPUT_TYPE: 'TABLE',
-            TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-            GROUPING_STRATEGY: 'NONE',
-            GROUP_KEY: null,
-        },
-    });
-    const getConfigStub = sinon.stub(selectors.baseConfig, 'getConfig').returns({
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-        OUTPUT_FORMAT: 'CSV',
-    });
-    const loggerStub = sinon.stub(logger, 'error');
-    const getSchemaStub = sinon.stub().resolves({});
-    yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.equal(getAllConfigSetStub.callCount, 1, 'getAllConfigSetStub should be called once');
-    assert.equal(getConfigStub.callCount, 1, 'getConfigStub should be called once');
-    // assert.ok(loggerStub.calledWith('Cannot add multiple datasources when using csv file without a template'));
-    if (loggerStub.args.length > 0) {
-        assert.equal(loggerStub.args[0][0], 'Cannot add multiple datasources when using csv file without a template');
-    }
-    else {
-        assert.unreachable('Logger was not called');
-    }
-    assert.equal(getSchemaStub.callCount, 0, 'getSchemaStub should not be called');
-}));
-CreateNewDatasourceConfig('should allow adding multiple datasources with CSV format IF template is selected', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
-    const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-        REQ_REP_existingSource_existingAlias: {
-            KEY: 'existingAlias',
-            NAME: 'existingSource',
-            INPUT_TYPE: 'REQ_REP',
-            OUTPUT_TYPE: 'TABLE',
-            TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-            GROUPING_STRATEGY: 'NONE',
-            GROUP_KEY: null,
-        },
-    });
-    sinon.stub(selectors.baseConfig, 'getConfig').returns({
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-        OUTPUT_FORMAT: 'CSV',
-        DOCUMENT_TEMPLATE_ID: 'some-template-id',
-    });
-    const mockSchema = {
-        properties: {
-            field1: {},
-            field2: {},
-        },
-    };
-    const getSchemaStub = sinon.stub().resolves(mockSchema);
-    const initConfigStub = sinon.stub(actions.datasourceConfig, 'initDatasourceConfiguration');
-    yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.ok(getAllConfigSetStub.calledOnce);
-    assert.ok(getSchemaStub.calledOnce);
-    assert.ok(initConfigStub.called);
-}));
-CreateNewDatasourceConfig('should successfully create new datasource configuration', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
-    const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({});
-    sinon.stub(selectors.baseConfig, 'getConfig').returns({
-        DESTINATION_IDS: [],
-        OUTPUT_DIRECTORY: '/reports',
-        OUTPUT_FORMAT: 'XLSX',
-    });
-    const mockSchema = {
-        properties: {
-            field1: {},
-            field2: {},
-        },
-    };
-    const getSchemaStub = sinon.stub().resolves(mockSchema);
-    const initConfigStub = sinon.stub(actions.datasourceConfig, 'initDatasourceConfiguration');
-    yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.ok(getAllConfigSetStub.calledOnce);
-    assert.ok(getSchemaStub.calledOnce);
-    assert.ok(initConfigStub.calledWith(sinon.match({
-        base: sinon.match({
-            KEY: 'testSource',
-            NAME: 'testSource',
-            INPUT_TYPE: 'REQ_REP',
-        }),
-        fields: sinon.match.array.deepEquals(['field1', 'field2']),
-    })));
-}));
-CreateNewDatasourceConfig.run();

package/dist/esm/new/main/edit-config/row-filters/row-filters.helpers.test.js

@@ -1 +0,0 @@
-export {};