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 {
CreateContextProvider,
useCreateContext,
} from '@app/features/command/context/create-context';
import { crmTaskComposerContext } from '@app/features/crm/task-composer';
import { SYSTEM_PROPERTY_IDS } from '@property/identifiers';
import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';
import { type Accessor, createSignal, Suspense } from 'solid-js';
import { Dynamic } from 'solid-js/web';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { resolveComponent } from '../componentRegistry';
const state = vi.hoisted(() => ({
authenticated: (): boolean => true,
enabled: (): boolean => false,
flagsLoaded: (): boolean => true,
touch: (): boolean => false,
replace: vi.fn(),
pageView: vi.fn(),
track: vi.fn(),
mountActivity: vi.fn(),
mountProjects: vi.fn(),
saveTask: vi.fn(),
isPopover: false,
close: vi.fn(),
split: undefined as { id: string } | undefined,
managerPublished: true,
unregister: [] as (() => void)[],
}));
vi.mock('@service-storage/websocket', () => ({
storageWS: { reconnectIfDisconnected: vi.fn() },
createWebSocketJob: vi.fn(),
}));
vi.mock('@service-connection/websocket', () => ({
ws: { addEventListener: vi.fn(), send: vi.fn() },
state: () => 'closed',
createConnectionBlockWebsocketEffect: vi.fn(),
createConnectionWebsocketEffect: vi.fn(),
}));
vi.mock('@app/lib/split-router', async (importOriginal) => ({
...(await importOriginal<typeof import('@app/lib/split-router')>()),
useSplitRouter: () => ({ entry: () => undefined }),
createSearchParams: () => [{ scope: 'mine' }, vi.fn()],
}));
vi.mock('@core/auth', () => ({
useIsAuthenticated: () => () => state.authenticated(),
}));
vi.mock('@app/lib/analytics/posthog', () => ({
usePosthog: () => ({ flagsLoaded: () => state.flagsLoaded() }),
useFeatureFlag: () => () => ({
enabled: state.enabled(),
loading: !state.flagsLoaded(),
}),
}));
vi.mock('@core/constant/featureFlags', async (importOriginal) => {
const original =
await importOriginal<typeof import('@core/constant/featureFlags')>();
return {
...original,
isFeatureEnabled: (flag: typeof original.enableCrmActivity) =>
flag === original.enableCrmActivity
? state.enabled()
: original.isFeatureEnabled(flag),
};
});
vi.mock('@app/lib/analytics/analytics-context', () => ({
useAnalytics: () => ({ pageView: state.pageView, track: state.track }),
}));
vi.mock('../layoutUtils', () => ({
useSplitPanelOrThrow: () => ({
handle: {
replace: state.replace,
isPopover: () => state.isPopover,
close: state.close,
},
}),
}));
vi.mock('@core/component/LoadingBlock', () => ({
LoadingBlock: () => <div>Authenticating</div>,
}));
vi.mock('@core/constant/allBlocks', () => ({
fileTypeToBlockName: (type: string) => type,
isBlockAlias: () => false,
resolveBlockAlias: (type: string) => type,
}));
vi.mock('@app/features/activity/views/my-activity-view', () => ({
MyActivityView: () => {
state.mountActivity();
return <div>Activity feed</div>;
},
}));
vi.mock('@app/features/activity/open-entity-in-split', () => ({
openEntityInSplit: vi.fn(),
}));
vi.mock('@app/features/projects/project-view', () => ({
ProjectsListView: () => {
state.mountProjects();
return <div>Project collection</div>;
},
ProjectView: () => {
state.mountProjects();
return <div>Project detail</div>;
},
CreateProjectView: () => {
state.mountProjects();
return <div>Project composer</div>;
},
}));
vi.mock('@app/features/home/components/HomeEntityDetailRouteView', () => ({
HomeEntityDetailRouteView: () => null,
}));
// Quarantine unrelated registered views and their module-load side effects.
// Route/preview codecs otherwise pull the full block-definition graph into this test.
vi.mock('@app/features/home/home-route', () => ({}));
vi.mock('@app/features/agents-view/views/AgentsView', () => ({}));
vi.mock('@app/features/channels-view/channels-view', () => ({
ChannelDetailRouteView: () => null,
}));
vi.mock('@app/features/drive-view/drive-view', () => ({}));
vi.mock('@app/features/drive-view/components/DriveDetailView', () => ({
DriveDetailView: () => null,
}));
vi.mock('@app/features/email-compose/email-compose', () => ({}));
vi.mock('@app/features/email-view/email-view', () => ({}));
vi.mock('@app/features/email-view/components/EmailDetailView', () => ({
EmailDetailRouteView: () => null,
}));
vi.mock('@app/features/home/home-view', () => ({
HomeDetailRouteView: () => null,
HomeCalendarRouteView: () => null,
HomePendingView: () => null,
}));
vi.mock('@app/features/next-soup/filters/filter-store', () => ({}));
vi.mock('@app/features/next-soup/filters/filter-store/query-store', () => ({}));
vi.mock('@app/features/next-soup/sidebar/soup-filter-presets', () => ({}));
vi.mock('@app/features/next-soup/soup-view/soup-view', () => ({}));
vi.mock('@app/features/next-soup/use-recent-view-flag', () => ({}));
vi.mock('@app/features/settings/Settings', () => ({
SettingsPanelComponentWrapper: () => null,
}));
vi.mock('@app/features/settings/IntegrationsPage', () => ({}));
vi.mock('@app/features/tasks-view/tasks-view', () => ({}));
vi.mock('@app/features/tasks-view/components/TasksDetailView', () => ({
TasksDetailRouteView: () => null,
}));
vi.mock('@app/signal/splitLayout', () => {
const manager = { activeSplit: () => state.split };
return {
globalSplitManager: () => (state.managerPublished ? manager : undefined),
};
});
vi.mock('@block-calendar/components/EventComposerSplit', () => ({}));
vi.mock('@block-channel/component/Compose', () => ({}));
vi.mock('@block-md/component/ComposeSkill', () => ({}));
vi.mock('@app/features/task-composer/compose-task', () => ({
ComposeTask: (props: {
composerContext?: {
key: string;
initialPropertyValues?: Record<string, unknown>;
};
initialTitle?: string;
}) => {
const [title, setTitle] = createSignal(props.initialTitle ?? '');
const [content, setContent] = createSignal('');
return (
<div>
<div>
{props.composerContext?.key ?? 'Standard'} composer:{' '}
{props.initialTitle}
</div>
<input
aria-label="Task title"
value={title()}
onInput={(event) => setTitle(event.currentTarget.value)}
/>
<textarea
aria-label="Task description"
value={content()}
onInput={(event) => setContent(event.currentTarget.value)}
/>
<button
type="button"
onClick={() =>
state.saveTask({
title: title(),
content: content(),
properties: props.composerContext?.initialPropertyValues,
})
}
>
Save task
</button>
</div>
);
},
}));
vi.mock('@app/features/crm/queries/saved-views', () => ({}));
vi.mock('@core/context/user', () => ({}));
vi.mock('@core/mobile/isTouchDevice', () => ({
isTouchDevice: () => state.touch(),
}));
vi.mock('@app/features/routines/queries/entities', () => ({}));
vi.mock('@ui', () => ({
createVariants: () => () => '',
}));
beforeEach(() => {
vi.clearAllMocks();
state.isPopover = false;
state.authenticated = () => true;
state.enabled = () => false;
state.flagsLoaded = () => true;
state.touch = () => false;
state.split = undefined;
state.managerPublished = true;
});
afterEach(() => {
cleanup();
for (const unregister of state.unregister.splice(0)) unregister();
});
/** Registry views are lazy chunks; settle the chunk so assertions see the view. */
async function renderActivity() {
const activity = resolveComponent('activity');
const result = render(() => <Suspense>{activity.element()}</Suspense>);
await import('@app/features/activity/route-views');
await new Promise((resolve) => setTimeout(resolve, 0));
return result;
}
describe('calendar layout registration', () => {
it('owns desktop chrome but keeps the floating split header on touch', () => {
expect(resolveComponent('calendar').initialMeta).toMatchObject({
splitPanelLayout: 'composable',
});
state.touch = () => true;
expect(resolveComponent('calendar').initialMeta).toBeUndefined();
});
});
describe('activity registration', () => {
it('redirects a disabled feed to inbox without mounting or tracking it', async () => {
await renderActivity();
expect(state.replace).toHaveBeenCalledExactlyOnceWith({
next: { type: 'component', id: 'home', entryMetadata: { search: {} } },
});
expect(state.mountActivity).not.toHaveBeenCalled();
expect(state.pageView).not.toHaveBeenCalled();
});
it.each([false, true])(
'waits for flags before resolving a restored split (enabled: %s)',
async (enabled) => {
const [flagEnabled, setFlagEnabled] = createSignal(false);
const [flagsLoaded, setFlagsLoaded] = createSignal(false);
state.enabled = flagEnabled;
state.flagsLoaded = flagsLoaded;
await renderActivity();
expect(state.replace).not.toHaveBeenCalled();
expect(state.mountActivity).not.toHaveBeenCalled();
expect(state.pageView).not.toHaveBeenCalled();
setFlagEnabled(enabled);
setFlagsLoaded(true);
if (enabled) {
expect(await screen.findByText('Activity feed')).toBeTruthy();
expect(state.replace).not.toHaveBeenCalled();
expect(state.pageView).toHaveBeenCalledExactlyOnceWith('activity');
} else {
expect(state.replace).toHaveBeenCalledExactlyOnceWith({
next: {
type: 'component',
id: 'home',
entryMetadata: { search: {} },
},
});
expect(state.mountActivity).not.toHaveBeenCalled();
expect(state.pageView).not.toHaveBeenCalled();
}
}
);
it('keeps an enabled feed behind authentication', async () => {
const [authenticated, setAuthenticated] = createSignal(false);
state.authenticated = authenticated;
state.enabled = () => true;
await renderActivity();
expect(screen.getByText('Authenticating')).toBeTruthy();
expect(state.mountActivity).not.toHaveBeenCalled();
expect(state.pageView).not.toHaveBeenCalled();
expect(state.replace).not.toHaveBeenCalled();
setAuthenticated(true);
expect(await screen.findByText('Activity feed')).toBeTruthy();
expect(state.mountActivity).toHaveBeenCalledOnce();
expect(state.pageView).toHaveBeenCalledExactlyOnceWith('activity');
expect(state.replace).not.toHaveBeenCalled();
});
});
describe('contextual task composer registration', () => {
it.each([false, true])(
'opens immediately while flags load and keeps its opening mode (enabled after load: %s)',
async (enabled) => {
const [flagEnabled, setFlagEnabled] = createSignal(false);
const [flagsLoaded, setFlagsLoaded] = createSignal(false);
state.enabled = flagEnabled;
state.flagsLoaded = flagsLoaded;
const component = resolveComponent('task-compose', {
initialTitle: 'Follow up',
composerContext: { key: 'crm:company:acme', visiblePropertyIds: [] },
});
render(() => (
<Suspense>
<Dynamic component={component.element} />
</Suspense>
));
expect(
await screen.findByText('crm:company:acme composer: Follow up')
).toBeTruthy();
const title = screen.getByRole('textbox', { name: 'Task title' });
fireEvent.input(title, { target: { value: 'Draft saved' } });
setFlagEnabled(enabled);
setFlagsLoaded(true);
expect(
screen.getByText('crm:company:acme composer: Follow up')
).toBeTruthy();
expect(screen.getByRole('textbox', { name: 'Task title' })).toBe(title);
expect(title).toHaveProperty('value', 'Draft saved');
const next = resolveComponent('task-compose', {
initialTitle: 'Next',
composerContext: { key: 'crm:company:acme', visiblePropertyIds: [] },
});
render(() => (
<Suspense>
<Dynamic component={next.element} />
</Suspense>
));
expect(
await screen.findByText('crm:company:acme composer: Next')
).toBeTruthy();
}
);
it('opens standard tasks without waiting for the CRM rollout', async () => {
state.flagsLoaded = () => false;
const component = resolveComponent('task-compose', {
initialTitle: 'Plan',
});
render(() => (
<Suspense>
<Dynamic component={component.element} />
</Suspense>
));
expect(await screen.findByText('Standard composer: Plan')).toBeTruthy();
});
it.each([true, false])(
'preserves an open draft and its associations when the rollout changes (initial: %s)',
async (initiallyEnabled) => {
const [enabled, setEnabled] = createSignal(initiallyEnabled);
state.enabled = enabled;
const properties = {
companies: {
valueType: 'ENTITY',
refs: [{ entity_id: 'acme', entity_type: 'COMPANY' }],
},
};
const component = resolveComponent('task-compose', {
composerContext: {
key: 'CRM',
visiblePropertyIds: ['companies'],
initialPropertyValues: properties,
},
});
render(() => (
<Suspense>
<Dynamic component={component.element} />
</Suspense>
));
const title = await screen.findByRole('textbox', { name: 'Task title' });
const description = screen.getByRole('textbox', {
name: 'Task description',
});
fireEvent.input(title, { target: { value: 'Follow up with Acme' } });
fireEvent.input(description, {
target: { value: 'Discuss the renewal' },
});
setEnabled(!initiallyEnabled);
expect(screen.getByRole('textbox', { name: 'Task title' })).toBe(title);
expect(screen.getByRole('textbox', { name: 'Task description' })).toBe(
description
);
fireEvent.click(screen.getByRole('button', { name: 'Save task' }));
expect(state.saveTask).toHaveBeenCalledExactlyOnceWith({
title: 'Follow up with Acme',
content: 'Discuss the renewal',
properties,
});
const next = resolveComponent('task-compose', {
initialTitle: 'New draft',
composerContext: { key: 'CRM', initialPropertyValues: properties },
});
render(() => (
<Suspense>
<Dynamic component={next.element} />
</Suspense>
));
expect(await screen.findByText('CRM composer: New draft')).toBeTruthy();
}
);
it.each([true, false])(
'uses supplied context when flags change before mounting (enabled at launch: %s)',
async (initiallyEnabled) => {
const [enabled, setEnabled] = createSignal(initiallyEnabled);
state.enabled = enabled;
const properties = {
companies: {
valueType: 'ENTITY',
refs: [{ entity_id: 'acme', entity_type: 'COMPANY' }],
},
};
const component = resolveComponent('task-compose', {
initialTitle: 'Follow up',
composerContext: { key: 'CRM', initialPropertyValues: properties },
});
setEnabled(!initiallyEnabled);
render(() => (
<Suspense>
<Dynamic component={component.element} />
</Suspense>
));
await screen.findByRole('textbox', { name: 'Task title' });
fireEvent.click(screen.getByRole('button', { name: 'Save task' }));
expect(state.saveTask).toHaveBeenCalledExactlyOnceWith({
title: 'Follow up',
content: '',
properties,
});
}
);
});
function mountCreateContext(focusedPaneId: Accessor<string | undefined>) {
let context!: ReturnType<typeof useCreateContext>;
render(() => (
<CreateContextProvider focusedPaneId={focusedPaneId}>
{(() => {
context = useCreateContext();
return null;
})()}
</CreateContextProvider>
));
return context;
}
describe('pane create context registration', () => {
it('reads the focused pane and supports explicit pane selection', () => {
const [paneId, setPaneId] = createSignal<string | undefined>('one');
const context = mountCreateContext(paneId);
state.unregister.push(
context.register('one', () => ({ task: { key: 'first' } })),
context.register('two', () => ({ task: { key: 'second' } }))
);
expect(context.read('task')?.key).toBe('first');
expect(context.snapshot('task')?.key).toBe('first');
setPaneId('two');
expect(context.read('task')?.key).toBe('second');
expect(context.snapshot('task', 'one')?.key).toBe('first');
expect(context.read('task', 'one')?.key).toBe('first');
setPaneId(undefined);
expect(context.read('task')).toBeUndefined();
expect(context.snapshot('task')).toBeUndefined();
});
it('isolates providers with identical pane IDs', () => {
const first = mountCreateContext(() => 'pane');
const second = mountCreateContext(() => 'pane');
state.unregister.push(
first.register('pane', () => ({ task: { key: 'first' } })),
second.register('pane', () => ({ task: { key: 'second' } }))
);
expect(first.snapshot('task')?.key).toBe('first');
expect(second.snapshot('task')?.key).toBe('second');
});
it('works without a published global split manager', () => {
state.managerPublished = false;
const context = mountCreateContext(() => 'pane');
state.unregister.push(
context.register('pane', () => ({ task: { key: 'mounted' } }))
);
expect(context.snapshot('task')?.key).toBe('mounted');
});
it('restores the parent after nested cleanup and tolerates repeated teardown', () => {
const context = mountCreateContext(() => 'pane');
const removeParent = context.register('pane', () => ({
task: { key: 'parent' },
}));
const removeChild = context.register('pane', () => ({
task: { key: 'child' },
}));
state.unregister.push(removeParent, removeChild);
expect(context.snapshot('task')?.key).toBe('child');
removeChild();
expect(context.snapshot('task')?.key).toBe('parent');
removeChild();
expect(context.snapshot('task')?.key).toBe('parent');
removeParent();
expect(context.snapshot('task')).toBeUndefined();
});
it('keeps the child when its parent unmounts first', () => {
const context = mountCreateContext(() => 'pane');
const removeParent = context.register('pane', () => ({
task: { key: 'parent' },
}));
const removeChild = context.register('pane', () => ({
task: { key: 'child' },
}));
state.unregister.push(removeParent, removeChild);
removeParent();
expect(context.snapshot('task')?.key).toBe('child');
removeChild();
expect(context.snapshot('task')).toBeUndefined();
});
it('reads loaded associations at launch and leaves an earlier snapshot unchanged', () => {
const context = mountCreateContext(() => 'pane');
const [companyId, setCompanyId] = createSignal<string>();
state.unregister.push(
context.register('pane', () => ({
task: crmTaskComposerContext({
type: 'contact',
id: 'maya',
companyId: companyId(),
}),
}))
);
const first = context.snapshot('task');
expect(
first?.initialPropertyValues?.[SYSTEM_PROPERTY_IDS.COMPANIES]
).toBeUndefined();
setCompanyId('acme');
const next = context.snapshot('task');
expect(next?.initialPropertyValues?.[SYSTEM_PROPERTY_IDS.CONTACTS]).toEqual(
{
valueType: 'ENTITY',
refs: [{ entity_id: 'maya', entity_type: 'CONTACT' }],
}
);
expect(
next?.initialPropertyValues?.[SYSTEM_PROPERTY_IDS.COMPANIES]
).toEqual({
valueType: 'ENTITY',
refs: [{ entity_id: 'acme', entity_type: 'COMPANY' }],
});
expect(
first?.initialPropertyValues?.[SYSTEM_PROPERTY_IDS.COMPANIES]
).toBeUndefined();
});
it('isolates snapshots from mutable provider values', () => {
const context = mountCreateContext(() => 'pane');
const preset = {
...crmTaskComposerContext({ type: 'company', id: 'acme' }),
visiblePropertyIds: ['existing-property'],
};
state.unregister.push(context.register('pane', () => ({ task: preset })));
const snapshot = context.snapshot('task');
preset.visiblePropertyIds.push('new-property');
expect(snapshot?.visiblePropertyIds).not.toContain('new-property');
});
it('suppresses a parent with null and responds to reactive source changes', () => {
const context = mountCreateContext(() => 'pane');
const [enabled, setEnabled] = createSignal(false);
state.unregister.push(
context.register('pane', () => ({ task: { key: 'parent' } })),
context.register('pane', () => ({
task: enabled() ? { key: 'child' } : null,
}))
);
expect(context.read('task')).toBeUndefined();
expect(context.snapshot('task')).toBeUndefined();
setEnabled(true);
const snapshot = context.snapshot('task');
expect(snapshot?.key).toBe('child');
setEnabled(false);
expect(context.read('task')).toBeUndefined();
expect(snapshot?.key).toBe('child');
});
it('inherits the parent action when the child omits it', () => {
const context = mountCreateContext(() => 'pane');
state.unregister.push(
context.register('pane', () => ({ task: { key: 'parent' } })),
context.register('pane', () => ({}))
);
expect(context.read('task')?.key).toBe('parent');
expect(context.snapshot('task')?.key).toBe('parent');
});
it('updates reads when registrations change', () => {
const context = mountCreateContext(() => 'pane');
const removeParent = context.register('pane', () => ({
task: { key: 'parent' },
}));
state.unregister.push(removeParent);
expect(context.read('task')?.key).toBe('parent');
const removeChild = context.register('pane', () => ({
task: { key: 'child' },
}));
state.unregister.push(removeChild);
expect(context.read('task')?.key).toBe('child');
removeChild();
expect(context.read('task')?.key).toBe('parent');
removeParent();
expect(context.read('task')).toBeUndefined();
});
});
describe('project registration', () => {
const routes = [
['tasks-projects', 'Project collection'],
['new-project', 'Project composer'],
['project-compose', 'Project composer'],
[
'initiative-view~01a0cf92-3101-7e21-9a20-6e21058d20e0~overview',
'Project detail',
],
] as const;
it.each(routes)(
'gates a restored %s route until PostHog enables Projects',
async (route, title) => {
const [enabled, setEnabled] = createSignal(false);
const [loaded, setLoaded] = createSignal(false);
state.enabled = enabled;
state.flagsLoaded = loaded;
const component = resolveComponent(route);
render(() => <Suspense>{component.element()}</Suspense>);
expect(state.mountProjects).not.toHaveBeenCalled();
expect(state.replace).not.toHaveBeenCalled();
setEnabled(true);
setLoaded(true);
expect(await screen.findByText(title)).toBeTruthy();
expect(state.replace).not.toHaveBeenCalled();
setEnabled(false);
expect(screen.queryByText(title)).toBeNull();
expect(state.replace).toHaveBeenCalledExactlyOnceWith({
next: { type: 'component', id: 'tasks' },
});
}
);
it.each(routes)(
'redirects disabled %s without mounting project data',
(route) => {
const component = resolveComponent(route);
render(() => <Suspense>{component.element()}</Suspense>);
expect(state.mountProjects).not.toHaveBeenCalled();
expect(state.replace).toHaveBeenCalledExactlyOnceWith({
next: { type: 'component', id: 'tasks' },
});
}
);
it('closes a disabled composer popover instead of replacing its background split', () => {
state.isPopover = true;
const component = resolveComponent('project-compose');
render(() => <Suspense>{component.element()}</Suspense>);
expect(state.mountProjects).not.toHaveBeenCalled();
expect(state.replace).not.toHaveBeenCalled();
expect(state.close).toHaveBeenCalledOnce();
});
});