@openvcs/sdk 0.2.4 → 0.2.6

package/test/vcs-delegate-base.test.js

@@ -0,0 +1,169 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const { VcsDelegateBase } = require('../lib/runtime');
+
+/**
+ * Compile-time override safety lives in `vcs-delegate-base.types.ts`, which
+ * verifies that generic parameters are explicit and incompatible signatures
+ * (wrong return type or params) fail the TypeScript compiler.  This file
+ * tests runtime behavior using the plain Node test runner.
+ * @typedef {{ message: string, method: string }} CommitCall */
+
+class ExampleVcsDelegates extends VcsDelegateBase {
+  /** @param {{ prefix: string, calls: CommitCall[] }} deps */
+  constructor(deps) {
+    super(deps);
+  }
+
+  getCaps() {
+    return {
+      commits: true,
+      branches: true,
+      tags: false,
+      staging: true,
+      push_pull: false,
+      fast_forward: true,
+    };
+  }
+
+  async commit(params, context) {
+    this.deps.calls.push({ message: params.message, method: context.method });
+    return `${this.deps.prefix}:${params.message}`;
+  }
+}
+
+class SharedBranchDelegates extends VcsDelegateBase {
+  /** @param {{}} deps */
+  constructor(deps) {
+    super(deps);
+  }
+
+  getCurrentBranch(params) {
+    return `branch:${params.session_id}`;
+  }
+}
+
+class DerivedBranchDelegates extends SharedBranchDelegates {
+  listBranches() {
+    return [];
+  }
+}
+
+test('VcsDelegateBase maps overridden camelCase methods to rpc delegates', async () => {
+  const delegate = new ExampleVcsDelegates({ prefix: 'commit', calls: [] });
+  const delegates = delegate.toDelegates();
+
+  assert.deepEqual(Object.keys(delegates).sort(), ['vcs.commit', 'vcs.get_caps']);
+  assert.equal(typeof delegates['vcs.get_caps'], 'function');
+  assert.equal(typeof delegates['vcs.commit'], 'function');
+
+  assert.deepEqual(await delegates['vcs.get_caps']({}, {}), {
+    commits: true,
+    branches: true,
+    tags: false,
+    staging: true,
+    push_pull: false,
+    fast_forward: true,
+  });
+
+  assert.equal(
+    await delegates['vcs.commit'](
+      {
+        session_id: 'session-1',
+        name: 'OpenVCS',
+        email: 'team@example.com',
+        message: 'ship it',
+      },
+      { host: {}, method: 'vcs.commit', requestId: 7 },
+    ),
+    'commit:ship it',
+  );
+  assert.deepEqual(delegate.deps.calls, [
+    { message: 'ship it', method: 'vcs.commit' },
+  ]);
+});
+
+test('VcsDelegateBase keeps inherited overrides when building delegates', async () => {
+  const delegates = new DerivedBranchDelegates({}).toDelegates();
+
+  assert.deepEqual(Object.keys(delegates).sort(), [
+    'vcs.get_current_branch',
+    'vcs.list_branches',
+  ]);
+  assert.equal(
+    await delegates['vcs.get_current_branch'](
+      { session_id: 'session-2' },
+      { host: {}, method: 'vcs.get_current_branch', requestId: 8 },
+    ),
+    'branch:session-2',
+  );
+  assert.deepEqual(
+    await delegates['vcs.list_branches'](
+      { session_id: 'session-2' },
+      { host: {}, method: 'vcs.list_branches', requestId: 9 },
+    ),
+    [],
+  );
+});
+
+test('VcsDelegateBase returns a fresh delegate map on each call', async () => {
+  const delegate = new ExampleVcsDelegates({ prefix: 'repeat', calls: [] });
+  const firstDelegates = delegate.toDelegates();
+  const secondDelegates = delegate.toDelegates();
+
+  assert.notStrictEqual(firstDelegates, secondDelegates);
+  assert.notStrictEqual(
+    firstDelegates['vcs.commit'],
+    secondDelegates['vcs.commit'],
+  );
+  assert.equal(
+    await secondDelegates['vcs.commit'](
+      {
+        session_id: 'session-3',
+        name: 'OpenVCS',
+        email: 'team@example.com',
+        message: 'again',
+      },
+      { host: {}, method: 'vcs.commit', requestId: 10 },
+    ),
+    'repeat:again',
+  );
+});
+
+test('VcsDelegateBase throws with the exact error message for base stubs', () => {
+  const delegate = new ExampleVcsDelegates({ prefix: 'x', calls: [] });
+
+  // Each base stub throws with a message that includes the method name.
+  // Test a representative subset; all stubs share the same formatter.
+  const expectedMessage = "VCS delegate method 'cloneRepo' must be overridden before registration";
+  let thrown;
+  try {
+    delegate.cloneRepo({ url: 'x', dest: 'y' }, {});
+  } catch (e) {
+    thrown = e;
+  }
+  assert.ok(thrown instanceof Error, 'should throw an Error');
+  assert.strictEqual(thrown.message, expectedMessage);
+
+  // Verify a second stub throws with its own method name in the message.
+  const expectedMessage2 = "VCS delegate method 'stashPush' must be overridden before registration";
+  let thrown2;
+  try {
+    delegate.stashPush({ session_id: 's' }, {});
+  } catch (e) {
+    thrown2 = e;
+  }
+  assert.ok(thrown2 instanceof Error);
+  assert.strictEqual(thrown2.message, expectedMessage2);
+});
+
+test('VcsDelegateBase accepts an empty deps object without errors', () => {
+  assert.doesNotThrow(() => new ExampleVcsDelegates({ prefix: '', calls: [] }));
+  assert.doesNotThrow(() => new SharedBranchDelegates({}));
+  const delegates = new SharedBranchDelegates({}).toDelegates();
+  assert.deepEqual(Object.keys(delegates), ['vcs.get_current_branch']);
+});

package/test/vcs-delegate-base.types.ts

@@ -0,0 +1,44 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import type { RequestParams, VcsCapabilities } from '../src/lib/types';
+
+import {
+  VcsDelegateBase,
+  type PluginRuntimeContext,
+} from '../src/lib/runtime';
+
+type CommitCall = {
+  message: string;
+  method: string;
+};
+
+class TypedExampleVcsDelegates extends VcsDelegateBase<{
+  prefix: string;
+  calls: CommitCall[];
+}> {
+  override getCaps(
+    _params: RequestParams,
+    _context: PluginRuntimeContext,
+  ): VcsCapabilities {
+    return {
+      commits: true,
+      branches: true,
+      tags: false,
+      staging: true,
+      push_pull: false,
+      fast_forward: true,
+    };
+  }
+}
+
+new TypedExampleVcsDelegates({ prefix: 'commit', calls: [] }).toDelegates();
+
+class InvalidVcsDelegates extends VcsDelegateBase<{}> {
+  // @ts-expect-error `getCaps` must return `VcsCapabilities`.
+  override getCaps(): string {
+    return 'invalid';
+  }
+}
+
+new InvalidVcsDelegates({});