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 { openPipedreamConnectUI } from '@core/pipedream/connect-ui';
import { err, ok } from 'neverthrow';
import { beforeEach, describe, expect, it, vi } from 'vitest';
const mocks = vi.hoisted(() => ({
open: vi.fn(),
close: vi.fn(),
complete: vi.fn(),
recover: vi.fn(),
setData: vi.fn(),
invalidate: vi.fn(async () => {}),
native: false,
openNative: vi.fn(),
userId: 'user-one',
token: vi.fn(),
startAuth: vi.fn(),
fetchServers: vi.fn(),
reservePopup: vi.fn(),
assignUrl: vi.fn(),
linkGithub: vi.fn(),
completeConnect: vi.fn(),
macroConnect: false,
overlays: [] as { app_slug: string; server_url: string }[],
overlaysUnavailable: false,
cachedOverlays: undefined as
| { app_slug: string; server_url: string }[]
| undefined,
}));
vi.mock('@core/util/platform', () => ({ isTauri: () => mocks.native }));
vi.mock('@core/constant/featureFlags', () => ({
macroConnect: { key: 'macro-connect' },
isFeatureEnabled: () => mocks.macroConnect,
}));
vi.mock('@core/auth/authorize-github', () => ({
linkGithubAccount: mocks.linkGithub,
}));
vi.mock('@core/pipedream/connect-native', () => ({
openNativePipedreamConnectUI: mocks.openNative,
}));
vi.mock('@core/pipedream/connect-ui', () => ({
openPipedreamConnectUI: mocks.open,
}));
vi.mock('@core/pipedream/oauth-popup', () => ({
reserveOauthPopup: mocks.reservePopup,
assignOauthUrl: mocks.assignUrl,
}));
vi.mock('@queries/client', () => ({
queryClient: {
setQueryData: mocks.setData,
invalidateQueries: mocks.invalidate,
getQueryData: (key: readonly unknown[]) =>
key[1] === 'overlays' ? mocks.cachedOverlays : { id: mocks.userId },
ensureQueryData: async () => {
if (mocks.overlaysUnavailable) throw new Error('404');
return mocks.overlays;
},
fetchQuery: mocks.fetchServers,
},
}));
vi.mock('@service-cognition/client', () => ({
PIPEDREAM_DISABLED: 'PIPEDREAM_DISABLED',
cognitionApiServiceClient: {
createPipedreamToken: mocks.token,
completePipedreamConnection: mocks.complete,
startMcpAuth: mocks.startAuth,
recoverPipedreamConnection: mocks.recover,
completeMacroConnect: mocks.completeConnect,
},
}));
import { connectPipedreamApp, overlaidAppSlug } from './pipedream-connectors';
beforeEach(() => {
vi.clearAllMocks();
mocks.native = false;
mocks.userId = 'user-one';
mocks.overlays = [];
mocks.overlaysUnavailable = false;
mocks.cachedOverlays = undefined;
mocks.macroConnect = false;
mocks.token.mockImplementation(async () => ok({ token: 'fixture' }));
mocks.open.mockImplementation(() => ({ close: mocks.close }));
mocks.openNative.mockImplementation(() => ({ close: mocks.close }));
mocks.recover.mockResolvedValue(
err([{ code: 'NOT_FOUND', message: 'Resource not found' }])
);
});
async function connect(native = false) {
mocks.native = native;
const opened =
Promise.withResolvers<Parameters<typeof openPipedreamConnectUI>[0]>();
(native ? mocks.openNative : mocks.open).mockImplementation((options) => {
opened.resolve(options);
return { close: mocks.close };
});
const pending = connectPipedreamApp({
appSlug: 'linear',
serverName: 'Linear',
});
const { onEvent } = await opened.promise;
return { pending, event: onEvent };
}
describe('verified Pipedream connection completion', () => {
it('does not attach a browser result after the user changes accounts', async () => {
const { pending, event } = await connect();
mocks.userId = 'user-two';
event({ type: 'success', accountId: 'apn_test' });
expect(await pending).toBe('closed');
expect(mocks.complete).not.toHaveBeenCalled();
});
it('does not populate another account cache when registration finishes late', async () => {
let complete!: (value: { app_slug: string; enabled: boolean }) => void;
mocks.complete.mockImplementation(
() =>
new Promise((resolve) => {
complete = (connection) => resolve(ok(connection));
})
);
const { pending, event } = await connect();
event({ type: 'success', accountId: 'apn_test' });
await vi.waitFor(() => expect(mocks.complete).toHaveBeenCalled());
mocks.userId = 'user-two';
complete({ app_slug: 'linear', enabled: true });
expect(await pending).toBe('closed');
expect(mocks.setData).not.toHaveBeenCalled();
});
it('opens native consent in the browser and verifies the returned account before success', async () => {
mocks.complete.mockResolvedValue(ok({ app_slug: 'linear', enabled: true }));
const { pending, event } = await connect(true);
expect(mocks.open).not.toHaveBeenCalled();
expect(mocks.complete).not.toHaveBeenCalled();
event({
type: 'success',
accountId: 'apn_test',
});
expect(await pending).toBe('connected');
expect(mocks.complete).toHaveBeenCalledExactlyOnceWith({
account_id: 'apn_test',
server_name: 'Linear',
});
});
it('reports success only after the requested enabled connection is registered', async () => {
mocks.complete.mockResolvedValue(ok({ app_slug: 'linear', enabled: true }));
const { pending, event } = await connect();
event({ type: 'success', accountId: 'apn_test' });
event({ type: 'success', accountId: 'apn_test' });
expect(await pending).toBe('connected');
expect(mocks.complete).toHaveBeenCalledOnce();
expect(mocks.invalidate).toHaveBeenCalledOnce();
expect(mocks.close).toHaveBeenCalledOnce();
});
it.each([
{ app_slug: 'slack', enabled: true },
{ app_slug: 'linear', enabled: false },
])(
'does not report connected for $app_slug with enabled=$enabled',
async (connection) => {
mocks.complete.mockResolvedValue(ok(connection));
const { pending, event } = await connect();
const rejected = expect(pending).rejects.toThrow(
'requested connector was not enabled'
);
event({ type: 'success', accountId: 'apn_test' });
await rejected;
expect(mocks.setData).not.toHaveBeenCalled();
expect(mocks.close).toHaveBeenCalledOnce();
}
);
it('cancelling does not register an account', async () => {
const { pending, event } = await connect();
event({ type: 'close' });
expect(await pending).toBe('closed');
expect(mocks.complete).not.toHaveBeenCalled();
});
it.each([false, true])(
'registers an account the Connect UI never reported (native=%s)',
async (native) => {
mocks.recover.mockResolvedValue(
ok({ app_slug: 'linear', enabled: true })
);
const { pending, event } = await connect(native);
event({ type: 'close' });
expect(await pending).toBe('connected');
expect(mocks.recover).toHaveBeenCalledExactlyOnceWith({
app_slug: 'linear',
server_name: 'Linear',
});
expect(mocks.complete).not.toHaveBeenCalled();
expect(mocks.invalidate).toHaveBeenCalledOnce();
}
);
it('surfaces recovery failures other than a missing account', async () => {
mocks.recover.mockResolvedValue(
err([{ code: 'SERVER_ERROR', message: 'boom' }])
);
const { pending, event } = await connect();
const rejected = expect(pending).rejects.toThrow();
event({ type: 'close' });
await rejected;
expect(mocks.setData).not.toHaveBeenCalled();
});
});
describe('overlaid apps connect through their own MCP server', () => {
const sentry = {
app_slug: 'sentry',
server_url: 'https://mcp.sentry.dev/mcp',
};
const authorized = {
url: 'https://mcp.sentry.dev/mcp',
server_name: 'Sentry',
enabled: true,
authenticated: true,
};
beforeEach(() => {
mocks.cachedOverlays = [sentry];
mocks.startAuth.mockResolvedValue(
ok({ authorization_url: 'https://sentry.io/oauth/authorize?x=1' })
);
});
it('authorizes the overlay server in the reserved tab, never Pipedream', async () => {
const popup = { closed: false, close: vi.fn() };
mocks.reservePopup.mockReturnValue(popup);
mocks.fetchServers.mockResolvedValue([authorized]);
const outcome = await connectPipedreamApp({
appSlug: 'sentry',
serverName: 'Sentry',
});
expect(outcome).toBe('connected');
expect(mocks.startAuth).toHaveBeenCalledWith({
server_url: 'https://mcp.sentry.dev/mcp',
server_name: 'Sentry',
});
expect(mocks.assignUrl).toHaveBeenCalledWith(
popup,
'https://sentry.io/oauth/authorize?x=1'
);
expect(mocks.token).not.toHaveBeenCalled();
expect(mocks.open).not.toHaveBeenCalled();
});
it('reports closed when the tab closes before the server is authorized', async () => {
mocks.reservePopup.mockReturnValue({ closed: true, close: vi.fn() });
mocks.fetchServers.mockResolvedValue([
{ ...authorized, authenticated: false },
]);
expect(await connectPipedreamApp({ appSlug: 'sentry' })).toBe('closed');
});
it('looks the overlay up when it is not cached yet', async () => {
mocks.cachedOverlays = undefined;
mocks.overlays = [sentry];
mocks.fetchServers.mockResolvedValue([authorized]);
expect(await connectPipedreamApp({ appSlug: 'sentry' })).toBe('connected');
expect(mocks.reservePopup).not.toHaveBeenCalled();
expect(mocks.assignUrl).toHaveBeenCalledWith(
null,
'https://sentry.io/oauth/authorize?x=1'
);
expect(mocks.token).not.toHaveBeenCalled();
});
});
describe('GitHub connects through the account link', () => {
const github = {
app_slug: 'github',
server_url: 'https://api.githubcopilot.com/mcp',
};
beforeEach(() => {
mocks.cachedOverlays = [github];
});
it('links the account instead of authorizing the server or Pipedream', async () => {
mocks.linkGithub.mockResolvedValue(true);
expect(await connectPipedreamApp({ appSlug: 'github' })).toBe('connected');
expect(mocks.linkGithub).toHaveBeenCalled();
expect(mocks.reservePopup).not.toHaveBeenCalled();
expect(mocks.startAuth).not.toHaveBeenCalled();
expect(mocks.token).not.toHaveBeenCalled();
expect(mocks.invalidate).toHaveBeenCalled();
});
it('reports closed when the page leaves for GitHub or the link fails', async () => {
mocks.linkGithub.mockResolvedValue(false);
expect(await connectPipedreamApp({ appSlug: 'github' })).toBe('closed');
expect(mocks.startAuth).not.toHaveBeenCalled();
});
});
describe('a backend without overlays', () => {
it('connects through Pipedream when the overlay list cannot be read', async () => {
mocks.overlaysUnavailable = true;
const { pending, event } = await connect();
event({ type: 'close' });
expect(await pending).toBe('closed');
expect(mocks.token).toHaveBeenCalledOnce();
});
});
describe('overlaidAppSlug', () => {
const overlays = [
{ app_slug: 'sentry', server_url: 'https://mcp.sentry.dev/mcp' },
];
it('matches a connected server to its catalog app despite a trailing slash', () => {
expect(overlaidAppSlug(overlays, 'https://mcp.sentry.dev/mcp/')).toBe(
'sentry'
);
});
it('leaves custom servers unmatched', () => {
expect(
overlaidAppSlug(overlays, 'https://example.com/mcp')
).toBeUndefined();
});
});
describe('apps Macro Connect serves', () => {
const popup = { closed: false, close: vi.fn() };
const notYet = err([{ code: 'NOT_FOUND', message: 'Resource not found' }]);
beforeEach(() => {
vi.useFakeTimers();
popup.closed = false;
mocks.macroConnect = true;
mocks.reservePopup.mockReturnValue(popup);
mocks.token.mockResolvedValue(
ok({ provider: 'connect', connect_url: 'https://connect.test/c/tok' })
);
return () => vi.useRealTimers();
});
it('opens Connect in the reserved tab and records the app once Connect confirms it', async () => {
mocks.completeConnect
.mockResolvedValueOnce(notYet)
.mockResolvedValueOnce(
ok({ app_slug: 'linear', server_name: 'Linear', enabled: true })
);
const pending = connectPipedreamApp({ appSlug: 'linear' });
await vi.runAllTimersAsync();
await expect(pending).resolves.toBe('connected');
expect(mocks.token).toHaveBeenCalledWith({ app_slug: 'linear' });
expect(mocks.assignUrl).toHaveBeenCalledWith(
popup,
'https://connect.test/c/tok'
);
expect(mocks.completeConnect).toHaveBeenCalledTimes(2);
expect(mocks.open).not.toHaveBeenCalled();
expect(mocks.setData).toHaveBeenCalled();
});
it('reports closed when the tab closes before Connect has the app', async () => {
mocks.completeConnect.mockImplementation(async () => {
popup.closed = true;
return notYet;
});
const pending = connectPipedreamApp({ appSlug: 'linear' });
await vi.runAllTimersAsync();
await expect(pending).resolves.toBe('closed');
expect(mocks.setData).not.toHaveBeenCalled();
});
it('closes the reserved tab and uses Pipedream when the backend answers with a token', async () => {
mocks.token.mockResolvedValue(ok({ provider: 'pipedream', token: 'pd' }));
mocks.open.mockImplementation(({ onEvent }) => {
onEvent({ type: 'close' });
return { close: mocks.close };
});
const pending = connectPipedreamApp({ appSlug: 'linear' });
await vi.runAllTimersAsync();
await expect(pending).resolves.toBe('closed');
expect(popup.close).toHaveBeenCalled();
expect(mocks.open).toHaveBeenCalledWith(
expect.objectContaining({ token: 'pd', app: 'linear' })
);
expect(mocks.completeConnect).not.toHaveBeenCalled();
});
});