slicejs-web-framework 3.2.1 → 3.2.3

package/Slice/tests/props-allowed-values-validation.test.js

@@ -0,0 +1,119 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { collectInvalidAllowedValueProps } from '../Components/Structural/Controller/allowedValuesValidation.js';
+
+test('collectInvalidAllowedValueProps returns empty when value is allowed', () => {
+  const result = collectInvalidAllowedValueProps(
+    {
+      variant: {
+        type: 'string',
+        allowedValues: ['primary', 'secondary']
+      }
+    },
+    {
+      variant: 'primary'
+    }
+  );
+
+  assert.deepEqual(result, []);
+});
+
+test('collectInvalidAllowedValueProps reports invalid provided values', () => {
+  const result = collectInvalidAllowedValueProps(
+    {
+      variant: {
+        type: 'string',
+        allowedValues: ['primary', 'secondary']
+      },
+      size: {
+        type: 'number',
+        allowedValues: [12, 16]
+      }
+    },
+    {
+      variant: 'danger',
+      size: 14
+    }
+  );
+
+  assert.deepEqual(result, [
+    {
+      propName: 'variant',
+      value: 'danger',
+      allowedValues: ['primary', 'secondary']
+    },
+    {
+      propName: 'size',
+      value: 14,
+      allowedValues: [12, 16]
+    }
+  ]);
+});
+
+test('collectInvalidAllowedValueProps ignores props not provided', () => {
+  const result = collectInvalidAllowedValueProps(
+    {
+      variant: {
+        type: 'string',
+        allowedValues: ['primary', 'secondary']
+      },
+      disabled: {
+        type: 'boolean'
+      }
+    },
+    {
+      disabled: true
+    }
+  );
+
+  assert.deepEqual(result, []);
+});
+
+test('collectInvalidAllowedValueProps uses strict equality', () => {
+  const result = collectInvalidAllowedValueProps(
+    {
+      amount: {
+        type: 'number',
+        allowedValues: [1]
+      },
+      active: {
+        type: 'boolean',
+        allowedValues: [true]
+      }
+    },
+    {
+      amount: '1',
+      active: 1
+    }
+  );
+
+  assert.deepEqual(result, [
+    {
+      propName: 'amount',
+      value: '1',
+      allowedValues: [1]
+    },
+    {
+      propName: 'active',
+      value: 1,
+      allowedValues: [true]
+    }
+  ]);
+});
+
+test('collectInvalidAllowedValueProps ignores empty allowedValues arrays', () => {
+  const result = collectInvalidAllowedValueProps(
+    {
+      variant: {
+        type: 'string',
+        allowedValues: []
+      }
+    },
+    {
+      variant: 'unexpected'
+    }
+  );
+
+  assert.deepEqual(result, []);
+});

package/Slice/tests/public-env-runtime-accessors.test.js

@@ -1,44 +1,44 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-globalThis.alert = () => {};
-
-const { default: Slice } = await import('../Slice.js');
-
-function createSliceInstance() {
-  return new Slice({
-    paths: {},
-    themeManager: {},
-    stylesManager: {},
-    logger: {},
-    debugger: {},
-    loading: {},
-    events: {}
-  });
-}
-
-test('getEnv returns fallback for missing key and stored value for known key', () => {
-  const sliceInstance = createSliceInstance();
-
-  assert.equal(typeof sliceInstance.getEnv, 'function');
-  assert.equal(typeof sliceInstance.setPublicEnv, 'function');
-  assert.equal(sliceInstance.getEnv('SLICE_PUBLIC_MISSING', 'fallback'), 'fallback');
-
-  sliceInstance.setPublicEnv({ SLICE_PUBLIC_API_URL: 'https://api.example.com' });
-  assert.equal(sliceInstance.getEnv('SLICE_PUBLIC_API_URL'), 'https://api.example.com');
-});
-
-test('getPublicEnv returns a copy and only includes SLICE_PUBLIC_ keys', () => {
-  const sliceInstance = createSliceInstance();
-
-  sliceInstance.setPublicEnv({
-    SLICE_PUBLIC_FLAG: 'true',
-    INTERNAL_SECRET: 'hidden'
-  });
-
-  const snapshot = sliceInstance.getPublicEnv();
-  assert.deepEqual(snapshot, { SLICE_PUBLIC_FLAG: 'true' });
-
-  snapshot.SLICE_PUBLIC_FLAG = 'mutated';
-  assert.equal(sliceInstance.getEnv('SLICE_PUBLIC_FLAG'), 'true');
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+globalThis.alert = () => {};
+
+const { default: Slice } = await import('../Slice.js');
+
+function createSliceInstance() {
+  return new Slice({
+    paths: {},
+    themeManager: {},
+    stylesManager: {},
+    logger: {},
+    debugger: {},
+    loading: {},
+    events: {}
+  });
+}
+
+test('getEnv returns fallback for missing key and stored value for known key', () => {
+  const sliceInstance = createSliceInstance();
+
+  assert.equal(typeof sliceInstance.getEnv, 'function');
+  assert.equal(typeof sliceInstance.setPublicEnv, 'function');
+  assert.equal(sliceInstance.getEnv('SLICE_PUBLIC_MISSING', 'fallback'), 'fallback');
+
+  sliceInstance.setPublicEnv({ SLICE_PUBLIC_API_URL: 'https://api.example.com' });
+  assert.equal(sliceInstance.getEnv('SLICE_PUBLIC_API_URL'), 'https://api.example.com');
+});
+
+test('getPublicEnv returns a copy and only includes SLICE_PUBLIC_ keys', () => {
+  const sliceInstance = createSliceInstance();
+
+  sliceInstance.setPublicEnv({
+    SLICE_PUBLIC_FLAG: 'true',
+    INTERNAL_SECRET: 'hidden'
+  });
+
+  const snapshot = sliceInstance.getPublicEnv();
+  assert.deepEqual(snapshot, { SLICE_PUBLIC_FLAG: 'true' });
+
+  snapshot.SLICE_PUBLIC_FLAG = 'mutated';
+  assert.equal(sliceInstance.getEnv('SLICE_PUBLIC_FLAG'), 'true');
+});

package/Slice/tests/router-loading-finally.test.js

@@ -1,68 +1,68 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Router from '../Components/Structural/Router/Router.js';
-
-test('handleRoute stops loading when build throws on error path', async () => {
-   const originalSlice = globalThis.slice;
-   const originalDocument = globalThis.document;
-
-   const targetElement = {
-      innerHTML: 'existing',
-      appendChild() {},
-   };
-
-   try {
-      globalThis.document = {
-         querySelector(selector) {
-            if (selector === '#app') {
-               return targetElement;
-            }
-            return null;
-         },
-      };
-
-      const loadingCalls = [];
-
-      globalThis.slice = {
-         loading: {
-            start() {
-               loadingCalls.push('start');
-            },
-            stop() {
-               loadingCalls.push('stop');
-            },
-         },
-         controller: {
-            getComponent() {
-               return null;
-            },
-         },
-         build: async () => {
-            throw new Error('boom');
-         },
-         router: {
-            activeRoute: null,
-         },
-      };
-
-      const router = new Router([]);
-
-      await assert.rejects(
-         () =>
-            router.handleRoute(
-               {
-                  component: 'Dashboard',
-                  parentRoute: null,
-               },
-               {}
-            ),
-         /boom/
-      );
-
-      assert.deepEqual(loadingCalls, ['start', 'stop']);
-   } finally {
-      globalThis.slice = originalSlice;
-      globalThis.document = originalDocument;
-   }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import Router from '../Components/Structural/Router/Router.js';
+
+test('handleRoute stops loading when build throws on error path', async () => {
+   const originalSlice = globalThis.slice;
+   const originalDocument = globalThis.document;
+
+   const targetElement = {
+      innerHTML: 'existing',
+      appendChild() {},
+   };
+
+   try {
+      globalThis.document = {
+         querySelector(selector) {
+            if (selector === '#app') {
+               return targetElement;
+            }
+            return null;
+         },
+      };
+
+      const loadingCalls = [];
+
+      globalThis.slice = {
+         loading: {
+            start() {
+               loadingCalls.push('start');
+            },
+            stop() {
+               loadingCalls.push('stop');
+            },
+         },
+         controller: {
+            getComponent() {
+               return null;
+            },
+         },
+         build: async () => {
+            throw new Error('boom');
+         },
+         router: {
+            activeRoute: null,
+         },
+      };
+
+      const router = new Router([]);
+
+      await assert.rejects(
+         () =>
+            router.handleRoute(
+               {
+                  component: 'Dashboard',
+                  parentRoute: null,
+               },
+               {}
+            ),
+         /boom/
+      );
+
+      assert.deepEqual(loadingCalls, ['start', 'stop']);
+   } finally {
+      globalThis.slice = originalSlice;
+      globalThis.document = originalDocument;
+   }
+});