150 lines
4.7 KiB
TypeScript
150 lines
4.7 KiB
TypeScript
import { HermesIntegrationService } from './hermes-integration.service';
|
|
import { HermesAdapter } from './hermes.adapter';
|
|
describe('backend-owned runtime authorization', () => {
|
|
const ctx = { subject: 'admin', profiles: ['seo'] };
|
|
const make = (allow = true, enabled = false) => {
|
|
const fetcher = jest
|
|
.fn()
|
|
.mockResolvedValue(
|
|
new Response(
|
|
JSON.stringify({ id: 'j', profile: 'seo', enabled: false }),
|
|
),
|
|
);
|
|
const authorize = jest.fn().mockResolvedValue(allow);
|
|
return {
|
|
fetcher,
|
|
authorize,
|
|
s: new HermesIntegrationService(
|
|
new HermesAdapter(
|
|
{
|
|
origin: 'http://canina-hermes:9119',
|
|
token: () => Promise.resolve('secret'),
|
|
},
|
|
fetcher,
|
|
),
|
|
{ authorize },
|
|
enabled,
|
|
),
|
|
};
|
|
};
|
|
it('denies missing principal, missing profile, denied policy before upstream IO', async () => {
|
|
const { s, fetcher } = make(false);
|
|
await expect(s.pauseCron(ctx, 'seo', 'j')).rejects.toMatchObject({
|
|
code: 'FORBIDDEN',
|
|
});
|
|
await expect(
|
|
s.pauseCron({ ...ctx, subject: '' }, 'seo', 'j'),
|
|
).rejects.toMatchObject({ code: 'FORBIDDEN' });
|
|
await expect(s.pauseCron(ctx, 'dev', 'j')).rejects.toMatchObject({
|
|
code: 'FORBIDDEN',
|
|
});
|
|
expect(fetcher).not.toHaveBeenCalled();
|
|
});
|
|
it('allows authorized pause but leaves resume disabled by default', async () => {
|
|
const { s, fetcher, authorize } = make();
|
|
await s.pauseCron(ctx, 'seo', 'j');
|
|
expect(authorize).toHaveBeenCalledWith(ctx, 'cron.pause', 'seo');
|
|
await expect(s.resumeCron(ctx, 'seo', 'j')).rejects.toMatchObject({
|
|
code: 'FORBIDDEN',
|
|
});
|
|
expect(fetcher).toHaveBeenCalledTimes(1);
|
|
});
|
|
it('fails closed on all execution and never forwards arbitrary events or RPC', async () => {
|
|
const { s, fetcher } = make();
|
|
expect(s.capabilities()).toMatchObject({
|
|
chat: false,
|
|
control: false,
|
|
eventDispatch: false,
|
|
cronResume: false,
|
|
});
|
|
await expect(s.chat(ctx, 'seo', 'hello')).rejects.toMatchObject({
|
|
code: 'UNSUPPORTED',
|
|
});
|
|
await expect(s.control(ctx, 'seo', 'interrupt')).rejects.toMatchObject({
|
|
code: 'UNSUPPORTED',
|
|
});
|
|
await expect(
|
|
s.dispatchEvent(ctx, 'seo', { type: 'order.created' }),
|
|
).rejects.toMatchObject({ code: 'FORBIDDEN' });
|
|
expect(fetcher).not.toHaveBeenCalled();
|
|
});
|
|
it('fails closed when authorization provider throws', async () => {
|
|
const a = new HermesAdapter({
|
|
origin: 'http://canina-hermes:9119',
|
|
token: () => Promise.resolve('secret'),
|
|
});
|
|
const s = new HermesIntegrationService(a, {
|
|
authorize: () => Promise.reject(new Error('private')),
|
|
});
|
|
await expect(s.health(ctx)).rejects.toMatchObject({ code: 'FORBIDDEN' });
|
|
});
|
|
});
|
|
|
|
it('checks every read capability and filters the global profile roster', async () => {
|
|
const fetcher = jest.fn().mockImplementation((input: URL) => {
|
|
const payloads: Record<string, unknown> = {
|
|
'/api/health': {
|
|
ok: true,
|
|
version: 'x',
|
|
commit: 'x',
|
|
auth_required: true,
|
|
},
|
|
'/api/status': {
|
|
version: 'x',
|
|
gateway_running: false,
|
|
gateway_state: null,
|
|
overall: 'degraded',
|
|
active_agents: 0,
|
|
},
|
|
'/api/profiles': {
|
|
profiles: [
|
|
{ name: 'seo', is_default: false, gateway_running: false },
|
|
{ name: 'dev', is_default: false, gateway_running: false },
|
|
],
|
|
},
|
|
'/api/model/info': {
|
|
model: 'm',
|
|
provider: 'p',
|
|
effective_context_length: 1,
|
|
},
|
|
'/api/model/options': { providers: [] },
|
|
'/api/analytics/usage': {
|
|
period_days: 30,
|
|
totals: {
|
|
total_input: 0,
|
|
total_output: 0,
|
|
total_sessions: 0,
|
|
total_estimated_cost: 0,
|
|
},
|
|
},
|
|
'/api/sessions': { sessions: [], total: 0 },
|
|
'/api/cron/jobs': [],
|
|
};
|
|
return Promise.resolve(
|
|
new Response(JSON.stringify(payloads[input.pathname])),
|
|
);
|
|
});
|
|
const authorize = jest.fn().mockResolvedValue(true);
|
|
const s = new HermesIntegrationService(
|
|
new HermesAdapter(
|
|
{
|
|
origin: 'http://canina-hermes:9119',
|
|
token: () => Promise.resolve('secret'),
|
|
},
|
|
fetcher,
|
|
),
|
|
{ authorize },
|
|
);
|
|
const p = { subject: 'verified', profiles: ['seo'] };
|
|
await s.health(p);
|
|
await s.status(p, 'seo');
|
|
expect(await s.profiles(p)).toHaveLength(1);
|
|
await s.modelInfo(p, 'seo');
|
|
await s.modelOptions(p, 'seo');
|
|
await s.usage(p, 'seo');
|
|
await s.sessions(p, 'seo');
|
|
await s.crons(p, 'seo');
|
|
expect(authorize).toHaveBeenCalledTimes(8);
|
|
expect(authorize.mock.calls.every((c) => c[1] === 'runtime.read')).toBe(true);
|
|
});
|