262 lines
9.6 KiB
TypeScript
262 lines
9.6 KiB
TypeScript
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');
|
|
});
|
|
});
|