chore: remove cashed

frontend/src/api/__tests__/certificates.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import client from '../client';
+import { getCertificates, uploadCertificate, deleteCertificate, Certificate } from '../certificates';
+
+vi.mock('../client', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    delete: vi.fn(),
+  },
+}));
+
+describe('certificates API', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const mockCert: Certificate = {
+    id: 1,
+    domain: 'example.com',
+    issuer: 'Let\'s Encrypt',
+    expires_at: '2023-01-01',
+    status: 'valid',
+    provider: 'letsencrypt',
+  };
+
+  it('getCertificates calls client.get', async () => {
+    vi.mocked(client.get).mockResolvedValue({ data: [mockCert] });
+    const result = await getCertificates();
+    expect(client.get).toHaveBeenCalledWith('/certificates');
+    expect(result).toEqual([mockCert]);
+  });
+
+  it('uploadCertificate calls client.post with FormData', async () => {
+    vi.mocked(client.post).mockResolvedValue({ data: mockCert });
+    const certFile = new File(['cert'], 'cert.pem', { type: 'text/plain' });
+    const keyFile = new File(['key'], 'key.pem', { type: 'text/plain' });
+
+    const result = await uploadCertificate('My Cert', certFile, keyFile);
+
+    expect(client.post).toHaveBeenCalledWith('/certificates', expect.any(FormData), {
+      headers: { 'Content-Type': 'multipart/form-data' },
+    });
+    expect(result).toEqual(mockCert);
+  });
+
+  it('deleteCertificate calls client.delete', async () => {
+    vi.mocked(client.delete).mockResolvedValue({ data: {} });
+    await deleteCertificate(1);
+    expect(client.delete).toHaveBeenCalledWith('/certificates/1');
+  });
+});

frontend/src/api/__tests__/domains.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import client from '../client';
+import { getDomains, createDomain, deleteDomain, Domain } from '../domains';
+
+vi.mock('../client', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    delete: vi.fn(),
+  },
+}));
+
+describe('domains API', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const mockDomain: Domain = {
+    id: 1,
+    uuid: '123',
+    name: 'example.com',
+    created_at: '2023-01-01',
+  };
+
+  it('getDomains calls client.get', async () => {
+    vi.mocked(client.get).mockResolvedValue({ data: [mockDomain] });
+    const result = await getDomains();
+    expect(client.get).toHaveBeenCalledWith('/domains');
+    expect(result).toEqual([mockDomain]);
+  });
+
+  it('createDomain calls client.post', async () => {
+    vi.mocked(client.post).mockResolvedValue({ data: mockDomain });
+    const result = await createDomain('example.com');
+    expect(client.post).toHaveBeenCalledWith('/domains', { name: 'example.com' });
+    expect(result).toEqual(mockDomain);
+  });
+
+  it('deleteDomain calls client.delete', async () => {
+    vi.mocked(client.delete).mockResolvedValue({ data: {} });
+    await deleteDomain('123');
+    expect(client.delete).toHaveBeenCalledWith('/domains/123');
+  });
+});

frontend/src/api/__tests__/proxyHosts.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import client from '../client';
+import {
+  getProxyHosts,
+  getProxyHost,
+  createProxyHost,
+  updateProxyHost,
+  deleteProxyHost,
+  testProxyHostConnection,
+  ProxyHost
+} from '../proxyHosts';
+
+vi.mock('../client', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+  },
+}));
+
+describe('proxyHosts API', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const mockHost: ProxyHost = {
+    uuid: '123',
+    domain_names: 'example.com',
+    forward_scheme: 'http',
+    forward_host: 'localhost',
+    forward_port: 8080,
+    ssl_forced: true,
+    http2_support: true,
+    hsts_enabled: true,
+    hsts_subdomains: false,
+    block_exploits: false,
+    websocket_support: false,
+    locations: [],
+    enabled: true,
+    created_at: '2023-01-01',
+    updated_at: '2023-01-01',
+  };
+
+  it('getProxyHosts calls client.get', async () => {
+    vi.mocked(client.get).mockResolvedValue({ data: [mockHost] });
+    const result = await getProxyHosts();
+    expect(client.get).toHaveBeenCalledWith('/proxy-hosts');
+    expect(result).toEqual([mockHost]);
+  });
+
+  it('getProxyHost calls client.get with uuid', async () => {
+    vi.mocked(client.get).mockResolvedValue({ data: mockHost });
+    const result = await getProxyHost('123');
+    expect(client.get).toHaveBeenCalledWith('/proxy-hosts/123');
+    expect(result).toEqual(mockHost);
+  });
+
+  it('createProxyHost calls client.post', async () => {
+    vi.mocked(client.post).mockResolvedValue({ data: mockHost });
+    const newHost = { domain_names: 'example.com' };
+    const result = await createProxyHost(newHost);
+    expect(client.post).toHaveBeenCalledWith('/proxy-hosts', newHost);
+    expect(result).toEqual(mockHost);
+  });
+
+  it('updateProxyHost calls client.put', async () => {
+    vi.mocked(client.put).mockResolvedValue({ data: mockHost });
+    const updates = { enabled: false };
+    const result = await updateProxyHost('123', updates);
+    expect(client.put).toHaveBeenCalledWith('/proxy-hosts/123', updates);
+    expect(result).toEqual(mockHost);
+  });
+
+  it('deleteProxyHost calls client.delete', async () => {
+    vi.mocked(client.delete).mockResolvedValue({ data: {} });
+    await deleteProxyHost('123');
+    expect(client.delete).toHaveBeenCalledWith('/proxy-hosts/123');
+  });
+
+  it('testProxyHostConnection calls client.post', async () => {
+    vi.mocked(client.post).mockResolvedValue({ data: {} });
+    await testProxyHostConnection('localhost', 8080);
+    expect(client.post).toHaveBeenCalledWith('/proxy-hosts/test', {
+      forward_host: 'localhost',
+      forward_port: 8080,
+    });
+  });
+});

frontend/src/api/__tests__/system.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import client from '../client'
+import { checkUpdates, getNotifications, markNotificationRead, markAllNotificationsRead } from '../system'
+
+vi.mock('../client', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+  },
+}))
+
+describe('System API', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('checkUpdates calls /system/updates', async () => {
+    const mockData = { available: true, latest_version: '1.0.0', changelog_url: 'url' }
+    vi.mocked(client.get).mockResolvedValue({ data: mockData })
+
+    const result = await checkUpdates()
+
+    expect(client.get).toHaveBeenCalledWith('/system/updates')
+    expect(result).toEqual(mockData)
+  })
+
+  it('getNotifications calls /notifications', async () => {
+    const mockData = [{ id: '1', title: 'Test' }]
+    vi.mocked(client.get).mockResolvedValue({ data: mockData })
+
+    const result = await getNotifications()
+
+    expect(client.get).toHaveBeenCalledWith('/notifications', { params: { unread: false } })
+    expect(result).toEqual(mockData)
+  })
+
+  it('getNotifications calls /notifications with unreadOnly=true', async () => {
+    const mockData = [{ id: '1', title: 'Test' }]
+    vi.mocked(client.get).mockResolvedValue({ data: mockData })
+
+    const result = await getNotifications(true)
+
+    expect(client.get).toHaveBeenCalledWith('/notifications', { params: { unread: true } })
+    expect(result).toEqual(mockData)
+  })
+
+  it('markNotificationRead calls /notifications/:id/read', async () => {
+    vi.mocked(client.post).mockResolvedValue({})
+
+    await markNotificationRead('123')
+
+    expect(client.post).toHaveBeenCalledWith('/notifications/123/read')
+  })
+
+  it('markAllNotificationsRead calls /notifications/read-all', async () => {
+    vi.mocked(client.post).mockResolvedValue({})
+
+    await markAllNotificationsRead()
+
+    expect(client.post).toHaveBeenCalledWith('/notifications/read-all')
+  })
+})