@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/omadaClient/clientBlocks.test.ts

@@ -1,170 +0,0 @@
-/**
- * Unblocking clients the controller no longer treats as current, the blocked
- * list, and deleting a client record (for orphaned blocks).
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import type { McpServer } from '@modelcontextprotocol/server';
-
-import { ClientOperations, CLIENT_DOES_NOT_EXIST, normalizeMac } from '../../src/omadaClient/client.js';
-import { OmadaApiError, RequestHandler } from '../../src/omadaClient/request.js';
-import type { SiteOperations } from '../../src/omadaClient/site.js';
-import type { OmadaClient } from '../../src/omadaClient/index.js';
-import { registerDeleteClientTool } from '../../src/tools/omada/deleteClient.js';
-import { registerListBlockedClientsTool } from '../../src/tools/omada/listBlockedClients.js';
-import { Permission } from '../../src/permissions/index.js';
-
-const buildPath = (p: string): string => `/openapi/v1/omadac1${p}`;
-const MAC = '4C-1D-96-8D-37-C7';
-
-function setup(knownClients: unknown[] = []) {
-    const request = {
-        post: vi.fn(),
-        request: vi.fn(),
-        fetchPaginated: vi.fn().mockResolvedValue(knownClients),
-        // Mirrors the real ensureSuccess: a typed error carrying the controller's errorCode.
-        ensureSuccess: vi.fn((response: { errorCode: number; msg?: string; result?: unknown }) => {
-            if (response.errorCode !== 0) throw new OmadaApiError(response.msg ?? 'Omada error', response.errorCode);
-            return response.result;
-        }),
-    };
-    const site = { resolveSiteId: vi.fn(() => 'site-1') } as unknown as SiteOperations;
-    return { request, ops: new ClientOperations(request as unknown as RequestHandler, site, buildPath) };
-}
-
-const doesNotExist = { errorCode: CLIENT_DOES_NOT_EXIST, msg: 'This client does not exist.' };
-
-describe('normalizeMac', () => {
-    it('treats colon, dash and bare formats as the same MAC', () => {
-        expect(normalizeMac('4c:1d:96:8d:37:c7')).toBe(normalizeMac(MAC));
-        expect(normalizeMac('4c1d968d37c7')).toBe('4C1D968D37C7');
-    });
-});
-
-describe('ClientOperations.unblockClient', () => {
-    it('unblocks normally when the controller knows the client', async () => {
-        const { request, ops } = setup();
-        request.post.mockResolvedValue({ errorCode: 0 });
-
-        await expect(ops.unblockClient(MAC)).resolves.toEqual({ mac: MAC, siteId: 'site-1', blocked: false });
-        expect(request.fetchPaginated).not.toHaveBeenCalled();
-    });
-
-    it('reports success when the client is known and no longer blocked (e.g. unblocked in the web UI)', async () => {
-        const { request, ops } = setup([{ mac: '4c:1d:96:8d:37:c7', name: 'node-1271', block: false }]);
-        request.post.mockResolvedValue(doesNotExist);
-
-        await expect(ops.unblockClient(MAC)).resolves.toEqual({ mac: MAC, siteId: 'site-1', blocked: false });
-        expect(request.fetchPaginated).toHaveBeenCalledWith('/openapi/v1/omadac1/sites/site-1/insight/clients');
-    });
-
-    it('explains the controller limitation when the known client is still blocked', async () => {
-        const { request, ops } = setup([{ mac: MAC, name: 'node-1271', block: true }]);
-        request.post.mockResolvedValue(doesNotExist);
-
-        await expect(ops.unblockClient(MAC)).rejects.toThrow(/cannot unblock .* offline.*Known Clients.*omada_deleteClient/);
-    });
-
-    it('a known record without block state is not proof of an unblock', async () => {
-        const { request, ops } = setup([{ mac: MAC, name: 'node-1271' }]);
-        request.post.mockResolvedValue(doesNotExist);
-
-        await expect(ops.unblockClient(MAC)).rejects.toThrow(/cannot unblock/);
-    });
-
-    it('never reports success when the controller has no record at all (an orphaned block may remain)', async () => {
-        const { request, ops } = setup([{ mac: 'AA-BB-CC-DD-EE-FF', block: false }]);
-        request.post.mockResolvedValue(doesNotExist);
-
-        await expect(ops.unblockClient(MAC)).rejects.toThrow(/no record of .*orphaned block.*omada_deleteClient/);
-    });
-
-    it('other controller errors are passed through as before', async () => {
-        const { request, ops } = setup();
-        request.post.mockResolvedValue({ errorCode: -1, msg: 'General error' });
-
-        await expect(ops.unblockClient(MAC)).rejects.toThrow('General error');
-        expect(request.fetchPaginated).not.toHaveBeenCalled();
-    });
-});
-
-describe('unblockClient through the real request handler', () => {
-    afterEach(() => vi.unstubAllGlobals());
-
-    it('handles "client does not exist" sent with an HTTP error status, too', async () => {
-        const fetchMock = vi.fn(async (url: string) => {
-            if (url.includes('/unblock')) {
-                return new Response(JSON.stringify({ errorCode: CLIENT_DOES_NOT_EXIST, msg: 'This client does not exist.' }), { status: 400 });
-            }
-            // Known clients: present and no longer blocked.
-            return new Response(JSON.stringify({ errorCode: 0, result: { totalRows: 1, data: [{ mac: MAC, block: false }] } }), { status: 200 });
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const auth = { getAccessToken: vi.fn().mockResolvedValue('t'), clearToken: vi.fn() };
-        const request = new RequestHandler({ baseUrl: 'https://omada.test', strictSsl: true }, auth as never);
-        const site = { resolveSiteId: vi.fn(() => 'site-1') } as unknown as SiteOperations;
-        const ops = new ClientOperations(request, site, buildPath);
-
-        await expect(ops.unblockClient(MAC)).resolves.toEqual({ mac: MAC, siteId: 'site-1', blocked: false });
-        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/insight/clients'))).toBe(true);
-    });
-});
-
-describe('ClientOperations.listBlockedClients / deleteClient', () => {
-    it('lists only blocked known clients, offline ones included', async () => {
-        const { ops } = setup([
-            { mac: MAC, name: 'node-1271', block: true, lastSeen: 1 },
-            { mac: 'AA-BB-CC-DD-EE-FF', name: 'tv', block: false },
-            { mac: '11-22-33-44-55-66', name: 'old' },
-        ]);
-
-        await expect(ops.listBlockedClients()).resolves.toEqual([{ mac: MAC, name: 'node-1271', block: true, lastSeen: 1 }]);
-    });
-
-    it('deletes the client record with DELETE /clients/{mac}, encoding the MAC', async () => {
-        const { request, ops } = setup();
-        request.request.mockResolvedValue({ errorCode: 0 });
-
-        await expect(ops.deleteClient(MAC)).resolves.toEqual({ mac: MAC, siteId: 'site-1', deleted: true });
-        expect(request.request).toHaveBeenCalledWith({ method: 'DELETE', url: `/openapi/v1/omadac1/sites/site-1/clients/${MAC}` });
-    });
-
-    it('surfaces a failed delete', async () => {
-        const { request, ops } = setup();
-        request.request.mockResolvedValue(doesNotExist);
-
-        await expect(ops.deleteClient(MAC)).rejects.toThrow('This client does not exist.');
-    });
-});
-
-describe('client block tools: permissions', () => {
-    const extra = (permissions: number) => ({ sessionId: 's', http: { authInfo: { extra: { permissions } } } });
-
-    function register() {
-        const handlers = new Map<string, (a: unknown, e: unknown) => Promise<{ content: { text: string }[] }>>();
-        const server = { registerTool: vi.fn((name, _c, h) => handlers.set(name, h)) } as unknown as McpServer;
-        const client = { deleteClient: vi.fn().mockResolvedValue({ deleted: true }), listBlockedClients: vi.fn().mockResolvedValue([]) };
-        registerDeleteClientTool(server, client as unknown as OmadaClient);
-        registerListBlockedClientsTool(server, client as unknown as OmadaClient);
-        return { handlers, client };
-    }
-
-    let tools: ReturnType<typeof register>;
-    beforeEach(() => {
-        tools = register();
-    });
-
-    it('omada_deleteClient needs CONFIGURE (CONTROL is not enough)', async () => {
-        const denied = await tools.handlers.get('omada_deleteClient')!({ clientMac: MAC }, extra(Permission.QUERY | Permission.CONTROL));
-        expect(JSON.parse(denied.content[0].text)).toMatchObject({ error: 'Permission denied' });
-        expect(tools.client.deleteClient).not.toHaveBeenCalled();
-
-        await tools.handlers.get('omada_deleteClient')!({ clientMac: MAC }, extra(Permission.CONFIGURE));
-        expect(tools.client.deleteClient).toHaveBeenCalledWith(MAC, undefined);
-    });
-
-    it('omada_listBlockedClients needs only QUERY', async () => {
-        await tools.handlers.get('omada_listBlockedClients')!({}, extra(Permission.QUERY));
-        expect(tools.client.listBlockedClients).toHaveBeenCalled();
-    });
-});

package/tests/omadaClient/ntp.test.ts

@@ -1,381 +0,0 @@
-/**
- * Unit tests for the site NTP operations:
- *  - ntpAddressError / buildSiteUpdateBody (pure helpers)
- *  - SiteOperations.getSiteNtpStatus / setSiteNtpServers (read-modify-write of PUT /sites/{siteId})
- *  - the omada_getSiteNtpStatus / omada_setSiteNtpServers tools (RBAC + argument plumbing)
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { McpServer } from '@modelcontextprotocol/server';
-
-import type { OmadaClient } from '../../src/omadaClient/index.js';
-import type { RequestHandler } from '../../src/omadaClient/request.js';
-import { SiteOperations, buildSiteUpdateBody, ntpAddressError, type OmadaSiteInfo } from '../../src/omadaClient/site.js';
-import { registerGetSiteNtpStatusTool } from '../../src/tools/omada/getSiteNtpStatus.js';
-import { registerSetSiteNtpServersTool } from '../../src/tools/omada/setSiteNtpServers.js';
-import { Permission } from '../../src/permissions/index.js';
-
-const buildPath = (p: string): string => `/openapi/v1/omadac1${p.startsWith('/') ? p : `/${p}`}`;
-
-function createMockRequest() {
-    return {
-        get: vi.fn(),
-        put: vi.fn(),
-        // Mirrors the real ensureSuccess: unwrap result, throw on errorCode !== 0
-        ensureSuccess: vi.fn((response: { errorCode: number; msg?: string; result?: unknown }) => {
-            if (response.errorCode !== 0) {
-                throw new Error(response.msg ?? `Omada error ${String(response.errorCode)}`);
-            }
-            return response.result;
-        }),
-    };
-}
-
-const ok = (result?: unknown) => ({ errorCode: 0, msg: 'Success', result });
-
-/** A site as GET /sites/{siteId} returns it, including read-only DST fields. */
-function siteFixture(overrides: Partial<OmadaSiteInfo> = {}): OmadaSiteInfo {
-    return {
-        siteId: 'site-1',
-        name: 'Tower',
-        type: 0,
-        tagIds: ['tag-a'],
-        region: 'RO',
-        timeZone: 'Europe/Bucharest',
-        scenario: 'Home',
-        ntpEnable: false,
-        ntpServers: ['old.example.org'],
-        dst: {
-            enable: true,
-            mode: 1,
-            start: { month: 3, serial: 5, day: 7, hour: 3, minute: 0 },
-            end: { month: 10, serial: 5, day: 7, hour: 4, minute: 0 },
-            offset: 3600000,
-            status: true,
-            startTime: 1774746000000,
-            endTime: 1792890000000,
-            nextStart: 1806195600000,
-        },
-        longitude: 25.6,
-        latitude: 45.65,
-        address: 'Brasov',
-        supportES: true,
-        supportL2: true,
-        ...overrides,
-    };
-}
-
-const APPROVED = ['82.76.255.14', '194.102.58.251'];
-
-describe('ntpAddressError', () => {
-    it.each(['82.76.255.14', '194.102.58.251', 'time.nipne.ro', 'ro.pool.ntp.org', '0.0.0.0'])(
-        'accepts %s',
-        (address) => {
-            expect(ntpAddressError(address)).toBeNull();
-        }
-    );
-
-    it.each([
-        '999.1.1.1',
-        '1.2.3',
-        '1.2.3.4.5',
-        '01.2.3.4',
-        'localhost',
-        'http://time.nipne.ro',
-        'time nipne.ro',
-        '-bad.example.org',
-        'x',
-        '',
-    ])('rejects %s', (address) => {
-        expect(ntpAddressError(address)).toMatch(/not a valid/);
-    });
-});
-
-describe('buildSiteUpdateBody', () => {
-    it('carries over every writable site field and changes only NTP', () => {
-        const body = buildSiteUpdateBody(siteFixture(), APPROVED, true);
-
-        expect(body).toEqual({
-            name: 'Tower',
-            region: 'RO',
-            timeZone: 'Europe/Bucharest',
-            scenario: 'Home',
-            tagIds: ['tag-a'],
-            ntpEnable: true,
-            ntpServers: [{ address: '82.76.255.14' }, { address: '194.102.58.251' }],
-            dst: {
-                enable: true,
-                mode: 1,
-                start: { month: 3, serial: 5, day: 7, hour: 3, minute: 0 },
-                end: { month: 10, serial: 5, day: 7, hour: 4, minute: 0 },
-                offset: 3600000,
-            },
-            longitude: 25.6,
-            latitude: 45.65,
-            address: 'Brasov',
-            supportES: true,
-            supportL2: true,
-        });
-    });
-
-    it('drops read-only fields (siteId, type, DST status/timestamps)', () => {
-        const body = buildSiteUpdateBody(siteFixture(), APPROVED, true) as unknown as Record<string, unknown>;
-
-        expect(body).not.toHaveProperty('siteId');
-        expect(body).not.toHaveProperty('type');
-        expect(Object.keys(body.dst as object).sort()).toEqual(['enable', 'end', 'mode', 'offset', 'start']);
-    });
-
-    it('drops the empty DST start/end the controller returns when DST is off (it rejects them on write)', () => {
-        // Shape seen live on Omada: DST off, start/end as empty objects.
-        const site = siteFixture({ dst: { enable: false, mode: 0, start: {} as never, end: {} as never } });
-
-        expect(buildSiteUpdateBody(site, APPROVED, true).dst).toEqual({ enable: false, mode: 0 });
-    });
-
-    it('refuses to write when DST is on but its start/end is incomplete', () => {
-        const site = siteFixture({
-            dst: { enable: true, mode: 2, start: { month: 3 } as never, end: { month: 10, serial: 5, day: 7, hour: 4, minute: 0 } },
-        });
-
-        expect(() => buildSiteUpdateBody(site, APPROVED, true)).toThrow(/daylight saving enabled but an incomplete start\/end/);
-    });
-
-    it('omits optional fields the site does not have instead of sending undefined', () => {
-        const site: OmadaSiteInfo = { region: 'RO', timeZone: 'Europe/Bucharest', scenario: 'Home' };
-        const body = buildSiteUpdateBody(site, APPROVED, true);
-
-        expect(Object.keys(body).sort()).toEqual(['ntpEnable', 'ntpServers', 'region', 'scenario', 'timeZone']);
-    });
-
-    it.each(['region', 'timeZone', 'scenario'] as const)('refuses to build a body when %s is missing', (field) => {
-        const site = siteFixture({ [field]: undefined } as Partial<OmadaSiteInfo>);
-
-        expect(() => buildSiteUpdateBody(site, APPROVED, true)).toThrow(new RegExp(`missing '${field}'.*refusing to write`));
-    });
-});
-
-describe('SiteOperations NTP', () => {
-    let request: ReturnType<typeof createMockRequest>;
-    let ops: SiteOperations;
-
-    beforeEach(() => {
-        request = createMockRequest();
-        ops = new SiteOperations(request as unknown as RequestHandler, buildPath, 'site-1');
-    });
-
-    it('getSiteNtpStatus GETs the site ntp setting', async () => {
-        request.get.mockResolvedValue(ok({ ntpEnable: true }));
-
-        await expect(ops.getSiteNtpStatus()).resolves.toEqual({ ntpEnable: true });
-        expect(request.get).toHaveBeenCalledWith('/openapi/v1/omadac1/sites/site-1/setting/ntp');
-    });
-
-    it('dryRun returns the exact PUT body and does not write', async () => {
-        request.get.mockResolvedValue(ok(siteFixture()));
-
-        const result = await ops.setSiteNtpServers(APPROVED, { dryRun: true });
-
-        expect(request.put).not.toHaveBeenCalled();
-        expect(result.applied).toBe(false);
-        expect(result.before).toEqual({ ntpEnable: false, ntpServers: ['old.example.org'] });
-        expect(result.after).toEqual({ ntpEnable: true, ntpServers: APPROVED });
-        expect(result.request).toEqual(buildSiteUpdateBody(siteFixture(), APPROVED, true));
-    });
-
-    it('PUTs the full site body, then reports what the controller holds afterwards', async () => {
-        request.get
-            .mockResolvedValueOnce(ok(siteFixture()))
-            .mockResolvedValueOnce(ok(siteFixture()))
-            .mockResolvedValueOnce(ok(siteFixture({ ntpEnable: true, ntpServers: APPROVED })));
-        request.put.mockResolvedValue(ok());
-
-        const result = await ops.setSiteNtpServers(APPROVED);
-
-        expect(request.get).toHaveBeenNthCalledWith(1, '/openapi/v1/omadac1/sites/site-1');
-        expect(request.put).toHaveBeenCalledWith(
-            '/openapi/v1/omadac1/sites/site-1',
-            buildSiteUpdateBody(siteFixture(), APPROVED, true)
-        );
-        expect(request.get).toHaveBeenCalledTimes(3);
-        expect(result).toMatchObject({
-            siteId: 'site-1',
-            siteName: 'Tower',
-            applied: true,
-            before: { ntpEnable: false, ntpServers: ['old.example.org'] },
-            after: { ntpEnable: true, ntpServers: APPROVED },
-        });
-    });
-
-    it('reports the controller state, even when it differs from the request', async () => {
-        request.get
-            .mockResolvedValueOnce(ok(siteFixture()))
-            .mockResolvedValueOnce(ok(siteFixture()))
-            .mockResolvedValueOnce(ok(siteFixture({ ntpEnable: true, ntpServers: ['82.76.255.14'] })));
-        request.put.mockResolvedValue(ok());
-
-        const result = await ops.setSiteNtpServers(APPROVED);
-
-        expect(result.after.ntpServers).toEqual(['82.76.255.14']);
-    });
-
-    it('uses an explicit siteId and encodes it', async () => {
-        request.get.mockResolvedValue(ok(siteFixture()));
-
-        await ops.setSiteNtpServers(APPROVED, { siteId: 'a/b', dryRun: true });
-
-        expect(request.get).toHaveBeenCalledWith('/openapi/v1/omadac1/sites/a%2Fb');
-    });
-
-    it('allows turning NTP off with an empty list', async () => {
-        request.get.mockResolvedValue(ok(siteFixture({ ntpEnable: true })));
-
-        const result = await ops.setSiteNtpServers([], { enabled: false, dryRun: true });
-
-        expect(result.request.ntpEnable).toBe(false);
-        expect(result.request.ntpServers).toEqual([]);
-    });
-
-    it.each([
-        { servers: [] as string[], enabled: true, error: /At least one NTP server/ },
-        { servers: ['1.1.1.1', '2.2.2.2', '3.3.3.3', '4.4.4.4', '5.5.5.5', '6.6.6.6'], enabled: true, error: /at most 5/ },
-        { servers: ['82.76.255.14', '999.1.1.1'], enabled: true, error: /'999.1.1.1' is not a valid IPv4/ },
-        { servers: ['82.76.255.14', '82.76.255.14'], enabled: true, error: /duplicates/ },
-    ])('rejects $servers before contacting the controller', async ({ servers, enabled, error }) => {
-        await expect(ops.setSiteNtpServers(servers, { enabled })).rejects.toThrow(error);
-        expect(request.get).not.toHaveBeenCalled();
-        expect(request.put).not.toHaveBeenCalled();
-    });
-
-    it('propagates a controller rejection of the PUT and does not report success', async () => {
-        request.get.mockResolvedValue(ok(siteFixture()));
-        request.put.mockResolvedValue({ errorCode: -1, msg: 'Permission denied' });
-
-        await expect(ops.setSiteNtpServers(APPROVED)).rejects.toThrow('Permission denied');
-        expect(request.get).toHaveBeenCalledTimes(2);
-    });
-
-    it('refuses to write when a non-NTP setting changed between the read and the write', async () => {
-        request.get
-            .mockResolvedValueOnce(ok(siteFixture()))
-            .mockResolvedValueOnce(ok(siteFixture({ timeZone: 'Europe/London' })));
-
-        await expect(ops.setSiteNtpServers(APPROVED)).rejects.toThrow(/changed while preparing.*nothing was written/);
-        expect(request.put).not.toHaveBeenCalled();
-    });
-
-    it('ignores NTP-only differences between the two reads (NTP is what is being set)', async () => {
-        request.get
-            .mockResolvedValueOnce(ok(siteFixture()))
-            .mockResolvedValueOnce(ok(siteFixture({ ntpServers: ['someone.else.org'] })))
-            .mockResolvedValueOnce(ok(siteFixture({ ntpEnable: true, ntpServers: APPROVED })));
-        request.put.mockResolvedValue(ok());
-
-        await expect(ops.setSiteNtpServers(APPROVED)).resolves.toMatchObject({ applied: true });
-    });
-
-    it('serializes concurrent writes to the same site: the second reads only after the first wrote', async () => {
-        const events: string[] = [];
-        let state = siteFixture();
-        request.get.mockImplementation(async () => {
-            events.push('get');
-            await new Promise((r) => setTimeout(r, 5));
-            return ok(state);
-        });
-        request.put.mockImplementation(async (_path: string, body: { ntpServers: Array<{ address: string }> }) => {
-            events.push('put');
-            await new Promise((r) => setTimeout(r, 5));
-            state = { ...state, ntpEnable: true, ntpServers: body.ntpServers.map((s) => s.address) };
-            return ok();
-        });
-
-        const [first, second] = await Promise.all([
-            ops.setSiteNtpServers(['82.76.255.14']),
-            ops.setSiteNtpServers(['194.102.58.251']),
-        ]);
-
-        expect(events).toEqual(['get', 'get', 'put', 'get', 'get', 'get', 'put', 'get']);
-        expect(first.after.ntpServers).toEqual(['82.76.255.14']);
-        expect(second.before.ntpServers).toEqual(['82.76.255.14']);
-        expect(second.after.ntpServers).toEqual(['194.102.58.251']);
-    });
-
-    it('a failed write does not block the next one', async () => {
-        request.get.mockResolvedValue(ok(siteFixture()));
-        request.put.mockResolvedValueOnce({ errorCode: -1, msg: 'boom' }).mockResolvedValueOnce(ok());
-
-        await expect(ops.setSiteNtpServers(APPROVED)).rejects.toThrow('boom');
-        await expect(ops.setSiteNtpServers(APPROVED)).resolves.toMatchObject({ applied: true });
-    });
-
-    it('does not write when the site info lacks a required field', async () => {
-        request.get.mockResolvedValue(ok(siteFixture({ scenario: '' })));
-
-        await expect(ops.setSiteNtpServers(APPROVED)).rejects.toThrow(/missing 'scenario'/);
-        expect(request.put).not.toHaveBeenCalled();
-    });
-});
-
-// ---- Tools -------------------------------------------------------------------
-
-type Handler = (args: unknown, extra: unknown) => Promise<{ content: { text: string }[] }>;
-
-function createMockServer() {
-    const handlers = new Map<string, Handler>();
-    return {
-        registerTool: vi.fn((name: string, _config: unknown, handler: Handler) => {
-            handlers.set(name, handler);
-        }),
-        handlers,
-    } as unknown as McpServer & { handlers: Map<string, Handler> };
-}
-
-const extraWith = (permissions: number) => ({
-    sessionId: 'test-session',
-    http: { authInfo: { extra: { permissions } } },
-});
-
-const parse = (result: { content: { text: string }[] }) => JSON.parse(result.content[0].text) as Record<string, unknown>;
-
-describe('omada NTP tools', () => {
-    let server: ReturnType<typeof createMockServer>;
-    let client: { getSiteNtpStatus: ReturnType<typeof vi.fn>; setSiteNtpServers: ReturnType<typeof vi.fn> };
-
-    beforeEach(() => {
-        server = createMockServer();
-        client = { getSiteNtpStatus: vi.fn(), setSiteNtpServers: vi.fn() };
-        registerGetSiteNtpStatusTool(server, client as unknown as OmadaClient);
-        registerSetSiteNtpServersTool(server, client as unknown as OmadaClient);
-    });
-
-    it('omada_getSiteNtpStatus needs only QUERY', async () => {
-        client.getSiteNtpStatus.mockResolvedValue({ ntpEnable: true });
-
-        const result = await server.handlers.get('omada_getSiteNtpStatus')!({ siteId: 's1' }, extraWith(Permission.QUERY));
-
-        expect(parse(result)).toEqual({ ntpEnable: true });
-        expect(client.getSiteNtpStatus).toHaveBeenCalledWith('s1');
-    });
-
-    it('omada_setSiteNtpServers is denied to a CONTROL + QUERY caller (needs CONFIGURE)', async () => {
-        const result = await server.handlers.get('omada_setSiteNtpServers')!(
-            { servers: APPROVED },
-            extraWith(Permission.QUERY | Permission.CONTROL)
-        );
-
-        expect(parse(result)).toMatchObject({ error: 'Permission denied' });
-        expect(parse(result).message).toContain('CONFIGURE');
-        expect(client.setSiteNtpServers).not.toHaveBeenCalled();
-    });
-
-    it('omada_setSiteNtpServers passes servers and options through for a CONFIGURE caller', async () => {
-        client.setSiteNtpServers.mockResolvedValue({ applied: false });
-
-        await server.handlers.get('omada_setSiteNtpServers')!(
-            { servers: APPROVED, siteId: 's1', dryRun: true },
-            extraWith(Permission.CONFIGURE)
-        );
-
-        expect(client.setSiteNtpServers).toHaveBeenCalledWith(APPROVED, { enabled: undefined, siteId: 's1', dryRun: true });
-    });
-});

package/tests/omadaClient/site.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { checkConfiguredSite } from '../../src/omadaClient/site.js';
-import type { OmadaSiteSummary } from '../../src/types/index.js';
-
-const site = (siteId: string, name: string): OmadaSiteSummary => ({ siteId, name });
-
-const SITES: OmadaSiteSummary[] = [site('69bbeb9fa83b077caff61fee', 'Home'), site('ab12cd34', 'Office')];
-
-describe('checkConfiguredSite', () => {
-  it('returns null when no OMADA_SITE_ID is configured (no default)', () => {
-    expect(checkConfiguredSite(undefined, SITES)).toBeNull();
-    expect(checkConfiguredSite('', SITES)).toBeNull();
-  });
-
-  it('returns null when the configured site exists on the controller', () => {
-    expect(checkConfiguredSite('69bbeb9fa83b077caff61fee', SITES)).toBeNull();
-    expect(checkConfiguredSite('ab12cd34', SITES)).toBeNull();
-  });
-
-  it('returns an actionable error when the configured site is not on the controller', () => {
-    const err = checkConfiguredSite('stale-old-id', SITES);
-    expect(err).not.toBeNull();
-    // Names the bad value...
-    expect(err).toContain('stale-old-id');
-    // ...and lists the valid choices (name + id) so the operator can fix .env.
-    expect(err).toContain('Home (69bbeb9fa83b077caff61fee)');
-    expect(err).toContain('Office (ab12cd34)');
-  });
-
-  it('still flags a stale id when the controller returns no sites', () => {
-    const err = checkConfiguredSite('stale-old-id', []);
-    expect(err).not.toBeNull();
-    expect(err).toContain('stale-old-id');
-    expect(err).toContain('(controller returned no sites)');
-  });
-});