slicejs-web-framework 4.0.2 → 4.1.1

package/Slice/tests/bundle-v2-runtime-contract.test.js

@@ -1,747 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { register } from 'node:module';
-import { pathToFileURL } from 'node:url';
-
-test('validateBundleModule rejects module missing Bundling V2 exports contract', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalWindow = globalThis.window;
-
-   try {
-      globalThis.window = {
-         __slicePendingRegistrations: [],
-      };
-
-      assert.equal(
-         typeof controller.validateBundleModule,
-         'function',
-         'Controller must expose validateBundleModule for Bundling V2 runtime contract checks'
-      );
-
-      if (typeof controller.validateBundleModule === 'function') {
-         await assert.rejects(
-            () => Promise.resolve(controller.validateBundleModule({ default: {} }, 'critical.js')),
-            /missing bundling v2 exports contract/i
-         );
-      }
-   } finally {
-      globalThis.window = originalWindow;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('loadBundle marks requested bundle key and metadata bundleKey as loaded', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalSlice = globalThis.slice;
-
-   controller.bundleConfig = {
-      bundles: {
-         routes: {
-            dashboard: {
-               file: 'dashboard.js',
-            },
-         },
-      },
-   };
-
-   controller.importBundleOnce = async () => ({});
-   controller.validateBundleModule = async () => ({
-      metadata: {
-         bundleKey: 'routes.dashboard.v2',
-         type: 'route',
-      },
-      registerAll: async () => {},
-   });
-
-   try {
-      globalThis.slice = {
-         stylesManager: {},
-      };
-
-      await controller.loadBundle('dashboard');
-
-      assert.equal(controller.loadedBundles.has('dashboard'), true);
-      assert.equal(controller.loadedBundles.has('routes.dashboard.v2'), true);
-      assert.equal(controller.criticalBundleLoaded, false);
-   } finally {
-      globalThis.slice = originalSlice;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('loadBundle resolves dependencies first and registers vendor-shared exports once', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalSlice = globalThis.slice;
-   const originalWindow = globalThis.window;
-
-   controller.bundleConfig = {
-      bundles: {
-         shared: {
-            'vendor-shared': {
-               file: 'slice-bundle.vendor-shared.js',
-            },
-         },
-         routes: {
-            dashboard: {
-               file: 'slice-bundle.dashboard.js',
-               dependencies: ['vendor-shared'],
-            },
-         },
-      },
-   };
-
-   const importOrder = [];
-   const registerOrder = [];
-   const importsByPath = {
-      '/bundles/slice-bundle.vendor-shared.js': {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'vendor-shared',
-            type: 'shared',
-         },
-         SLICE_SHARED_DEPS: {
-            'vendors/dompurify': {
-               sanitize: () => 'ok',
-            },
-         },
-         registerAll: async () => {
-            registerOrder.push('vendor-shared');
-         },
-      },
-      '/bundles/slice-bundle.dashboard.js': {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'dashboard',
-            type: 'route',
-         },
-         registerAll: async () => {
-            registerOrder.push('dashboard');
-         },
-      },
-   };
-
-   controller.importBundleOnce = async (bundlePath) => {
-      importOrder.push(bundlePath);
-      return importsByPath[bundlePath];
-   };
-
-   try {
-      globalThis.slice = {
-         stylesManager: {},
-      };
-      globalThis.window = {
-         __SLICE_SHARED_DEPS__: {},
-      };
-
-      await controller.loadBundle('dashboard');
-      await controller.loadBundle('dashboard');
-
-      assert.deepEqual(importOrder, ['/bundles/slice-bundle.vendor-shared.js', '/bundles/slice-bundle.dashboard.js']);
-      assert.deepEqual(registerOrder, ['vendor-shared', 'dashboard']);
-      assert.equal(typeof globalThis.window.__SLICE_SHARED_DEPS__['vendors/dompurify']?.sanitize, 'function');
-   } finally {
-      globalThis.slice = originalSlice;
-      globalThis.window = originalWindow;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('loadBundle resolves vendor-shared dependency from bundles.vendorShared config shape', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalSlice = globalThis.slice;
-   const originalWindow = globalThis.window;
-
-   controller.bundleConfig = {
-      bundles: {
-         vendorShared: {
-            file: 'slice-bundle.vendor-shared.js',
-         },
-         routes: {
-            dashboard: {
-               file: 'slice-bundle.dashboard.js',
-               dependencies: ['vendor-shared'],
-            },
-         },
-      },
-   };
-
-   const importOrder = [];
-   const registerOrder = [];
-   const importsByPath = {
-      '/bundles/slice-bundle.vendor-shared.js': {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'vendor-shared',
-            type: 'shared',
-         },
-         SLICE_SHARED_DEPS: {
-            'vendors/dompurify': {
-               sanitize: () => 'ok',
-            },
-         },
-         registerAll: async () => {
-            registerOrder.push('vendor-shared');
-         },
-      },
-      '/bundles/slice-bundle.dashboard.js': {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'dashboard',
-            type: 'route',
-         },
-         registerAll: async () => {
-            registerOrder.push('dashboard');
-         },
-      },
-   };
-
-   controller.importBundleOnce = async (bundlePath) => {
-      importOrder.push(bundlePath);
-      return importsByPath[bundlePath];
-   };
-
-   try {
-      globalThis.slice = {
-         stylesManager: {},
-      };
-      globalThis.window = {
-         __SLICE_SHARED_DEPS__: {},
-      };
-
-      await controller.loadBundle('dashboard');
-
-      assert.deepEqual(importOrder, ['/bundles/slice-bundle.vendor-shared.js', '/bundles/slice-bundle.dashboard.js']);
-      assert.deepEqual(registerOrder, ['vendor-shared', 'dashboard']);
-      assert.equal(typeof globalThis.window.__SLICE_SHARED_DEPS__['vendors/dompurify']?.sanitize, 'function');
-   } finally {
-      globalThis.slice = originalSlice;
-      globalThis.window = originalWindow;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('loadBundle registers vendor-shared dependencies from registerAll return when SLICE_SHARED_DEPS export is absent', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalSlice = globalThis.slice;
-   const originalWindow = globalThis.window;
-
-   controller.bundleConfig = {
-      bundles: {
-         vendorShared: {
-            file: 'slice-bundle.vendor-shared.js',
-         },
-         routes: {
-            dashboard: {
-               file: 'slice-bundle.dashboard.js',
-               dependencies: ['vendor-shared'],
-            },
-         },
-      },
-   };
-
-   const importsByPath = {
-      '/bundles/slice-bundle.vendor-shared.js': {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'vendor-shared',
-            type: 'shared',
-         },
-         registerAll: async () => ({
-            'vendors/dompurify': {
-               sanitize: () => 'ok',
-            },
-         }),
-      },
-      '/bundles/slice-bundle.dashboard.js': {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'dashboard',
-            type: 'route',
-         },
-         registerAll: async () => {},
-      },
-   };
-
-   controller.importBundleOnce = async (bundlePath) => importsByPath[bundlePath];
-
-   try {
-      globalThis.slice = {
-         stylesManager: {},
-      };
-      globalThis.window = {
-         __SLICE_SHARED_DEPS__: {},
-      };
-
-      await controller.loadBundle('dashboard');
-
-      assert.equal(typeof globalThis.window.__SLICE_SHARED_DEPS__['vendors/dompurify']?.sanitize, 'function');
-   } finally {
-      globalThis.slice = originalSlice;
-      globalThis.window = originalWindow;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('loadBundle appends bundle hash as query param when importing bundle files', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalSlice = globalThis.slice;
-
-   controller.bundleConfig = {
-      bundles: {
-         routes: {
-            dashboard: {
-               file: 'slice-bundle.dashboard.js',
-               hash: 'abc123hash',
-            },
-         },
-      },
-   };
-
-   let importedPath = null;
-   controller.importBundleOnce = async (bundlePath) => {
-      importedPath = bundlePath;
-      return {
-         SLICE_BUNDLE_META: {
-            bundleKey: 'dashboard',
-            type: 'route',
-         },
-         registerAll: async () => {},
-      };
-   };
-
-   try {
-      globalThis.slice = {
-         stylesManager: {},
-      };
-
-      await controller.loadBundle('dashboard');
-      assert.equal(importedPath, '/bundles/slice-bundle.dashboard.js?v=abc123hash');
-   } finally {
-      globalThis.slice = originalSlice;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('loadBundle dedupes concurrent and repeated alias/case requests using canonical bundle key', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalSlice = globalThis.slice;
-
-   controller.bundleConfig = {
-      bundles: {
-         routes: {
-            dashboard: {
-               file: 'slice-bundle.dashboard.js',
-            },
-         },
-      },
-   };
-
-   let registerCallCount = 0;
-   controller.importBundleOnce = async () => ({
-      SLICE_BUNDLE_META: {
-         bundleKey: 'routes.dashboard.v2',
-         type: 'route',
-      },
-      registerAll: async () => {
-         registerCallCount += 1;
-         await new Promise((resolve) => setTimeout(resolve, 10));
-      },
-   });
-
-   try {
-      globalThis.slice = {
-         stylesManager: {},
-      };
-
-      await Promise.all([
-         controller.loadBundle('dashboard'),
-         controller.loadBundle('DASHBOARD'),
-      ]);
-
-      await controller.loadBundle('Dashboard');
-
-      assert.equal(registerCallCount, 1);
-      assert.equal(controller.loadedBundles.has('dashboard'), true);
-      assert.equal(controller.loadedBundles.has('routes.dashboard.v2'), true);
-      assert.equal(controller.bundleLoadPromises.size, 0);
-   } finally {
-      globalThis.slice = originalSlice;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('registerVendorSharedDependencies only runs for vendor-shared canonical bundle or explicit metadata flag', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-controller-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const controller = new Controller();
-   const originalWindow = globalThis.window;
-
-   try {
-      globalThis.window = {
-         __SLICE_SHARED_DEPS__: {},
-      };
-
-      controller.registerVendorSharedDependencies(
-         {
-            SLICE_SHARED_DEPS: {
-               shouldNotLoad: true,
-            },
-         },
-         {
-            type: 'shared',
-            bundleKey: 'app-shared',
-         },
-         'app-shared'
-      );
-
-      assert.equal(globalThis.window.__SLICE_SHARED_DEPS__.shouldNotLoad, undefined);
-
-      controller.registerVendorSharedDependencies(
-         {
-            SLICE_SHARED_DEPS: {
-               explicitFlagDependency: true,
-            },
-         },
-         {
-            type: 'shared',
-            bundleKey: 'app-shared',
-            registerVendorSharedDependencies: true,
-         },
-         'app-shared'
-      );
-
-      assert.equal(globalThis.window.__SLICE_SHARED_DEPS__.explicitFlagDependency, true);
-   } finally {
-      globalThis.window = originalWindow;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});
-
-test('Slice init fails fast with contextual error on invalid Bundling V2 contract path', async () => {
-   const tempDir = await mkdtemp(path.join(tmpdir(), 'slice-init-loader-'));
-   const loaderPath = path.join(tempDir, 'components-alias-loader.mjs');
-   await writeFile(
-      loaderPath,
-      `export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         shortCircuit: true,
-         url: 'data:text/javascript,export default {};',
-      };
-   }
-   return nextResolve(specifier, context);
-}
-`,
-      'utf8'
-   );
-   register(pathToFileURL(loaderPath).href);
-
-   const originalWindow = globalThis.window;
-   const originalDocument = globalThis.document;
-   const originalFetch = globalThis.fetch;
-   const originalAlert = globalThis.alert;
-   const originalSliceDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'slice');
-   const originalConsoleLog = console.log;
-   const originalConsoleWarn = console.warn;
-   const originalConsoleError = console.error;
-   const controllerModuleUrl = new URL('../Components/Structural/Controller/Controller.js', import.meta.url).href;
-   const { default: Controller } = await import(controllerModuleUrl);
-   const originalLoadBundle = Controller.prototype.loadBundle;
-
-   const loggedMessages = [];
-
-   try {
-      globalThis.window = {
-         location: {
-            pathname: '/dashboard',
-            origin: 'http://localhost',
-         },
-      };
-
-      Object.defineProperty(globalThis, 'slice', {
-         configurable: true,
-         get() {
-            return globalThis.window?.slice;
-         },
-         set(value) {
-            if (!globalThis.window) {
-               globalThis.window = {};
-            }
-            globalThis.window.slice = value;
-         },
-      });
-
-      Controller.prototype.loadBundle = async () => {
-         throw new Error(
-            'Bundle "critical" missing Bundling V2 exports contract: requires SLICE_BUNDLE_META and registerAll'
-         );
-      };
-
-      globalThis.document = {
-         head: {
-            appendChild() {},
-         },
-         body: {
-            appendChild() {},
-         },
-         createElement() {
-            return {
-               appendChild() {},
-               innerHTML: '',
-               id: '',
-            };
-         },
-         createTextNode() {
-            return {};
-         },
-         addEventListener() {},
-      };
-
-      globalThis.alert = () => {};
-      console.log = (...args) => {
-         loggedMessages.push(args.map(String).join(' '));
-      };
-      console.warn = () => {};
-      console.error = (...args) => {
-         loggedMessages.push(args.map(String).join(' '));
-      };
-
-      globalThis.fetch = async (url) => {
-         if (url === '/sliceConfig.json') {
-            return {
-               ok: true,
-               json: async () => ({
-                  paths: {
-                     routesFile: '/routes.js',
-                     components: {},
-                  },
-                  themeManager: { enabled: false },
-                  stylesManager: { requestedStyles: [] },
-                  logger: { enabled: false },
-                  debugger: { enabled: false },
-                  loading: { enabled: false },
-                  events: { enabled: false },
-                  context: { enabled: false },
-               }),
-            };
-         }
-
-         if (url === '/slice-env.json') {
-            return {
-               ok: true,
-               json: async () => ({ mode: 'production' }),
-            };
-         }
-
-         if (url === '/bundles/bundle.config.json') {
-            return {
-               ok: true,
-               json: async () => ({
-                  production: true,
-                  bundles: {
-                     critical: { file: 'critical.js' },
-                     routes: {},
-                  },
-                  routeBundles: {},
-               }),
-            };
-         }
-
-         throw new Error(`Unexpected fetch URL: ${url}`);
-      };
-
-      const sliceModuleUrl = new URL(`../Slice.js?fail-fast-test=${Date.now()}`, import.meta.url).href;
-
-      // Failing fast means the failure propagates: a rejected import stops
-      // consumers from running against a runtime that has no router and no
-      // registered components. Previously init() logged and resolved anyway,
-      // so the first symptom a developer saw was an unrelated TypeError
-      // further downstream rather than this contextual error.
-      await assert.rejects(
-         () => import(sliceModuleUrl),
-         /Bundling V2 initialization failed/,
-         'a failed init must reject the module import, not resolve a half-built runtime'
-      );
-
-      assert.ok(
-         loggedMessages.some((message) => /Bundling V2 initialization failed/i.test(message)),
-         'init must log contextual error on Bundling V2 contract failure'
-      );
-
-      assert.equal(
-         loggedMessages.some((message) => message.includes('Using individual component loading (no bundles found)')),
-         false,
-         'init must not log fallback bundle message on Bundling V2 contract failure'
-      );
-   } finally {
-      Controller.prototype.loadBundle = originalLoadBundle;
-      globalThis.window = originalWindow;
-      globalThis.document = originalDocument;
-      globalThis.fetch = originalFetch;
-      globalThis.alert = originalAlert;
-      if (originalSliceDescriptor) {
-         Object.defineProperty(globalThis, 'slice', originalSliceDescriptor);
-      } else {
-         delete globalThis.slice;
-      }
-      console.log = originalConsoleLog;
-      console.warn = originalConsoleWarn;
-      console.error = originalConsoleError;
-      await rm(tempDir, { recursive: true, force: true });
-   }
-});