@omega.js/desktop 0.1.0

package/dist/test/suites/main/context-menu.test.js

@@ -0,0 +1,365 @@
+// Main-process tests for lib/context-menu.js — file-based right-click menus.
+//
+// We can't actually trigger a real right-click event in tests, so we exercise
+// the surface that gets called when one fires: the definition fn, the items
+// builder, and the resolver. `buildItems(params)` is the test entry point.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'context-menu (main)',
+  cleanup: (ctx) => {
+    // Reset to the built-in default fn so subsequent test runs aren't affected.
+    ctx.manager.contextMenu._definitionFn = null;
+  },
+  tests: [
+    {
+      name: 'initialize ran (enabled by default)',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.contextMenu._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'definition presence reflects whether src/integrations/context-menu/index.js exists',
+      run: (ctx) => {
+        const path = require('path');
+        const fs   = require('fs');
+        // Resolve the file the SAME way the lib does — via app-root.js, not process.cwd().
+        // In the test harness, appRoot() === app.getAppPath() === the @omega.js/desktop harness dir, which
+        // differs from process.cwd() (the consumer project dir when run from a consumer).
+        // Comparing against process.cwd() made this assert a false mismatch in consumers:
+        // the consumer has src/integrations/context-menu/index.js, but the manager never
+        // looks there — it looks under appRoot(). Keying the expectation off appRoot() makes
+        // the invariant self-consistent in both the @omega.js/desktop self-test and any consumer run.
+        const appRoot = require('../../../utils/app-root.js')();
+        const consumerFile = path.join(appRoot, 'src', 'integrations', 'context-menu', 'index.js');
+        const hasConsumer = fs.existsSync(consumerFile);
+        ctx.expect(ctx.manager.contextMenu.hasCustomDefinition()).toBe(hasConsumer);
+      },
+    },
+    {
+      name: 'default fn: editable params produce cut/copy/paste',
+      run: (ctx) => {
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canCut: true, canCopy: true, canPaste: true },
+        });
+        const roles = items.filter((i) => i.role).map((i) => i.role);
+        ctx.expect(roles).toContain('cut');
+        ctx.expect(roles).toContain('copy');
+        ctx.expect(roles).toContain('paste');
+      },
+    },
+    {
+      name: 'default fn: text selection produces copy only',
+      run: (ctx) => {
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: false,
+          selectionText: 'hello world',
+        });
+        const roles = items.filter((i) => i.role).map((i) => i.role);
+        ctx.expect(roles).toContain('copy');
+        ctx.expect(roles).not.toContain('cut');
+        ctx.expect(roles).not.toContain('paste');
+      },
+    },
+    {
+      name: 'default fn: link adds Open / Copy Address items',
+      run: (ctx) => {
+        const items = ctx.manager.contextMenu.buildItems({
+          linkURL: 'https://example.com',
+        });
+        const labels = items.filter((i) => i.label).map((i) => i.label);
+        ctx.expect(labels).toContain('Open Link in Browser');
+        ctx.expect(labels).toContain('Copy Link Address');
+      },
+    },
+    {
+      name: 'default fn: empty params → only the always-on items (reload)',
+      run: (ctx) => {
+        // Force isDevelopment false so dev-only items don't appear.
+        const orig = ctx.manager.isDevelopment;
+        ctx.manager.isDevelopment = () => false;
+        try {
+          const items = ctx.manager.contextMenu.buildItems({});
+          // With no editFlags, no selection, no link → only `reload` is always-on.
+          const ids = items.filter((i) => i.id).map((i) => i.id);
+          ctx.expect(ids).toEqual(['reload']);
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+      },
+    },
+    {
+      name: 'define() replaces the fn',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu, params }) => {
+          menu.item({ label: `Selected: ${params.selectionText}` });
+        });
+        ctx.expect(ctx.manager.contextMenu.hasCustomDefinition()).toBe(true);
+
+        const items = ctx.manager.contextMenu.buildItems({ selectionText: 'foo' });
+        ctx.expect(items.length).toBe(1);
+        ctx.expect(items[0].label).toBe('Selected: foo');
+      },
+    },
+    {
+      name: 'define() throws on non-function input',
+      run: (ctx) => {
+        ctx.expect(() => ctx.manager.contextMenu.define(null)).toThrow(/must be a function/);
+      },
+    },
+    {
+      name: 'menu.separator() pushes a separator descriptor',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.item({ label: 'A' });
+          menu.separator();
+          menu.item({ label: 'B' });
+        });
+        const items = ctx.manager.contextMenu.buildItems({});
+        ctx.expect(items.length).toBe(3);
+        ctx.expect(items[1].type).toBe('separator');
+      },
+    },
+    {
+      name: 'menu.submenu() builds a nested submenu',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.submenu('More', [{ label: 'X' }, { label: 'Y' }]);
+        });
+        const items = ctx.manager.contextMenu.buildItems({});
+        ctx.expect(items[0].label).toBe('More');
+        ctx.expect(items[0].submenu.length).toBe(2);
+      },
+    },
+    {
+      name: 'definition fn receives manager, params, webContents',
+      run: (ctx) => {
+        let received;
+        ctx.manager.contextMenu.define((arg) => {
+          received = arg;
+          arg.menu.item({ label: 'probe' });
+        });
+        ctx.manager.contextMenu.buildItems({ x: 100, y: 200 }, { id: 'fake-wc' });
+        ctx.expect(received.manager).toBe(ctx.manager);
+        ctx.expect(received.params).toEqual({ x: 100, y: 200 });
+        ctx.expect(received.webContents).toEqual({ id: 'fake-wc' });
+        ctx.expect(typeof received.menu.item).toBe('function');
+        ctx.expect(typeof received.menu.separator).toBe('function');
+        ctx.expect(typeof received.menu.submenu).toBe('function');
+      },
+    },
+    {
+      name: '_resolveItem evaluates dynamic labels',
+      run: (ctx) => {
+        let n = 0;
+        const resolved = ctx.manager.contextMenu._resolveItem({
+          label: () => `Items: ${n}`,
+        });
+        ctx.expect(resolved.label).toBe('Items: 0');
+        n = 4;
+        const resolved2 = ctx.manager.contextMenu._resolveItem({ label: () => `Items: ${n}` });
+        ctx.expect(resolved2.label).toBe('Items: 4');
+      },
+    },
+    {
+      name: '_resolveItem wraps click handlers to swallow errors',
+      run: (ctx) => {
+        let called = false;
+        const resolved = ctx.manager.contextMenu._resolveItem({
+          label: 'X',
+          click: () => { called = true; throw new Error('nope'); },
+        });
+        resolved.click(null, null, null);
+        ctx.expect(called).toBe(true);
+      },
+    },
+    {
+      name: 'attach is idempotent per webContents',
+      run: (ctx) => {
+        // Mock webContents — minimal surface used by attach().
+        const calls = [];
+        const mockWC = {
+          on: (evt, fn) => { calls.push({ evt, fn }); },
+        };
+        ctx.manager.contextMenu.attach(mockWC);
+        ctx.manager.contextMenu.attach(mockWC); // second call should be a no-op
+        ctx.expect(calls.length).toBe(1);
+        ctx.expect(calls[0].evt).toBe('context-menu');
+      },
+    },
+    {
+      name: 'menu.useDefaults() ships id-tagged items (cut, copy, paste, ...)',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => { menu.useDefaults(); });
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canCut: true, canCopy: true, canPaste: true },
+        });
+        const ids = items.filter((i) => i.id).map((i) => i.id);
+        ctx.expect(ids).toContain('cut');
+        ctx.expect(ids).toContain('copy');
+        ctx.expect(ids).toContain('paste');
+      },
+    },
+    {
+      name: 'menu.remove() drops an item by id within the event',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.useDefaults();
+          menu.remove('paste');
+        });
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canCut: true, canCopy: true, canPaste: true },
+        });
+        const ids = items.filter((i) => i.id).map((i) => i.id);
+        ctx.expect(ids).toContain('cut');
+        ctx.expect(ids).toContain('copy');
+        ctx.expect(ids).not.toContain('paste');
+      },
+    },
+    {
+      name: 'menu.insertAfter splices a new item by id',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.useDefaults();
+          menu.insertAfter('copy', { id: 'search', label: 'Search...' });
+        });
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: false,
+          selectionText: 'foo',
+        });
+        const ids = items.filter((i) => i.id).map((i) => i.id);
+        const copyIdx   = ids.indexOf('copy');
+        const searchIdx = ids.indexOf('search');
+        ctx.expect(copyIdx >= 0).toBe(true);
+        ctx.expect(searchIdx).toBe(copyIdx + 1);
+      },
+    },
+    {
+      name: 'menu.update() patches a default item before popup',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.useDefaults();
+          menu.update('copy', { label: 'CUSTOM COPY' });
+        });
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: false,
+          selectionText: 'foo',
+        });
+        const copy = items.find((i) => i.id === 'copy');
+        ctx.expect(copy).toBeTruthy();
+        ctx.expect(copy.label).toBe('CUSTOM COPY');
+      },
+    },
+    {
+      name: 'defaults: undo/redo appear when canUndo/canRedo flags set',
+      run: (ctx) => {
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canUndo: true, canRedo: true, canCut: true, canCopy: true, canPaste: true },
+        });
+        const ids = items.filter((i) => i.id).map((i) => i.id);
+        ctx.expect(ids).toContain('undo');
+        ctx.expect(ids).toContain('redo');
+      },
+    },
+    {
+      name: 'defaults: paste-and-match-style appears in editable contexts',
+      run: (ctx) => {
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canCut: true, canCopy: true, canPaste: true },
+        });
+        const ids = items.filter((i) => i.id).map((i) => i.id);
+        ctx.expect(ids).toContain('paste-and-match-style');
+      },
+    },
+    {
+      name: 'defaults: reload always present',
+      run: (ctx) => {
+        const orig = ctx.manager.isDevelopment;
+        ctx.manager.isDevelopment = () => false;
+        try {
+          const items = ctx.manager.contextMenu.buildItems({ selectionText: 'hi' });
+          const ids = items.filter((i) => i.id).map((i) => i.id);
+          ctx.expect(ids).toContain('reload');
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+      },
+    },
+    {
+      name: 'menu.find / menu.has work within event builder',
+      run: (ctx) => {
+        let foundCopy, hasCut, hasNope;
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.useDefaults();
+          foundCopy = menu.find('copy');
+          hasCut    = menu.has('cut');
+          hasNope   = menu.has('does-not-exist');
+        });
+        ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canCut: true, canCopy: true, canPaste: true },
+        });
+        ctx.expect(foundCopy).toBeTruthy();
+        ctx.expect(hasCut).toBe(true);
+        ctx.expect(hasNope).toBe(false);
+      },
+    },
+    {
+      name: 'menu.insertBefore splices a new item by id',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.useDefaults();
+          menu.insertBefore('copy', { id: 'pre-copy', label: 'BEFORE COPY' });
+        });
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: false,
+          selectionText: 'foo',
+        });
+        const ids = items.filter((i) => i.id).map((i) => i.id);
+        const copyIdx    = ids.indexOf('copy');
+        const preCopyIdx = ids.indexOf('pre-copy');
+        ctx.expect(preCopyIdx).toBe(copyIdx - 1);
+      },
+    },
+    {
+      name: 'menu.hide / menu.enable / menu.show within event',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          menu.useDefaults();
+          menu.hide('copy');
+          menu.enable('paste', false);
+        });
+        const items = ctx.manager.contextMenu.buildItems({
+          isEditable: true,
+          editFlags: { canCut: true, canCopy: true, canPaste: true },
+        });
+        const copy  = items.find((i) => i.id === 'copy');
+        const paste = items.find((i) => i.id === 'paste');
+        ctx.expect(copy.visible).toBe(false);
+        ctx.expect(paste.enabled).toBe(false);
+      },
+    },
+    {
+      name: 'menu.appendTo pushes into a submenu created via menu.submenu(...)',
+      run: (ctx) => {
+        ctx.manager.contextMenu.define(({ menu }) => {
+          // Build a parent submenu with an id.
+          menu.item({ id: 'more', label: 'More', submenu: [] });
+          menu.appendTo('more', { id: 'extra', label: 'Extra' });
+        });
+        const items = ctx.manager.contextMenu.buildItems({});
+        const more = items.find((i) => i.id === 'more');
+        ctx.expect(more).toBeTruthy();
+        ctx.expect(more.submenu[0].id).toBe('extra');
+      },
+    },
+  ],
+});

package/dist/test/suites/main/context.test.js

@@ -0,0 +1,155 @@
+// Main-layer tests for lib/context.js — session id, deviceId resolution,
+// client info, geolocation cache restore + persistence.
+
+const path = require('path');
+const fs   = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const MOD_PATH = path.join(__dirname, '..', '..', '..', 'lib', 'context.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'context (main)',
+  tests: [
+    {
+      name: 'context module wired on manager + initialized during boot',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.context).toBeDefined();
+        ctx.expect(ctx.manager.context._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'session has id (UUID), startTime (ISO), deviceId (string)',
+      run: (ctx) => {
+        const s = ctx.manager.context.session;
+        ctx.expect(typeof s.id).toBe('string');
+        ctx.expect(s.id.length).toBe(36);
+        ctx.expect(typeof s.startTime).toBe('string');
+        ctx.expect(s.startTime).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        ctx.expect(typeof s.deviceId).toBe('string');
+        ctx.expect(s.deviceId.length > 0).toBe(true);
+      },
+    },
+    {
+      name: 'deviceId is stable — re-init preserves the same id',
+      run: async (ctx) => {
+        const before = ctx.manager.context.session.deviceId;
+        ctx.manager.context.shutdown();
+        await ctx.manager.context.initialize(ctx.manager);
+        const after = ctx.manager.context.session.deviceId;
+        ctx.expect(after).toBe(before);
+      },
+    },
+    {
+      // The WIRING, not just the outcome: desktop's own walk is gone and the
+      // shared derivation is what runs (#396). The behavior below is identical
+      // either way, so this is the assertion that tells the two apart.
+      name: 'deviceId resolution calls the shared core.deriveDeviceId, not a local walk',
+      run: (ctx) => {
+        const source = fs.readFileSync(MOD_PATH, 'utf8');
+
+        // Vendored into dist at prepare time, live via the package in a linked
+        // monorepo — either specifier is the same module.
+        ctx.expect(/require\('(\.\.\/vendor\/analytics\/core\.js|@omega\.js\/analytics\/core)'\)/.test(source)).toBe(true);
+        ctx.expect(source.includes('core.deriveDeviceId({')).toBe(true);
+        ctx.expect(source.includes('seed: () => context._readFirstMac()')).toBe(true);
+        ctx.expect(source.includes('const id = mac ||')).toBe(false);
+      },
+    },
+    {
+      // The derivation is @omega.js/analytics' one walk (#396); what desktop
+      // owns is the pair injected into it — electron-store, and the MAC seed
+      // that hands a wiped install back the id it had before.
+      name: 'deviceId derives from the injected MAC seed and persists to storage',
+      run: async (ctx) => {
+        const storage = ctx.manager.storage;
+        const saved = storage.get('context.deviceId');
+
+        try {
+          // A wiped install: nothing stored, so the seed decides
+          storage.delete('context.deviceId');
+          const derived = await ctx.manager.context._resolveDeviceId();
+          const mac = ctx.manager.context._readFirstMac();
+
+          if (mac) {
+            ctx.expect(derived).toBe(mac);
+          } else {
+            ctx.expect(derived).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+          }
+
+          // Persisted on that first resolve, and read back on every one after
+          ctx.expect(storage.get('context.deviceId')).toBe(derived);
+
+          storage.set('context.deviceId', 'stored-wins-over-the-seed');
+          ctx.expect(await ctx.manager.context._resolveDeviceId()).toBe('stored-wins-over-the-seed');
+        } finally {
+          if (saved) storage.set('context.deviceId', saved);
+          else storage.delete('context.deviceId');
+        }
+      },
+    },
+    {
+      name: 'client.platform is set (matches os.platform())',
+      run: (ctx) => {
+        const expected = require('os').platform();
+        ctx.expect(ctx.manager.context.client.platform).toBe(expected);
+      },
+    },
+    {
+      name: 'client.arch is set',
+      run: (ctx) => {
+        ctx.expect(typeof ctx.manager.context.client.arch).toBe('string');
+        ctx.expect(ctx.manager.context.client.arch.length > 0).toBe(true);
+      },
+    },
+    {
+      name: 'client.mobile is false on desktop',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.context.client.mobile).toBe(false);
+      },
+    },
+    {
+      name: 'app.environment matches manager.getEnvironment()',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.context.app.environment).toBe(ctx.manager.getEnvironment());
+      },
+    },
+    {
+      name: 'app.version matches manager.getVersion()',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.context.app.version).toBe(ctx.manager.getVersion());
+      },
+    },
+    {
+      name: 'toJSON returns plain JSON snapshot (structured-cloneable)',
+      run: (ctx) => {
+        const snap = ctx.manager.context.toJSON();
+        ctx.expect(snap.geolocation).toBeDefined();
+        ctx.expect(snap.client).toBeDefined();
+        ctx.expect(snap.session).toBeDefined();
+        ctx.expect(snap.app).toBeDefined();
+        // Must JSON-roundtrip without errors.
+        const roundtripped = JSON.parse(JSON.stringify(snap));
+        ctx.expect(roundtripped.session.id).toBe(snap.session.id);
+      },
+    },
+    {
+      name: '_readFirstMac returns null or a MAC-shaped string',
+      run: (ctx) => {
+        const mac = ctx.manager.context._readFirstMac();
+        if (mac !== null) {
+          ctx.expect(mac).toMatch(/^[0-9a-f]{2}(:[0-9a-f]{2}){5}$/i);
+        }
+      },
+    },
+    {
+      name: 'IPC handler desktop:context:get returns the snapshot',
+      run: async (ctx) => {
+        const snap = await ctx.manager.ipc.invoke('desktop:context:get');
+        ctx.expect(snap.session.id).toBe(ctx.manager.context.session.id);
+        ctx.expect(snap.client.platform).toBe(ctx.manager.context.client.platform);
+      },
+    },
+  ],
+});