Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

13.8 KB
Raw Blame
import { expect, type Locator, type Page, test } from '@playwright/test';

async function tap(page: Page, target: Locator) {
  const box = await target.boundingBox();
  if (!box) throw new Error('The tap target is not rendered');
  await page.touchscreen.tap(box.x + box.width / 2, box.y + box.height / 2);
}

/** Corvu starts the opening slide a frame after mount, so wait for it to end. */
async function settled(sheet: Locator) {
  await expect(sheet).toBeInViewport({ ratio: 1 });
  await expect(sheet).not.toHaveAttribute('data-transitioning');
}

const pressed = (page: Page) => page.getByRole('status', { name: 'Pressed' });

/** A finger dragging the sheet down by its top edge, past the break point. */
async function dragDown(page: Page, sheet: Locator) {
  const box = await sheet.boundingBox();
  if (!box) throw new Error('The sheet is not rendered');
  const x = box.x + box.width / 2;
  const y = box.y + 12;
  const cdp = await page.context().newCDPSession(page);
  await cdp.send('Input.dispatchTouchEvent', {
    type: 'touchStart',
    touchPoints: [{ x, y }],
  });
  for (let step = 1; step <= 10; step += 1)
    await cdp.send('Input.dispatchTouchEvent', {
      type: 'touchMove',
      touchPoints: [{ x, y: y + (box.height * step) / 10 }],
    });
  await cdp.send('Input.dispatchTouchEvent', {
    type: 'touchEnd',
    touchPoints: [],
  });
}

test('a sheet its owner keeps open returns into view after a drag down', async ({
  page,
}) => {
  await page.goto('/?scenario=discard');
  const share = page.getByRole('dialog', { name: 'Share to Macro' });
  await settled(share);

  await dragDown(page, share);

  const confirm = page.getByRole('dialog', { name: 'Discard this share?' });
  await settled(confirm);
  await settled(share);
  await tap(page, confirm.getByRole('button', { name: 'Keep editing' }));
  await expect(confirm).toHaveCount(0);
  await tap(page, share.getByRole('button', { name: 'Send' }));
  await expect(pressed(page)).toHaveText('Send');

  await dragDown(page, share);
  await settled(confirm);
  await tap(page, confirm.getByRole('button', { name: 'Discard' }));
  await expect(share).toHaveCount(0);
});

test('a pointerdown dismissal does not dismiss the parent on pointerup', async ({
  page,
}) => {
  await page.goto('/?scenario=event');
  const details = page.getByRole('dialog', { name: 'Weekly product sync' });
  await settled(details);
  await tap(page, details.getByRole('button', { name: 'Share note' }));
  const share = page.getByRole('dialog', { name: 'Share note' });
  await settled(share);

  await tap(
    page,
    page.getByRole('button', { name: 'Page control', includeHidden: true })
  );

  await expect(share).toHaveCount(0);
  await expect(details).toBeVisible();
  await expect(pressed(page)).toHaveText('');
  await tap(page, details.getByRole('button', { name: 'Edit' }));
  await expect(pressed(page)).toHaveText('Edit');
  await tap(
    page,
    page.getByRole('button', { name: 'Page control', includeHidden: true })
  );
  await expect(details).toHaveCount(0);
  await expect(pressed(page)).toHaveText('Edit');
});

for (const control of ['Remove', 'Back to settings']) {
  test(`a tap on the dimmed Settings sheet over ${control} closes only Connect email`, async ({
    page,
  }) => {
    await page.goto('/?scenario=settings');
    const settings = page.getByRole('dialog', { name: 'Settings' });
    await settled(settings);
    await tap(page, page.getByRole('button', { name: 'Add account' }));
    const connectEmail = page.getByRole('dialog', { name: 'Connect email' });
    await settled(connectEmail);

    const covered = settings.getByRole('button', {
      name: control,
      exact: true,
    });
    await tap(page, covered);

    await expect(connectEmail).toHaveCount(0);
    await expect(settings).toBeVisible();
    await expect(
      settings.getByRole('heading', { name: 'Email' })
    ).toBeVisible();
    await expect(pressed(page)).toHaveText('');

    await tap(page, covered);
    await expect(pressed(page)).not.toHaveText('');
  });
}

for (const [opener, sheetName] of [
  ['Add guests', 'Add guests'],
  ['RSVP', 'RSVP to recurring event'],
  ['Delete', 'Delete event'],
]) {
  test(`a tap on the dimmed event details closes only ${sheetName}`, async ({
    page,
  }) => {
    await page.goto('/?scenario=event');
    const details = page.getByRole('dialog', { name: 'Weekly product sync' });
    await settled(details);
    await tap(page, details.getByRole('button', { name: opener }));
    const sheet = page.getByRole('dialog', { name: sheetName });
    await settled(sheet);

    const edit = details.getByRole('button', { name: 'Edit' });
    await tap(page, edit);

    await expect(sheet).toHaveCount(0);
    await expect(details).toBeVisible();
    await expect(pressed(page)).toHaveText('');

    await tap(page, edit);
    await expect(pressed(page)).toHaveText('Edit');
  });
}

for (const [opener, sheetName, control, result] of [
  ['Add guests', 'Add guests', 'Add Priya', 'Add guest'],
  ['RSVP', 'RSVP to recurring event', 'All events', 'All events'],
  ['Delete', 'Delete event', 'Delete', 'Confirm delete'],
]) {
  test(`a tap on ${control} in ${sheetName} over event details presses it`, async ({
    page,
  }) => {
    await page.goto('/?scenario=event');
    const details = page.getByRole('dialog', { name: 'Weekly product sync' });
    await settled(details);
    await tap(page, details.getByRole('button', { name: opener }));
    const sheet = page.getByRole('dialog', { name: sheetName });
    await settled(sheet);

    await tap(page, sheet.getByRole('button', { name: control, exact: true }));

    await expect(pressed(page)).toHaveText(result);
    await expect(details).toBeVisible();
  });
}

test('a tap on Gmail in Connect email over Settings presses it', async ({
  page,
}) => {
  await page.goto('/?scenario=settings');
  const settings = page.getByRole('dialog', { name: 'Settings' });
  await settled(settings);
  await tap(page, page.getByRole('button', { name: 'Add account' }));
  const connectEmail = page.getByRole('dialog', { name: 'Connect email' });
  await settled(connectEmail);

  await tap(page, connectEmail.getByRole('button', { name: 'Gmail' }));

  await expect(pressed(page)).toHaveText('Connect GMAIL');
  await expect(connectEmail).toHaveCount(0);
  await expect(settings).toBeVisible();
});

test('a tap on the backdrop of event details closes it without pressing the page', async ({
  page,
}) => {
  await page.goto('/?scenario=event');
  const details = page.getByRole('dialog', { name: 'Weekly product sync' });
  await settled(details);
  const pageControl = page.getByRole('button', {
    name: 'Page control',
    includeHidden: true,
  });

  await tap(page, pageControl);

  await expect(details).toHaveCount(0);
  await expect(pressed(page)).toHaveText('');

  await tap(page, pageControl);
  await expect(pressed(page)).toHaveText('Page control');
});

test('Keep editing after a drag on the composer keeps its edits, and Discard closes it', async ({
  page,
}) => {
  await page.goto('/?scenario=composer');
  const composer = page.getByRole('dialog', { name: 'New event' });
  await settled(composer);
  const title = composer.getByRole('textbox', { name: 'Title' });
  await title.fill('Design review');
  const prompt = page.getByRole('dialog', {
    name: 'You still have remaining changes',
  });

  await dragDown(page, composer);
  await settled(prompt);
  await settled(composer);
  await tap(page, prompt.getByRole('button', { name: 'Keep editing' }));

  await expect(prompt).toHaveCount(0);
  await settled(composer);
  await expect(title).toHaveValue('Design review');
  await tap(page, composer.getByRole('button', { name: 'Create event' }));
  await expect(pressed(page)).toHaveText('Create event');
  await expect(prompt).toHaveCount(0);

  await dragDown(page, composer);
  await settled(prompt);
  await tap(page, prompt.getByRole('button', { name: 'Discard' }));

  await expect(prompt).toHaveCount(0);
  await expect(composer).toHaveCount(0);
  await expect(page.locator('[data-corvu-drawer-overlay]')).toHaveCount(0);
});

test('a swipe does not hide a confirmation that is still pending', async ({
  page,
}) => {
  await page.goto('/?scenario=pending');
  const confirmation = page.getByRole('dialog', { name: 'Delete event' });
  await settled(confirmation);

  await dragDown(page, confirmation);

  await settled(confirmation);
  await expect(pressed(page)).toHaveText('');
});

test('a swipe over event details closes only the sheet on top', async ({
  page,
}) => {
  await page.goto('/?scenario=event');
  const details = page.getByRole('dialog', { name: 'Weekly product sync' });
  await settled(details);
  await tap(page, details.getByRole('button', { name: 'RSVP' }));
  const rsvp = page.getByRole('dialog', { name: 'RSVP to recurring event' });
  await settled(rsvp);

  await dragDown(page, rsvp);

  await expect(rsvp).toHaveCount(0);
  await settled(details);
});

test('a swiped-away sheet opens again on screen', async ({ page }) => {
  await page.goto('/?scenario=event');
  const details = page.getByRole('dialog', { name: 'Weekly product sync' });
  await settled(details);
  await tap(page, details.getByRole('button', { name: 'RSVP' }));
  const rsvp = page.getByRole('dialog', { name: 'RSVP to recurring event' });
  await settled(rsvp);
  await dragDown(page, rsvp);
  await expect(rsvp).toHaveCount(0);

  await tap(page, details.getByRole('button', { name: 'RSVP' }));
  await settled(rsvp);

  await dragDown(page, rsvp);
  await expect(rsvp).toHaveCount(0);
  await settled(details);
  await dragDown(page, details);
  await expect(details).toHaveCount(0);
});

test('a sheet opened by its trigger slides up, and swipes away', async ({
  page,
}) => {
  await page.goto('/?scenario=uncontrolled');
  await tap(page, page.getByRole('button', { name: 'Open filters' }));
  const filters = page.getByRole('dialog', { name: 'Filters' });

  await expect(filters).toHaveAttribute('data-opening');
  await settled(filters);
  await dragDown(page, filters);

  await expect(filters).toHaveCount(0);
});

test.describe('a persistent prompt', () => {
  const toastCard = (page: Page, text: string) =>
    page.locator('[data-macro-toast]', { hasText: text });
  const prompt = (page: Page) =>
    toastCard(page, 'Enable Browser Notifications');
  const notice = (page: Page) => toastCard(page, 'Link copied');

  async function middleOf(target: Locator) {
    await expect(target).toBeVisible();
    const box = await target.boundingBox();
    if (!box) throw new Error('The target is not rendered');
    return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
  }

  /** Whether a tap at this spot lands in `target`, not on what covers it. */
  const receivesTapsAt = (target: Locator, spot: { x: number; y: number }) =>
    target.evaluate(
      (element, { x, y }) => element.contains(document.elementFromPoint(x, y)),
      spot
    );

  async function openProperties(page: Page) {
    await tap(page, page.getByRole('button', { name: 'Properties' }));
    const properties = page.getByRole('dialog', { name: 'Properties' });
    await settled(properties);
    return properties;
  }

  test('waits under a sheet and the picker stacked on it', async ({ page }) => {
    await page.goto('/?scenario=prompt');
    const spot = await middleOf(prompt(page));
    await tap(page, prompt(page).getByRole('button', { name: 'Enable' }));
    await expect(pressed(page)).toHaveText('Enable');

    const properties = await openProperties(page);
    expect(await receivesTapsAt(properties, spot)).toBe(true);
    await tap(page, properties.getByRole('button', { name: 'Due date' }));
    await expect(pressed(page)).toHaveText('Enable, Due date');

    await tap(page, properties.getByRole('button', { name: 'Assignee' }));
    const picker = page.getByRole('dialog', { name: 'Assignee' });
    await settled(picker);
    const search = picker.getByRole('textbox', { name: 'Search people' });
    await expect(search).toBeVisible();
    expect(await receivesTapsAt(picker, spot)).toBe(true);
    await tap(page, search);
    await expect(search).toBeFocused();

    await tap(page, picker.getByRole('button', { name: 'Cancel' }));
    await expect(picker).toHaveCount(0);
    await dragDown(page, properties);
    await expect(properties).toHaveCount(0);

    expect(await receivesTapsAt(prompt(page), spot)).toBe(true);
    await tap(page, prompt(page).getByRole('button', { name: 'Enable' }));
    await expect(pressed(page)).toHaveText('Enable, Due date, Enable');
  });

  test('moves up to clear a notice, and back when it goes', async ({
    page,
  }) => {
    await page.goto('/?scenario=prompt');
    await expect(prompt(page)).toBeVisible();
    await prompt(page).evaluate((card) =>
      Promise.all(card.getAnimations().map((motion) => motion.finished))
    );
    const resting = await prompt(page).boundingBox();
    // 12px over the dock inset, plus the 20px gap the stack keeps above notices.
    expect(
      page.viewportSize()!.height - (resting!.y + resting!.height)
    ).toBeCloseTo(32, 1);

    await tap(page, page.getByRole('button', { name: 'Show notice' }));
    await expect(notice(page)).toBeVisible();
    await expect(async () => {
      const raised = await prompt(page).boundingBox();
      const shown = await notice(page).boundingBox();
      expect(shown!.y - (raised!.y + raised!.height)).toBeCloseTo(20, 1);
    }).toPass();

    await page.getByRole('button', { name: 'Dismiss notice' }).click();
    await expect(notice(page)).toHaveCount(0);
    await expect
      .poll(async () => (await prompt(page).boundingBox())?.y)
      .toBe(resting!.y);
  });

  test('leaves a notice on top of the sheet', async ({ page }) => {
    await page.goto('/?scenario=prompt');
    const properties = await openProperties(page);

    await tap(page, properties.getByRole('button', { name: 'Copy link' }));

    expect(
      await receivesTapsAt(notice(page), await middleOf(notice(page)))
    ).toBe(true);
  });
});