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 { EntryState } from '@components/app/split-layout/layoutManager';
import type {
EntityItem,
QuickAccessItem,
UserItem,
} from '@core/context/quickAccess';
import type { EntityData, SearchLocation } from '@entity';
import {
cleanup,
fireEvent,
render,
screen,
waitFor,
within,
} from '@solidjs/testing-library';
import { CombinedError } from '@urql/core';
import { okAsync } from 'neverthrow';
import { type Accessor, createSignal, onMount, Show } from 'solid-js';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import { mergeCommandPeople } from '../contact-items';
import { MobileSearchInput } from './MobileSearchInput';
import { MobileSearchResults } from './MobileSearchResults';
import { SearchState } from './mobileSearchState';
const mocks = vi.hoisted(() => ({
accountId: (() => 'owner') as Accessor<string>,
authenticated: (() => true) as Accessor<boolean>,
fullText: vi.fn(),
fullTextItems: [] as EntityData[],
fullTextData: (() => []) as Accessor<EntityData[]>,
fullTextLoading: (() => false) as Accessor<boolean>,
fullTextSettling: (() => false) as Accessor<boolean>,
open: vi.fn(),
onOpen: () => {},
directMessage: vi.fn(),
failure: vi.fn(),
loadMore: vi.fn(),
hasMore: true,
loadingMore: false,
viewportHeight: 400,
deferLayout: false,
measureLayout: () => {},
fetchNextPage: vi.fn(),
items: (() => []) as Accessor<QuickAccessItem[]>,
loadingEntities: (() => false) as Accessor<boolean>,
refreshError: (() => false) as Accessor<boolean>,
fullTextError: (() => undefined) as Accessor<Error | undefined>,
active: (() => true) as Accessor<boolean>,
setActive: (_active: boolean) => {},
entryState: undefined as EntryState | undefined,
captors: new Map<string, () => unknown>(),
}));
vi.mock('@app/lib/split-router', async (importOriginal) => ({
...(await importOriginal<typeof import('@app/lib/split-router')>()),
useSplitRouter: () => ({ entry: () => ({ id: 'search-entry' }) }),
}));
vi.mock('@app/lib/analytics/posthog', () => ({
useFeatureFlag: () => () => ({ enabled: true }),
}));
vi.mock('../../universal-input/use-universal-input', () => ({
useUniversalInputEnabled: () => () => false,
}));
vi.mock('@app/features/crm/record-adapter', () => ({
useCrmContactDiscovery: vi.fn(),
}));
vi.mock('@app/features/next-soup/utils', () => ({
openEntityInSplitFromUnifiedList: mocks.open,
}));
vi.mock('@components/app/split-layout/layout', () => ({
useSplitLayout: () => ({ openWithSplit: mocks.open }),
}));
vi.mock('@components/app/split-layout/layoutUtils', () => ({
useSplitPanelOrThrow: () => ({
handle: {
isActive: () => mocks.active(),
currentEntryState: () => mocks.entryState,
content: () => ({ state: mocks.entryState }),
captureEntryState: () => {
mocks.entryState = Object.fromEntries(
[...mocks.captors].map(([key, read]) => [key, read()])
);
},
registerEntryStateCaptor: (key: string, getter: () => unknown) => {
mocks.captors.set(key, getter);
return () => mocks.captors.delete(key);
},
},
}),
}));
vi.mock('@components/app/mobile/use-mobile-nav', () => ({
useForegroundMobileView: () => () => 'search',
useMobileNavNavigate: () => vi.fn(),
}));
vi.mock('@core/mobile/haptics', () => ({ hapticImpact: vi.fn() }));
vi.mock('@core/context/user', () => ({
useUserId: () => mocks.accountId,
useIsAuthenticated: () => mocks.authenticated,
}));
vi.mock(
'@core/component/LexicalMarkdown/component/core/StaticMarkdown',
() => ({
StaticMarkdownContext: (props: {
children: import('solid-js').JSX.Element;
}) => props.children,
})
);
vi.mock('@core/component/Toast/Toast', () => ({
toast: { failure: mocks.failure },
}));
vi.mock('@queries/channel/get-or-create-dm', () => ({
existingDirectMessage: mocks.directMessage,
}));
vi.mock('@queries/storage/databases', () => ({
useDatabaseDiscoverySync: vi.fn(),
}));
vi.mock('../CommandItem', () => ({
ItemDisplay: (props: { item: QuickAccessItem }) => (
<span>{props.item.searchText}</span>
),
}));
vi.mock('@entity', () => ({
ListEntityMetadataQueryProvider: (props: {
children: import('solid-js').JSX.Element;
}) => props.children,
ListLayoutProvider: (props: {
children: import('solid-js').JSX.Element;
onMeasured?: () => void;
}) => {
mocks.measureLayout = () => props.onMeasured?.();
onMount(() => {
if (!mocks.deferLayout) mocks.measureLayout();
});
return props.children;
},
ListEntity: (props: {
entity: EntityData;
ref?: (element: HTMLDivElement) => void;
onContentHitClick: (event: MouseEvent, location: SearchLocation) => void;
}) => (
<div ref={props.ref}>
<button
type="button"
onClick={(event) =>
props.onContentHitClick(event, {
type: 'email',
messageId: 'matching-message',
})
}
>
{props.entity.name} snippet
</button>
</div>
),
}));
vi.mock('../queries/entity-search', () => ({
useEntitySearch: () => ({
items: () => mocks.items(),
rankItems: (items: QuickAccessItem[]) => items,
isLoadingEntities: () => mocks.loadingEntities(),
isSettling: () => mocks.loadingEntities(),
hasError: () => mocks.refreshError(),
hasAuthoritativeError: () => false,
pagination: {
hasMore: () => mocks.hasMore,
isLoadingMore: () => mocks.loadingMore,
loadMore: mocks.loadMore,
},
}),
}));
vi.mock('../queries/mobile-full-text-search', () => ({
createMobileFullTextSearch: (...args: unknown[]) => {
mocks.fullText(...args);
return {
data: () => mocks.fullTextData(),
isLoading: () => mocks.fullTextLoading(),
isSettling: () => mocks.fullTextSettling(),
error: () => mocks.fullTextError(),
hasNextPage: () => mocks.hasMore,
isFetchingNextPage: () => mocks.loadingMore,
fetchNextPage: mocks.fetchNextPage,
};
},
}));
beforeEach(() => {
mocks.accountId = () => 'owner';
mocks.authenticated = () => true;
const [active, setActive] = createSignal(true);
mocks.active = active;
mocks.setActive = setActive;
mocks.entryState = undefined;
mocks.captors.clear();
mocks.open.mockImplementation(() => {
mocks.onOpen();
mocks.entryState = Object.fromEntries(
[...mocks.captors].map(([key, read]) => [key, read()])
);
setActive(false);
});
vi.spyOn(HTMLElement.prototype, 'offsetParent', 'get').mockReturnValue(
document.body
);
vi.stubGlobal(
'ResizeObserver',
class implements ResizeObserver {
constructor(private callback: ResizeObserverCallback) {}
observe(target: Element) {
this.callback(
[
{
target,
contentRect: new DOMRect(
0,
0,
400,
target.getAttribute('role') === 'region'
? mocks.viewportHeight
: 400
),
borderBoxSize: [],
contentBoxSize: [],
devicePixelContentBoxSize: [],
},
],
this
);
}
unobserve() {}
disconnect() {}
}
);
mocks.hasMore = true;
mocks.onOpen = () => {};
mocks.viewportHeight = 400;
mocks.deferLayout = false;
mocks.loadingMore = false;
mocks.items = () => [];
mocks.loadingEntities = () => false;
mocks.refreshError = () => false;
mocks.fullTextError = () => undefined;
mocks.fullTextItems = [];
mocks.fullTextData = () => mocks.fullTextItems;
mocks.fullTextLoading = () => false;
mocks.fullTextSettling = () => mocks.fullTextLoading();
SearchState.open();
});
afterEach(() => {
cleanup();
SearchState.close();
vi.resetAllMocks();
vi.unstubAllGlobals();
vi.restoreAllMocks();
});
it('offers full text above empty results, only mounts it explicitly, and keeps the input during mode changes', () => {
render(() => (
<>
<MobileSearchInput />
<MobileSearchResults />
</>
));
const input = screen.getByPlaceholderText('Search…');
input.focus();
fireEvent.input(input, { target: { value: 'teo' } });
expect(screen.getByText('No results')).toBeTruthy();
expect(mocks.fullText).not.toHaveBeenCalled();
fireEvent.click(
screen.getByRole('button', { name: 'Search full text for “teo”' })
);
expect(mocks.fullText).toHaveBeenCalledOnce();
expect(document.activeElement).toBe(input);
fireEvent.input(input, { target: { value: 'teo update' } });
expect(SearchState.mode()).toBe('full-text');
SearchState.setCategory('email');
expect(mocks.fullText).toHaveBeenCalledOnce();
fireEvent.input(input, { target: { value: ' ' } });
expect(SearchState.mode()).toBe('name');
expect(SearchState.category()).toBe('email');
expect(screen.queryByText(/Search full text for/)).toBeNull();
expect(screen.getByPlaceholderText('Search…')).toBe(input);
});
it('omits full text for Projects and hides search on result opening', async () => {
const [items, setItems] = createSignal<QuickAccessItem[]>([]);
mocks.items = items;
render(() => <MobileSearchResults />);
SearchState.setQuery('teo');
SearchState.searchFullText();
SearchState.setCategory('projects');
expect(screen.queryByText(/Search full text for/)).toBeNull();
expect(screen.queryByRole('button', { name: 'Load more' })).toBeNull();
setItems([
{
id: 'project',
kind: 'entity',
bucket: 'initiative',
data: {
id: 'project',
type: 'initiative',
name: 'Teo project',
ownerId: 'owner',
},
searchText: 'Teo project',
sortTimestamp: 0,
timestamps: {},
},
]);
fireEvent.click(screen.getByRole('button', { name: 'Teo project' }));
expect(SearchState.isOpen()).toBe(false);
expect(mocks.open).toHaveBeenCalled();
SearchState.open();
expect(SearchState.mode()).toBe('name');
expect(SearchState.category()).toBe('all');
});
it('preserves the search after a failed person lookup and on return from a successful retry', async () => {
mocks.items = () => [
{
id: 'macro|[email protected]',
kind: 'user',
bucket: 'person',
searchText: 'Teo',
sortTimestamp: 0,
timestamps: {},
data: {
id: 'macro|[email protected]',
email: '[email protected]',
name: 'Teo',
},
},
];
mocks.directMessage.mockReturnValue(okAsync('direct-message'));
mocks.open.mockImplementationOnce(() => {
throw new Error('Unavailable');
});
SearchState.setQuery('teo');
SearchState.setCategory('people');
render(() => <MobileSearchResults />);
fireEvent.click(screen.getByRole('button', { name: 'Teo' }));
await waitFor(() =>
expect(mocks.failure).toHaveBeenCalledWith(
'Unable to open result. Please try again.'
)
);
expect(SearchState.isOpen()).toBe(true);
expect(SearchState.query()).toBe('teo');
expect(SearchState.category()).toBe('people');
expect(SearchState.mode()).toBe('name');
fireEvent.click(screen.getByRole('button', { name: 'Teo' }));
expect(SearchState.isOpen()).toBe(true);
await waitFor(() =>
expect(mocks.open).toHaveBeenNthCalledWith(
2,
{ type: 'channel', id: 'direct-message' },
{ reopen: 'latest' }
)
);
expect(SearchState.isOpen()).toBe(false);
mocks.setActive(true);
expect(SearchState.isOpen()).toBe(true);
expect(SearchState.query()).toBe('teo');
expect(SearchState.category()).toBe('people');
expect(screen.getByRole('button', { name: 'Teo' })).toBeTruthy();
});
it('opens the selected full-text message and hides the search chrome', () => {
const email: EntityData = {
id: 'thread',
type: 'email',
name: 'Weekly update',
ownerId: 'owner',
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-02T00:00:00Z',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
};
mocks.fullTextItems = [email];
SearchState.setQuery('teo');
SearchState.setCategory('email');
SearchState.searchFullText();
render(() => <MobileSearchResults />);
fireEvent.click(
screen.getByRole('button', { name: 'Weekly update snippet' })
);
expect(mocks.open).toHaveBeenCalledWith(email, {
splitHandle: expect.objectContaining({ isActive: expect.any(Function) }),
location: { type: 'email', messageId: 'matching-message' },
});
expect(SearchState.isOpen()).toBe(false);
expect(SearchState.query()).toBe('teo');
expect(SearchState.category()).toBe('email');
});
it('bounds mounted recent rows while keeping the first result usable', () => {
mocks.items = () =>
Array.from({ length: 2000 }, (_, index) => ({
id: `project-${index}`,
kind: 'entity',
bucket: 'initiative',
data: {
id: `project-${index}`,
type: 'initiative',
name: `Project ${index}`,
ownerId: 'owner',
},
searchText: `Project ${index}`,
sortTimestamp: 0,
timestamps: {},
}));
render(() => <MobileSearchResults />);
expect(screen.getAllByRole('button').length).toBeLessThan(50);
fireEvent.click(screen.getByRole('button', { name: 'Project 0' }));
expect(mocks.open).toHaveBeenCalled();
expect(SearchState.isOpen()).toBe(false);
});
it('restores full-text order, query, category, mode and scroll after measuring remounted rows', async () => {
const email: EntityData = {
id: 'thread',
type: 'email',
name: 'Weekly update',
ownerId: 'owner',
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-02T00:00:00Z',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
};
const other = { ...email, id: 'other', name: 'Earlier update' };
const [items, setItems] = createSignal<EntityData[]>([other, email]);
mocks.onOpen = () => setItems([email, other]);
const [settling, setSettling] = createSignal(false);
mocks.fullTextData = items;
mocks.fullTextSettling = settling;
mocks.hasMore = false;
SearchState.setQuery('teo');
SearchState.setCategory('email');
SearchState.searchFullText();
const view = render(() => <MobileSearchResults />);
const list = screen.getByRole('region', { name: 'Search results' });
fireEvent.scroll(list, { target: { scrollTop: 1280 } });
fireEvent.click(
screen.getByRole('button', { name: 'Weekly update snippet' })
);
mocks.setActive(true);
expect(
within(list)
.getAllByRole('button')
.map((row) => row.textContent)
).toEqual(['Earlier update snippet', 'Weekly update snippet']);
const entry = mocks.entryState;
view.unmount();
// A separate dock session must not overwrite this history entry.
SearchState.open();
SearchState.setQuery('another query');
SearchState.setCategory('tasks');
SearchState.close();
expect(mocks.entryState).toBe(entry);
mocks.setActive(true);
setSettling(true);
setItems([]);
mocks.deferLayout = true;
render(() => (
<>
<MobileSearchInput />
<MobileSearchResults />
</>
));
const input = screen.getByPlaceholderText('Search…');
expect(input).toHaveProperty('value', 'teo');
expect(document.activeElement).not.toBe(input);
expect(SearchState.category()).toBe('email');
expect(SearchState.mode()).toBe('full-text');
expect(screen.getByText('Searching…')).toBeTruthy();
expect(
screen.queryByRole('button', { name: 'Weekly update snippet' })
).toBeNull();
mocks.measureLayout();
setItems([email, other]);
setSettling(false);
await waitFor(() =>
expect(
screen.getByRole('region', { name: 'Search results' }).scrollTop
).toBe(1280)
);
expect(
within(screen.getByRole('region', { name: 'Search results' }))
.getAllByRole('button')
.map((row) => row.textContent)
).toEqual(['Earlier update snippet', 'Weekly update snippet']);
expect(screen.getByRole('region', { name: 'Search results' }).scrollTop).toBe(
1280
);
expect(
screen.getByRole('button', { name: 'Weekly update snippet' })
).toBeTruthy();
});
it('reveals the same scrolled results when native Back uncovers search', () => {
mocks.fullTextItems = [
{
id: 'thread',
type: 'email',
name: 'Weekly update',
ownerId: 'owner',
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-02T00:00:00Z',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
},
];
mocks.hasMore = false;
SearchState.setQuery('teo');
SearchState.setCategory('email');
SearchState.searchFullText();
render(() => (
<>
<Show when={SearchState.isOpen()}>
<MobileSearchInput />
</Show>
<MobileSearchResults />
</>
));
const list = screen.getByRole('region', { name: 'Search results' });
fireEvent.scroll(list, { target: { scrollTop: 940 } });
fireEvent.click(
screen.getByRole('button', { name: 'Weekly update snippet' })
);
expect(screen.queryByPlaceholderText('Search…')).toBeNull();
mocks.setActive(true);
expect(screen.getByRole('region', { name: 'Search results' })).toBe(list);
expect(list.scrollTop).toBe(940);
const input = screen.getByPlaceholderText('Search…');
expect(input).toHaveProperty('value', 'teo');
expect(document.activeElement).not.toBe(input);
});
it('restores the name list order and scroll after opening promotes a result by recency', async () => {
mocks.hasMore = false;
const originalItems: QuickAccessItem[] = Array.from(
{ length: 100 },
(_, index) => ({
id: `project-${index}`,
kind: 'entity',
bucket: 'initiative',
data: {
id: `project-${index}`,
type: 'initiative',
name: `Project ${index}`,
ownerId: 'owner',
},
searchText: `Project ${index}`,
sortTimestamp: 0,
timestamps: {},
})
);
const [items, setItems] = createSignal(originalItems);
mocks.items = items;
mocks.onOpen = () =>
setItems([
originalItems[2],
...originalItems.filter((item) => item.id !== 'project-2'),
]);
SearchState.setQuery('Project');
SearchState.setCategory('projects');
const view = render(() => <MobileSearchResults />);
fireEvent.scroll(screen.getByRole('region', { name: 'Search results' }), {
target: { scrollTop: 800 },
});
const visibleResults = screen
.getAllByRole('button')
.map((row) => row.textContent);
fireEvent.click(screen.getByRole('button', { name: 'Project 2' }));
expect(screen.getAllByRole('button').map((row) => row.textContent)).toEqual(
visibleResults
);
// Native Back can uncover the same mounted list before any remount.
mocks.setActive(true);
expect(screen.getAllByRole('button').map((row) => row.textContent)).toEqual(
visibleResults
);
expect(mocks.entryState?.['mobileSearch.nameScroll']).toMatchObject({
offset: 800,
});
view.unmount();
mocks.setActive(true);
render(() => <MobileSearchResults />);
expect(SearchState.query()).toBe('Project');
expect(SearchState.category()).toBe('projects');
const restoredList = screen.getByRole('region', { name: 'Search results' });
await waitFor(() => expect(restoredList.scrollTop).toBe(800));
fireEvent.scroll(restoredList);
expect(screen.getByRole('button', { name: 'Project 2' })).toBeTruthy();
expect(mocks.entryState?.['mobileSearch.nameOrder']).toMatchObject({
ids: originalItems.map((item) => item.id),
});
expect(mocks.entryState?.['mobileSearch.nameScroll']).not.toHaveProperty(
'cache'
);
});
it.each(['before navigation', 'while away'])(
'keeps a person in place when their DM arrives %s',
async (arrival) => {
mocks.hasMore = false;
const people: UserItem[] = Array.from({ length: 100 }, (_, index) => ({
id: `macro|person-${index}@example.com`,
kind: 'user',
bucket: 'person',
searchText: `Person ${index}`,
sortTimestamp: 0,
timestamps: {},
data: {
id: `macro|person-${index}@example.com`,
email: `person-${index}@example.com`,
name: `Person ${index}`,
},
}));
const [conversations, setConversations] = createSignal<EntityItem[]>([]);
// Exercise the real person-to-conversation composition. A new DM is also
// promoted by recency, so its raw channel ID no longer occupies the old slot.
mocks.items = () =>
mergeCommandPeople(
[...conversations(), ...people],
conversations(),
'owner'
);
const publishConversation = () => {
setConversations([
{
id: 'new-dm',
kind: 'entity',
bucket: 'dm',
searchText: 'Person 2',
sortTimestamp: Date.now(),
timestamps: {},
data: {
id: 'new-dm',
type: 'channel',
name: 'Person 2',
ownerId: 'owner',
channelType: 'direct_message',
participantIds: ['owner', people[2].id],
},
},
]);
};
mocks.directMessage.mockImplementation(() => {
if (arrival === 'before navigation') publishConversation();
return okAsync('new-dm');
});
SearchState.setQuery('Person');
const view = render(() => <MobileSearchResults />);
const list = screen.getByRole('region', { name: 'Search results' });
fireEvent.scroll(list, { target: { scrollTop: 800 } });
const visiblePeople = () =>
within(screen.getByRole('region', { name: 'Search results' }))
.getAllByRole('button')
.map((row) => row.textContent?.match(/Person \d+/)?.[0]);
const before = visiblePeople();
fireEvent.click(screen.getByRole('button', { name: 'Person 2' }));
await waitFor(() => expect(mocks.open).toHaveBeenCalled());
mocks.setActive(true);
expect(visiblePeople()).toEqual(before);
expect(list.scrollTop).toBe(800);
view.unmount();
if (arrival === 'while away') publishConversation();
mocks.setActive(true);
render(() => <MobileSearchResults />);
const restored = screen.getByRole('region', { name: 'Search results' });
await waitFor(() => expect(restored.scrollTop).toBe(800));
fireEvent.scroll(restored);
// Remounting can add an overscan row above the viewport.
expect(visiblePeople()).toEqual(expect.arrayContaining(before));
expect(visiblePeople().indexOf('Person 3')).toBe(
visiblePeople().indexOf('Person 2') + 1
);
const person = within(restored).getByRole('button', { name: /Person 2$/ });
fireEvent.click(person);
await waitFor(() =>
expect(mocks.open).toHaveBeenLastCalledWith(
expect.objectContaining({ id: 'new-dm', type: 'channel' }),
expect.anything()
)
);
expect(mocks.directMessage).toHaveBeenCalledOnce();
}
);
it('reloads name rows on remount instead of storing them in history', async () => {
const savedItems: QuickAccessItem[] = Array.from(
{ length: 100 },
(_, index) => ({
id: `project-${index}`,
kind: 'entity',
bucket: 'initiative',
data: {
id: `project-${index}`,
type: 'initiative',
name: `Project ${index}`,
ownerId: 'owner',
},
searchText: `Project ${index}`,
sortTimestamp: 0,
timestamps: {},
})
);
const [items, setItems] = createSignal(savedItems);
const [loading, setLoading] = createSignal(false);
mocks.items = items;
mocks.loadingEntities = loading;
SearchState.setQuery('Project');
SearchState.setCategory('projects');
const view = render(() => <MobileSearchResults />);
fireEvent.scroll(screen.getByRole('region', { name: 'Search results' }), {
target: { scrollTop: 800 },
});
fireEvent.click(
within(screen.getByRole('region', { name: 'Search results' })).getAllByRole(
'button'
)[0]
);
expect(mocks.entryState?.['mobileSearch.nameOrder']).toEqual({
accountId: 'owner',
query: 'Project',
category: 'projects',
ids: savedItems.map((item) => item.id),
});
expect(mocks.entryState?.['mobileSearch.nameScroll']).not.toHaveProperty(
'cache'
);
view.unmount();
setLoading(true);
setItems([]);
mocks.setActive(true);
render(() => <MobileSearchResults />);
expect(screen.queryByRole('button', { name: 'Project 2' })).toBeNull();
expect(SearchState.query()).toBe('Project');
setItems(savedItems);
setLoading(false);
const restoredList = screen.getByRole('region', { name: 'Search results' });
await waitFor(() => expect(restoredList.scrollTop).toBe(800));
fireEvent.scroll(restoredList);
expect(screen.getByRole('button', { name: 'Project 2' })).toBeTruthy();
});
it('does not show a loading footer for available name results during a background lookup', () => {
mocks.items = () => [
{
id: 'project',
kind: 'entity',
bucket: 'initiative',
data: {
id: 'project',
type: 'initiative',
name: 'Project',
ownerId: 'owner',
},
searchText: 'Project',
sortTimestamp: 0,
timestamps: {},
},
];
mocks.loadingEntities = () => true;
render(() => <MobileSearchResults />);
expect(screen.getByRole('button', { name: 'Project' })).toBeTruthy();
expect(screen.queryByText('Loading…')).toBeNull();
});
it.each(['name', 'full-text'] as const)(
'keeps user scrolling after restoring %s results and resets it for another account',
async (mode) => {
const [accountId, setAccountId] = createSignal('owner');
const [authenticated, setAuthenticated] = createSignal(true);
mocks.accountId = accountId;
mocks.authenticated = authenticated;
const [nameItems, setNameItems] = createSignal<QuickAccessItem[]>([
{
id: 'first',
kind: 'entity',
bucket: 'initiative',
data: {
id: 'first',
type: 'initiative',
name: 'First',
ownerId: 'owner',
},
searchText: 'First',
sortTimestamp: 0,
timestamps: {},
},
{
id: 'second',
kind: 'entity',
bucket: 'initiative',
data: {
id: 'second',
type: 'initiative',
name: 'Second',
ownerId: 'owner',
},
searchText: 'Second',
sortTimestamp: 0,
timestamps: {},
},
]);
const [fullTextItems, setFullTextItems] = createSignal<EntityData[]>([
{
id: 'first',
type: 'email',
name: 'First',
ownerId: 'owner',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
},
{
id: 'second',
type: 'email',
name: 'Second',
ownerId: 'owner',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
},
]);
mocks.items = nameItems;
mocks.fullTextData = fullTextItems;
vi.spyOn(HTMLElement.prototype, 'scrollHeight', 'get').mockReturnValue(800);
vi.spyOn(HTMLElement.prototype, 'clientHeight', 'get').mockImplementation(
() => mocks.viewportHeight
);
SearchState.setQuery('First');
if (mode === 'full-text') SearchState.searchFullText();
const view = render(() => <MobileSearchResults />);
fireEvent.scroll(screen.getByRole('region', { name: 'Search results' }), {
target: { scrollTop: 300 },
});
fireEvent.click(
screen.getByRole('button', {
name: mode === 'name' ? 'First' : 'First snippet',
})
);
view.unmount();
// A taller viewport cannot reach the previously saved offset yet.
mocks.viewportHeight = 600;
mocks.setActive(true);
render(() => <MobileSearchResults />);
const list = screen.getByRole('region', { name: 'Search results' });
if (mode === 'full-text')
await waitFor(() => expect(list.scrollTop).toBe(300));
fireEvent.wheel(list);
// Simulate the browser clamping the initial offset to the new scroll range.
fireEvent.scroll(list, { target: { scrollTop: 200 } });
fireEvent.scroll(list, { target: { scrollTop: 100 } });
setNameItems([
{ ...nameItems()[0], searchText: 'Updated first' },
nameItems()[1],
{ ...nameItems()[0], id: 'third', searchText: 'Third' },
]);
setFullTextItems([
{ ...fullTextItems()[0], name: 'Updated first' },
fullTextItems()[1],
{ ...fullTextItems()[0], id: 'third', name: 'Third' },
]);
await waitFor(() =>
expect(
screen.getByRole('button', {
name: mode === 'name' ? 'Updated first' : 'Updated first snippet',
})
).toBeTruthy()
);
expect(list.scrollTop).toBe(100);
fireEvent.click(
screen.getByRole('button', {
name: mode === 'name' ? 'Updated first' : 'Updated first snippet',
})
);
const scroll =
mocks.entryState?.[
mode === 'name'
? 'mobileSearch.nameScroll'
: 'mobileSearch.fullTextScroll'
];
expect(scroll).toMatchObject({ offset: 100 });
mocks.setActive(true);
setAccountId('another-account');
const nextList = screen.getByRole('region', { name: 'Search results' });
expect(nextList).not.toBe(list);
expect(nextList.scrollTop).toBe(0);
cleanup();
render(() => <MobileSearchResults />);
expect(
screen.getByRole('region', { name: 'Search results' }).scrollTop
).toBe(0);
setAuthenticated(false);
expect(screen.queryByRole('region', { name: 'Search results' })).toBeNull();
}
);
it('does not revive saved name rows after a failed refresh or successful empty result', () => {
const [items, setItems] = createSignal<QuickAccessItem[]>([
{
id: 'project',
kind: 'entity',
bucket: 'initiative',
data: {
id: 'project',
type: 'initiative',
name: 'Project',
ownerId: 'owner',
},
searchText: 'Project',
sortTimestamp: 0,
timestamps: {},
},
]);
const [loading, setLoading] = createSignal(false);
const [failed, setFailed] = createSignal(false);
mocks.items = items;
mocks.loadingEntities = loading;
mocks.refreshError = failed;
mocks.hasMore = false;
SearchState.setQuery('Project');
SearchState.setCategory('projects');
const view = render(() => <MobileSearchResults />);
fireEvent.click(screen.getByRole('button', { name: 'Project' }));
view.unmount();
setLoading(true);
setItems([]);
mocks.setActive(true);
render(() => <MobileSearchResults />);
setFailed(true);
setLoading(false);
expect(screen.queryByRole('button', { name: 'Project' })).toBeNull();
expect(mocks.loadMore).not.toHaveBeenCalled();
setLoading(true);
setFailed(false);
setLoading(false);
expect(screen.queryByRole('button', { name: 'Project' })).toBeNull();
expect(screen.getByText('No results')).toBeTruthy();
});
it('discards saved full-text rows on access loss even when an old cursor remains', () => {
const [items, setItems] = createSignal<EntityData[]>([
{
id: 'thread',
type: 'email',
name: 'Weekly update',
ownerId: 'owner',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
},
]);
mocks.fullTextData = items;
const [error, setError] = createSignal<Error>();
mocks.fullTextError = error;
SearchState.setQuery('teo');
SearchState.searchFullText();
render(() => <MobileSearchResults />);
expect(
screen.getByRole('button', { name: 'Weekly update snippet' })
).toBeTruthy();
setError(new Error('Network unavailable'));
expect(
screen.getByRole('button', { name: 'Weekly update snippet' })
).toBeTruthy();
setError(
new CombinedError({
graphQLErrors: [
{ message: 'Forbidden', extensions: { code: 'FORBIDDEN' } },
],
})
);
// The real service source removes rows after an authoritative failure.
setItems([]);
expect(
screen.queryByRole('button', { name: 'Weekly update snippet' })
).toBeNull();
expect(mocks.fetchNextPage).not.toHaveBeenCalled();
});
it('keeps a covered native search entry independent of a new dock session', () => {
SearchState.setQuery('original');
SearchState.setCategory('email');
render(() => <MobileSearchResults />);
mocks.setActive(false);
expect(SearchState.isOpen()).toBe(false);
SearchState.open();
SearchState.setQuery('new search');
SearchState.setCategory('tasks');
expect(
screen.getByRole('button', { name: 'Email' }).getAttribute('aria-pressed')
).toBe('true');
expect(
screen.getByRole('button', { name: 'Tasks' }).getAttribute('aria-pressed')
).toBe('false');
fireEvent.click(screen.getByRole('button', { name: 'Files' }));
expect(SearchState.category()).toBe('tasks');
mocks.setActive(true);
expect(SearchState.query()).toBe('original');
expect(SearchState.category()).toBe('documents');
});
it('loads another name page near the end without a persistent paging bar', async () => {
mocks.items = () =>
Array.from({ length: 100 }, (_, index) => ({
id: `project-${index}`,
kind: 'entity',
bucket: 'initiative',
data: {
id: `project-${index}`,
type: 'initiative',
name: `Project ${index}`,
ownerId: 'owner',
},
searchText: `Project ${index}`,
sortTimestamp: 0,
timestamps: {},
}));
render(() => <MobileSearchResults />);
expect(screen.queryByRole('button', { name: 'Load more' })).toBeNull();
const list = screen.getByRole('region', { name: 'Search results' });
fireEvent.scroll(list, { target: { scrollTop: 1 } });
expect(mocks.loadMore).not.toHaveBeenCalled();
fireEvent.scroll(list, { target: { scrollTop: 100000 } });
await waitFor(() => expect(mocks.loadMore).toHaveBeenCalledOnce());
mocks.loadingMore = true;
fireEvent.scroll(list, { target: { scrollTop: 100001 } });
expect(mocks.loadMore).toHaveBeenCalledOnce();
mocks.loadingMore = false;
mocks.hasMore = false;
fireEvent.scroll(list, { target: { scrollTop: 100002 } });
expect(mocks.loadMore).toHaveBeenCalledOnce();
});
it('loads full-text pages near the end without a persistent paging bar', () => {
SearchState.setQuery('teo');
SearchState.searchFullText();
render(() => <MobileSearchResults />);
expect(screen.queryByRole('button', { name: 'Load more' })).toBeNull();
const list = screen.getByRole('region', { name: 'Search results' });
Object.defineProperties(list, {
scrollHeight: { value: 2000 },
clientHeight: { value: 400 },
});
fireEvent.scroll(list, { target: { scrollTop: 100 } });
expect(mocks.fetchNextPage).not.toHaveBeenCalled();
fireEvent.scroll(list, { target: { scrollTop: 1550 } });
expect(mocks.fetchNextPage).toHaveBeenCalledOnce();
mocks.loadingMore = true;
fireEvent.scroll(list, { target: { scrollTop: 1551 } });
expect(mocks.fetchNextPage).toHaveBeenCalledOnce();
mocks.loadingMore = false;
mocks.hasMore = false;
fireEvent.scroll(list, { target: { scrollTop: 1552 } });
expect(mocks.fetchNextPage).toHaveBeenCalledOnce();
});
it('fills an empty name page without requiring a scroll and stops once rows fill the viewport', async () => {
const [items, setItems] = createSignal<QuickAccessItem[]>([]);
mocks.items = items;
mocks.loadMore.mockImplementationOnce(async () => {
setItems([]);
});
mocks.loadMore.mockImplementationOnce(async () => {
setItems(
Array.from({ length: 100 }, (_, index) => ({
id: `project-${index}`,
kind: 'entity',
bucket: 'initiative',
data: {
id: `project-${index}`,
type: 'initiative',
name: `Project ${index}`,
ownerId: 'owner',
},
searchText: `Project ${index}`,
sortTimestamp: 0,
timestamps: {},
}))
);
});
render(() => <MobileSearchResults />);
await waitFor(() =>
expect(screen.getByRole('button', { name: 'Project 0' })).toBeTruthy()
);
expect(mocks.loadMore).toHaveBeenCalledTimes(2);
});
it('does not automatically retry an unchanged empty page or fetch after closing', async () => {
const view = render(() => <MobileSearchResults />);
await waitFor(() => expect(mocks.loadMore).toHaveBeenCalledOnce());
view.unmount();
render(() => <MobileSearchResults />).unmount();
await Promise.resolve();
expect(mocks.loadMore).toHaveBeenCalledOnce();
});
it('fills empty full-text pages until pagination is exhausted', async () => {
const [items, setItems] = createSignal<EntityData[]>([]);
mocks.fullTextData = items;
mocks.fetchNextPage.mockImplementationOnce(async () => {
setItems([]);
});
mocks.fetchNextPage.mockImplementationOnce(async () => {
mocks.hasMore = false;
setItems([]);
});
SearchState.setQuery('teo');
SearchState.searchFullText();
render(() => <MobileSearchResults />);
await waitFor(() => expect(mocks.fetchNextPage).toHaveBeenCalledTimes(2));
});
it('uses current source rows during refresh and keeps row identity when pages append', () => {
const email: EntityData = {
id: 'thread',
type: 'email',
name: 'Weekly update',
ownerId: 'owner',
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-02T00:00:00Z',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
};
const [items, setItems] = createSignal<EntityData[]>([email]);
const [loading, setLoading] = createSignal(false);
const [settling, setSettling] = createSignal(false);
mocks.fullTextData = items;
mocks.fullTextLoading = loading;
mocks.fullTextSettling = () => loading() || settling();
SearchState.setQuery('teo');
SearchState.searchFullText();
render(() => <MobileSearchResults />);
setLoading(true);
setItems([]);
expect(
screen.queryByRole('button', { name: 'Weekly update snippet' })
).toBeNull();
setItems([email]);
setLoading(false);
const refreshedRow = screen.getByRole('button', {
name: 'Weekly update snippet',
});
// Service page selection rematerializes existing entities when it appends.
setItems([
{ ...email, name: 'Updated subject' },
{ ...email, id: 'next', name: 'Next page' },
]);
expect(screen.getByRole('button', { name: 'Updated subject snippet' })).toBe(
refreshedRow
);
expect(
screen.getByRole('button', { name: 'Next page snippet' })
).toBeTruthy();
// The real source keeps old rows briefly while the new query debounces.
setSettling(true);
SearchState.setQuery('different');
expect(
screen.queryByRole('button', { name: 'Updated subject snippet' })
).toBeNull();
});
it('keeps a full-text top-of-list anchor below the mobile safe-area padding', async () => {
mocks.fullTextItems = [
{
id: 'first',
type: 'email',
name: 'First',
ownerId: 'owner',
isRead: true,
isDraft: false,
isImportant: false,
done: false,
},
];
mocks.hasMore = false;
SearchState.setQuery('First');
SearchState.searchFullText();
vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(
function (this: HTMLElement) {
return new DOMRect(0, this.dataset.mobileSearchId ? 80 : 0, 390, 64);
}
);
const view = render(() => <MobileSearchResults />);
fireEvent.click(screen.getByRole('button', { name: 'First snippet' }));
expect(mocks.entryState?.['mobileSearch.fullTextScroll']).toMatchObject({
id: 'first',
offset: 0,
within: -80,
});
view.unmount();
mocks.setActive(true);
render(() => <MobileSearchResults />);
await waitFor(() =>
expect(
screen.getByRole('region', { name: 'Search results' }).scrollTop
).toBe(0)
);
await Promise.resolve();
expect(screen.getByRole('region', { name: 'Search results' }).scrollTop).toBe(
0
);
});
it('resumes viewport paging when editing a restored search in the dock', async () => {
mocks.items = () => [
{
id: 'first',
kind: 'entity',
bucket: 'initiative',
data: {
id: 'first',
type: 'initiative',
name: 'First',
ownerId: 'owner',
},
searchText: 'First',
sortTimestamp: 0,
timestamps: {},
},
];
mocks.entryState = {
'mobileSearch.session': {
query: 'First',
category: 'projects',
mode: 'name',
},
'mobileSearch.nameScroll': {
accountId: 'owner',
query: 'First',
category: 'projects',
id: 'first',
offset: 0,
within: 0,
},
};
render(() => <MobileSearchResults />);
await Promise.resolve();
expect(mocks.loadMore).not.toHaveBeenCalled();
SearchState.setQuery('Next');
await waitFor(() => expect(mocks.loadMore).toHaveBeenCalledOnce());
});