refactor(server): move the team runtime into a postponed package (P1.1)
Team mode stays in the repository but is not built or shipped (ADR-0003). - The team server (index.ts, config, db, daemons, plugins, proactive, routes, scheduler, services, ws, drizzle migrations) and its tests move from @waggle/server to packages/team-server (@waggle/team-server, private). It keeps its own copies of the logger and the agent-group executor, so it does not import @waggle/server. @clerk/fastify, bullmq, ioredis, postgres, drizzle-orm, drizzle-kit, cron-parser and @waggle/waggle-dance leave @waggle/server; the launcher drops the same team-only dependencies. - build:packages no longer builds waggle-dance or the worker: nothing in the community edition imports them, and the worker's project reference would otherwise build the team server. The worker now imports from team-server; the team Dockerfile builds both explicitly. - The sidecar no longer starts the team server when DATABASE_URL is set, and loses the team routes (/api/team/*, /api/teams), the WaggleDance routes and bridge (/api/waggle-dance/*), the Team server binding and egress guard, the WebSocket team client, the TeamSync cache and pushes, team audit forwarding, team workspace registration and the team capability-policy lookup in chat. The in-process room signal bus stays: agent groups, fleet runs and external tool runs use it. middleware/audit.ts was dead and is deleted. - @waggle/core loses TeamSync and the teamServer part of WaggleConfig. A teamServer key in config.json is ignored and kept on save, as P0.1 does for the tier keys. Workspaces lose teamServerUrl and teamUserId; teamId and teamRole stay because workspaces from a shared data directory still carry them and the viewer write guards read them. POST /api/workspaces ignores team fields. - The sidecar bundle no longer marks the team packages as external. The agent still references the TeamSync type in orchestrator.ts and pattern-write-back.ts; those files are being rewritten in P1.5 and drop it there. Logs UF-030 and UF-031 (team sync and team policy defects found while removing the code).
This commit is contained in:
234
packages/team-server/tests/audit.test.ts
Normal file
234
packages/team-server/tests/audit.test.ts
Normal file
@@ -0,0 +1,234 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import type { FastifyRequest, FastifyReply } from 'fastify';
|
||||
import { buildServer } from '../src/index.js';
|
||||
import { users, teams, teamMembers, agentAuditLog } from '../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
import { AuditService } from '../src/services/audit-service.js';
|
||||
|
||||
describe('Audit & Traceability (Task 3.23)', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'audit_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'audit-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'audit_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'audit_owner',
|
||||
displayName: 'Audit Owner',
|
||||
email: 'audit_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'audit_member',
|
||||
displayName: 'Audit Member',
|
||||
email: 'audit_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
// Create team
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Audit Test Team',
|
||||
slug: 'audit-test',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
teamSlug = team.slug;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
// Override auth handler for testing
|
||||
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'audit_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'audit-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'audit_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('logs an audit entry via AuditService', async () => {
|
||||
const auditService = new AuditService(server.db);
|
||||
const entry = await auditService.log({
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'memory-weaver',
|
||||
actionType: 'consolidation',
|
||||
description: 'Consolidated 5 memory fragments into 1 summary',
|
||||
beforeState: { fragmentCount: 5 },
|
||||
afterState: { summaryId: 'abc123' },
|
||||
});
|
||||
|
||||
expect(entry).toBeDefined();
|
||||
expect(entry.agentName).toBe('memory-weaver');
|
||||
expect(entry.actionType).toBe('consolidation');
|
||||
expect(entry.description).toBe('Consolidated 5 memory fragments into 1 summary');
|
||||
expect(entry.beforeState).toEqual({ fragmentCount: 5 });
|
||||
expect(entry.afterState).toEqual({ summaryId: 'abc123' });
|
||||
expect(entry.requiresApproval).toBe(false);
|
||||
expect(entry.approved).toBeNull();
|
||||
});
|
||||
|
||||
it('lists audit entries for team', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/admin/teams/${teamSlug}/audit`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body[0].agentName).toBe('memory-weaver');
|
||||
});
|
||||
|
||||
it('filters by actionType', async () => {
|
||||
// Add another entry with different actionType
|
||||
const auditService = new AuditService(server.db);
|
||||
await auditService.log({
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'scout',
|
||||
actionType: 'discovery',
|
||||
description: 'Found new relevant paper',
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/admin/teams/${teamSlug}/audit?actionType=discovery`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.length).toBe(1);
|
||||
expect(body[0].actionType).toBe('discovery');
|
||||
expect(body[0].agentName).toBe('scout');
|
||||
});
|
||||
|
||||
it('approves a pending entry', async () => {
|
||||
const auditService = new AuditService(server.db);
|
||||
const pending = await auditService.log({
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'hive-mind',
|
||||
actionType: 'share_knowledge',
|
||||
description: 'Share pricing analysis with team graph',
|
||||
requiresApproval: true,
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/admin/teams/${teamSlug}/audit/${pending.id}/approve`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.approved).toBe(true);
|
||||
expect(body.approvedBy).toBe(ownerId);
|
||||
});
|
||||
|
||||
it('rejects a pending entry', async () => {
|
||||
const auditService = new AuditService(server.db);
|
||||
const pending = await auditService.log({
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'subconscious',
|
||||
actionType: 'auto_task',
|
||||
description: 'Create follow-up task from meeting notes',
|
||||
requiresApproval: true,
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/admin/teams/${teamSlug}/audit/${pending.id}/reject`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.approved).toBe(false);
|
||||
expect(body.approvedBy).toBe(ownerId);
|
||||
});
|
||||
|
||||
it('only team admins can access audit endpoints (non-admin gets 403)', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/admin/teams/${teamSlug}/audit`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.error).toBe('Admin access required');
|
||||
});
|
||||
|
||||
it('returns 404 for non-existent audit entry on approve', async () => {
|
||||
const fakeId = '00000000-0000-0000-0000-000000000000';
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/admin/teams/${teamSlug}/audit/${fakeId}/approve`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
});
|
||||
|
||||
it('lists pending approvals', async () => {
|
||||
const auditService = new AuditService(server.db);
|
||||
// Create a new pending entry
|
||||
await auditService.log({
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'hive-mind',
|
||||
actionType: 'bulk_share',
|
||||
description: 'Share 10 entities with team',
|
||||
requiresApproval: true,
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/admin/teams/${teamSlug}/audit/pending`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
// All returned entries should require approval and have null approved
|
||||
for (const entry of body) {
|
||||
expect(entry.requiresApproval).toBe(true);
|
||||
expect(entry.approved).toBeNull();
|
||||
}
|
||||
});
|
||||
});
|
||||
167
packages/team-server/tests/auth.test.ts
Normal file
167
packages/team-server/tests/auth.test.ts
Normal file
@@ -0,0 +1,167 @@
|
||||
import { createHmac } from 'node:crypto';
|
||||
import { describe, it, expect, afterAll, beforeAll } from 'vitest';
|
||||
import { buildServer } from '../src/index.js';
|
||||
import { users } from '../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
import { UserService } from '../src/services/user-service.js';
|
||||
|
||||
const SIGNING_KEY = Buffer.from('waggle-clerk-auth-integration-test-secret');
|
||||
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
|
||||
|
||||
function signedHeaders(payload: object) {
|
||||
const id = 'msg_waggle_clerk_auth_integration';
|
||||
const timestamp = Math.floor(Date.now() / 1000);
|
||||
const signature = createHmac('sha256', SIGNING_KEY)
|
||||
.update(`${id}.${timestamp}.${JSON.stringify(payload)}`)
|
||||
.digest('base64');
|
||||
|
||||
return {
|
||||
'svix-id': id,
|
||||
'svix-timestamp': String(timestamp),
|
||||
'svix-signature': `v1,${signature}`,
|
||||
};
|
||||
}
|
||||
|
||||
describe('Clerk webhook', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let originalSigningSecret: string | undefined;
|
||||
|
||||
beforeAll(async () => {
|
||||
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
|
||||
server = await buildServer();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'test_%'`);
|
||||
await server.close();
|
||||
if (originalSigningSecret === undefined) {
|
||||
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
} else {
|
||||
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
|
||||
}
|
||||
});
|
||||
|
||||
it('creates user on user.created webhook', async () => {
|
||||
const payload = {
|
||||
type: 'user.created',
|
||||
data: {
|
||||
id: 'test_clerk_001',
|
||||
first_name: 'Marko',
|
||||
last_name: 'Markovic',
|
||||
email_addresses: [{ email_address: 'marko@test.com' }],
|
||||
image_url: 'https://example.com/avatar.jpg',
|
||||
},
|
||||
};
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(payload),
|
||||
payload,
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const [user] = await server.db.select().from(users).where(sql`clerk_id = 'test_clerk_001'`);
|
||||
expect(user).toBeDefined();
|
||||
expect(user.displayName).toBe('Marko Markovic');
|
||||
expect(user.email).toBe('marko@test.com');
|
||||
});
|
||||
|
||||
it('updates user on user.updated webhook', async () => {
|
||||
const payload = {
|
||||
type: 'user.updated',
|
||||
data: {
|
||||
id: 'test_clerk_001',
|
||||
first_name: 'Marko',
|
||||
last_name: 'Updated',
|
||||
email_addresses: [{ email_address: 'marko@test.com' }],
|
||||
image_url: null,
|
||||
},
|
||||
};
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(payload),
|
||||
payload,
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const [user] = await server.db.select().from(users).where(sql`clerk_id = 'test_clerk_001'`);
|
||||
expect(user.displayName).toBe('Marko Updated');
|
||||
});
|
||||
|
||||
it('deletes user on user.deleted webhook', async () => {
|
||||
const payload = {
|
||||
type: 'user.deleted',
|
||||
data: {
|
||||
id: 'test_clerk_001',
|
||||
},
|
||||
};
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(payload),
|
||||
payload,
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const result = await server.db.select().from(users).where(sql`clerk_id = 'test_clerk_001'`);
|
||||
expect(result).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('UserService.upsertFromClerk', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let userService: UserService;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
userService = new UserService(server.db);
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'test_upsert_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('creates a new user when clerkId does not exist', async () => {
|
||||
const user = await userService.upsertFromClerk({
|
||||
clerkId: 'test_upsert_new',
|
||||
displayName: 'New User',
|
||||
email: 'new@test.com',
|
||||
avatarUrl: 'https://example.com/avatar.jpg',
|
||||
});
|
||||
|
||||
expect(user).toBeDefined();
|
||||
expect(user.clerkId).toBe('test_upsert_new');
|
||||
expect(user.displayName).toBe('New User');
|
||||
expect(user.email).toBe('new@test.com');
|
||||
expect(user.id).toBeTruthy();
|
||||
});
|
||||
|
||||
it('updates existing user when clerkId already exists', async () => {
|
||||
// First create
|
||||
await userService.upsertFromClerk({
|
||||
clerkId: 'test_upsert_existing',
|
||||
displayName: 'Original Name',
|
||||
email: 'original@test.com',
|
||||
});
|
||||
|
||||
// Then upsert with updated data
|
||||
const updated = await userService.upsertFromClerk({
|
||||
clerkId: 'test_upsert_existing',
|
||||
displayName: 'Updated Name',
|
||||
email: 'updated@test.com',
|
||||
avatarUrl: 'https://new-avatar.com/pic.jpg',
|
||||
});
|
||||
|
||||
expect(updated.displayName).toBe('Updated Name');
|
||||
expect(updated.email).toBe('updated@test.com');
|
||||
expect(updated.avatarUrl).toBe('https://new-avatar.com/pic.jpg');
|
||||
});
|
||||
|
||||
it('getByClerkId returns null for unknown clerkId', async () => {
|
||||
const result = await userService.getByClerkId('nonexistent_clerk_id');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
53
packages/team-server/tests/config.test.ts
Normal file
53
packages/team-server/tests/config.test.ts
Normal file
@@ -0,0 +1,53 @@
|
||||
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
|
||||
import { loadConfig } from '../src/config.js';
|
||||
|
||||
// Guards the CORS_ORIGIN fail-closed contract on the TEAM server config
|
||||
// (packages/server/src/config.ts). The team server (index.ts) is the only
|
||||
// consumer of config.corsOrigin; the desktop/local server uses the separate
|
||||
// hardcoded ALLOWED_ORIGINS allowlist (local/cors-config.ts) and is unaffected.
|
||||
describe('loadConfig — CORS_ORIGIN', () => {
|
||||
const SAVED = {
|
||||
CORS_ORIGIN: process.env.CORS_ORIGIN,
|
||||
NODE_ENV: process.env.NODE_ENV,
|
||||
DATABASE_URL: process.env.DATABASE_URL,
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
delete process.env.CORS_ORIGIN;
|
||||
delete process.env.NODE_ENV;
|
||||
// DATABASE_URL also fails closed in production; set it so we isolate the
|
||||
// CORS_ORIGIN behavior under test.
|
||||
process.env.DATABASE_URL = 'postgres://localhost:5434/waggle';
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
for (const [k, v] of Object.entries(SAVED)) {
|
||||
if (v === undefined) delete process.env[k];
|
||||
else process.env[k] = v;
|
||||
}
|
||||
});
|
||||
|
||||
it('defaults to the localhost dev origin when CORS_ORIGIN is unset (non-production)', () => {
|
||||
expect(loadConfig().corsOrigin).toEqual(['http://localhost:5173']);
|
||||
});
|
||||
|
||||
it('FAILS CLOSED in production when CORS_ORIGIN is unset (no silent localhost fallback)', () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
expect(() => loadConfig()).toThrow(/CORS_ORIGIN.*required in production/);
|
||||
});
|
||||
|
||||
it('parses a comma-separated list, trimming whitespace and dropping empties', () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
process.env.CORS_ORIGIN = 'https://app.example.com, https://admin.example.com ,';
|
||||
expect(loadConfig().corsOrigin).toEqual([
|
||||
'https://app.example.com',
|
||||
'https://admin.example.com',
|
||||
]);
|
||||
});
|
||||
|
||||
it('accepts a single explicit origin in production', () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
process.env.CORS_ORIGIN = 'https://app.example.com';
|
||||
expect(loadConfig().corsOrigin).toEqual(['https://app.example.com']);
|
||||
});
|
||||
});
|
||||
616
packages/team-server/tests/cron.test.ts
Normal file
616
packages/team-server/tests/cron.test.ts
Normal file
@@ -0,0 +1,616 @@
|
||||
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import type { FastifyRequest, FastifyReply } from 'fastify';
|
||||
import { Queue } from 'bullmq';
|
||||
import { buildServer } from '../src/index.js';
|
||||
import { users, teams, teamMembers, cronSchedules, agentJobs } from '../src/db/schema.js';
|
||||
import { sql, eq } from 'drizzle-orm';
|
||||
import { CronRunner } from '../src/scheduler/cron-runner.js';
|
||||
import { CronService } from '../src/services/cron-service.js';
|
||||
import { JobService } from '../src/services/job-service.js';
|
||||
|
||||
async function waitFor(
|
||||
predicate: () => Promise<boolean>,
|
||||
message: string,
|
||||
timeoutMs = 1_000,
|
||||
): Promise<void> {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (await predicate()) return;
|
||||
await new Promise(resolve => setTimeout(resolve, 10));
|
||||
}
|
||||
throw new Error(message);
|
||||
}
|
||||
|
||||
describe('Cron Scheduler (Task 3.16)', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let attackerId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
let attackerTeamSlug: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'crontest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'crontest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'crontest_owner',
|
||||
displayName: 'Cron Owner',
|
||||
email: 'crontest_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'crontest_member',
|
||||
displayName: 'Cron Member',
|
||||
email: 'crontest_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
const [attacker] = await server.db.insert(users).values({
|
||||
clerkId: 'crontest_attacker',
|
||||
displayName: 'Cron Attacker',
|
||||
email: 'crontest_attacker@test.com',
|
||||
}).returning();
|
||||
attackerId = attacker.id;
|
||||
|
||||
// Create team
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Cron Test Team',
|
||||
slug: 'crontest-cron',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
teamSlug = team.slug;
|
||||
|
||||
const [attackerTeam] = await server.db.insert(teams).values({
|
||||
name: 'Cron Attacker Team',
|
||||
slug: 'crontest-attacker',
|
||||
ownerId: attackerId,
|
||||
}).returning();
|
||||
attackerTeamSlug = attackerTeam.slug;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
{ teamId: attackerTeam.id, userId: attackerId, role: 'owner' },
|
||||
]);
|
||||
|
||||
// Override auth handler for testing
|
||||
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'crontest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'crontest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('creates a cron schedule with computed next_run_at', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
name: 'Daily Report',
|
||||
cronExpr: '0 9 * * *',
|
||||
jobType: 'task',
|
||||
jobConfig: { prompt: 'Generate daily report' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.name).toBe('Daily Report');
|
||||
expect(body.cronExpr).toBe('0 9 * * *');
|
||||
expect(body.jobType).toBe('task');
|
||||
expect(body.enabled).toBe(true);
|
||||
expect(body.nextRunAt).toBeTruthy();
|
||||
expect(new Date(body.nextRunAt).getTime()).toBeGreaterThan(Date.now());
|
||||
expect(body.lastRunAt).toBeNull();
|
||||
});
|
||||
|
||||
it('lists schedules for team', async () => {
|
||||
// Create another schedule
|
||||
await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: {
|
||||
name: 'Hourly Check',
|
||||
cronExpr: '0 * * * *',
|
||||
jobType: 'chat',
|
||||
},
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(2);
|
||||
});
|
||||
|
||||
it('returns the same not-found response for missing and foreign-team schedule ids without mutation', async () => {
|
||||
const createRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
name: 'Victim Schedule',
|
||||
cronExpr: '15 * * * *',
|
||||
jobType: 'task',
|
||||
},
|
||||
});
|
||||
const schedule = JSON.parse(createRes.body);
|
||||
|
||||
const foreignRes = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${attackerTeamSlug}/cron/${schedule.id}`,
|
||||
headers: { 'x-test-user-id': attackerId },
|
||||
payload: { name: 'Hijacked Schedule', enabled: false },
|
||||
});
|
||||
const missingRes = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${attackerTeamSlug}/cron/00000000-0000-4000-8000-000000000001`,
|
||||
headers: { 'x-test-user-id': attackerId },
|
||||
payload: { enabled: false },
|
||||
});
|
||||
|
||||
expect(foreignRes.statusCode).toBe(404);
|
||||
expect(foreignRes.json()).toEqual({ error: 'Schedule not found' });
|
||||
expect(missingRes.statusCode).toBe(404);
|
||||
expect(missingRes.json()).toEqual(foreignRes.json());
|
||||
|
||||
const [persisted] = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, schedule.id));
|
||||
expect(persisted.name).toBe('Victim Schedule');
|
||||
expect(persisted.enabled).toBe(true);
|
||||
});
|
||||
|
||||
it('disables a schedule via PATCH', async () => {
|
||||
// Create a schedule to disable
|
||||
const createRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
name: 'To Disable',
|
||||
cronExpr: '*/30 * * * *',
|
||||
jobType: 'task',
|
||||
},
|
||||
});
|
||||
const schedule = JSON.parse(createRes.body);
|
||||
expect(schedule.enabled).toBe(true);
|
||||
|
||||
const patchRes = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/cron/${schedule.id}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { enabled: false },
|
||||
});
|
||||
|
||||
expect(patchRes.statusCode).toBe(200);
|
||||
const updated = JSON.parse(patchRes.body);
|
||||
expect(updated.enabled).toBe(false);
|
||||
});
|
||||
|
||||
it.each(['cron', 'shell'])('rejects unsupported scheduled job type %s before persistence', async (jobType) => {
|
||||
const name = `Unsupported ${jobType}`;
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
name,
|
||||
cronExpr: '0 4 * * *',
|
||||
jobType,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
const schedules = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.teamId, teamId));
|
||||
expect(schedules.some(schedule => schedule.name === name)).toBe(false);
|
||||
});
|
||||
|
||||
it('CronService refuses unsupported job types outside route validation', async () => {
|
||||
const cronService = new CronService(server.db);
|
||||
|
||||
await expect(cronService.create(teamId, ownerId, {
|
||||
name: 'Direct Unsafe Schedule',
|
||||
cronExpr: '0 5 * * *',
|
||||
jobType: 'shell',
|
||||
})).rejects.toThrow('Unsupported scheduled job type: shell');
|
||||
|
||||
const schedules = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.teamId, teamId));
|
||||
expect(schedules.some(schedule => schedule.name === 'Direct Unsafe Schedule')).toBe(false);
|
||||
});
|
||||
|
||||
it('CronRunner.tick() picks up due schedule and queues job', async () => {
|
||||
// Snapshot job count before tick
|
||||
const jobsBefore = await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId));
|
||||
const beforeCount = jobsBefore.length;
|
||||
|
||||
// Create a schedule with next_run_at in the past so it's immediately due
|
||||
const pastDate = new Date(Date.now() - 60_000);
|
||||
await server.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Due Now',
|
||||
cronExpr: '* * * * *', // every minute
|
||||
jobType: 'task',
|
||||
jobConfig: { prompt: 'Cron runner test' },
|
||||
enabled: true,
|
||||
nextRunAt: pastDate,
|
||||
}).returning();
|
||||
|
||||
const runner = new CronRunner(server.db, server.jobService);
|
||||
const count = await runner.tick();
|
||||
|
||||
expect(count).toBeGreaterThanOrEqual(1);
|
||||
|
||||
// Verify our specific job was created
|
||||
const jobsAfter = await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId));
|
||||
const cronJob = jobsAfter.find(j => (j.input as { prompt?: string }).prompt === 'Cron runner test');
|
||||
expect(cronJob).toBeTruthy();
|
||||
expect(cronJob!.jobType).toBe('task');
|
||||
expect(cronJob!.status).toBe('queued');
|
||||
expect(jobsAfter.length).toBeGreaterThan(beforeCount);
|
||||
});
|
||||
|
||||
it('updates last_run_at and next_run_at after tick', async () => {
|
||||
// Create a due schedule
|
||||
const pastDate = new Date(Date.now() - 120_000);
|
||||
const [schedule] = await server.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Check After Tick',
|
||||
cronExpr: '*/5 * * * *', // every 5 minutes
|
||||
jobType: 'chat',
|
||||
jobConfig: {},
|
||||
enabled: true,
|
||||
nextRunAt: pastDate,
|
||||
}).returning();
|
||||
|
||||
const runner = new CronRunner(server.db, server.jobService);
|
||||
await runner.tick();
|
||||
|
||||
// Re-read the schedule
|
||||
const [updated] = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, schedule.id));
|
||||
|
||||
expect(updated.lastRunAt).toBeTruthy();
|
||||
expect(new Date(updated.lastRunAt!).getTime()).toBeGreaterThan(pastDate.getTime());
|
||||
expect(updated.nextRunAt).toBeTruthy();
|
||||
expect(new Date(updated.nextRunAt!).getTime()).toBeGreaterThan(Date.now());
|
||||
});
|
||||
|
||||
it('runs due schedules through the Fastify lifecycle without a manual tick', async () => {
|
||||
const lifecycleConfig = { port: 0 };
|
||||
const lifecycleServer = await buildServer(lifecycleConfig);
|
||||
const marker = `lifecycle-${Date.now()}`;
|
||||
let scheduleId: string | undefined;
|
||||
|
||||
try {
|
||||
const [schedule] = await lifecycleServer.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Lifecycle Due Schedule',
|
||||
cronExpr: '* * * * *',
|
||||
jobType: 'task',
|
||||
jobConfig: { marker, prompt: 'Lifecycle cron test' },
|
||||
enabled: true,
|
||||
nextRunAt: new Date(Date.now() - 60_000),
|
||||
}).returning();
|
||||
scheduleId = schedule.id;
|
||||
expect(schedule.lastRunAt).toBeNull();
|
||||
|
||||
await lifecycleServer.ready();
|
||||
await waitFor(async () => {
|
||||
const [persisted] = await lifecycleServer.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, schedule.id));
|
||||
return persisted?.lastRunAt !== null;
|
||||
}, 'Fastify lifecycle did not advance the due cron schedule');
|
||||
|
||||
const [advanced] = await lifecycleServer.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, schedule.id));
|
||||
expect(advanced.nextRunAt?.getTime()).toBeGreaterThan(Date.now());
|
||||
|
||||
const jobs = await lifecycleServer.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId));
|
||||
expect(jobs.some(job => (job.input as { marker?: string }).marker === marker)).toBe(true);
|
||||
} finally {
|
||||
const jobs = await lifecycleServer.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId));
|
||||
for (const job of jobs.filter(item => (item.input as { marker?: string }).marker === marker)) {
|
||||
await lifecycleServer.jobService.cancelJob(job.id);
|
||||
}
|
||||
if (scheduleId) {
|
||||
await lifecycleServer.db.delete(cronSchedules)
|
||||
.where(eq(cronSchedules.id, scheduleId));
|
||||
}
|
||||
await lifecycleServer.close();
|
||||
}
|
||||
});
|
||||
|
||||
it('skips a legacy invalid cron expression before queueing and continues later schedules', async () => {
|
||||
const pastDate = new Date(Date.now() - 60_000);
|
||||
const invalidMarker = `invalid-cron-${Date.now()}`;
|
||||
const validMarker = `valid-after-invalid-${Date.now()}`;
|
||||
const [invalidSchedule] = await server.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Legacy Invalid Cron',
|
||||
cronExpr: 'not a cron expression',
|
||||
jobType: 'task',
|
||||
jobConfig: { marker: invalidMarker },
|
||||
enabled: true,
|
||||
nextRunAt: pastDate,
|
||||
}).returning();
|
||||
const [validSchedule] = await server.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Valid After Invalid Cron',
|
||||
cronExpr: '* * * * *',
|
||||
jobType: 'task',
|
||||
jobConfig: { marker: validMarker },
|
||||
enabled: true,
|
||||
nextRunAt: pastDate,
|
||||
}).returning();
|
||||
const errors: unknown[] = [];
|
||||
const runner = new CronRunner(server.db, server.jobService, error => errors.push(error));
|
||||
let validJob: typeof agentJobs.$inferSelect | undefined;
|
||||
|
||||
try {
|
||||
await expect(runner.tick()).resolves.toBe(1);
|
||||
const jobs = await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId));
|
||||
expect(jobs.some(job => (job.input as { marker?: string }).marker === invalidMarker)).toBe(false);
|
||||
validJob = jobs.find(job => (job.input as { marker?: string }).marker === validMarker);
|
||||
expect(validJob?.status).toBe('queued');
|
||||
expect(errors).toHaveLength(1);
|
||||
|
||||
const [persistedInvalid] = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, invalidSchedule.id));
|
||||
expect(persistedInvalid.lastRunAt).toBeNull();
|
||||
expect(persistedInvalid.nextRunAt?.getTime()).toBe(pastDate.getTime());
|
||||
} finally {
|
||||
if (validJob) await server.jobService.cancelJob(validJob.id);
|
||||
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, invalidSchedule.id));
|
||||
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, validSchedule.id));
|
||||
}
|
||||
});
|
||||
|
||||
it('deduplicates one due occurrence across concurrent runners', async () => {
|
||||
const marker = `concurrent-occurrence-${Date.now()}`;
|
||||
const [schedule] = await server.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Concurrent Occurrence',
|
||||
cronExpr: '* * * * *',
|
||||
jobType: 'task',
|
||||
jobConfig: { marker },
|
||||
enabled: true,
|
||||
nextRunAt: new Date(Date.now() - 60_000),
|
||||
}).returning();
|
||||
|
||||
const originalCreate = server.jobService.createJob.bind(server.jobService);
|
||||
let arrivals = 0;
|
||||
let release!: () => void;
|
||||
const bothSelected = new Promise<void>(resolve => { release = resolve; });
|
||||
const createSpy = vi.spyOn(server.jobService, 'createJob').mockImplementation(async (...args) => {
|
||||
arrivals++;
|
||||
if (arrivals === 2) release();
|
||||
await bothSelected;
|
||||
return originalCreate(...args);
|
||||
});
|
||||
let jobs: Array<typeof agentJobs.$inferSelect> = [];
|
||||
|
||||
try {
|
||||
const first = new CronRunner(server.db, server.jobService);
|
||||
const second = new CronRunner(server.db, server.jobService);
|
||||
const counts = await Promise.all([first.tick(), second.tick()]);
|
||||
|
||||
jobs = (await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId)))
|
||||
.filter(job => (job.input as { marker?: string }).marker === marker);
|
||||
expect(jobs).toHaveLength(1);
|
||||
expect(counts[0] + counts[1]).toBe(1);
|
||||
} finally {
|
||||
createSpy.mockRestore();
|
||||
for (const job of jobs) await server.jobService.cancelJob(job.id);
|
||||
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, schedule.id));
|
||||
}
|
||||
});
|
||||
|
||||
it('reuses the same occurrence job after a post-enqueue schedule-update failure', async () => {
|
||||
const marker = `retry-occurrence-${Date.now()}`;
|
||||
const [schedule] = await server.db.insert(cronSchedules).values({
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Retry Occurrence',
|
||||
cronExpr: '* * * * *',
|
||||
jobType: 'task',
|
||||
jobConfig: { marker },
|
||||
enabled: true,
|
||||
nextRunAt: new Date(Date.now() - 60_000),
|
||||
}).returning();
|
||||
const errors: unknown[] = [];
|
||||
const runner = new CronRunner(server.db, server.jobService, error => errors.push(error));
|
||||
const updateSpy = vi.spyOn(server.db, 'update').mockImplementationOnce(() => {
|
||||
throw new Error('simulated schedule update failure');
|
||||
});
|
||||
let jobs: Array<typeof agentJobs.$inferSelect> = [];
|
||||
|
||||
try {
|
||||
try {
|
||||
expect(await runner.tick()).toBe(0);
|
||||
expect(errors).toHaveLength(1);
|
||||
} finally {
|
||||
updateSpy.mockRestore();
|
||||
}
|
||||
|
||||
expect(await runner.tick()).toBe(1);
|
||||
jobs = (await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId)))
|
||||
.filter(job => (job.input as { marker?: string }).marker === marker);
|
||||
expect(jobs).toHaveLength(1);
|
||||
} finally {
|
||||
for (const job of jobs) await server.jobService.cancelJob(job.id);
|
||||
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, schedule.id));
|
||||
}
|
||||
});
|
||||
|
||||
it('queues the persisted canonical payload when an occurrence retry input differs', async () => {
|
||||
const queueName = `cron-canonical-${Date.now()}`;
|
||||
const redisUrl = new URL(process.env.REDIS_URL ?? 'redis://localhost:6381');
|
||||
const jobService = new JobService(server.db, redisUrl.href, queueName);
|
||||
const queue = new Queue(queueName, {
|
||||
connection: {
|
||||
host: redisUrl.hostname,
|
||||
port: parseInt(redisUrl.port || '6379', 10),
|
||||
},
|
||||
});
|
||||
const jobId = randomUUID();
|
||||
|
||||
try {
|
||||
await jobService.createJob(teamId, ownerId, 'task', { marker: 'canonical' }, jobId);
|
||||
const firstQueueJob = await queue.getJob(jobId);
|
||||
expect(firstQueueJob).toBeTruthy();
|
||||
await firstQueueJob!.remove();
|
||||
|
||||
await jobService.createJob(teamId, ownerId, 'task', { marker: 'conflicting-retry' }, jobId);
|
||||
const [persisted] = await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.id, jobId));
|
||||
const retriedQueueJob = await queue.getJob(jobId);
|
||||
|
||||
expect(persisted.input).toEqual({ marker: 'canonical' });
|
||||
expect(retriedQueueJob?.data.input).toEqual(persisted.input);
|
||||
} finally {
|
||||
const queued = await queue.getJob(jobId);
|
||||
if (queued) await queued.remove();
|
||||
await server.db.delete(agentJobs).where(eq(agentJobs.id, jobId));
|
||||
await queue.close();
|
||||
await jobService.close();
|
||||
}
|
||||
});
|
||||
|
||||
it('skips an unsafe legacy schedule while queueing an allowed due schedule', async () => {
|
||||
const pastDate = new Date(Date.now() - 60_000);
|
||||
const [unsafeSchedule, validSchedule] = await server.db.insert(cronSchedules).values([
|
||||
{
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Legacy Recursive Cron',
|
||||
cronExpr: '* * * * *',
|
||||
jobType: 'cron',
|
||||
jobConfig: { marker: 'blocked-recursive-cron' },
|
||||
enabled: true,
|
||||
nextRunAt: pastDate,
|
||||
},
|
||||
{
|
||||
teamId,
|
||||
createdBy: ownerId,
|
||||
name: 'Allowed Due Chat',
|
||||
cronExpr: '* * * * *',
|
||||
jobType: 'chat',
|
||||
jobConfig: { marker: 'allowed-due-chat', message: 'Scheduled read-only check' },
|
||||
enabled: true,
|
||||
nextRunAt: pastDate,
|
||||
},
|
||||
]).returning();
|
||||
|
||||
const runner = new CronRunner(server.db, server.jobService);
|
||||
let unsafeJob: typeof agentJobs.$inferSelect | undefined;
|
||||
let validJob: typeof agentJobs.$inferSelect | undefined;
|
||||
|
||||
try {
|
||||
const count = await runner.tick();
|
||||
const jobs = await server.db.select().from(agentJobs)
|
||||
.where(eq(agentJobs.teamId, teamId));
|
||||
unsafeJob = jobs.find(job => (job.input as { marker?: string }).marker === 'blocked-recursive-cron');
|
||||
validJob = jobs.find(job => (job.input as { marker?: string }).marker === 'allowed-due-chat');
|
||||
|
||||
expect(count).toBe(1);
|
||||
expect(unsafeJob).toBeUndefined();
|
||||
expect(validJob?.jobType).toBe('chat');
|
||||
|
||||
const [persistedUnsafe] = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, unsafeSchedule.id));
|
||||
const [persistedValid] = await server.db.select().from(cronSchedules)
|
||||
.where(eq(cronSchedules.id, validSchedule.id));
|
||||
expect(persistedUnsafe.lastRunAt).toBeNull();
|
||||
expect(persistedUnsafe.nextRunAt?.getTime()).toBe(pastDate.getTime());
|
||||
expect(persistedValid.lastRunAt).toBeTruthy();
|
||||
expect(persistedValid.nextRunAt!.getTime()).toBeGreaterThan(Date.now());
|
||||
} finally {
|
||||
if (unsafeJob) await server.jobService.cancelJob(unsafeJob.id);
|
||||
if (validJob) await server.jobService.cancelJob(validJob.id);
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects invalid cron expression', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
name: 'Bad Cron',
|
||||
cronExpr: 'not a cron',
|
||||
jobType: 'task',
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
|
||||
it('non-member gets 403', async () => {
|
||||
// Create an outsider
|
||||
const [outsider] = await server.db.insert(users).values({
|
||||
clerkId: 'crontest_outsider',
|
||||
displayName: 'Cron Outsider',
|
||||
email: 'crontest_outsider@test.com',
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/cron`,
|
||||
headers: { 'x-test-user-id': outsider.id },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
});
|
||||
170
packages/team-server/tests/daemons/hive-mind.test.ts
Normal file
170
packages/team-server/tests/daemons/hive-mind.test.ts
Normal file
@@ -0,0 +1,170 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, teamResources, agentJobs, tasks, messages } from '../../src/db/schema.js';
|
||||
import { sql, eq } from 'drizzle-orm';
|
||||
import { HiveMindAgent } from '../../src/daemons/hive-mind.js';
|
||||
|
||||
describe('Hive Mind Agent (Task 3.20)', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let teamId: string;
|
||||
let hiveMind: HiveMindAgent;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'hivetest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'hive_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'hive_owner',
|
||||
displayName: 'Hive Owner',
|
||||
email: 'hive_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'hive_member',
|
||||
displayName: 'Hive Member',
|
||||
email: 'hive_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
// Create team
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Hive Test Team',
|
||||
slug: 'hivetest-team',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
// Seed data: completed jobs
|
||||
await server.db.insert(agentJobs).values(
|
||||
Array.from({ length: 5 }, (_, i) => ({
|
||||
teamId,
|
||||
userId: ownerId,
|
||||
jobType: 'chat',
|
||||
status: 'completed',
|
||||
input: { prompt: `job ${i}` },
|
||||
completedAt: new Date(),
|
||||
})),
|
||||
);
|
||||
|
||||
// Seed data: tasks with similar titles by different users (duplicate work)
|
||||
await server.db.insert(tasks).values([
|
||||
{ teamId, title: 'Setup CI/CD pipeline for backend', status: 'done', createdBy: ownerId },
|
||||
{ teamId, title: 'Setup CI/CD pipeline for frontend', status: 'done', createdBy: memberId },
|
||||
{ teamId, title: 'Write unit tests', status: 'done', createdBy: ownerId },
|
||||
]);
|
||||
|
||||
// Seed data: team resources with ratings
|
||||
await server.db.insert(teamResources).values([
|
||||
{
|
||||
teamId,
|
||||
resourceType: 'prompt_template',
|
||||
name: 'Best Code Review Prompt',
|
||||
description: 'A highly rated code review template',
|
||||
config: {},
|
||||
sharedBy: ownerId,
|
||||
rating: 4.5,
|
||||
},
|
||||
{
|
||||
teamId,
|
||||
resourceType: 'skill',
|
||||
name: 'Low Rated Skill',
|
||||
description: 'Not very useful',
|
||||
config: {},
|
||||
sharedBy: memberId,
|
||||
rating: 1.0,
|
||||
},
|
||||
]);
|
||||
|
||||
hiveMind = new HiveMindAgent(server.db);
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'hivetest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'hive_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('generates weekly digest with metrics', async () => {
|
||||
const { digest, messageId } = await hiveMind.generateWeeklyDigest(teamId);
|
||||
|
||||
expect(digest).toBeTruthy();
|
||||
expect(digest.metrics.jobsCompleted).toBe(5);
|
||||
expect(digest.metrics.tasksCompleted).toBe(3);
|
||||
expect(digest.metrics.resourcesShared).toBe(2);
|
||||
expect(digest.period.from).toBeInstanceOf(Date);
|
||||
expect(digest.period.to).toBeInstanceOf(Date);
|
||||
expect(messageId).toBeTruthy();
|
||||
});
|
||||
|
||||
it('detects duplicate work across team members', async () => {
|
||||
const { digest } = await hiveMind.generateWeeklyDigest(teamId);
|
||||
|
||||
// "Setup CI/CD pipeline" tasks by different users should be detected
|
||||
expect(digest.duplicateWork.length).toBeGreaterThan(0);
|
||||
const duplicate = digest.duplicateWork[0];
|
||||
expect(duplicate.users.length).toBe(2);
|
||||
expect(duplicate.titles.length).toBe(2);
|
||||
});
|
||||
|
||||
it('identifies best practices from high-rated resources', async () => {
|
||||
const { digest } = await hiveMind.generateWeeklyDigest(teamId);
|
||||
|
||||
// Only the high-rated resource (4.5 >= 3.0) should appear
|
||||
expect(digest.bestPractices.length).toBe(1);
|
||||
expect(digest.bestPractices[0].name).toBe('Best Code Review Prompt');
|
||||
expect(digest.bestPractices[0].rating).toBe(4.5);
|
||||
});
|
||||
|
||||
it('generates recommendations based on findings', async () => {
|
||||
const { digest } = await hiveMind.generateWeeklyDigest(teamId);
|
||||
|
||||
// Should have duplicate work recommendation
|
||||
expect(digest.recommendations.length).toBeGreaterThan(0);
|
||||
expect(digest.recommendations.some(r => r.includes('duplicate'))).toBe(true);
|
||||
// Should have best practices recommendation
|
||||
expect(digest.recommendations.some(r => r.includes('highly-rated'))).toBe(true);
|
||||
});
|
||||
|
||||
it('broadcasts digest as a waggle dance message', async () => {
|
||||
const { messageId } = await hiveMind.generateWeeklyDigest(teamId);
|
||||
|
||||
// Verify the message was stored
|
||||
const [msg] = await server.db.select().from(messages)
|
||||
.where(eq(messages.id, messageId));
|
||||
|
||||
expect(msg).toBeTruthy();
|
||||
expect(msg.type).toBe('broadcast');
|
||||
expect(msg.subtype).toBe('discovery');
|
||||
const digestContent = msg.content as { type: string; digest: unknown };
|
||||
expect(digestContent.type).toBe('weekly_digest');
|
||||
expect(digestContent.digest).toBeTruthy();
|
||||
});
|
||||
});
|
||||
223
packages/team-server/tests/daemons/scout.test.ts
Normal file
223
packages/team-server/tests/daemons/scout.test.ts
Normal file
@@ -0,0 +1,223 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import type { FastifyRequest, FastifyReply } from 'fastify';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, teamResources, agents, scoutFindings } from '../../src/db/schema.js';
|
||||
import { sql, eq } from 'drizzle-orm';
|
||||
import { ScoutAgent } from '../../src/daemons/scout.js';
|
||||
|
||||
describe('Scout Agent (Task 3.18)', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let userId: string;
|
||||
let secondUserId: string;
|
||||
let teamId: string;
|
||||
let scout: ScoutAgent;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM scout_findings WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'scouttest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'scout_%'`);
|
||||
|
||||
// Create test user
|
||||
const [user] = await server.db.insert(users).values({
|
||||
clerkId: 'scout_user1',
|
||||
displayName: 'Scout User',
|
||||
email: 'scout_user1@test.com',
|
||||
}).returning();
|
||||
userId = user.id;
|
||||
|
||||
const [secondUser] = await server.db.insert(users).values({
|
||||
clerkId: 'scout_user2',
|
||||
displayName: 'Scout User 2',
|
||||
email: 'scout_user2@test.com',
|
||||
}).returning();
|
||||
secondUserId = secondUser.id;
|
||||
|
||||
// Create team
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Scout Test Team',
|
||||
slug: 'scouttest-team',
|
||||
ownerId: userId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
|
||||
// Add membership with interests
|
||||
await server.db.insert(teamMembers).values({
|
||||
teamId,
|
||||
userId,
|
||||
role: 'owner',
|
||||
interests: ['python', 'data-science'],
|
||||
});
|
||||
|
||||
// Create an agent with tools for the user
|
||||
await server.db.insert(agents).values({
|
||||
userId,
|
||||
teamId,
|
||||
name: 'TestAgent',
|
||||
tools: ['web_search', 'code_review'],
|
||||
});
|
||||
|
||||
// Create team resources
|
||||
await server.db.insert(teamResources).values([
|
||||
{
|
||||
teamId,
|
||||
resourceType: 'skill',
|
||||
name: 'Python Data Analyzer',
|
||||
description: 'A skill for analyzing data with Python',
|
||||
config: {},
|
||||
sharedBy: userId,
|
||||
},
|
||||
{
|
||||
teamId,
|
||||
resourceType: 'prompt_template',
|
||||
name: 'Code Review Template',
|
||||
description: 'Template for code reviews',
|
||||
config: {},
|
||||
sharedBy: userId,
|
||||
},
|
||||
]);
|
||||
|
||||
scout = new ScoutAgent(server.db);
|
||||
|
||||
// Override auth handler
|
||||
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM scout_findings WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'scouttest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'scout_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('scan creates findings from team resources', async () => {
|
||||
const findings = await scout.scan(userId, teamId);
|
||||
expect(findings.length).toBeGreaterThanOrEqual(2);
|
||||
expect(findings.every((f) => f.status === 'new')).toBe(true);
|
||||
expect(findings.some((f) => f.title.includes('Python Data Analyzer'))).toBe(true);
|
||||
expect(findings.some((f) => f.title.includes('Code Review Template'))).toBe(true);
|
||||
});
|
||||
|
||||
it('relevance scoring boosts based on user interests', async () => {
|
||||
// The Python Data Analyzer should be boosted because user has 'python' interest
|
||||
const findings = await scout.listFindings(userId);
|
||||
const pythonFinding = findings.find((f) => f.title.includes('Python'));
|
||||
const templateFinding = findings.find((f) => f.title.includes('Code Review'));
|
||||
|
||||
expect(pythonFinding).toBeTruthy();
|
||||
expect(templateFinding).toBeTruthy();
|
||||
// Python finding should have higher score (base 0.5 + 0.3 interest boost)
|
||||
expect(pythonFinding!.relevanceScore).toBeGreaterThan(templateFinding!.relevanceScore);
|
||||
});
|
||||
|
||||
it('adopt updates status', async () => {
|
||||
const findings = await scout.listFindings(userId);
|
||||
const finding = findings[0];
|
||||
|
||||
const updated = await scout.adopt(finding.id, userId);
|
||||
expect(updated).toBeTruthy();
|
||||
expect(updated!.status).toBe('adopted');
|
||||
});
|
||||
|
||||
it('dismiss updates status', async () => {
|
||||
const findings = await scout.listFindings(userId);
|
||||
const newFinding = findings.find((f) => f.status === 'new');
|
||||
expect(newFinding).toBeTruthy();
|
||||
|
||||
const updated = await scout.dismiss(newFinding!.id, userId);
|
||||
expect(updated).toBeTruthy();
|
||||
expect(updated!.status).toBe('dismissed');
|
||||
});
|
||||
|
||||
it('dismissed finding not resurfaced in future scans', async () => {
|
||||
// Clear all non-dismissed findings
|
||||
const allFindings = await scout.listFindings(userId);
|
||||
const dismissed = allFindings.filter((f) => f.status === 'dismissed');
|
||||
expect(dismissed.length).toBeGreaterThan(0);
|
||||
|
||||
// Run scan again — dismissed titles should not reappear as new
|
||||
const newFindings = await scout.scan(userId, teamId);
|
||||
const dismissedTitles = dismissed.map((f) => f.title);
|
||||
const resurfaced = newFindings.filter((f) => dismissedTitles.includes(f.title));
|
||||
expect(resurfaced.length).toBe(0);
|
||||
});
|
||||
|
||||
it('GET /api/scout/findings returns findings for user', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/scout/findings',
|
||||
headers: { 'x-test-user-id': userId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it.each(['adopted', 'dismissed'] as const)(
|
||||
'does not let one user mark another user\'s finding as %s',
|
||||
async (status) => {
|
||||
const [victimFinding] = await server.db.insert(scoutFindings).values({
|
||||
userId: secondUserId,
|
||||
teamId,
|
||||
source: 'team',
|
||||
category: 'practice',
|
||||
title: `Victim finding ${status}`,
|
||||
summary: 'belongs to another user',
|
||||
relevanceScore: 0.8,
|
||||
url: null,
|
||||
status: 'new',
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/scout/findings/${victimFinding.id}`,
|
||||
headers: { 'x-test-user-id': userId },
|
||||
payload: { status },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json()).toEqual({ error: 'Finding not found' });
|
||||
const [unchanged] = await server.db.select().from(scoutFindings)
|
||||
.where(eq(scoutFindings.id, victimFinding.id));
|
||||
expect(unchanged.status).toBe('new');
|
||||
expect(unchanged.userId).toBe(secondUserId);
|
||||
},
|
||||
);
|
||||
|
||||
it('PATCH /api/scout/findings/:id rejects invalid status', async () => {
|
||||
const findings = await scout.listFindings(userId);
|
||||
const finding = findings[0];
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/scout/findings/${finding.id}`,
|
||||
headers: { 'x-test-user-id': userId },
|
||||
payload: { status: 'invalid' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
});
|
||||
130
packages/team-server/tests/daemons/subconscious.test.ts
Normal file
130
packages/team-server/tests/daemons/subconscious.test.ts
Normal file
@@ -0,0 +1,130 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, agentJobs, agentAuditLog } from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
import { SubconsciousAgent } from '../../src/daemons/subconscious.js';
|
||||
|
||||
describe('Subconscious Agent (Task 3.19)', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let userId: string;
|
||||
let teamId: string;
|
||||
let subconscious: SubconsciousAgent;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'subcontest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'subcon_%'`);
|
||||
|
||||
// Create test user
|
||||
const [user] = await server.db.insert(users).values({
|
||||
clerkId: 'subcon_user1',
|
||||
displayName: 'Subconscious User',
|
||||
email: 'subcon_user1@test.com',
|
||||
}).returning();
|
||||
userId = user.id;
|
||||
|
||||
// Create team
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Subconscious Test Team',
|
||||
slug: 'subcontest-team',
|
||||
ownerId: userId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
|
||||
await server.db.insert(teamMembers).values({
|
||||
teamId,
|
||||
userId,
|
||||
role: 'owner',
|
||||
});
|
||||
|
||||
subconscious = new SubconsciousAgent(server.db);
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'subcontest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'subcon_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('shouldReflect returns false when under threshold', async () => {
|
||||
// No completed jobs yet
|
||||
const result = await subconscious.shouldReflect(userId);
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
it('shouldReflect returns true after N completed jobs', async () => {
|
||||
// Insert 10 completed jobs (SUBCONSCIOUS_INTERACTION_THRESHOLD = 10)
|
||||
const jobValues = Array.from({ length: 10 }, (_, i) => ({
|
||||
teamId,
|
||||
userId,
|
||||
jobType: 'chat',
|
||||
status: 'completed',
|
||||
input: { prompt: `test ${i}` },
|
||||
completedAt: new Date(),
|
||||
}));
|
||||
await server.db.insert(agentJobs).values(jobValues);
|
||||
|
||||
const result = await subconscious.shouldReflect(userId);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('reflect creates audit entry', async () => {
|
||||
const { auditEntry, insights } = await subconscious.reflect(userId);
|
||||
|
||||
expect(auditEntry).toBeTruthy();
|
||||
expect(auditEntry.agentName).toBe('subconscious');
|
||||
expect(auditEntry.actionType).toBe('subconscious_reflection');
|
||||
expect(auditEntry.description).toContain('Reflected on');
|
||||
expect(Array.isArray(insights)).toBe(true);
|
||||
});
|
||||
|
||||
it('detects repeated job types pattern', async () => {
|
||||
// Insert 5 more jobs of same type to trigger pattern detection
|
||||
const repeatedJobs = Array.from({ length: 5 }, (_, i) => ({
|
||||
teamId,
|
||||
userId,
|
||||
jobType: 'task',
|
||||
status: 'completed',
|
||||
input: { prompt: `repeated ${i}` },
|
||||
completedAt: new Date(),
|
||||
}));
|
||||
await server.db.insert(agentJobs).values(repeatedJobs);
|
||||
|
||||
const { insights } = await subconscious.reflect(userId);
|
||||
|
||||
// Should find a prompt_change insight for the repeated 'chat' type (10 jobs)
|
||||
const promptInsight = insights.find(i => i.type === 'prompt_change');
|
||||
expect(promptInsight).toBeTruthy();
|
||||
expect(promptInsight!.description).toContain('executed');
|
||||
expect(promptInsight!.description).toContain('times recently');
|
||||
});
|
||||
|
||||
it('prompt change insight requires approval in audit entry', async () => {
|
||||
// The previous reflect should have created an audit entry with requiresApproval
|
||||
const entries = await server.db.select().from(agentAuditLog)
|
||||
.where(sql`${agentAuditLog.userId} = ${userId} AND ${agentAuditLog.actionType} = 'subconscious_reflection'`);
|
||||
|
||||
// Find one that has insights with prompt_change
|
||||
const withApproval = entries.find(e => {
|
||||
const state = e.afterState as { insights?: Array<{ type: string }> } | null;
|
||||
return state?.insights?.some((i) => i.type === 'prompt_change');
|
||||
});
|
||||
|
||||
expect(withApproval).toBeTruthy();
|
||||
expect(withApproval!.requiresApproval).toBe(true);
|
||||
});
|
||||
});
|
||||
93
packages/team-server/tests/db/schema.test.ts
Normal file
93
packages/team-server/tests/db/schema.test.ts
Normal file
@@ -0,0 +1,93 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { createDb, type Db } from '../../src/db/connection.js';
|
||||
import { users, teams, teamMembers, tasks, messages, agents, agentGroups } from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
|
||||
const SUFFIX = `_schema_${Date.now()}`;
|
||||
|
||||
describe('PostgreSQL schema', () => {
|
||||
let db: Db;
|
||||
let testUserId: string;
|
||||
let testTeamId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
db = createDb(process.env.DATABASE_URL ?? 'postgres://waggle:waggle_dev@localhost:5434/waggle');
|
||||
|
||||
// Clean up any leftovers from previous runs
|
||||
await db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
|
||||
await db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
|
||||
await db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
|
||||
await db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
|
||||
await db.execute(sql`DELETE FROM teams WHERE slug LIKE '%_schema_%'`);
|
||||
await db.execute(sql`DELETE FROM users WHERE clerk_id LIKE '%_schema_%'`);
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Clean up test data created by these tests
|
||||
if (testTeamId) {
|
||||
await db.execute(sql`DELETE FROM team_members WHERE team_id = ${testTeamId}`);
|
||||
await db.execute(sql`DELETE FROM team_capability_requests WHERE team_id = ${testTeamId}`);
|
||||
await db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id = ${testTeamId}`);
|
||||
await db.execute(sql`DELETE FROM team_capability_policies WHERE team_id = ${testTeamId}`);
|
||||
await db.execute(sql`DELETE FROM teams WHERE id = ${testTeamId}`);
|
||||
}
|
||||
if (testUserId) {
|
||||
await db.execute(sql`DELETE FROM users WHERE id = ${testUserId}`);
|
||||
}
|
||||
});
|
||||
|
||||
it('creates a user', async () => {
|
||||
const [user] = await db.insert(users).values({
|
||||
clerkId: `clerk${SUFFIX}`,
|
||||
displayName: 'Schema Test User',
|
||||
email: `schematest${SUFFIX}@test.com`,
|
||||
}).returning();
|
||||
testUserId = user.id;
|
||||
expect(user.id).toBeDefined();
|
||||
expect(user.displayName).toBe('Schema Test User');
|
||||
});
|
||||
|
||||
it('creates a team with owner', async () => {
|
||||
// Depends on previous test having created user
|
||||
expect(testUserId).toBeTruthy();
|
||||
|
||||
const [team] = await db.insert(teams).values({
|
||||
name: 'Marketing',
|
||||
slug: `marketing${SUFFIX}`,
|
||||
ownerId: testUserId,
|
||||
}).returning();
|
||||
testTeamId = team.id;
|
||||
expect(team.slug).toBe(`marketing${SUFFIX}`);
|
||||
|
||||
await db.insert(teamMembers).values({
|
||||
teamId: team.id,
|
||||
userId: testUserId,
|
||||
role: 'owner',
|
||||
});
|
||||
});
|
||||
|
||||
it('creates all 16 tables', async () => {
|
||||
const result = await db.execute(sql`
|
||||
SELECT table_name FROM information_schema.tables
|
||||
WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
|
||||
ORDER BY table_name
|
||||
`);
|
||||
const tableNames = (result as Array<{ table_name: string }>).map((r) => r.table_name);
|
||||
expect(tableNames).toContain('users');
|
||||
expect(tableNames).toContain('teams');
|
||||
expect(tableNames).toContain('team_members');
|
||||
expect(tableNames).toContain('agents');
|
||||
expect(tableNames).toContain('agent_groups');
|
||||
expect(tableNames).toContain('tasks');
|
||||
expect(tableNames).toContain('messages');
|
||||
expect(tableNames).toContain('team_entities');
|
||||
expect(tableNames).toContain('team_relations');
|
||||
expect(tableNames).toContain('team_resources');
|
||||
expect(tableNames).toContain('agent_jobs');
|
||||
expect(tableNames).toContain('cron_schedules');
|
||||
expect(tableNames).toContain('scout_findings');
|
||||
expect(tableNames).toContain('proactive_patterns');
|
||||
expect(tableNames).toContain('suggestions_log');
|
||||
expect(tableNames).toContain('agent_audit_log');
|
||||
});
|
||||
});
|
||||
139
packages/team-server/tests/e2e/team-server.spec.ts
Normal file
139
packages/team-server/tests/e2e/team-server.spec.ts
Normal file
@@ -0,0 +1,139 @@
|
||||
/**
|
||||
* Team Server E2E — tests the multi-user team server running on Docker
|
||||
* (Postgres + Redis + LiteLLM).
|
||||
*
|
||||
* Requires: docker-compose up (postgres:5434, redis:6381, litellm:4000)
|
||||
* Team server running on port 3100.
|
||||
*/
|
||||
import { test, expect } from '@playwright/test';
|
||||
|
||||
const TEAM = 'http://127.0.0.1:3100';
|
||||
|
||||
test.beforeEach(async ({ request }) => {
|
||||
try {
|
||||
const res = await request.get(`${TEAM}/health`, { timeout: 1_000 });
|
||||
test.skip(!res.ok(), 'Optional team server is not running on 127.0.0.1:3100');
|
||||
} catch {
|
||||
test.skip(true, 'Optional team server is not running on 127.0.0.1:3100');
|
||||
}
|
||||
});
|
||||
|
||||
// ── 1. Server Health ──────────────────────────────────────────────────
|
||||
|
||||
test.describe('1. Team Server Health', () => {
|
||||
test('health endpoint responds', async ({ request }) => {
|
||||
const res = await request.get(`${TEAM}/health`);
|
||||
expect(res.ok()).toBeTruthy();
|
||||
const data = await res.json();
|
||||
expect(data.status).toBe('ok');
|
||||
});
|
||||
});
|
||||
|
||||
// ── 2. Team CRUD ──────────────────────────────────────────────────────
|
||||
|
||||
test.describe('2. Team Management', () => {
|
||||
let teamSlug: string;
|
||||
|
||||
test('can create a team', async ({ request }) => {
|
||||
const name = `TestTeam-${Date.now()}`;
|
||||
teamSlug = name.toLowerCase().replace(/[^a-z0-9]/g, '-');
|
||||
const res = await request.post(`${TEAM}/api/teams`, {
|
||||
data: { name, slug: teamSlug },
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
});
|
||||
// May need auth — accept 200, 201, or 401
|
||||
expect([200, 201, 401, 403]).toContain(res.status());
|
||||
});
|
||||
|
||||
test('can list teams', async ({ request }) => {
|
||||
const res = await request.get(`${TEAM}/api/teams`);
|
||||
expect([200, 401, 403]).toContain(res.status());
|
||||
if (res.ok()) {
|
||||
const data = await res.json();
|
||||
expect(Array.isArray(data) || Array.isArray(data.teams)).toBeTruthy();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ── 3. Agent Routes ───────────────────────────────────────────────────
|
||||
|
||||
test.describe('3. Agent & Model Routes', () => {
|
||||
test('agents list', async ({ request }) => {
|
||||
const res = await request.get(`${TEAM}/api/agents`);
|
||||
expect([200, 401]).toContain(res.status());
|
||||
});
|
||||
|
||||
test('workflows list', async ({ request }) => {
|
||||
const res = await request.get(`${TEAM}/api/workflows`);
|
||||
expect([200, 401, 404]).toContain(res.status());
|
||||
});
|
||||
});
|
||||
|
||||
// ── 4. Database Connection ────────────────────────────────────────────
|
||||
|
||||
test.describe('4. Database', () => {
|
||||
test('postgres is reachable from server', async ({ request }) => {
|
||||
// The server started successfully which means DB connected.
|
||||
// Verify by hitting an endpoint that requires DB.
|
||||
const res = await request.get(`${TEAM}/api/teams`);
|
||||
// If 500, DB connection failed. 200 or 401 means DB is fine.
|
||||
expect(res.status()).not.toBe(500);
|
||||
});
|
||||
});
|
||||
|
||||
// ── 5. WebSocket Gateway ──────────────────────────────────────────────
|
||||
|
||||
test.describe('5. WebSocket', () => {
|
||||
test('ws endpoint exists', async ({ request }) => {
|
||||
// HTTP GET to /ws should return upgrade required or similar
|
||||
const res = await request.get(`${TEAM}/ws`);
|
||||
// WebSocket endpoints typically return 400 or 426 on plain HTTP
|
||||
expect([400, 404, 426]).toContain(res.status());
|
||||
});
|
||||
});
|
||||
|
||||
// ── 6. Cron & Jobs ────────────────────────────────────────────────────
|
||||
|
||||
test.describe('6. Background Services', () => {
|
||||
test('cron status endpoint', async ({ request }) => {
|
||||
const res = await request.get(`${TEAM}/api/cron`);
|
||||
expect([200, 401, 404]).toContain(res.status());
|
||||
});
|
||||
});
|
||||
|
||||
// ── 7. Knowledge & Resources ──────────────────────────────────────────
|
||||
|
||||
test.describe('7. Knowledge Routes', () => {
|
||||
test('skills endpoint', async ({ request }) => {
|
||||
const res = await request.get(`${TEAM}/api/skills`);
|
||||
expect([200, 401, 404]).toContain(res.status());
|
||||
});
|
||||
});
|
||||
|
||||
// ── 8. Concurrent Requests ────────────────────────────────────────────
|
||||
|
||||
test.describe('8. Concurrency', () => {
|
||||
test('10 concurrent health checks all succeed', async ({ request }) => {
|
||||
const results = await Promise.all(
|
||||
Array.from({ length: 10 }, () => request.get(`${TEAM}/health`))
|
||||
);
|
||||
for (const res of results) {
|
||||
expect(res.ok()).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
test('server handles rapid API calls without crashing', async ({ request }) => {
|
||||
const endpoints = ['/health', '/api/teams', '/api/agents', '/api/workflows', '/api/cron'];
|
||||
const results = await Promise.all(
|
||||
endpoints.map(ep => request.get(`${TEAM}${ep}`))
|
||||
);
|
||||
// No 500s — server survived the burst
|
||||
for (const res of results) {
|
||||
expect(res.status()).toBeLessThan(500);
|
||||
}
|
||||
|
||||
// Health still ok after burst
|
||||
const health = await request.get(`${TEAM}/health`);
|
||||
expect(health.ok()).toBeTruthy();
|
||||
});
|
||||
});
|
||||
35
packages/team-server/tests/entrypoint.test.ts
Normal file
35
packages/team-server/tests/entrypoint.test.ts
Normal file
@@ -0,0 +1,35 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
import { fileURLToPath, pathToFileURL } from 'node:url';
|
||||
import { isDirectModule } from '../src/index.js';
|
||||
|
||||
const REPO_ROOT = fileURLToPath(new URL('../../../', import.meta.url));
|
||||
|
||||
describe('team server entrypoint detection', () => {
|
||||
it('is left out of the community-edition package build with the rest of team mode (ADR-0003)', () => {
|
||||
const rootPackage = JSON.parse(readFileSync(resolve(REPO_ROOT, 'package.json'), 'utf8')) as {
|
||||
scripts: Record<string, string>;
|
||||
};
|
||||
const build = rootPackage.scripts['build:packages'];
|
||||
|
||||
expect(build).toContain('cd ../server && npx tsc --build');
|
||||
for (const postponed of ['../team-server', '../worker', '../waggle-dance']) {
|
||||
expect(build).not.toContain(postponed);
|
||||
}
|
||||
});
|
||||
|
||||
it('recognizes the compiled dist entrypoint by URL identity', () => {
|
||||
const distPath = resolve(REPO_ROOT, 'packages/team-server/dist/index.js');
|
||||
|
||||
expect(isDirectModule(distPath, pathToFileURL(distPath).href)).toBe(true);
|
||||
});
|
||||
|
||||
it('does not start when imported by another process entrypoint', () => {
|
||||
const distPath = resolve(REPO_ROOT, 'packages/team-server/dist/index.js');
|
||||
const importerUrl = pathToFileURL(resolve(REPO_ROOT, 'packages/team-server/dist/consumer.js')).href;
|
||||
|
||||
expect(isDirectModule(distPath, importerUrl)).toBe(false);
|
||||
expect(isDirectModule(undefined, importerUrl)).toBe(false);
|
||||
});
|
||||
});
|
||||
292
packages/team-server/tests/integration/m3-full-stack.test.ts
Normal file
292
packages/team-server/tests/integration/m3-full-stack.test.ts
Normal file
@@ -0,0 +1,292 @@
|
||||
import { createHmac } from 'node:crypto';
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import type { FastifyRequest, FastifyReply } from 'fastify';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import {
|
||||
users, teams, teamMembers, tasks, messages,
|
||||
teamEntities, teamResources, agentAuditLog,
|
||||
} from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
|
||||
const SIGNING_KEY = Buffer.from('waggle-m3-full-stack-test-secret');
|
||||
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
|
||||
|
||||
function signedHeaders(payload: object) {
|
||||
const id = 'msg_waggle_m3_full_stack';
|
||||
const timestamp = Math.floor(Date.now() / 1000);
|
||||
const signature = createHmac('sha256', SIGNING_KEY)
|
||||
.update(`${id}.${timestamp}.${JSON.stringify(payload)}`)
|
||||
.digest('base64');
|
||||
|
||||
return {
|
||||
'svix-id': id,
|
||||
'svix-timestamp': String(timestamp),
|
||||
'svix-signature': `v1,${signature}`,
|
||||
};
|
||||
}
|
||||
|
||||
describe('M3 Full Stack Integration', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let teamId: string;
|
||||
let originalSigningSecret: string | undefined;
|
||||
const teamSlug = 'integ-team';
|
||||
|
||||
beforeAll(async () => {
|
||||
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data from previous runs (reverse dependency order)
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'integ_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'integ-team'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'integ_%'`);
|
||||
|
||||
// Override auth handler for testing
|
||||
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
try {
|
||||
// Clean up all test data
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'integ_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'integ-team'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'integ_%'`);
|
||||
} finally {
|
||||
try {
|
||||
await server?.close();
|
||||
} finally {
|
||||
if (originalSigningSecret === undefined) {
|
||||
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
} else {
|
||||
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('Step 1: Creates users via webhook', async () => {
|
||||
// Create owner
|
||||
const ownerEvent = {
|
||||
type: 'user.created',
|
||||
data: {
|
||||
id: 'integ_owner',
|
||||
first_name: 'Owner',
|
||||
last_name: 'User',
|
||||
email_addresses: [{ email_address: 'integ_owner@test.com' }],
|
||||
},
|
||||
};
|
||||
let res = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(ownerEvent),
|
||||
payload: ownerEvent,
|
||||
});
|
||||
expect(res.statusCode).toBe(200);
|
||||
|
||||
// Create member
|
||||
const memberEvent = {
|
||||
type: 'user.created',
|
||||
data: {
|
||||
id: 'integ_member',
|
||||
first_name: 'Member',
|
||||
last_name: 'User',
|
||||
email_addresses: [{ email_address: 'integ_member@test.com' }],
|
||||
},
|
||||
};
|
||||
res = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(memberEvent),
|
||||
payload: memberEvent,
|
||||
});
|
||||
expect(res.statusCode).toBe(200);
|
||||
|
||||
// Get user IDs
|
||||
const [owner] = await server.db.select().from(users).where(sql`clerk_id = 'integ_owner'`);
|
||||
const [member] = await server.db.select().from(users).where(sql`clerk_id = 'integ_member'`);
|
||||
expect(owner).toBeDefined();
|
||||
expect(member).toBeDefined();
|
||||
ownerId = owner.id;
|
||||
memberId = member.id;
|
||||
});
|
||||
|
||||
it('Step 2: Creates team and invites member', async () => {
|
||||
let res = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/teams',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { name: 'Integration Team', slug: teamSlug },
|
||||
});
|
||||
expect(res.statusCode).toBe(201);
|
||||
teamId = JSON.parse(res.body).id;
|
||||
|
||||
// Add member
|
||||
res = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/members`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { email: 'integ_member@test.com', role: 'member' },
|
||||
});
|
||||
expect(res.statusCode).toBe(201);
|
||||
});
|
||||
|
||||
it('Step 3: Creates task on team board', async () => {
|
||||
const res = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { title: 'Research competitor pricing', priority: 'high' },
|
||||
});
|
||||
expect(res.statusCode).toBe(201);
|
||||
const body = JSON.parse(res.body);
|
||||
expect(body.title).toBe('Research competitor pricing');
|
||||
expect(body.priority).toBe('high');
|
||||
expect(body.status).toBe('open');
|
||||
});
|
||||
|
||||
it('Step 4: Sends Waggle Dance message', async () => {
|
||||
const res = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
type: 'request',
|
||||
subtype: 'knowledge_check',
|
||||
content: { topic: 'competitor pricing' },
|
||||
},
|
||||
});
|
||||
expect(res.statusCode).toBe(201);
|
||||
const body = JSON.parse(res.body);
|
||||
expect(body.type).toBe('request');
|
||||
expect(body.subtype).toBe('knowledge_check');
|
||||
});
|
||||
|
||||
it('Step 5: Shares knowledge entity to team graph', async () => {
|
||||
const res = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'competitor', name: 'Acme Corp', properties: { pricing: '$99/mo' } },
|
||||
});
|
||||
expect(res.statusCode).toBe(201);
|
||||
const body = JSON.parse(res.body);
|
||||
expect(body.entityType).toBe('competitor');
|
||||
expect(body.name).toBe('Acme Corp');
|
||||
});
|
||||
|
||||
it('Step 6: Shares team resource', async () => {
|
||||
const res = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/resources`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
resourceType: 'model_recipe',
|
||||
name: 'Fast Research Config',
|
||||
config: { model: 'claude-haiku-4-5', temperature: 0.3 },
|
||||
},
|
||||
});
|
||||
expect(res.statusCode).toBe(201);
|
||||
const body = JSON.parse(res.body);
|
||||
expect(body.resourceType).toBe('model_recipe');
|
||||
expect(body.name).toBe('Fast Research Config');
|
||||
});
|
||||
|
||||
it('Step 7: Creates audit trail entry', async () => {
|
||||
const { AuditService } = await import('../../src/services/audit-service.js');
|
||||
const auditService = new AuditService(server.db);
|
||||
const entry = await auditService.log({
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'memory-weaver',
|
||||
actionType: 'consolidation',
|
||||
description: 'Consolidated meeting notes',
|
||||
});
|
||||
expect(entry.agentName).toBe('memory-weaver');
|
||||
|
||||
// Verify via admin API
|
||||
// First promote owner to admin role (owner already has admin+ perms)
|
||||
const res = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/admin/teams/${teamSlug}/audit`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
expect(res.statusCode).toBe(200);
|
||||
const body = JSON.parse(res.body);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
it('Step 8: Member cannot access admin audit endpoint', async () => {
|
||||
const res = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/admin/teams/${teamSlug}/audit`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
expect(res.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('Step 9: Lists tasks, messages, entities for the team', async () => {
|
||||
// Tasks
|
||||
const tasksRes = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
expect(tasksRes.statusCode).toBe(200);
|
||||
expect(JSON.parse(tasksRes.body).length).toBeGreaterThanOrEqual(1);
|
||||
|
||||
// Messages
|
||||
const msgsRes = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
expect(msgsRes.statusCode).toBe(200);
|
||||
expect(JSON.parse(msgsRes.body).length).toBeGreaterThanOrEqual(1);
|
||||
|
||||
// Entities
|
||||
const entRes = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
expect(entRes.statusCode).toBe(200);
|
||||
expect(JSON.parse(entRes.body).length).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
it('Step 10: Health check passes', async () => {
|
||||
const res = await server.inject({ method: 'GET', url: '/health' });
|
||||
expect(res.statusCode).toBe(200);
|
||||
expect(JSON.parse(res.body).status).toBe('ok');
|
||||
});
|
||||
});
|
||||
220
packages/team-server/tests/proactive.test.ts
Normal file
220
packages/team-server/tests/proactive.test.ts
Normal file
@@ -0,0 +1,220 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import type { FastifyRequest, FastifyReply } from 'fastify';
|
||||
import { buildServer } from '../src/index.js';
|
||||
import { users, proactivePatterns, suggestionsLog } from '../src/db/schema.js';
|
||||
import { sql, eq } from 'drizzle-orm';
|
||||
import { ProactiveService } from '../src/services/proactive-service.js';
|
||||
|
||||
describe('Proactive Engine (Task 3.17)', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let userId: string;
|
||||
let secondUserId: string;
|
||||
let proactiveService: ProactiveService;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'protest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM proactive_patterns WHERE name LIKE 'test_%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'protest_%'`);
|
||||
// Also clean any seeded patterns for a clean slate
|
||||
await server.db.execute(sql`DELETE FROM suggestions_log`);
|
||||
await server.db.execute(sql`DELETE FROM proactive_patterns`);
|
||||
|
||||
// Create test users
|
||||
const [user] = await server.db.insert(users).values({
|
||||
clerkId: 'protest_user1',
|
||||
displayName: 'Proactive User',
|
||||
email: 'protest_user1@test.com',
|
||||
}).returning();
|
||||
userId = user.id;
|
||||
|
||||
const [user2] = await server.db.insert(users).values({
|
||||
clerkId: 'protest_user2',
|
||||
displayName: 'Proactive User 2',
|
||||
email: 'protest_user2@test.com',
|
||||
}).returning();
|
||||
secondUserId = user2.id;
|
||||
|
||||
proactiveService = new ProactiveService(server.db);
|
||||
|
||||
// Seed patterns
|
||||
await proactiveService.ensurePatternsSeeded();
|
||||
|
||||
// Override auth handler
|
||||
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'protest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM proactive_patterns`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'protest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('seeds built-in patterns', async () => {
|
||||
const patterns = await server.db.select().from(proactivePatterns);
|
||||
expect(patterns.length).toBe(5);
|
||||
const names = patterns.map(p => p.name);
|
||||
expect(names).toContain('recurring_task');
|
||||
expect(names).toContain('data_report');
|
||||
expect(names).toContain('relevant_to_others');
|
||||
expect(names).toContain('expensive_model');
|
||||
expect(names).toContain('manual_repetition');
|
||||
});
|
||||
|
||||
it('does not re-seed if patterns exist', async () => {
|
||||
await proactiveService.ensurePatternsSeeded();
|
||||
const patterns = await server.db.select().from(proactivePatterns);
|
||||
expect(patterns.length).toBe(5); // still 5, not 10
|
||||
});
|
||||
|
||||
it('pattern triggers create suggestion when context matches', async () => {
|
||||
const result = await proactiveService.evaluate(userId, {
|
||||
repeatCount: 5, // triggers 'recurring_task' (cron) pattern
|
||||
});
|
||||
|
||||
expect(result).toBeTruthy();
|
||||
expect(result!.status).toBe('pending');
|
||||
expect(result!.pattern.suggestionType).toBe('cron');
|
||||
});
|
||||
|
||||
it('max 1 suggestion per interaction (second evaluate returns null)', async () => {
|
||||
// User already has a pending suggestion from previous test
|
||||
const result = await proactiveService.evaluate(userId, {
|
||||
hasData: true, // would trigger 'data_report' (dashboard) pattern
|
||||
});
|
||||
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it('dismissed pattern not re-suggested', async () => {
|
||||
// Clear all pending suggestions for secondUserId so we start fresh
|
||||
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id = ${secondUserId}`);
|
||||
|
||||
// First, trigger a suggestion for secondUserId
|
||||
const suggestion = await proactiveService.evaluate(secondUserId, {
|
||||
repeatCount: 4, // triggers cron pattern
|
||||
});
|
||||
expect(suggestion).toBeTruthy();
|
||||
|
||||
// Dismiss it
|
||||
await proactiveService.updateStatus(suggestion!.id, secondUserId, 'dismissed');
|
||||
|
||||
// Clear pending count so the MAX check doesn't block us
|
||||
// (dismissed doesn't count as pending, so evaluate should proceed)
|
||||
|
||||
// Try to trigger the same pattern again
|
||||
const result2 = await proactiveService.evaluate(secondUserId, {
|
||||
repeatCount: 10,
|
||||
});
|
||||
|
||||
// Should be null because the cron pattern was dismissed
|
||||
// It might match a different pattern though, so check specifically
|
||||
if (result2) {
|
||||
expect(result2.pattern.suggestionType).not.toBe('cron');
|
||||
}
|
||||
});
|
||||
|
||||
it('accept/dismiss/snooze updates status via API', async () => {
|
||||
// Clear suggestions for userId
|
||||
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id = ${userId}`);
|
||||
|
||||
// Create a new suggestion
|
||||
const suggestion = await proactiveService.evaluate(userId, {
|
||||
expensiveModel: true, // triggers 'upgrade' pattern
|
||||
});
|
||||
expect(suggestion).toBeTruthy();
|
||||
|
||||
// Accept via API
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/suggestions/${suggestion!.id}`,
|
||||
headers: { 'x-test-user-id': userId },
|
||||
payload: { status: 'accepted' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.status).toBe('accepted');
|
||||
});
|
||||
|
||||
it('does not let one user update another user\'s suggestion', async () => {
|
||||
const patterns = await server.db.select().from(proactivePatterns);
|
||||
const [victimSuggestion] = await server.db.insert(suggestionsLog).values({
|
||||
userId: secondUserId,
|
||||
patternId: patterns[0].id,
|
||||
context: { owner: 'victim' },
|
||||
status: 'pending',
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/suggestions/${victimSuggestion.id}`,
|
||||
headers: { 'x-test-user-id': userId },
|
||||
payload: { status: 'accepted' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json()).toEqual({ error: 'Suggestion not found' });
|
||||
const [unchanged] = await server.db.select().from(suggestionsLog)
|
||||
.where(eq(suggestionsLog.id, victimSuggestion.id));
|
||||
expect(unchanged.status).toBe('pending');
|
||||
expect(unchanged.userId).toBe(secondUserId);
|
||||
});
|
||||
|
||||
it('list pending returns only pending suggestions via API', async () => {
|
||||
// Clear and create fresh data
|
||||
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id = ${userId}`);
|
||||
|
||||
// Create a pending suggestion directly
|
||||
const patterns = await server.db.select().from(proactivePatterns);
|
||||
const pattern = patterns[0];
|
||||
|
||||
await server.db.insert(suggestionsLog).values([
|
||||
{ userId, patternId: pattern.id, context: { test: 1 }, status: 'pending' },
|
||||
{ userId, patternId: pattern.id, context: { test: 2 }, status: 'accepted' },
|
||||
{ userId, patternId: pattern.id, context: { test: 3 }, status: 'dismissed' },
|
||||
]);
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/suggestions',
|
||||
headers: { 'x-test-user-id': userId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
// Only pending ones should be returned
|
||||
expect((body as Array<{ status: string }>).every((s) => s.status === 'pending')).toBe(true);
|
||||
expect(body.length).toBe(1);
|
||||
});
|
||||
|
||||
it('rejects invalid status in PATCH', async () => {
|
||||
const patterns = await server.db.select().from(proactivePatterns);
|
||||
const [suggestion] = await server.db.insert(suggestionsLog).values({
|
||||
userId,
|
||||
patternId: patterns[0].id,
|
||||
context: {},
|
||||
status: 'pending',
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/suggestions/${suggestion.id}`,
|
||||
headers: { 'x-test-user-id': userId },
|
||||
payload: { status: 'invalid' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
});
|
||||
581
packages/team-server/tests/routes/agents.test.ts
Normal file
581
packages/team-server/tests/routes/agents.test.ts
Normal file
@@ -0,0 +1,581 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, agents, agentGroups, agentGroupMembers, agentJobs, teams, teamMembers } from '../../src/db/schema.js';
|
||||
import { sql, eq } from 'drizzle-orm';
|
||||
|
||||
describe('Agent API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let user1Id: string;
|
||||
let user2Id: string;
|
||||
let teamId: string;
|
||||
let team2Id: string;
|
||||
let agent1Id: string;
|
||||
let agent2Id: string;
|
||||
let foreignAgentId: string;
|
||||
let group1Id: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up leftover test data
|
||||
await server.db.execute(sql`DELETE FROM agent_group_members WHERE group_id IN (SELECT id FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%'))`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'agtest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'agtest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [u1] = await server.db.insert(users).values({
|
||||
clerkId: 'agtest_user1',
|
||||
displayName: 'Agent User 1',
|
||||
email: 'agentuser1@test.com',
|
||||
}).returning();
|
||||
user1Id = u1.id;
|
||||
|
||||
const [u2] = await server.db.insert(users).values({
|
||||
clerkId: 'agtest_user2',
|
||||
displayName: 'Agent User 2',
|
||||
email: 'agentuser2@test.com',
|
||||
}).returning();
|
||||
user2Id = u2.id;
|
||||
|
||||
// Create a team for job tests
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Agent Test Team',
|
||||
slug: 'agtest-team',
|
||||
ownerId: user1Id,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
|
||||
await server.db.insert(teamMembers).values({ teamId, userId: user1Id, role: 'owner' });
|
||||
|
||||
const [team2] = await server.db.insert(teams).values({
|
||||
name: 'Agent Test Team 2',
|
||||
slug: 'agtest-team-2',
|
||||
ownerId: user2Id,
|
||||
}).returning();
|
||||
team2Id = team2.id;
|
||||
|
||||
await server.db.insert(teamMembers).values({ teamId: team2Id, userId: user2Id, role: 'owner' });
|
||||
|
||||
// Override auth handler for tests
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM agent_group_members WHERE group_id IN (SELECT id FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%'))`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'agtest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'agtest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('creates an agent with custom model, tools, and system prompt', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agents',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
name: 'Research Agent',
|
||||
role: 'researcher',
|
||||
systemPrompt: 'You are a research agent.',
|
||||
model: 'claude-sonnet-4-20250514',
|
||||
tools: ['web_search', 'read_file'],
|
||||
config: { maxTokens: 4096 },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.name).toBe('Research Agent');
|
||||
expect(body.role).toBe('researcher');
|
||||
expect(body.systemPrompt).toBe('You are a research agent.');
|
||||
expect(body.model).toBe('claude-sonnet-4-20250514');
|
||||
expect(body.tools).toEqual(['web_search', 'read_file']);
|
||||
expect(body.config).toEqual({ maxTokens: 4096 });
|
||||
expect(body.userId).toBe(user1Id);
|
||||
agent1Id = body.id;
|
||||
});
|
||||
|
||||
it('creates a second agent for user1', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agents',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
name: 'Coding Agent',
|
||||
model: 'claude-haiku-4-5',
|
||||
tools: ['execute_code'],
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
agent2Id = JSON.parse(response.body).id;
|
||||
});
|
||||
|
||||
it('lists agents returns only the user\'s agents', async () => {
|
||||
// Create an agent for user2
|
||||
const foreignAgentResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agents',
|
||||
headers: { 'x-test-user-id': user2Id },
|
||||
payload: { name: 'User2 Agent' },
|
||||
});
|
||||
expect(foreignAgentResponse.statusCode).toBe(201);
|
||||
foreignAgentId = JSON.parse(foreignAgentResponse.body).id;
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/agents',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBe(2);
|
||||
expect(body.every((a: { userId: string }) => a.userId === user1Id)).toBe(true);
|
||||
});
|
||||
|
||||
it('updates agent model and config', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/agents/${agent1Id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
model: 'claude-haiku-4-5',
|
||||
config: { maxTokens: 2048, temperature: 0.7 },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.model).toBe('claude-haiku-4-5');
|
||||
expect(body.config).toEqual({ maxTokens: 2048, temperature: 0.7 });
|
||||
});
|
||||
|
||||
it('user cannot update another user\'s agent', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/agents/${agent1Id}`,
|
||||
headers: { 'x-test-user-id': user2Id },
|
||||
payload: { model: 'hacked-model' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('user cannot delete another user\'s agent', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/agents/${agent1Id}`,
|
||||
headers: { 'x-test-user-id': user2Id },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('creates an agent group with parallel strategy and 2 members', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agent-groups',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
name: 'Research Squad',
|
||||
description: 'Parallel research team',
|
||||
strategy: 'parallel',
|
||||
members: [
|
||||
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
|
||||
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 0 },
|
||||
],
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.name).toBe('Research Squad');
|
||||
expect(body.strategy).toBe('parallel');
|
||||
expect(body.members).toHaveLength(2);
|
||||
group1Id = body.id;
|
||||
});
|
||||
|
||||
it('rejects foreign and missing agents identically when creating a group', async () => {
|
||||
const payload = {
|
||||
name: 'Cross-tenant group',
|
||||
strategy: 'parallel',
|
||||
members: [
|
||||
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
|
||||
{ agentId: foreignAgentId, roleInGroup: 'worker', executionOrder: 1 },
|
||||
],
|
||||
};
|
||||
const foreignResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agent-groups',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload,
|
||||
});
|
||||
const missingResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agent-groups',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
...payload,
|
||||
members: [
|
||||
payload.members[0],
|
||||
{ ...payload.members[1], agentId: '00000000-0000-4000-8000-000000000001' },
|
||||
],
|
||||
},
|
||||
});
|
||||
|
||||
expect(foreignResponse.statusCode).toBe(404);
|
||||
expect(missingResponse.statusCode).toBe(404);
|
||||
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Agent not found' });
|
||||
expect(missingResponse.body).toBe(foreignResponse.body);
|
||||
|
||||
const groups = await server.db
|
||||
.select()
|
||||
.from(agentGroups)
|
||||
.where(eq(agentGroups.userId, user1Id));
|
||||
expect(groups.some((group) => group.name === payload.name)).toBe(false);
|
||||
});
|
||||
|
||||
it('rejects foreign replacement members without altering the owned group', async () => {
|
||||
const foreignResponse = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/agent-groups/${group1Id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
members: [
|
||||
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
|
||||
{ agentId: foreignAgentId, roleInGroup: 'worker', executionOrder: 1 },
|
||||
],
|
||||
},
|
||||
});
|
||||
const missingResponse = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/agent-groups/${group1Id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
members: [
|
||||
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
|
||||
{
|
||||
agentId: '00000000-0000-4000-8000-000000000001',
|
||||
roleInGroup: 'worker',
|
||||
executionOrder: 1,
|
||||
},
|
||||
],
|
||||
},
|
||||
});
|
||||
|
||||
expect(foreignResponse.statusCode).toBe(404);
|
||||
expect(missingResponse.statusCode).toBe(404);
|
||||
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Agent not found' });
|
||||
expect(missingResponse.body).toBe(foreignResponse.body);
|
||||
|
||||
const groupResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/agent-groups/${group1Id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
expect(groupResponse.statusCode).toBe(200);
|
||||
const group = JSON.parse(groupResponse.body);
|
||||
expect(group.members.map((member: { agentId: string }) => member.agentId).sort())
|
||||
.toEqual([agent1Id, agent2Id].sort());
|
||||
});
|
||||
|
||||
it('replaces group membership when every agent belongs to the caller', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/agent-groups/${group1Id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
members: [
|
||||
{ agentId: agent1Id, roleInGroup: 'lead', executionOrder: 0 },
|
||||
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 1 },
|
||||
],
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const group = JSON.parse(response.body);
|
||||
expect(group.members.map((member: { agentId: string }) => member.agentId).sort())
|
||||
.toEqual([agent1Id, agent2Id].sort());
|
||||
});
|
||||
|
||||
it('creates a group with coordinator strategy and a lead agent', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/agent-groups',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
name: 'Coordinated Team',
|
||||
strategy: 'coordinator',
|
||||
members: [
|
||||
{ agentId: agent1Id, roleInGroup: 'lead', executionOrder: 0 },
|
||||
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 1 },
|
||||
],
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.strategy).toBe('coordinator');
|
||||
const lead = body.members.find((m: { roleInGroup: string; agentId: string }) => m.roleInGroup === 'lead');
|
||||
expect(lead).toBeDefined();
|
||||
expect(lead.agentId).toBe(agent1Id);
|
||||
});
|
||||
|
||||
it('gets group with members', async () => {
|
||||
// List groups to get an ID
|
||||
const listResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/agent-groups',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
|
||||
expect(listResponse.statusCode).toBe(200);
|
||||
const groups = JSON.parse(listResponse.body);
|
||||
expect(groups.length).toBeGreaterThanOrEqual(2);
|
||||
|
||||
const groupId = groups[0].id;
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/agent-groups/${groupId}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.id).toBe(groupId);
|
||||
expect(body.members).toBeDefined();
|
||||
expect(Array.isArray(body.members)).toBe(true);
|
||||
});
|
||||
|
||||
it('executes group run — queues a job and returns 202 with jobId', async () => {
|
||||
const listResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/agent-groups',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
const groups = JSON.parse(listResponse.body);
|
||||
const groupId = groups[0].id;
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/agent-groups/${groupId}/run`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
task: 'Research the latest AI papers',
|
||||
teamId,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(202);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.jobId).toBeDefined();
|
||||
expect(typeof body.jobId).toBe('string');
|
||||
|
||||
// Verify the job was created in the database
|
||||
const [job] = await server.db
|
||||
.select()
|
||||
.from(agentJobs)
|
||||
.where(eq(agentJobs.id, body.jobId))
|
||||
.limit(1);
|
||||
expect(job).toBeDefined();
|
||||
expect(job.status).toBe('queued');
|
||||
expect(job.jobType).toBe('group');
|
||||
expect(job.userId).toBe(user1Id);
|
||||
});
|
||||
|
||||
it('rejects an owned group run attributed to a foreign team', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/agent-groups/${group1Id}/run`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: { task: 'Cross-tenant run', teamId: team2Id },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(JSON.parse(response.body)).toEqual({ error: 'Team not found' });
|
||||
});
|
||||
|
||||
it('rejects generic job submission for a foreign team', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/jobs',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: { jobType: 'chat', teamId: team2Id, input: { message: 'Cross-tenant job' } },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(JSON.parse(response.body)).toEqual({ error: 'Team not found' });
|
||||
});
|
||||
|
||||
it('rejects a generic group job that references another user\'s group', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/jobs',
|
||||
headers: { 'x-test-user-id': user2Id },
|
||||
payload: {
|
||||
jobType: 'group',
|
||||
teamId: team2Id,
|
||||
input: { groupId: group1Id, taskInput: { task: 'Run foreign group' } },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(JSON.parse(response.body)).toEqual({ error: 'Agent group not found' });
|
||||
});
|
||||
|
||||
it('hides job status from users outside the job team while preserving member access', async () => {
|
||||
const createResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/jobs',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: { jobType: 'chat', teamId, input: { message: 'Private job' } },
|
||||
});
|
||||
expect(createResponse.statusCode).toBe(202);
|
||||
const { jobId } = JSON.parse(createResponse.body);
|
||||
|
||||
const foreignResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/jobs/${jobId}`,
|
||||
headers: { 'x-test-user-id': user2Id },
|
||||
});
|
||||
expect(foreignResponse.statusCode).toBe(404);
|
||||
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Job not found' });
|
||||
|
||||
const memberResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/jobs/${jobId}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
expect(memberResponse.statusCode).toBe(200);
|
||||
expect(JSON.parse(memberResponse.body).id).toBe(jobId);
|
||||
});
|
||||
|
||||
it('prevents users outside the job team from cancelling it', async () => {
|
||||
const createResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/jobs',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: { jobType: 'chat', teamId, input: { message: 'Do not cancel' } },
|
||||
});
|
||||
expect(createResponse.statusCode).toBe(202);
|
||||
const { jobId } = JSON.parse(createResponse.body);
|
||||
|
||||
const foreignResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/jobs/${jobId}/cancel`,
|
||||
headers: { 'x-test-user-id': user2Id },
|
||||
});
|
||||
expect(foreignResponse.statusCode).toBe(404);
|
||||
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Job not found' });
|
||||
|
||||
const [unchanged] = await server.db
|
||||
.select()
|
||||
.from(agentJobs)
|
||||
.where(eq(agentJobs.id, jobId))
|
||||
.limit(1);
|
||||
expect(unchanged.status).toBe('queued');
|
||||
|
||||
const memberResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/jobs/${jobId}/cancel`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
expect(memberResponse.statusCode).toBe(200);
|
||||
});
|
||||
|
||||
it('fails closed when a legacy group contains a foreign-owned agent', async () => {
|
||||
const [legacyGroup] = await server.db.insert(agentGroups).values({
|
||||
userId: user1Id,
|
||||
name: 'Legacy compromised group',
|
||||
strategy: 'parallel',
|
||||
}).returning();
|
||||
await server.db.insert(agentGroupMembers).values({
|
||||
groupId: legacyGroup.id,
|
||||
agentId: foreignAgentId,
|
||||
roleInGroup: 'worker',
|
||||
executionOrder: 0,
|
||||
});
|
||||
|
||||
const getResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/agent-groups/${legacyGroup.id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
const patchResponse = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/agent-groups/${legacyGroup.id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: { name: 'Preserved compromise' },
|
||||
});
|
||||
const runResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/agent-groups/${legacyGroup.id}/run`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: { task: 'Run foreign configuration', teamId },
|
||||
});
|
||||
const jobResponse = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/jobs',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
payload: {
|
||||
jobType: 'group',
|
||||
teamId,
|
||||
input: { groupId: legacyGroup.id, taskInput: { task: 'Run foreign configuration' } },
|
||||
},
|
||||
});
|
||||
|
||||
for (const response of [getResponse, patchResponse, runResponse, jobResponse]) {
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(JSON.parse(response.body)).toEqual({ error: 'Agent group not found' });
|
||||
}
|
||||
|
||||
const [unchanged] = await server.db
|
||||
.select()
|
||||
.from(agentGroups)
|
||||
.where(eq(agentGroups.id, legacyGroup.id))
|
||||
.limit(1);
|
||||
expect(unchanged.name).toBe('Legacy compromised group');
|
||||
});
|
||||
|
||||
it('deletes an agent', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/agents/${agent2Id}`,
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(204);
|
||||
|
||||
// Verify it's gone
|
||||
const listResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/agents',
|
||||
headers: { 'x-test-user-id': user1Id },
|
||||
});
|
||||
const remaining = JSON.parse(listResponse.body);
|
||||
const ids = remaining.map((a: { id: string }) => a.id);
|
||||
expect(ids).not.toContain(agent2Id);
|
||||
});
|
||||
});
|
||||
261
packages/team-server/tests/routes/analytics.test.ts
Normal file
261
packages/team-server/tests/routes/analytics.test.ts
Normal file
@@ -0,0 +1,261 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, agentAuditLog, agentJobs, teamCapabilityRequests } from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
|
||||
describe('Analytics API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let teamId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up any leftover test data
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE agent_name = 'analytics-test'`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE job_type = 'analytics-test'`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE justification = 'analytics-test'`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'test-analytics'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'antest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'antest_owner',
|
||||
displayName: 'Analytics Owner',
|
||||
email: 'analytics-owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'antest_member',
|
||||
displayName: 'Analytics Member',
|
||||
email: 'analytics-member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
// Create team
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Analytics Test Team',
|
||||
slug: 'test-analytics',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
|
||||
// Add members
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
// Override auth handler for tests
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE agent_name = 'analytics-test'`);
|
||||
await server.db.execute(sql`DELETE FROM agent_jobs WHERE job_type = 'analytics-test'`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE justification = 'analytics-test'`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'test-analytics'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'antest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('GET /api/admin/teams/:slug/analytics returns correct shape with zeroes for empty data', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/test-analytics/analytics',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
|
||||
// Verify top-level shape
|
||||
expect(body).toHaveProperty('activeUsers');
|
||||
expect(body).toHaveProperty('tokenUsage');
|
||||
expect(body).toHaveProperty('topTools');
|
||||
expect(body).toHaveProperty('topCommands');
|
||||
expect(body).toHaveProperty('capabilityGaps');
|
||||
expect(body).toHaveProperty('performanceTrends');
|
||||
|
||||
// activeUsers shape
|
||||
expect(body.activeUsers).toHaveProperty('daily');
|
||||
expect(body.activeUsers).toHaveProperty('weekly');
|
||||
expect(body.activeUsers).toHaveProperty('monthly');
|
||||
expect(typeof body.activeUsers.daily).toBe('number');
|
||||
expect(typeof body.activeUsers.weekly).toBe('number');
|
||||
expect(typeof body.activeUsers.monthly).toBe('number');
|
||||
|
||||
// tokenUsage shape
|
||||
expect(typeof body.tokenUsage.total).toBe('number');
|
||||
expect(Array.isArray(body.tokenUsage.byUser)).toBe(true);
|
||||
|
||||
// topTools and topCommands are arrays
|
||||
expect(Array.isArray(body.topTools)).toBe(true);
|
||||
expect(Array.isArray(body.topCommands)).toBe(true);
|
||||
expect(Array.isArray(body.capabilityGaps)).toBe(true);
|
||||
|
||||
// performanceTrends shape
|
||||
expect(typeof body.performanceTrends.correctionRate).toBe('number');
|
||||
expect(typeof body.performanceTrends.correctionTrend).toBe('number');
|
||||
expect(typeof body.performanceTrends.avgResponseTime).toBe('number');
|
||||
|
||||
// With no activity, everything should be zeroes
|
||||
expect(body.activeUsers.daily).toBe(0);
|
||||
expect(body.activeUsers.weekly).toBe(0);
|
||||
expect(body.activeUsers.monthly).toBe(0);
|
||||
expect(body.tokenUsage.total).toBe(0);
|
||||
expect(body.topTools).toHaveLength(0);
|
||||
expect(body.topCommands).toHaveLength(0);
|
||||
expect(body.capabilityGaps).toHaveLength(0);
|
||||
expect(body.performanceTrends.correctionRate).toBe(0);
|
||||
expect(body.performanceTrends.avgResponseTime).toBe(0);
|
||||
});
|
||||
|
||||
it('returns 401 without auth header', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/test-analytics/analytics',
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(401);
|
||||
});
|
||||
|
||||
it('returns 403 for non-admin member', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/test-analytics/analytics',
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('returns 404 for non-existent team', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/nonexistent-team/analytics',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
});
|
||||
|
||||
it('returns data when audit log entries exist', async () => {
|
||||
// Insert some audit log entries
|
||||
await server.db.insert(agentAuditLog).values([
|
||||
{
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'analytics-test',
|
||||
actionType: 'web_search',
|
||||
description: 'test search 1',
|
||||
},
|
||||
{
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'analytics-test',
|
||||
actionType: 'web_search',
|
||||
description: 'test search 2',
|
||||
},
|
||||
{
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'analytics-test',
|
||||
actionType: 'save_memory',
|
||||
description: 'test memory save',
|
||||
},
|
||||
{
|
||||
userId: ownerId,
|
||||
teamId,
|
||||
agentName: 'analytics-test',
|
||||
actionType: 'command:/research',
|
||||
description: 'test command',
|
||||
},
|
||||
]);
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/test-analytics/analytics',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
|
||||
// Should detect the active user
|
||||
expect(body.activeUsers.daily).toBeGreaterThanOrEqual(1);
|
||||
expect(body.activeUsers.weekly).toBeGreaterThanOrEqual(1);
|
||||
expect(body.activeUsers.monthly).toBeGreaterThanOrEqual(1);
|
||||
|
||||
// Should show top tools
|
||||
expect(body.topTools.length).toBeGreaterThanOrEqual(1);
|
||||
const webSearch = body.topTools.find((t: { name: string }) => t.name === 'web_search');
|
||||
expect(webSearch).toBeDefined();
|
||||
expect(webSearch.invocations).toBeGreaterThanOrEqual(2);
|
||||
|
||||
// Should show top commands
|
||||
expect(body.topCommands.length).toBeGreaterThanOrEqual(1);
|
||||
const research = body.topCommands.find((c: { name: string }) => c.name === '/research');
|
||||
expect(research).toBeDefined();
|
||||
expect(research.count).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
it('returns capability gaps from pending requests', async () => {
|
||||
// Insert a pending capability request
|
||||
await server.db.insert(teamCapabilityRequests).values({
|
||||
teamId,
|
||||
requestedBy: memberId,
|
||||
capabilityName: 'email_send',
|
||||
capabilityType: 'tool',
|
||||
justification: 'analytics-test',
|
||||
status: 'pending',
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/test-analytics/analytics',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
|
||||
expect(body.capabilityGaps.length).toBeGreaterThanOrEqual(1);
|
||||
const emailGap = body.capabilityGaps.find((g: { tool: string }) => g.tool === 'email_send');
|
||||
expect(emailGap).toBeDefined();
|
||||
expect(emailGap.requestCount).toBeGreaterThanOrEqual(1);
|
||||
expect(emailGap.suggestion).toContain('email_send');
|
||||
});
|
||||
|
||||
it('includes byUser token estimates in tokenUsage', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/admin/teams/test-analytics/analytics',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
|
||||
// byUser should include team members
|
||||
expect(body.tokenUsage.byUser.length).toBeGreaterThanOrEqual(1);
|
||||
const ownerEntry = body.tokenUsage.byUser.find((u: { userId: string }) => u.userId === ownerId);
|
||||
expect(ownerEntry).toBeDefined();
|
||||
expect(ownerEntry.name).toBe('Analytics Owner');
|
||||
expect(typeof ownerEntry.tokens).toBe('number');
|
||||
expect(typeof ownerEntry.cost).toBe('number');
|
||||
});
|
||||
});
|
||||
191
packages/team-server/tests/routes/capability-governance.test.ts
Normal file
191
packages/team-server/tests/routes/capability-governance.test.ts
Normal file
@@ -0,0 +1,191 @@
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||||
import { and, eq, sql } from 'drizzle-orm';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import {
|
||||
messages,
|
||||
teamCapabilityOverrides,
|
||||
teamCapabilityRequests,
|
||||
teamMembers,
|
||||
teams,
|
||||
users,
|
||||
} from '../../src/db/schema.js';
|
||||
|
||||
const SLUG_PREFIX = 'cap-bind-';
|
||||
const MISSING_ID = '00000000-0000-4000-8000-000000000000';
|
||||
|
||||
describe('Capability Governance Routes', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let attackerAdminId: string;
|
||||
let victimOwnerId: string;
|
||||
let attackerTeamId: string;
|
||||
let victimTeamId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'cap_bind_%'`);
|
||||
|
||||
const [attackerAdmin, victimOwner] = await server.db.insert(users).values([
|
||||
{
|
||||
clerkId: 'cap_bind_attacker_admin',
|
||||
displayName: 'Capability Attacker Admin',
|
||||
email: 'cap-bind-attacker@test.invalid',
|
||||
},
|
||||
{
|
||||
clerkId: 'cap_bind_victim_owner',
|
||||
displayName: 'Capability Victim Owner',
|
||||
email: 'cap-bind-victim@test.invalid',
|
||||
},
|
||||
]).returning();
|
||||
attackerAdminId = attackerAdmin.id;
|
||||
victimOwnerId = victimOwner.id;
|
||||
|
||||
const [attackerTeam, victimTeam] = await server.db.insert(teams).values([
|
||||
{ name: 'Capability Attacker Team', slug: `${SLUG_PREFIX}attacker`, ownerId: attackerAdminId },
|
||||
{ name: 'Capability Victim Team', slug: `${SLUG_PREFIX}victim`, ownerId: victimOwnerId },
|
||||
]).returning();
|
||||
attackerTeamId = attackerTeam.id;
|
||||
victimTeamId = victimTeam.id;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId: attackerTeamId, userId: attackerAdminId, role: 'admin' },
|
||||
{ teamId: victimTeamId, userId: victimOwnerId, role: 'owner' },
|
||||
]);
|
||||
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'cap_bind_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('does not let an authorized admin delete another team\'s override by ID', async () => {
|
||||
const [victimOverride] = await server.db.insert(teamCapabilityOverrides).values({
|
||||
teamId: victimTeamId,
|
||||
capabilityName: 'victim-secret-tool',
|
||||
capabilityType: 'mcp',
|
||||
decision: 'blocked',
|
||||
decidedBy: victimOwnerId,
|
||||
}).returning();
|
||||
|
||||
const foreign = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${victimOverride.id}`,
|
||||
headers: { 'x-test-user-id': attackerAdminId },
|
||||
});
|
||||
const missing = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${MISSING_ID}`,
|
||||
headers: { 'x-test-user-id': attackerAdminId },
|
||||
});
|
||||
|
||||
expect({ statusCode: foreign.statusCode, body: foreign.body }).toEqual({
|
||||
statusCode: missing.statusCode,
|
||||
body: missing.body,
|
||||
});
|
||||
const [stored] = await server.db.select().from(teamCapabilityOverrides).where(and(
|
||||
eq(teamCapabilityOverrides.id, victimOverride.id),
|
||||
eq(teamCapabilityOverrides.teamId, victimTeamId),
|
||||
));
|
||||
expect(stored).toBeDefined();
|
||||
});
|
||||
|
||||
it('still lets a same-team admin delete an override', async () => {
|
||||
const [ownOverride] = await server.db.insert(teamCapabilityOverrides).values({
|
||||
teamId: attackerTeamId,
|
||||
capabilityName: 'attacker-team-tool',
|
||||
capabilityType: 'mcp',
|
||||
decision: 'blocked',
|
||||
decidedBy: attackerAdminId,
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${ownOverride.id}`,
|
||||
headers: { 'x-test-user-id': attackerAdminId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(204);
|
||||
const [stored] = await server.db.select().from(teamCapabilityOverrides).where(eq(teamCapabilityOverrides.id, ownOverride.id));
|
||||
expect(stored).toBeUndefined();
|
||||
});
|
||||
|
||||
it('does not let an authorized admin decide another team\'s request by ID', async () => {
|
||||
const [victimRequest] = await server.db.insert(teamCapabilityRequests).values({
|
||||
teamId: victimTeamId,
|
||||
requestedBy: victimOwnerId,
|
||||
capabilityName: 'victim-requested-tool',
|
||||
capabilityType: 'mcp',
|
||||
justification: 'Victim-only request',
|
||||
}).returning();
|
||||
|
||||
const foreign = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${victimRequest.id}`,
|
||||
headers: { 'x-test-user-id': attackerAdminId },
|
||||
payload: { status: 'rejected', reason: 'cross-team decision attempt' },
|
||||
});
|
||||
const missing = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${MISSING_ID}`,
|
||||
headers: { 'x-test-user-id': attackerAdminId },
|
||||
payload: { status: 'rejected', reason: 'missing request' },
|
||||
});
|
||||
|
||||
expect({ statusCode: foreign.statusCode, body: foreign.body }).toEqual({
|
||||
statusCode: missing.statusCode,
|
||||
body: missing.body,
|
||||
});
|
||||
const [stored] = await server.db.select().from(teamCapabilityRequests).where(and(
|
||||
eq(teamCapabilityRequests.id, victimRequest.id),
|
||||
eq(teamCapabilityRequests.teamId, victimTeamId),
|
||||
));
|
||||
expect(stored?.status).toBe('pending');
|
||||
expect(stored?.decidedBy).toBeNull();
|
||||
});
|
||||
|
||||
it('still lets a same-team admin decide a pending request', async () => {
|
||||
const [ownRequest] = await server.db.insert(teamCapabilityRequests).values({
|
||||
teamId: attackerTeamId,
|
||||
requestedBy: attackerAdminId,
|
||||
capabilityName: 'attacker-requested-tool',
|
||||
capabilityType: 'mcp',
|
||||
justification: 'Same-team request',
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${ownRequest.id}`,
|
||||
headers: { 'x-test-user-id': attackerAdminId },
|
||||
payload: { status: 'rejected', reason: 'same-team decision' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
expect(response.json()).toMatchObject({
|
||||
id: ownRequest.id,
|
||||
teamId: attackerTeamId,
|
||||
status: 'rejected',
|
||||
decidedBy: attackerAdminId,
|
||||
});
|
||||
});
|
||||
});
|
||||
366
packages/team-server/tests/routes/knowledge.test.ts
Normal file
366
packages/team-server/tests/routes/knowledge.test.ts
Normal file
@@ -0,0 +1,366 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, teamEntities, teamRelations } from '../../src/db/schema.js';
|
||||
import { eq, or, sql } from 'drizzle-orm';
|
||||
|
||||
describe('Team Knowledge Graph API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let outsiderId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
let foreignEntityId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up any leftover test data
|
||||
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'kgtest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'kgtest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'kgtest_owner',
|
||||
displayName: 'KG Owner',
|
||||
email: 'kgtest_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'kgtest_member',
|
||||
displayName: 'KG Member',
|
||||
email: 'kgtest_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
const [outsider] = await server.db.insert(users).values({
|
||||
clerkId: 'kgtest_outsider',
|
||||
displayName: 'KG Outsider',
|
||||
email: 'kgtest_outsider@test.com',
|
||||
}).returning();
|
||||
outsiderId = outsider.id;
|
||||
|
||||
// Create a team with owner + member
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'KG Test Team',
|
||||
slug: 'kgtest-knowledge',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
teamSlug = team.slug;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
const [foreignTeam] = await server.db.insert(teams).values({
|
||||
name: 'Foreign KG Team',
|
||||
slug: 'kgtest-foreign-knowledge',
|
||||
ownerId: outsiderId,
|
||||
}).returning();
|
||||
await server.db.insert(teamMembers).values({
|
||||
teamId: foreignTeam.id,
|
||||
userId: outsiderId,
|
||||
role: 'owner',
|
||||
});
|
||||
const [foreignEntity] = await server.db.insert(teamEntities).values({
|
||||
teamId: foreignTeam.id,
|
||||
entityType: 'secret',
|
||||
name: 'Foreign Entity',
|
||||
properties: { confidential: true },
|
||||
sharedBy: outsiderId,
|
||||
}).returning();
|
||||
foreignEntityId = foreignEntity.id;
|
||||
|
||||
// Override auth handler
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'kgtest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'kgtest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('creates an entity with properties and valid_from/valid_to', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
entityType: 'concept',
|
||||
name: 'Machine Learning',
|
||||
properties: { domain: 'AI', level: 'advanced' },
|
||||
validFrom: '2026-01-01T00:00:00.000Z',
|
||||
validTo: '2027-01-01T00:00:00.000Z',
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.entityType).toBe('concept');
|
||||
expect(body.name).toBe('Machine Learning');
|
||||
expect(body.properties).toEqual({ domain: 'AI', level: 'advanced' });
|
||||
expect(body.sharedBy).toBe(ownerId);
|
||||
expect(body.teamId).toBe(teamId);
|
||||
expect(body.validFrom).toBeTruthy();
|
||||
expect(body.validTo).toBeTruthy();
|
||||
});
|
||||
|
||||
it('searches entities by type', async () => {
|
||||
// Create entities of different types
|
||||
await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'person', name: 'Alice' },
|
||||
});
|
||||
await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'person', name: 'Bob' },
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/entities?type=person`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(2);
|
||||
expect(body.every((e: { entityType: string }) => e.entityType === 'person')).toBe(true);
|
||||
});
|
||||
|
||||
it('searches entities by name (ILIKE)', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/entities?search=machine`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body.some((e: { name: string }) => e.name === 'Machine Learning')).toBe(true);
|
||||
});
|
||||
|
||||
it('creates a relation with confidence score', async () => {
|
||||
// Create two entities to relate
|
||||
const res1 = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'tool', name: 'TensorFlow' },
|
||||
});
|
||||
const entity1 = JSON.parse(res1.body);
|
||||
|
||||
const res2 = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'concept', name: 'Deep Learning' },
|
||||
});
|
||||
const entity2 = JSON.parse(res2.body);
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/relations`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
sourceId: entity1.id,
|
||||
targetId: entity2.id,
|
||||
relationType: 'implements',
|
||||
confidence: 0.95,
|
||||
properties: { since: '2015' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.sourceId).toBe(entity1.id);
|
||||
expect(body.targetId).toBe(entity2.id);
|
||||
expect(body.relationType).toBe('implements');
|
||||
expect(body.confidence).toBeCloseTo(0.95);
|
||||
expect(body.teamId).toBe(teamId);
|
||||
});
|
||||
|
||||
it('rejects relations when either endpoint belongs to another team', async () => {
|
||||
const localRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'concept', name: 'Local Endpoint' },
|
||||
});
|
||||
const localEntity = localRes.json();
|
||||
|
||||
const foreignSource = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/relations`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
sourceId: foreignEntityId,
|
||||
targetId: localEntity.id,
|
||||
relationType: 'references',
|
||||
},
|
||||
});
|
||||
const foreignTarget = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/relations`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
sourceId: localEntity.id,
|
||||
targetId: foreignEntityId,
|
||||
relationType: 'references',
|
||||
},
|
||||
});
|
||||
|
||||
expect(foreignSource.statusCode).toBe(404);
|
||||
expect(foreignSource.json()).toEqual({ error: 'Entity not found' });
|
||||
expect(foreignTarget.statusCode).toBe(404);
|
||||
expect(foreignTarget.json()).toEqual({ error: 'Entity not found' });
|
||||
|
||||
const leaked = await server.db.select().from(teamRelations).where(or(
|
||||
eq(teamRelations.sourceId, foreignEntityId),
|
||||
eq(teamRelations.targetId, foreignEntityId),
|
||||
));
|
||||
expect(leaked).toEqual([]);
|
||||
});
|
||||
|
||||
it('graph traversal returns connected entities up to depth N', async () => {
|
||||
// Create a chain: A -> B -> C
|
||||
const resA = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'node', name: 'Node-A' },
|
||||
});
|
||||
const nodeA = JSON.parse(resA.body);
|
||||
|
||||
const resB = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'node', name: 'Node-B' },
|
||||
});
|
||||
const nodeB = JSON.parse(resB.body);
|
||||
|
||||
const resC = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'node', name: 'Node-C' },
|
||||
});
|
||||
const nodeC = JSON.parse(resC.body);
|
||||
|
||||
// A -> B
|
||||
await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/relations`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { sourceId: nodeA.id, targetId: nodeB.id, relationType: 'links_to' },
|
||||
});
|
||||
|
||||
// B -> C
|
||||
await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/relations`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { sourceId: nodeB.id, targetId: nodeC.id, relationType: 'links_to' },
|
||||
});
|
||||
|
||||
// Depth 1: should find A and B only
|
||||
const res1 = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/graph?startId=${nodeA.id}&depth=1`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
expect(res1.statusCode).toBe(200);
|
||||
const graph1 = JSON.parse(res1.body);
|
||||
const entityIds1 = graph1.entities.map((e: { id: string }) => e.id);
|
||||
expect(entityIds1).toContain(nodeA.id);
|
||||
expect(entityIds1).toContain(nodeB.id);
|
||||
expect(entityIds1).not.toContain(nodeC.id);
|
||||
|
||||
// Depth 2: should find A, B, and C
|
||||
const res2 = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/graph?startId=${nodeA.id}&depth=2`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
expect(res2.statusCode).toBe(200);
|
||||
const graph2 = JSON.parse(res2.body);
|
||||
const entityIds2 = graph2.entities.map((e: { id: string }) => e.id);
|
||||
expect(entityIds2).toContain(nodeA.id);
|
||||
expect(entityIds2).toContain(nodeB.id);
|
||||
expect(entityIds2).toContain(nodeC.id);
|
||||
expect(graph2.relations.length).toBeGreaterThanOrEqual(2);
|
||||
});
|
||||
|
||||
it('does not return a foreign-team graph start entity', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/graph?startId=${foreignEntityId}&depth=1`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json()).toEqual({ error: 'Entity not found' });
|
||||
expect(response.body).not.toContain('Foreign Entity');
|
||||
expect(response.body).not.toContain('confidential');
|
||||
});
|
||||
|
||||
it('shared_by tracks who contributed', async () => {
|
||||
// Owner creates entity
|
||||
const res1 = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { entityType: 'doc', name: 'Owner Doc' },
|
||||
});
|
||||
expect(JSON.parse(res1.body).sharedBy).toBe(ownerId);
|
||||
|
||||
// Member creates entity
|
||||
const res2 = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { entityType: 'doc', name: 'Member Doc' },
|
||||
});
|
||||
expect(JSON.parse(res2.body).sharedBy).toBe(memberId);
|
||||
});
|
||||
|
||||
it('non-member gets 403', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/entities`,
|
||||
headers: { 'x-test-user-id': outsiderId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
});
|
||||
392
packages/team-server/tests/routes/messages.test.ts
Normal file
392
packages/team-server/tests/routes/messages.test.ts
Normal file
@@ -0,0 +1,392 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, teamEntities, tasks, messages } from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
|
||||
describe('Waggle Dance Messages API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let outsiderId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
|
||||
const SLUG_PREFIX = 'msgtest-';
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up any leftover test data (order matters for FK constraints)
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'msgtest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'msgtest_owner',
|
||||
displayName: 'Msg Owner',
|
||||
email: 'msgtest_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'msgtest_member',
|
||||
displayName: 'Msg Member',
|
||||
email: 'msgtest_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
const [outsider] = await server.db.insert(users).values({
|
||||
clerkId: 'msgtest_outsider',
|
||||
displayName: 'Msg Outsider',
|
||||
email: 'msgtest_outsider@test.com',
|
||||
}).returning();
|
||||
outsiderId = outsider.id;
|
||||
|
||||
// Create a team with owner + member
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Msg Test Team',
|
||||
slug: `${SLUG_PREFIX}waggle`,
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
teamSlug = team.slug;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
// Seed some team_entities and tasks for hive-check tests
|
||||
await server.db.insert(teamEntities).values([
|
||||
{ teamId, entityType: 'concept', name: 'Machine Learning', properties: { domain: 'AI' }, sharedBy: ownerId },
|
||||
{ teamId, entityType: 'tool', name: 'TensorFlow', properties: { lang: 'python' }, sharedBy: memberId },
|
||||
{ teamId, entityType: 'concept', name: 'Database Design', properties: { domain: 'engineering' }, sharedBy: ownerId },
|
||||
]);
|
||||
|
||||
await server.db.insert(tasks).values([
|
||||
{ teamId, title: 'Implement ML pipeline', description: 'Build a machine learning pipeline', status: 'open', createdBy: ownerId },
|
||||
{ teamId, title: 'Fix login bug', description: 'Login page crashes on mobile', status: 'done', createdBy: memberId },
|
||||
]);
|
||||
|
||||
// Override auth handler
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'msgtest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('sends a broadcast message and returns 201', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
type: 'broadcast',
|
||||
subtype: 'discovery',
|
||||
content: { topic: 'New skill available', details: 'web-scraper v2' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.type).toBe('broadcast');
|
||||
expect(body.subtype).toBe('discovery');
|
||||
expect(body.content).toEqual({ topic: 'New skill available', details: 'web-scraper v2' });
|
||||
expect(body.senderId).toBe(ownerId);
|
||||
expect(body.teamId).toBe(teamId);
|
||||
expect(body.id).toBeDefined();
|
||||
});
|
||||
|
||||
it('sends a request message with valid type-subtype combo', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: {
|
||||
type: 'request',
|
||||
subtype: 'knowledge_check',
|
||||
content: { query: 'Who knows about React?' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.type).toBe('request');
|
||||
expect(body.subtype).toBe('knowledge_check');
|
||||
});
|
||||
|
||||
it('rejects invalid type-subtype combination with 400', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
type: 'request',
|
||||
subtype: 'discovery', // discovery is a broadcast subtype, not request
|
||||
content: { query: 'test' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.error).toContain('Invalid type-subtype combination');
|
||||
});
|
||||
|
||||
it('stores routing field when provided', async () => {
|
||||
const routing = [
|
||||
{ userId: memberId, reason: 'Expert in ML' },
|
||||
];
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
type: 'broadcast',
|
||||
subtype: 'routed_share',
|
||||
content: { data: 'ML model results' },
|
||||
routing,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.routing).toEqual(routing);
|
||||
});
|
||||
|
||||
it('stores referenceId when provided', async () => {
|
||||
// First create a message to reference
|
||||
const firstRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: {
|
||||
type: 'request',
|
||||
subtype: 'task_delegation',
|
||||
content: { task: 'Review PR #42' },
|
||||
},
|
||||
});
|
||||
const firstMsg = JSON.parse(firstRes.body);
|
||||
|
||||
// Send a response referencing the first message
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
type: 'response',
|
||||
subtype: 'task_claim',
|
||||
content: { accepted: true },
|
||||
referenceId: firstMsg.id,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.referenceId).toBe(firstMsg.id);
|
||||
});
|
||||
|
||||
it('lists messages for the team', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
it('filters messages by type', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/messages?type=broadcast`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.every((m: { type: string }) => m.type === 'broadcast')).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
it('filters messages by subtype', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/messages?subtype=discovery`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.every((m: { subtype: string }) => m.subtype === 'discovery')).toBe(true);
|
||||
});
|
||||
|
||||
it('publishes message to Redis channel on send', async () => {
|
||||
// Subscribe to the team channel before sending
|
||||
const receivedMessages: string[] = [];
|
||||
await server.redisSub.subscribe(`team:${teamId}:waggle`);
|
||||
server.redisSub.on('message', (_channel: string, message: string) => {
|
||||
receivedMessages.push(message);
|
||||
});
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
type: 'broadcast',
|
||||
subtype: 'skill_share',
|
||||
content: { skill: 'data-analysis', version: '1.0' },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
|
||||
// Give Redis a moment to deliver
|
||||
await new Promise((resolve) => setTimeout(resolve, 200));
|
||||
|
||||
expect(receivedMessages.length).toBeGreaterThanOrEqual(1);
|
||||
const published = JSON.parse(receivedMessages[receivedMessages.length - 1]);
|
||||
expect(published.subtype).toBe('skill_share');
|
||||
expect(published.content).toEqual({ skill: 'data-analysis', version: '1.0' });
|
||||
|
||||
// Cleanup subscription
|
||||
await server.redisSub.unsubscribe(`team:${teamId}:waggle`);
|
||||
server.redisSub.removeAllListeners('message');
|
||||
});
|
||||
|
||||
it('non-member gets 403 when sending messages', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': outsiderId },
|
||||
payload: {
|
||||
type: 'broadcast',
|
||||
subtype: 'discovery',
|
||||
content: { test: true },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('non-member gets 403 when listing messages', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/messages`,
|
||||
headers: { 'x-test-user-id': outsiderId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
describe('hive-check', () => {
|
||||
it('finds matching entities by topic', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages/hive-check`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { topic: 'Machine Learning' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.entities.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body.entities.some((e: { name: string }) => e.name === 'Machine Learning')).toBe(true);
|
||||
});
|
||||
|
||||
it('finds matching tasks by topic', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages/hive-check`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { topic: 'ML pipeline' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.relatedTasks.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body.relatedTasks.some((t: { title: string }) => t.title.includes('ML pipeline'))).toBe(true);
|
||||
});
|
||||
|
||||
it('finds matching broadcast messages', async () => {
|
||||
// We already sent broadcast messages earlier in the test suite
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages/hive-check`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { topic: 'anything' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.relatedMessages).toBeDefined();
|
||||
expect(Array.isArray(body.relatedMessages)).toBe(true);
|
||||
});
|
||||
|
||||
it('returns empty results for non-matching topic', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages/hive-check`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { topic: 'xyzzy_nonexistent_topic_12345' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.entities).toHaveLength(0);
|
||||
expect(body.relatedTasks).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('non-member gets 403 on hive-check', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages/hive-check`,
|
||||
headers: { 'x-test-user-id': outsiderId },
|
||||
payload: { topic: 'test' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('validates hive-check input', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/messages/hive-check`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {}, // missing topic
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
});
|
||||
});
|
||||
263
packages/team-server/tests/routes/resources.test.ts
Normal file
263
packages/team-server/tests/routes/resources.test.ts
Normal file
@@ -0,0 +1,263 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, teamResources } from '../../src/db/schema.js';
|
||||
import { eq, sql } from 'drizzle-orm';
|
||||
|
||||
describe('Team Resources API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let outsiderId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up any leftover test data
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'restest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'restest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'restest_owner',
|
||||
displayName: 'Res Owner',
|
||||
email: 'restest_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'restest_member',
|
||||
displayName: 'Res Member',
|
||||
email: 'restest_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
const [outsider] = await server.db.insert(users).values({
|
||||
clerkId: 'restest_outsider',
|
||||
displayName: 'Res Outsider',
|
||||
email: 'restest_outsider@test.com',
|
||||
}).returning();
|
||||
outsiderId = outsider.id;
|
||||
|
||||
// Create a team with owner + member
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Res Test Team',
|
||||
slug: 'restest-resources',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
teamSlug = team.slug;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
// Override auth handler
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'restest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'restest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('shares a model_recipe resource', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/resources`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
resourceType: 'model_recipe',
|
||||
name: 'GPT-4 Coding Recipe',
|
||||
description: 'Optimized for code generation',
|
||||
config: { model: 'gpt-4', temperature: 0.2 },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.resourceType).toBe('model_recipe');
|
||||
expect(body.name).toBe('GPT-4 Coding Recipe');
|
||||
expect(body.description).toBe('Optimized for code generation');
|
||||
expect(body.config).toEqual({ model: 'gpt-4', temperature: 0.2 });
|
||||
expect(body.sharedBy).toBe(ownerId);
|
||||
expect(body.rating).toBe(0);
|
||||
expect(body.useCount).toBe(0);
|
||||
});
|
||||
|
||||
it('shares a skill resource', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/resources`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: {
|
||||
resourceType: 'skill',
|
||||
name: 'Code Review Skill',
|
||||
description: 'Automated code review with best practices',
|
||||
config: { language: 'typescript', rules: ['no-any', 'strict-null'] },
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.resourceType).toBe('skill');
|
||||
expect(body.name).toBe('Code Review Skill');
|
||||
expect(body.sharedBy).toBe(memberId);
|
||||
});
|
||||
|
||||
it('rates a resource and updates running average', async () => {
|
||||
// Create a resource first
|
||||
const createRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/resources`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
resourceType: 'prompt_template',
|
||||
name: 'Summarizer Prompt',
|
||||
config: { template: 'Summarize: {{input}}' },
|
||||
},
|
||||
});
|
||||
const resource = JSON.parse(createRes.body);
|
||||
|
||||
// First rating: should be the rating itself (useCount was 0)
|
||||
const rate1 = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { rating: 4 },
|
||||
});
|
||||
expect(rate1.statusCode).toBe(200);
|
||||
const body1 = JSON.parse(rate1.body);
|
||||
// After first rate: rating was set to 4 (useCount was 0), then useCount incremented to 1
|
||||
expect(body1.useCount).toBe(1);
|
||||
|
||||
// Second rating: running average = (4 * 1 + 2) / 2 = 3
|
||||
const rate2 = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { rating: 2 },
|
||||
});
|
||||
expect(rate2.statusCode).toBe(200);
|
||||
const body2 = JSON.parse(rate2.body);
|
||||
expect(body2.useCount).toBe(2);
|
||||
// rating = (4 * 1 + 2) / 2 = 3
|
||||
expect(body2.rating).toBeCloseTo(3, 1);
|
||||
});
|
||||
|
||||
it('increments use_count on rate', async () => {
|
||||
const createRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/resources`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: {
|
||||
resourceType: 'tool_config',
|
||||
name: 'Linter Config',
|
||||
config: { tool: 'eslint', extends: 'recommended' },
|
||||
},
|
||||
});
|
||||
const resource = JSON.parse(createRes.body);
|
||||
expect(resource.useCount).toBe(0);
|
||||
|
||||
// Rate it
|
||||
const rateRes = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { rating: 5 },
|
||||
});
|
||||
const rated = JSON.parse(rateRes.body);
|
||||
expect(rated.useCount).toBe(1);
|
||||
|
||||
// Rate again
|
||||
const rateRes2 = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { rating: 3 },
|
||||
});
|
||||
const rated2 = JSON.parse(rateRes2.body);
|
||||
expect(rated2.useCount).toBe(2);
|
||||
});
|
||||
|
||||
it('does not rate a resource owned by another team through this team route', async () => {
|
||||
const [foreignTeam] = await server.db.insert(teams).values({
|
||||
name: 'Foreign Resource Team',
|
||||
slug: 'restest-foreign-resources',
|
||||
ownerId: outsiderId,
|
||||
}).returning();
|
||||
await server.db.insert(teamMembers).values({
|
||||
teamId: foreignTeam.id,
|
||||
userId: outsiderId,
|
||||
role: 'owner',
|
||||
});
|
||||
const [foreignResource] = await server.db.insert(teamResources).values({
|
||||
teamId: foreignTeam.id,
|
||||
resourceType: 'model_recipe',
|
||||
name: 'Foreign Recipe',
|
||||
config: { model: 'private-model' },
|
||||
sharedBy: outsiderId,
|
||||
rating: 1,
|
||||
useCount: 1,
|
||||
}).returning();
|
||||
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/resources/${foreignResource.id}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { rating: 5 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json()).toEqual({ error: 'Resource not found' });
|
||||
|
||||
const [unchanged] = await server.db.select().from(teamResources)
|
||||
.where(eq(teamResources.id, foreignResource.id));
|
||||
expect(unchanged.rating).toBe(1);
|
||||
expect(unchanged.useCount).toBe(1);
|
||||
});
|
||||
|
||||
it('filters resources by resource_type', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/resources?type=skill`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body.every((r: { resourceType: string }) => r.resourceType === 'skill')).toBe(true);
|
||||
});
|
||||
|
||||
it('non-member gets 403', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/resources`,
|
||||
headers: { 'x-test-user-id': outsiderId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
});
|
||||
210
packages/team-server/tests/routes/tasks.test.ts
Normal file
210
packages/team-server/tests/routes/tasks.test.ts
Normal file
@@ -0,0 +1,210 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers, tasks } from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
|
||||
describe('Task Board API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let outsiderId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
let createdTaskId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up any leftover test data
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'tstest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tstest_%'`);
|
||||
|
||||
// Create test users
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'tstest_owner',
|
||||
displayName: 'Task Owner',
|
||||
email: 'tstest_owner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'tstest_member',
|
||||
displayName: 'Task Member',
|
||||
email: 'tstest_member@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
const [outsider] = await server.db.insert(users).values({
|
||||
clerkId: 'tstest_outsider',
|
||||
displayName: 'Task Outsider',
|
||||
email: 'tstest_outsider@test.com',
|
||||
}).returning();
|
||||
outsiderId = outsider.id;
|
||||
|
||||
// Create a team with owner + member
|
||||
const [team] = await server.db.insert(teams).values({
|
||||
name: 'Task Test Team',
|
||||
slug: 'tstest-tasks',
|
||||
ownerId,
|
||||
}).returning();
|
||||
teamId = team.id;
|
||||
teamSlug = team.slug;
|
||||
|
||||
await server.db.insert(teamMembers).values([
|
||||
{ teamId, userId: ownerId, role: 'owner' },
|
||||
{ teamId, userId: memberId, role: 'member' },
|
||||
]);
|
||||
|
||||
// Override auth handler
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'tstest-%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tstest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('creates a task on team board', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { title: 'Research competitors', description: 'Analyze top 5 competitors', priority: 'high' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.title).toBe('Research competitors');
|
||||
expect(body.description).toBe('Analyze top 5 competitors');
|
||||
expect(body.priority).toBe('high');
|
||||
expect(body.status).toBe('open');
|
||||
expect(body.createdBy).toBe(ownerId);
|
||||
expect(body.teamId).toBe(teamId);
|
||||
createdTaskId = body.id;
|
||||
});
|
||||
|
||||
it('lists tasks on team board', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
expect(body.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body.some((t: { id: string }) => t.id === createdTaskId)).toBe(true);
|
||||
});
|
||||
|
||||
it('lists tasks with status filter', async () => {
|
||||
// Create a second task and mark it done
|
||||
const createRes = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { title: 'Done task' },
|
||||
});
|
||||
const doneTask = JSON.parse(createRes.body);
|
||||
|
||||
await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/tasks/${doneTask.id}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { status: 'done' },
|
||||
});
|
||||
|
||||
// Filter by status=open
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/tasks?status=open`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.every((t: { status: string }) => t.status === 'open')).toBe(true);
|
||||
expect(body.some((t: { id: string }) => t.id === doneTask.id)).toBe(false);
|
||||
});
|
||||
|
||||
it('claims a task — sets assignedTo and status to claimed', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}/claim`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.assignedTo).toBe(memberId);
|
||||
expect(body.status).toBe('claimed');
|
||||
});
|
||||
|
||||
it('completes a task — status changes to done', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { status: 'done' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.status).toBe('done');
|
||||
});
|
||||
|
||||
it('creates a subtask with parentTaskId', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { title: 'Sub-research item', parentTaskId: createdTaskId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.parentTaskId).toBe(createdTaskId);
|
||||
expect(body.priority).toBe('normal');
|
||||
});
|
||||
|
||||
it('non-team-member gets 403', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/tasks`,
|
||||
headers: { 'x-test-user-id': outsiderId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('gets a single task by id', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.id).toBe(createdTaskId);
|
||||
expect(body.title).toBe('Research competitors');
|
||||
});
|
||||
});
|
||||
304
packages/team-server/tests/routes/teams.test.ts
Normal file
304
packages/team-server/tests/routes/teams.test.ts
Normal file
@@ -0,0 +1,304 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { buildServer } from '../../src/index.js';
|
||||
import { users, teams, teamMembers } from '../../src/db/schema.js';
|
||||
import { sql } from 'drizzle-orm';
|
||||
|
||||
describe('Team API', () => {
|
||||
let server: Awaited<ReturnType<typeof buildServer>>;
|
||||
let ownerId: string;
|
||||
let memberId: string;
|
||||
let adminId: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = await buildServer();
|
||||
|
||||
// Clean up any leftover test data (use unique prefix to avoid collision with auth tests)
|
||||
// Narrow to 'test-team%' — previously 'test-%' collided with analytics.test.ts's
|
||||
// 'test-analytics' slug when files ran in parallel and wiped it mid-run, causing
|
||||
// spurious 403s because the analytics team's owner was no longer a member.
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'test-team%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tmtest_%'`);
|
||||
|
||||
// Create test users directly in DB (clerk IDs use 'tmtest_' prefix to avoid auth test cleanup)
|
||||
const [owner] = await server.db.insert(users).values({
|
||||
clerkId: 'tmtest_owner',
|
||||
displayName: 'Team Owner',
|
||||
email: 'teamowner@test.com',
|
||||
}).returning();
|
||||
ownerId = owner.id;
|
||||
|
||||
const [member] = await server.db.insert(users).values({
|
||||
clerkId: 'tmtest_member',
|
||||
displayName: 'Team Member',
|
||||
email: 'teammember@test.com',
|
||||
}).returning();
|
||||
memberId = member.id;
|
||||
|
||||
const [admin] = await server.db.insert(users).values({
|
||||
clerkId: 'tmtest_admin',
|
||||
displayName: 'Team Admin',
|
||||
email: 'teamadmin@test.com',
|
||||
}).returning();
|
||||
adminId = admin.id;
|
||||
|
||||
// Override auth handler to use x-test-user-id header (via indirection object)
|
||||
server._authHandler.fn = async function (request, reply) {
|
||||
const testUserId = request.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
|
||||
}
|
||||
request.userId = testUserId;
|
||||
request.clerkId = 'test';
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Narrow to 'test-team%' — previously 'test-%' collided with analytics.test.ts's
|
||||
// 'test-analytics' slug when files ran in parallel and wiped it mid-run, causing
|
||||
// spurious 403s because the analytics team's owner was no longer a member.
|
||||
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'test-team%'`);
|
||||
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tmtest_%'`);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('creates a team and auto-adds owner as member with role owner', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/teams',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { name: 'Test Team', slug: 'test-team-crud' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.name).toBe('Test Team');
|
||||
expect(body.slug).toBe('test-team-crud');
|
||||
expect(body.ownerId).toBe(ownerId);
|
||||
|
||||
// Verify owner membership
|
||||
const [membership] = await server.db
|
||||
.select()
|
||||
.from(teamMembers)
|
||||
.where(sql`team_id = ${body.id} AND user_id = ${ownerId}`);
|
||||
expect(membership).toBeDefined();
|
||||
expect(membership.role).toBe('owner');
|
||||
});
|
||||
|
||||
it('returns 409 on duplicate slug', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/teams',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { name: 'Another Team', slug: 'test-team-crud' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(409);
|
||||
});
|
||||
|
||||
it('lists only teams the user belongs to', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/teams',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(Array.isArray(body)).toBe(true);
|
||||
const slugs = body.map((t: { slug: string }) => t.slug);
|
||||
expect(slugs).toContain('test-team-crud');
|
||||
});
|
||||
|
||||
it('non-member gets empty list', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/teams',
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
// memberId is not a member of any team with test- slug yet
|
||||
const testTeams = body.filter((t: { slug: string }) => t.slug.startsWith('test-'));
|
||||
expect(testTeams).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('gets team by slug with members', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/teams/test-team-crud',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.slug).toBe('test-team-crud');
|
||||
expect(body.members).toBeDefined();
|
||||
expect(body.members.length).toBeGreaterThanOrEqual(1);
|
||||
expect(body.members[0].displayName).toBe('Team Owner');
|
||||
});
|
||||
|
||||
it('non-member gets 403 when accessing team', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/teams/test-team-crud',
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('adds a member via invite (admin+)', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/teams/test-team-crud/members',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { email: 'teammember@test.com', role: 'member' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.userId).toBe(memberId);
|
||||
expect(body.role).toBe('member');
|
||||
});
|
||||
|
||||
it('returns 409 when inviting existing member', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/teams/test-team-crud/members',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { email: 'teammember@test.com', role: 'member' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(409);
|
||||
});
|
||||
|
||||
it('adds an admin member', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'POST',
|
||||
url: '/api/teams/test-team-crud/members',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
payload: { email: 'teamadmin@test.com', role: 'admin' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.role).toBe('admin');
|
||||
});
|
||||
|
||||
it('member can update own roleDescription and interests', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/test-team-crud/members/${memberId}`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: {
|
||||
roleDescription: 'Frontend developer',
|
||||
interests: ['React', 'TypeScript'],
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.roleDescription).toBe('Frontend developer');
|
||||
expect(body.interests).toEqual(['React', 'TypeScript']);
|
||||
});
|
||||
|
||||
it('member cannot change own role', async () => {
|
||||
// Attempting to change role requires admin, but member is only 'member'
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/test-team-crud/members/${memberId}`,
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { role: 'admin' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('admin can update team name', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: '/api/teams/test-team-crud',
|
||||
headers: { 'x-test-user-id': adminId },
|
||||
payload: { name: 'Updated Team Name' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.name).toBe('Updated Team Name');
|
||||
});
|
||||
|
||||
it('member cannot update team name', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: '/api/teams/test-team-crud',
|
||||
headers: { 'x-test-user-id': memberId },
|
||||
payload: { name: 'Should Fail' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('cannot remove the team owner', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/teams/test-team-crud/members/${ownerId}`,
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
});
|
||||
|
||||
it('admin can remove a member', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'DELETE',
|
||||
url: `/api/teams/test-team-crud/members/${memberId}`,
|
||||
headers: { 'x-test-user-id': adminId },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(204);
|
||||
|
||||
// Verify member is gone
|
||||
const checkResponse = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/teams/test-team-crud',
|
||||
headers: { 'x-test-user-id': ownerId },
|
||||
});
|
||||
const body = JSON.parse(checkResponse.body);
|
||||
const memberIds = body.members.map((m: { userId: string }) => m.userId);
|
||||
expect(memberIds).not.toContain(memberId);
|
||||
});
|
||||
|
||||
it('does not let an admin demote the team owner', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'PATCH',
|
||||
url: `/api/teams/test-team-crud/members/${ownerId}`,
|
||||
headers: { 'x-test-user-id': adminId },
|
||||
payload: { role: 'member' },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
expect(response.json()).toEqual({ error: 'Cannot change the team owner role' });
|
||||
|
||||
const [membership] = await server.db.select().from(teamMembers)
|
||||
.where(sql`team_id = (SELECT id FROM teams WHERE slug = 'test-team-crud') AND user_id = ${ownerId}`);
|
||||
expect(membership.role).toBe('owner');
|
||||
});
|
||||
|
||||
it('returns 401 without auth header', async () => {
|
||||
const response = await server.inject({
|
||||
method: 'GET',
|
||||
url: '/api/teams',
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(401);
|
||||
});
|
||||
});
|
||||
173
packages/team-server/tests/routes/webhooks.test.ts
Normal file
173
packages/team-server/tests/routes/webhooks.test.ts
Normal file
@@ -0,0 +1,173 @@
|
||||
import { createHmac } from 'node:crypto';
|
||||
import Fastify, { type FastifyInstance } from 'fastify';
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
||||
import { webhookRoutes } from '../../src/routes/webhooks.js';
|
||||
|
||||
const SIGNING_KEY = Buffer.from('waggle-clerk-webhook-test-secret');
|
||||
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
|
||||
|
||||
const createEvent = {
|
||||
type: 'user.created',
|
||||
data: {
|
||||
id: 'clerk_webhook_user',
|
||||
first_name: 'Ada',
|
||||
last_name: 'Lovelace',
|
||||
email_addresses: [{ email_address: 'ada@example.com' }],
|
||||
image_url: 'https://example.com/ada.png',
|
||||
},
|
||||
};
|
||||
|
||||
function signedHeaders(payload: object, timestamp = Math.floor(Date.now() / 1000)) {
|
||||
const id = 'msg_waggle_clerk_test';
|
||||
const body = JSON.stringify(payload);
|
||||
const signature = createHmac('sha256', SIGNING_KEY)
|
||||
.update(`${id}.${timestamp}.${body}`)
|
||||
.digest('base64');
|
||||
|
||||
return {
|
||||
'svix-id': id,
|
||||
'svix-timestamp': String(timestamp),
|
||||
'svix-signature': `v1,${signature}`,
|
||||
};
|
||||
}
|
||||
|
||||
function createDbDouble() {
|
||||
const onConflictDoNothing = vi.fn().mockResolvedValue(undefined);
|
||||
const values = vi.fn(() => ({ onConflictDoNothing }));
|
||||
const insert = vi.fn(() => ({ values }));
|
||||
|
||||
const updateWhere = vi.fn().mockResolvedValue(undefined);
|
||||
const set = vi.fn(() => ({ where: updateWhere }));
|
||||
const update = vi.fn(() => ({ set }));
|
||||
|
||||
const deleteWhere = vi.fn().mockResolvedValue(undefined);
|
||||
const deleteFrom = vi.fn(() => ({ where: deleteWhere }));
|
||||
|
||||
return {
|
||||
db: { insert, update, delete: deleteFrom },
|
||||
mutations: { insert, values, update, deleteFrom },
|
||||
};
|
||||
}
|
||||
|
||||
describe('Clerk webhook authenticity', () => {
|
||||
let app: FastifyInstance;
|
||||
let mutations: ReturnType<typeof createDbDouble>['mutations'];
|
||||
let originalSigningSecret: string | undefined;
|
||||
|
||||
beforeEach(async () => {
|
||||
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
|
||||
|
||||
const dbDouble = createDbDouble();
|
||||
mutations = dbDouble.mutations;
|
||||
app = Fastify();
|
||||
app.decorate('db', dbDouble.db as never);
|
||||
await app.register(webhookRoutes);
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await app.close();
|
||||
if (originalSigningSecret === undefined) {
|
||||
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
} else {
|
||||
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
|
||||
}
|
||||
});
|
||||
|
||||
it.each([
|
||||
['user.created', createEvent.data],
|
||||
['user.updated', createEvent.data],
|
||||
['user.deleted', { id: createEvent.data.id }],
|
||||
])('rejects an unsigned %s event before any database mutation', async (type, data) => {
|
||||
const response = await app.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
payload: { type, data },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json()).toEqual({ error: 'Invalid webhook signature' });
|
||||
expect(mutations.insert).not.toHaveBeenCalled();
|
||||
expect(mutations.update).not.toHaveBeenCalled();
|
||||
expect(mutations.deleteFrom).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects an otherwise signed event when its timestamp is stale', async () => {
|
||||
const staleTimestamp = Math.floor(Date.now() / 1000) - 301;
|
||||
const response = await app.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(createEvent, staleTimestamp),
|
||||
payload: createEvent,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(mutations.insert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('rejects a signature that was generated for a different body', async () => {
|
||||
const tamperedEvent = {
|
||||
...createEvent,
|
||||
data: { ...createEvent.data, email_addresses: [{ email_address: 'attacker@example.com' }] },
|
||||
};
|
||||
const response = await app.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(createEvent),
|
||||
payload: tamperedEvent,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(mutations.insert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('fails closed when the Clerk webhook signing secret is not configured', async () => {
|
||||
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
|
||||
|
||||
const response = await app.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(createEvent),
|
||||
payload: createEvent,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(mutations.insert).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('preserves a correctly signed user.created event and its field mapping', async () => {
|
||||
const response = await app.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(createEvent),
|
||||
payload: createEvent,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
expect(response.json()).toEqual({ received: true });
|
||||
expect(mutations.values).toHaveBeenCalledWith({
|
||||
clerkId: 'clerk_webhook_user',
|
||||
displayName: 'Ada Lovelace',
|
||||
email: 'ada@example.com',
|
||||
avatarUrl: 'https://example.com/ada.png',
|
||||
});
|
||||
});
|
||||
|
||||
it('preserves correctly signed user.updated and user.deleted events', async () => {
|
||||
const updateEvent = { ...createEvent, type: 'user.updated' };
|
||||
const deleteEvent = { type: 'user.deleted', data: { id: createEvent.data.id } };
|
||||
|
||||
for (const event of [updateEvent, deleteEvent]) {
|
||||
const response = await app.inject({
|
||||
method: 'POST',
|
||||
url: '/api/webhooks/clerk',
|
||||
headers: signedHeaders(event),
|
||||
payload: event,
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
}
|
||||
|
||||
expect(mutations.update).toHaveBeenCalledOnce();
|
||||
expect(mutations.deleteFrom).toHaveBeenCalledOnce();
|
||||
});
|
||||
});
|
||||
19
packages/team-server/tests/server.test.ts
Normal file
19
packages/team-server/tests/server.test.ts
Normal file
@@ -0,0 +1,19 @@
|
||||
import { describe, it, expect, afterAll } from 'vitest';
|
||||
import { buildServer } from '../src/index.js';
|
||||
|
||||
describe('Fastify server', () => {
|
||||
const serverPromise = buildServer();
|
||||
|
||||
afterAll(async () => {
|
||||
const server = await serverPromise;
|
||||
await server.close();
|
||||
});
|
||||
|
||||
it('responds to health check', async () => {
|
||||
const server = await serverPromise;
|
||||
const response = await server.inject({ method: 'GET', url: '/health' });
|
||||
expect(response.statusCode).toBe(200);
|
||||
const body = JSON.parse(response.body);
|
||||
expect(body.status).toBe('ok');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,203 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import {
|
||||
resolvePermission,
|
||||
filterByPermissions,
|
||||
getDefaultPolicies,
|
||||
riskExceedsThreshold,
|
||||
type EffectivePermissions,
|
||||
} from '../../src/services/team-capability-governance.js';
|
||||
|
||||
function makePerms(overrides?: Partial<EffectivePermissions>): EffectivePermissions {
|
||||
return {
|
||||
role: 'member',
|
||||
allowedSources: ['native', 'skill'],
|
||||
blockedTools: ['bash', 'delete_skill'],
|
||||
approvalThreshold: 'medium',
|
||||
overrides: new Map(),
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
describe('riskExceedsThreshold', () => {
|
||||
it('high exceeds medium', () => {
|
||||
expect(riskExceedsThreshold('high', 'medium')).toBe(true);
|
||||
});
|
||||
|
||||
it('medium does not exceed medium', () => {
|
||||
expect(riskExceedsThreshold('medium', 'medium')).toBe(false);
|
||||
});
|
||||
|
||||
it('low does not exceed medium', () => {
|
||||
expect(riskExceedsThreshold('low', 'medium')).toBe(false);
|
||||
});
|
||||
|
||||
it('nothing exceeds none threshold', () => {
|
||||
expect(riskExceedsThreshold('high', 'none')).toBe(false);
|
||||
expect(riskExceedsThreshold('medium', 'none')).toBe(false);
|
||||
expect(riskExceedsThreshold('low', 'none')).toBe(false);
|
||||
});
|
||||
|
||||
it('medium exceeds low', () => {
|
||||
expect(riskExceedsThreshold('medium', 'low')).toBe(true);
|
||||
});
|
||||
|
||||
// P7/D15 A2b regression: 'critical' was omitted from the local risk map, so
|
||||
// `?? 0` sorted it BELOW 'low' and a critical capability slipped past a 'low'
|
||||
// approval threshold. Now ranked on the canonical scale.
|
||||
it('critical exceeds every lower threshold', () => {
|
||||
expect(riskExceedsThreshold('critical', 'low')).toBe(true);
|
||||
expect(riskExceedsThreshold('critical', 'medium')).toBe(true);
|
||||
expect(riskExceedsThreshold('critical', 'high')).toBe(true);
|
||||
});
|
||||
|
||||
it('critical does not exceed critical', () => {
|
||||
expect(riskExceedsThreshold('critical', 'critical')).toBe(false);
|
||||
});
|
||||
|
||||
it('nothing exceeds the none threshold, including critical', () => {
|
||||
expect(riskExceedsThreshold('critical', 'none')).toBe(false);
|
||||
});
|
||||
|
||||
it('low does not exceed low', () => {
|
||||
expect(riskExceedsThreshold('low', 'low')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('resolvePermission', () => {
|
||||
it('override approved returns allowed immediately', () => {
|
||||
const perms = makePerms({
|
||||
overrides: new Map([['dangerous_tool', 'approved']]),
|
||||
});
|
||||
// Even if source not in allowedSources, override wins
|
||||
expect(resolvePermission(perms, 'dangerous_tool', 'plugin', 'high')).toBe('allowed');
|
||||
});
|
||||
|
||||
it('override blocked returns blocked immediately', () => {
|
||||
const perms = makePerms({
|
||||
overrides: new Map([['some_skill', 'blocked']]),
|
||||
});
|
||||
// Even if source is allowed and tool not blocked, override wins
|
||||
expect(resolvePermission(perms, 'some_skill', 'native', 'low')).toBe('blocked');
|
||||
});
|
||||
|
||||
it('source not allowed returns source_not_allowed', () => {
|
||||
const perms = makePerms({ allowedSources: ['native'] });
|
||||
expect(resolvePermission(perms, 'some_plugin', 'plugin', 'low')).toBe('source_not_allowed');
|
||||
});
|
||||
|
||||
it('blocked tool returns blocked', () => {
|
||||
const perms = makePerms();
|
||||
expect(resolvePermission(perms, 'bash', 'native', 'low')).toBe('blocked');
|
||||
});
|
||||
|
||||
it('risk exceeds threshold returns needs_approval', () => {
|
||||
const perms = makePerms({ approvalThreshold: 'medium' });
|
||||
expect(resolvePermission(perms, 'safe_tool', 'native', 'high')).toBe('needs_approval');
|
||||
});
|
||||
|
||||
it('risk within threshold returns allowed', () => {
|
||||
const perms = makePerms({ approvalThreshold: 'medium' });
|
||||
expect(resolvePermission(perms, 'safe_tool', 'native', 'low')).toBe('allowed');
|
||||
});
|
||||
|
||||
it('threshold none means everything allowed (no approval needed)', () => {
|
||||
const perms = makePerms({ approvalThreshold: 'none' });
|
||||
expect(resolvePermission(perms, 'safe_tool', 'native', 'high')).toBe('allowed');
|
||||
});
|
||||
|
||||
it('blocked tool takes priority over source check', () => {
|
||||
const perms = makePerms({
|
||||
allowedSources: ['native'],
|
||||
blockedTools: ['bash'],
|
||||
});
|
||||
// bash is native (allowed source) but blocked tool — should be blocked
|
||||
expect(resolvePermission(perms, 'bash', 'native', 'low')).toBe('blocked');
|
||||
});
|
||||
|
||||
it('defaults risk to low when not provided', () => {
|
||||
const perms = makePerms({ approvalThreshold: 'low' });
|
||||
// low does not exceed low, so allowed
|
||||
expect(resolvePermission(perms, 'safe_tool', 'native')).toBe('allowed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('filterByPermissions', () => {
|
||||
it('removes blocked capabilities', () => {
|
||||
const perms = makePerms();
|
||||
const caps = [
|
||||
{ name: 'bash', type: 'native' },
|
||||
{ name: 'safe_tool', type: 'native', risk: 'low' },
|
||||
];
|
||||
const results = filterByPermissions(perms, caps);
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0].result).toBe('blocked');
|
||||
expect(results[1].result).toBe('allowed');
|
||||
});
|
||||
|
||||
it('keeps approved overrides even if source not in policy', () => {
|
||||
const perms = makePerms({
|
||||
allowedSources: ['native'],
|
||||
overrides: new Map([['my_plugin', 'approved']]),
|
||||
});
|
||||
const caps = [{ name: 'my_plugin', type: 'plugin', risk: 'high' }];
|
||||
const results = filterByPermissions(perms, caps);
|
||||
expect(results[0].result).toBe('allowed');
|
||||
});
|
||||
|
||||
it('blocks override-blocked even if policy would allow', () => {
|
||||
const perms = makePerms({
|
||||
allowedSources: ['native', 'skill'],
|
||||
blockedTools: [],
|
||||
overrides: new Map([['good_skill', 'blocked']]),
|
||||
});
|
||||
const caps = [{ name: 'good_skill', type: 'skill', risk: 'low' }];
|
||||
const results = filterByPermissions(perms, caps);
|
||||
expect(results[0].result).toBe('blocked');
|
||||
});
|
||||
|
||||
it('marks source_not_allowed for unknown sources', () => {
|
||||
const perms = makePerms({ allowedSources: ['native'] });
|
||||
const caps = [{ name: 'mcp_tool', type: 'mcp' }];
|
||||
const results = filterByPermissions(perms, caps);
|
||||
expect(results[0].result).toBe('source_not_allowed');
|
||||
});
|
||||
|
||||
it('marks needs_approval when risk exceeds threshold', () => {
|
||||
const perms = makePerms({ approvalThreshold: 'low' });
|
||||
const caps = [{ name: 'risky_skill', type: 'skill', risk: 'medium' }];
|
||||
const results = filterByPermissions(perms, caps);
|
||||
expect(results[0].result).toBe('needs_approval');
|
||||
});
|
||||
});
|
||||
|
||||
describe('getDefaultPolicies', () => {
|
||||
it('returns 3 role policies', () => {
|
||||
const policies = getDefaultPolicies();
|
||||
expect(policies).toHaveLength(3);
|
||||
const roles = policies.map((p) => p.role);
|
||||
expect(roles).toContain('owner');
|
||||
expect(roles).toContain('admin');
|
||||
expect(roles).toContain('member');
|
||||
});
|
||||
|
||||
it('owner has all sources and no blocks', () => {
|
||||
const owner = getDefaultPolicies().find((p) => p.role === 'owner')!;
|
||||
expect(owner.allowedSources).toEqual(['native', 'skill', 'plugin', 'mcp']);
|
||||
expect(owner.blockedTools).toEqual([]);
|
||||
expect(owner.approvalThreshold).toBe('none');
|
||||
});
|
||||
|
||||
it('admin has all sources and no blocks', () => {
|
||||
const admin = getDefaultPolicies().find((p) => p.role === 'admin')!;
|
||||
expect(admin.allowedSources).toEqual(['native', 'skill', 'plugin', 'mcp']);
|
||||
expect(admin.blockedTools).toEqual([]);
|
||||
expect(admin.approvalThreshold).toBe('none');
|
||||
});
|
||||
|
||||
it('member has restricted sources and blocked tools', () => {
|
||||
const member = getDefaultPolicies().find((p) => p.role === 'member')!;
|
||||
expect(member.allowedSources).toEqual(['native', 'skill']);
|
||||
expect(member.blockedTools).toEqual(['bash', 'delete_skill']);
|
||||
expect(member.approvalThreshold).toBe('medium');
|
||||
});
|
||||
});
|
||||
574
packages/team-server/tests/ws/gateway.test.ts
Normal file
574
packages/team-server/tests/ws/gateway.test.ts
Normal file
@@ -0,0 +1,574 @@
|
||||
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
|
||||
import type { Mock } from 'vitest';
|
||||
import type { WebSocket } from 'ws';
|
||||
import type { Task, SuggestionEntry } from '@waggle/shared';
|
||||
import type { AuthenticateFn } from '../../src/plugins/auth.js';
|
||||
import { ConnectionManager } from '../../src/ws/connection-manager.js';
|
||||
import { connectionManager, setWsTokenVerifier } from '../../src/ws/gateway.js';
|
||||
|
||||
/** A minimal mock WebSocket exposing the surface ConnectionManager touches. */
|
||||
interface MockWebSocket {
|
||||
readyState: number;
|
||||
OPEN: number;
|
||||
send: Mock;
|
||||
}
|
||||
|
||||
/** Build a mock WebSocket whose `send` is a vitest mock the tests can assert on. */
|
||||
function mockWs(readyState = 1): MockWebSocket {
|
||||
return { readyState, OPEN: 1, send: vi.fn() };
|
||||
}
|
||||
|
||||
/**
|
||||
* Cast a mock WebSocket to the real `ws.WebSocket` type at ConnectionManager
|
||||
* boundaries. The real type has a large surface; ConnectionManager only reads
|
||||
* `readyState`/`OPEN` and calls `send`, so the minimal mock is sound here.
|
||||
*/
|
||||
function asWs(ws: MockWebSocket): WebSocket {
|
||||
return ws as unknown as WebSocket;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a structurally valid JWT with a given payload.
|
||||
* Header: {"alg":"HS256","typ":"JWT"}, signature: fake.
|
||||
* This is NOT cryptographically signed — it's for testing JWT structure validation.
|
||||
*/
|
||||
function makeTestJwt(payload: Record<string, unknown>): string {
|
||||
const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
|
||||
.toString('base64url');
|
||||
const body = Buffer.from(JSON.stringify(payload)).toString('base64url');
|
||||
const signature = Buffer.from('test-signature').toString('base64url');
|
||||
return `${header}.${body}.${signature}`;
|
||||
}
|
||||
|
||||
// ─── ConnectionManager unit tests ───────────────────────────────────────────
|
||||
|
||||
describe('ConnectionManager', () => {
|
||||
it('tracks connections by team and user', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws));
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
|
||||
|
||||
cm.remove('team1', 'user1');
|
||||
expect(cm.getConnectedUsers('team1')).toEqual([]);
|
||||
});
|
||||
|
||||
it('returns empty array for unknown team', () => {
|
||||
const cm = new ConnectionManager();
|
||||
expect(cm.getConnectedUsers('nonexistent')).toEqual([]);
|
||||
});
|
||||
|
||||
it('removes team entry when last user disconnects', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws));
|
||||
expect(cm.getTeamCount()).toBe(1);
|
||||
|
||||
cm.remove('team1', 'user1');
|
||||
expect(cm.getTeamCount()).toBe(0);
|
||||
});
|
||||
|
||||
it('tracks multiple users in same team', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team1', 'user2', asWs(ws2));
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1', 'user2']);
|
||||
});
|
||||
|
||||
it('tracks users across multiple teams', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team2', 'user2', asWs(ws2));
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
|
||||
expect(cm.getConnectedUsers('team2')).toEqual(['user2']);
|
||||
expect(cm.getTeamCount()).toBe(2);
|
||||
});
|
||||
|
||||
it('broadcasts to all team members', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team1', 'user2', asWs(ws2));
|
||||
|
||||
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
|
||||
expect(ws1.send).toHaveBeenCalledOnce();
|
||||
expect(ws2.send).toHaveBeenCalledOnce();
|
||||
|
||||
const sentData = JSON.parse(ws1.send.mock.calls[0][0] as string);
|
||||
expect(sentData.type).toBe('task_update');
|
||||
});
|
||||
|
||||
it('excludes user from broadcast', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team1', 'user2', asWs(ws2));
|
||||
|
||||
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task }, 'user1');
|
||||
expect(ws1.send).not.toHaveBeenCalled();
|
||||
expect(ws2.send).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('skips sockets that are not OPEN', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const wsOpen = mockWs(1);
|
||||
const wsClosed = mockWs(3); // readyState 3 = CLOSED
|
||||
|
||||
cm.add('team1', 'user1', asWs(wsOpen));
|
||||
cm.add('team1', 'user2', asWs(wsClosed));
|
||||
|
||||
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
|
||||
expect(wsOpen.send).toHaveBeenCalledOnce();
|
||||
expect(wsClosed.send).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('sends to specific user', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team1', 'user2', asWs(ws2));
|
||||
|
||||
cm.sendTo('team1', 'user1', { type: 'suggestion', suggestion: {} as unknown as SuggestionEntry });
|
||||
expect(ws1.send).toHaveBeenCalledOnce();
|
||||
expect(ws2.send).not.toHaveBeenCalled();
|
||||
|
||||
const sentData = JSON.parse(ws1.send.mock.calls[0][0] as string);
|
||||
expect(sentData.type).toBe('suggestion');
|
||||
});
|
||||
|
||||
it('sendTo does nothing for nonexistent user', () => {
|
||||
const cm = new ConnectionManager();
|
||||
// Should not throw
|
||||
cm.sendTo('team1', 'nobody', { type: 'task_update', task: {} as unknown as Task });
|
||||
});
|
||||
|
||||
it('sendTo does nothing for closed socket', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const wsClosed = mockWs(3);
|
||||
|
||||
cm.add('team1', 'user1', asWs(wsClosed));
|
||||
cm.sendTo('team1', 'user1', { type: 'task_update', task: {} as unknown as Task });
|
||||
expect(wsClosed.send).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('broadcast does nothing for nonexistent team', () => {
|
||||
const cm = new ConnectionManager();
|
||||
// Should not throw
|
||||
cm.broadcast('nonexistent', { type: 'task_update', task: {} as unknown as Task });
|
||||
});
|
||||
|
||||
it('replaces connection when same user re-adds', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team1', 'user1', asWs(ws2)); // replace
|
||||
|
||||
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
|
||||
expect(ws1.send).not.toHaveBeenCalled();
|
||||
expect(ws2.send).toHaveBeenCalledOnce();
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
|
||||
});
|
||||
|
||||
// ── 11F-6: WebSocket lifecycle tests ──────────────────────────────────
|
||||
|
||||
it('multiple clients with one disconnect: broadcast still reaches remaining 2', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const ws1 = mockWs();
|
||||
const ws2 = mockWs();
|
||||
const ws3 = mockWs();
|
||||
|
||||
// Register 3 clients in a team
|
||||
cm.add('team1', 'user1', asWs(ws1));
|
||||
cm.add('team1', 'user2', asWs(ws2));
|
||||
cm.add('team1', 'user3', asWs(ws3));
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1', 'user2', 'user3']);
|
||||
|
||||
// Disconnect user2
|
||||
cm.remove('team1', 'user2');
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1', 'user3']);
|
||||
|
||||
// Broadcast — should reach user1 and user3 only
|
||||
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
|
||||
expect(ws1.send).toHaveBeenCalledOnce();
|
||||
expect(ws2.send).not.toHaveBeenCalled();
|
||||
expect(ws3.send).toHaveBeenCalledOnce();
|
||||
|
||||
// Team is still tracked (not removed since 2 users remain)
|
||||
expect(cm.getTeamCount()).toBe(1);
|
||||
});
|
||||
|
||||
it('reconnection with same userId: no duplicate entries, clean replacement', () => {
|
||||
const cm = new ConnectionManager();
|
||||
const wsOriginal = mockWs();
|
||||
const wsReconnect = mockWs();
|
||||
|
||||
// Initial connection
|
||||
cm.add('team1', 'user1', asWs(wsOriginal));
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
|
||||
|
||||
// Simulate disconnect
|
||||
cm.remove('team1', 'user1');
|
||||
expect(cm.getConnectedUsers('team1')).toEqual([]);
|
||||
// Team entry should be cleaned up since last user left
|
||||
expect(cm.getTeamCount()).toBe(0);
|
||||
|
||||
// Reconnect with same userId
|
||||
cm.add('team1', 'user1', asWs(wsReconnect));
|
||||
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
|
||||
expect(cm.getTeamCount()).toBe(1);
|
||||
|
||||
// Broadcast should only reach the reconnected socket
|
||||
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
|
||||
expect(wsOriginal.send).not.toHaveBeenCalled();
|
||||
expect(wsReconnect.send).toHaveBeenCalledOnce();
|
||||
|
||||
// No duplicate user entries
|
||||
expect(cm.getConnectedUsers('team1')).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── WebSocket Gateway integration tests ────────────────────────────────────
|
||||
// These require PostgreSQL + Redis running (ports 5434 / 6381)
|
||||
|
||||
describe('WebSocket Gateway (integration)', () => {
|
||||
let server: Awaited<ReturnType<typeof import('../../src/index.js').buildServer>>;
|
||||
let address: string;
|
||||
let userId: string;
|
||||
let outsiderUserId: string;
|
||||
let clerkId: string;
|
||||
let teamSlug: string;
|
||||
let teamId: string;
|
||||
/** A structurally valid JWT whose sub matches our test user's clerkId */
|
||||
let validJwt: string;
|
||||
let outsiderJwt: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
const { buildServer } = await import('../../src/index.js');
|
||||
const { sql: drizzleSql } = await import('drizzle-orm');
|
||||
server = await buildServer();
|
||||
|
||||
// Override auth to bypass Clerk for REST routes
|
||||
const testAuthHandler: AuthenticateFn = async (req, reply) => {
|
||||
const testUserId = req.headers['x-test-user-id'] as string;
|
||||
if (!testUserId) {
|
||||
await reply.code(401).send({ error: 'Missing test user' });
|
||||
return;
|
||||
}
|
||||
req.userId = testUserId;
|
||||
req.clerkId = 'test';
|
||||
};
|
||||
server._authHandler.fn = testAuthHandler;
|
||||
|
||||
// Clean up leftover data from previous runs
|
||||
const { users, teams, teamMembers } = await import('../../src/db/schema.js');
|
||||
await server.db.execute(drizzleSql`DELETE FROM team_members WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`);
|
||||
await server.db.execute(drizzleSql`DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`);
|
||||
await server.db.execute(drizzleSql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
|
||||
await server.db.execute(drizzleSql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
|
||||
await server.db.execute(drizzleSql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
|
||||
await server.db.execute(drizzleSql`DELETE FROM teams WHERE slug LIKE 'ws-test-team-%'`);
|
||||
await server.db.execute(drizzleSql`DELETE FROM users WHERE clerk_id LIKE 'wstest_%'`);
|
||||
|
||||
// Create test user and team with unique IDs
|
||||
const suffix = Date.now();
|
||||
clerkId = `wstest_user_${suffix}`;
|
||||
const [user] = await server.db
|
||||
.insert(users)
|
||||
.values({
|
||||
clerkId,
|
||||
displayName: 'WS User',
|
||||
email: `wsuser_${suffix}@test.com`,
|
||||
})
|
||||
.returning();
|
||||
userId = user.id;
|
||||
|
||||
const outsiderClerkId = `wstest_outsider_${suffix}`;
|
||||
const [outsider] = await server.db
|
||||
.insert(users)
|
||||
.values({
|
||||
clerkId: outsiderClerkId,
|
||||
displayName: 'WS Outsider',
|
||||
email: `wsoutsider_${suffix}@test.com`,
|
||||
})
|
||||
.returning();
|
||||
outsiderUserId = outsider.id;
|
||||
|
||||
// Build a valid test JWT with the user's clerkId as `sub`
|
||||
validJwt = makeTestJwt({ sub: clerkId, iat: Math.floor(Date.now() / 1000) });
|
||||
outsiderJwt = makeTestJwt({ sub: outsiderClerkId, iat: Math.floor(Date.now() / 1000) });
|
||||
|
||||
// Override the WS token verifier so tests don't need a real Clerk secret key.
|
||||
// The verifier accepts any structurally valid JWT and returns its decoded `sub`.
|
||||
setWsTokenVerifier(async (token: string) => {
|
||||
const parts = token.split('.');
|
||||
const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
|
||||
if (typeof payload.sub !== 'string') throw new Error('Missing sub');
|
||||
return { sub: payload.sub };
|
||||
});
|
||||
|
||||
teamSlug = `ws-test-team-${suffix}`;
|
||||
const [team] = await server.db
|
||||
.insert(teams)
|
||||
.values({ name: 'WS Team', slug: teamSlug, ownerId: userId })
|
||||
.returning();
|
||||
teamId = team.id;
|
||||
|
||||
await server.db
|
||||
.insert(teamMembers)
|
||||
.values({ teamId: team.id, userId, role: 'owner' });
|
||||
|
||||
// Start listening on a random port
|
||||
await server.listen({ port: 0, host: '127.0.0.1' });
|
||||
const addr = server.server.address();
|
||||
address = typeof addr === 'string' ? addr : `127.0.0.1:${addr?.port}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Clear the WS token verifier override
|
||||
setWsTokenVerifier(null);
|
||||
|
||||
if (!server) return;
|
||||
const { sql } = await import('drizzle-orm');
|
||||
await server.db.execute(
|
||||
sql`DELETE FROM team_members WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`,
|
||||
);
|
||||
await server.db.execute(
|
||||
sql`DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`,
|
||||
);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
|
||||
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
|
||||
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'ws-test-team-%'`);
|
||||
await server.db.execute(
|
||||
sql`DELETE FROM users WHERE clerk_id LIKE 'wstest_%'`,
|
||||
);
|
||||
await server.close();
|
||||
});
|
||||
|
||||
function connectWs(): Promise<{ ws: import('ws').WebSocket; messages: Record<string, unknown>[] }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
// Dynamic import to avoid issues if ws isn't available at parse time
|
||||
import('ws').then(({ default: WS }) => {
|
||||
const ws = new WS(`ws://${address}/ws`);
|
||||
const msgs: Record<string, unknown>[] = [];
|
||||
ws.on('message', (data: Buffer) => msgs.push(JSON.parse(data.toString())));
|
||||
ws.on('open', () => resolve({ ws, messages: msgs }));
|
||||
ws.on('error', reject);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function wait(ms: number) {
|
||||
return new Promise((r) => setTimeout(r, ms));
|
||||
}
|
||||
|
||||
/** Wait until messages array has at least `count` entries, or timeout. */
|
||||
async function waitForMessages(messages: Record<string, unknown>[], count: number, timeoutMs = 3000) {
|
||||
const start = Date.now();
|
||||
while (messages.length < count && Date.now() - start < timeoutMs) {
|
||||
await wait(50);
|
||||
}
|
||||
}
|
||||
|
||||
it('connects and authenticates via WebSocket', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
expect(messages).toHaveLength(1);
|
||||
expect(messages[0]).toEqual({ type: 'authenticated', userId });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('rejects join_team before authentication', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
expect(messages[0]).toEqual({ type: 'error', message: 'Not authenticated' });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('joins team room after authentication', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
|
||||
await waitForMessages(messages, 2);
|
||||
|
||||
expect(messages[1]).toEqual({ type: 'joined_team', teamSlug });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('rejects an authenticated non-member joining an existing team', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: outsiderJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
expect(messages[0]).toEqual({ type: 'authenticated', userId: outsiderUserId });
|
||||
|
||||
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
|
||||
await waitForMessages(messages, 2);
|
||||
|
||||
expect(messages[1]).toEqual({ type: 'error', message: 'Team not found' });
|
||||
expect(connectionManager.getConnectedUsers(teamId)).not.toContain(outsiderUserId);
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('clears the joined team when a socket authenticates as a different user', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
|
||||
await waitForMessages(messages, 2);
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: outsiderJwt }));
|
||||
await waitForMessages(messages, 3);
|
||||
|
||||
expect(messages[2]).toEqual({ type: 'authenticated', userId: outsiderUserId });
|
||||
expect(connectionManager.getConnectedUsers(teamId)).not.toContain(userId);
|
||||
|
||||
ws.send(
|
||||
JSON.stringify({
|
||||
type: 'send_message',
|
||||
teamSlug,
|
||||
messageType: 'broadcast',
|
||||
subtype: 'discovery',
|
||||
content: { text: 'reauthenticated outsider' },
|
||||
}),
|
||||
);
|
||||
await waitForMessages(messages, 4);
|
||||
expect(messages[3]).toEqual({ type: 'error', message: 'Not in a team' });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('returns error for nonexistent team', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
ws.send(JSON.stringify({ type: 'join_team', teamSlug: 'does-not-exist' }));
|
||||
await waitForMessages(messages, 2);
|
||||
|
||||
expect(messages[1]).toEqual({ type: 'error', message: 'Team not found' });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('rejects send_message before joining team', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
ws.send(
|
||||
JSON.stringify({
|
||||
type: 'send_message',
|
||||
teamSlug,
|
||||
messageType: 'broadcast',
|
||||
subtype: 'discovery',
|
||||
content: { text: 'hello' },
|
||||
}),
|
||||
);
|
||||
await waitForMessages(messages, 2);
|
||||
|
||||
expect(messages[1]).toEqual({ type: 'error', message: 'Not in a team' });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('handles invalid JSON gracefully', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send('this is not json');
|
||||
await wait(200);
|
||||
|
||||
expect(messages[0]).toEqual({ type: 'error', message: 'Invalid message' });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
// ─── JWT auth security tests ──────────────────────────────────────────────
|
||||
|
||||
it('rejects plain userId string as token (not a JWT)', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
// Sending a raw userId (UUID) should be rejected — it's not a JWT
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: userId }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
expect(messages[0]).toEqual({
|
||||
type: 'error',
|
||||
message: 'Invalid token: must be a valid JWT',
|
||||
});
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('rejects random non-JWT string as token', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: 'not-a-jwt-token' }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
expect(messages[0]).toEqual({
|
||||
type: 'error',
|
||||
message: 'Invalid token: must be a valid JWT',
|
||||
});
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('rejects JWT with nonexistent user (unknown clerkId)', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
const fakeJwt = makeTestJwt({ sub: 'clerk_user_does_not_exist', iat: Math.floor(Date.now() / 1000) });
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: fakeJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
expect(messages[0]).toEqual({
|
||||
type: 'error',
|
||||
message: 'User not found',
|
||||
});
|
||||
|
||||
ws.close();
|
||||
});
|
||||
|
||||
it('authenticates with valid JWT and maps clerkId to internal userId', async () => {
|
||||
const { ws, messages } = await connectWs();
|
||||
|
||||
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
|
||||
await waitForMessages(messages, 1);
|
||||
|
||||
expect(messages[0]).toEqual({ type: 'authenticated', userId });
|
||||
|
||||
ws.close();
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user