Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import type {
ActionConfiguration,
ScheduledAction,
} from '@service-scheduled-action/generated/schemas';
import {
cleanup,
fireEvent,
render,
screen,
waitFor,
within,
} from '@solidjs/testing-library';
import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';
import { createSignal, type JSX } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { buildAgentRoster } from '../agents-view/core/roster';
import { getDefaultTimezone } from './core/routine-draft';
import { newRoutineDraft, routineTemplates } from './core/routine-templates';
import { loadRoutineComposerDraft } from './draft-storage';
import { RoutineCreator } from './routine-creator';
import { startRoutineDraft } from './routine-draft-start';
import { RoutineNew } from './routine-new';
const findTemplateByKey = (key: string) => {
const template = routineTemplates.find((each) => each.key === key);
if (!template) throw new Error(`No template ${key}`);
return template;
};
const host = vi.hoisted(() => ({
create: vi.fn<(body: ActionConfiguration) => Promise<ScheduledAction>>(),
openWithSplit: vi.fn(),
created: vi.fn(),
flags: new Set<string>(),
cancelled: vi.fn(),
started: vi.fn(),
success: vi.fn(),
alert: vi.fn(),
editorMount: vi.fn(),
githubLinked: true as boolean | undefined,
connectGithub: vi.fn(),
}));
vi.mock('@app/lib/analytics/posthog', () => ({
useFeatureFlag: (flag: { key: string }) => () => ({
enabled: host.flags.has(flag.key),
}),
}));
vi.mock('@components/app/split-layout/layout', () => ({
useSplitLayout: () => ({ openWithSplit: host.openWithSplit }),
}));
vi.mock('@components/app/split-layout/layoutUtils', () => ({
useSplitPanel: () => undefined,
useSplitPanelOrThrow: () => ({
handle: { close: vi.fn(), setDisplayName: vi.fn() },
setTitleFileMenuRef: vi.fn(),
}),
returnSplitToRecentListView: vi.fn(),
}));
vi.mock('@components/app/split-layout/components/HeaderIsland', () => ({
HeaderIsland: (props: { children: JSX.Element }) => props.children,
}));
vi.mock('@components/app/split-layout/components/SplitHeader', () => ({
SplitHeaderLeft: (props: { children: JSX.Element }) => props.children,
}));
vi.mock('@components/app/split-layout/components/SplitLabel', () => ({
SplitTitleFileMenu: (props: { children: JSX.Element }) => props.children,
}));
vi.mock('@queries/agent-repositories/repositories', () => ({
useAgentRepositoriesQuery: () => ({
isSuccess: true,
isLoading: false,
isError: false,
data: {
repositories: [
{ url: 'https://github.com/macro-inc/macro' },
{ url: 'https://github.com/macro-inc/docs' },
],
},
}),
}));
vi.mock('./queries/github-link', () => ({
createGithubConnection: () => () => ({
linked: host.githubLinked,
connecting: false,
connect: host.connectGithub,
}),
}));
vi.mock('./routine-event-scope', () => ({
RoutineEventScope: () => <span>Any document</span>,
RoutineEventScopeLabel: () => <span>Any document</span>,
}));
vi.mock('@core/component/Toast/Toast', () => ({
toast: { success: host.success, alert: host.alert },
}));
vi.mock('@core/constant/SettingsState', () => ({
useSettingsState: () => ({ openSettings: vi.fn() }),
}));
vi.mock('../agents-view/primitives/open-page', () => ({
openAgentsPage: vi.fn(),
}));
vi.mock('@core/auth/license', () => ({ useHasPaidAccess: () => () => true }));
vi.mock('@core/mobile/isMobile', () => ({ isMobile: () => false }));
vi.mock('@core/mobile/isTouchDevice', () => ({ isTouchDevice: () => false }));
vi.mock('@core/mobile/virtualKeyboard', () => ({
virtualKeyboardVisible: () => false,
}));
vi.mock('@core/constant/allBlocks', () => ({
blockNameToDefaultFile: () => 'New routine',
}));
vi.mock('./queries/schedules', async () => {
const { useMutation } = await import('@tanstack/solid-query');
return {
useCreateScheduleMutation: (callbacks: {
onSuccess: (schedule: ScheduledAction) => Promise<void>;
onError: (error: Error) => void;
}) => useMutation(() => ({ mutationFn: host.create, ...callbacks })),
};
});
// Keep the real trigger menu, picker, model discovery adapter, storage, and mutation
// lifecycle. The editor double exposes initialValue and detects any remount.
vi.mock('./routine-ai-composer', () => ({
RoutineAiComposer: () => null,
useComposerContext: () => () => ({}),
}));
// Steps are added by hand here; AI adding steps is covered with the steps.
vi.mock('./routine-step-author', () => ({
createRoutineStepAuthor: undefined,
}));
vi.mock('./routine-step-pickers', () => ({
routineToolSlots: {
LabelPicker: () => null,
TagPicker: () => null,
ChannelPicker: () => null,
AssigneePicker: () => null,
FolderPicker: () => null,
},
}));
vi.mock('./routine-prompt-editor', () => ({
RoutinePromptEditor: (props: {
initialValue: string;
onChange: (value: string) => void;
}): JSX.Element => {
host.editorMount();
const initialValue = props.initialValue;
return (
<textarea
aria-label="Instructions"
value={initialValue}
onInput={(event) => props.onChange(event.currentTarget.value)}
/>
);
},
}));
const agentId = '12345678-1234-1234-1234-123456789abc';
const [catalogState, setCatalogState] = createSignal<
'pending' | 'success' | 'error'
>('success');
vi.mock('../agents-view/queries/agent-roster-source', () => ({
createAgentRosterSource: () => ({
roster: () =>
buildAgentRoster({
agents: [
{
bot: { id: agentId, name: 'Researcher', handle: 'researcher' },
harness: 'in-memory',
default_model: 'claude-sonnet-4-6',
},
],
runtimes: [],
cursorConnected: false,
cursorNeedsConnection: true,
}),
loading: () => false,
error: () => false,
availabilityLoading: () => false,
}),
}));
vi.mock('@queries/agents/models', () => ({
useAgentModelsQuery: () => ({
get isSuccess() {
return catalogState() === 'success';
},
get isPending() {
return catalogState() === 'pending';
},
get isError() {
return catalogState() === 'error';
},
get data() {
if (catalogState() !== 'success') throw new Error('Unsafe catalog read');
return {
status: 'available',
models: [
{ id: 'claude-sonnet-4-6', name: 'Sonnet' },
{ id: 'vendor/custom-model', name: 'Custom model' },
],
};
},
}),
}));
class NoResize {
observe() {}
unobserve() {}
disconnect() {}
}
let styles: HTMLStyleElement;
beforeEach(() => {
vi.clearAllMocks();
host.githubLinked = true;
host.flags = new Set([
'enable-routine-conditions',
'enable-routine-starter-templates',
]);
localStorage.clear();
setCatalogState('success');
styles = document.createElement('style');
styles.textContent = '* { animation-name: none; transition-duration: 0s; }';
document.head.append(styles);
vi.stubGlobal('scrollTo', vi.fn());
// The page measures its pane; every test unstubs globals afterwards.
vi.stubGlobal('ResizeObserver', NoResize);
});
afterEach(() => {
cleanup();
styles.remove();
vi.useRealTimers();
vi.unstubAllGlobals();
});
async function mount(): Promise<void> {
const client = new QueryClient({
defaultOptions: { mutations: { retry: false } },
});
render(() => (
<QueryClientProvider client={client}>
<RoutineNew onCreated={host.created} onCancel={host.cancelled} />
</QueryClientProvider>
));
// A blank page starts without steps; an unsent draft resumes as it was.
if (!screen.queryByRole('textbox', { name: 'Instructions' })) {
fireEvent.click(await screen.findByRole('button', { name: 'Add step' }));
fireEvent.click(await screen.findByRole('option', { name: /^Ask AI/ }));
}
await screen.findByRole('textbox', { name: 'Routine name' });
await screen.findByRole('textbox', { name: 'Instructions' });
}
function inputPrompt(value = 'Summarize updates'): HTMLTextAreaElement {
const editor = screen.getByRole<HTMLTextAreaElement>('textbox', {
name: 'Instructions',
});
fireEvent.input(editor, { target: { value } });
return editor;
}
function openPicker(): void {
const trigger = screen.getByRole('button', { name: 'Agent' });
trigger.focus();
fireEvent.keyDown(trigger, { key: 'Enter' });
}
async function selectTarget(
target: 'model' | 'agent' | 'override'
): Promise<void> {
openPicker();
if (target === 'agent') {
fireEvent.click(screen.getByRole('menuitem', { name: /^Researcher/ }));
} else {
let menu: HTMLElement | undefined;
if (target === 'override') {
const row = screen.getByRole('menuitem', { name: /^Researcher/ });
row.focus();
fireEvent.keyDown(row, { key: 'ArrowRight' });
// Do not select the same model from the root Macro catalog.
menu = await screen.findByRole('menu', { name: /^Researcher/ });
await within(menu).findByRole('textbox', { name: 'Search models' });
}
const item = (menu ? within(menu) : screen).getByRole('menuitem', {
name: 'Custom model',
});
item.focus();
fireEvent.keyDown(item, { key: 'Enter' });
}
await waitFor(() =>
expect(
screen
.getByRole('button', { name: 'Agent' })
.getAttribute('aria-expanded')
).toBe('false')
);
}
function create(): void {
fireEvent.click(screen.getByRole('button', { name: 'Create routine' }));
}
/** Kobalte menus open from the keyboard in jsdom. */
function press(element: HTMLElement, key: string) {
element.focus();
fireEvent.keyDown(element, { key });
}
/** Add trigger, then a trigger from its type's submenu. */
function chooseTrigger(type: string, name: string) {
press(screen.getAllByRole('button', { name: 'Add trigger' })[0]!, 'Enter');
press(
screen.getByRole('menuitem', { name: type, hidden: true }),
'ArrowRight'
);
press(
screen.getByRole('menuitem', {
name: new RegExp(`^${name}`),
hidden: true,
}),
'Enter'
);
}
async function addScheduled(name = 'Daily') {
const add = screen.getByRole('button', { name: 'Add trigger' });
chooseTrigger('Schedule', 'On a schedule');
fireEvent.click(await screen.findByRole('radio', { name }));
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Add trigger' })).getByRole(
'button',
{ name: 'Add trigger' }
)
);
await waitFor(() => expect(add.getAttribute('aria-expanded')).toBe('false'));
}
async function addDocumentEvent() {
const add = screen.getByRole('button', { name: 'Add trigger' });
chooseTrigger('Documents', 'Document created');
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Add trigger' })).getByRole(
'button',
{ name: 'Add trigger' }
)
);
await waitFor(() => expect(add.getAttribute('aria-expanded')).toBe('false'));
}
function created(body: ActionConfiguration): ScheduledAction {
if (!('trigger' in body)) throw new Error('Expected a tagged trigger');
return {
...body,
run_visibility:
'run_visibility' in body && body.run_visibility
? body.run_visibility
: 'unlisted',
id: 'new-routine',
owner: 'macro|[email protected]',
created_at: '2026-09-28T00:00:00Z',
updated_at: '2026-09-28T00:00:00Z',
configuration_revision: 1,
};
}
describe('routine composer execution selection', () => {
it.each(['model', 'agent', 'override'] as const)(
'submits a %s target with unchanged cron and timezone behavior',
async (target) => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt(' Summarize updates ');
await addScheduled();
await selectTarget(target);
create();
await waitFor(() => expect(host.create).toHaveBeenCalledOnce());
const body = host.create.mock.calls[0][0];
const expectedTask: Record<string, unknown> = {
prompt: '',
user_prompt: 'Summarize updates',
mcp_servers: [],
};
if (target === 'model') expectedTask.model = 'vendor/custom-model';
else expectedTask.agent = { bot_id: agentId };
if (target === 'override') expectedTask.model = 'vendor/custom-model';
expect(body.task).toEqual(expectedTask);
expect(body).toMatchObject({
trigger: {
type: 'cron',
schedule: '0 0 9 * * *',
timezone: getDefaultTimezone(),
},
});
await waitFor(() =>
expect(host.created).toHaveBeenCalledWith('new-routine')
);
expect(body.enabled).toBe(true);
expect(body).toMatchObject({ run_visibility: 'unlisted' });
}
);
it('creates a routine whose runs show in Home and Agents when asked', async () => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt('Summarize updates');
await addScheduled();
const visibility = screen.getByRole<HTMLInputElement>('switch', {
name: 'Show runs in Home and Agents',
});
expect(visibility.checked).toBe(false);
fireEvent.click(visibility);
expect(visibility.checked).toBe(true);
create();
await waitFor(() => expect(host.create).toHaveBeenCalledOnce());
expect(host.create.mock.calls[0][0]).toMatchObject({
run_visibility: 'listed',
});
});
it('restores the latest selection and prompt even when closed before the save timer', async () => {
await mount();
inputPrompt();
await selectTarget('override');
vi.useFakeTimers();
inputPrompt('Last keystroke');
cleanup();
expect(loadRoutineComposerDraft()).toMatchObject({
prompt: 'Last keystroke',
target: { kind: 'agent', agentId, modelOverride: 'vendor/custom-model' },
});
await mount();
expect(
screen.getByRole<HTMLTextAreaElement>('textbox', { name: 'Instructions' })
.value
).toBe('Last keystroke');
expect(screen.getByRole('button', { name: 'Agent' }).textContent).toContain(
'Researcher'
);
vi.advanceTimersByTime(500);
expect(loadRoutineComposerDraft()?.target).toEqual({
kind: 'agent',
agentId,
modelOverride: 'vendor/custom-model',
});
});
it('retains the draft after an API selection error and allows retry', async () => {
host.create.mockRejectedValueOnce(
new Error('The selected agent is unavailable.')
);
host.create.mockImplementation(async (body) => created(body));
await mount();
const editor = inputPrompt();
await addScheduled();
await selectTarget('agent');
create();
expect((await screen.findByRole('alert')).textContent).toBe(
'The selected agent is unavailable.'
);
expect(host.created).not.toHaveBeenCalled();
await screen.findByRole('button', { name: 'Create routine' });
expect(screen.getByRole('textbox', { name: 'Instructions' })).toBe(editor);
cleanup();
expect(loadRoutineComposerDraft()?.target).toEqual({
kind: 'agent',
agentId,
});
await mount();
create();
await waitFor(() => expect(host.create).toHaveBeenCalledTimes(2));
expect(host.create.mock.calls[1][0]).toEqual(host.create.mock.calls[0][0]);
await waitFor(() =>
expect(host.created).toHaveBeenCalledWith('new-routine')
);
});
it('locks selection and submission while creating and cancels queued saves on success', async () => {
let resolveCreate!: (value: ScheduledAction) => void;
host.create.mockImplementation(
() =>
new Promise((resolve) => {
resolveCreate = resolve;
})
);
await mount();
await selectTarget('agent');
await addScheduled();
vi.useFakeTimers();
inputPrompt();
create();
await vi.advanceTimersByTimeAsync(0);
const picker = screen.getByRole('button', { name: 'Agent' });
expect(picker.closest('fieldset')?.disabled).toBe(true);
expect(
screen.getByRole<HTMLButtonElement>('button', { name: 'Creating…' })
.disabled
).toBe(true);
fireEvent.click(screen.getByRole('button', { name: 'Creating…' }));
expect(host.create).toHaveBeenCalledOnce();
resolveCreate(created(host.create.mock.calls[0][0]));
await vi.advanceTimersByTimeAsync(0);
expect(host.created).toHaveBeenCalledWith('new-routine');
expect(loadRoutineComposerDraft()).toBeNull();
await vi.advanceTimersByTimeAsync(1000);
expect(loadRoutineComposerDraft()).toBeNull();
cleanup();
// Nothing was kept, so the next routine starts fresh.
vi.useRealTimers();
await mount();
expect(
screen.getByRole<HTMLTextAreaElement>('textbox', { name: 'Instructions' })
.value
).toBe('');
});
it('does not remount the prompt editor when targets or catalog status change', async () => {
await mount();
const editor = inputPrompt();
await selectTarget('agent');
setCatalogState('pending');
expect(screen.getByRole('textbox', { name: 'Instructions' })).toBe(editor);
setCatalogState('error');
expect(screen.getByRole('textbox', { name: 'Instructions' })).toBe(editor);
setCatalogState('success');
await selectTarget('override');
await selectTarget('model');
expect(screen.getByRole('textbox', { name: 'Instructions' })).toBe(editor);
expect(editor.value).toBe('Summarize updates');
expect(host.editorMount).toHaveBeenCalledOnce();
});
it('requires instructions and at least one trigger, with no history in creation', async () => {
await mount();
create();
expect(screen.getByText('Instructions are required.')).toBeTruthy();
inputPrompt();
create();
expect(
screen.getByText('Add a trigger to tell this routine when to run.')
).toBeTruthy();
expect(screen.queryByRole('tab', { name: 'Run History' })).toBeNull();
expect(host.create).not.toHaveBeenCalled();
});
it('creates recurring schedules and Macro events together', async () => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt();
await addScheduled('Daily');
await addScheduled('Weekly');
await addDocumentEvent();
create();
await waitFor(() => expect(host.create).toHaveBeenCalledOnce());
expect(host.create.mock.calls[0][0]).toMatchObject({
enabled: true,
trigger: {
type: 'multiple',
triggers: [
{
type: 'cron',
schedule: '0 0 9 * * *',
timezone: getDefaultTimezone(),
},
{
type: 'cron',
schedule: '0 0 9 * * 2',
timezone: getDefaultTimezone(),
},
{ type: 'events', filters: [{ events: ['document.created'] }] },
],
},
});
});
it('offers the focused Macro event catalog and saves new task and email triggers', async () => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt();
press(screen.getByRole('button', { name: 'Add trigger' }), 'Enter');
for (const name of [
'Schedule',
'Email',
'Tasks',
'Channels',
'Documents',
]) {
expect(screen.getByRole('menuitem', { name, hidden: true })).toBeTruthy();
}
// Searching reaches every submenu's events.
const search = screen.getByRole('textbox', { name: 'Search triggers' });
for (const name of [
'On a schedule',
'Once',
'Channel created',
'Message sent in channel',
'@ mentioned in channel',
'Document created',
'Document deleted',
'Task created',
'Status changed',
'Priority changed',
'Assignees changed',
'Due date changed',
'Project changed',
'Effort changed',
'Any property changed',
'New email received',
]) {
fireEvent.input(search, { target: { value: name } });
expect(
screen.getByRole('menuitem', {
name: new RegExp(`^${name}`),
hidden: true,
})
).toBeTruthy();
}
for (const name of [
'Document details changed',
'Message edited',
'Attachment added',
]) {
fireEvent.input(search, { target: { value: name } });
expect(
screen.queryByRole('menuitem', {
name: new RegExp(`^${name}`),
hidden: true,
})
).toBeNull();
}
fireEvent.input(search, { target: { value: 'Task created' } });
fireEvent.keyDown(search, { key: 'Enter' });
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Add trigger' })).getByRole(
'button',
{ name: 'Add trigger' }
)
);
chooseTrigger('Email', 'New email received');
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Add trigger' })).getByRole(
'button',
{ name: 'Add trigger' }
)
);
fireEvent.click(screen.getByRole('button', { name: /Create routine/i }));
await waitFor(() => expect(host.create).toHaveBeenCalledTimes(1));
expect(host.create.mock.calls[0][0]).toMatchObject({
trigger: {
type: 'events',
filters: [
{ events: ['task.created'] },
{ events: ['email.message_received'] },
],
},
});
});
it('saves an email trigger with an only-run-if condition', async () => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt();
chooseTrigger('Email', 'New email received');
const condition = screen.getByRole('textbox', {
name: 'Only run if AI says yes',
});
expect(condition.getAttribute('placeholder')).toBe(
'Is this email an invoice or a receipt?'
);
fireEvent.input(condition, {
target: { value: ' Is this email an invoice? ' },
});
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Add trigger' })).getByRole(
'button',
{ name: 'Add trigger' }
)
);
// The page's trigger reads as a sentence, its condition hanging below.
expect(
screen.getByRole('button', {
name: 'Edit condition: Is this email an invoice?',
})
).toBeTruthy();
fireEvent.click(screen.getByRole('button', { name: /Create routine/i }));
await waitFor(() => expect(host.create).toHaveBeenCalledTimes(1));
expect(host.create.mock.calls[0][0]).toMatchObject({
trigger: {
type: 'events',
filters: [
{
events: ['email.message_received'],
condition: 'Is this email an invoice?',
},
],
},
});
});
it('saves a GitHub workflow trigger narrowed to one repository and workflow', async () => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt();
chooseTrigger('GitHub', 'Workflow failed');
const panel = await screen.findByRole('dialog', { name: 'Add trigger' });
fireEvent.click(
within(panel).getByRole('checkbox', { name: 'macro-inc/macro' })
);
fireEvent.click(
within(panel).getByRole('button', { name: 'Add a field test' })
);
const fields = within(panel).getAllByRole('textbox', {
name: 'Payload field',
});
fireEvent.input(fields[1], { target: { value: 'workflow_run.name' } });
const values = within(panel).getAllByRole('textbox', { name: 'Value' });
fireEvent.input(values[1], { target: { value: 'CI' } });
fireEvent.click(within(panel).getByRole('button', { name: 'Add trigger' }));
expect(
screen.getByRole('button', { name: 'Change Workflow failed trigger' })
).toBeTruthy();
expect(
screen.getByRole('button', { name: 'Repositories for Workflow failed' })
.textContent
).toContain('macro-inc/macro');
fireEvent.click(screen.getByRole('button', { name: /Create routine/i }));
await waitFor(() => expect(host.create).toHaveBeenCalledTimes(1));
expect(host.create.mock.calls[0][0]).toMatchObject({
trigger: {
type: 'events',
filters: [
{
events: ['github'],
github: {
events: ['workflow_run'],
actions: ['completed'],
repositories: ['macro-inc/macro'],
includeBots: false,
},
match: [
{
path: ['workflow_run', 'conclusion'],
in: ['failure', 'timed_out'],
},
{ path: ['workflow_run', 'name'], equals: 'CI' },
],
},
],
},
});
});
it('asks to connect GitHub before offering GitHub triggers', async () => {
host.githubLinked = false;
await mount();
inputPrompt();
press(screen.getByRole('button', { name: 'Add trigger' }), 'Enter');
press(
screen.getByRole('menuitem', { name: 'GitHub', hidden: true }),
'ArrowRight'
);
fireEvent.click(
await screen.findByRole('button', {
name: 'Connect GitHub',
hidden: true,
})
);
expect(
screen.queryByRole('menuitem', {
name: /^Workflow failed/,
hidden: true,
})
).toBeNull();
expect(host.connectGithub).toHaveBeenCalledOnce();
});
it('keeps trigger edits local until confirmed and leaves an add chip', async () => {
await mount();
const editor = inputPrompt();
await addScheduled();
fireEvent.click(screen.getByRole('button', { name: /^Edit Every day at/ }));
fireEvent.input(screen.getByRole('textbox', { name: 'Run time' }), {
target: { value: '3:30pm' },
});
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Edit trigger' })).getByRole(
'button',
{ name: 'Cancel' }
)
);
expect(
screen.getByRole('button', { name: 'Edit Every day at 9:00 AM trigger' })
).toBeTruthy();
fireEvent.click(screen.getByRole('button', { name: /^Edit Every day at/ }));
fireEvent.input(screen.getByRole('textbox', { name: 'Run time' }), {
target: { value: '3:30pm' },
});
fireEvent.click(screen.getByRole('button', { name: 'Done' }));
expect(
screen.getByRole('button', { name: 'Edit Every day at 3:30 PM trigger' })
).toBeTruthy();
expect(screen.getAllByRole('button', { name: 'Add trigger' })).toHaveLength(
1
);
expect(screen.getByRole('textbox', { name: 'Instructions' })).toBe(editor);
expect(host.editorMount).toHaveBeenCalledOnce();
});
it('creates a one-off routine from a relative date phrase', async () => {
host.create.mockImplementation(async (body) => created(body));
await mount();
inputPrompt();
const before = Date.now();
chooseTrigger('Schedule', 'Once');
const date = screen.getByRole('textbox', { name: 'Run once date' });
fireEvent.input(date, { target: { value: 'in 2 hours' } });
fireEvent.keyDown(date, { key: 'Enter' });
fireEvent.click(
within(screen.getByRole('dialog', { name: 'Add trigger' })).getByRole(
'button',
{ name: 'Add trigger' }
)
);
expect(screen.queryByRole('dialog')).toBeNull();
create();
await waitFor(() => expect(host.create).toHaveBeenCalledOnce());
const body = host.create.mock.calls[0][0];
if (!('trigger' in body)) throw new Error('Expected a tagged trigger');
const trigger = body.trigger;
if (trigger.type !== 'once') throw new Error('Expected a once trigger');
const scheduled = new Date(trigger.at).getTime();
expect(scheduled).toBeGreaterThanOrEqual(
before + 2 * 60 * 60 * 1000 - 1000
);
expect(scheduled).toBeLessThanOrEqual(Date.now() + 2 * 60 * 60 * 1000);
});
it('configures one-off dates and the calendar in the same panel', async () => {
await mount();
inputPrompt();
chooseTrigger('Schedule', 'Once');
const panel = screen.getByRole('dialog', { name: 'Add trigger' });
const confirm = () =>
within(panel).getByRole('button', { name: 'Add trigger' });
fireEvent.click(confirm());
expect(within(panel).getByRole('alert').textContent).toMatch(
/Choose a date/
);
fireEvent.click(
screen.getByRole('button', { name: 'Custom date and time…' })
);
expect(screen.getAllByRole('dialog')).toHaveLength(1);
expect(screen.getByRole('dialog', { name: 'Add trigger' })).toBe(panel);
fireEvent.click(
screen.getByRole('button', { name: 'Type a date instead' })
);
fireEvent.input(screen.getByRole('textbox', { name: 'Run once date' }), {
target: { value: 'tomorrow 10am' },
});
fireEvent.click(screen.getByRole('button', { name: /^Tomorrow/ }));
fireEvent.click(confirm());
expect(screen.queryByRole('dialog')).toBeNull();
expect(
screen.getByRole('button', { name: /Edit .*10:00 AM trigger/ })
).toBeTruthy();
cleanup();
expect(loadRoutineComposerDraft()?.triggers).toMatchObject([
{ kind: 'schedule', frequency: 'once', onceAt: expect.any(String) },
]);
const trigger = loadRoutineComposerDraft()?.triggers?.[0];
if (trigger?.kind !== 'schedule') throw new Error('Expected one-off');
const date = new Date(trigger.onceAt);
expect(date.getTime()).toBeGreaterThan(Date.now());
expect(date.getHours()).toBe(10);
});
it('removes one trigger and restores the others after closing', async () => {
await mount();
inputPrompt();
await addScheduled('Daily');
await addDocumentEvent();
fireEvent.click(screen.getByRole('button', { name: /^Edit Every day at/ }));
fireEvent.click(screen.getByRole('button', { name: 'Remove trigger' }));
cleanup();
await mount();
expect(
screen.getByRole('button', { name: 'Change Document created trigger' })
).toBeTruthy();
expect(loadRoutineComposerDraft()?.triggers).toMatchObject([
{ kind: 'event', events: ['document.created'] },
]);
});
});
describe('new routine', () => {
function openNewRoutine() {
const client = new QueryClient();
render(() => (
<QueryClientProvider client={client}>
<RoutineCreator onStart={host.started} />
</QueryClientProvider>
));
}
it('starts a template on the new routine’s page, unsaved', async () => {
openNewRoutine();
expect(screen.queryByRole('button', { name: 'Create routine' })).toBeNull();
fireEvent.click(
await screen.findByRole('button', {
name: 'Start a routine from Morning brief',
})
);
expect(host.started).toHaveBeenCalledOnce();
expect(host.create).not.toHaveBeenCalled();
cleanup();
await mount();
expect(
screen.getByRole<HTMLInputElement>('textbox', { name: 'Routine name' })
.value
).toBe('Morning brief');
expect(
screen.getByRole<HTMLTextAreaElement>('textbox', { name: 'Instructions' })
.value
).toMatch(/Summarize my day/);
expect(
screen.getByRole<HTMLTextAreaElement>('textbox', {
name: 'Routine description',
}).value
).toBe('Weekdays at 9, sum up my day');
});
it('offers no templates while Macro’s templates are flagged off', async () => {
host.flags.delete('enable-routine-starter-templates');
openNewRoutine();
await screen.findByRole('button', { name: 'Start fresh' });
expect(screen.queryByRole('region', { name: 'Templates' })).toBeNull();
expect(
screen.queryByRole('button', {
name: 'Start a routine from Morning brief',
})
).toBeNull();
});
it('starts fresh on a blank page', async () => {
openNewRoutine();
fireEvent.click(await screen.findByRole('button', { name: 'Start fresh' }));
expect(host.started).toHaveBeenCalledOnce();
expect(loadRoutineComposerDraft()).toMatchObject({
name: '',
triggers: [],
steps: [],
});
});
it('starts over when a new routine starts while its page is open', async () => {
await mount();
const name = screen.getByRole<HTMLInputElement>('textbox', {
name: 'Routine name',
});
fireEvent.input(name, { target: { value: 'Old idea' } });
fireEvent.blur(name);
inputPrompt('An unsaved prompt');
startRoutineDraft(
newRoutineDraft(findTemplateByKey('brief'), {
defaultModel: 'claude-sonnet-4-6',
starters: {},
})
);
await waitFor(() =>
expect(
screen.getByRole<HTMLInputElement>('textbox', { name: 'Routine name' })
.value
).toBe('Morning brief')
);
// The replaced page doesn't write its draft over the new one.
expect(loadRoutineComposerDraft()?.name).toBe('Morning brief');
});
it('discards the draft on Cancel', async () => {
await mount();
inputPrompt();
fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
// A routine with anything in it asks before it is dropped.
expect(host.cancelled).not.toHaveBeenCalled();
fireEvent.click(await screen.findByRole('button', { name: 'Discard' }));
expect(host.cancelled).toHaveBeenCalledOnce();
expect(loadRoutineComposerDraft()).toBeNull();
});
});