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 { toast } from '@core/component/Toast/Toast';
import { fetchWithToken } from '@core/util/fetchWithToken';
import { queryClient } from '@queries/client';
import { databasesKeys } from '@queries/storage/keys';
import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
import {
cleanup,
fireEvent,
render,
screen,
waitFor,
} from '@solidjs/testing-library';
import { QueryObserver } from '@tanstack/solid-query';
import { err, ok } from 'neverthrow';
import { createSignal, onCleanup } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TableTabs } from './TableTabs';
vi.mock('@core/mobile/isMobile', () => ({ isMobile: () => false }));
vi.mock('@core/util/fetchWithToken', () => ({ fetchWithToken: vi.fn() }));
vi.mock('@core/component/Toast/Toast', () => ({
toast: { failure: vi.fn(), success: vi.fn() },
}));
vi.mock('@service-storage/client', async () => {
const { databasesClient } = await import('@service-storage/databases');
return { storageServiceClient: { databases: databasesClient } };
});
// The forms chip and warnings are off here: no forms list loads.
vi.mock('@queries/storage/forms', () => ({
useFormsForDatabaseQuery: () => ({
isSuccess: false,
isError: false,
fetchStatus: 'idle',
data: undefined,
}),
}));
vi.mock('@queries/client', async () => {
const { QueryClient } = await import('@tanstack/solid-query');
return {
queryClient: new QueryClient({
defaultOptions: { queries: { retry: false } },
}),
};
});
const fetch = vi.mocked(fetchWithToken);
const key = databasesKeys.detail('db').queryKey;
const detail: DatabaseDetail = {
database: {
id: 'db',
name: 'Offsite',
owner_id: 'owner',
created_at: '',
trashed_at: null,
project_id: null,
},
grant: 'owner',
tables: [
{
views: [],
table: {
id: 'guests',
database_id: 'db',
name: 'Guests',
position: '000000000001',
version: 3,
},
sql_name: '"Guests"',
columns: [],
},
{
views: [],
table: {
id: 'budget',
database_id: 'db',
name: 'Budget',
position: '000000000002',
version: 1,
},
sql_name: '"Budget"',
columns: [],
},
{
views: [],
table: {
id: 'venues',
database_id: 'db',
name: 'Venues',
position: '000000000003',
version: 0,
},
sql_name: '"Venues"',
columns: [],
},
],
};
function renderTabs() {
render(() => {
const [cached, setCached] = createSignal(
queryClient.getQueryData<DatabaseDetail>(key)
);
onCleanup(
queryClient
.getQueryCache()
.subscribe(() => setCached(queryClient.getQueryData(key)))
);
return (
<TableTabs
databaseId="db"
tables={cached()?.tables ?? []}
activeTableId="guests"
canEdit
onSelect={vi.fn()}
/>
);
});
}
function tabNames() {
return screen.getAllByRole('tab').map((tab) => tab.textContent);
}
async function chooseMenuItem(tabName: string, item: string) {
fireEvent.contextMenu(screen.getByRole('tab', { name: tabName }), {
clientX: 100,
clientY: 40,
});
fireEvent(
await screen.findByRole('menuitem', { name: item }),
new MouseEvent('pointerup', { button: 0, bubbles: true })
);
}
let menuStyles: HTMLStyleElement;
beforeEach(() => {
vi.stubGlobal('scrollTo', vi.fn());
vi.stubGlobal(
'ResizeObserver',
class {
observe() {}
unobserve() {}
disconnect() {}
}
);
menuStyles = document.createElement('style');
menuStyles.textContent = '[role=menu] { animation-name: none; }';
document.head.append(menuStyles);
fetch.mockReset();
vi.mocked(toast.failure).mockReset();
queryClient.setQueryData(key, detail);
});
afterEach(() => {
cleanup();
menuStyles.remove();
queryClient.clear();
vi.unstubAllGlobals();
});
describe('reordering tabs', () => {
it('moves a tab right from its menu, sends the full order, and keeps it', async () => {
fetch.mockResolvedValue(
ok({
results: [
{
kind: 'reorder_tables',
tables: [
{ table: 'budget', version: 2 },
{ table: 'guests', version: 4 },
{ table: 'venues', version: 1 },
],
},
],
changes: [],
})
);
renderTabs();
expect(tabNames()).toEqual(['Guests', 'Budget', 'Venues']);
fireEvent.contextMenu(screen.getByRole('tab', { name: 'Guests' }), {
clientX: 100,
clientY: 40,
});
expect(
(await screen.findByRole('menuitem', { name: 'Move left' })).getAttribute(
'aria-disabled'
)
).toBe('true');
fireEvent(
screen.getByRole('menuitem', { name: 'Move right' }),
new MouseEvent('pointerup', { button: 0, bubbles: true })
);
await waitFor(() =>
expect(tabNames()).toEqual(['Budget', 'Guests', 'Venues'])
);
await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
const [url, init] = fetch.mock.calls[0];
expect(url).toMatch(/\/databases\/db\/ops$/);
expect(init?.method).toBe('POST');
expect(init?.body).toBe(
JSON.stringify({
ops: [
{ kind: 'reorder_tables', order: ['budget', 'guests', 'venues'] },
],
})
);
await waitFor(() =>
expect(
queryClient
.getQueryData<DatabaseDetail>(key)
?.tables.map((entry) => [entry.table.id, entry.table.version])
).toEqual([
['budget', 2],
['guests', 4],
['venues', 1],
])
);
expect(tabNames()).toEqual(['Budget', 'Guests', 'Venues']);
expect(toast.failure).not.toHaveBeenCalled();
});
it('disables Move right on the last tab', async () => {
renderTabs();
fireEvent.contextMenu(screen.getByRole('tab', { name: 'Venues' }), {
clientX: 100,
clientY: 40,
});
expect(
(
await screen.findByRole('menuitem', { name: 'Move right' })
).getAttribute('aria-disabled')
).toBe('true');
expect(
screen
.getByRole('menuitem', { name: 'Move left' })
.getAttribute('aria-disabled')
).not.toBe('true');
});
it('puts the tabs back and says so when the server refuses the order', async () => {
fetch.mockResolvedValue(
err([
{
code: 'INVALID_OP',
message: 'The table order must include every table',
},
])
);
renderTabs();
await chooseMenuItem('Venues', 'Move left');
await waitFor(() => expect(toast.failure).toHaveBeenCalledOnce());
expect(fetch.mock.calls[0][1]?.body).toBe(
JSON.stringify({
ops: [
{ kind: 'reorder_tables', order: ['guests', 'venues', 'budget'] },
],
})
);
await waitFor(() =>
expect(tabNames()).toEqual(['Guests', 'Budget', 'Venues'])
);
expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
});
describe('deleting a table', () => {
it('asks first, then sends one delete op for that table and drops its tab', async () => {
fetch.mockResolvedValue(
ok({
results: [
{ kind: 'table', table: 'budget', change: { kind: 'deleted' } },
],
changes: [{ table: 'budget', version: 2, change: 1 }],
})
);
renderTabs();
await chooseMenuItem('Budget', 'Delete table');
const dialog = await screen.findByRole('dialog');
expect(dialog.textContent).toContain('“Budget”');
expect(fetch).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole('button', { name: 'Delete table' }));
await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
const [url, init] = fetch.mock.calls[0];
expect(url).toMatch(/\/databases\/db\/ops$/);
expect(init?.method).toBe('POST');
expect(init?.body).toBe(
JSON.stringify({
ops: [{ kind: 'table', table: 'budget', change: { kind: 'delete' } }],
})
);
await waitFor(() => expect(tabNames()).toEqual(['Guests', 'Venues']));
expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
it('refuses to delete the only table', async () => {
queryClient.setQueryData(key, { ...detail, tables: [detail.tables[0]] });
renderTabs();
fireEvent.contextMenu(screen.getByRole('tab', { name: 'Guests' }), {
clientX: 100,
clientY: 40,
});
const item = await screen.findByRole('menuitem', { name: 'Delete table' });
expect(item.getAttribute('aria-disabled')).toBe('true');
fireEvent(item, new MouseEvent('pointerup', { button: 0, bubbles: true }));
expect(screen.queryByRole('dialog')).toBeNull();
expect(fetch).not.toHaveBeenCalled();
});
});
it('shows a rename before commit and cancels an older schema read', async () => {
let releaseRead!: (value: DatabaseDetail) => void;
const staleRead = queryClient.fetchQuery({
queryKey: key,
queryFn: () =>
new Promise<DatabaseDetail>((resolve) => {
releaseRead = resolve;
}),
staleTime: 0,
});
const settled = Promise.allSettled([staleRead]);
let releaseWrite!: () => void;
fetch.mockImplementationOnce(async () => {
await new Promise<void>((resolve) => {
releaseWrite = resolve;
});
return ok({
results: [
{
kind: 'table',
table: 'guests',
tableVersion: 4,
change: { kind: 'renamed' },
},
],
changes: [],
});
});
renderTabs();
fireEvent.dblClick(screen.getByRole('tab', { name: 'Guests' }));
const input = screen.getByRole('textbox', { name: 'Table name' });
fireEvent.input(input, { target: { value: 'Attendees' } });
fireEvent.keyDown(input, { key: 'Enter' });
await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
expect(
queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.name
).toBe('Attendees');
releaseWrite();
await screen.findByRole('tab', { name: 'Attendees' });
releaseRead(detail);
await settled;
expect(
queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.name
).toBe('Attendees');
});
it('refreshes a refused optimistic rename back to server state', async () => {
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: async () => detail,
staleTime: Infinity,
});
const unsubscribe = observer.subscribe(() => {});
try {
fetch.mockResolvedValue(
err([{ code: 'CONFLICT', message: 'The table changed.' }])
);
renderTabs();
fireEvent.dblClick(screen.getByRole('tab', { name: 'Guests' }));
const input = screen.getByRole('textbox', { name: 'Table name' });
fireEvent.input(input, { target: { value: 'Attendees' } });
fireEvent.keyDown(input, { key: 'Enter' });
await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
await waitFor(() =>
expect(
queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.name
).toBe('Guests')
);
} finally {
unsubscribe();
}
});
it('restores a refused deletion even when its recovery read fails', async () => {
const observer = new QueryObserver(queryClient, {
queryKey: key,
queryFn: async (): Promise<DatabaseDetail> => {
throw new Error('Offline');
},
staleTime: Infinity,
retry: false,
});
const unsubscribe = observer.subscribe(() => {});
try {
fetch.mockResolvedValue(
err([{ code: 'UNKNOWN_ERROR', message: 'Offline' }])
);
renderTabs();
await chooseMenuItem('Budget', 'Delete table');
await screen.findByRole('dialog');
fireEvent.click(screen.getByRole('button', { name: 'Delete table' }));
await waitFor(() => expect(toast.failure).toHaveBeenCalledOnce());
await waitFor(() =>
expect(tabNames()).toEqual(['Guests', 'Budget', 'Venues'])
);
await waitFor(() =>
expect(queryClient.getQueryState(key)?.status).toBe('error')
);
} finally {
unsubscribe();
}
});