DC-153: provider.syncAccess enforcement wiring (tailscale ACL push + wireguard nftables apply) + contract tests

This commit is contained in:
Hermes committed 2026-10-03 22:34:02 -07:00
1 parent 88f7600693
commit 44567031eb
6 files changed
+820 -32

No files matched your search

@@ -531,16 +531,224 @@ describe('wireguard provider: invites (spec §8.5)', () => {
});
});
describe('wireguard provider: unsupported / not-implemented surface', () => {
test('syncAccess → not_implemented (DC-151 injects the firewall compiler)', async () => {
const { provider } = makeProvider();
await expect(provider.syncAccess()).rejects.toMatchObject({
name: 'ProviderError',
code: 'not_implemented',
retryable: false,
});
describe('wireguard provider: syncAccess() (DC-153 contract tests)', () => {
const {
FirewallCheckError,
FirewallApplyError,
FirewallVerifyError,
} = require('../src/network/wg-firewall');
/** firewall engine mock factory (applier surface). */
function makeFirewall(overrides = {}) {
return {
apply: jest.fn(async () => ({
applied: true,
verified: true,
tempPath: '/tmp/x.nft',
rollbackFile: '/tmp/rb.nft',
previousExisted: false,
})),
rollback: jest.fn(async () => ({ applied: true, rollbackFile: '/tmp/rb.nft' })),
...overrides,
};
}
const input = () => ({
accessMap: { grants: [{ principal: { type: 'person', id: 'p1' }, resource: 'plex', allowed: true }] },
people: [
{ id: 'p1', groups: ['Admin'], status: 'active' },
{ id: 'p2', groups: [], status: 'active' },
],
resources: { plex: { ip: '10.53.0.1', port: 32400 } },
peerAddresses: { 'p1/d1': '10.53.0.2', 'p2/d2': '10.53.0.3' },
adminPeers: ['p1'],
});
function makeProviderWithFirewall(firewall) {
const fs = makeFs();
const exec = makeExec();
const provider = createWireGuardProvider({
execFileImpl: exec,
fsImpl: fs,
dataDir: '/data',
confPath: '/wg/dcnet0.conf',
unitPath: '/sys/dcnet-hub.service',
getuid: () => 0,
now: () => 1700000000000,
firewall,
});
return { provider, fs, exec };
}
test('happy path: applies the compiled ruleset, returns {applied, resourcesAffected}', async () => {
const firewall = makeFirewall();
const { provider } = makeProviderWithFirewall(firewall);
const res = await provider.syncAccess(input());
expect(res).toEqual({ applied: true, resourcesAffected: 1 });
expect(firewall.apply).toHaveBeenCalledTimes(1);
const ruleset = firewall.apply.mock.calls[0][0];
// The ruleset is the REAL compiler output for these shapes: admin set
// scoped to p1's peer IP, plex resource set with p1 (allowed) but not p2.
expect(ruleset).toContain('set net_dc_admins');
expect(ruleset).toContain('elements = { 10.53.0.2 }');
expect(ruleset).toContain('set net_dc_res_plex');
expect(ruleset).toContain('10.53.0.2'); // p1 in the plex resource set
expect(ruleset).not.toContain('10.53.0.3'); // p2 (no grant) in NO set
});
test('adminPeers defaults to active Admin-group people when omitted', async () => {
const firewall = makeFirewall();
const { provider } = makeProviderWithFirewall(firewall);
const { adminPeers: _omit, ...withoutAdminPeers } = input();
await provider.syncAccess(withoutAdminPeers);
const ruleset = firewall.apply.mock.calls[0][0];
expect(ruleset).toContain('elements = { 10.53.0.2 }'); // p1 = Admin group
});
test('admin lockout at compile (no active admin peer IPs) → ProviderError lockout_guard, nothing applied', async () => {
const firewall = makeFirewall();
const { provider } = makeProviderWithFirewall(firewall);
await expect(
provider.syncAccess({ ...input(), peerAddresses: {} })
).rejects.toMatchObject({
name: 'ProviderError',
code: 'lockout_guard',
retryable: false,
});
expect(firewall.apply).not.toHaveBeenCalled();
});
test('FirewallCheckError → ProviderError firewall_check_failed, .detail carries stderr + applied:false', async () => {
const firewall = makeFirewall({
apply: jest.fn(() => Promise.reject(
new FirewallCheckError('nft -c rejected ruleset (syntax)', { stderr: 'syntax error' })
)),
});
const { provider } = makeProviderWithFirewall(firewall);
const err = await provider.syncAccess(input()).catch((e) => e);
expect(err).toMatchObject({
name: 'ProviderError',
code: 'firewall_check_failed',
retryable: false,
});
expect(err.detail).toEqual({ stderr: 'syntax error', applied: false });
});
test('FirewallApplyError → ProviderError firewall_apply_failed, .detail records NOT partially applied', async () => {
const firewall = makeFirewall({
apply: jest.fn(() => Promise.reject(
new FirewallApplyError('nft -f apply failed (op not permitted)', { stderr: 'op not permitted' })
)),
});
const { provider } = makeProviderWithFirewall(firewall);
const err = await provider.syncAccess(input()).catch((e) => e);
expect(err).toMatchObject({ name: 'ProviderError', code: 'firewall_apply_failed' });
expect(err.detail).toEqual({ stderr: 'op not permitted', applied: false, rolledBack: false });
});
test('FirewallVerifyError → ProviderError firewall_verify_failed, .detail preserves rolledBack info', async () => {
const firewall = makeFirewall({
apply: jest.fn(() => Promise.reject(
new FirewallVerifyError('post-apply verify failed (missing table); rollback succeeded', {
stderr: 'missing table',
rolledBack: true,
})
)),
});
const { provider } = makeProviderWithFirewall(firewall);
const err = await provider.syncAccess(input()).catch((e) => e);
expect(err).toMatchObject({ name: 'ProviderError', code: 'firewall_verify_failed' });
expect(err.detail).toEqual({ stderr: 'missing table', applied: true, rolledBack: true });
});
describe('default construction (dep OMITTED — real wg-firewall applier wiring)', () => {
/**
* exec stub: default WG behavior PLUS `nft` (check/apply ok, list table
* returns the dcnet table text so verify passes). Records every call.
*/
function makeExecWithNft() {
const base = makeExec();
const calls = [];
const fn = async (bin, args, opts = {}) => {
calls.push({ bin, args, opts });
if (bin === 'nft') {
if (args[0] === '-c') return { stdout: '', stderr: '' };
if (args[0] === '-f') return { stdout: '', stderr: '' };
if (args[0] === 'list') return { stdout: 'table inet dcnet {\n}\n', stderr: '' };
}
return base(bin, args, opts);
};
fn.calls = calls;
return fn;
}
test('execFile mock receives nft -c -f THEN nft -f (transactional order)', async () => {
const exec = makeExecWithNft();
const fs = makeFs();
const provider = createWireGuardProvider({
execFileImpl: exec,
fsImpl: fs,
dataDir: '/data',
confPath: '/wg/dcnet0.conf',
unitPath: '/sys/dcnet-hub.service',
getuid: () => 0,
now: () => 1700000000000,
// firewall dep OMITTED — default createWgFirewallApplier(execFileImpl)
});
const res = await provider.syncAccess(input());
expect(res).toEqual({ applied: true, resourcesAffected: 1 });
const nftCalls = exec.calls.filter((c) => c.bin === 'nft');
expect(nftCalls.length).toBeGreaterThanOrEqual(4);
// Sequence: `nft -c -f` (check) → `nft list table` (capture previous)
// → `nft -f` (apply) → `nft list table` (verify), strictly in order.
const checkCall = nftCalls.find((c) => c.args[0] === '-c');
const applyCall = nftCalls.find((c) => c.args[0] === '-f');
const listCalls = nftCalls.filter((c) => c.args[0] === 'list');
expect(checkCall).toBeTruthy();
expect(applyCall).toBeTruthy();
expect(listCalls.length).toBeGreaterThanOrEqual(2);
expect(nftCalls.indexOf(checkCall)).toBeLessThan(nftCalls.indexOf(applyCall));
expect(listCalls[0].args).toEqual(['list', 'table', 'inet', 'dcnet']);
// The checked file and the applied file are the same temp ruleset.
expect(applyCall.args[1]).toBe(checkCall.args[2]);
// The applied ruleset text is the REAL compiler output.
const appliedText = fs.readFileSync(applyCall.args[1], 'utf8');
expect(appliedText).toContain('set net_dc_admins');
expect(appliedText).toContain('elements = { 10.53.0.2 }');
});
test('default applier: nft -c failure → firewall_check_failed with stderr detail, no apply', async () => {
const base = makeExec();
const calls = [];
const exec = async (bin, args, opts = {}) => {
calls.push({ bin, args, opts });
if (bin === 'nft' && args[0] === '-c') {
const e = new Error('nft: syntax error');
e.stderr = 'nft: syntax error near line 4';
throw e;
}
return base(bin, args, opts);
};
const provider = createWireGuardProvider({
execFileImpl: exec,
fsImpl: makeFs(),
dataDir: '/data',
confPath: '/wg/dcnet0.conf',
unitPath: '/sys/dcnet-hub.service',
getuid: () => 0,
now: () => 1700000000000,
});
const err = await provider.syncAccess(input()).catch((e) => e);
expect(err).toMatchObject({ name: 'ProviderError', code: 'firewall_check_failed' });
expect(err.detail).toMatchObject({ stderr: 'nft: syntax error near line 4', applied: false });
// check failed ⇒ `nft -f` apply NEVER ran
expect(calls.filter((c) => c.bin === 'nft' && c.args[0] === '-f')).toHaveLength(0);
});
});
});
describe('wireguard provider: unsupported / not-implemented surface', () => {
test('configureDns → unsupported (splitDnsApi capability false)', async () => {
const { provider } = makeProvider();
await expect(provider.configureDns({ zone: 'z', server: 's' })).rejects.toMatchObject({