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 { createRoot, createSignal } from 'solid-js';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { createCalendarEventFormController } from '../components/composer/create-calendar-event-form-controller';
import {
calendarEventToEditorInitialValues,
type EventEditorSubmitValues,
} from '../components/composer/event-form-model';
import { type CalendarEvent, DEFAULT_GUEST_POLICY } from '../types';
import { useEventEditor } from './use-event-editor';
const mocks = vi.hoisted(() => ({
createEvent: vi.fn(),
createMeeting: vi.fn(),
failure: vi.fn(),
alert: vi.fn(),
updateEvent: vi.fn(),
inviteGuests: vi.fn(),
updateMeeting: vi.fn(),
fetchMeeting: vi.fn(),
quickCalls: true,
quickCallsLoading: false,
}));
vi.mock('@core/util/webOrigin', () => ({
getWebOrigin: () => 'https://macro.com',
}));
vi.mock('@core/component/Toast/Toast', () => ({
toast: { failure: mocks.failure, alert: mocks.alert },
}));
vi.mock('@core/user', () => ({
useContacts: () => () => [],
recipientEntityMapper: () => (value: unknown) => value,
}));
vi.mock('@queries/calendar/calendars', () => ({
useVisibleCalendarsQuery: () => ({ data: [], isSuccess: true }),
}));
vi.mock('@queries/calendar/mutations', () => ({
useCreateCalendarEventMutation: () => ({
mutateAsync: mocks.createEvent,
isPending: false,
}),
useUpdateCalendarEventMutation: () => ({
mutateAsync: mocks.updateEvent,
isPending: false,
}),
useInviteCalendarEventGuestsMutation: () => ({
mutateAsync: mocks.inviteGuests,
isPending: false,
}),
isGuestEditRefused: (error: unknown) =>
(error as { code?: string }).code === 'guests_cannot_modify',
}));
vi.mock('@queries/call/meetings', () => ({
useCreateMeetingMutation: () => ({ mutateAsync: mocks.createMeeting }),
useUpdateMeetingMutation: () => ({ mutateAsync: mocks.updateMeeting }),
fetchMeeting: mocks.fetchMeeting,
}));
const values: EventEditorSubmitValues = {
title: 'Planning',
time: {
kind: 'timed',
startsAt: '2026-09-22T14:00:00Z',
endsAt: '2026-09-22T15:00:00Z',
timeZone: 'America/New_York',
},
location: 'Meeting room',
description: '<p>Roadmap discussion</p>',
conferenceChoice: 'macro',
guestEmails: ['[email protected]'],
};
const savedEvent: CalendarEvent = {
id: 'event-1',
eventId: 'event-1',
occurrenceKey: '2026-09-22T14:00:00Z',
isCancelled: false,
isReadOnly: false,
guestPolicy: DEFAULT_GUEST_POLICY,
// The viewer's own event with no guests yet: they organize it.
viewerCan: {
editDetails: true,
inviteGuests: true,
removeGuests: true,
setGuestPolicy: true,
rsvp: false,
organize: true,
},
attendees: [],
recurrenceLines: [],
title: 'Planning',
start: '2026-09-22T14:00:00Z',
end: '2026-09-22T15:00:00Z',
allDay: false,
sourceCalendarIds: ['calendar-1'],
calendarId: 'calendar-1',
calendar: { id: 'calendar-1', name: 'Calendar', color: '#336699' },
visibleCalendars: [],
location: 'https://macro.com/app/meet/8m8mGwzHqxzYjeIN5-nJRquRbzyTEhGF',
};
beforeEach(() => {
vi.clearAllMocks();
mocks.quickCalls = true;
mocks.quickCallsLoading = false;
mocks.createEvent.mockResolvedValue({
id: 'event-1',
calendarId: 'calendar-1',
});
mocks.updateEvent.mockResolvedValue({ id: 'event-1' });
mocks.inviteGuests.mockResolvedValue({ id: 'event-1' });
mocks.createMeeting.mockResolvedValue({
shareToken: '8m8mGwzHqxzYjeIN5-nJRquRbzyTEhGF',
});
mocks.fetchMeeting.mockResolvedValue({ id: 'meeting-1' });
mocks.updateMeeting.mockResolvedValue({ id: 'meeting-1' });
});
describe('editing event times', () => {
function editorFor(
overrides: Partial<CalendarEvent> = {},
macroCallsEnabled = false
) {
return createRoot((dispose) => {
const event: CalendarEvent = {
...savedEvent,
location: '',
recurrenceLines: ['RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR'],
reminders: {
useDefault: false,
overrides: [{ method: 'popup', minutes: 10 }],
},
...overrides,
};
const onSaved = vi.fn();
const editor = useEventEditor({
event: () => event,
onSaved,
macroCallsEnabled: () => macroCallsEnabled,
});
const form = createCalendarEventFormController({
initialValue: calendarEventToEditorInitialValues(event),
isEdit: true,
calendarOptions: editor.calendarOptions,
guestOptions: () => [],
});
return { editor, form, event, onSaved, dispose };
});
}
it('syncs an existing point call title without writing a zero-duration schedule', async () => {
const { editor, form, dispose } = editorFor(
{
start: savedEvent.start,
end: savedEvent.start,
location: savedEvent.location,
},
true
);
try {
form.setField('title', 'Updated point call');
await editor.save(form.submitValues()!);
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
title: 'Updated point call',
});
expect(mocks.updateMeeting).toHaveBeenCalledWith({
meetingId: 'meeting-1',
title: 'Updated point call',
});
expect(editor.saveError()).toBeUndefined();
expect(mocks.alert).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('syncs a positive schedule when an imported point gains duration', async () => {
const { editor, form, dispose } = editorFor(
{
start: savedEvent.start,
end: savedEvent.start,
location: savedEvent.location,
},
true
);
try {
form.setField('end', form.state().end.replace('14:00', '15:00'));
const submitted = form.submitValues()!;
expect(submitted.time.kind).toBe('timed');
await editor.save(submitted);
expect(mocks.updateMeeting).toHaveBeenCalledWith({
meetingId: 'meeting-1',
title: 'Planning',
scheduledStart: '2026-09-22T14:00:00.000Z',
scheduledEnd: '2026-09-22T15:00:00.000Z',
});
} finally {
dispose();
}
});
it('rejects adding a point call before any calendar or meeting mutation', async () => {
const { editor, form, onSaved, dispose } = editorFor(
{
start: savedEvent.start,
end: savedEvent.start,
},
true
);
try {
form.setField('conference', 'macro');
form.setField('title', 'A new point call');
await editor.save(form.submitValues()!);
expect(editor.saveError()).toBe(
'Give this event a duration before adding a Macro call.'
);
expect(editor.pending()).toBe(false);
expect(mocks.updateEvent).not.toHaveBeenCalled();
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
expect(onSaved).not.toHaveBeenCalled();
} finally {
dispose();
}
});
describe.each(['all', 'this_event'] as const)('%s scope', (scope) => {
it('edits imported point metadata without sending a time patch', async () => {
const { editor, form, dispose } = editorFor({
start: '2026-09-22T10:00:37-04:00',
end: '2026-09-22T10:00:37-04:00',
});
try {
form.setField('title', 'Updated point title');
expect(form.canSave()).toBe(true);
expect(form.dateRangeError()).toBeUndefined();
const submitted = form.submitValues();
expect(submitted?.time).toMatchObject({
startsAt: '2026-09-22T10:00:37-04:00',
endsAt: '2026-09-22T10:00:37-04:00',
});
await editor.save(submitted!, scope);
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
title: 'Updated point title',
});
} finally {
dispose();
}
});
it('requires positive duration when changing an imported point time', () => {
const { form, dispose } = editorFor({
start: '2026-09-22T14:00:00Z',
end: '2026-09-22T14:00:00Z',
});
try {
form.setField('start', '2026-09-23T14:00');
form.setField('end', '2026-09-23T14:00');
expect(form.canSave()).toBe(false);
expect(form.submitValues()).toBeUndefined();
expect(form.dateRangeError()).toBe(
'End time must be after the start time.'
);
form.setField('end', '2026-09-23T14:30');
expect(form.canSave()).toBe(true);
} finally {
dispose();
}
});
it.each([
'RRULE:FREQ=WEEKLY;WKST=SU;INTERVAL=1;BYDAY=MO,TU,WE,TH,FR',
'RRULE:BYDAY=FR,TH,WE,TU,MO;FREQ=WEEKLY',
'RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR;UNTIL=20261231T180000Z',
])('removes only reminders without rewriting %s', async (rule) => {
const { editor, form, onSaved, dispose } = editorFor({
recurrenceLines: [rule],
});
try {
form.setReminderMinutes([]);
await editor.save(form.submitValues()!, scope);
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
reminders: { useDefault: false, overrides: [] },
});
expect(onSaved).toHaveBeenCalledOnce();
} finally {
dispose();
}
});
it.each([
{ label: 'timed', overrides: {} },
{
label: 'timed with seconds and an explicit offset',
overrides: {
start: '2026-09-22T10:00:37-04:00',
end: '2026-09-22T11:00:42-04:00',
},
},
{
label: 'all-day',
overrides: {
allDay: true,
start: '2026-09-22',
end: '2026-09-24',
},
},
])(
'preserves $label timing when only reminders change',
async ({ overrides }) => {
const { editor, form, event, onSaved, dispose } = editorFor(overrides);
try {
form.setReminderMinutes([5]);
const submitted = form.submitValues();
expect(submitted).toBeDefined();
await editor.save(submitted!, scope);
expect(mocks.updateEvent).toHaveBeenCalledOnce();
const request = mocks.updateEvent.mock.lastCall?.[0];
expect(request.scope).toBe(scope);
expect(request.recurrenceId).toBe(
scope === 'this_event' ? event.occurrenceKey : undefined
);
expect(request.patch).toEqual({
reminders: {
useDefault: false,
overrides: [{ method: 'popup', minutes: 5 }],
},
});
expect(onSaved).toHaveBeenCalledOnce();
expect(mocks.failure).not.toHaveBeenCalled();
} finally {
dispose();
}
}
);
it.each(['start', 'end', 'allDay'] as const)(
'still sends intentional %s changes',
async (field) => {
const { editor, form, dispose } = editorFor();
try {
if (field === 'allDay') form.setAllDay(true);
else if (field === 'start') form.setStart('2026-09-21T18:00');
else form.setField('end', '2026-10-01T18:30');
const submitted = form.submitValues();
expect(submitted).toBeDefined();
await editor.save(submitted!, scope);
expect(mocks.updateEvent.mock.lastCall?.[0].patch.time).toEqual(
submitted!.time
);
} finally {
dispose();
}
}
);
});
it.each([
{
label: 'Google Meet',
conferenceUrl: 'https://meet.google.com/abc-defg-hij',
conferenceProvider: 'google_meet' as const,
location: 'Meeting room',
description: '<p>Deploy checklist</p>',
},
{ label: 'Macro call', location: savedEvent.location },
])('sends only reminders on an invited $label event', async (overrides) => {
const { editor, form, onSaved, dispose } = editorFor({
...overrides,
attendees: [
{
email: '[email protected]',
isOrganizer: true,
isSelf: false,
isOptional: false,
responseStatus: 'accepted',
},
{
email: '[email protected]',
isOrganizer: false,
isSelf: true,
isOptional: false,
responseStatus: 'accepted',
},
],
});
mocks.updateEvent.mockImplementationOnce(async ({ patch }) => {
if (Object.keys(patch).some((field) => field !== 'reminders')) {
throw new Error('Forbidden');
}
return { id: 'event-1' };
});
try {
form.setReminderMinutes([5]);
await editor.save(form.submitValues()!, 'all');
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(onSaved).toHaveBeenCalledOnce();
expect(mocks.failure).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('closes an unchanged event without sending an empty patch', async () => {
const { editor, form, onSaved, dispose } = editorFor();
try {
await editor.save(form.submitValues()!, 'all');
expect(mocks.updateEvent).not.toHaveBeenCalled();
expect(onSaved).toHaveBeenCalledOnce();
} finally {
dispose();
}
});
it.each(['title', 'location', 'description'] as const)(
'still sends intentional %s edits and clearing',
async (field) => {
const { editor, form, dispose } = editorFor({
title: 'Prod Deploy',
location: 'Meeting room',
description: '<p>Checklist</p>',
});
try {
form.setField(field, field === 'title' ? 'Updated deploy' : '');
await editor.save(form.submitValues()!, 'all');
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
[field]: field === 'title' ? 'Updated deploy' : '',
});
} finally {
dispose();
}
}
);
});
describe('scheduling a Macro call', () => {
it.each(['off', 'loading'] as const)(
'saves a calendar event without creating a call when the flag is %s',
async (state) => {
mocks.quickCalls = state === 'loading';
mocks.quickCallsLoading = state === 'loading';
const saved = vi.fn();
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: saved,
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(mocks.createEvent).toHaveBeenCalledOnce();
expect(mocks.createEvent.mock.calls[0]?.[0]).not.toHaveProperty(
'macroCall'
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
expect(saved).toHaveBeenCalledOnce();
} finally {
dispose();
}
}
);
it('creates the event with its Macro call in a single write', async () => {
const saved = vi.fn();
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: saved,
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(mocks.createEvent).toHaveBeenCalledOnce();
expect(mocks.createEvent).toHaveBeenCalledWith(
expect.objectContaining({
title: 'Planning',
location: 'Meeting room',
description: '<p>Roadmap discussion</p>',
macroCall: true,
})
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateEvent).not.toHaveBeenCalled();
expect(editor.saveError()).toBeUndefined();
expect(saved).toHaveBeenCalledOnce();
} finally {
dispose();
}
});
it('reports the created event before it closes', async () => {
const order: string[] = [];
const created = vi.fn(() => order.push('created'));
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () => false,
event: () => undefined,
onCreated: created,
onSaved: () => order.push('saved'),
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(created).toHaveBeenCalledExactlyOnceWith({
eventId: 'event-1',
time: values.time,
});
expect(order).toEqual(['created', 'saved']);
} finally {
dispose();
}
});
it.each(['off', 'loading'] as const)(
'preserves an existing Macro link without syncing it while %s',
async (state) => {
mocks.quickCalls = state === 'loading';
mocks.quickCallsLoading = state === 'loading';
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => savedEvent,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(
mocks.updateEvent.mock.lastCall?.[0].patch.description
).toContain(savedEvent.location);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
} finally {
dispose();
}
}
);
it('does not sync a call if the flag is disabled while fetching its details', async () => {
mocks.fetchMeeting.mockImplementation(async () => {
mocks.quickCalls = false;
return { id: 'meeting-1' };
});
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
event: () => savedEvent,
onSaved: vi.fn(),
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(mocks.fetchMeeting).toHaveBeenCalledOnce();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
expect(mocks.updateEvent.mock.lastCall?.[0].patch.description).toContain(
savedEvent.location
);
} finally {
dispose();
}
});
it.each(['none', 'macro'] as const)(
'clears legacy provider conferencing when %s is selected on an event carrying both links',
async (conferenceChoice) => {
const event = {
...savedEvent,
conferenceUrl: 'https://meet.google.com/abc-defg-hij',
conferenceProvider: 'google_meet' as const,
};
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => event,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
await editor.save({ ...values, conferenceChoice });
expect(mocks.updateEvent.mock.calls[0][0].patch.conference).toBe(
'none'
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).toHaveBeenCalledTimes(
conferenceChoice === 'macro' ? 1 : 0
);
} finally {
dispose();
}
}
);
it('keeps hidden link content untouched when editing an out-of-office event', async () => {
const event = { ...savedEvent, eventType: 'out_of_office' as const };
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => event,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
const initial = calendarEventToEditorInitialValues(event);
await editor.save({
...values,
location: initial.location,
description: initial.description,
conferenceChoice: 'none',
});
expect(mocks.updateEvent.mock.lastCall?.[0].patch).not.toHaveProperty(
'location'
);
expect(mocks.updateEvent.mock.lastCall?.[0].patch).not.toHaveProperty(
'description'
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it.each(['none', 'google_meet'] as const)(
'does not attach a Macro call when %s is selected',
async (conferenceChoice) => {
const saved = vi.fn();
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: saved,
}),
dispose,
] as const
);
try {
await editor.save({
...values,
conferenceChoice,
...(conferenceChoice === 'google_meet'
? { conference: 'google_meet' }
: {}),
});
expect(mocks.createEvent).toHaveBeenCalledOnce();
expect(mocks.createEvent.mock.lastCall?.[0].conference).toBe(
conferenceChoice === 'google_meet' ? 'google_meet' : undefined
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateEvent).not.toHaveBeenCalled();
expect(saved).toHaveBeenCalledOnce();
} finally {
dispose();
}
}
);
it.each(['none', 'google_meet'] as const)(
'removes a saved Macro link when changed to %s',
async (conferenceChoice) => {
const event = {
...savedEvent,
description: `<p>Roadmap discussion</p><p>Join Macro call: <a href="${savedEvent.location}">${savedEvent.location}</a></p>`,
};
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => event,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
const initial = calendarEventToEditorInitialValues(event);
expect(initial.conference).toBe('macro');
await editor.save({
...values,
location: initial.location,
description: initial.description,
conferenceChoice,
conference: conferenceChoice,
});
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual(
expect.objectContaining({
location: '',
description: '<p>Roadmap discussion</p>',
conference: conferenceChoice,
})
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
} finally {
dispose();
}
}
);
it('adds a Macro call when an event without a call switches to Macro', async () => {
const event = { ...savedEvent, location: 'Meeting room' };
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => event,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
expect(editor.initialValues()?.conference).toBe('none');
await editor.save({ ...values, conferenceChoice: 'none' });
expect(mocks.createMeeting).not.toHaveBeenCalled();
await editor.save(values);
expect(mocks.createMeeting).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch.description).toContain(
'Join Macro call'
);
} finally {
dispose();
}
});
it('asks the server for an untimed call on an all-day event', async () => {
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
await editor.save({
...values,
time: {
kind: 'allDay',
startDate: '2026-09-22',
endDate: '2026-09-24',
},
});
expect(mocks.createEvent).toHaveBeenCalledWith(
expect.objectContaining({
macroCall: true,
time: {
kind: 'allDay',
startDate: '2026-09-22',
endDate: '2026-09-24',
},
})
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('does not attach a call to an out-of-office entry', async () => {
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
await editor.save({
...values,
outOfOffice: { autoDeclineMode: 'decline_none' },
});
expect(mocks.createEvent).toHaveBeenCalledOnce();
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateEvent).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('retains an invited event link without managing another organizer’s call', async () => {
const event = {
...savedEvent,
// A guest the organizer lets modify the event.
viewerCan: {
editDetails: true,
inviteGuests: true,
removeGuests: false,
setGuestPolicy: false,
rsvp: true,
organize: false,
},
attendees: [
{
email: '[email protected]',
isOrganizer: true,
isOptional: false,
isSelf: false,
responseStatus: 'accepted' as const,
},
],
};
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => event,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
expect(editor.disabledFields()?.conference).toBe(true);
await editor.save(values);
expect(mocks.updateEvent.mock.lastCall?.[0].patch.description).toContain(
savedEvent.location
);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateMeeting).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('does not create a call when event creation fails', async () => {
mocks.createEvent.mockRejectedValueOnce(new Error('Calendar unavailable'));
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.failure).toHaveBeenCalledWith('Failed to create event', {
subtext: 'Calendar unavailable',
});
} finally {
dispose();
}
});
it('retries a failed create from scratch instead of patching a saved event', async () => {
mocks.createEvent.mockRejectedValueOnce(
new Error('the Macro call for the event could not be created')
);
const saved = vi.fn();
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: saved,
}),
dispose,
] as const
);
try {
await editor.save(values);
expect(mocks.failure).toHaveBeenCalledWith('Failed to create event', {
subtext: 'the Macro call for the event could not be created',
});
expect(editor.saveError()).toBeUndefined();
expect(saved).not.toHaveBeenCalled();
await editor.save(values);
expect(mocks.createEvent).toHaveBeenCalledTimes(2);
expect(mocks.createEvent.mock.lastCall?.[0]).toMatchObject({
macroCall: true,
});
expect(mocks.updateEvent).not.toHaveBeenCalled();
expect(saved).toHaveBeenCalledOnce();
} finally {
dispose();
}
});
it('guards the whole save flow against concurrent submissions', async () => {
let finish!: (event: { id: string }) => void;
mocks.createEvent.mockReturnValueOnce(
new Promise((resolve) => {
finish = resolve;
})
);
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => undefined,
onSaved: vi.fn(),
}),
dispose,
] as const
);
try {
const saving = editor.save(values);
expect(editor.pending()).toBe(true);
await editor.save(values);
expect(mocks.createEvent).toHaveBeenCalledOnce();
finish({ id: 'event-1' });
await saving;
expect(editor.pending()).toBe(false);
expect(mocks.createEvent).toHaveBeenCalledOnce();
expect(mocks.createMeeting).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('clears the existing meeting schedule when an event becomes all-day', async () => {
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
event: () => savedEvent,
onSaved: vi.fn(),
macroCallsEnabled: () => true,
}),
dispose,
] as const
);
try {
await editor.save({
...values,
time: {
kind: 'allDay',
startDate: '2026-09-22',
endDate: '2026-09-24',
},
});
expect(mocks.updateMeeting).toHaveBeenCalledWith({
meetingId: 'meeting-1',
title: 'Planning',
scheduledStart: null,
scheduledEnd: null,
clearSchedule: true,
});
} finally {
dispose();
}
});
it('updates an existing event before syncing its saved call', async () => {
const saved = vi.fn();
const [editor, dispose] = createRoot(
(dispose) =>
[
useEventEditor({
macroCallsEnabled: () =>
mocks.quickCalls && !mocks.quickCallsLoading,
event: () => savedEvent,
onSaved: saved,
}),
dispose,
] as const
);
try {
await editor.save({ ...values, title: 'Rescheduled planning' });
expect(mocks.createMeeting).not.toHaveBeenCalled();
expect(mocks.updateEvent.mock.invocationCallOrder[0]).toBeLessThan(
mocks.updateMeeting.mock.invocationCallOrder[0]
);
expect(mocks.updateMeeting).toHaveBeenCalledWith({
meetingId: 'meeting-1',
title: 'Rescheduled planning',
scheduledStart: '2026-09-22T14:00:00Z',
scheduledEnd: '2026-09-22T15:00:00Z',
});
expect(saved).toHaveBeenCalledOnce();
} finally {
dispose();
}
});
});
describe('guests of an event the viewer was invited to', () => {
const invitedEvent = (
viewerCan: CalendarEvent['viewerCan'],
overrides: Partial<CalendarEvent> = {}
): CalendarEvent => ({
...savedEvent,
location: '',
viewerCan,
attendees: [
{
email: '[email protected]',
isOrganizer: true,
isOptional: false,
isSelf: false,
responseStatus: 'accepted',
},
{
email: '[email protected]',
isOrganizer: false,
isOptional: false,
isSelf: true,
responseStatus: 'accepted',
},
],
...overrides,
});
const mayInvite = {
editDetails: false,
inviteGuests: true,
removeGuests: false,
setGuestPolicy: false,
rsvp: true,
organize: false,
};
const mayNotInvite = { ...mayInvite, inviteGuests: false };
const mayModify = { ...mayInvite, editDetails: true, removeGuests: true };
const thirtyMinutes = {
useDefault: false,
overrides: [{ method: 'popup', minutes: 30 }],
};
const unchanged: EventEditorSubmitValues = {
...values,
location: '',
description: '',
conferenceChoice: 'none',
guestEmails: ['[email protected]'],
};
function editorFor(
event: CalendarEvent,
invitesEnabled: boolean,
onDetailsLocked?: () => void,
syncedEvent?: () => CalendarEvent | undefined,
forwardEnabled = invitesEnabled
) {
return createRoot((dispose) => ({
editor: useEventEditor({
event: () => event,
syncedEvent,
onSaved: vi.fn(),
macroCallsEnabled: () => false,
guestInvitesEnabled: () => invitesEnabled,
invitationForwardEnabled: () => forwardEnabled,
onDetailsLocked,
}),
dispose,
}));
}
it('invites only the added guests instead of replacing the guest list', async () => {
const { editor, dispose } = editorFor(invitedEvent(mayInvite), true);
try {
expect(editor.addOnlyGuests()).toBe(true);
expect(editor.disabledFields()?.guests).toBe(false);
expect(editor.disabledFields()?.conference).toBe(true);
await editor.save({
...unchanged,
reminders: thirtyMinutes,
guestEmails: ['[email protected]', '[email protected]'],
});
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
reminders: thirtyMinutes,
});
expect(mocks.inviteGuests).toHaveBeenCalledWith({
eventId: 'event-1',
calendarId: 'calendar-1',
guests: [{ email: '[email protected]' }],
scope: 'all',
recurrenceId: undefined,
occurrenceKey: undefined,
});
expect(mocks.updateEvent.mock.invocationCallOrder[0]).toBeLessThan(
mocks.inviteGuests.mock.invocationCallOrder[0]
);
} finally {
dispose();
}
});
it('sends no request when the guest added nobody', async () => {
const { editor, dispose } = editorFor(invitedEvent(mayInvite), true);
try {
await editor.save(unchanged);
expect(mocks.updateEvent).not.toHaveBeenCalled();
expect(mocks.inviteGuests).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('invites to the one occurrence an edit is scoped to', async () => {
const { editor, dispose } = editorFor(
invitedEvent(mayInvite, {
recurrenceLines: ['RRULE:FREQ=WEEKLY'],
recurrenceId: '2026-09-22T14:00:00Z',
}),
true
);
try {
await editor.save(
{
...unchanged,
recurrenceLines: ['RRULE:FREQ=WEEKLY'],
guestEmails: ['[email protected]', '[email protected]'],
},
'this_event'
);
expect(mocks.inviteGuests).toHaveBeenCalledWith(
expect.objectContaining({
scope: 'this_event',
recurrenceId: '2026-09-22T14:00:00Z',
occurrenceKey: '2026-09-22T14:00:00Z',
})
);
} finally {
dispose();
}
});
it('reports a refused invitation as a failed save', async () => {
mocks.inviteGuests.mockRejectedValueOnce(
new Error('Only the organizer can invite guests.')
);
const { editor, dispose } = editorFor(invitedEvent(mayInvite), true);
try {
await editor.save({
...unchanged,
guestEmails: ['[email protected]', '[email protected]'],
});
expect(mocks.failure).toHaveBeenCalledWith('Failed to update event', {
subtext: 'Only the organizer can invite guests.',
});
} finally {
dispose();
}
});
it('keeps the guest list read-only while guest invites are off', () => {
const { editor, dispose } = editorFor(invitedEvent(mayInvite), false);
try {
expect(editor.addOnlyGuests()).toBe(false);
expect(editor.disabledFields()?.guests).toBe(true);
expect(editor.guestsReadOnlyReason()).toBeUndefined();
} finally {
dispose();
}
});
it('explains why a guest the organizer does not let invite cannot add guests, and offers the forward', () => {
const { editor, dispose } = editorFor(invitedEvent(mayNotInvite), true);
try {
expect(editor.disabledFields()?.guests).toBe(true);
expect(editor.guestsReadOnlyReason()).toBe(
"Only the organizer can invite guests. You can forward the invitation instead. The people you send it to get the event by email but won't be on the guest list."
);
} finally {
dispose();
}
});
it('explains without offering the forward while forwarding is off', () => {
const { editor, dispose } = editorFor(invitedEvent(mayNotInvite), false);
try {
expect(editor.guestsReadOnlyReason()).toBe(
'Only the organizer can invite guests.'
);
} finally {
dispose();
}
});
it('locks the details of a guest the organizer does not let modify, but not their reminders', () => {
const { editor, dispose } = editorFor(invitedEvent(mayInvite), true);
try {
expect(editor.disabledFields()).toMatchObject({
title: true,
allDay: true,
start: true,
end: true,
recurrence: true,
location: true,
description: true,
conference: true,
reminders: false,
});
expect(editor.detailsReadOnlyReason()).toBe(
'Only the organizer can change this event.'
);
} finally {
dispose();
}
});
it('saves only the reminders of a guest the organizer does not let modify', async () => {
const { editor, dispose } = editorFor(invitedEvent(mayInvite), true);
try {
await editor.save({
...unchanged,
title: 'Planning review',
location: 'Room 4',
time: {
kind: 'timed',
startsAt: '2026-09-22T16:00:00Z',
endsAt: '2026-09-22T17:00:00Z',
timeZone: 'America/New_York',
},
reminders: thirtyMinutes,
});
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
reminders: thirtyMinutes,
});
} finally {
dispose();
}
});
it('saves only the reminders of a snapshot of a shared meeting', async () => {
const snapshot = invitedEvent(
{ ...mayInvite, inviteGuests: false, rsvp: false },
{ isSnapshot: true }
);
const { editor, dispose } = editorFor(snapshot, true);
try {
expect(editor.disabledFields()).toMatchObject({
title: true,
start: true,
description: true,
location: true,
guests: true,
conference: true,
reminders: false,
});
await editor.save({
...unchanged,
title: 'Planning review',
description: '<p>My notes</p>',
reminders: thirtyMinutes,
});
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
reminders: thirtyMinutes,
});
expect(mocks.inviteGuests).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('leaves the details editable for a guest the organizer lets modify', async () => {
const { editor, dispose } = editorFor(invitedEvent(mayModify), true);
try {
expect(editor.disabledFields()?.title).toBeUndefined();
expect(editor.detailsReadOnlyReason()).toBeUndefined();
await editor.save({ ...unchanged, title: 'Planning review' });
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
title: 'Planning review',
});
} finally {
dispose();
}
});
it('locks the details when the server refuses a guest’s change', async () => {
mocks.updateEvent.mockRejectedValueOnce({ code: 'guests_cannot_modify' });
const detailsLocked = vi.fn();
const { editor, dispose } = editorFor(
invitedEvent(mayModify),
true,
detailsLocked
);
try {
await editor.save({ ...unchanged, title: 'Planning review' });
expect(mocks.failure).toHaveBeenCalledWith(
'Only the organizer can change this event.'
);
expect(mocks.alert).not.toHaveBeenCalled();
expect(detailsLocked).toHaveBeenCalledOnce();
expect(editor.disabledFields()?.title).toBe(true);
expect(editor.detailsReadOnlyReason()).toBe(
'Only the organizer can change this event.'
);
await editor.save({
...unchanged,
title: 'Planning review',
reminders: thirtyMinutes,
});
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
reminders: thirtyMinutes,
});
} finally {
dispose();
}
});
it('locks the open editor once the synced event stops letting the guest modify it', async () => {
const opened = invitedEvent(mayModify);
const [synced, setSynced] = createSignal<CalendarEvent | undefined>();
const detailsLocked = vi.fn();
const { editor, dispose } = editorFor(opened, true, detailsLocked, synced);
try {
// The day loads with the copy the editor opened with.
setSynced(opened);
expect(editor.disabledFields()?.title).toBeUndefined();
expect(detailsLocked).not.toHaveBeenCalled();
// The organizer turns Modify event off and the guest's copy syncs.
setSynced(invitedEvent(mayInvite));
expect(editor.disabledFields()?.title).toBe(true);
expect(editor.detailsReadOnlyReason()).toBe(
'Only the organizer can change this event.'
);
expect(detailsLocked).toHaveBeenCalledOnce();
expect(mocks.alert).toHaveBeenCalledWith(
'Only the organizer can change this event.'
);
await editor.save({
...unchanged,
title: 'Planning review',
reminders: thirtyMinutes,
});
expect(mocks.updateEvent).toHaveBeenCalledOnce();
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
reminders: thirtyMinutes,
});
} finally {
dispose();
}
});
it('keeps the viewer on a meeting their secondary calendar organizes', async () => {
// Google names the secondary calendar as the organizer and lists the
// viewer's own address as a plain guest.
const organized = invitedEvent(
{ ...mayModify, setGuestPolicy: true, organize: true },
{
organizerEmail: '[email protected]',
attendees: [
{
email: '[email protected]',
isOrganizer: false,
isOptional: false,
isSelf: true,
responseStatus: 'accepted',
},
],
}
);
const { editor, dispose } = editorFor(organized, true);
try {
expect(editor.initialValues()?.guests).toBe('[email protected]');
await editor.save({
...unchanged,
guestEmails: ['[email protected]', '[email protected]'],
});
expect(mocks.updateEvent.mock.lastCall?.[0].patch.attendees).toEqual([
{ email: '[email protected]' },
{ email: '[email protected]' },
]);
} finally {
dispose();
}
});
});
describe('guest permissions', () => {
const noInvites = {
canModify: false,
canInviteOthers: false,
canSeeOtherGuests: true,
};
function editorFor(event: CalendarEvent | undefined, invitesEnabled = true) {
return createRoot((dispose) => ({
editor: useEventEditor({
event: () => event,
onSaved: vi.fn(),
macroCallsEnabled: () => false,
guestInvitesEnabled: () => invitesEnabled,
}),
dispose,
}));
}
it('offers guest permissions only with the guest-invites rollout', () => {
const { editor, dispose } = editorFor(undefined, false);
try {
expect(editor.guestPolicyEditable()).toBe(false);
} finally {
dispose();
}
});
it('creates an event with the guest permissions the organizer chose', async () => {
const { editor, dispose } = editorFor(undefined);
try {
expect(editor.guestPolicyEditable()).toBe(true);
await editor.save({
...values,
conferenceChoice: 'none',
guestPolicy: noInvites,
});
expect(mocks.createEvent.mock.lastCall?.[0].guestPolicy).toEqual(
noInvites
);
} finally {
dispose();
}
});
it('sends the organizer’s changed guest permissions with the update', async () => {
const { editor, dispose } = editorFor({ ...savedEvent, location: '' });
try {
expect(editor.guestPolicyEditable()).toBe(true);
await editor.save({
...values,
location: '',
description: '',
conferenceChoice: 'none',
guestEmails: [],
guestPolicy: noInvites,
});
expect(mocks.updateEvent.mock.lastCall?.[0].patch).toEqual({
guestPolicy: noInvites,
});
} finally {
dispose();
}
});
it('keeps guest permissions out of a change to one occurrence', async () => {
const { editor, dispose } = editorFor({
...savedEvent,
location: '',
recurrenceLines: ['RRULE:FREQ=WEEKLY'],
recurrenceId: '2026-09-22T14:00:00Z',
});
try {
await editor.save(
{
...values,
location: '',
description: '',
conferenceChoice: 'none',
guestEmails: [],
recurrenceLines: ['RRULE:FREQ=WEEKLY'],
guestPolicy: noInvites,
},
'this_event'
);
expect(mocks.updateEvent).not.toHaveBeenCalled();
} finally {
dispose();
}
});
it('leaves guest permissions to the organizer', () => {
const { editor, dispose } = editorFor({
...savedEvent,
viewerCan: {
editDetails: true,
inviteGuests: true,
removeGuests: true,
setGuestPolicy: false,
rsvp: true,
organize: false,
},
});
try {
expect(editor.guestPolicyEditable()).toBe(false);
} finally {
dispose();
}
});
});