@coast/core-utils 0.0.2 → 0.0.6

package/src/test/ArrayUtilsTest.ts

@@ -0,0 +1,135 @@
+import { CoastException } from '@coast/core-types/exception/CoastException';
+
+import { ArrayUtils } from '../ArrayUtils';
+
+describe('ArrayUtils', () => {
+    describe('liftNonEmpty', () => {
+        it('returns the same array as a NonEmptyArray when given a non-empty array', () => {
+            const input = [1, 2, 3];
+
+            const result = ArrayUtils.liftNonEmpty(input);
+
+            expect(result).toEqual([1, 2, 3]);
+        });
+
+        it('returns a single-element array', () => {
+            const input = ['only'];
+
+            const result = ArrayUtils.liftNonEmpty(input);
+
+            expect(result).toEqual(['only']);
+        });
+
+        it('throws a CoastException when given an empty array', () => {
+            expect(() => ArrayUtils.liftNonEmpty([])).toThrow(CoastException);
+            expect(() => ArrayUtils.liftNonEmpty([])).toThrow('Cannot lift empty array');
+        });
+    });
+
+    describe('first', () => {
+        it('returns the first element of a non-empty array', () => {
+            expect(ArrayUtils.first([10, 20, 30])).toEqual(10);
+        });
+
+        it('returns the first element of a single-element array', () => {
+            expect(ArrayUtils.first(['hello'])).toEqual('hello');
+        });
+
+        it('returns undefined for an empty array', () => {
+            expect(ArrayUtils.first([])).toBeUndefined();
+        });
+
+        it('returns undefined when given undefined', () => {
+            expect(ArrayUtils.first(undefined)).toBeUndefined();
+        });
+
+        it('returns undefined when given null', () => {
+            expect(ArrayUtils.first(null)).toBeUndefined();
+        });
+    });
+
+    describe('isNonEmptyArray', () => {
+        it('returns true for a non-empty array', () => {
+            expect(ArrayUtils.isNonEmptyArray([1, 2, 3])).toEqual(true);
+        });
+
+        it('returns true for a single-element array', () => {
+            expect(ArrayUtils.isNonEmptyArray(['item'])).toEqual(true);
+        });
+
+        it('returns false for an empty array', () => {
+            expect(ArrayUtils.isNonEmptyArray([])).toEqual(false);
+        });
+
+        it('returns false for null', () => {
+            expect(ArrayUtils.isNonEmptyArray(null)).toEqual(false);
+        });
+
+        it('returns false for undefined', () => {
+            expect(ArrayUtils.isNonEmptyArray(undefined)).toEqual(false);
+        });
+    });
+
+    describe('isUniformArray', () => {
+        it('returns true for an empty array', () => {
+            expect(ArrayUtils.isUniformArray([])).toEqual(true);
+        });
+
+        it('returns false for a non-array value', () => {
+            expect(ArrayUtils.isUniformArray('not an array')).toEqual(false);
+        });
+
+        it('returns false for null', () => {
+            expect(ArrayUtils.isUniformArray(null)).toEqual(false);
+        });
+
+        it('returns false for undefined', () => {
+            expect(ArrayUtils.isUniformArray(undefined)).toEqual(false);
+        });
+
+        it('returns true for an array of uniform string types', () => {
+            expect(ArrayUtils.isUniformArray(['a', 'b', 'c'])).toEqual(true);
+        });
+
+        it('returns true for an array of uniform number types', () => {
+            expect(ArrayUtils.isUniformArray([1, 2, 3])).toEqual(true);
+        });
+
+        it('returns false for an array of mixed types', () => {
+            expect(ArrayUtils.isUniformArray([1, 'two', 3])).toEqual(false);
+        });
+
+        it('returns false for an array mixing numbers and booleans', () => {
+            expect(ArrayUtils.isUniformArray([1, true, 3])).toEqual(false);
+        });
+
+        describe('with itemGuard', () => {
+            const isString = (item: unknown): item is string => typeof item === 'string';
+            const isNumber = (item: unknown): item is number => typeof item === 'number';
+
+            it('returns true when all items satisfy the guard', () => {
+                expect(ArrayUtils.isUniformArray(['a', 'b', 'c'], isString)).toEqual(true);
+            });
+
+            it('returns false when any item fails the guard', () => {
+                expect(ArrayUtils.isUniformArray(['a', 1, 'c'], isString)).toEqual(false);
+            });
+
+            it('returns true for an empty array regardless of guard', () => {
+                expect(ArrayUtils.isUniformArray([], isNumber)).toEqual(true);
+            });
+
+            it('returns true when all items satisfy a number guard', () => {
+                expect(ArrayUtils.isUniformArray([1, 2, 3], isNumber)).toEqual(true);
+            });
+
+            it('narrowing: correctly types result as string[] when guard passes', () => {
+                const value: unknown = ['x', 'y'];
+
+                if (ArrayUtils.isUniformArray(value, isString)) {
+                    expect(value[0]).toEqual('x');
+                }
+            });
+        });
+    });
+});

package/src/test/AssertionUtilsTest.ts

@@ -0,0 +1,141 @@
+import { EntityType } from '@coast/core-types/common/EntityType';
+import { EntityTypeLabels } from '@coast/core-types/common/EntityTypeLabels';
+import { AssertionFailedException } from '@coast/core-types/exception/AssertionFailedException';
+import { CoastException } from '@coast/core-types/exception/CoastException';
+import { InvalidEntityReferenceException } from '@coast/core-types/exception/InvalidEntityReferenceException';
+import { NotDefinedException } from '@coast/core-types/exception/NotDefinedException';
+import { assertType } from '@coast/service-common/types/assertType';
+import { Equals } from '@coast/service-common/types/Equals';
+import { safeExpect } from '@paradoxical-io/common-test';
+
+import { AssertionUtils } from '../AssertionUtils';
+
+describe('AssertionUtils', () => {
+    describe('assertIsDefined', () => {
+        it('should throw if value is not defined', () => {
+            const x = undefined as object | undefined;
+            try {
+                AssertionUtils.assertIsDefined(x);
+            } catch (error) {
+                expect(error).toBeInstanceOf(NotDefinedException);
+                safeExpect((error as NotDefinedException).message).toEqual('Value is not defined');
+            }
+        });
+
+        it('should use custom error message', () => {
+            const x = undefined as object | undefined;
+            try {
+                AssertionUtils.assertIsDefined(x, 'x should exist...');
+            } catch (error) {
+                expect(error).toBeInstanceOf(NotDefinedException);
+                safeExpect((error as NotDefinedException).message).toEqual('x should exist...');
+            }
+        });
+
+        it('should use custom Exception', () => {
+            const x = undefined as object | undefined;
+            try {
+                AssertionUtils.assertIsDefined(x, new CoastException('custom exception'));
+            } catch (error) {
+                expect(error).toBeInstanceOf(CoastException);
+                safeExpect((error as NotDefinedException).message).toEqual('custom exception');
+            }
+        });
+
+        it('should not throw and should type narrow if value is defined', () => {
+            const x = '' as string | undefined;
+            assertType<Equals<typeof x, string | undefined>>();
+
+            AssertionUtils.assertIsDefined(x);
+            assertType<Equals<typeof x, string>>();
+        });
+    });
+
+    describe('assert', () => {
+        it('should throw AssertionFailedException if value is falsy', () => {
+            try {
+                AssertionUtils.assert(false);
+            } catch (error) {
+                expect(error).toBeInstanceOf(AssertionFailedException);
+            }
+        });
+
+        it('should use custom error message', () => {
+            try {
+                AssertionUtils.assert(false, 'value must be truthy');
+            } catch (error) {
+                expect(error).toBeInstanceOf(AssertionFailedException);
+                safeExpect((error as AssertionFailedException).message).toEqual('value must be truthy');
+            }
+        });
+
+        it('should use custom CoastException', () => {
+            try {
+                AssertionUtils.assert(false, new CoastException('custom coast exception'));
+            } catch (error) {
+                expect(error).toBeInstanceOf(CoastException);
+                safeExpect((error as CoastException).message).toEqual('custom coast exception');
+            }
+        });
+
+        it('should not throw if value is truthy', () => {
+            safeExpect(() => AssertionUtils.assert(true)).not.toThrow();
+            safeExpect(() => AssertionUtils.assert(1)).not.toThrow();
+            safeExpect(() => AssertionUtils.assert('hello')).not.toThrow();
+            safeExpect(() => AssertionUtils.assert({})).not.toThrow();
+        });
+
+        it('should type narrow to exclude falsy', () => {
+            const x = 'hello' as false | string;
+            assertType<Equals<typeof x, false | string>>();
+
+            AssertionUtils.assert(x);
+            assertType<Equals<typeof x, string>>();
+        });
+    });
+
+    describe('assertValidEntityReference', () => {
+        it('should throw if value is not defined', () => {
+            const x = undefined as object | undefined;
+            try {
+                AssertionUtils.assertValidEntityReference(x, EntityType.WORKFLOW_ENTITY);
+            } catch (error) {
+                expect(error).toBeInstanceOf(InvalidEntityReferenceException);
+
+                safeExpect((error as InvalidEntityReferenceException).message).toEqual(
+                    `Invalid entity reference: ${EntityTypeLabels[EntityType.WORKFLOW_ENTITY]} not found`
+                );
+
+                safeExpect((error as InvalidEntityReferenceException).additionalData).toMatchObject({
+                    entityType: EntityType.WORKFLOW_ENTITY,
+                });
+            }
+        });
+
+        it('should use custom error message', () => {
+            const x = undefined as object | undefined;
+            try {
+                AssertionUtils.assertValidEntityReference(x, EntityType.WORKFLOW_ENTITY, {
+                    message: 'x should exist...',
+                    id: 'abc-123',
+                });
+            } catch (error) {
+                expect(error).toBeInstanceOf(InvalidEntityReferenceException);
+                safeExpect((error as InvalidEntityReferenceException).message).toEqual('x should exist...');
+
+                safeExpect((error as InvalidEntityReferenceException).additionalData).toMatchObject({
+                    entityType: EntityType.WORKFLOW_ENTITY,
+                    id: 'abc-123',
+                });
+            }
+        });
+
+        it('should not throw and should type narrow if value is defined', () => {
+            const x = { id: 'abc' } as object | undefined;
+            assertType<Equals<typeof x, object | undefined>>();
+
+            AssertionUtils.assertValidEntityReference(x, EntityType.COMPONENT);
+            assertType<Equals<typeof x, object>>();
+        });
+    });
+});

package/tsconfig.json

@@ -3,7 +3,15 @@
     "compilerOptions": {
         "composite": true,
         "outDir": "./dist",
-        "rootDir": "./src"
+        "rootDir": "./src",
+        "paths": {
+            "@coast/core-types/*": ["../core-types/src/*"],
+            "@coast/core-types": ["../core-types/src"]
+        }
     },
-    "include": ["src/**/*"]
+    "references": [
+        { "path": "../core-types" }
+    ],
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
 }