Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

7.1 KB
Raw Blame
// @vitest-environment node
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { createRequire } from 'node:module';
import { join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { createServer } from 'vite';
import react from '@vitejs/plugin-react';
import { BROWSER_FIXTURE_STARTUP_MS, startBrowserFixture } from '../../test/browserFixture.js';
import { resolveTestChrome } from '../../../../scripts/lib/testChrome.js';

const require = createRequire(import.meta.url);
// Prefer the client dev dependency; linked worktrees can also use the same
// pinned driver from the server without installing into shared node_modules.
const { chromium } = require(require.resolve('playwright-core', { paths: [
  fileURLToPath(new URL('../../..', import.meta.url)),
  fileURLToPath(new URL('../../../../server', import.meta.url)),
] }));
const chrome = resolveTestChrome();

// No live API or external service is reachable from this fixture.
const isolateFixture = origin => route => {
  const url = new URL(route.request().url());
  return url.origin === new URL(origin).origin && !url.pathname.startsWith('/api/')
    ? route.continue() : route.fulfill({ contentType: 'application/json', body: '{}' });
};

// This fixture exercises the real toolbar and Tailwind CSS with synthetic goals.
// Only WebGL is replaced: the canvas stub retains the production sizing props.
describe.skipIf(!chrome)('Goals Tree touch targets', () => {
  let fixture, browser, origin;
  beforeAll(async () => {
    // Each startup phase is bounded and cleaned up inside the hook (#10543).
    fixture = await startBrowserFixture({ name: 'goals-touch', createServer, chromium,
      launchOptions: { executablePath: chrome }, viteConfig: temp => ({
      configFile: false,
      cacheDir: join(temp, 'vite-cache'),
      // Pre-bundle only what this fixture renders, not the whole app's graph.
      optimizeDeps: { entries: ['src/components/goals/GoalsTreeView.jsx'], include: ['react', 'react-dom/client'] },
      root: fileURLToPath(new URL('../../..', import.meta.url)),
      plugins: [react(), {
        name: 'goals-touch-fixture',
        enforce: 'pre',
        resolveId(id) {
          if (id === '/goals-fixture.jsx') return '\0goals-fixture.jsx';
          if (id === '@react-three/fiber') return '\0canvas-stub';
          if (id.endsWith('/useProviderModels')) return '\0provider-stub';
        },
        load(id) {
          if (id === '\0canvas-stub') return `
            import React from 'react';
            export const Canvas = ({ style }) => React.createElement('div', { 'data-testid': 'canvas', style });
            export const useFrame = () => {};
            export const useThree = () => null;
            export const extend = () => {};
          `;
          if (id === '\0provider-stub') return `
            export default () => ({ providers: [], selectedProviderId: '', selectedModel: '',
              availableModels: [], setSelectedProviderId: () => {}, setSelectedModel: () => {}, loading: false });
          `;
          if (id !== '\0goals-fixture.jsx') return;
          return `
            import React from 'react';
            import { createRoot } from 'react-dom/client';
            import GoalsTreeView from '/src/components/goals/GoalsTreeView.jsx';
            import '/src/index.css';
            const data = { flat: [
              { id: 'example-1', title: 'Example apex', category: 'mastery', horizon: 'lifetime', goalType: 'apex' },
              { id: 'example-2', title: 'Example craft', category: 'creative', horizon: '3-year', parentId: 'example-1' },
              { id: 'example-3', title: 'Example practice', category: 'mastery', horizon: '5-year', parentId: 'example-1' },
            ] };
            createRoot(document.getElementById('root')).render(React.createElement(GoalsTreeView, { data, onRefresh: () => {} }));
          `;
        },
        configureServer(vite) {
          vite.middlewares.use('/goals-test', async (_req, res) => {
            res.setHeader('Content-Type', 'text/html');
            res.end(await vite.transformIndexHtml('/goals-test',
              '<style>html,body,#root{height:100%;margin:0}</style><div id="root"></div><script type="module" src="/goals-fixture.jsx"></script>'));
          });
        },
      }],
      server: { host: '127.0.0.1', port: 0 },
    }),
    // Compile the cold module graph inside the bounded warmup phase, not the
    // first test's navigation (#10638). The phase's own deadline bounds the
    // navigation.
    warmup: async (page, url) => {
      await page.route('**/*', isolateFixture(url));
      await page.goto(`${url}goals-test`);
      await page.getByRole('button', { name: 'Organize', exact: true }).waitFor({ timeout: 5000 });
    } });
    ({ browser, origin } = fixture);
  }, BROWSER_FIXTURE_STARTUP_MS);
  afterAll(() => fixture?.close());

  it.each([[360, 800], [768, 1024], [1440, 900]])('keeps targets usable at %sx%s', async (width, height) => {
    const page = await browser.newPage({ viewport: { width, height } });
    try {
      await page.route('**/*', isolateFixture(origin));
      await page.goto(origin + 'goals-test');
      const names = ['Creative', 'Family', 'Health', 'Financial', 'Legacy', 'Mastery', 'Labels', 'Add', 'Organize'];
      const boxes = [];
      for (const name of names) {
        const button = page.getByRole('button', { name, exact: true });
        await button.waitFor();
        const box = await button.boundingBox();
        expect(box.width).toBeGreaterThanOrEqual(44);
        expect(box.height).toBeGreaterThanOrEqual(44);
        expect(box.x).toBeGreaterThanOrEqual(0);
        expect(box.x + box.width).toBeLessThanOrEqual(width);
        boxes.push(box);
        expect(await button.evaluate(el => {
          const r = el.getBoundingClientRect();
          return [-20, 20].every(offset => el.contains(document.elementFromPoint(r.x + r.width / 2 + offset, r.y + r.height / 2)));
        })).toBe(true);
      }
      for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
        const a = boxes[i], b = boxes[j];
        expect(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y).toBe(true);
      }
      const canvas = await page.getByTestId('canvas').boundingBox();
      expect(canvas.y).toBeGreaterThanOrEqual(Math.max(...boxes.map(b => b.y + b.height)));
      expect(canvas.height).toBeGreaterThan(height / 2);
      await page.getByRole('button', { name: 'Creative', exact: true }).click();
      await page.waitForFunction(() => document.body.textContent.includes('2 nodes'));
      const labels = page.getByRole('button', { name: 'Labels', exact: true });
      await labels.click();
      expect(await labels.getAttribute('aria-pressed')).toBe('false');
      await page.getByRole('button', { name: 'Add', exact: true }).click();
      const form = await page.getByRole('textbox', { name: 'New goal title' }).boundingBox();
      expect(form.y).toBeGreaterThan(Math.max(...boxes.map(b => b.y + b.height)));
      expect(await page.getByRole('button', { name: 'Organize', exact: true }).isDisabled()).toBe(true);
    } finally { await page.close(); }
  }, 60000);
});