@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/dist/esm/new/main/edit-config/data-transforms-derived-fields/data-transforms.helpers.test.js

@@ -1,629 +0,0 @@
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { actions, selectors } from '../../../store';
-import { GridColumnNames } from '../shared';
-import { determineDateLocaleFormat, FormatToConfigTokens, getDateConfig, lookupColumnFormat, mapToDateFormat, transformFromFormatString, validateFormatString, valueExprCellRendereronChange, mapToNumberFormat, transformFromNumberFormatString, getDefaultFormat, } from './data-transforms.helpers';
-import { DateLocaleFormats, DateMonthFormats, DateStandardFormats, DateTimeFormats, DateYearFormats, FormatTypes, NumericFormats, NumericCurrencies, isNumericFieldType, } from './data-transforms.types';
-const LookupColumnFormat = suite('LookupColumnFormat()');
-LookupColumnFormat.before.each(() => {
-    sinon.restore();
-});
-LookupColumnFormat('should return empty string when no format is found', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'originalColumn',
-        [GridColumnNames.Format]: '',
-        [GridColumnNames.Type]: 'DATETIME',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const getDatasourceStub = sinon.stub(selectors.datasourceConfig, 'getDatasource').returns({
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        TRANSFORMER_CONFIGURATION: { COLUMN_FORMATS: {} },
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-    });
-    const result = lookupColumnFormat(mockData);
-    assert.equal(result[GridColumnNames.Format], ''); // No format found, returns empty string
-    assert.ok(getDatasourceStub.calledOnce);
-});
-LookupColumnFormat('should return data with format when format exists', () => {
-    const originalColumn = 'originalColumn';
-    const newFormat = 'dd/MM/yyyy';
-    const mockData = {
-        [GridColumnNames.ColumnName]: originalColumn,
-        [GridColumnNames.Format]: newFormat,
-        [GridColumnNames.Type]: 'STRING',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const getDatasourceStub = sinon.stub(selectors.datasourceConfig, 'getDatasource').returns({
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        TRANSFORMER_CONFIGURATION: {
-            COLUMN_FORMATS: {
-                [originalColumn]: newFormat,
-            },
-        },
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-    });
-    const result = lookupColumnFormat(mockData);
-    assert.equal(result[GridColumnNames.Format], newFormat);
-    assert.equal(result[GridColumnNames.ColumnName], mockData[GridColumnNames.ColumnName]);
-    assert.equal(result[GridColumnNames.Type], mockData[GridColumnNames.Type]);
-    assert.equal(result[GridColumnNames.Datasource], mockData[GridColumnNames.Datasource]);
-    assert.ok(getDatasourceStub.calledOnce);
-});
-LookupColumnFormat('should handle undefined COLUMN_FORMATS', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'originalColumn',
-        [GridColumnNames.Format]: '',
-        [GridColumnNames.Type]: 'STRING',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const getDatasourceStub = sinon.stub(selectors.datasourceConfig, 'getDatasource').returns({
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        TRANSFORMER_CONFIGURATION: {},
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-    });
-    const result = lookupColumnFormat(mockData);
-    assert.equal(result[GridColumnNames.Format], ''); // No format found, returns empty string
-    assert.ok(getDatasourceStub.calledOnce);
-});
-LookupColumnFormat('should return existing format when format exists', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'numericColumn',
-        [GridColumnNames.Format]: '',
-        [GridColumnNames.Type]: 'DOUBLE',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-    };
-    const getDatasourceStub = sinon.stub(selectors.datasourceConfig, 'getDatasource').returns({
-        KEY: 'test',
-        NAME: 'Test Datasource',
-        INPUT_TYPE: 'REQ_REP',
-        OUTPUT_TYPE: 'TABLE',
-        TRANSFORMER_CONFIGURATION: {
-            COLUMN_FORMATS: {
-                numericColumn: '#.##',
-            },
-        },
-        GROUPING_STRATEGY: 'NONE',
-        GROUP_KEY: null,
-    });
-    const result = lookupColumnFormat(mockData);
-    assert.equal(result[GridColumnNames.Format], '#.##'); // Existing format is returned
-    assert.ok(getDatasourceStub.calledOnce);
-});
-LookupColumnFormat.run();
-const DetermineDateLocaleFormat = suite('DetermineDateLocaleFormat()');
-DetermineDateLocaleFormat.before.each(() => {
-    sinon.restore();
-});
-DetermineDateLocaleFormat('should return unformatted for empty format string', () => {
-    const formatString = '';
-    assert.equal(determineDateLocaleFormat(formatString), DateLocaleFormats.Unformatted);
-});
-DetermineDateLocaleFormat('should return en-US for format string that contains hh, a, - or starts with month', () => {
-    assert.equal(determineDateLocaleFormat('MM-dd-yyyy'), DateLocaleFormats.US);
-    assert.equal(determineDateLocaleFormat('dd-MM-yyyy hh:mm:ss a'), DateLocaleFormats.US);
-});
-DetermineDateLocaleFormat('should return en-GB for format string that contains / or does not starts with month', () => {
-    assert.equal(determineDateLocaleFormat('dd/MM/yyyy'), DateLocaleFormats.UK);
-});
-DetermineDateLocaleFormat.run();
-const GetDateConfig = suite('GetDateConfig()');
-GetDateConfig.before.each(() => {
-    sinon.restore();
-});
-GetDateConfig('should return config with valid date time tokens', () => {
-    const formatString = 'd/MM/yyyy HH:mm:ss';
-    const mockData = {
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        month: '2-digit',
-        day: 'numeric',
-        year: 'full',
-    };
-    assert.equal(getDateConfig(formatString), mockData);
-});
-GetDateConfig('should return config with valid date time tokens and skip invalid tokens(YY, DD)', () => {
-    const formatString = 'DD/MM/YY HH:mm:ss';
-    const mockData = {
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        month: '2-digit',
-    };
-    assert.equal(getDateConfig(formatString), mockData);
-});
-GetDateConfig.run();
-const ValidateFormatString = suite('validateFormatString()');
-ValidateFormatString.before.each(() => {
-    sinon.restore();
-});
-ValidateFormatString('should return empty list for valid format string', () => {
-    const formatString = 'dd/MM/yyyy HH:mm:ss';
-    assert.equal(validateFormatString(formatString).length, 0);
-});
-ValidateFormatString('should return config with valid date time tokens and skip invalid tokens(YY, DD)', () => {
-    const formatString = 'DD/MM/YY HH:mm:ss';
-    assert.equal(validateFormatString(formatString).length, 2);
-});
-ValidateFormatString.run();
-const MapToDateFormat = suite('MapToDateFormat()');
-MapToDateFormat.before.each(() => {
-    sinon.restore();
-});
-MapToDateFormat('should return format string for uk according to input data', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'originalColumn',
-        [GridColumnNames.Format]: '',
-        [GridColumnNames.Type]: 'DATETIME',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-        type: FormatTypes.Datetime,
-        format: DateLocaleFormats.UK,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-        hour: DateTimeFormats.Show,
-        minute: DateTimeFormats.Show,
-        second: DateTimeFormats.Show,
-    };
-    const formatString = 'dd/MM/yyyy HH:mm:ss';
-    assert.equal(mapToDateFormat(mockData), formatString);
-});
-MapToDateFormat('should return format string for US with 12 hr format and am/pm indicator', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'originalColumn',
-        [GridColumnNames.Format]: '',
-        [GridColumnNames.Type]: 'DATETIME',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-        type: FormatTypes.Datetime,
-        format: DateLocaleFormats.US,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-        hour: DateTimeFormats.Show,
-        minute: DateTimeFormats.Show,
-        second: DateTimeFormats.Show,
-    };
-    const formatString = 'MM-dd-yyyy hh:mm:ss a';
-    assert.equal(mapToDateFormat(mockData), formatString);
-});
-MapToDateFormat('should return format string with only date parts when time parts are hidden ', () => {
-    const mockData = {
-        [GridColumnNames.ColumnName]: 'originalColumn',
-        [GridColumnNames.Format]: '',
-        [GridColumnNames.Type]: 'DATETIME',
-        [GridColumnNames.Datasource]: 'Test (Snapshot)',
-        type: FormatTypes.Datetime,
-        format: DateLocaleFormats.US,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-        hour: DateTimeFormats.Hide,
-        minute: DateTimeFormats.Hide,
-        second: DateTimeFormats.Hide,
-    };
-    const formatString = 'MM-dd-yyyy';
-    assert.equal(mapToDateFormat(mockData), formatString);
-});
-MapToDateFormat.run();
-const TransformFromFormatString = suite('TransformFromFormatString()');
-TransformFromFormatString.before.each(() => {
-    sinon.restore();
-});
-TransformFromFormatString('should return config with format en-GB for dd/MM/yyyy HH:mm:ss', () => {
-    const mockData = {
-        type: FormatTypes.Datetime,
-        format: DateLocaleFormats.UK,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-        hour: DateTimeFormats.Show,
-        minute: DateTimeFormats.Show,
-        second: DateTimeFormats.Show,
-    };
-    const formatString = 'dd/MM/yyyy HH:mm:ss';
-    const result = transformFromFormatString(formatString, mockData.type);
-    assert.equal(result, mockData);
-});
-TransformFromFormatString('should return config with format en-GB for dd/MM/yyyy and hide in time tokens', () => {
-    const mockData = {
-        type: FormatTypes.Datetime,
-        format: DateLocaleFormats.UK,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-        hour: DateTimeFormats.Hide,
-        minute: DateTimeFormats.Hide,
-        second: DateTimeFormats.Hide,
-    };
-    const formatString = 'dd/MM/yyyy';
-    const result = transformFromFormatString(formatString, mockData.type);
-    assert.equal(result, mockData);
-});
-TransformFromFormatString('should return config with format en-GB for dd/MM/yyyy HH:mm:ss', () => {
-    const mockData = {
-        type: FormatTypes.Datetime,
-        format: DateLocaleFormats.UK,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-        hour: DateTimeFormats.Show,
-        minute: DateTimeFormats.Show,
-        second: DateTimeFormats.Show,
-    };
-    const formatString = 'dd/MM/yyyy HH:mm:ss';
-    const result = transformFromFormatString(formatString, mockData.type);
-    assert.equal(result, mockData);
-});
-TransformFromFormatString('should return config with format en-GB for dd/MM/yyyy and without time token for Date type column ', () => {
-    const mockData = {
-        type: FormatTypes.Date,
-        format: DateLocaleFormats.UK,
-        year: DateYearFormats.Full,
-        month: DateMonthFormats.Digit,
-        day: DateStandardFormats.Digit,
-    };
-    const formatString = 'dd/MM/yyyy';
-    const result = transformFromFormatString(formatString, mockData.type);
-    assert.equal(result, mockData);
-});
-TransformFromFormatString.run();
-const FormatToConfigTokensSuite = suite('FormatToConfigTokens()');
-FormatToConfigTokensSuite.before.each(() => {
-    sinon.restore();
-});
-FormatToConfigTokensSuite('should return object with field value for date format tokens', () => {
-    assert.equal(FormatToConfigTokens['HH'], { field: 'hour', value: DateTimeFormats.Show });
-    assert.equal(FormatToConfigTokens['hh'], { field: 'hour', value: DateTimeFormats.Show });
-    assert.equal(FormatToConfigTokens['yy'], { field: 'year', value: DateYearFormats.Digit });
-    assert.equal(FormatToConfigTokens['M'], { field: 'month', value: DateMonthFormats.Numeric });
-});
-FormatToConfigTokensSuite.run();
-// Test for lookupDataTransform function
-// const LookupDataTransform = suite('lookupDataTransform()');
-// LookupDataTransform.before.each(() => {
-//   sinon.restore();
-// });
-// LookupDataTransform('should return data with added transform when transform exists', () => {
-//   const mockExpressionBuilderFields: ExpressionBuilderTypes.Field[] = [
-//     {
-//       fieldId: 'field1',
-//       label: 'Field 1',
-//       type: 'string',
-//       input: 'text',
-//     },
-//     {
-//       fieldId: 'field2',
-//       label: 'Field 2',
-//       type: 'double',
-//       input: 'number',
-//     },
-//   ];
-//   const mockData: DataTransformData = {
-//     [GridColumnNames.ColumnName]: 'testColumn',
-//     [GridColumnNames.Datasource]: 'Test (Snapshot)',
-//     [GridColumnNames.Type]: 'STRING',
-//   };
-//   // Using a specific allowed method type
-//   const mockExpression = {
-//     METHOD: 'TRIM' as const,
-//     TYPE: 'METHOD_EXPRESSION' as const,
-//     PARAMETERS: [
-//       {
-//         TYPE: 'FIELD' as const,
-//         NAME: 'field1',
-//       },
-//     ],
-//   };
-//   const getRowTransformStub = sinon
-//     .stub(selectors.datasourceConfig, 'getRowTransform')
-//     .returns(mockExpression);
-//   const result = lookupDataTransform(mockExpressionBuilderFields)(mockData);
-//   assert.ok(getRowTransformStub.calledOnce);
-//   assert.equal(getRowTransformStub.firstCall.args[0], 'REQ_REP_Test');
-//   assert.equal(getRowTransformStub.firstCall.args[1], 'testColumn');
-//   assert.equal(result[GridColumnNames.ColumnName], mockData[GridColumnNames.ColumnName]);
-//   assert.equal(result[GridColumnNames.Datasource], mockData[GridColumnNames.Datasource]);
-//   assert.equal(result[GridColumnNames.Type], mockData[GridColumnNames.Type]);
-//   const transformResult = result[GridColumnNames.DataTransform];
-//   assert.equal(transformResult!.fields, mockExpressionBuilderFields);
-//   assert.equal(transformResult!.model, mockExpression);
-//   assert.equal(transformResult!.partialRuleValidationWarning, true);
-// });
-// LookupDataTransform('should return data with empty model when no transform exists', () => {
-//   const mockExpressionBuilderFields: ExpressionBuilderTypes.Field[] = [
-//     {
-//       fieldId: 'field1',
-//       label: 'Field 1',
-//       type: 'string',
-//       input: 'text',
-//     },
-//   ];
-//   const mockData: DataTransformData = {
-//     [GridColumnNames.ColumnName]: 'testColumn',
-//     [GridColumnNames.Datasource]: 'Test (Snapshot)',
-//     [GridColumnNames.Type]: 'STRING',
-//   };
-//   const getRowTransformStub = sinon
-//     .stub(selectors.datasourceConfig, 'getRowTransform')
-//     .returns(undefined);
-//   const result = lookupDataTransform(mockExpressionBuilderFields)(mockData);
-//   assert.ok(getRowTransformStub.calledOnce);
-//   const transformResult = result[GridColumnNames.DataTransform];
-//   assert.equal(transformResult!.fields, mockExpressionBuilderFields);
-//   assert.equal(transformResult!.model, undefined);
-//   assert.equal(transformResult!.partialRuleValidationWarning, true);
-// });
-// LookupDataTransform.run();
-// Test for valueExprCellRendereronChange function
-const ValueExprCellRendereronChange = suite('valueExprCellRendereronChange()');
-ValueExprCellRendereronChange.before.each(() => {
-    sinon.restore();
-});
-ValueExprCellRendereronChange('should call setColumnTransform when model exists', () => {
-    const datasourceKey = 'REQ_REP_RESOURCE_ALIAS';
-    const columnName = 'testColumn';
-    // Using type assertions to match the expected type
-    const mockExpression = {
-        METHOD: 'TRIM',
-        TYPE: 'METHOD_EXPRESSION',
-        PARAMETERS: [
-            {
-                TYPE: 'FIELD',
-                NAME: 'field1',
-            },
-        ],
-    };
-    const mockParams = {
-        data: {
-            [GridColumnNames.ColumnName]: columnName,
-        },
-    };
-    const setColumnTransformStub = sinon.stub(actions.datasourceConfig, 'setColumnTransform');
-    const deleteColumnTransformStub = sinon.stub(actions.datasourceConfig, 'deleteColumnTransform');
-    const onChange = valueExprCellRendereronChange(datasourceKey);
-    onChange({
-        fields: [
-            {
-                fieldId: 'field1',
-                label: 'Field 1',
-                type: 'string',
-                input: 'text',
-            },
-        ],
-        model: mockExpression,
-        partialRuleValidationWarning: true,
-    }, mockParams);
-    assert.ok(setColumnTransformStub.calledOnce);
-    assert.equal(setColumnTransformStub.firstCall.args[0].key, datasourceKey);
-    assert.equal(setColumnTransformStub.firstCall.args[0].column, columnName);
-    assert.equal(setColumnTransformStub.firstCall.args[0].expression, mockExpression);
-    assert.equal(deleteColumnTransformStub.called, false);
-});
-ValueExprCellRendereronChange('should call deleteColumnTransform when model is null', () => {
-    const datasourceKey = 'REQ_REP_RESOURCE_ALIAS';
-    const columnName = 'testColumn';
-    const mockParams = {
-        data: {
-            [GridColumnNames.ColumnName]: columnName,
-        },
-    };
-    const setColumnTransformStub = sinon.stub(actions.datasourceConfig, 'setColumnTransform');
-    const deleteColumnTransformStub = sinon.stub(actions.datasourceConfig, 'deleteColumnTransform');
-    const onChange = valueExprCellRendereronChange(datasourceKey);
-    onChange({
-        fields: [
-            {
-                fieldId: 'field1',
-                label: 'Field 1',
-                type: 'string',
-                input: 'text',
-            },
-        ],
-        model: null,
-        partialRuleValidationWarning: true,
-    }, mockParams);
-    assert.equal(setColumnTransformStub.called, false);
-    assert.ok(deleteColumnTransformStub.calledOnce);
-    assert.equal(deleteColumnTransformStub.firstCall.args[0].key, datasourceKey);
-    assert.equal(deleteColumnTransformStub.firstCall.args[0].column, columnName);
-});
-ValueExprCellRendereronChange.run();
-const MapToNumberFormat = suite('MapToNumberFormat()');
-MapToNumberFormat.before.each(() => {
-    sinon.restore();
-});
-MapToNumberFormat('should create financial format with no decimal places by default', () => {
-    const result = mapToNumberFormat(NumericFormats.Financial);
-    assert.equal(result, '#,##0');
-});
-MapToNumberFormat('should create financial format with specified decimal places', () => {
-    const result = mapToNumberFormat(NumericFormats.Financial, 3);
-    assert.equal(result, '#,##0.###');
-});
-MapToNumberFormat('should create financial format with 0 decimal places', () => {
-    const result = mapToNumberFormat(NumericFormats.Financial, 0);
-    assert.equal(result, '#,##0');
-});
-MapToNumberFormat('should create simple decimal format with no decimal places by default', () => {
-    const result = mapToNumberFormat(NumericFormats.SimpleDecimal);
-    assert.equal(result, '#');
-});
-MapToNumberFormat('should create simple decimal format with specified decimal places', () => {
-    const result = mapToNumberFormat(NumericFormats.SimpleDecimal, 3);
-    assert.equal(result, '#.###');
-});
-MapToNumberFormat('should create simple decimal format with 0 decimal places', () => {
-    const result = mapToNumberFormat(NumericFormats.SimpleDecimal, 0);
-    assert.equal(result, '#');
-});
-MapToNumberFormat('should create percent format with no decimal places by default', () => {
-    const result = mapToNumberFormat(NumericFormats.Percent);
-    assert.equal(result, '##%');
-});
-MapToNumberFormat('should create percent format with specified decimal places', () => {
-    const result = mapToNumberFormat(NumericFormats.Percent, 1);
-    assert.equal(result, '##.#%');
-});
-MapToNumberFormat('should create currency format with US dollar symbol', () => {
-    const result = mapToNumberFormat(NumericFormats.Currency, 2, NumericCurrencies.US);
-    assert.equal(result, '$#,##0.##');
-});
-MapToNumberFormat('should create currency format with UK pound symbol', () => {
-    const result = mapToNumberFormat(NumericFormats.Currency, 2, NumericCurrencies.UK);
-    assert.equal(result, '£#,##0.##');
-});
-MapToNumberFormat('should create currency format with Euro symbol', () => {
-    const result = mapToNumberFormat(NumericFormats.Currency, 2, NumericCurrencies.EU);
-    assert.equal(result, '€#,##0.##');
-});
-MapToNumberFormat('should create currency format with Chinese Yuan symbol', () => {
-    const result = mapToNumberFormat(NumericFormats.Currency, 2, NumericCurrencies.CN);
-    assert.equal(result, '¥#,##0.##');
-});
-MapToNumberFormat('should default to US dollar when no currency specified', () => {
-    const result = mapToNumberFormat(NumericFormats.Currency, 2);
-    assert.equal(result, '$#,##0.##');
-});
-MapToNumberFormat('should create currency rounded format with US dollar symbol', () => {
-    const result = mapToNumberFormat(NumericFormats.CurrencyRounded, undefined, NumericCurrencies.US);
-    assert.equal(result, '$#,##0');
-});
-MapToNumberFormat('should create currency rounded format with UK pound symbol', () => {
-    const result = mapToNumberFormat(NumericFormats.CurrencyRounded, undefined, NumericCurrencies.UK);
-    assert.equal(result, '£#,##0');
-});
-MapToNumberFormat('should return empty string for unformatted', () => {
-    const result = mapToNumberFormat(NumericFormats.Unformatted);
-    assert.equal(result, '');
-});
-MapToNumberFormat.run();
-const IsNumericFieldType = suite('IsNumericFieldType()');
-IsNumericFieldType.before.each(() => {
-    sinon.restore();
-});
-IsNumericFieldType('should return true for numeric field types', () => {
-    assert.equal(isNumericFieldType('DOUBLE'), true);
-    assert.equal(isNumericFieldType('BIGDECIMAL'), true);
-    assert.equal(isNumericFieldType('INT'), true);
-    assert.equal(isNumericFieldType('SHORT'), true);
-    assert.equal(isNumericFieldType('LONG'), true);
-});
-IsNumericFieldType('should return false for non-numeric field types', () => {
-    assert.equal(isNumericFieldType('STRING'), false);
-    assert.equal(isNumericFieldType('DATE'), false);
-    assert.equal(isNumericFieldType('DATETIME'), false);
-    assert.equal(isNumericFieldType('BOOLEAN'), false);
-    assert.equal(isNumericFieldType('ENUM'), false);
-});
-IsNumericFieldType.run();
-const TransformFromNumberFormatString = suite('TransformFromNumberFormatString()');
-TransformFromNumberFormatString.before.each(() => {
-    sinon.restore();
-});
-TransformFromNumberFormatString('should return unformatted for empty format string', () => {
-    const result = transformFromNumberFormatString('', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.Unformatted);
-});
-TransformFromNumberFormatString('should parse financial format', () => {
-    const result = transformFromNumberFormatString('#,##0.##', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.Financial);
-    const numericResult = result;
-    assert.equal(numericResult.decimalPlaces, 2);
-});
-TransformFromNumberFormatString('should parse simple decimal format with decimal places', () => {
-    const result = transformFromNumberFormatString('#.##', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.SimpleDecimal);
-    const numericResult = result;
-    assert.equal(numericResult.decimalPlaces, 2);
-});
-TransformFromNumberFormatString('should parse simple decimal format without decimal places', () => {
-    const result = transformFromNumberFormatString('#', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.SimpleDecimal);
-    const numericResult = result;
-    assert.equal(numericResult.decimalPlaces, undefined);
-});
-TransformFromNumberFormatString('should parse percent format', () => {
-    const result = transformFromNumberFormatString('##.##%', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.Percent);
-    const numericResult = result;
-    assert.equal(numericResult.decimalPlaces, 2);
-});
-TransformFromNumberFormatString('should parse currency format with US dollar', () => {
-    const result = transformFromNumberFormatString('$#,##0.##', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.Currency);
-    const numericResult = result;
-    assert.equal(numericResult.currency, NumericCurrencies.US);
-    assert.equal(numericResult.decimalPlaces, 2);
-});
-TransformFromNumberFormatString('should parse currency format with UK pound', () => {
-    const result = transformFromNumberFormatString('£#,##0.##', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.Currency);
-    const numericResult = result;
-    assert.equal(numericResult.currency, NumericCurrencies.UK);
-    assert.equal(numericResult.decimalPlaces, 2);
-});
-TransformFromNumberFormatString('should parse currency rounded format', () => {
-    const result = transformFromNumberFormatString('$#,##0', FormatTypes.Double);
-    assert.equal(result.type, FormatTypes.Double);
-    assert.equal(result.format, NumericFormats.CurrencyRounded);
-    const numericResult = result;
-    assert.equal(numericResult.currency, NumericCurrencies.US);
-    assert.equal(numericResult.decimalPlaces, undefined);
-});
-TransformFromNumberFormatString.run();
-const GetDefaultFormat = suite('GetDefaultFormat()');
-GetDefaultFormat.before.each(() => {
-    sinon.restore();
-});
-GetDefaultFormat('should return #.## for BIGDECIMAL type', () => {
-    const result = getDefaultFormat('BIGDECIMAL');
-    assert.equal(result, '#.##');
-});
-GetDefaultFormat('should return #.## for DOUBLE type', () => {
-    const result = getDefaultFormat('DOUBLE');
-    assert.equal(result, '#.##');
-});
-GetDefaultFormat('should return # for INT type', () => {
-    const result = getDefaultFormat('INT');
-    assert.equal(result, '#');
-});
-GetDefaultFormat('should return # for SHORT type', () => {
-    const result = getDefaultFormat('SHORT');
-    assert.equal(result, '#');
-});
-GetDefaultFormat('should return # for LONG type', () => {
-    const result = getDefaultFormat('LONG');
-    assert.equal(result, '#');
-});
-GetDefaultFormat('should return dd/MM/yyyy for DATE type', () => {
-    const result = getDefaultFormat('DATE');
-    assert.equal(result, 'dd/MM/yyyy');
-});
-GetDefaultFormat('should return dd/MM/yyyy HH:mm:ss for DATETIME type', () => {
-    const result = getDefaultFormat('DATETIME');
-    assert.equal(result, 'dd/MM/yyyy HH:mm:ss');
-});
-GetDefaultFormat('should return empty string for non-numeric and non-date types', () => {
-    assert.equal(getDefaultFormat('STRING'), '');
-    assert.equal(getDefaultFormat('BOOLEAN'), '');
-    assert.equal(getDefaultFormat('ENUM'), '');
-});
-GetDefaultFormat.run();