@omega.js/desktop 0.1.0

package/dist/test/suites/build/strip-dev-blocks.test.js

@@ -0,0 +1,116 @@
+// @dev-only strip, desktop bundle lane (#18): production desktop bundles must not
+// carry the dev-only blocks their inputs hold — @omega.js/client's src and the
+// vendored theme assets both use the markers, and every one of them reaches a
+// renderer bundle. The mechanism is @omega.js/devkit's bundle wrapper, which
+// registers the strip for PRODUCTION builds only (#737), so these tests build a
+// real fixture entry through that wrapper from the desktop framework root and
+// read the emitted bundle back.
+//
+// The marker + cut themselves are @omega.js/devkit's (one home); pinned there.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const FRAMEWORK_ROOT = path.join(__dirname, '..', '..', '..', '..');
+const { bundle } = require('../../../vendor/devkit/bundle.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const FIXTURE = [
+  '/* @dev-only:start */',
+  'console.log("DEV_ONLY_SENTINEL");',
+  '/* @dev-only:end */',
+  'module.exports = { alwaysShips: "PROD_SENTINEL" };',
+  '',
+].join('\n');
+
+// Build the fixture the way the desktop lane builds its main bundle for `isProd`
+// — `dev` is the ONE switch, so the strip is the only variable. Minify stays off
+// the assertion's way by reading sentinels, which minification preserves.
+async function compile(isProd) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'omega-desktop-strip-'));
+  fs.writeFileSync(path.join(dir, 'entry.js'), FIXTURE);
+  const outfile = path.join(dir, 'dist', 'entry.bundle.js');
+
+  try {
+    await bundle({
+      frameworkRoot: FRAMEWORK_ROOT,
+      entries: [path.join(dir, 'entry.js')],
+      outfile,
+      platform: 'node',
+      format: 'cjs',
+      dev: !isProd,
+    });
+    return fs.readFileSync(outfile, 'utf8');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'strip-dev-blocks — the desktop bundle lane cuts @dev-only blocks from production bundles',
+  timeout: 60000,
+  tests: [
+    {
+      name: 'production bundle drops the dev-only block and keeps the real code',
+      run: async (ctx) => {
+        const built = await compile(true);
+        ctx.expect(built).toContain('PROD_SENTINEL');
+        ctx.expect(built.includes('DEV_ONLY_SENTINEL')).toBe(false);
+      },
+    },
+
+    {
+      name: 'development bundle keeps the dev-only block',
+      run: async (ctx) => {
+        const built = await compile(false);
+        ctx.expect(built).toContain('PROD_SENTINEL');
+        ctx.expect(built).toContain('DEV_ONLY_SENTINEL');
+      },
+    },
+
+    {
+      // The strip existing is not the bug #18 reports — the bug was three bundles
+      // WITHOUT it. Pin the wiring itself: the run derives the production rule
+      // once and ALL THREE bundles take it, which is what registers the strip
+      // inside the wrapper.
+      name: 'main, preload, and renderer bundles all take the production rule',
+      run: (ctx) => {
+        const task = fs.readFileSync(path.join(FRAMEWORK_ROOT, 'src', 'gulp', 'tasks', 'bundle.js'), 'utf8');
+        ctx.expect(task.includes('dev: !isProd')).toBe(true);
+        ctx.expect(task.split('dev: shared.dev').length - 1).toBe(3);
+      },
+    },
+
+    {
+      name: 'the strip comes from the one home (@omega.js/devkit), production only',
+      run: async (ctx) => {
+        const seen = { prod: [], dev: [] };
+        const spy = (into) => ({ name: 'spy', setup: (build) => { into.push(...build.initialOptions.plugins.map((p) => p.name)); } });
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'omega-desktop-strip-plugins-'));
+        fs.writeFileSync(path.join(dir, 'entry.js'), FIXTURE);
+
+        try {
+          for (const [lane, dev] of [['prod', false], ['dev', true]]) {
+            await bundle({
+              frameworkRoot: FRAMEWORK_ROOT,
+              entries: [path.join(dir, 'entry.js')],
+              outfile: path.join(dir, lane, 'entry.bundle.js'),
+              platform: 'node',
+              format: 'cjs',
+              dev,
+              plugins: [spy(seen[lane])],
+            });
+          }
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+
+        ctx.expect(seen.prod.includes('omega-strip-dev-blocks')).toBe(true);
+        ctx.expect(seen.dev.includes('omega-strip-dev-blocks')).toBe(false);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/templating.test.js

@@ -0,0 +1,95 @@
+// Build-layer tests for lib/templating.js — render, buildPageVars, renderPage.
+
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'templating — render + buildPageVars',
+  tests: [
+    {
+      name: 'templating exports the expected surface',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        ctx.expect(typeof t.initialize).toBe('function');
+        ctx.expect(typeof t.render).toBe('function');
+        ctx.expect(typeof t.buildPageVars).toBe('function');
+        ctx.expect(typeof t.renderPage).toBe('function');
+      },
+    },
+    {
+      name: 'render replaces {{ var }} tokens with vars',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const out = t.render('Hello {{ name }}!', { name: 'Ian' });
+        ctx.expect(out).toBe('Hello Ian!');
+      },
+    },
+    {
+      name: 'render supports dot-notation paths',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const out = t.render('{{ brand.name }} v{{ app.version }}', { brand: { name: 'MyApp' }, app: { version: '1.2.3' } });
+        ctx.expect(out).toBe('MyApp v1.2.3');
+      },
+    },
+    {
+      name: 'render leaves unknown tokens intact (does not throw)',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const out = t.render('Hello {{ missing }}!', {});
+        // node-powertools returns the original token when not found.
+        ctx.expect(typeof out).toBe('string');
+      },
+    },
+    {
+      name: 'render supports custom brackets',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const out = t.render('Hello [name]!', { name: 'Ian' }, { brackets: ['[', ']'] });
+        ctx.expect(out).toBe('Hello Ian!');
+      },
+    },
+    {
+      name: 'buildPageVars produces brand/app/page/theme/cacheBust from a manager-like object',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const fakeManager = { config: { brand: { name: 'MyApp', id: 'myapp' }, app: { productName: 'MyApp' } } };
+        const vars = t.buildPageVars('settings', { cacheBust: '12345' }, fakeManager);
+        ctx.expect(vars.page.name).toBe('settings');
+        ctx.expect(vars.page.title).toBe('MyApp');
+        ctx.expect(vars.brand.id).toBe('myapp');
+        ctx.expect(vars.theme.appearance).toBe('system');
+        ctx.expect(vars.cacheBust).toBe('12345');
+        ctx.expect(vars.content).toBe('');
+      },
+    },
+    {
+      name: 'buildPageVars accepts a content slot',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const vars = t.buildPageVars('main', { content: '<h1>Hi</h1>' }, { config: {} });
+        ctx.expect(vars.content).toBe('<h1>Hi</h1>');
+      },
+    },
+    {
+      name: 'renderPage end-to-end: page template + body content',
+      run: (ctx) => {
+        const t = require(path.join(__dirname, '..', '..', '..', 'lib', 'templating.js'));
+        const tpl = '<title>{{ page.title }}</title><body>{{ content }}</body>';
+        const vars = t.buildPageVars('main', {
+          content: 'Hello {{ brand.name }}',
+          cacheBust: '1',
+        }, { config: { brand: { name: 'MyApp' }, app: { productName: 'MyApp' } } });
+        // Note: content has its own {{ brand.name }} — this test verifies that the OUTER render
+        // does not double-render the body. Templating call sites (gulp/html) handle the two-pass
+        // explicitly: render body first, then page.
+        // For this test, we just check the page-level render applied correctly.
+        const final = t.renderPage(tpl, vars);
+        ctx.expect(final).toContain('<title>MyApp</title>');
+        ctx.expect(final).toContain('<body>Hello {{ brand.name }}</body>');
+      },
+    },
+  ],
+});

package/dist/test/suites/build/test-discovery.test.js

@@ -0,0 +1,64 @@
+// Build-layer tests for test-suite discovery — specifically the
+// "underscore = not a suite" convention: `_`-prefixed files and everything
+// under `_`-prefixed directories (at ANY depth) must be excluded, so consumers
+// can keep helpers and fixture trees (e.g. test/_fixtures/packages/x/index.js)
+// next to their suites.
+
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'test discovery — underscore exclusion convention',
+  tests: [
+    {
+      name: 'runner exports DISCOVERY_IGNORE',
+      run: (ctx) => {
+        const runner = require(path.join(__dirname, '..', '..', 'runner.js'));
+        ctx.expect(Array.isArray(runner.DISCOVERY_IGNORE)).toBe(true);
+        ctx.expect(runner.DISCOVERY_IGNORE.length >= 2).toBe(true);
+      },
+    },
+    {
+      name: 'glob with DISCOVERY_IGNORE skips _ files and _ dirs at any depth',
+      run: (ctx) => {
+        const fs = require('fs');
+        const os = require('os');
+        const glob = require('glob').globSync;
+        const { DISCOVERY_IGNORE } = require(path.join(__dirname, '..', '..', 'runner.js'));
+
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-discovery-test-'));
+        const write = (rel) => {
+          const file = path.join(tmp, rel);
+          fs.mkdirSync(path.dirname(file), { recursive: true });
+          fs.writeFileSync(file, 'module.exports = {};\n');
+        };
+
+        // Should be DISCOVERED:
+        write('build/config.test.js');
+        write('main/runner.test.js');
+        write('boot/nested/deep.test.js');
+
+        // Should be EXCLUDED:
+        write('_init.js');                                  // top-level _ file
+        write('main/_helper.js');                           // nested _ file
+        write('_fixtures/runner-stack.js');                 // file in top-level _ dir
+        write('_fixtures/packages/runner/mod/index.js');    // deep inside a _ dir
+        write('boot/_private/util.js');                     // _ dir below a layer dir
+
+        const found = glob('**/*.js', { cwd: tmp, ignore: [...DISCOVERY_IGNORE] }).sort();
+
+        try {
+          ctx.expect(found).toEqual([
+            'boot/nested/deep.test.js',
+            'build/config.test.js',
+            'main/runner.test.js',
+          ]);
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/build/test-stealth.test.js

@@ -0,0 +1,83 @@
+// test-stealth predicate tests — the single source of truth for "keep test-run UI
+// invisible and non-intrusive". Consumed by window-manager (stealth surfacing),
+// main.js (macOS app-activation suppression), and the test harness.
+//
+// Build layer runs in plain Node, so the env-var contract (OMEGA_TEST_MODE /
+// OMEGA_TEST_SHOW) is exercised directly with save/restore around each case.
+
+const isTestStealth = require('../../../utils/test-stealth.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+// Run fn with OMEGA_TEST_MODE / OMEGA_TEST_SHOW set to the given values (undefined = unset),
+// restoring the real environment afterwards so other build suites are unaffected.
+function withEnv(vars, fn) {
+  const saved = {};
+  for (const [key, value] of Object.entries(vars)) {
+    saved[key] = process.env[key];
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'test-stealth predicate',
+  tests: [
+    {
+      name: 'true in testing mode without OMEGA_TEST_SHOW',
+      run: (ctx) => {
+        withEnv({ OMEGA_TEST_MODE: 'true', OMEGA_TEST_SHOW: undefined }, () => {
+          ctx.expect(isTestStealth()).toBe(true);
+        });
+      },
+    },
+    {
+      name: 'OMEGA_TEST_SHOW=1 opts out even in testing mode',
+      run: (ctx) => {
+        withEnv({ OMEGA_TEST_MODE: 'true', OMEGA_TEST_SHOW: '1' }, () => {
+          ctx.expect(isTestStealth()).toBe(false);
+        });
+      },
+    },
+    {
+      name: 'false outside testing mode regardless of OMEGA_TEST_SHOW',
+      run: (ctx) => {
+        withEnv({ OMEGA_TEST_MODE: undefined, OMEGA_TEST_SHOW: undefined, OMEGA_BUILD_MODE: undefined, NODE_ENV: 'development' }, () => {
+          ctx.expect(isTestStealth()).toBe(false);
+        });
+      },
+    },
+    {
+      name: 'a provided manager is authoritative over the env fallback',
+      run: (ctx) => {
+        // Build-time Manager carries the same mode-helpers mixin as the runtime
+        // Managers — config.em.environment overrides the env detection.
+        const Manager = require('../../../build.js');
+        withEnv({ OMEGA_TEST_MODE: undefined, OMEGA_TEST_SHOW: undefined }, () => {
+          const testing = new Manager();
+          testing.config = { em: { environment: 'testing' } };
+          ctx.expect(isTestStealth(testing)).toBe(true);
+
+          const production = new Manager();
+          production.config = { em: { environment: 'production' } };
+          ctx.expect(isTestStealth(production)).toBe(false);
+        });
+      },
+    },
+  ],
+});

package/dist/test/suites/build/test-target-no-match.test.js

@@ -0,0 +1,119 @@
+// Build-layer tests for the no-match rule ([#814](https://github.com/Omega-JS-Stack/omega/issues/814)).
+//
+// `npx omega test renderer/main-view` with no such file printed "No test files
+// found.", "0 passing", and exited 0: a typo'd path target, or a suite renamed
+// out from under one, ran silently green.
+//
+// The rule lives in the runner's selection step, so these drive the REAL
+// desktop runner from a consumer directory with no tests of its own.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const RUNNER = path.join(__dirname, '..', '..', 'runner.js');
+
+// A consumer directory with a package.json and no test/ dir at all.
+function makeEmptyConsumer() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-no-match-'));
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'no-match-fixture' }));
+  return dir;
+}
+
+// Run the real runner from `dir`, with its report silenced: the probe reports
+// like any run, and its report is not THIS run's.
+async function runFrom(dir, options) {
+  const { run } = require(RUNNER);
+  const previousCwd = process.cwd();
+  const realLog = console.log;
+
+  process.chdir(dir);
+  console.log = () => {};
+
+  try {
+    return await run(options);
+  } finally {
+    console.log = realLog;
+    process.chdir(previousCwd);
+  }
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'test targets that match nothing',
+  tests: [
+    {
+      name: 'a named target that selects no file comes back flagged, not green',
+      run: async (ctx) => {
+        const dir = makeEmptyConsumer();
+
+        try {
+          // Every spelling of a path target: bare, framework-scoped, project-scoped.
+          for (const target of ['renderer/does-not-exist', 'desktop:build/does-not-exist', 'project:does-not-exist']) {
+            const result = await runFrom(dir, { target });
+            ctx.expect(result.noMatch).toBe(target);
+            ctx.expect(result.passed).toBe(0);
+            ctx.expect(result.failed).toBe(0);
+          }
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'a run that named no file stays green with nothing to run',
+      run: async (ctx) => {
+        const dir = makeEmptyConsumer();
+
+        try {
+          // A bare run, and a bare source prefix, ask for a source rather than
+          // a file: an empty project is still an exit-0 run.
+          for (const options of [{}, { target: 'project:' }]) {
+            const result = await runFrom(dir, options);
+            ctx.expect(result.noMatch).toBe(null);
+            ctx.expect(result.passed).toBe(0);
+          }
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'a target naming a real framework suite still selects it',
+      run: async (ctx) => {
+        const dir = makeEmptyConsumer();
+
+        try {
+          const result = await runFrom(dir, { target: 'desktop:build/test-discovery' });
+          ctx.expect(result.noMatch).toBe(null);
+          ctx.expect(result.passed > 0).toBe(true);
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'in a brand-root fan-out the same miss answers with its own exit code',
+      run: (ctx) => {
+        // The brand root forwards ONE target to every target, so a target that
+        // does not carry it is a no-op there, not a failure. The code is the
+        // whole difference, and this package ships its own copy of the rule.
+        const { noMatchExitCode, NO_MATCH_EXIT_CODE, FANOUT_ENV } = require('../../../vendor/devkit/test/scope.js');
+
+        ctx.expect(FANOUT_ENV).toBe('OMEGA_TEST_FANOUT');
+        ctx.expect(NO_MATCH_EXIT_CODE).toBe(3);
+        ctx.expect(noMatchExitCode({})).toBe(1);
+        ctx.expect(noMatchExitCode({ OMEGA_TEST_FANOUT: '1' })).toBe(3);
+      },
+    },
+    {
+      name: 'the line the CLI prints names the target',
+      run: (ctx) => {
+        const { noMatchMessage } = require('../../../vendor/devkit/test/scope.js');
+        ctx.expect(noMatchMessage('renderer/does-not-exist')).toBe('No test file matches "renderer/does-not-exist".');
+      },
+    },
+  ],
+});