slicejs-web-framework 4.0.1 → 4.1.0

package/api/tests/public-env-resolver.test.js

@@ -1,193 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-
-const resolverModulePath = new URL('../framework/publicEnvResolver.js', import.meta.url);
-
-async function withTempEnvFile(contents, callback) {
-   const dir = await mkdtemp(path.join(tmpdir(), 'slice-public-env-'));
-   const envFilePath = path.join(dir, '.env');
-
-   try {
-      await writeFile(envFilePath, contents, 'utf8');
-      await callback(envFilePath);
-   } finally {
-      await rm(dir, { recursive: true, force: true });
-   }
-}
-
-test('resolvePublicEnv filters only SLICE_PUBLIC_ keys', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-
-   await withTempEnvFile(
-      ['SLICE_PUBLIC_FROM_FILE=file-visible', 'PRIVATE_KEY=hidden-file-value', 'SLICE_API_URL=hidden-file-api-url'].join('\n'),
-      async (envFilePath) => {
-         const payload = resolvePublicEnv({
-            mode: 'development',
-            envFilePath,
-            processEnv: {
-               SLICE_PUBLIC_FROM_PROCESS: 'process-visible',
-               SECRET_TOKEN: 'hidden-process-token',
-               NODE_ENV: 'development',
-            },
-         });
-
-         assert.equal(payload.mode, 'development');
-         assert.deepEqual(payload.env, {
-            SLICE_PUBLIC_FROM_FILE: 'file-visible',
-            SLICE_PUBLIC_FROM_PROCESS: 'process-visible',
-         });
-      }
-   );
-});
-
-test('resolvePublicEnv uses process.env values over .env values', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-
-   await withTempEnvFile('SLICE_PUBLIC_API_URL=https://from-file.example', async (envFilePath) => {
-      const payload = resolvePublicEnv({
-         mode: 'development',
-         envFilePath,
-         processEnv: {
-            SLICE_PUBLIC_API_URL: 'https://from-process.example',
-         },
-      });
-
-      assert.equal(payload.mode, 'development');
-      assert.equal(payload.env.SLICE_PUBLIC_API_URL, 'https://from-process.example');
-   });
-});
-
-test('resolvePublicEnv warns about suspicious public key names without exposing values', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-   const warnings = [];
-   const logger = {
-      warn: (...args) => warnings.push(args.map(String).join(' ')),
-   };
-
-   await withTempEnvFile('SLICE_PUBLIC_API_KEY=super-secret-value', async (envFilePath) => {
-      const payload = resolvePublicEnv({
-         mode: 'development',
-         envFilePath,
-         processEnv: {},
-         logger,
-      });
-
-      assert.equal(payload.mode, 'development');
-      assert.equal(payload.env.SLICE_PUBLIC_API_KEY, 'super-secret-value');
-      assert.equal(warnings.length, 1);
-      assert.match(warnings[0], /SLICE_PUBLIC_API_KEY/);
-      assert.doesNotMatch(warnings[0], /super-secret-value/);
-   });
-});
-
-test('resolvePublicEnv warns once when suspicious key appears in .env and processEnv', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-   const warnings = [];
-   const logger = {
-      warn: (...args) => warnings.push(args.map(String).join(' ')),
-   };
-
-   await withTempEnvFile('SLICE_PUBLIC_API_KEY=from-file-secret', async (envFilePath) => {
-      const payload = resolvePublicEnv({
-         mode: 'development',
-         envFilePath,
-         processEnv: {
-            SLICE_PUBLIC_API_KEY: 'from-process-secret',
-         },
-         logger,
-      });
-
-      assert.equal(payload.env.SLICE_PUBLIC_API_KEY, 'from-process-secret');
-      assert.equal(warnings.length, 1);
-      assert.match(warnings[0], /SLICE_PUBLIC_API_KEY/);
-      assert.doesNotMatch(warnings[0], /from-file-secret|from-process-secret/);
-   });
-});
-
-test('resolvePublicEnv parses first key when .env starts with BOM', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-
-   await withTempEnvFile('\uFEFFSLICE_PUBLIC_TITLE=Slice App', async (envFilePath) => {
-      const payload = resolvePublicEnv({
-         mode: 'development',
-         envFilePath,
-         processEnv: {},
-      });
-
-      assert.equal(payload.env.SLICE_PUBLIC_TITLE, 'Slice App');
-   });
-});
-
-test('resolvePublicEnv strips inline comments for unquoted values', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-
-   await withTempEnvFile('SLICE_PUBLIC_ORIGIN=https://slice.dev # dev origin', async (envFilePath) => {
-      const payload = resolvePublicEnv({
-         mode: 'development',
-         envFilePath,
-         processEnv: {},
-      });
-
-      assert.equal(payload.env.SLICE_PUBLIC_ORIGIN, 'https://slice.dev');
-   });
-});
-
-test('resolvePublicEnv strips trailing comments after quoted values', async () => {
-   const { resolvePublicEnv } = await import(resolverModulePath.href);
-
-   await withTempEnvFile('SLICE_PUBLIC_X="value" # comment', async (envFilePath) => {
-      const payload = resolvePublicEnv({
-         mode: 'development',
-         envFilePath,
-         processEnv: {},
-      });
-
-      assert.equal(payload.env.SLICE_PUBLIC_X, 'value');
-   });
-});
-
-test('createPublicEnvProvider caches in production and recomputes in development', async () => {
-   const { createPublicEnvProvider } = await import(resolverModulePath.href);
-
-   await withTempEnvFile('SLICE_PUBLIC_COUNTER=from-file', async (envFilePath) => {
-      let processValue = 'first-value';
-      const processEnv = {
-         get SLICE_PUBLIC_COUNTER() {
-            return processValue;
-         },
-      };
-
-      const productionProvider = createPublicEnvProvider({
-         mode: 'production',
-         envFilePath,
-         processEnv,
-      });
-      assert.equal(typeof productionProvider.getPayload, 'function');
-
-      const firstProduction = productionProvider.getPayload();
-      processValue = 'second-value';
-      const secondProduction = productionProvider.getPayload();
-
-      assert.equal(firstProduction.mode, 'production');
-      assert.equal(firstProduction.env.SLICE_PUBLIC_COUNTER, 'first-value');
-      assert.equal(secondProduction.env.SLICE_PUBLIC_COUNTER, 'first-value');
-
-      const developmentProvider = createPublicEnvProvider({
-         mode: 'development',
-         envFilePath,
-         processEnv,
-      });
-      assert.equal(typeof developmentProvider.getPayload, 'function');
-
-      const firstDevelopment = developmentProvider.getPayload();
-      processValue = 'third-value';
-      const secondDevelopment = developmentProvider.getPayload();
-
-      assert.equal(firstDevelopment.mode, 'development');
-      assert.equal(firstDevelopment.env.SLICE_PUBLIC_COUNTER, 'second-value');
-      assert.equal(secondDevelopment.env.SLICE_PUBLIC_COUNTER, 'third-value');
-   });
-});

package/tests/router-emit-ordering.test.js

@@ -1,63 +0,0 @@
-// Regression test for GOTCHAS §3: router:change must not be observable before
-// slice.router.activeRoute is updated.
-//
-// Router is a plain class with no module-level DOM/global access and no imports,
-// so onRouteChange() can be exercised directly on a stubbed instance. The fix
-// makes onRouteChange() resolve only AFTER the debounced handleRoute() runs
-// (which is where activeRoute is set), so a caller that awaits it — like
-// _performNavigation — emits router:change with activeRoute already current.
-//
-// Run: node --test tests/router-emit-ordering.test.js
-
-import { test, describe, before } from 'node:test';
-import assert from 'node:assert/strict';
-
-describe('Router.onRouteChange (§3 emit-after-activeRoute)', () => {
-  let Router;
-
-  before(async () => {
-    globalThis.window = globalThis.window || { location: { pathname: '/' } };
-    globalThis.slice = globalThis.slice || { logger: { error() {} }, router: {} };
-    ({ default: Router } = await import('../Slice/Components/Structural/Router/Router.js'));
-  });
-
-  const makeRouter = (handleRoute) => {
-    const r = Object.create(Router.prototype);
-    r.renderRoutesComponentsInPage = async () => false; // not the MultiRoute container path
-    r.matchRoute = () => ({ route: { component: 'X' }, params: {} });
-    r.handleRoute = handleRoute;
-    return r;
-  };
-
-  test('awaiting onRouteChange() waits until handleRoute() has finished', async () => {
-    const order = [];
-    const r = makeRouter(async () => {
-      await new Promise((res) => setTimeout(res, 5)); // simulate async render
-      order.push('handleRoute-done'); // activeRoute is assigned here in the real code
-    });
-
-    await r.onRouteChange();
-    order.push('after-await');
-
-    // With the fix, handleRoute completes BEFORE the await returns. (Before the
-    // fix the awaited promise resolved the instant the timer was scheduled, so
-    // 'after-await' would land first — i.e. emit-before-activeRoute.)
-    assert.deepEqual(order, ['handleRoute-done', 'after-await']);
-  });
-
-  test('a superseded (debounced) call still resolves — no hang', async () => {
-    let handled = 0;
-    const r = makeRouter(async () => { handled++; });
-
-    const p1 = r.onRouteChange(); // schedules timer T1
-    const p2 = r.onRouteChange(); // clears T1, resolves p1, schedules T2
-
-    await Promise.race([
-      Promise.all([p1, p2]),
-      new Promise((_, rej) => setTimeout(() => rej(new Error('onRouteChange hung')), 1000)),
-    ]);
-
-    // Only the surviving timer runs its work.
-    assert.equal(handled, 1);
-  });
-});