@manojkmfsi/monodog 1.1.35 → 1.1.37

package/monodog-dashboard/__tests__/api-client.test.ts

@@ -0,0 +1,475 @@
+/**
+ * API Client Tests
+ * Tests for ApiClient class: request handling, error handling, retries, interceptors
+ */
+
+import axios from 'axios';
+import ApiClient from '../src/services/api/api-client';
+import { cookieUtils } from '../src/utils/cookies';
+
+// Mock axios
+jest.mock('axios');
+
+describe('ApiClient', () => {
+  let mockAxiosInstance:  Record<string, jest.Mock|jest.MockedFunction<any>>;
+  let apiClient: ApiClient;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Mock axios.create
+    mockAxiosInstance = {
+      request: jest.fn(),
+      interceptors: {
+        request: { use: jest.fn() },
+        response: { use: jest.fn() },
+      },
+    };
+
+    (axios.create as jest.Mock).mockReturnValue(mockAxiosInstance);
+    // cast to unknown first to satisfy TS
+    ((axios.isAxiosError as unknown) as jest.Mock).mockImplementation(error => error && error.response);
+
+    apiClient = new ApiClient({ baseUrl: 'http://localhost:8999' });
+  });
+
+  describe('Constructor and Configuration', () => {
+    it('should create instance with default config', () => {
+      expect(axios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'http://localhost:8999',
+          timeout: 30000,
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+          }),
+          withCredentials: true,
+        })
+      );
+    });
+
+    it('should create instance with custom config', () => {
+      jest.clearAllMocks();
+      mockAxiosInstance = {
+        request: jest.fn(),
+        interceptors: {
+          request: { use: jest.fn() },
+          response: { use: jest.fn() },
+        },
+      };
+      (axios.create as jest.Mock).mockReturnValue(mockAxiosInstance);
+
+      const customClient = new ApiClient({
+        baseUrl: 'http://api.example.com',
+        timeout: 60000,
+        headers: { Authorization: 'Bearer token' },
+      });
+
+      expect(axios.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          baseURL: 'http://api.example.com',
+          timeout: 60000,
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer token',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('Authentication handling', () => {
+    it('registers request interceptor that adds Authorization header', () => {
+      const token = 'abc123';
+      jest.spyOn(cookieUtils, 'get').mockReturnValue(token);
+
+      // ensure interceptor was attached
+      expect(mockAxiosInstance.interceptors.request.use).toHaveBeenCalled();
+      const interceptorFn = mockAxiosInstance.interceptors.request.use.mock.calls[0][0];
+      const cfg = interceptorFn({ headers: {} });
+      expect(cfg.headers).toEqual(expect.objectContaining({ Authorization: `Bearer ${token}` }));
+    });
+
+    it('registers response interceptor that clears cookies on 401 errors', async () => {
+      jest.spyOn(cookieUtils, 'get').mockReturnValue('token');
+      const removeSpy = jest.spyOn(cookieUtils, 'remove');
+
+      // confirm interceptor attached
+      expect(mockAxiosInstance.interceptors.response.use).toHaveBeenCalled();
+      const errorHandler = mockAxiosInstance.interceptors.response.use.mock.calls[0][1];
+
+      const fakeError = { response: { status: 401 } };
+      await errorHandler(fakeError).catch(() => {});
+
+      expect(removeSpy).toHaveBeenCalledWith('monodog_session_token');
+      expect(removeSpy).toHaveBeenCalledWith('monodog_session_data');
+    });
+  });
+
+  describe('GET Request', () => {
+    it('should make successful GET request', async () => {
+      const mockResponse = {
+        data: { id: 1, name: 'Test' },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      };
+
+      mockAxiosInstance.request.mockResolvedValue(mockResponse);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(true);
+      expect((result).data).toEqual({ id: 1, name: 'Test' });
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'get',
+          url: '/api/test',
+        })
+      );
+    });
+
+    it('should include request config in GET request', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {},
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      await apiClient.get('/test', {
+        headers: { 'X-Custom': 'value' },
+        timeout: 5000,
+      });
+
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'get',
+          headers: { 'X-Custom': 'value' },
+          timeout: 5000,
+        })
+      );
+    });
+  });
+
+  describe('POST Request', () => {
+    it('should make successful POST request with body', async () => {
+      const mockResponse = {
+        data: { id: 1, name: 'Created' },
+        status: 201,
+        statusText: 'Created',
+        headers: {},
+      };
+
+      mockAxiosInstance.request.mockResolvedValue(mockResponse);
+
+      const result = await apiClient.post('/test', { name: 'Test' });
+
+      expect(result.success).toBe(true);
+      expect((result).data).toEqual({ id: 1, name: 'Created' });
+      expect(result.meta?.status).toBe(201);
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'post',
+          url: '/api/test',
+          data: { name: 'Test' },
+        })
+      );
+    });
+
+    it('should post without body', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {},
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      await apiClient.post('/test');
+
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'post',
+          url: '/api/test',
+          data: undefined,
+        })
+      );
+    });
+  });
+
+  describe('PUT Request', () => {
+    it('should make successful PUT request', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { id: 1, name: 'Updated' },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      const result = await apiClient.put('/test/1', { name: 'Updated' });
+
+      expect(result.success).toBe(true);
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'put',
+          url: '/api/test/1',
+          data: { name: 'Updated' },
+        })
+      );
+    });
+  });
+
+  describe('DELETE Request', () => {
+    it('should make successful DELETE request', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { success: true },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      const result = await apiClient.delete('/test/1');
+
+      expect(result.success).toBe(true);
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'delete',
+          url: '/api/test/1',
+        })
+      );
+    });
+  });
+
+  describe('PATCH Request', () => {
+    it('should make successful PATCH request', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { id: 1, status: 'active' },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      const result = await apiClient.patch('/test/1', { status: 'active' });
+
+      expect(result.success).toBe(true);
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'patch',
+          url: '/api/test/1',
+          data: { status: 'active' },
+        })
+      );
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle 400 validation error', async () => {
+      const error = {
+        response: {
+          status: 400,
+          statusText: 'Bad Request',
+          data: { error: 'Invalid input' },
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/VALIDATION/i);
+      expect((result).error?.status).toBe(400);
+    });
+
+    it('should handle 401 unauthorized error', async () => {
+      const error = {
+        response: {
+          status: 401,
+          statusText: 'Unauthorized',
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/UNAUTHORIZED/i);
+      expect((result).error?.status).toBe(401);
+    });
+
+    it('should handle 403 forbidden error', async () => {
+      const error = {
+        response: {
+          status: 403,
+          statusText: 'Forbidden',
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/FORBIDDEN/i);
+      expect((result).error?.status).toBe(403);
+    });
+
+    it('should handle 404 not found error', async () => {
+      const error = {
+        response: {
+          status: 404,
+          statusText: 'Not Found',
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/NOT_FOUND/i);
+      expect((result).error?.status).toBe(404);
+    });
+
+    it('should handle 408 timeout error', async () => {
+      const error = {
+        response: {
+          status: 408,
+          statusText: 'Request Timeout',
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/TIMEOUT/i);
+      expect((result).error?.status).toBe(408);
+    });
+
+    it('should handle 429 rate limit error', async () => {
+      const error = {
+        response: {
+          status: 429,
+          statusText: 'Too Many Requests',
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/RATE_LIMIT/i);
+      expect((result).error?.status).toBe(429);
+    });
+
+    it('should handle 500 server error', async () => {
+      const error = {
+        response: {
+          status: 500,
+          statusText: 'Internal Server Error',
+          headers: {},
+        },
+        config: {},
+      };
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/SERVER/i);
+      expect((result).error?.status).toBe(500);
+    });
+
+    it('should handle unknown non-axios errors', async () => {
+      const error = new Error('Network error');
+      ((axios.isAxiosError as unknown) as jest.Mock).mockReturnValue(false);
+
+      mockAxiosInstance.request.mockRejectedValue(error);
+
+      const result = await apiClient.get('/test');
+
+      expect(result.success).toBe(false);
+      expect((result).error?.code).toMatch(/UNKNOWN/i);
+      expect((result).error?.message).toBe('Network error');
+    });
+  });
+
+  describe('Response Metadata', () => {
+    it('should include timestamp and duration in response', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: { test: true },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'content-type': 'application/json' },
+      });
+
+      const result = await apiClient.get('/test');
+
+      expect(result.meta).toBeDefined();
+      expect(result.meta?.status).toBe(200);
+      expect(result.meta?.statusText).toBe('OK');
+      expect(result.meta?.timestamp).toBeDefined();
+      expect(result.meta?.duration).toBeDefined();
+      expect(typeof result.meta?.duration).toBe('number');
+    });
+
+    it('should include headers in response metadata', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {},
+        status: 200,
+        statusText: 'OK',
+        headers: { 'x-custom': 'value' },
+      });
+
+      const result = await apiClient.get('/test');
+
+      expect(result.meta?.headers).toEqual(expect.objectContaining({ 'x-custom': 'value' }));
+    });
+  });
+
+
+  describe('Endpoint Path Construction', () => {
+    it('should prepend /api to all endpoint paths', async () => {
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {},
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      await apiClient.get('/packages');
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({ url: '/api/packages' })
+      );
+
+      jest.clearAllMocks();
+      mockAxiosInstance.request.mockResolvedValue({
+        data: {},
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+      });
+
+      await apiClient.get('/auth/login');
+      expect(mockAxiosInstance.request).toHaveBeenCalledWith(
+        expect.objectContaining({ url: '/api/auth/login' })
+      );
+    });
+  });
+});

package/monodog-dashboard/__tests__/components.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Tests for dashboard component utilities and structure.
+ * These are basic unit tests that verify components can be imported and have expected structure.
+ */
+
+// Mock all components before using them
+jest.mock('../src/components/modules/packages/components/ConfigurationTab', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/modules/health-status/HealthStatus', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/modules/packages/PackagesOverview', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/modules/packages/PackageDetail', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/modules/dependency-graph/DependencyGraph', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/modules/ci-integration/CIIntegration', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/modules/config-inspector/ConfigInspector', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+jest.mock('../src/components/publish-control/PublishControl', () => ({
+  __esModule: true,
+  default: jest.fn(() => null),
+}));
+
+import ConfigurationTab from '../src/components/modules/packages/components/ConfigurationTab';
+import HealthStatus from '../src/components/modules/health-status/HealthStatus';
+import PackagesOverview from '../src/components/modules/packages/PackagesOverview';
+import PackageDetail from '../src/components/modules/packages/PackageDetail';
+import DependencyGraph from '../src/components/modules/dependency-graph/DependencyGraph';
+import CIIntegration from '../src/components/modules/ci-integration/CIIntegration';
+import ConfigInspector from '../src/components/modules/config-inspector/ConfigInspector';
+import PublishControl from '../src/components/publish-control/PublishControl';
+
+describe('Dashboard components exist', () => {
+  test('ConfigurationTab can be imported', () => {
+    // This verifies the file exists and can be imported
+    expect(ConfigurationTab).toBeDefined();
+    expect(typeof ConfigurationTab).toBe('function');
+  });
+
+  test('HealthStatus can be imported', () => {
+    expect(HealthStatus).toBeDefined();
+    expect(typeof HealthStatus).toBe('function');
+  });
+
+  test('PackagesOverview can be imported', () => {
+    expect(PackagesOverview).toBeDefined();
+    expect(typeof PackagesOverview).toBe('function');
+  });
+
+  test('PackageDetail can be imported', () => {
+    expect(PackageDetail).toBeDefined();
+    expect(typeof PackageDetail).toBe('function');
+  });
+
+  test('DependencyGraph can be imported', () => {
+    expect(DependencyGraph).toBeDefined();
+    expect(typeof DependencyGraph).toBe('function');
+  });
+
+  test('CIIntegration can be imported', () => {
+    expect(CIIntegration).toBeDefined();
+    expect(typeof CIIntegration).toBe('function');
+  });
+
+  test('ConfigInspector can be imported', () => {
+    expect(ConfigInspector).toBeDefined();
+    expect(typeof ConfigInspector).toBe('function');
+  });
+
+  test('PublishControl can be imported', () => {
+    expect(PublishControl).toBeDefined();
+    expect(typeof PublishControl).toBe('function');
+  });
+});
+
+describe('Dashboard components are React components', () => {
+  test('components are functions that can be called', () => {
+    const components = [
+      ConfigurationTab,
+      HealthStatus,
+      PackagesOverview,
+      PackageDetail,
+      DependencyGraph,
+      CIIntegration,
+      ConfigInspector,
+      PublishControl,
+    ];
+
+    components.forEach((component: any) => {
+      expect(typeof component).toBe('function');
+      expect(component).toBeDefined();
+    });
+  });
+});