test.js

/**
 * RO-JRPC JS Reference Implementation Tests
 * Run: node --test test.js
 */

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createRouter, buildRequest, validateRequest, ErrorCode } from './index.js';

// ---------------------------------------------------------------------------
// validateRequest — flat resources
// ---------------------------------------------------------------------------

test('validateRequest: accepts valid flat request', () => {
  const req = buildRequest({ resource: 'user', verb: 'get', target: '42', id: 1 });
  assert.deepEqual(validateRequest(req), { valid: true });
});

test('validateRequest: rejects missing jsonrpc', () => {
  const result = validateRequest({ method: 'user.get', resource: 'user', verb: 'get', id: 1 });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

test('validateRequest: rejects mismatched method/resource/verb', () => {
  const result = validateRequest({
    jsonrpc: '2.0', method: 'task.delete', resource: 'user', verb: 'create', id: 1,
  });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

test('validateRequest: accepts plain JSON-RPC 2.0 (no resource/verb)', () => {
  const result = validateRequest({ jsonrpc: '2.0', method: 'user.get', id: 1 });
  assert.deepEqual(result, { valid: true });
});

// ---------------------------------------------------------------------------
// validateRequest — co-presence rules
// ---------------------------------------------------------------------------

test('validateRequest: rejects resource without verb', () => {
  const result = validateRequest({ jsonrpc: '2.0', method: 'user.get', resource: 'user', id: 1 });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

test('validateRequest: rejects verb without resource', () => {
  const result = validateRequest({ jsonrpc: '2.0', method: 'user.get', verb: 'get', id: 1 });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

test('validateRequest: rejects subresource without resource', () => {
  const result = validateRequest({
    jsonrpc: '2.0', method: 'issue.get', verb: 'get', subresource: 'issue', id: 1,
  });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

test('validateRequest: rejects parent without subresource', () => {
  const result = validateRequest({
    jsonrpc: '2.0', method: 'user.get', resource: 'user', verb: 'get', parent: '42', id: 1,
  });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

test('validateRequest: rejects target without resource', () => {
  const result = validateRequest({
    jsonrpc: '2.0', method: 'user.get', target: '42', id: 1,
  });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

// ---------------------------------------------------------------------------
// validateRequest — sub-resources
// ---------------------------------------------------------------------------

test('validateRequest: accepts valid sub-resource request', () => {
  const req = buildRequest({
    resource: 'repo', subresource: 'issue', verb: 'get',
    parent: '99', target: '7', id: 3,
  });
  assert.deepEqual(validateRequest(req), { valid: true });
  assert.equal(req.method, 'repo.issue.get');
});

test('validateRequest: rejects mismatched subresource in method', () => {
  const result = validateRequest({
    jsonrpc: '2.0', method: 'repo.comment.get',
    resource: 'repo', subresource: 'issue', verb: 'get', id: 1,
  });
  assert.equal(result.valid, false);
  assert.equal(result.code, ErrorCode.INVALID_REQUEST);
});

// ---------------------------------------------------------------------------
// Router — flat routing
// ---------------------------------------------------------------------------

test('router: routes flat request to correct handler', async () => {
  const router = createRouter();
  router.resource('user').verb('get', async ({ target }) => ({ id: target, name: 'Alice' }));

  const req = buildRequest({ resource: 'user', verb: 'get', target: '42', id: 1 });
  const res = await router.handle(req);

  assert.equal(res.jsonrpc, '2.0');
  assert.equal(res.id, 1);
  assert.deepEqual(res.result, { id: '42', name: 'Alice' });
});

test('router: returns METHOD_NOT_FOUND for unknown verb', async () => {
  const router = createRouter();
  const req = buildRequest({ resource: 'user', verb: 'clone', id: 3 });
  const res = await router.handle(req);
  assert.equal(res.error.code, ErrorCode.METHOD_NOT_FOUND);
});

test('router: returns INVALID_REQUEST for mismatched method/resource/verb', async () => {
  const router = createRouter();
  const res = await router.handle({
    jsonrpc: '2.0', method: 'task.delete', resource: 'user', verb: 'create', id: 4,
  });
  assert.equal(res.error.code, ErrorCode.INVALID_REQUEST);
});

test('router: catches handler errors and returns INTERNAL_ERROR', async () => {
  const router = createRouter();
  router.resource('user').verb('explode', async () => { throw new Error('boom'); });
  const req = buildRequest({ resource: 'user', verb: 'explode', id: 5 });
  const res = await router.handle(req);
  assert.equal(res.error.code, ErrorCode.INTERNAL_ERROR);
  assert.equal(res.error.message, 'boom');
});

// ---------------------------------------------------------------------------
// Router — sub-resource routing
// ---------------------------------------------------------------------------

test('router: routes sub-resource request', async () => {
  const router = createRouter();
  router.resource('repo').subresource('issue').verb('get', async ({ parent, target }) => ({
    repoId: parent, issueId: target,
  }));

  const req = buildRequest({
    resource: 'repo', subresource: 'issue', verb: 'get',
    parent: '99', target: '7', id: 10,
  });
  const res = await router.handle(req);

  assert.equal(res.error, undefined);
  assert.deepEqual(res.result, { repoId: '99', issueId: '7' });
});

test('router: routes sub-resource list (no target)', async () => {
  const router = createRouter();
  router.resource('project').subresource('task').verb('list', async ({ parent }) => ([
    { id: '1', projectId: parent },
  ]));

  const req = buildRequest({
    resource: 'project', subresource: 'task', verb: 'list', parent: '42', id: 11,
  });
  const res = await router.handle(req);
  assert.equal(res.result.length, 1);
  assert.equal(res.result[0].projectId, '42');
});

test('router: flat and sub-resource handlers coexist on same resource', async () => {
  const router = createRouter();
  router.resource('repo').verb('get', async ({ target }) => ({ type: 'repo', id: target }));
  router.resource('repo').subresource('issue').verb('get', async ({ target }) => ({ type: 'issue', id: target }));

  const repoReq = buildRequest({ resource: 'repo', verb: 'get', target: '5', id: 1 });
  const issueReq = buildRequest({ resource: 'repo', subresource: 'issue', verb: 'get', parent: '5', target: '3', id: 2 });

  const repoRes = await router.handle(repoReq);
  const issueRes = await router.handle(issueReq);

  assert.equal(repoRes.result.type, 'repo');
  assert.equal(issueRes.result.type, 'issue');
});

// ---------------------------------------------------------------------------
// Notifications
// ---------------------------------------------------------------------------

test('router: returns null for notifications (no id)', async () => {
  const router = createRouter();
  let called = false;
  router.resource('log').verb('create', async () => { called = true; });

  const notification = buildRequest({ resource: 'log', verb: 'create', params: { message: 'hi' } });
  delete notification.id;

  const res = await router.handle(notification);
  assert.equal(res, null);
  assert.equal(called, true);
});

// ---------------------------------------------------------------------------
// Discovery
// ---------------------------------------------------------------------------

test('router.describe(): lists flat resources and verbs', () => {
  const router = createRouter();
  router.resource('user').verb('get', async () => {}).verb('create', async () => {});
  router.resource('task').verb('cancel', async () => {});

  const desc = router.describe();
  assert.equal(desc.protocol, 'ro-jrpc');
  assert.equal(desc.version, '1.0-draft');

  const names = desc.resources.map(r => r.name).sort();
  assert.deepEqual(names, ['task', 'user']);
});

test('router.describe(): includes subresources', () => {
  const router = createRouter();
  router.resource('repo').verb('get', async () => {});
  router.resource('repo').subresource('issue').verb('get', async () => {}).verb('list', async () => {});

  const desc = router.describe();
  const repo = desc.resources.find(r => r.name === 'repo');
  assert.ok(repo);
  assert.ok(repo.subresources);
  const issue = repo.subresources.find(s => s.name === 'issue');
  assert.ok(issue);
  assert.deepEqual(issue.verbs.sort(), ['get', 'list']);
});

// ---------------------------------------------------------------------------
// buildRequest
// ---------------------------------------------------------------------------

test('buildRequest: flat — sets method to resource.verb', () => {
  const req = buildRequest({ resource: 'task', verb: 'cancel', target: '123', id: 'abc' });
  assert.equal(req.method, 'task.cancel');
  assert.equal(req.jsonrpc, '2.0');
  assert.equal('subresource' in req, false);
  assert.equal('parent' in req, false);
});

test('buildRequest: sub-resource — sets method to resource.subresource.verb', () => {
  const req = buildRequest({
    resource: 'repo', subresource: 'issue', verb: 'get',
    parent: '99', target: '7', id: 1,
  });
  assert.equal(req.method, 'repo.issue.get');
  assert.equal(req.resource, 'repo');
  assert.equal(req.subresource, 'issue');
  assert.equal(req.verb, 'get');
  assert.equal(req.parent, '99');
  assert.equal(req.target, '7');
});

test('buildRequest: omits optional fields when not provided', () => {
  const req = buildRequest({ resource: 'user', verb: 'create', params: { name: 'X' }, id: 1 });
  assert.equal('target' in req, false);
  assert.equal('parent' in req, false);
  assert.equal('subresource' in req, false);
});