slicejs-web-framework 4.0.2 → 4.1.1

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

@@ -1,119 +0,0 @@
-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 +0,0 @@
-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/public-env-typed-accessors.test.js

@@ -1,66 +0,0 @@
-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('slice.env.get / has / all', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({ SLICE_PUBLIC_API_URL: 'https://api.example.com', INTERNAL: 'hidden' });
-
-  assert.equal(s.env.get('SLICE_PUBLIC_API_URL'), 'https://api.example.com');
-  assert.equal(s.env.get('SLICE_PUBLIC_MISSING', 'fb'), 'fb');
-  assert.equal(s.env.has('SLICE_PUBLIC_API_URL'), true);
-  assert.equal(s.env.has('SLICE_PUBLIC_MISSING'), false);
-  assert.deepEqual(s.env.all(), { SLICE_PUBLIC_API_URL: 'https://api.example.com' }); // only SLICE_PUBLIC_*
-});
-
-test('slice.env.bool parses truthy strings and falls back', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({
-    SLICE_PUBLIC_ON: 'true',
-    SLICE_PUBLIC_ON2: 'YES',
-    SLICE_PUBLIC_ON3: '1',
-    SLICE_PUBLIC_OFF: 'false',
-    SLICE_PUBLIC_EMPTY: ''
-  });
-
-  assert.equal(s.env.bool('SLICE_PUBLIC_ON'), true);
-  assert.equal(s.env.bool('SLICE_PUBLIC_ON2'), true);
-  assert.equal(s.env.bool('SLICE_PUBLIC_ON3'), true);
-  assert.equal(s.env.bool('SLICE_PUBLIC_OFF'), false);
-  assert.equal(s.env.bool('SLICE_PUBLIC_EMPTY', true), true);   // empty → fallback
-  assert.equal(s.env.bool('SLICE_PUBLIC_MISSING'), false);       // missing → default false
-  assert.equal(s.env.bool('SLICE_PUBLIC_MISSING', true), true);  // missing → custom fallback
-});
-
-test('slice.env.int parses integers and falls back', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({ SLICE_PUBLIC_TIMEOUT: '5000', SLICE_PUBLIC_BAD: 'nope' });
-
-  assert.equal(s.env.int('SLICE_PUBLIC_TIMEOUT'), 5000);
-  assert.equal(s.env.int('SLICE_PUBLIC_BAD', 10), 10);       // non-numeric → fallback
-  assert.equal(s.env.int('SLICE_PUBLIC_MISSING', 42), 42);   // missing → fallback
-});
-
-test('slice.env.list splits CSV, trims, drops empties', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({ SLICE_PUBLIC_MODELS: ' a , b ,, c ', SLICE_PUBLIC_EMPTY: '' });
-
-  assert.deepEqual(s.env.list('SLICE_PUBLIC_MODELS'), ['a', 'b', 'c']);
-  assert.deepEqual(s.env.list('SLICE_PUBLIC_EMPTY', ['x']), ['x']);     // empty → fallback
-  assert.deepEqual(s.env.list('SLICE_PUBLIC_MISSING'), []);             // missing → default []
-});

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

@@ -1,68 +0,0 @@
-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;
-   }
-});

package/api/tests/dev-deps-optimizer.test.js

@@ -1,137 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { createDevDepsOptimizer, MODULES_PREFIX } from '../framework/devDepsOptimizer.js';
-
-// projectRoot for esbuild resolution: this framework package's own root, whose
-// node_modules contains es-module-lexer (used here as a real ESM package to
-// bundle). Two dirs up from api/tests/.
-const projectRoot = new URL('../../', import.meta.url).pathname;
-
-test('rewriteBareImports rewrites bare specifiers to the virtual endpoint', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  const code = [
-    "import dayjs from 'dayjs';",
-    "import { a, b } from '@scope/pkg';",
-    "import './local.js';",
-    "import '/libs/x.js';",
-    "import x from 'https://cdn/x.js';",
-    "const d = import('lodash/fp');"
-  ].join('\n');
-
-  const out = await opt.rewriteBareImports(code);
-
-  assert.match(out, new RegExp(`from '${MODULES_PREFIX}dayjs'`));
-  assert.match(out, new RegExp(`from '${MODULES_PREFIX}@scope/pkg'`));
-  assert.match(out, new RegExp(`import\\('${MODULES_PREFIX}lodash/fp'\\)`));
-  // Relative, absolute (public/) and URL imports are untouched.
-  assert.match(out, /import '\.\/local\.js'/);
-  assert.match(out, /import '\/libs\/x\.js'/);
-  assert.match(out, /from 'https:\/\/cdn\/x\.js'/);
-});
-
-test('rewriteBareImports is a no-op when disabled', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: false });
-  const code = "import dayjs from 'dayjs';";
-  assert.equal(await opt.rewriteBareImports(code), code);
-});
-
-test('rewriteBareImports returns source unchanged when there is nothing bare', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  const code = "import './a.js';\nexport const x = 1;\n";
-  assert.equal(await opt.rewriteBareImports(code), code);
-});
-
-test('specifierFromRequest extracts the package from the virtual path', () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  assert.equal(opt.specifierFromRequest(`${MODULES_PREFIX}dayjs`), 'dayjs');
-  assert.equal(opt.specifierFromRequest(`${MODULES_PREFIX}@scope/pkg/sub`), '@scope/pkg/sub');
-  assert.equal(opt.specifierFromRequest('/Components/x.js'), null);
-});
-
-test('bundlePackage resolves a real ESM package to self-contained ESM', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  // es-module-lexer is a named-export ESM package (no default) — exercises the
-  // namespace-only fallback path in bundlePackage.
-  const { code } = await opt.bundlePackage('es-module-lexer');
-  assert.ok(code.length > 0, 'expected bundled code');
-  // Self-contained: no bare imports left to resolve at runtime.
-  assert.doesNotMatch(code, /^\s*import\s+.*from\s+['"][^./]/m);
-  // Exposes the package's named API.
-  assert.match(code, /\bparse\b/);
-  assert.match(code, /export\s*\{/);
-});
-
-test('bundlePackage caches and shares a single build per specifier', async () => {
-  const opt = createDevDepsOptimizer({ projectRoot, enabled: true });
-  const [a, b] = await Promise.all([
-    opt.bundlePackage('es-module-lexer'),
-    opt.bundlePackage('es-module-lexer')
-  ]);
-  assert.equal(a, b, 'concurrent requests should share the same cached result');
-});
-
-test('bundlePackage persists a disk cache keyed by version, reused by a fresh optimizer', async () => {
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-devcache-'));
-  try {
-    // Minimal installed package in the temp project's node_modules.
-    const pkgDir = path.join(tmp, 'node_modules', 'mini-pkg');
-    await fsp.mkdir(pkgDir, { recursive: true });
-    await fsp.writeFile(path.join(pkgDir, 'package.json'),
-      JSON.stringify({ name: 'mini-pkg', version: '2.3.4', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const hi = () => "hi";');
-
-    const opt1 = createDevDepsOptimizer({ projectRoot: tmp, enabled: true });
-    const first = await opt1.bundlePackage('mini-pkg');
-    assert.match(first.code, /hi/);
-
-    // A cache file keyed by the installed version must now exist.
-    const cacheFile = path.join(tmp, 'node_modules', '.slice-deps', 'mini-pkg@2.3.4.js');
-    const cached = await fsp.readFile(cacheFile, 'utf8');
-    assert.equal(cached, first.code);
-
-    // A brand-new optimizer (empty in-memory cache) reads the same bytes from disk.
-    const opt2 = createDevDepsOptimizer({ projectRoot: tmp, enabled: true });
-    const second = await opt2.bundlePackage('mini-pkg');
-    assert.equal(second.code, first.code);
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-});
-
-test('bundlePackage prunes stale cache files when a package version changes', async () => {
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-devcache-gc-'));
-  try {
-    const pkgDir = path.join(tmp, 'node_modules', 'mini-pkg');
-    const pkgJson = path.join(pkgDir, 'package.json');
-    const cacheDir = path.join(tmp, 'node_modules', '.slice-deps');
-    await fsp.mkdir(pkgDir, { recursive: true });
-    await fsp.writeFile(pkgJson, JSON.stringify({ name: 'mini-pkg', version: '1.0.0', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const v = 1;');
-
-    // A sibling package must survive the prune (its name is not a prefix match).
-    const otherDir = path.join(tmp, 'node_modules', 'mini-pkg-extra');
-    await fsp.mkdir(otherDir, { recursive: true });
-    await fsp.writeFile(path.join(otherDir, 'package.json'), JSON.stringify({ name: 'mini-pkg-extra', version: '9.0.0', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(otherDir, 'index.js'), 'export const e = 1;');
-
-    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg');
-    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg-extra');
-    assert.ok(await fsp.stat(path.join(cacheDir, 'mini-pkg@1.0.0.js')).then(() => true));
-
-    // Simulate an upgrade: bump the installed version, then rebundle.
-    await fsp.writeFile(pkgJson, JSON.stringify({ name: 'mini-pkg', version: '1.1.0', type: 'module', main: 'index.js' }));
-    await fsp.writeFile(path.join(pkgDir, 'index.js'), 'export const v = 2;');
-    await createDevDepsOptimizer({ projectRoot: tmp, enabled: true }).bundlePackage('mini-pkg');
-
-    const remaining = (await fsp.readdir(cacheDir)).sort();
-    // Old version gone, new version present, sibling untouched.
-    assert.ok(!remaining.includes('mini-pkg@1.0.0.js'), 'stale version should be pruned');
-    assert.ok(remaining.includes('mini-pkg@1.1.0.js'), 'new version should be cached');
-    assert.ok(remaining.includes('mini-pkg-extra@9.0.0.js'), 'sibling package must not be pruned');
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-});

package/api/tests/dev-server-external.test.js

@@ -1,56 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-
-// Boots the real dev server against a temp project and checks the two moving
-// parts of external-dependency support in development: bare-import rewriting of
-// served src modules, and on-demand esbuild bundling at /@slice-modules/.
-test('dev server rewrites bare imports and serves bundled packages', async () => {
-  process.env.NODE_ENV = 'development';
-  const frameworkRoot = new URL('../../', import.meta.url).pathname; // slice.js root
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-dev-'));
-
-  try {
-    await fsp.mkdir(path.join(tmp, 'src', 'Components', 'Demo'), { recursive: true });
-    await fsp.writeFile(
-      path.join(tmp, 'src', 'sliceConfig.json'),
-      JSON.stringify({ externalDependencies: { enabled: true } })
-    );
-    await fsp.writeFile(
-      path.join(tmp, 'src', 'Components', 'Demo', 'Demo.js'),
-      "import { parse } from 'es-module-lexer';\nimport './local.js';\nexport default class Demo { run(){ return typeof parse; } }\n"
-    );
-    // Make es-module-lexer resolvable from the temp project for esbuild.
-    fs.symlinkSync(path.join(frameworkRoot, 'node_modules'), path.join(tmp, 'node_modules'), 'dir');
-
-    const { createSliceServer } = await import('../framework/server.js');
-    const { app } = createSliceServer({ projectRoot: tmp });
-    const server = app.listen(0);
-    await new Promise((resolve) => server.once('listening', resolve));
-    const base = `http://127.0.0.1:${server.address().port}`;
-
-    try {
-      // 1. The component's bare import is rewritten; the relative one is not.
-      const compRes = await fetch(`${base}/Components/Demo/Demo.js`);
-      const compText = await compRes.text();
-      assert.equal(compRes.status, 200);
-      assert.match(compText, /from ['"]\/@slice-modules\/es-module-lexer['"]/);
-      assert.match(compText, /import ['"]\.\/local\.js['"]/);
-
-      // 2. The virtual endpoint returns a self-contained ESM bundle of the pkg.
-      const modRes = await fetch(`${base}/@slice-modules/es-module-lexer`);
-      const modText = await modRes.text();
-      assert.equal(modRes.status, 200);
-      assert.match(modRes.headers.get('content-type') || '', /javascript/);
-      assert.match(modText, /export\s*\{/);
-      assert.doesNotMatch(modText, /^\s*import\s+.*from\s+['"][^./]/m);
-    } finally {
-      await new Promise((resolve) => server.close(resolve));
-    }
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-});

package/api/tests/precompressed-static.test.js

@@ -1,119 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { createPrecompressedStatic } from '../framework/precompressedStatic.js';
-
-function fakeRes() {
-  return {
-    headers: {},
-    body: null,
-    sent: false,
-    setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
-    send(body) { this.body = body; this.sent = true; return this; }
-  };
-}
-
-function run(mw, req) {
-  const res = fakeRes();
-  let nextCalled = false;
-  mw(req, res, () => { nextCalled = true; });
-  return { res, nextCalled };
-}
-
-async function withRoot(fn) {
-  const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'slice-precomp-'));
-  try {
-    await fn(tmp);
-  } finally {
-    await fsp.rm(tmp, { recursive: true, force: true });
-  }
-}
-
-test('serves the .br variant when the client accepts brotli', async () => {
-  await withRoot(async (root) => {
-    await fsp.mkdir(path.join(root, 'bundles'), { recursive: true });
-    await fsp.writeFile(path.join(root, 'bundles', 'app.js'), 'ORIGINAL');
-    await fsp.writeFile(path.join(root, 'bundles', 'app.js.br'), 'BROTLI-BYTES');
-    await fsp.writeFile(path.join(root, 'bundles', 'app.js.gz'), 'GZIP-BYTES');
-
-    const mw = createPrecompressedStatic([root]);
-    const { res, nextCalled } = run(mw, {
-      method: 'GET', path: '/bundles/app.js', headers: { 'accept-encoding': 'gzip, br' }
-    });
-
-    assert.equal(nextCalled, false);
-    assert.equal(res.sent, true);
-    assert.equal(res.body.toString(), 'BROTLI-BYTES'); // brotli preferred over gzip
-    assert.equal(res.headers['content-encoding'], 'br');
-    assert.equal(res.headers['content-type'], 'application/javascript; charset=utf-8');
-    assert.equal(res.headers['vary'], 'Accept-Encoding');
-  });
-});
-
-test('falls back to gzip when brotli is not accepted', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'style.css'), 'ORIGINAL');
-    await fsp.writeFile(path.join(root, 'style.css.gz'), 'GZIP-BYTES');
-
-    const mw = createPrecompressedStatic([root]);
-    const { res } = run(mw, { method: 'GET', path: '/style.css', headers: { 'accept-encoding': 'gzip' } });
-    assert.equal(res.headers['content-encoding'], 'gzip');
-    assert.equal(res.headers['content-type'], 'text/css; charset=utf-8');
-    assert.equal(res.body.toString(), 'GZIP-BYTES');
-  });
-});
-
-test('passes through when the client accepts no encoding', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'app.js'), 'ORIGINAL');
-    await fsp.writeFile(path.join(root, 'app.js.br'), 'BROTLI-BYTES');
-    const mw = createPrecompressedStatic([root]);
-    const { res, nextCalled } = run(mw, { method: 'GET', path: '/app.js', headers: {} });
-    assert.equal(nextCalled, true);
-    assert.equal(res.sent, false);
-  });
-});
-
-test('passes through when no precompressed variant exists', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'app.js'), 'ORIGINAL'); // no .br/.gz
-    const mw = createPrecompressedStatic([root]);
-    const { res, nextCalled } = run(mw, { method: 'GET', path: '/app.js', headers: { 'accept-encoding': 'br' } });
-    assert.equal(nextCalled, true);
-    assert.equal(res.sent, false);
-  });
-});
-
-test('passes through for non-text extensions', async () => {
-  await withRoot(async (root) => {
-    await fsp.writeFile(path.join(root, 'img.png.br'), 'X');
-    const mw = createPrecompressedStatic([root]);
-    const { nextCalled } = run(mw, { method: 'GET', path: '/img.png', headers: { 'accept-encoding': 'br' } });
-    assert.equal(nextCalled, true);
-  });
-});
-
-test('honors root priority (public over dist root)', async () => {
-  await withRoot(async (root) => {
-    const pub = path.join(root, 'public');
-    await fsp.mkdir(pub, { recursive: true });
-    await fsp.writeFile(path.join(pub, 'theme.css.br'), 'PUBLIC');
-    await fsp.writeFile(path.join(root, 'theme.css.br'), 'ROOT');
-    const mw = createPrecompressedStatic([pub, root]);
-    const { res } = run(mw, { method: 'GET', path: '/theme.css', headers: { 'accept-encoding': 'br' } });
-    assert.equal(res.body.toString(), 'PUBLIC');
-  });
-});
-
-test('blocks path traversal', async () => {
-  await withRoot(async (root) => {
-    const mw = createPrecompressedStatic([path.join(root, 'public')]);
-    const { nextCalled, res } = run(mw, {
-      method: 'GET', path: '/../secret.js', headers: { 'accept-encoding': 'br' }
-    });
-    assert.equal(nextCalled, true);
-    assert.equal(res.sent, false);
-  });
-});