chore: clean git cache

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

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { accessListsApi } from '../accessLists';
+import client from '../client';
+import type { AccessList } from '../accessLists';
+
+// Mock the client module
+vi.mock('../client', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+  },
+}));
+
+describe('accessListsApi', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('list', () => {
+    it('should fetch all access lists', async () => {
+      const mockLists: AccessList[] = [
+        {
+          id: 1,
+          uuid: 'test-uuid',
+          name: 'Test ACL',
+          description: 'Test description',
+          type: 'whitelist',
+          ip_rules: '[{"cidr":"192.168.1.0/24"}]',
+          country_codes: '',
+          local_network_only: false,
+          enabled: true,
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+        },
+      ];
+
+      vi.mocked(client.get).mockResolvedValueOnce({ data: mockLists });
+
+      const result = await accessListsApi.list();
+
+      expect(client.get).toHaveBeenCalledWith<[string]>('/access-lists');
+      expect(result).toEqual(mockLists);
+    });
+  });
+
+  describe('get', () => {
+    it('should fetch access list by ID', async () => {
+      const mockList: AccessList = {
+        id: 1,
+        uuid: 'test-uuid',
+        name: 'Test ACL',
+        description: 'Test description',
+        type: 'whitelist',
+        ip_rules: '[{"cidr":"192.168.1.0/24"}]',
+        country_codes: '',
+        local_network_only: false,
+        enabled: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+      };
+
+      vi.mocked(client.get).mockResolvedValueOnce({ data: mockList });
+
+      const result = await accessListsApi.get(1);
+
+      expect(client.get).toHaveBeenCalledWith<[string]>('/access-lists/1');
+      expect(result).toEqual(mockList);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new access list', async () => {
+      const newList = {
+        name: 'New ACL',
+        description: 'New description',
+        type: 'whitelist' as const,
+        ip_rules: '[{"cidr":"10.0.0.0/8"}]',
+        enabled: true,
+      };
+
+      const mockResponse: AccessList = {
+        id: 1,
+        uuid: 'new-uuid',
+        ...newList,
+        country_codes: '',
+        local_network_only: false,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+      };
+
+      vi.mocked(client.post).mockResolvedValueOnce({ data: mockResponse });
+
+      const result = await accessListsApi.create(newList);
+
+      expect(client.post).toHaveBeenCalledWith<[string, typeof newList]>('/access-lists', newList);
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('update', () => {
+    it('should update an access list', async () => {
+      const updates = {
+        name: 'Updated ACL',
+        enabled: false,
+      };
+
+      const mockResponse: AccessList = {
+        id: 1,
+        uuid: 'test-uuid',
+        name: 'Updated ACL',
+        description: 'Test description',
+        type: 'whitelist',
+        ip_rules: '[{"cidr":"192.168.1.0/24"}]',
+        country_codes: '',
+        local_network_only: false,
+        enabled: false,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+      };
+
+      vi.mocked(client.put).mockResolvedValueOnce({ data: mockResponse });
+
+      const result = await accessListsApi.update(1, updates);
+
+      expect(client.put).toHaveBeenCalledWith<[string, typeof updates]>('/access-lists/1', updates);
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete an access list', async () => {
+      vi.mocked(client.delete).mockResolvedValueOnce({ data: undefined });
+
+      await accessListsApi.delete(1);
+
+      expect(client.delete).toHaveBeenCalledWith<[string]>('/access-lists/1');
+    });
+  });
+
+  describe('testIP', () => {
+    it('should test an IP against an access list', async () => {
+      const mockResponse = {
+        allowed: true,
+        reason: 'IP matches whitelist rule',
+      };
+
+      vi.mocked(client.post).mockResolvedValueOnce({ data: mockResponse });
+
+      const result = await accessListsApi.testIP(1, '192.168.1.100');
+
+      expect(client.post).toHaveBeenCalledWith<[string, { ip_address: string }]>('/access-lists/1/test', {
+        ip_address: '192.168.1.100',
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getTemplates', () => {
+    it('should fetch access list templates', async () => {
+      const mockTemplates = [
+        {
+          name: 'Private Networks',
+          description: 'RFC1918 private networks',
+          type: 'whitelist' as const,
+          ip_rules: '[{"cidr":"10.0.0.0/8"},{"cidr":"172.16.0.0/12"},{"cidr":"192.168.0.0/16"}]',
+        },
+      ];
+
+      vi.mocked(client.get).mockResolvedValueOnce({ data: mockTemplates });
+
+      const result = await accessListsApi.getTemplates();
+
+      expect(client.get).toHaveBeenCalledWith<[string]>('/access-lists/templates');
+      expect(result).toEqual(mockTemplates);
+    });
+  });
+});