@wise/dynamic-flow-client 3.5.0-experimental-b041af5 → 3.5.0-experimental-63c768d

package/build/legacy/common/utils/id-utils.spec.js

@@ -0,0 +1,12 @@
+import { generateRandomId } from './id-utils';
+jest.spyOn(Math, 'random').mockReturnValue(0.123456789);
+describe('generateRandomId', function () {
+    it('should generate a random id', function () {
+        var id = generateRandomId();
+        expect(id).toBe('12345678');
+    });
+    it('should generate a random id with a prefix', function () {
+        var id = generateRandomId('prefix');
+        expect(id).toBe('prefix-12345678');
+    });
+});

package/build/legacy/common/utils/is-equal.spec.js

@@ -0,0 +1,88 @@
+import { isEqual } from './is-equal';
+describe('isEqual', function () {
+    describe('primitives', function () {
+        it('will be true for null equality', function () {
+            expect(isEqual(null, null)).toBe(true);
+        });
+        it('will be true for undefined equality', function () {
+            expect(isEqual(undefined, undefined)).toBe(true);
+        });
+        it('will be true for string equality', function () {
+            expect(isEqual('a string', 'a string')).toBe(true);
+            expect(isEqual('', '')).toBe(true);
+        });
+        it('will be true for number equality', function () {
+            expect(isEqual(0, 0)).toBe(true);
+            expect(isEqual(123, 123)).toBe(true);
+            expect(isEqual(123.456, 123.456)).toBe(true);
+            expect(isEqual(123, 123.0)).toBe(true);
+        });
+        it('will be true for boolean equality', function () {
+            expect(isEqual(false, false)).toBe(true);
+            expect(isEqual(true, true)).toBe(true);
+        });
+        it('will be false for null inequality', function () {
+            expect(isEqual(null, undefined)).toBe(false);
+            expect(isEqual(null, '')).toBe(false);
+            expect(isEqual(null, 0)).toBe(false);
+            expect(isEqual(null, {})).toBe(false);
+        });
+        it('will be false for undefined inequality', function () {
+            expect(isEqual(undefined, null)).toBe(false);
+            expect(isEqual(undefined, '')).toBe(false);
+            expect(isEqual(undefined, 0)).toBe(false);
+            expect(isEqual(undefined, {})).toBe(false);
+        });
+        it('will be false for string inequality', function () {
+            expect(isEqual('a string', null)).toBe(false);
+            expect(isEqual('a string', '')).toBe(false);
+            expect(isEqual('a string', 0)).toBe(false);
+            expect(isEqual('a string', {})).toBe(false);
+        });
+        it('will be false for number inequality', function () {
+            expect(isEqual(123, null)).toBe(false);
+            expect(isEqual(123, '')).toBe(false);
+            expect(isEqual(123, 0)).toBe(false);
+            expect(isEqual(123, {})).toBe(false);
+        });
+    });
+    describe('arrays', function () {
+        it('will be true for primitive array equality', function () {
+            expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+            expect(isEqual(['a', 'b', 'c'], ['a', 'b', 'c'])).toBe(true);
+            expect(isEqual([true, false], [true, false])).toBe(true);
+            expect(isEqual([null, undefined], [null, undefined])).toBe(true);
+        });
+        it('will be true for complex array equality', function () {
+            expect(isEqual([{ a: 1, b: 2 }, { c: { d: 4 } }], [{ a: 1, b: 2 }, { c: { d: 4 } }])).toBe(true);
+            expect(isEqual([{}], [{}])).toBe(true);
+        });
+        it('will be true for nested array equality', function () {
+            expect(isEqual([[1], [2], [3, 4]], [[1], [2], [3, 4]])).toBe(true);
+        });
+        it('will be false for inequivalent arrays', function () {
+            expect(isEqual([1, 2, 3], [4, 5, 6])).toBe(false);
+            expect(isEqual([null], [{}])).toBe(false);
+            expect(isEqual({ a: 'b' }, { b: 'c' })).toBe(false);
+        });
+        it('will be false for differently ordered arrays', function () {
+            expect(isEqual([1, 2, 3], [3, 2, 1])).toBe(false);
+        });
+    });
+    describe('objects', function () {
+        it('will return true for equivalent objects', function () {
+            expect(isEqual({ a: 'b', b: 1 }, { a: 'b', b: 1 })).toBe(true);
+            expect(isEqual({}, {})).toBe(true);
+        });
+        it('will return true for nested equivalent objects', function () {
+            expect(isEqual({ a: 'b', b: { c: { d: 1 } } }, { b: { c: { d: 1 } }, a: 'b' })).toBe(true);
+            expect(isEqual({ a: 'b', b: [1, 2, 3] }, { b: [1, 2, 3], a: 'b' })).toBe(true);
+        });
+        it('will return false for inequivalent objects', function () {
+            expect(isEqual({ a: 'b' }, { b: 1, c: 2 })).toBe(false);
+            expect(isEqual({ a: 'c', b: { c: { d: 1 } } }, { b: { c: { d: 1 } }, a: 'b' })).toBe(false);
+            expect(isEqual({ a: 'b', b: [1, 2, 3] }, { a: 'b', b: [4, 5, 6] })).toBe(false);
+            expect(isEqual({ a: 1 }, { a: 2 })).toBe(false);
+        });
+    });
+});

package/build/legacy/common/utils/mobile-utils.spec.js

@@ -0,0 +1,71 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { isMobileUA, isMobileScreenSize, isTouchScreen } from './mobile-utils';
+describe('hasMobileUA', function () {
+    it('should return true for iPhone user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1')).toBe(true);
+    });
+    it('should return true for Android user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (Linux; Android 11; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.66 Mobile Safari/537.36')).toBe(true);
+    });
+    it('should return true for BlackBerry user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (BB10; Touch) AppleWebKit/537.36 (KHTML, like Gecko) Version/10.3.2.2639 Mobile Safari/537.36')).toBe(true);
+    });
+    it('should return true for webOS user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (webOS/2.2.4; U; en-US) AppleWebKit/534.6 (KHTML, like Gecko) wOSBrowser/234.83 Safari/534.6 Pre/3.0')).toBe(true);
+    });
+    it('should return true for Windows Phone user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; Trident/7.0; Touch; rv:11.0; IEMobile/11.0; NOKIA; Lumia 520) like Gecko')).toBe(true);
+    });
+    it('should return false if user agent indicates desktop', function () {
+        expect(isMobileUA('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36')).toBe(false);
+    });
+});
+describe('hasMobileScreenSize', function () {
+    it('should return true if screen width < 768px', function () {
+        expect(isMobileScreenSize(390, 844)).toBe(true);
+        expect(isMobileScreenSize(844, 390)).toBe(true);
+    });
+    it('should return true if screen height < 768px (landscape mode)', function () {
+        expect(isMobileScreenSize(844, 390)).toBe(true);
+    });
+    it('should return false if screen width > 768px', function () {
+        expect(isMobileScreenSize(1024, 768)).toBe(false);
+    });
+});
+describe('hasTouchScreen', function () {
+    var mockNavigator = {
+        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36'
+    };
+    it('should return true if the device has a touch screen', function () {
+        expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 1 }))).toBe(true);
+    });
+    it('should return false if the device does not have a touch screen', function () {
+        expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 0 }))).toBe(false);
+    });
+    it('should return true if matchMedia indicates a touch screen', function () {
+        var mockMatchMedia = jest.fn().mockReturnValue({ media: '(pointer:coarse)', matches: true });
+        var result = isTouchScreen(mockNavigator, mockMatchMedia);
+        expect(mockMatchMedia).toHaveBeenCalledWith('(pointer:coarse)');
+        expect(result).toBe(true);
+    });
+    it('should return false if matchMedia does not indicate a touch screen', function () {
+        var mockMatchMedia = jest.fn().mockReturnValue({ media: '(pointer:coarse)', matches: false });
+        var result = isTouchScreen(mockNavigator, mockMatchMedia);
+        expect(mockMatchMedia).toHaveBeenCalledWith('(pointer:coarse)');
+        expect(result).toBe(false);
+    });
+    it('should return false when none of the conditions are met', function () {
+        var result = isTouchScreen(mockNavigator, undefined);
+        expect(result).toBe(false);
+    });
+});

package/build/legacy/common/validators/models/model-utils.spec.js

@@ -0,0 +1,45 @@
+import { cleanModelWithArraySchema } from './model-utils';
+var basicArray = {
+    type: 'array',
+    items: {
+        title: 'Email',
+        type: 'string'
+    }
+};
+var objectArray = {
+    type: 'array',
+    addItemTitle: '',
+    editItemTitle: '',
+    items: {
+        type: 'object',
+        displayOrder: ['name', 'terms'],
+        properties: {
+            name: {
+                title: 'Full name',
+                type: 'string'
+            },
+            terms: {
+                title: 'I agree to the terms and conditions',
+                type: 'boolean'
+            }
+        }
+    }
+};
+describe('cleanModelWithArraySchema', function () {
+    it('should return null if the model is not an array', function () {
+        expect(cleanModelWithArraySchema('foo', basicArray)).toBeNull();
+    });
+    it('should return an empty array if the model is an empty array', function () {
+        expect(cleanModelWithArraySchema([], basicArray)).toStrictEqual([]);
+    });
+    // This is kind of strange behaviour, but it's existing, so I don't want to change it
+    it('should return an array of nulls if the model has items with different types', function () {
+        expect(cleanModelWithArraySchema(['foo', 1], basicArray)).toStrictEqual([null, null]);
+    });
+    it('should return the model if the model is a non-empty array', function () {
+        expect(cleanModelWithArraySchema(['foo'], basicArray)).toStrictEqual(['foo']);
+    });
+    it('should return valid model parts of each item in the array', function () {
+        expect(cleanModelWithArraySchema([{ name: 'foo', terms: true }, { cat: 'chaos' }], objectArray)).toStrictEqual([{ name: 'foo', terms: true }, {}]);
+    });
+});