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

@@ -285,14 +285,176 @@ describe('tailscale provider: revokeDevice()', () => {
});
});
describe('tailscale provider: syncAccess()', () => {
test('throws ProviderError code=not_implemented_in_provider (DC-148 lands later)', async () => {
const p = createTailscaleProvider({ coordClient: makeCoord() });
await expect(p.syncAccess({}, [])).rejects.toMatchObject({
describe('tailscale provider: syncAccess() (DC-153 contract tests)', () => {
const { LockoutError } = require('../src/network/acl-compiler');
const { AclPushError } = require('../src/network/acl-push');
/** aclSync engine mock factory (src/network/acl-sync.js surface). */
function makeAclSync(overrides = {}) {
return {
compile: jest.fn(async () => ({
policy: { acls: [] },
hash: 'sha256:abc',
usersAffected: 2,
})),
preview: jest.fn(async () => ({ feasible: true, errors: [] })),
push: jest.fn(async () => ({ pushed: true, hash: 'sha256:abc' })),
getState: jest.fn(() => null),
...overrides,
};
}
const input = () => ({
accessMap: { grants: [{ principal: { type: 'person', id: 'p1' }, resource: 'dashcaddy', allowed: true }] },
people: [
{ id: 'p1', providerUserId: '1001', groups: ['Admin'], status: 'active' },
{ id: 'p2', providerUserId: '2002', groups: [], status: 'active' },
],
resources: [{ name: 'dashcaddy', host: 'dns2.tail.ts.net', ports: ['*'] }],
hostDeviceId: 'dev-host',
});
test('happy path: compiles → previews → pushes, returns {pushed, hash, usersAffected}', async () => {
const aclSync = makeAclSync();
const p = createTailscaleProvider({ coordClient: makeCoord(), aclSync });
const res = await p.syncAccess(input());
expect(res).toEqual({ pushed: true, hash: 'sha256:abc', usersAffected: 2 });
// Compile receives the caller shapes + the derived guard inputs.
expect(aclSync.compile).toHaveBeenCalledWith(
expect.objectContaining({
accessMap: input().accessMap,
people: expect.any(Array),
resources: expect.any(Array),
hostDeviceId: 'dev-host',
adminUserIds: ['1001'], // derived from the active Admin-group person
hostResource: { host: 'dns2.tail.ts.net', ports: ['*'] },
})
);
// Preview runs on the compiled policy, BEFORE the push.
expect(aclSync.preview).toHaveBeenCalledTimes(1);
expect(aclSync.preview).toHaveBeenCalledWith({ acls: [] });
expect(aclSync.push).toHaveBeenCalledWith({ acls: [] });
});
test('LockoutError from compile → ProviderError lockout_guard, nothing previewed or pushed', async () => {
const aclSync = makeAclSync({
compile: jest.fn(() => {
throw new LockoutError('every active admin (1001) would be denied the host resource');
}),
});
const p = createTailscaleProvider({ coordClient: makeCoord(), aclSync });
await expect(p.syncAccess(input())).rejects.toMatchObject({
name: 'ProviderError',
code: 'not_implemented_in_provider',
code: 'lockout_guard',
retryable: false,
});
expect(aclSync.preview).not.toHaveBeenCalled();
expect(aclSync.push).not.toHaveBeenCalled();
});
test('preview errors[] → ProviderError acl_preview_failed, NOTHING pushed', async () => {
const aclSync = makeAclSync({
preview: jest.fn(() => Promise.reject(new AclPushError('ACL preview reported errors', {
code: 'acl_rejected',
cause: ['bad dst'],
}))),
});
const p = createTailscaleProvider({ coordClient: makeCoord(), aclSync });
await expect(p.syncAccess(input())).rejects.toMatchObject({
name: 'ProviderError',
code: 'acl_preview_failed',
retryable: false,
});
expect(aclSync.push).not.toHaveBeenCalled();
});
test('push API failure (acl_rejected) → ProviderError bad_input, mapped not leaked', async () => {
const aclSync = makeAclSync({
push: jest.fn(() => Promise.reject(new AclPushError('POST acl returned 400', {
code: 'acl_rejected',
}))),
});
const p = createTailscaleProvider({ coordClient: makeCoord(), aclSync });
await expect(p.syncAccess(input())).rejects.toMatchObject({
name: 'ProviderError',
code: 'bad_input',
});
});
test('explicit adminUserIds/hostResource pass through verbatim', async () => {
const aclSync = makeAclSync();
const p = createTailscaleProvider({ coordClient: makeCoord(), aclSync });
await p.syncAccess({
...input(),
adminUserIds: ['9999'],
hostResource: { host: 'other-host', ports: ['22'] },
});
expect(aclSync.compile).toHaveBeenCalledWith(
expect.objectContaining({ adminUserIds: ['9999'], hostResource: { host: 'other-host', ports: ['22'] } })
);
});
describe('default construction (dep OMITTED — real acl-compiler + acl-push wiring)', () => {
const fsReal = require('fs');
const os = require('os');
const pathMod = require('path');
let stateDir;
beforeAll(() => {
stateDir = fsReal.mkdtempSync(pathMod.join(os.tmpdir(), 'dc-ts-syncaccess-'));
global.__DC_ACL_STATE_DIR__ = stateDir; // acl-push state file location
});
afterAll(() => {
delete global.__DC_ACL_STATE_DIR__;
fsReal.rmSync(stateDir, { recursive: true, force: true });
});
test('coord mock: ACL preview + push POST bodies contain per-user srcs', async () => {
const request = jest.fn(async (method, apiPath) => {
if (apiPath === '/tailnet/-/acl/preview') return { feasible: true, errors: [] };
if (apiPath === '/tailnet/-/acl') return {};
throw new Error('unexpected ' + method + ' ' + apiPath);
});
const coord = makeCoord({ request });
const p = createTailscaleProvider({ coordClient: coord }); // aclSync OMITTED
const res = await p.syncAccess(input());
expect(res.pushed).toBe(true);
expect(res.hash).toMatch(/^sha256:[0-9a-f]{64}$/);
expect(res.usersAffected).toBe(1); // user 1001 only (host device excluded)
const previewCall = request.mock.calls.find((c) => c[1] === '/tailnet/-/acl/preview');
const pushCall = request.mock.calls.find((c) => c[1] === '/tailnet/-/acl');
expect(previewCall).toBeTruthy();
expect(pushCall).toBeTruthy();
// preview BEFORE push, both carrying the compiled policy
expect(request.mock.calls.indexOf(previewCall)).toBeLessThan(request.mock.calls.indexOf(pushCall));
for (const call of [previewCall, pushCall]) {
const acls = call[2].body.acls;
// per-user src (never a group), dst host:port per resource grant
expect(acls).toContainEqual({
action: 'accept',
src: ['1001'],
dst: ['dns2.tail.ts.net:*'],
proto: ['tcp', 'udp'],
});
// host device egress rule
expect(acls).toContainEqual({
action: 'accept',
src: ['dev-host'],
dst: ['*:*'],
proto: ['tcp', 'udp'],
});
}
});
test('no coord client attached → not_configured (never builds a dead engine)', async () => {
const p = createTailscaleProvider(); // no coordClient, no aclSync
await expect(p.syncAccess(input())).rejects.toMatchObject({
name: 'ProviderError',
code: 'not_configured',
});
});
});
});