refactor: remove old test files for useProxyHosts and useRemoteServers; add new tests for useImport and update existing tests for useProxyHosts and useRemoteServers

2025-11-19 20:22:01 -05:00
parent 2f0058083e
commit 21eb2d2608
4 changed files with 10 additions and 5 deletions
@@ -0,0 +1,191 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { renderHook, waitFor, act } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import React from 'react'
+import { useProxyHosts } from '../useProxyHosts'
+import * as api from '../../services/api'
+
+// Mock the API
+vi.mock('../../services/api', () => ({
+  proxyHostsAPI: {
+    list: vi.fn(),
+    get: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+  },
+}))
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  })
+  return ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  )
+}
+
+describe('useProxyHosts', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('loads proxy hosts on mount', async () => {
+    const mockHosts = [
+      { uuid: '1', domain_names: 'test.com', enabled: true, forward_host: 'localhost', forward_port: 8080 },
+      { uuid: '2', domain_names: 'app.com', enabled: true, forward_host: 'localhost', forward_port: 3000 },
+    ]
+
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue(mockHosts)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    expect(result.current.loading).toBe(true)
+    expect(result.current.hosts).toEqual([])
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    expect(result.current.hosts).toEqual(mockHosts)
+    expect(result.current.error).toBeNull()
+    expect(api.proxyHostsAPI.list).toHaveBeenCalledOnce()
+  })
+
+  it('handles loading errors', async () => {
+    const mockError = new Error('Failed to fetch')
+    vi.mocked(api.proxyHostsAPI.list).mockRejectedValue(mockError)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    expect(result.current.error).toBe('Failed to fetch')
+    expect(result.current.hosts).toEqual([])
+  })
+
+  it('creates a new proxy host', async () => {
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue([])
+    const newHost = { domain_names: 'new.com', forward_host: 'localhost', forward_port: 9000 }
+    const createdHost = { uuid: '3', ...newHost, enabled: true }
+
+    vi.mocked(api.proxyHostsAPI.create).mockResolvedValue(createdHost)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    await act(async () => {
+      await result.current.createHost(newHost)
+    })
+
+    expect(api.proxyHostsAPI.create).toHaveBeenCalledWith(newHost)
+    await waitFor(() => {
+      expect(result.current.hosts).toContainEqual(createdHost)
+    })
+  })
+
+  it('updates an existing proxy host', async () => {
+    const existingHost = { uuid: '1', domain_names: 'test.com', enabled: true, forward_host: 'localhost', forward_port: 8080 }
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue([existingHost])
+
+    const updatedHost = { ...existingHost, domain_names: 'updated.com' }
+    vi.mocked(api.proxyHostsAPI.update).mockResolvedValue(updatedHost)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    await act(async () => {
+      await result.current.updateHost('1', { domain_names: 'updated.com' })
+    })
+
+    expect(api.proxyHostsAPI.update).toHaveBeenCalledWith('1', { domain_names: 'updated.com' })
+    await waitFor(() => {
+      expect(result.current.hosts[0].domain_names).toBe('updated.com')
+    })
+  })
+
+  it('deletes a proxy host', async () => {
+    const hosts = [
+      { uuid: '1', domain_names: 'test.com', enabled: true, forward_host: 'localhost', forward_port: 8080 },
+      { uuid: '2', domain_names: 'app.com', enabled: true, forward_host: 'localhost', forward_port: 3000 },
+    ]
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue(hosts)
+    vi.mocked(api.proxyHostsAPI.delete).mockResolvedValue(undefined)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    await act(async () => {
+      await result.current.deleteHost('1')
+    })
+
+    expect(api.proxyHostsAPI.delete).toHaveBeenCalledWith('1')
+    await waitFor(() => {
+      expect(result.current.hosts).toHaveLength(1)
+      expect(result.current.hosts[0].uuid).toBe('2')
+    })
+  })
+
+  it('handles create errors', async () => {
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue([])
+    const mockError = new Error('Failed to create')
+    vi.mocked(api.proxyHostsAPI.create).mockRejectedValue(mockError)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    await expect(result.current.createHost({ domain_names: 'test.com', forward_host: 'localhost', forward_port: 8080 })).rejects.toThrow('Failed to create')
+  })
+
+  it('handles update errors', async () => {
+    const host = { uuid: '1', domain_names: 'test.com', enabled: true, forward_host: 'localhost', forward_port: 8080 }
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue([host])
+    const mockError = new Error('Failed to update')
+    vi.mocked(api.proxyHostsAPI.update).mockRejectedValue(mockError)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    await expect(result.current.updateHost('1', { domain_names: 'updated.com' })).rejects.toThrow('Failed to update')
+  })
+
+  it('handles delete errors', async () => {
+    const host = { uuid: '1', domain_names: 'test.com', enabled: true, forward_host: 'localhost', forward_port: 8080 }
+    vi.mocked(api.proxyHostsAPI.list).mockResolvedValue([host])
+    const mockError = new Error('Failed to delete')
+    vi.mocked(api.proxyHostsAPI.delete).mockRejectedValue(mockError)
+
+    const { result } = renderHook(() => useProxyHosts(), { wrapper: createWrapper() })
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    await expect(result.current.deleteHost('1')).rejects.toThrow('Failed to delete')
+  })
+})