@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/dist/esm/new/main/edit-config/shared/datasource-data-base-component.test.js

@@ -1,426 +0,0 @@
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { actions, selectors } from '../../../store';
-import { convertToPathFormat, datasourceNameForDisplay, datasourceNameFromDisplay, lookupColumnIsIncluded, mapTypeToRenderer, pathParameters, shouldDisableColumn, configureDisabledColumns, } from './datasource-data-base-component.helpers.ts';
-import { GridColumnNames } from './datasource-data-base-component.types';
-// Helper function to create consistent test data
-function createTestRowData(overrides = {}) {
-    const result = {
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'Test Column',
-        [GridColumnNames.Type]: 'STRING',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    // Apply overrides properly
-    return Object.assign(Object.assign({}, result), overrides);
-}
-// Type for SelectRendererParams
-const FIRST_PARAM = 0;
-// DatasourceNameFromDisplay tests
-const DatasourceNameFromDisplayTests = suite('datasourceNameFromDisplay()');
-DatasourceNameFromDisplayTests.before.each(() => {
-    sinon.restore();
-});
-DatasourceNameFromDisplayTests('Correctly builds datasource key from Snapshot (REQ_REP) input', () => {
-    const input = 'myService (Snapshot)';
-    const expected = 'REQ_REP_myService_myService';
-    assert.equal(datasourceNameFromDisplay(input), expected);
-});
-DatasourceNameFromDisplayTests('Correctly builds datasource key from Data Pipeline (DATA_PIPELINE) input', () => {
-    const input = 'dataFlow (Data Pipeline)';
-    const expected = 'DATA_PIPELINE_dataFlow_dataFlow';
-    assert.equal(datasourceNameFromDisplay(input), expected);
-});
-DatasourceNameFromDisplayTests.run();
-// datasourceNameForDisplay tests
-const DatasourceNameForDisplayTests = suite('datasourceNameForDisplay()');
-DatasourceNameForDisplayTests('Correctly formats REQ_REP datasource for display', () => {
-    const datasource = 'myService';
-    const type = 'REQ_REP';
-    const expected = 'myService (Snapshot)';
-    assert.equal(datasourceNameForDisplay(datasource, type), expected);
-});
-DatasourceNameForDisplayTests('Correctly formats DATA_PIPELINE datasource for display', () => {
-    const datasource = 'dataFlow';
-    const type = 'DATA_PIPELINE';
-    const expected = 'dataFlow (Data Pipeline)';
-    assert.equal(datasourceNameForDisplay(datasource, type), expected);
-});
-DatasourceNameForDisplayTests.run();
-// LookupColumnIsFiltered tests
-const LookupColumnIsIncluded = suite('lookupColumnIsIncluded');
-LookupColumnIsIncluded.before.each(() => {
-    sinon.restore();
-});
-LookupColumnIsIncluded('returns true when column is in included', () => {
-    const mockData = {
-        [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'testColumn',
-        [GridColumnNames.Type]: 'STRING',
-    };
-    const mockDatasource = {
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-        TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
-    };
-    sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-    const result = lookupColumnIsIncluded(mockData);
-    assert.equal(result, true);
-});
-LookupColumnIsIncluded('returns false when column is not in filters', () => {
-    const mockData = {
-        [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-        [GridColumnNames.ColumnName]: 'nonFilteredColumn',
-        [GridColumnNames.DisplayName]: 'nonFilteredColumn',
-        [GridColumnNames.Type]: 'STRING',
-    };
-    const mockDatasource = {
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-        TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
-    };
-    sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-    const result = lookupColumnIsIncluded(mockData);
-    assert.equal(result, false);
-});
-LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is undefined', () => {
-    const mockData = {
-        [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'testColumn',
-        [GridColumnNames.Type]: 'STRING',
-    };
-    const mockDatasource = {
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-        TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: undefined },
-    };
-    sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-    const result = lookupColumnIsIncluded(mockData);
-    assert.equal(result, false);
-});
-LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is empty array', () => {
-    const mockData = {
-        [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'testColumn',
-        [GridColumnNames.Type]: 'STRING',
-    };
-    const mockDatasource = {
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-        TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-    };
-    sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-    const result = lookupColumnIsIncluded(mockData);
-    assert.equal(result, false);
-});
-LookupColumnIsIncluded.run();
-// PathParametersTests tests
-const PathParametersTests = suite('pathParameters()');
-// Helper function to build JSON schema for testing
-function buildJsonSchema(properties) {
-    return {
-        type: 'object',
-        properties: properties,
-    };
-}
-PathParametersTests('Should convert simple schema properties to grid row data', () => {
-    const datasource = {
-        name: 'TestDatasource',
-        spec: {
-            properties: {
-                field1: {
-                    genesisType: 'STRING',
-                },
-                field2: {
-                    genesisType: 'INT',
-                },
-                field3: {
-                    genesisType: 'BOOLEAN',
-                },
-            },
-        },
-    };
-    const result = pathParameters(datasource);
-    assert.equal(result.length, 3);
-    assert.equal(result[0][GridColumnNames.ColumnName], 'field1');
-    assert.equal(result[0][GridColumnNames.DisplayName], 'field1');
-    assert.equal(result[0][GridColumnNames.Type], 'STRING');
-    assert.equal(result[0][GridColumnNames.Datasource], 'TestDatasource');
-    assert.equal(result[1][GridColumnNames.ColumnName], 'field2');
-    assert.equal(result[1][GridColumnNames.Type], 'INT');
-    assert.equal(result[2][GridColumnNames.ColumnName], 'field3');
-    assert.equal(result[2][GridColumnNames.Type], 'BOOLEAN');
-});
-PathParametersTests('Should handle nullable enum types and extract enum values correctly', () => {
-    // Schema with nullable enum field to test the handling of enum values
-    const datasource = {
-        name: 'TradesData',
-        spec: {
-            properties: {
-                TRADE_ID: {
-                    type: 'integer',
-                    description: '',
-                    genesisType: 'LONG',
-                },
-                DIRECTION: {
-                    oneOf: [
-                        {
-                            type: 'null',
-                        },
-                        {
-                            type: 'string',
-                            enum: ['SELL', 'SHORT_SELL', 'BUY'],
-                        },
-                    ],
-                    description: '',
-                    genesisType: 'ENUM',
-                    // No top-level enum property - matches server payload
-                },
-                INSTRUMENT_ID: {
-                    oneOf: [
-                        {
-                            type: 'null',
-                        },
-                        {
-                            type: 'integer',
-                        },
-                    ],
-                    description: '',
-                    genesisType: 'LONG',
-                },
-            },
-            additionalProperties: false,
-            required: [],
-        },
-    };
-    const result = pathParameters(datasource);
-    // Find the DIRECTION field result
-    const directionField = result.find((row) => row[GridColumnNames.ColumnName] === 'DIRECTION');
-    assert.ok(directionField, 'DIRECTION field should be in the results');
-    assert.equal(directionField[GridColumnNames.Type], 'ENUM', 'Type should be ENUM');
-    // Check that EnumValues array exists and contains the expected values
-    assert.ok(Array.isArray(directionField[GridColumnNames.EnumValues]), 'EnumValues should be an array');
-    assert.equal(directionField[GridColumnNames.EnumValues].length, 3, 'EnumValues should have 3 items');
-    assert.equal(directionField[GridColumnNames.EnumValues][0], 'SELL');
-    assert.equal(directionField[GridColumnNames.EnumValues][1], 'SHORT_SELL');
-    assert.equal(directionField[GridColumnNames.EnumValues][2], 'BUY');
-});
-PathParametersTests('Should handle non-nullable enum types with top-level enum property', () => {
-    // Schema with non-nullable enum field (direct enum property)
-    const datasource = {
-        name: 'StatusData',
-        spec: {
-            properties: {
-                STATUS: {
-                    type: 'string',
-                    enum: ['ACTIVE', 'PENDING', 'COMPLETED', 'CANCELLED'],
-                    description: 'Status field',
-                    genesisType: 'ENUM',
-                },
-            },
-            additionalProperties: false,
-            required: [],
-        },
-    };
-    const result = pathParameters(datasource);
-    // Find the STATUS field result
-    const statusField = result.find((row) => row[GridColumnNames.ColumnName] === 'STATUS');
-    assert.ok(statusField, 'STATUS field should be in the results');
-    assert.equal(statusField[GridColumnNames.Type], 'ENUM', 'Type should be ENUM');
-    // Check that EnumValues array exists and contains the expected values
-    assert.ok(Array.isArray(statusField[GridColumnNames.EnumValues]), 'EnumValues should be an array');
-    assert.equal(statusField[GridColumnNames.EnumValues].length, 4, 'EnumValues should have 4 items');
-    assert.equal(statusField[GridColumnNames.EnumValues][0], 'ACTIVE');
-    assert.equal(statusField[GridColumnNames.EnumValues][1], 'PENDING');
-    assert.equal(statusField[GridColumnNames.EnumValues][2], 'COMPLETED');
-    assert.equal(statusField[GridColumnNames.EnumValues][3], 'CANCELLED');
-});
-PathParametersTests('Should throw error for malformed enum schema without enum values', () => {
-    // Schema with malformed enum field (no enum values available)
-    const datasource = {
-        name: 'MalformedData',
-        spec: {
-            properties: {
-                BROKEN_ENUM: {
-                    description: 'Malformed enum without values',
-                    genesisType: 'ENUM',
-                    // Missing enum and oneOf - should cause an error
-                },
-            },
-            additionalProperties: false,
-            required: [],
-        },
-    };
-    // Should throw an error with specific message
-    assert.throws(() => pathParameters(datasource), Error, "Could not extract enum values for field 'BROKEN_ENUM'");
-});
-PathParametersTests('Should throw error when no properties exist', () => {
-    const datasource = {
-        name: 'TestDatasource',
-        spec: { type: 'object' }, // Schema without properties
-    };
-    assert.throws(() => pathParameters(datasource), Error, 'No properties on schema for datasource TestDatasource');
-});
-PathParametersTests('Should handle empty properties object', () => {
-    const datasource = {
-        name: 'TestDatasource',
-        spec: buildJsonSchema({}),
-    };
-    assert.equal(pathParameters(datasource), []);
-});
-PathParametersTests.run();
-// ConvertToPathFormat tests
-const ConvertToPathFormat = suite('convertToPathFormat()');
-ConvertToPathFormat('Converts basic string to path format', () => {
-    assert.equal(convertToPathFormat('hello'), '/req-hello');
-});
-ConvertToPathFormat('Converts uppercase string to lowercase path format', () => {
-    assert.equal(convertToPathFormat('HELLO'), '/req-hello');
-});
-ConvertToPathFormat('Converts string with underscores to dashes', () => {
-    assert.equal(convertToPathFormat('hello_world'), '/req-hello-world');
-});
-ConvertToPathFormat('Converts mixed case string with multiple underscores', () => {
-    assert.equal(convertToPathFormat('HELLO_World_TEST'), '/req-hello-world-test');
-});
-ConvertToPathFormat('Handles empty string', () => {
-    assert.equal(convertToPathFormat(''), '/req-');
-});
-ConvertToPathFormat.run();
-// MapTypeToRenderer tests
-const MapTypeToRendererTests = suite('mapTypeToRenderer');
-MapTypeToRendererTests('returns "boolean" for boolean type', () => {
-    const result = mapTypeToRenderer('BOOLEAN');
-    assert.equal(result, 'boolean');
-});
-MapTypeToRendererTests('returns "string" for string type', () => {
-    const result = mapTypeToRenderer('STRING');
-    assert.equal(result, 'string');
-});
-MapTypeToRendererTests('returns "string" for enum type', () => {
-    const result = mapTypeToRenderer('ENUM');
-    assert.equal(result, 'string');
-});
-MapTypeToRendererTests('returns "number" for number type', () => {
-    const result = mapTypeToRenderer('LONG');
-    assert.equal(result, 'number');
-});
-MapTypeToRendererTests('returns "number" for integer type', () => {
-    const result = mapTypeToRenderer('INT');
-    assert.equal(result, 'number');
-});
-MapTypeToRendererTests('returns "number" for DOUBLE type', () => {
-    const result = mapTypeToRenderer('DOUBLE');
-    assert.equal(result, 'number');
-});
-MapTypeToRendererTests('returns "number" for SHORT type', () => {
-    const result = mapTypeToRenderer('SHORT');
-    assert.equal(result, 'number');
-});
-MapTypeToRendererTests('returns "number" for BIGDECIMAL type', () => {
-    const result = mapTypeToRenderer('BIGDECIMAL');
-    assert.equal(result, 'number');
-});
-MapTypeToRendererTests('returns null for unsupported type', () => {
-    const result = mapTypeToRenderer('UNSUPPORTED_TYPE');
-    assert.equal(result, null);
-});
-MapTypeToRendererTests.run();
-// ShouldDisableColumn tests
-const ShouldDisableColumnTests = suite('shouldDisableColumn()');
-ShouldDisableColumnTests.before.each(() => {
-    sinon.restore();
-});
-ShouldDisableColumnTests('should return true when Type is undefined', () => {
-    const mockData = {
-        [GridColumnNames.Type]: undefined,
-    };
-    const result = shouldDisableColumn(mockData);
-    assert.equal(result, true);
-});
-ShouldDisableColumnTests('should return true when Type is RAW', () => {
-    const mockData = {
-        [GridColumnNames.Type]: 'RAW',
-    };
-    const result = shouldDisableColumn(mockData);
-    assert.equal(result, true);
-});
-ShouldDisableColumnTests('should return false when Type is valid', () => {
-    const mockData = {
-        [GridColumnNames.Type]: 'STRING',
-    };
-    const result = shouldDisableColumn(mockData);
-    assert.equal(result, false);
-});
-ShouldDisableColumnTests.run();
-// ConfigureDisabledColumns tests
-const ConfigureDisabledColumnsTests = suite('configureDisabledColumns()');
-ConfigureDisabledColumnsTests.before.each(() => {
-    sinon.restore();
-});
-ConfigureDisabledColumnsTests('should not set column filter when column type is valid', () => {
-    // Using enum keys now that imports are fixed
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'Test Column',
-        [GridColumnNames.Type]: 'STRING',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
-    const result = configureDisabledColumns(mockData);
-    assert.equal(result, mockData);
-    assert.ok(setColumnIncludedStub.notCalled);
-});
-ConfigureDisabledColumnsTests('should set column filter when column type is RAW', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'Test Column',
-        [GridColumnNames.Type]: 'RAW',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
-    const result = configureDisabledColumns(mockData);
-    assert.equal(result, mockData);
-    assert.ok(setColumnIncludedStub.calledOnce);
-    assert.ok(setColumnIncludedStub.calledWith({
-        key: datasourceNameFromDisplay(mockData[GridColumnNames.Datasource]),
-        column: mockData[GridColumnNames.ColumnName],
-        included: false,
-    }));
-});
-ConfigureDisabledColumnsTests('should set column filter when column type is undefined', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'testColumn',
-        [GridColumnNames.DisplayName]: 'Test Column',
-        [GridColumnNames.Type]: undefined,
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
-    const result = configureDisabledColumns(mockData);
-    assert.equal(result, mockData);
-    assert.ok(setColumnIncludedStub.calledOnce);
-    assert.ok(setColumnIncludedStub.calledWith({
-        key: datasourceNameFromDisplay(mockData[GridColumnNames.Datasource]),
-        column: mockData[GridColumnNames.ColumnName],
-        included: false,
-    }));
-});
-ConfigureDisabledColumnsTests.run();

package/dist/esm/new/utils/alias-generator.test.js

@@ -1,36 +0,0 @@
-import { assert, suite } from '@genesislcap/foundation-testing';
-import { generateUniqueAlias } from './alias-generator';
-const GenerateUniqueAlias = suite('generateUniqueAlias');
-GenerateUniqueAlias('returns the base alias if it does not exist', () => {
-    const existingAliases = new Set(['other']);
-    const alias = generateUniqueAlias('test', existingAliases);
-    assert.equal(alias, 'test');
-});
-GenerateUniqueAlias('increments the alias if it already exists', () => {
-    const existingAliases = new Set(['test']);
-    const alias = generateUniqueAlias('test', existingAliases);
-    assert.equal(alias, 'test_1');
-});
-GenerateUniqueAlias('increments the alias until it is unique', () => {
-    const existingAliases = new Set(['test', 'test_1']);
-    const alias = generateUniqueAlias('test', existingAliases);
-    assert.equal(alias, 'test_2');
-});
-GenerateUniqueAlias('handles case-insensitivity when checking for existing aliases', () => {
-    const existingAliases = new Set(['Test']);
-    const alias = generateUniqueAlias('test', existingAliases);
-    assert.equal(alias, 'test_1');
-});
-GenerateUniqueAlias('handles case-insensitivity for new alias generation', () => {
-    const existingAliases = new Set(['test']);
-    const alias = generateUniqueAlias('Test', existingAliases);
-    // Since input baseAlias is 'Test', it tries 'Test'. 'Test' matches 'test' case-insensitively.
-    // Next attempt 'Test_1'.
-    assert.equal(alias, 'Test_1');
-});
-GenerateUniqueAlias('handles mixed case existing aliases', () => {
-    const existingAliases = new Set(['TeSt', 'tEsT_1']);
-    const alias = generateUniqueAlias('test', existingAliases);
-    assert.equal(alias, 'test_2');
-});
-GenerateUniqueAlias.run();

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

@@ -1,162 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { getDatasourceSchema, getEndpointUrl } from './endpoint';
-const GetDatasourceSchema = suite('getDatasourceSchema');
-GetDatasourceSchema.before.each(() => {
-    sinon.restore();
-});
-GetDatasourceSchema('returns schema items when response is valid', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        getJSONSchema: sinon.stub(),
-    };
-    const mockResponse = {
-        OUTBOUND: {
-            properties: {
-                REPLY: {
-                    items: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-            },
-        },
-    };
-    mockConnect.getJSONSchema.resolves(mockResponse);
-    const getSchema = getDatasourceSchema(mockConnect);
-    const result = yield getSchema('TEST_RESOURCE');
-    assert.equal(result, mockResponse.OUTBOUND.properties.REPLY.items);
-}));
-GetDatasourceSchema('surfaces server error response instead of a shape error', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        getJSONSchema: sinon.stub(),
-    };
-    const mockResponse = {
-        MESSAGE_TYPE: 'JSON_SCHEMA_NACK',
-        ERROR: [
-            {
-                '@type': 'StandardError',
-                CODE: 'FEATURE_NOT_FOUND',
-                STATUS_CODE: '404 Not Found',
-                TEXT: 'Feature not found',
-            },
-        ],
-    };
-    mockConnect.getJSONSchema.resolves(mockResponse);
-    const getSchema = getDatasourceSchema(mockConnect);
-    try {
-        yield getSchema('Allocations');
-        assert.unreachable('Expected function to throw');
-    }
-    catch (error) {
-        assert.equal(error.message, 'Failed to fetch JSON schema for Allocations: 404 Not Found - FEATURE_NOT_FOUND - Feature not found');
-    }
-}));
-GetDatasourceSchema('throws error when items is missing', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        getJSONSchema: sinon.stub(),
-    };
-    const mockResponse = {
-        OUTBOUND: {
-            properties: {
-                REPLY: {
-                    type: 'object',
-                },
-            },
-        },
-    };
-    mockConnect.getJSONSchema.resolves(mockResponse);
-    const getSchema = getDatasourceSchema(mockConnect);
-    try {
-        yield getSchema('TEST_RESOURCE');
-        assert.unreachable('Expected function to throw');
-    }
-    catch (error) {
-        assert.equal(error.message, 'Invalid response shape for TEST_RESOURCE');
-    }
-}));
-GetDatasourceSchema('throws error when REPLY is not an object', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        getJSONSchema: sinon.stub(),
-    };
-    const mockResponse = {
-        OUTBOUND: {
-            properties: {
-                REPLY: 'not an object',
-            },
-        },
-    };
-    mockConnect.getJSONSchema.resolves(mockResponse);
-    const getSchema = getDatasourceSchema(mockConnect);
-    try {
-        yield getSchema('TEST_RESOURCE');
-        assert.unreachable('Expected function to throw');
-    }
-    catch (error) {
-        assert.equal(error.message, 'Invalid response shape for TEST_RESOURCE');
-    }
-}));
-GetDatasourceSchema('throws error when items is an array', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockConnect = {
-        getJSONSchema: sinon.stub(),
-    };
-    const mockResponse = {
-        OUTBOUND: {
-            properties: {
-                REPLY: {
-                    items: [],
-                },
-            },
-        },
-    };
-    mockConnect.getJSONSchema.resolves(mockResponse);
-    const getSchema = getDatasourceSchema(mockConnect);
-    try {
-        yield getSchema('TEST_RESOURCE');
-        assert.unreachable('Expected function to throw');
-    }
-    catch (error) {
-        assert.equal(error.message, 'Items is an array');
-    }
-}));
-GetDatasourceSchema.run();
-const GetEndpointUrl = suite('getEndpointUrl');
-GetEndpointUrl.before.each(() => {
-    sinon.restore();
-    // Clear sessionStorage before each test
-    sessionStorage.clear();
-});
-GetEndpointUrl('returns correct http URL for localhost', () => {
-    const endpoint = 'api/data';
-    const urlRoot = 'http://localhost:3000';
-    const result = getEndpointUrl(endpoint, urlRoot);
-    assert.equal(result, 'http://localhost:3000/api/data');
-});
-GetEndpointUrl('returns correct https URL for non-localhost', () => {
-    const endpoint = 'api/data';
-    const urlRoot = 'https://example.com';
-    const result = getEndpointUrl(endpoint, urlRoot);
-    assert.equal(result, 'https://example.com/api/data');
-});
-GetEndpointUrl('handles urlRoot with trailing slash correctly', () => {
-    const endpoint = 'api/data';
-    const urlRoot = 'https://example.com/';
-    const result = getEndpointUrl(endpoint, urlRoot);
-    assert.equal(result, 'https://example.com/api/data');
-});
-GetEndpointUrl('handles urlRoot with path correctly', () => {
-    const endpoint = 'api/data';
-    const urlRoot = 'https://example.com/base/path';
-    const result = getEndpointUrl(endpoint, urlRoot);
-    assert.equal(result, 'https://example.com/base/path/api/data');
-});
-GetEndpointUrl('uses sessionStorage hostUrl when urlRoot is not provided', () => {
-    sessionStorage.setItem('hostUrl', 'https://example.com/base');
-    const endpoint = 'api/data';
-    const result = getEndpointUrl(endpoint);
-    assert.equal(result, 'https://example.com/base/api/data');
-});
-GetEndpointUrl('throws error when no valid URL is provided', () => {
-    const endpoint = 'api/data';
-    assert.throws(() => getEndpointUrl(endpoint), 'Invalid URL');
-});
-GetEndpointUrl.run();