@becollective/utils 1.10.2 → 2.0.0

package/tests/forms.test.ts

@@ -0,0 +1,674 @@
+'use strict';
+const validator = require('../src/forms');
+const testSchema = require('./forms.test-schema.json');
+const testUischema = require('./forms.test-uischema.json');
+const testData = require('./forms.test-data.json');
+
+let schema;
+let uischema;
+let data;
+
+beforeEach(() => {
+  // Deep cloning test data so we can mutate it inside tests.
+  schema = JSON.parse(JSON.stringify(testSchema));
+  uischema = JSON.parse(JSON.stringify(testUischema));
+  data = JSON.parse(JSON.stringify(testData));
+});
+
+describe('validateSchema', () => {
+  const { validateSchema } = validator;
+
+  test('should fail when array type has duplicate values', () => {
+    const t = {
+      data: {
+        type: 'object',
+        required: [],
+        properties: {
+          foo: {
+            title: 'Foobar',
+            type: 'array',
+            uniqueItems: true,
+            items: {
+              type: 'string',
+              anyOf: [
+                {
+                  type: 'string',
+                  enum: ['a'],
+                },
+                {
+                  type: 'string',
+                  enum: ['d'],
+                },
+                {
+                  type: 'string',
+                  enum: ['a'],
+                },
+              ],
+            },
+          },
+        },
+      },
+      ui: {
+        'ui:order': ['foo'],
+        foo: {
+          'ui:widget': 'WidgetTickbox',
+          'ui:title': 'Foobar',
+        },
+      },
+    };
+
+    return expect(validateSchema(t.data, t.ui)).rejects.toEqual([
+      {
+        key: 'foo',
+        message: 'must NOT have duplicate items (items ## 0 and 2 are identical)',
+        property: 'items.anyOf',
+      },
+    ]);
+  });
+
+  test('should fail when schema has property without a title', () => {
+    const t = {
+      data: {
+        type: 'object',
+        required: [],
+        properties: {
+          foo: {
+            title: '',
+            type: 'string',
+          },
+        },
+      },
+      ui: {
+        'ui:order': ['foo'],
+        foo: {
+          'ui:widget': 'WidgetDropDown',
+          'ui:title': '',
+        },
+      },
+    };
+
+    return expect(validateSchema(t.data, t.ui)).rejects.toEqual([
+      {
+        key: 'foo',
+        message: 'must NOT have fewer than 1 characters',
+        property: 'title',
+      },
+    ]);
+  });
+
+  test('should fail when array is empty', () => {
+    const t = {
+      data: {
+        type: 'object',
+        required: [],
+        properties: {
+          foobar: {
+            title: '',
+            type: 'array',
+            items: {
+              type: 'object',
+              anyOf: [],
+            },
+            uniqueItems: true,
+          },
+        },
+      },
+      ui: {
+        'ui:order': ['foobar'],
+        foobar: {
+          'ui:widget': 'WidgetDropDown',
+          'ui:title': '',
+        },
+      },
+    };
+
+    return expect(validateSchema(t.data, t.ui)).rejects.toEqual([
+      {
+        key: 'foobar',
+        message: 'must NOT have fewer than 1 characters',
+        property: 'title',
+      },
+      {
+        key: 'foobar',
+        message: 'must NOT have fewer than 1 items',
+        property: 'items.anyOf',
+      },
+    ]);
+  });
+
+  test('should succeed, returning true when schema and uischema are valid', () => {
+    return expect(validateSchema(schema, uischema)).resolves.toBe(true);
+  });
+
+  test('should fail when schema has missing data', () => {
+    delete schema.properties.B1WsCeOaz;
+
+    return expect(validateSchema(schema, uischema)).rejects.toEqual([
+      { key: '0', name: 'order-item-not-found', value: 'B1WsCeOaz' },
+    ]);
+  });
+
+  test('should fail when uischema has missing data', () => {
+    delete uischema.B1WsCeOaz;
+
+    return expect(validateSchema(schema, uischema)).rejects.toEqual([
+      { key: '0', name: 'ui-data-schema-mismatch', value: 'B1WsCeOaz' },
+    ]);
+  });
+
+  test('should fail when uischema is invalid', () => {
+    uischema.foo = {};
+
+    return expect(validateSchema(schema, uischema)).rejects.toEqual([
+      { name: 'invalid-uischema-property', object: 'foo' },
+    ]);
+  });
+
+  test('should fail when required is missing from schema', () => {
+    delete schema.required;
+
+    return expect(validateSchema(schema, uischema)).rejects.toEqual({ name: 'missing-required' });
+  });
+
+  test('should fail an invalid type is provided', () => {
+    schema.properties.B1WsCeOaz.type = 'foo';
+
+    return expect(validateSchema(schema, uischema)).rejects.toEqual([
+      {
+        name: 'invalid-schema-type',
+        object: { title: 'Who are you?', type: 'foo' },
+      },
+    ]);
+  });
+
+  test('should fail an invalid reportable field is provided', () => {
+    schema.properties.B1WsCe555.bcReportable = 'BC_SHOULD_FAIL';
+
+    return expect(validateSchema(schema, uischema)).rejects.toEqual([
+      {
+        name: 'invalid-reportable-field',
+        object: {
+          title: 'Do you own your own vehicle?',
+          type: 'string',
+          bcReportable: 'BC_SHOULD_FAIL',
+        },
+      },
+    ]);
+  });
+
+  test('should fail when schema has duplicated title', () => {
+    const properties = {
+      SbQY_SSBz: {
+        title: 'age',
+        type: 'string',
+      },
+      SyDtPZrkm: {
+        type: 'string',
+        title: 'spacer',
+        bcType: 'spacer',
+      },
+      cSCgS2dlE: {
+        title: 'Paragraph',
+        text: '<p>Rich text</p>',
+        type: 'string',
+        bcType: 'textParagraph',
+      },
+      sBFu87LVd: {
+        title: 'Notes',
+        type: 'string',
+      },
+      SyDtPZrks: {
+        type: 'string',
+        title: 'spacer',
+        bcType: 'spacer',
+      },
+      eoXtMLT0x: {
+        title: 'Age',
+        type: 'number',
+        properties: {},
+        bcType: 'number',
+      },
+      cSCgS2slE: {
+        title: 'Paragraph',
+        text: '<p>Rich text</p>',
+        type: 'string',
+        bcType: 'textParagraph',
+      },
+      L5p0dLuKs: {
+        title: 'Ask a question',
+        type: 'array',
+        uniqueItems: true,
+        items: {
+          type: 'string',
+          anyOf: [
+            {
+              type: 'string',
+              enum: ['Yes'],
+            },
+            {
+              type: 'string',
+              enum: ['No'],
+            },
+          ],
+        },
+        isDisabled: true,
+      },
+      kJFggxvpo: {
+        title: 'Ask a multiple choice question',
+        type: 'array',
+        uniqueItems: true,
+        items: {
+          type: 'string',
+          anyOf: [
+            {
+              type: 'string',
+              enum: ['yes'],
+            },
+            {
+              type: 'string',
+              enum: ['no'],
+            },
+          ],
+        },
+      },
+    };
+    const result = validator.validatePropertiesTitleUniqueness(properties, 'duplicate');
+    expect(result).toHaveLength(2);
+    expect(result[0].key).toEqual('SbQY_SSBz');
+    expect(result[1].key).toEqual('eoXtMLT0x');
+  });
+});
+
+describe('validateData', () => {
+  const { validateData } = validator;
+
+  test('should return true when schema and data are valid', () => {
+    return expect(validateData(schema, data)).resolves.toBe(undefined);
+  });
+
+  test('should return true when file is marked as required and data does not include file', () => {
+    // This requirement is due to how our backend is handling file data.
+    const schema = {
+      type: 'object',
+      required: ['FILE_FIELD'],
+      properties: {
+        FILE_FIELD: {
+          title: 'Upload a file',
+          type: 'string',
+          bcType: 'file',
+        },
+      },
+    };
+    const data = {};
+
+    return expect(validateData(schema, data)).resolves.toBe(undefined);
+  });
+});
+
+describe('stripEmptyArraysFromData', () => {
+  const { stripEmptyArraysFromData } = validator;
+
+  test('should return true when input data has empty array and that array is removed', () => {
+    const emptyArrayData = JSON.parse(JSON.stringify(data));
+    emptyArrayData['rkF-kbOaz'] = [];
+
+    const expectedData = JSON.parse(JSON.stringify(data));
+    delete expectedData['rkF-kbOaz'];
+
+    return expect(stripEmptyArraysFromData(emptyArrayData)).toEqual(expectedData);
+  });
+});
+
+describe('dataTypeIsValid', () => {
+  const isValid = validator.dataTypeIsValid;
+  const optionsSchema = {
+    type: 'string',
+    title: 'Fruits',
+    items: {
+      type: 'string',
+      enum: ['Apples', 'Bananas', 'Pears'],
+    },
+  };
+
+  describe('string', () => {
+    test('should return true when schema has items.enum and arg is a string value that is in enum', () => {
+      expect(isValid.string('Apples', optionsSchema)).toBe(true);
+    });
+
+    test('should return false when schema has items.enum and arg is a string value that is not in enum', () => {
+      expect(isValid.string('Berries', optionsSchema)).toBe(false);
+    });
+
+    test('should return true when arg is string', () => {
+      expect(isValid.string('Hello')).toBe(true);
+    });
+
+    test('should return false when arg is number', () => {
+      expect(isValid.string(1)).toBe(false);
+    });
+
+    test('should return false when arg is array', () => {
+      expect(isValid.string([])).toBe(false);
+    });
+
+    test('should return false when arg is object', () => {
+      expect(isValid.string({})).toBe(false);
+    });
+
+    test('should return false when arg is boolean', () => {
+      expect(isValid.string(true)).toBe(false);
+    });
+  });
+
+  describe('number', () => {
+    test('should return true when arg is number', () => {
+      expect(isValid.number(1)).toBe(true);
+    });
+
+    test('should return false when arg is string', () => {
+      expect(isValid.number('Hello')).toBe(false);
+    });
+
+    test('should return false when arg is array', () => {
+      expect(isValid.number([])).toBe(false);
+    });
+
+    test('should return false when arg is object', () => {
+      expect(isValid.number({})).toBe(false);
+    });
+
+    test('should return false when arg is boolean', () => {
+      expect(isValid.number(true)).toBe(false);
+    });
+
+    test('should return true when number with decimal places < 10', () => {
+      expect(isValid.number(1.123456789)).toBe(true);
+    });
+
+    test('should return false when number with decimal places > 10', () => {
+      expect(isValid.number(1.12345678901)).toBe(false);
+    });
+  });
+
+  describe('boolean', () => {
+    test('should return true when arg is boolean', () => {
+      expect(isValid.boolean(false)).toBe(true);
+    });
+
+    test('should return false when arg is number', () => {
+      expect(isValid.boolean(1)).toBe(false);
+    });
+
+    test('should return false when arg is array', () => {
+      expect(isValid.boolean([])).toBe(false);
+    });
+
+    test('should return false when arg is object', () => {
+      expect(isValid.boolean({})).toBe(false);
+    });
+
+    test('should return false when arg is string', () => {
+      expect(isValid.boolean('true')).toBe(false);
+    });
+  });
+
+  describe('date', () => {
+    test('should return true when arg is date string', () => {
+      expect(isValid.date('2021-12-04T14:00:00.000Z')).toBe(true);
+    });
+
+    test('should return true when arg is date string in YYYY-MM-DD format', () => {
+      expect(isValid.date('2021-12-04')).toBe(true);
+    });
+
+    test('should return false when arg is a date string with year > 9999', () => {
+      expect(isValid.date('10000-12-04T14:00:00.000Z')).toBe(false);
+    });
+
+    test('should return false when arg is a date string with year < 1000', () => {
+      expect(isValid.date('1-12-04T14:00:00.000Z')).toBe(false);
+    });
+
+    test('should return false when arg is date object', () => {
+      expect(isValid.date(new Date())).toBe(false);
+    });
+
+    test('should return false when arg is number', () => {
+      expect(isValid.date(123)).toBe(false);
+    });
+
+    test('should return false when arg is array', () => {
+      expect(isValid.date([])).toBe(false);
+    });
+
+    test('should return false when arg is object', () => {
+      expect(isValid.date({})).toBe(false);
+    });
+
+    test('should return false when arg is string', () => {
+      expect(isValid.date('apples')).toBe(false);
+    });
+  });
+
+  describe('dateRange', () => {
+    const dateRangeISO = {
+      from: '2018-05-26T14:00:00.000Z',
+      to: '2018-05-30T14:00:00.000Z',
+    };
+    const dateRangeDateObj = {
+      from: new Date('2018-05-26T14:00:00.000Z'),
+      to: new Date('2018-05-30T13:59:59.000Z'),
+    };
+    const ISODate = '2018-05-24T14:00:00.000Z';
+
+    test('should return true when arg is a date range object with ISO String dates', () => {
+      expect(isValid.dateRange(dateRangeISO)).toBe(true);
+    });
+
+    test('should return true when from and to date are the same', () => {
+      expect(
+        isValid.dateRange({
+          from: ISODate,
+          to: ISODate,
+        })
+      ).toBe(true);
+    });
+
+    test('should return false when arg is date range object with Date objects', () => {
+      expect(isValid.dateRange(dateRangeDateObj)).toBe(false);
+    });
+
+    test('should return false when arg is date ISO String', () => {
+      expect(isValid.dateRange(new Date().toISOString())).toBe(false);
+    });
+
+    test('should return false when arg is date object', () => {
+      expect(isValid.dateRange(new Date())).toBe(false);
+    });
+
+    test('should return false when arg is number', () => {
+      expect(isValid.dateRange(123)).toBe(false);
+    });
+
+    test('should return false when arg is array', () => {
+      expect(isValid.dateRange([])).toBe(false);
+    });
+
+    test('should return false when arg is object', () => {
+      expect(isValid.dateRange({})).toBe(false);
+    });
+
+    test('should return false when arg is string', () => {
+      expect(isValid.dateRange('apples')).toBe(false);
+    });
+  });
+
+  describe('phone', () => {
+    const validPhone = '+61434111222';
+
+    test('should return true when phone number is valid', () => {
+      expect(isValid.phone(validPhone)).toBe(true);
+    });
+
+    test("should return false when phone number isn't provided", () => {
+      expect(isValid.phone()).toBe(false);
+    });
+
+    test("should return false when phone number isn't in the E.164 format", () => {
+      expect(isValid.phone('0433222333')).toBe(false);
+    });
+  });
+
+  describe('array', () => {
+    const sport = {
+      schema: {
+        type: 'array',
+        title: 'What sport do you like?',
+        items: {
+          anyOf: [
+            {
+              type: 'string',
+              enum: ['Soccer'],
+            },
+            {
+              type: 'string',
+              enum: ['Basketball'],
+            },
+            {
+              type: 'string',
+              enum: ['Football'],
+            },
+            {
+              type: 'string',
+              enum: ['Cricket'],
+            },
+          ],
+        },
+        uniqueItems: true,
+      },
+    };
+
+    test('should return true when value exists in enum', () => {
+      expect(isValid.array(['Soccer'], sport.schema)).toBe(true);
+    });
+
+    test('should return false when schema is an empty object', () => {
+      expect(isValid.array(['Soccer'], {})).toBe(false);
+    });
+
+    test("should return false when value doesn't exists in enum", () => {
+      expect(isValid.array(['Tennis'], sport.schema)).toBe(false);
+    });
+
+    test('should return false when no value is passed in', () => {
+      expect(isValid.array(undefined, sport.schema)).toBe(false);
+    });
+
+    test('should return false when empty array is passed in', () => {
+      expect(isValid.array([], sport.schema)).toBe(false);
+    });
+  });
+
+  describe('skills', () => {
+    const skills = {
+      schema: {
+        title: 'Skills Required',
+        type: 'array',
+        uniqueItems: true,
+        bcType: 'skills',
+        items: {
+          type: 'string',
+          anyOf: [
+            {
+              enum: ['skillId1'],
+              title: 'Office Reception',
+              type: 'string',
+            },
+            {
+              enum: ['skillId2'],
+              title: 'Executive Administration',
+              type: 'string',
+            },
+            {
+              enum: ['skillId3'],
+              title: 'Office Management',
+              type: 'string',
+            },
+          ],
+        },
+      },
+    };
+
+    test('should return true when value exists in enum', () => {
+      expect(isValid.skills(['skillId1'], skills.schema)).toBe(true);
+    });
+
+    test('should return false when schema is an empty object', () => {
+      expect(isValid.skills(['skillId2'], {})).toBe(false);
+    });
+
+    test("should return false when value doesn't exists in enum", () => {
+      expect(isValid.skills(['skillId7'], skills.schema)).toBe(false);
+    });
+
+    test('should return false when no value is passed in', () => {
+      expect(isValid.skills(undefined, skills.schema)).toBe(false);
+    });
+
+    test('should return false when empty array is passed in', () => {
+      expect(isValid.skills([], skills.schema)).toBe(false);
+    });
+  });
+
+  describe('qualifications', () => {
+    const qualifications = {
+      schema: {
+        title: 'Qualifications Required',
+        type: 'array',
+        uniqueItems: true,
+        bcType: 'skills',
+        items: {
+          type: 'string',
+          enum: ['drivers-licence', 'working-with-children'],
+        },
+      },
+    };
+
+    test('should return true when value exists in enum', () => {
+      expect(isValid.qualifications(['drivers-licence'], qualifications.schema)).toBe(true);
+    });
+
+    test('should return false when schema is an empty object', () => {
+      expect(isValid.qualifications(['drivers-licence'], {})).toBe(false);
+    });
+
+    test("should return false when value doesn't exists in enum", () => {
+      expect(isValid.qualifications(['cook-food'], qualifications.schema)).toBe(false);
+    });
+
+    test('should return false when no value is passed in', () => {
+      expect(isValid.qualifications(undefined, qualifications.schema)).toBe(false);
+    });
+
+    test('should return false when empty array is passed in', () => {
+      expect(isValid.qualifications([], qualifications.schema)).toBe(false);
+    });
+  });
+});
+
+describe('getValidatorForTypeData', () => {
+  test('should resolve with a defined validator', () => {
+    const v= validator.getValidatorForTypeData('string');
+    expect(typeof v).toBe('function');
+  });
+
+  test('should reject with an undefined validator', () => {
+    try {
+      validator.getValidatorForTypeData();
+    }
+    catch(e) {
+      expect(e).toMatchObject({ name: 'Datatype not found' });
+    }
+    // return expect(validator.getValidatorForTypeData()).rejects.
+  });
+});

package/tests/{money.test.js → money.test.ts}

@@ -1,6 +1,5 @@
-const { currencies } = require('@becollective/constants');
-
-const { getCurrencyFromCurrencyCode, makeMoneyString } = require('../bundle.js');
+import { currencies } from '@becollective/constants';
+import { getCurrencyFromCurrencyCode, makeMoneyString } from '../lib/money';
 
 describe('getCurrencyFromCurrencyCode', () => {
   test('Returns the correct currency', () => {

package/tests/{password.test.js → password.test.ts}

@@ -1,4 +1,4 @@
-const util = require('../bundle.js');
+import * as util from '../lib/password';
 
 describe('password.valiate', () => {
   test('validate a valid password', async () => {
@@ -36,11 +36,12 @@ describe('password.valiate', () => {
       util.password.validate(password);
     }).not.toThrow('invalid-minimum-rules');
   }, 1000);
-  test('validate a missing password property', async () => {
-    expect(() => {
-      util.password.validate();
-    }).toThrow('not-string');
-  }, 1000);
+  // will not execute with TypeScript
+  // test('validate a missing password property', async () => {
+  //   expect(() => {
+  //     util.password.validate();
+  //   }).toThrow('not-string');
+  // }, 1000);
   test('validate a non-string', async () => {
     const password = { foo: 'bar' };
     expect(() => {