fix: remove application management tests and fix deployment tests

Author: StuMason

src/__tests__/coolify-client.test.ts

@@ -3,8 +3,10 @@ import type {
   ServerInfo,
   ServerResources,
   Environment,
-  Application,
-  CreateApplicationRequest,
+  CoolifyConfig,
+  Deployment,
+  Project,
+  ResourceStatus,
 } from '../types/coolify.js';
 
 // Mock fetch globally
@@ -300,158 +302,51 @@ describe('CoolifyClient', () => {
     });
   });
 
-  describe('Application Management', () => {
-    const mockApplication: Application = {
-      id: 1,
-      uuid: 'test-app-uuid',
-      name: 'test-app',
-      environment_uuid: 'test-env-uuid',
-      project_uuid: 'test-project-uuid',
-      git_repository: 'https://github.com/test/repo',
-      git_branch: 'main',
-      build_pack: 'nixpacks',
-      ports_exposes: '3000',
-      status: 'running',
-      created_at: '2024-03-05T12:00:00Z',
-      updated_at: '2024-03-05T12:00:00Z',
-    };
-
-    describe('listApplications', () => {
-      it('should fetch all applications when no environment UUID is provided', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => [mockApplication],
-        });
-
-        const result = await client.listApplications();
-
-        expect(result).toEqual([mockApplication]);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications',
-          expect.objectContaining({
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
-      });
-
-      it('should fetch applications filtered by environment UUID', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => [mockApplication],
-        });
-
-        const result = await client.listApplications('test-env-uuid');
-
-        expect(result).toEqual([mockApplication]);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications?environment_uuid=test-env-uuid',
-          expect.objectContaining({
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
-      });
-    });
-
-    describe('getApplication', () => {
-      it('should fetch application details successfully', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockApplication,
-        });
-
-        const result = await client.getApplication('test-app-uuid');
+  describe('deployApplication', () => {
+    it('should deploy an application', async () => {
+      const mockDeployment: Deployment = {
+        id: 1,
+        uuid: 'test-deployment-uuid',
+        application_uuid: 'test-app-uuid',
+        status: 'running',
+        created_at: '2024-03-20T12:00:00Z',
+        updated_at: '2024-03-20T12:00:00Z',
+      };
 
-        expect(result).toEqual(mockApplication);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/test-app-uuid',
-          expect.objectContaining({
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockDeployment),
       });
-    });
-
-    describe('createApplication', () => {
-      it('should create a new application successfully', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockApplication,
-        });
 
-        const createRequest: CreateApplicationRequest = {
-          project_uuid: 'test-project-uuid',
-          environment_uuid: 'test-env-uuid',
-          git_repository: 'https://github.com/test/repo',
-          git_branch: 'main',
-          build_pack: 'nixpacks',
-          ports_exposes: '3000',
-          name: 'test-app',
-        };
-
-        const result = await client.createApplication(createRequest);
-
-        expect(result).toEqual(mockApplication);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/public',
-          expect.objectContaining({
-            method: 'POST',
-            body: JSON.stringify(createRequest),
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
+      const result = await client.deployApplication('test-app-uuid');
+      expect(result).toEqual(mockDeployment);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/applications/test-app-uuid/deploy',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-token',
+            'Content-Type': 'application/json',
           }),
-        );
-      });
+        }),
+      );
     });
 
-    describe('deleteApplication', () => {
-      it('should delete an application successfully', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => ({}),
-        });
-
-        await client.deleteApplication('test-app-uuid');
+    it('should handle errors when deploying an application', async () => {
+      const errorResponse = {
+        error: 'Error',
+        status: 500,
+        message: 'Failed to deploy application',
+      };
 
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/test-app-uuid',
-          expect.objectContaining({
-            method: 'DELETE',
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        json: () => Promise.resolve(errorResponse),
       });
-    });
 
-    describe('deployApplication', () => {
-      it('should make a POST request to deploy an application', async () => {
-        const mockDeployment = { id: 'test-deployment' };
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockDeployment,
-        });
-
-        const result = await client.deployApplication('test-app-uuid');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/test-app-uuid/deploy',
-          expect.objectContaining({
-            method: 'POST',
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
-        expect(result).toEqual(mockDeployment);
-      });
+      await expect(client.deployApplication('test-app-uuid')).rejects.toThrow(
+        'Failed to deploy application'
+      );
     });
   });
 });

src/__tests__/mcp-server.test.ts

@@ -5,9 +5,10 @@ import {
   ValidationResponse,
   Project,
   Environment,
-  Application,
-  CreateApplicationRequest,
   Deployment,
+  CoolifyConfig,
+  ResourceStatus,
+  ServerInfo,
 } from '../types/coolify.js';
 
 describe('CoolifyMcpServer', () => {
@@ -167,111 +168,34 @@ describe('CoolifyMcpServer', () => {
     });
   });
 
-  describe('Application Management', () => {
-    const mockApplication: Application = {
-      id: 1,
-      uuid: 'test-app-uuid',
-      name: 'test-app',
-      environment_uuid: 'test-env-uuid',
-      project_uuid: 'test-project-uuid',
-      git_repository: 'https://github.com/test/repo',
-      git_branch: 'main',
-      build_pack: 'nixpacks',
-      ports_exposes: '3000',
-      status: 'running',
-      created_at: '2024-03-05T12:00:00Z',
-      updated_at: '2024-03-05T12:00:00Z',
-    };
-
-    const mockDeployment: Deployment = {
-      id: 1,
-      uuid: 'test-deployment-uuid',
-      application_uuid: 'test-app-uuid',
-      status: 'in_progress',
-      created_at: '2024-03-05T12:00:00Z',
-      updated_at: '2024-03-05T12:00:00Z',
-    };
-
-    describe('list_applications', () => {
-      it('should call client listApplications', async () => {
-        const spy = jest
-          .spyOn(server['client'], 'listApplications')
-          .mockResolvedValue([mockApplication]);
-
-        const result = await server.list_applications();
-
-        expect(result).toEqual([mockApplication]);
-        expect(spy).toHaveBeenCalledWith(undefined);
-      });
-
-      it('should call client listApplications with environment UUID', async () => {
-        const spy = jest
-          .spyOn(server['client'], 'listApplications')
-          .mockResolvedValue([mockApplication]);
-
-        const result = await server.list_applications('test-env-uuid');
-
-        expect(result).toEqual([mockApplication]);
-        expect(spy).toHaveBeenCalledWith('test-env-uuid');
-      });
-    });
-
-    describe('get_application', () => {
-      it('should call client getApplication', async () => {
-        const spy = jest
-          .spyOn(server['client'], 'getApplication')
-          .mockResolvedValue(mockApplication);
-
-        const result = await server.get_application('test-app-uuid');
+  describe('deploy_application', () => {
+    it('should deploy an application', async () => {
+      const mockDeployment: Deployment = {
+        id: 1,
+        uuid: 'test-deployment-uuid',
+        application_uuid: 'test-app-uuid',
+        status: 'running',
+        created_at: '2024-03-20T12:00:00Z',
+        updated_at: '2024-03-20T12:00:00Z',
+      };
 
-        expect(result).toEqual(mockApplication);
-        expect(spy).toHaveBeenCalledWith('test-app-uuid');
-      });
-    });
+      jest
+        .spyOn(server['client'], 'deployApplication')
+        .mockResolvedValue(mockDeployment);
 
-    describe('create_application', () => {
-      it('should call client createApplication', async () => {
-        const spy = jest
-          .spyOn(server['client'], 'createApplication')
-          .mockResolvedValue(mockApplication);
-
-        const createRequest: CreateApplicationRequest = {
-          project_uuid: 'test-project-uuid',
-          environment_uuid: 'test-env-uuid',
-          git_repository: 'https://github.com/test/repo',
-          git_branch: 'main',
-          build_pack: 'nixpacks',
-          ports_exposes: '3000',
-          name: 'test-app',
-        };
-
-        const result = await server.create_application(createRequest);
-
-        expect(result).toEqual(mockApplication);
-        expect(spy).toHaveBeenCalledWith(createRequest);
-      });
+      const result = await server.deploy_application({ uuid: 'test-app-uuid' });
+      expect(result).toEqual(mockDeployment);
+      expect(server['client'].deployApplication).toHaveBeenCalledWith('test-app-uuid');
     });
 
-    describe('delete_application', () => {
-      it('should call client deleteApplication', async () => {
-        const spy = jest.spyOn(server['client'], 'deleteApplication').mockResolvedValue(undefined);
+    it('should handle errors when deploying an application', async () => {
+      const error = new Error('Failed to deploy application');
 
-        const result = await server.delete_application('test-app-uuid');
-
-        expect(result).toEqual({ message: 'Application deleted successfully' });
-        expect(spy).toHaveBeenCalledWith('test-app-uuid');
-      });
-    });
+      jest.spyOn(server['client'], 'deployApplication').mockRejectedValue(error);
 
-    describe('deploy_application', () => {
-      it('should call client deployApplication', async () => {
-        const spy = jest
-          .spyOn(server['client'], 'deployApplication')
-          .mockResolvedValue(mockDeployment);
-        const result = await server.deploy_application({ uuid: 'test-app-uuid' });
-        expect(spy).toHaveBeenCalledWith('test-app-uuid');
-        expect(result).toEqual(mockDeployment);
-      });
+      await expect(
+        server.deploy_application({ uuid: 'test-app-uuid' })
+      ).rejects.toThrow('Failed to deploy application');
     });
   });
 });