Gabriel Brown
479 lines
14 KiB
TypeScript
479 lines
14 KiB
TypeScript
import { convexTest } from 'convex-test';
|
||
import { describe, expect, test } from 'vitest';
|
||
|
||
import type { Id } from '../../convex/_generated/dataModel.js';
|
||
import { api } from '../../convex/_generated/api.js';
|
||
import schema from '../../convex/schema';
|
||
|
||
const modules = import.meta.glob('../../convex/**/*.*s');
|
||
|
||
const createUser = async (t: ReturnType<typeof convexTest>, email: string) =>
|
||
await t.mutation(async (ctx) => {
|
||
return await ctx.db.insert('users', { email, name: email });
|
||
});
|
||
|
||
const authed = (t: ReturnType<typeof convexTest>, userId: string) =>
|
||
t.withIdentity({
|
||
subject: `${userId}|session`,
|
||
issuer: 'https://convex.test',
|
||
});
|
||
|
||
const spoonInput = {
|
||
name: 'Editor Spoon',
|
||
provider: 'gitea' as const,
|
||
upstreamOwner: 'upstream',
|
||
upstreamRepo: 'editor',
|
||
upstreamDefaultBranch: 'main',
|
||
upstreamUrl: 'https://git.example.com/upstream/editor',
|
||
forkOwner: 'team',
|
||
forkRepo: 'editor-spoon',
|
||
forkUrl: 'https://git.example.com/team/editor-spoon',
|
||
visibility: 'private' as const,
|
||
maintenanceMode: 'watch' as const,
|
||
syncCadence: 'daily' as const,
|
||
productionRefStrategy: 'default_branch' as const,
|
||
};
|
||
|
||
const githubSpoonInput = {
|
||
...spoonInput,
|
||
provider: 'github' as const,
|
||
upstreamUrl: 'https://github.com/upstream/editor',
|
||
forkUrl: 'https://github.com/team/editor-spoon',
|
||
};
|
||
|
||
const createAgentJob = async (
|
||
t: ReturnType<typeof convexTest>,
|
||
args: {
|
||
ownerId: Id<'users'>;
|
||
spoonId: Id<'spoons'>;
|
||
status: 'running' | 'failed' | 'cancelled';
|
||
workspaceStatus?: 'active' | 'stopped' | 'failed' | 'expired';
|
||
threadId?: Id<'threads'>;
|
||
},
|
||
) =>
|
||
await t.mutation(async (ctx) => {
|
||
const now = Date.now();
|
||
const requestId = await ctx.db.insert('agentRequests', {
|
||
spoonId: args.spoonId,
|
||
ownerId: args.ownerId,
|
||
prompt: 'Clean this workspace',
|
||
status: 'running',
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
});
|
||
const jobId = await ctx.db.insert('agentJobs', {
|
||
spoonId: args.spoonId,
|
||
ownerId: args.ownerId,
|
||
agentRequestId: requestId,
|
||
threadId: args.threadId,
|
||
status: args.status,
|
||
prompt: 'Clean this workspace',
|
||
runtime: 'opencode',
|
||
workspaceStatus: args.workspaceStatus,
|
||
baseBranch: 'main',
|
||
workBranch: 'spoon/test',
|
||
forkOwner: 'team',
|
||
forkRepo: 'editor-spoon',
|
||
forkUrl: 'https://git.example.com/team/editor-spoon',
|
||
upstreamOwner: 'upstream',
|
||
upstreamRepo: 'editor',
|
||
selectedSecretIds: [],
|
||
model: 'openai/gpt-5.1-codex',
|
||
reasoningEffort: 'medium',
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
});
|
||
await ctx.db.patch(requestId, { agentJobId: jobId });
|
||
await ctx.db.insert('agentJobMessages', {
|
||
jobId,
|
||
spoonId: args.spoonId,
|
||
ownerId: args.ownerId,
|
||
role: 'assistant',
|
||
content: 'done',
|
||
status: 'completed',
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
});
|
||
return jobId;
|
||
});
|
||
|
||
describe('convex-test harness', () => {
|
||
test('boots and executes against the project schema', async () => {
|
||
const t = convexTest(schema, modules);
|
||
expect(await t.run(() => Promise.resolve(42))).toBe(42);
|
||
});
|
||
|
||
test('requires authentication to create a Spoon', async () => {
|
||
const t = convexTest(schema, modules);
|
||
await expect(
|
||
t.mutation(api.spoons.createManual, spoonInput),
|
||
).rejects.toThrow('Not authenticated.');
|
||
});
|
||
|
||
test('creates and lists Spoons for the current user', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const userId = await createUser(t, 'one@example.com');
|
||
const session = authed(t, userId);
|
||
|
||
const spoonId = await session.mutation(api.spoons.createManual, spoonInput);
|
||
const spoons = await session.query(api.spoons.listMine, {});
|
||
|
||
expect(spoons).toHaveLength(1);
|
||
expect(spoons[0]?._id).toBe(spoonId);
|
||
expect(spoons[0]?.ownerId).toBe(userId);
|
||
});
|
||
|
||
test('lists effective drift after ignored upstream changes', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = await createUser(t, 'owner@example.com');
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
githubSpoonInput,
|
||
);
|
||
await t.mutation(async (ctx) => {
|
||
const now = Date.now();
|
||
await ctx.db.insert('spoonRepositoryStates', {
|
||
spoonId,
|
||
ownerId: ownerId as Id<'users'>,
|
||
upstreamFullName: 'upstream/editor',
|
||
forkFullName: 'team/editor-spoon',
|
||
upstreamDefaultBranch: 'main',
|
||
forkDefaultBranch: 'main',
|
||
upstreamHeadSha: 'upstream-head',
|
||
forkHeadSha: 'fork-head',
|
||
upstreamAheadBy: 2,
|
||
forkAheadBy: 1,
|
||
status: 'diverged',
|
||
openForkPullRequestCount: 0,
|
||
openUpstreamPullRequestCount: 0,
|
||
refreshedAt: now,
|
||
createdAt: now,
|
||
updatedAt: now,
|
||
});
|
||
await ctx.db.insert('ignoredUpstreamChanges', {
|
||
spoonId,
|
||
ownerId: ownerId as Id<'users'>,
|
||
upstreamTo: 'upstream-head',
|
||
commitShas: ['abc123'],
|
||
reason: 'irrelevant',
|
||
decidedBy: 'user',
|
||
createdAt: now,
|
||
});
|
||
});
|
||
|
||
const spoons = await authed(t, ownerId).query(
|
||
api.spoons.listMineWithState,
|
||
{},
|
||
);
|
||
|
||
expect(spoons[0]?.rawUpstreamAheadBy).toBe(2);
|
||
expect(spoons[0]?.effectiveUpstreamAheadBy).toBe(1);
|
||
expect(spoons[0]?.ignoredUpstreamCount).toBe(1);
|
||
});
|
||
|
||
test('does not allow reading another user’s Spoon', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = await createUser(t, 'owner@example.com');
|
||
const otherId = await createUser(t, 'other@example.com');
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
|
||
await expect(
|
||
authed(t, otherId).query(api.spoons.get, { spoonId }),
|
||
).rejects.toThrow('Spoon not found.');
|
||
});
|
||
|
||
test('thread notes are completed when no workspace handles them', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
githubSpoonInput,
|
||
);
|
||
const threadId = await t.mutation(async (ctx) => {
|
||
return await ctx.db.insert('threads', {
|
||
ownerId,
|
||
spoonId,
|
||
title: 'Manual note',
|
||
source: 'user_request',
|
||
status: 'open',
|
||
priority: 'normal',
|
||
createdAt: Date.now(),
|
||
updatedAt: Date.now(),
|
||
});
|
||
});
|
||
|
||
const messageId = await authed(t, ownerId).mutation(
|
||
api.threads.appendUserMessage,
|
||
{
|
||
threadId,
|
||
content: 'extra context',
|
||
},
|
||
);
|
||
const message = await t.run(async (ctx) => await ctx.db.get(messageId));
|
||
|
||
expect(message?.status).toBe('completed');
|
||
});
|
||
|
||
test('requires Spoon ownership for agent requests', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = await createUser(t, 'owner@example.com');
|
||
const otherId = await createUser(t, 'other@example.com');
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
|
||
await expect(
|
||
authed(t, otherId).mutation(api.agentRequests.create, {
|
||
spoonId,
|
||
prompt: 'Add a settings page',
|
||
}),
|
||
).rejects.toThrow('Spoon not found.');
|
||
});
|
||
|
||
test('deletes terminal workspaces and associated rows', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
const jobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
status: 'failed',
|
||
workspaceStatus: 'failed',
|
||
});
|
||
|
||
await authed(t, ownerId).mutation(api.agentJobs.deleteWorkspace, { jobId });
|
||
|
||
const job = await t.run(async (ctx) => await ctx.db.get(jobId));
|
||
const messages = await t.run(
|
||
async (ctx) =>
|
||
await ctx.db
|
||
.query('agentJobMessages')
|
||
.withIndex('by_job', (q) => q.eq('jobId', jobId))
|
||
.collect(),
|
||
);
|
||
expect(job).toBeNull();
|
||
expect(messages).toHaveLength(0);
|
||
});
|
||
|
||
test('does not delete active workspaces', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
const jobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
status: 'running',
|
||
workspaceStatus: 'active',
|
||
});
|
||
|
||
await expect(
|
||
authed(t, ownerId).mutation(api.agentJobs.deleteWorkspace, { jobId }),
|
||
).rejects.toThrow('Only stopped, cancelled, failed, or expired workspaces');
|
||
});
|
||
|
||
test('does not delete another user’s workspace', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const otherId = (await createUser(t, 'other@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
const jobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
status: 'cancelled',
|
||
workspaceStatus: 'stopped',
|
||
});
|
||
|
||
await expect(
|
||
authed(t, otherId).mutation(api.agentJobs.deleteWorkspace, { jobId }),
|
||
).rejects.toThrow('Agent job not found.');
|
||
});
|
||
|
||
test('persists and clamps workspace agent thread width', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
const jobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
status: 'running',
|
||
workspaceStatus: 'active',
|
||
});
|
||
|
||
const defaults = await authed(t, ownerId).query(
|
||
api.agentJobs.getWorkspaceUiState,
|
||
{ jobId },
|
||
);
|
||
expect(defaults.agentThreadWidth).toBe(420);
|
||
|
||
await authed(t, ownerId).mutation(api.agentJobs.patchWorkspaceUiState, {
|
||
jobId,
|
||
agentThreadWidth: 999,
|
||
});
|
||
const wide = await authed(t, ownerId).query(
|
||
api.agentJobs.getWorkspaceUiState,
|
||
{ jobId },
|
||
);
|
||
expect(wide.agentThreadWidth).toBe(720);
|
||
|
||
await authed(t, ownerId).mutation(api.agentJobs.patchWorkspaceUiState, {
|
||
jobId,
|
||
agentThreadWidth: 100,
|
||
});
|
||
const narrow = await authed(t, ownerId).query(
|
||
api.agentJobs.getWorkspaceUiState,
|
||
{ jobId },
|
||
);
|
||
expect(narrow.agentThreadWidth).toBe(320);
|
||
});
|
||
|
||
test('deletes terminal threads and attached terminal workspace rows', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
const threadId = await t.mutation(async (ctx) => {
|
||
return await ctx.db.insert('threads', {
|
||
ownerId,
|
||
spoonId,
|
||
title: 'Failed attempt',
|
||
source: 'user_request',
|
||
status: 'failed',
|
||
priority: 'normal',
|
||
createdAt: Date.now(),
|
||
updatedAt: Date.now(),
|
||
});
|
||
});
|
||
const jobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
threadId,
|
||
status: 'failed',
|
||
workspaceStatus: 'failed',
|
||
});
|
||
await t.mutation(async (ctx) => {
|
||
await ctx.db.patch(threadId, { latestAgentJobId: jobId });
|
||
});
|
||
|
||
await authed(t, ownerId).mutation(api.threads.deleteThread, { threadId });
|
||
|
||
const [thread, job, messages] = await t.run(async (ctx) => {
|
||
const rows = await ctx.db
|
||
.query('agentJobMessages')
|
||
.withIndex('by_job', (q) => q.eq('jobId', jobId))
|
||
.collect();
|
||
return [await ctx.db.get(threadId), await ctx.db.get(jobId), rows];
|
||
});
|
||
expect(thread).toBeNull();
|
||
expect(job).toBeNull();
|
||
expect(messages).toHaveLength(0);
|
||
});
|
||
|
||
test('does not delete threads with active workspace runs', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
spoonInput,
|
||
);
|
||
const threadId = await t.mutation(async (ctx) => {
|
||
return await ctx.db.insert('threads', {
|
||
ownerId,
|
||
spoonId,
|
||
title: 'Active attempt',
|
||
source: 'user_request',
|
||
status: 'running',
|
||
priority: 'normal',
|
||
createdAt: Date.now(),
|
||
updatedAt: Date.now(),
|
||
});
|
||
});
|
||
const jobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
threadId,
|
||
status: 'running',
|
||
workspaceStatus: 'active',
|
||
});
|
||
await t.mutation(async (ctx) => {
|
||
await ctx.db.patch(threadId, { latestAgentJobId: jobId });
|
||
});
|
||
|
||
await expect(
|
||
authed(t, ownerId).mutation(api.threads.deleteThread, { threadId }),
|
||
).rejects.toThrow('Stop or cancel active workspace runs');
|
||
});
|
||
|
||
test('queues a new thread job after the previous job is terminal', async () => {
|
||
const t = convexTest(schema, modules);
|
||
const ownerId = (await createUser(t, 'owner@example.com')) as Id<'users'>;
|
||
const spoonId = await authed(t, ownerId).mutation(
|
||
api.spoons.createManual,
|
||
githubSpoonInput,
|
||
);
|
||
await t.mutation(async (ctx) => {
|
||
await ctx.db.insert('aiProviderProfiles', {
|
||
ownerId,
|
||
name: 'Test provider',
|
||
provider: 'openai',
|
||
authType: 'none',
|
||
defaultModel: 'gpt-5.1-codex',
|
||
modelOptions: ['gpt-5.1-codex'],
|
||
reasoningEffort: 'medium',
|
||
enabled: true,
|
||
createdAt: Date.now(),
|
||
updatedAt: Date.now(),
|
||
});
|
||
});
|
||
const threadId = await t.mutation(async (ctx) => {
|
||
return await ctx.db.insert('threads', {
|
||
ownerId,
|
||
spoonId,
|
||
title: 'Retryable thread',
|
||
summary: 'try again',
|
||
source: 'user_request',
|
||
status: 'failed',
|
||
priority: 'normal',
|
||
createdAt: Date.now(),
|
||
updatedAt: Date.now(),
|
||
});
|
||
});
|
||
const failedJobId = await createAgentJob(t, {
|
||
ownerId,
|
||
spoonId,
|
||
status: 'failed',
|
||
workspaceStatus: 'failed',
|
||
});
|
||
await t.mutation(async (ctx) => {
|
||
await ctx.db.patch(threadId, { latestAgentJobId: failedJobId });
|
||
});
|
||
|
||
const newJobId = await authed(t, ownerId).mutation(
|
||
api.agentJobs.createForThread,
|
||
{
|
||
threadId,
|
||
jobType: 'user_change',
|
||
},
|
||
);
|
||
|
||
expect(newJobId).not.toBe(failedJobId);
|
||
});
|
||
});
|