@omniq/sdk 0.1.0

package/dist/__tests__/client.test.js

@@ -0,0 +1,784 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OmniqClient, OmniqApiError } from '../client.js';
+function jsonResponse(body, status = 200, statusText = 'OK') {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        statusText,
+        json: () => Promise.resolve(body),
+        headers: new Headers(),
+    };
+}
+function errorResponse(status, statusText, body = null) {
+    return {
+        ok: false,
+        status,
+        statusText,
+        json: () => Promise.resolve(body),
+        headers: new Headers(),
+    };
+}
+let fetchMock;
+beforeEach(() => {
+    fetchMock = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+    vi.useFakeTimers();
+});
+// ---------------------------------------------------------------------------
+// OmniqClient core
+// ---------------------------------------------------------------------------
+describe('OmniqClient', () => {
+    const BASE = 'https://api.omniq.pro';
+    function createClient(opts) {
+        return new OmniqClient({
+            baseUrl: BASE,
+            ...opts,
+        });
+    }
+    describe('successful requests', () => {
+        it('returns parsed JSON on 200', async () => {
+            const payload = { id: '1', name: 'Test' };
+            fetchMock.mockResolvedValueOnce(jsonResponse(payload));
+            const client = createClient({ token: 'tok' });
+            const result = await client.request('GET', '/things');
+            expect(result).toEqual(payload);
+            expect(fetchMock).toHaveBeenCalledOnce();
+            const [url, init] = fetchMock.mock.calls[0];
+            expect(url).toBe(`${BASE}/things`);
+            expect(init.method).toBe('GET');
+        });
+        it('sends JSON body for POST', async () => {
+            const body = { title: 'new' };
+            fetchMock.mockResolvedValueOnce(jsonResponse({ id: '2', ...body }));
+            const client = createClient({ token: 'tok' });
+            await client.request('POST', '/things', { body });
+            const [, init] = fetchMock.mock.calls[0];
+            expect(init.body).toBe(JSON.stringify(body));
+            expect(init.method).toBe('POST');
+        });
+        it('appends query parameters to url', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse([]));
+            const client = createClient();
+            await client.request('GET', '/items', { query: { status: 'active', page: 1 } });
+            const url = new URL(fetchMock.mock.calls[0][0]);
+            expect(url.searchParams.get('status')).toBe('active');
+            expect(url.searchParams.get('page')).toBe('1');
+        });
+        it('omits undefined query params', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse([]));
+            const client = createClient();
+            await client.request('GET', '/items', { query: { a: 'yes', b: undefined } });
+            const url = new URL(fetchMock.mock.calls[0][0]);
+            expect(url.searchParams.get('a')).toBe('yes');
+            expect(url.searchParams.has('b')).toBe(false);
+        });
+    });
+    describe('204 response', () => {
+        it('returns undefined', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(null, 204, 'No Content'));
+            const client = createClient();
+            const result = await client.request('DELETE', '/things/1');
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('authorization header', () => {
+        it('sends Bearer token when token is set', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = createClient({ token: 'secret-token' });
+            await client.request('GET', '/me');
+            const headers = fetchMock.mock.calls[0][1].headers;
+            expect(headers['Authorization']).toBe('Bearer secret-token');
+        });
+        it('does not send Authorization when no token', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = createClient();
+            await client.request('GET', '/public');
+            const headers = fetchMock.mock.calls[0][1].headers;
+            expect(headers['Authorization']).toBeUndefined();
+        });
+        it('reflects token set via setToken()', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = createClient();
+            client.setToken('dynamic-tok');
+            await client.request('GET', '/me');
+            expect(fetchMock.mock.calls[0][1].headers['Authorization']).toBe('Bearer dynamic-tok');
+        });
+        it('clears token via clearToken()', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = createClient({ token: 'will-be-cleared' });
+            client.clearToken();
+            await client.request('GET', '/me');
+            expect(fetchMock.mock.calls[0][1].headers['Authorization']).toBeUndefined();
+        });
+    });
+    describe('cookie header', () => {
+        it('sends Cookie header when cookieHeader is set', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = createClient({ cookieHeader: 'session=abc123' });
+            await client.request('GET', '/me');
+            expect(fetchMock.mock.calls[0][1].headers['Cookie']).toBe('session=abc123');
+        });
+        it('does not send Cookie header when not configured', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = createClient();
+            await client.request('GET', '/me');
+            expect(fetchMock.mock.calls[0][1].headers['Cookie']).toBeUndefined();
+        });
+    });
+    describe('4xx errors (no retry)', () => {
+        it('throws OmniqApiError on 403', async () => {
+            const body = { error: 'Forbidden' };
+            fetchMock.mockResolvedValueOnce(errorResponse(403, 'Forbidden', body));
+            const client = createClient({ token: 'tok' });
+            await expect(client.request('GET', '/admin')).rejects.toThrow(OmniqApiError);
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+        });
+        it('contains correct status and body', async () => {
+            const body = { message: 'Not Found' };
+            fetchMock.mockResolvedValueOnce(errorResponse(404, 'Not Found', body));
+            const client = createClient();
+            try {
+                await client.request('GET', '/missing');
+                expect.unreachable('should have thrown');
+            }
+            catch (err) {
+                expect(err).toBeInstanceOf(OmniqApiError);
+                const apiErr = err;
+                expect(apiErr.status).toBe(404);
+                expect(apiErr.statusText).toBe('Not Found');
+                expect(apiErr.body).toEqual(body);
+            }
+        });
+        it('does not retry 4xx errors', async () => {
+            fetchMock.mockResolvedValueOnce(errorResponse(422, 'Unprocessable Entity'));
+            const client = createClient({ maxRetries: 3 });
+            await expect(client.request('POST', '/things')).rejects.toThrow(OmniqApiError);
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('5xx errors (retry)', () => {
+        it('retries and eventually succeeds', async () => {
+            const payload = { ok: true };
+            fetchMock
+                .mockResolvedValueOnce(errorResponse(500, 'Internal Server Error'))
+                .mockResolvedValueOnce(errorResponse(502, 'Bad Gateway'))
+                .mockResolvedValueOnce(jsonResponse(payload));
+            const client = createClient({ maxRetries: 3 });
+            const promise = client.request('GET', '/unstable');
+            await vi.runAllTimersAsync();
+            const result = await promise;
+            expect(result).toEqual(payload);
+            expect(fetchMock).toHaveBeenCalledTimes(3);
+        });
+        it('throws after exhausting retries', async () => {
+            fetchMock
+                .mockResolvedValueOnce(errorResponse(503, 'Service Unavailable'))
+                .mockResolvedValueOnce(errorResponse(503, 'Service Unavailable'))
+                .mockResolvedValueOnce(errorResponse(503, 'Service Unavailable'));
+            const client = createClient({ maxRetries: 2 });
+            const promise = client.request('GET', '/down');
+            const assertion = expect(promise).rejects.toThrow(OmniqApiError);
+            await vi.runAllTimersAsync();
+            await assertion;
+            expect(fetchMock).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('trailing slash normalization', () => {
+        it('strips trailing slashes from baseUrl', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({}));
+            const client = new OmniqClient({ baseUrl: 'https://api.omniq.pro///' });
+            await client.request('GET', '/test');
+            expect(fetchMock.mock.calls[0][0]).toBe('https://api.omniq.pro/test');
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Pagination
+// ---------------------------------------------------------------------------
+describe('OmniqClient.paginate()', () => {
+    const BASE = 'https://api.omniq.pro';
+    it('yields all items across multiple pages', async () => {
+        const page1Items = Array.from({ length: 50 }, (_, i) => ({ id: String(i + 1) }));
+        const page2Items = [{ id: '51' }, { id: '52' }];
+        const page1 = { data: page1Items, total: 52 };
+        const page2 = { data: page2Items, total: 52 };
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(page1))
+            .mockResolvedValueOnce(jsonResponse(page2));
+        const client = new OmniqClient({ baseUrl: BASE });
+        const items = [];
+        for await (const item of client.paginate('/items')) {
+            items.push(item);
+        }
+        expect(items).toHaveLength(52);
+        expect(items[0]).toEqual({ id: '1' });
+        expect(items[51]).toEqual({ id: '52' });
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        const url2 = new URL(fetchMock.mock.calls[1][0]);
+        expect(url2.searchParams.get('page')).toBe('2');
+    });
+    it('sends page and limit as query params', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: [{ id: '1' }], total: 1 }));
+        const client = new OmniqClient({ baseUrl: BASE });
+        const items = [];
+        for await (const item of client.paginate('/things', { status: 'done' })) {
+            items.push(item);
+        }
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.searchParams.get('page')).toBe('1');
+        expect(url.searchParams.get('limit')).toBe('50');
+        expect(url.searchParams.get('status')).toBe('done');
+    });
+    it('stops when page * limit >= total', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: Array.from({ length: 50 }, (_, i) => ({ id: String(i) })), total: 50 }));
+        const client = new OmniqClient({ baseUrl: BASE });
+        const items = [];
+        for await (const item of client.paginate('/big')) {
+            items.push(item);
+        }
+        expect(items).toHaveLength(50);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Issues
+// ---------------------------------------------------------------------------
+describe('IssuesResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        const client = new OmniqClient({ baseUrl: BASE, token: 'tok' });
+        return client;
+    }
+    it('list() → GET /issues with query', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: [], total: 0 }));
+        const client = setup();
+        await client.issues.list({ projectId: 'p1' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('GET');
+        expect(new URL(url).pathname).toBe('/issues');
+        expect(new URL(url).searchParams.get('projectId')).toBe('p1');
+    });
+    it('get() → GET /issues/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'i1' }));
+        const client = setup();
+        await client.issues.get('i1');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('GET');
+        expect(new URL(url).pathname).toBe('/issues/i1');
+    });
+    it('create() → POST /issues with body', async () => {
+        const input = { projectId: 'p1', title: 'New issue' };
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'i2', ...input }));
+        const client = setup();
+        await client.issues.create(input);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/issues');
+        expect(JSON.parse(init.body)).toEqual(input);
+    });
+    it('update() → PATCH /issues/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'i1', title: 'Updated' }));
+        const client = setup();
+        await client.issues.update('i1', { title: 'Updated' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('PATCH');
+        expect(new URL(url).pathname).toBe('/issues/i1');
+        expect(JSON.parse(init.body)).toEqual({ title: 'Updated' });
+    });
+    it('delete() → DELETE /issues/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204, 'No Content'));
+        const client = setup();
+        await client.issues.delete('i1');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('DELETE');
+        expect(new URL(url).pathname).toBe('/issues/i1');
+    });
+    it('updateStatus() → POST /issues/:id/status with body', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'i1', status: 'done' }));
+        const client = setup();
+        await client.issues.updateStatus('i1', 'done');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/issues/i1/status');
+        expect(JSON.parse(init.body)).toEqual({ status: 'done' });
+    });
+    it('bulkUpdate() → POST /issues/bulk with body', async () => {
+        const input = { ids: ['i1', 'i2'], status: 'done' };
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.issues.bulkUpdate(input);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/issues/bulk');
+        expect(JSON.parse(init.body)).toEqual(input);
+    });
+    it('addComment() → POST /issues/:id/comments', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'c1' }));
+        const client = setup();
+        await client.issues.addComment('i1', { content: 'hello' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/issues/i1/comments');
+        expect(JSON.parse(init.body)).toEqual({ content: 'hello' });
+    });
+    it('addLink() → POST /issues/:id/links', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'l1' }));
+        const client = setup();
+        await client.issues.addLink('i1', { targetId: 'i2', relation: 'blocks' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/issues/i1/links');
+        expect(JSON.parse(init.body)).toEqual({ targetId: 'i2', relation: 'blocks' });
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Projects
+// ---------------------------------------------------------------------------
+describe('ProjectsResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('list() → GET /projects, unwraps .data', async () => {
+        const projects = [{ id: 'p1', name: 'Alpha' }];
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: projects }));
+        const client = setup();
+        const result = await client.projects.list();
+        expect(result).toEqual(projects);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('GET');
+        expect(new URL(url).pathname).toBe('/projects');
+    });
+    it('get() → GET /projects/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'p1' }));
+        const client = setup();
+        await client.projects.get('p1');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/projects/p1');
+    });
+    it('create() → POST /projects', async () => {
+        const input = { name: 'New', key: 'NEW' };
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'p2', ...input }));
+        const client = setup();
+        await client.projects.create(input);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/projects');
+        expect(JSON.parse(init.body)).toEqual(input);
+    });
+    it('update() → PATCH /projects/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'p1' }));
+        const client = setup();
+        await client.projects.update('p1', { name: 'Renamed' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('PATCH');
+        expect(new URL(url).pathname).toBe('/projects/p1');
+    });
+    it('delete() → DELETE /projects/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.projects.delete('p1');
+        expect(fetchMock.mock.calls[0][1].method).toBe('DELETE');
+    });
+    it('listMembers() → GET /projects/:id/members, unwraps .data', async () => {
+        const members = [{ userId: 'u1', role: 'developer' }];
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: members }));
+        const client = setup();
+        const result = await client.projects.listMembers('p1');
+        expect(result).toEqual(members);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('GET');
+        expect(new URL(url).pathname).toBe('/projects/p1/members');
+    });
+    it('addMember() → POST /projects/:id/members', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.projects.addMember('p1', { userId: 'u1', role: 'developer' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/projects/p1/members');
+        expect(JSON.parse(init.body)).toEqual({ userId: 'u1', role: 'developer' });
+    });
+    it('removeMember() → DELETE /projects/:id/members/:userId', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.projects.removeMember('p1', 'u1');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('DELETE');
+        expect(new URL(url).pathname).toBe('/projects/p1/members/u1');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Sprints
+// ---------------------------------------------------------------------------
+describe('SprintsResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('list() → GET /sprints?projectId=x, unwraps .data', async () => {
+        const sprints = [{ id: 's1' }];
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: sprints }));
+        const client = setup();
+        const result = await client.sprints.list({ projectId: 'p1' });
+        expect(result).toEqual(sprints);
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/sprints');
+        expect(url.searchParams.get('projectId')).toBe('p1');
+    });
+    it('get() → GET /sprints/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 's1' }));
+        const client = setup();
+        await client.sprints.get('s1');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/sprints/s1');
+    });
+    it('create() → POST /sprints', async () => {
+        const input = { projectId: 'p1', name: 'Sprint 1' };
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 's1', ...input }));
+        const client = setup();
+        await client.sprints.create(input);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/sprints');
+        expect(JSON.parse(init.body)).toEqual(input);
+    });
+    it('update() → PATCH /sprints/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 's1' }));
+        const client = setup();
+        await client.sprints.update('s1', { name: 'Renamed' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('PATCH');
+        expect(new URL(url).pathname).toBe('/sprints/s1');
+    });
+    it('start() → POST /sprints/:id/start', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 's1', status: 'active' }));
+        const client = setup();
+        await client.sprints.start('s1');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/sprints/s1/start');
+    });
+    it('close() → POST /sprints/:id/close with transferToSprintId', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 's1', status: 'completed' }));
+        const client = setup();
+        await client.sprints.close('s1', 's2');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/sprints/s1/close');
+        expect(JSON.parse(init.body)).toEqual({ transferToSprintId: 's2' });
+    });
+    it('close() → POST /sprints/:id/close without transfer (no body)', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 's1', status: 'completed' }));
+        const client = setup();
+        await client.sprints.close('s1');
+        const [, init] = fetchMock.mock.calls[0];
+        expect(init.body).toBeUndefined();
+    });
+    it('burndown() → GET /sprints/:id/burndown', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.sprints.burndown('s1');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/sprints/s1/burndown');
+        expect(fetchMock.mock.calls[0][1].method).toBe('GET');
+    });
+    it('velocity() → GET /sprints/velocity?projectId=x', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ sprints: [], averageVelocity: 0 }));
+        const client = setup();
+        await client.sprints.velocity({ projectId: 'p1' });
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/sprints/velocity');
+        expect(url.searchParams.get('projectId')).toBe('p1');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: GitLab
+// ---------------------------------------------------------------------------
+describe('GitLabResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('listActivity() → GET /git/events?projectId=x, unwraps .data', async () => {
+        const events = [{ id: 'e1', type: 'push' }];
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: events }));
+        const client = setup();
+        const result = await client.gitlab.listActivity('p1');
+        expect(result).toEqual(events);
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/git/events');
+        expect(url.searchParams.get('projectId')).toBe('p1');
+    });
+    it('linkCommit() → POST /git/commits/link', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.gitlab.linkCommit('i1', 'abc123', 'https://gl.example.com/commit/abc123');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/git/commits/link');
+        expect(JSON.parse(init.body)).toEqual({
+            issueId: 'i1',
+            sha: 'abc123',
+            url: 'https://gl.example.com/commit/abc123',
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Auth
+// ---------------------------------------------------------------------------
+describe('AuthResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE });
+    }
+    it('login() → POST /auth/login', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ user: { id: 'u1' } }));
+        const client = setup();
+        await client.auth.login({ email: 'a@b.com', password: 'pass' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/auth/login');
+        expect(JSON.parse(init.body)).toEqual({ email: 'a@b.com', password: 'pass' });
+    });
+    it('refresh() → POST /auth/refresh', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ success: true }));
+        const client = setup();
+        await client.auth.refresh();
+        expect(fetchMock.mock.calls[0][1].method).toBe('POST');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/auth/refresh');
+    });
+    it('logout() → POST /auth/logout', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.auth.logout();
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/auth/logout');
+    });
+    it('me() → GET /auth/me', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ user: { id: 'u1' } }));
+        const client = setup();
+        await client.auth.me();
+        expect(fetchMock.mock.calls[0][1].method).toBe('GET');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/auth/me');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Wiki
+// ---------------------------------------------------------------------------
+describe('WikiResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('listSpaces() → GET /wiki/spaces?projectId=x', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.wiki.listSpaces({ projectId: 'p1' });
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/wiki/spaces');
+        expect(url.searchParams.get('projectId')).toBe('p1');
+    });
+    it('createSpace() → POST /wiki/spaces', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'ws1' }));
+        const client = setup();
+        await client.wiki.createSpace({ projectId: 'p1', name: 'Docs' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/wiki/spaces');
+    });
+    it('createPage() → POST /wiki/pages', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'wp1' }));
+        const client = setup();
+        await client.wiki.createPage({ spaceId: 'ws1', title: 'Getting Started', content: '# Hello' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/wiki/pages');
+    });
+    it('updatePage() → PATCH /wiki/pages/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'wp1' }));
+        const client = setup();
+        await client.wiki.updatePage('wp1', { title: 'Updated' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('PATCH');
+        expect(new URL(url).pathname).toBe('/wiki/pages/wp1');
+    });
+    it('search() → GET /wiki/search?projectId&q', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.wiki.search({ projectId: 'p1', q: 'setup' });
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/wiki/search');
+        expect(url.searchParams.get('q')).toBe('setup');
+        expect(url.searchParams.get('projectId')).toBe('p1');
+    });
+    it('templates() → GET /wiki/templates', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.wiki.templates();
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/wiki/templates');
+    });
+    it('restorePage() → POST /wiki/pages/:id/restore/:versionId', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'wp1' }));
+        const client = setup();
+        await client.wiki.restorePage('wp1', 'v3');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/wiki/pages/wp1/restore/v3');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Calendar
+// ---------------------------------------------------------------------------
+describe('CalendarResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('listEvents() → GET /calendar/events with date range', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.calendar.listEvents({ start: '2026-01-01', end: '2026-01-31' });
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/calendar/events');
+        expect(url.searchParams.get('start')).toBe('2026-01-01');
+        expect(url.searchParams.get('end')).toBe('2026-01-31');
+    });
+    it('createEvent() → POST /calendar/events', async () => {
+        const input = { type: 'meeting', title: 'Standup', start: '2026-01-01T10:00:00Z' };
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'ev1', ...input }));
+        const client = setup();
+        await client.calendar.createEvent(input);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/calendar/events');
+    });
+    it('updateEvent() → PATCH /calendar/events/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 'ev1' }));
+        const client = setup();
+        await client.calendar.updateEvent('ev1', { title: 'Updated' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('PATCH');
+        expect(new URL(url).pathname).toBe('/calendar/events/ev1');
+    });
+    it('deleteEvent() → DELETE /calendar/events/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.calendar.deleteEvent('ev1');
+        expect(fetchMock.mock.calls[0][1].method).toBe('DELETE');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/calendar/events/ev1');
+    });
+    it('exportIcs() → GET /calendar/export.ics with rawResponse', async () => {
+        const fakeResponse = { ok: true, status: 200, text: () => 'ics-data' };
+        fetchMock.mockResolvedValueOnce(fakeResponse);
+        const client = setup();
+        const result = await client.calendar.exportIcs({ start: '2026-01-01', end: '2026-12-31' });
+        expect(result).toBe(fakeResponse);
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/calendar/export.ics');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: AI
+// ---------------------------------------------------------------------------
+describe('AIResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('chat() → POST /ai/chat', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ conversationId: 'c1', content: 'hi', tokensUsed: 10 }));
+        const client = setup();
+        await client.ai.chat({ message: 'hello' });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/ai/chat');
+        expect(JSON.parse(init.body)).toEqual({ message: 'hello' });
+    });
+    it('generate() → POST /ai/generate', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ content: '...', tokensUsed: 5 }));
+        const client = setup();
+        await client.ai.generate({ title: 'Feature X' });
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/ai/generate');
+        expect(fetchMock.mock.calls[0][1].method).toBe('POST');
+    });
+    it('estimate() → POST /ai/estimate', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ storyPoints: 5, confidence: 0.8, reasoning: 'ok' }));
+        const client = setup();
+        await client.ai.estimate({ title: 'Task', description: 'Desc' });
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/ai/estimate');
+    });
+    it('insights() → GET /ai/insights?projectId=x', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ content: 'insight', tokensUsed: 3 }));
+        const client = setup();
+        await client.ai.insights({ projectId: 'p1' });
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.pathname).toBe('/ai/insights');
+        expect(url.searchParams.get('projectId')).toBe('p1');
+        expect(fetchMock.mock.calls[0][1].method).toBe('GET');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Notifications
+// ---------------------------------------------------------------------------
+describe('NotificationsResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('list() → GET /notifications', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: [], unreadCount: 0 }));
+        const client = setup();
+        await client.notifications.list();
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/notifications');
+    });
+    it('list({ unreadOnly: true }) passes query param', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ data: [], unreadCount: 0 }));
+        const client = setup();
+        await client.notifications.list({ unreadOnly: true });
+        const url = new URL(fetchMock.mock.calls[0][0]);
+        expect(url.searchParams.get('unreadOnly')).toBe('true');
+    });
+    it('markRead() → POST /notifications/:id/read', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.notifications.markRead('n1');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/notifications/n1/read');
+    });
+    it('markAllRead() → POST /notifications/read-all', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.notifications.markAllRead();
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/notifications/read-all');
+    });
+});
+// ---------------------------------------------------------------------------
+// Resource: Tokens
+// ---------------------------------------------------------------------------
+describe('TokensResource', () => {
+    const BASE = 'https://api.omniq.pro';
+    function setup() {
+        return new OmniqClient({ baseUrl: BASE, token: 'tok' });
+    }
+    it('list() → GET /tokens', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse([]));
+        const client = setup();
+        await client.tokens.list();
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/tokens');
+        expect(fetchMock.mock.calls[0][1].method).toBe('GET');
+    });
+    it('create() → POST /tokens', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse({ id: 't1', token: 'omniq_xxx' }));
+        const client = setup();
+        await client.tokens.create({ name: 'CI', scopes: ['read'] });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(init.method).toBe('POST');
+        expect(new URL(url).pathname).toBe('/tokens');
+        expect(JSON.parse(init.body)).toEqual({ name: 'CI', scopes: ['read'] });
+    });
+    it('delete() → DELETE /tokens/:id', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(null, 204));
+        const client = setup();
+        await client.tokens.delete('t1');
+        expect(fetchMock.mock.calls[0][1].method).toBe('DELETE');
+        expect(new URL(fetchMock.mock.calls[0][0]).pathname).toBe('/tokens/t1');
+    });
+});
+//# sourceMappingURL=client.test.js.map