@masonator/coolify-mcp 0.1.0 → 0.1.1

package/dist/__tests__/coolify-client.test.js

@@ -198,128 +198,272 @@ describe('CoolifyClient', () => {
     describe('Environment Management', () => {
         const mockEnvironment = {
             id: 1,
-            uuid: 'env-test-id',
-            name: 'test-env',
-            project_uuid: 'project-test-id',
-            variables: { KEY: 'value' },
-            created_at: '2024-03-19T12:00:00Z',
-            updated_at: '2024-03-19T12:00:00Z',
+            uuid: 'jw0gwo4sowkoowswssk0gkc4',
+            name: 'production',
+            project_uuid: 'ikokwc8sk00wk8sg8gkwoscw',
+            created_at: '2025-02-11T11:37:33.000000Z',
+            updated_at: '2025-02-11T11:37:33.000000Z',
         };
         beforeEach(() => {
             mockFetch.mockClear();
         });
-        describe('listEnvironments', () => {
-            it('should fetch all environments successfully', async () => {
+        describe('getProjectEnvironment', () => {
+            it('should fetch environment by project UUID and name/UUID successfully', async () => {
                 mockFetch.mockResolvedValueOnce({
                     ok: true,
-                    json: () => Promise.resolve([mockEnvironment]),
+                    json: () => Promise.resolve(mockEnvironment),
                 });
-                const result = await client.listEnvironments();
-                expect(result).toEqual([mockEnvironment]);
-                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/environments', expect.objectContaining({
+                const result = await client.getProjectEnvironment('ikokwc8sk00wk8sg8gkwoscw', 'production');
+                expect(result).toEqual(mockEnvironment);
+                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/projects/ikokwc8sk00wk8sg8gkwoscw/production', expect.objectContaining({
                     headers: expect.objectContaining({
                         Authorization: 'Bearer test-token',
                         'Content-Type': 'application/json',
                     }),
                 }));
             });
-            it('should fetch environments by project UUID', async () => {
+            it('should handle not found error', async () => {
+                const errorResponse = {
+                    error: 'Not Found',
+                    status: 404,
+                    message: 'Environment not found',
+                };
                 mockFetch.mockResolvedValueOnce({
-                    ok: true,
-                    json: () => Promise.resolve([mockEnvironment]),
+                    ok: false,
+                    json: () => Promise.resolve(errorResponse),
                 });
-                const result = await client.listEnvironments('project-test-id');
-                expect(result).toEqual([mockEnvironment]);
-                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/environments?project_uuid=project-test-id', expect.objectContaining({
-                    headers: expect.objectContaining({
-                        Authorization: 'Bearer test-token',
-                        'Content-Type': 'application/json',
-                    }),
-                }));
+                await expect(client.getProjectEnvironment('invalid-project', 'invalid-env')).rejects.toThrow('Environment not found');
             });
         });
-        describe('getEnvironment', () => {
-            it('should fetch environment by UUID successfully', async () => {
-                mockFetch.mockResolvedValueOnce({
-                    ok: true,
-                    json: () => Promise.resolve(mockEnvironment),
-                });
-                const result = await client.getEnvironment('env-test-id');
-                expect(result).toEqual(mockEnvironment);
-                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/environments/env-test-id', expect.objectContaining({
-                    headers: expect.objectContaining({
-                        Authorization: 'Bearer test-token',
-                        'Content-Type': 'application/json',
-                    }),
-                }));
+    });
+    describe('deployApplication', () => {
+        it('should deploy an application', async () => {
+            const mockDeployment = {
+                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',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockDeployment),
             });
+            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('createEnvironment', () => {
-            it('should create environment successfully', async () => {
-                const createRequest = {
-                    name: 'test-env',
-                    project_uuid: 'project-test-id',
-                    variables: { KEY: 'value' },
-                };
-                const mockResponse = { uuid: 'env-test-id' };
-                mockFetch.mockResolvedValueOnce({
-                    ok: true,
-                    json: () => Promise.resolve(mockResponse),
-                });
-                const result = await client.createEnvironment(createRequest);
-                expect(result).toEqual(mockResponse);
-                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/environments', expect.objectContaining({
-                    method: 'POST',
-                    body: JSON.stringify(createRequest),
-                    headers: expect.objectContaining({
-                        Authorization: 'Bearer test-token',
-                        'Content-Type': 'application/json',
-                    }),
-                }));
+        it('should handle errors when deploying an application', async () => {
+            const errorResponse = {
+                error: 'Error',
+                status: 500,
+                message: 'Failed to deploy application',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                json: () => Promise.resolve(errorResponse),
             });
+            await expect(client.deployApplication('test-app-uuid')).rejects.toThrow('Failed to deploy application');
         });
-        describe('updateEnvironmentVariables', () => {
-            it('should update environment variables successfully', async () => {
-                const updateRequest = {
-                    variables: { NEW_KEY: 'new-value' },
-                };
-                const mockUpdatedEnvironment = {
-                    ...mockEnvironment,
-                    variables: updateRequest.variables,
-                };
-                mockFetch.mockResolvedValueOnce({
-                    ok: true,
-                    json: () => Promise.resolve(mockUpdatedEnvironment),
-                });
-                const result = await client.updateEnvironmentVariables('env-test-id', updateRequest);
-                expect(result).toEqual(mockUpdatedEnvironment);
-                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/environments/env-test-id/variables', expect.objectContaining({
-                    method: 'PUT',
-                    body: JSON.stringify(updateRequest),
-                    headers: expect.objectContaining({
-                        Authorization: 'Bearer test-token',
-                        'Content-Type': 'application/json',
-                    }),
-                }));
+    });
+    describe('Database Management', () => {
+        const mockDatabase = {
+            id: 1,
+            uuid: 'test-db-uuid',
+            name: 'test-db',
+            description: 'Test database',
+            type: 'postgresql',
+            status: 'running',
+            created_at: '2024-03-06T12:00:00Z',
+            updated_at: '2024-03-06T12:00:00Z',
+            is_public: false,
+            image: 'postgres:latest',
+            postgres_user: 'postgres',
+            postgres_password: 'test123',
+            postgres_db: 'testdb',
+        };
+        beforeEach(() => {
+            mockFetch.mockClear();
+        });
+        it('should list databases', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve([mockDatabase]),
             });
+            const result = await client.listDatabases();
+            expect(result).toEqual([mockDatabase]);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/databases', expect.objectContaining({
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
         });
-        describe('deleteEnvironment', () => {
-            it('should delete environment successfully', async () => {
-                const mockResponse = { message: 'Environment deleted successfully' };
-                mockFetch.mockResolvedValueOnce({
-                    ok: true,
-                    json: () => Promise.resolve(mockResponse),
-                });
-                const result = await client.deleteEnvironment('env-test-id');
-                expect(result).toEqual(mockResponse);
-                expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/environments/env-test-id', expect.objectContaining({
-                    method: 'DELETE',
-                    headers: expect.objectContaining({
-                        Authorization: 'Bearer test-token',
-                        'Content-Type': 'application/json',
-                    }),
-                }));
+        it('should get database details', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockDatabase),
+            });
+            const result = await client.getDatabase('test-db-uuid');
+            expect(result).toEqual(mockDatabase);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/databases/test-db-uuid', expect.objectContaining({
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should update database', async () => {
+            const updateData = {
+                name: 'updated-db',
+                description: 'Updated description',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ ...mockDatabase, ...updateData }),
+            });
+            const result = await client.updateDatabase('test-db-uuid', updateData);
+            expect(result).toEqual({ ...mockDatabase, ...updateData });
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/databases/test-db-uuid', expect.objectContaining({
+                method: 'PATCH',
+                body: JSON.stringify(updateData),
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should delete database', async () => {
+            const mockResponse = { message: 'Database deleted' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockResponse),
+            });
+            const result = await client.deleteDatabase('test-db-uuid', {
+                deleteConfigurations: true,
+                deleteVolumes: true,
             });
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/databases/test-db-uuid?delete_configurations=true&delete_volumes=true', expect.objectContaining({
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should handle database errors', async () => {
+            const errorMessage = 'Database not found';
+            mockFetch.mockRejectedValue(new Error(errorMessage));
+            await expect(client.getDatabase('invalid-uuid')).rejects.toThrow(errorMessage);
+        });
+    });
+    describe('Service Management', () => {
+        const mockService = {
+            id: 1,
+            uuid: 'test-service-uuid',
+            name: 'test-service',
+            description: 'Test service',
+            type: 'code-server',
+            status: 'running',
+            created_at: '2024-03-06T12:00:00Z',
+            updated_at: '2024-03-06T12:00:00Z',
+            project_uuid: 'test-project-uuid',
+            environment_name: 'production',
+            environment_uuid: 'test-env-uuid',
+            server_uuid: 'test-server-uuid',
+            domains: ['test-service.example.com'],
+        };
+        beforeEach(() => {
+            mockFetch.mockClear();
+        });
+        it('should list services', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve([mockService]),
+            });
+            const result = await client.listServices();
+            expect(result).toEqual([mockService]);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/services', expect.objectContaining({
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should get service details', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockService),
+            });
+            const result = await client.getService('test-service-uuid');
+            expect(result).toEqual(mockService);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/services/test-service-uuid', expect.objectContaining({
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should create service', async () => {
+            const createData = {
+                type: 'code-server',
+                name: 'test-service',
+                description: 'Test service',
+                project_uuid: 'test-project-uuid',
+                environment_name: 'production',
+                server_uuid: 'test-server-uuid',
+                instant_deploy: true,
+            };
+            const mockResponse = {
+                uuid: 'test-service-uuid',
+                domains: ['test-service.example.com'],
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockResponse),
+            });
+            const result = await client.createService(createData);
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/services', expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify(createData),
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should delete service', async () => {
+            const mockResponse = { message: 'Service deleted' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockResponse),
+            });
+            const result = await client.deleteService('test-service-uuid', {
+                deleteConfigurations: true,
+                deleteVolumes: true,
+            });
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('http://test.coolify.io/api/v1/services/test-service-uuid?delete_configurations=true&delete_volumes=true', expect.objectContaining({
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test-token',
+                },
+            }));
+        });
+        it('should handle service errors', async () => {
+            const errorMessage = 'Service not found';
+            mockFetch.mockRejectedValue(new Error(errorMessage));
+            await expect(client.getService('invalid-uuid')).rejects.toThrow(errorMessage);
         });
     });
 });

package/dist/__tests__/mcp-server.test.js

@@ -118,10 +118,11 @@ describe('CoolifyMcpServer', () => {
             const mockEnvironment = {
                 id: 1,
                 uuid: 'test-env-uuid',
-                name: 'test-environment',
+                name: 'test-env',
                 project_uuid: 'test-project-uuid',
-                created_at: '2024-03-19T12:00:00Z',
-                updated_at: '2024-03-19T12:00:00Z',
+                variables: { KEY: 'value' },
+                created_at: '2024-03-06T12:00:00Z',
+                updated_at: '2024-03-06T12:00:00Z',
             };
             const spy = globals_1.jest
                 .spyOn(server['client'], 'getProjectEnvironment')
@@ -130,80 +131,154 @@ describe('CoolifyMcpServer', () => {
             expect(spy).toHaveBeenCalledWith('test-project-uuid', 'test-env-uuid');
         });
     });
-    describe('Environment Management', () => {
-        const mockEnvironment = {
+    describe('deploy_application', () => {
+        it('should deploy an application', async () => {
+            const mockDeployment = {
+                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',
+            };
+            globals_1.jest.spyOn(server['client'], 'deployApplication').mockResolvedValue(mockDeployment);
+            const result = await server.deploy_application({ uuid: 'test-app-uuid' });
+            expect(result).toEqual(mockDeployment);
+            expect(server['client'].deployApplication).toHaveBeenCalledWith('test-app-uuid');
+        });
+        it('should handle errors when deploying an application', async () => {
+            const error = new Error('Failed to deploy application');
+            globals_1.jest.spyOn(server['client'], 'deployApplication').mockRejectedValue(error);
+            await expect(server.deploy_application({ uuid: 'test-app-uuid' })).rejects.toThrow('Failed to deploy application');
+        });
+    });
+    describe('Database Management', () => {
+        const mockDatabase = {
             id: 1,
-            uuid: 'test-env-uuid',
-            name: 'test-environment',
-            project_uuid: 'test-project-uuid',
-            variables: { KEY: 'value' },
-            created_at: '2024-03-19T12:00:00Z',
-            updated_at: '2024-03-19T12:00:00Z',
+            uuid: 'test-db-uuid',
+            name: 'test-db',
+            description: 'Test database',
+            type: 'postgresql',
+            status: 'running',
+            created_at: '2024-03-06T12:00:00Z',
+            updated_at: '2024-03-06T12:00:00Z',
+            is_public: false,
+            image: 'postgres:latest',
+            postgres_user: 'postgres',
+            postgres_password: 'test123',
+            postgres_db: 'testdb',
         };
-        describe('list_environments', () => {
-            it('should call client listEnvironments without project UUID', async () => {
-                const spy = globals_1.jest
-                    .spyOn(server['client'], 'listEnvironments')
-                    .mockResolvedValue([mockEnvironment]);
-                await server.list_environments({});
-                expect(spy).toHaveBeenCalledWith(undefined);
-            });
-            it('should call client listEnvironments with project UUID', async () => {
-                const spy = globals_1.jest
-                    .spyOn(server['client'], 'listEnvironments')
-                    .mockResolvedValue([mockEnvironment]);
-                await server.list_environments({ project_uuid: 'test-project-uuid' });
-                expect(spy).toHaveBeenCalledWith('test-project-uuid');
-            });
+        it('should list databases', async () => {
+            const spy = globals_1.jest.spyOn(server['client'], 'listDatabases').mockResolvedValue([mockDatabase]);
+            const result = await server.list_databases();
+            expect(result).toEqual([mockDatabase]);
+            expect(spy).toHaveBeenCalled();
         });
-        describe('get_environment', () => {
-            it('should call client getEnvironment', async () => {
-                const spy = globals_1.jest
-                    .spyOn(server['client'], 'getEnvironment')
-                    .mockResolvedValue(mockEnvironment);
-                await server.get_environment({ uuid: 'test-env-uuid' });
-                expect(spy).toHaveBeenCalledWith('test-env-uuid');
-            });
+        it('should get database details', async () => {
+            const spy = globals_1.jest.spyOn(server['client'], 'getDatabase').mockResolvedValue(mockDatabase);
+            const result = await server.get_database('test-db-uuid');
+            expect(result).toEqual(mockDatabase);
+            expect(spy).toHaveBeenCalledWith('test-db-uuid');
         });
-        describe('create_environment', () => {
-            it('should call client createEnvironment', async () => {
-                const createRequest = {
-                    name: 'test-environment',
-                    project_uuid: 'test-project-uuid',
-                    variables: { KEY: 'value' },
-                };
-                const mockResponse = { uuid: 'test-env-uuid' };
-                const spy = globals_1.jest
-                    .spyOn(server['client'], 'createEnvironment')
-                    .mockResolvedValue(mockResponse);
-                await server.create_environment(createRequest);
-                expect(spy).toHaveBeenCalledWith(createRequest);
+        it('should update database', async () => {
+            const updateData = {
+                name: 'updated-db',
+                description: 'Updated description',
+            };
+            const spy = globals_1.jest
+                .spyOn(server['client'], 'updateDatabase')
+                .mockResolvedValue({ ...mockDatabase, ...updateData, type: 'postgresql' });
+            const result = await server.update_database('test-db-uuid', updateData);
+            expect(result).toEqual({
+                ...mockDatabase,
+                ...updateData,
+                type: 'postgresql',
             });
+            expect(spy).toHaveBeenCalledWith('test-db-uuid', updateData);
         });
-        describe('update_environment_variables', () => {
-            it('should call client updateEnvironmentVariables', async () => {
-                const updateRequest = {
-                    variables: { NEW_KEY: 'new-value' },
-                };
-                const spy = globals_1.jest
-                    .spyOn(server['client'], 'updateEnvironmentVariables')
-                    .mockResolvedValue({ ...mockEnvironment, variables: updateRequest.variables });
-                await server.update_environment_variables({
-                    uuid: 'test-env-uuid',
-                    variables: updateRequest.variables,
-                });
-                expect(spy).toHaveBeenCalledWith('test-env-uuid', updateRequest);
+        it('should delete database', async () => {
+            const mockResponse = { message: 'Database deleted' };
+            const spy = globals_1.jest.spyOn(server['client'], 'deleteDatabase').mockResolvedValue(mockResponse);
+            const result = await server.delete_database('test-db-uuid', {
+                deleteConfigurations: true,
+                deleteVolumes: true,
+            });
+            expect(result).toEqual(mockResponse);
+            expect(spy).toHaveBeenCalledWith('test-db-uuid', {
+                deleteConfigurations: true,
+                deleteVolumes: true,
             });
         });
-        describe('delete_environment', () => {
-            it('should call client deleteEnvironment', async () => {
-                const mockResponse = { message: 'Environment deleted successfully' };
-                const spy = globals_1.jest
-                    .spyOn(server['client'], 'deleteEnvironment')
-                    .mockResolvedValue(mockResponse);
-                await server.delete_environment({ uuid: 'test-env-uuid' });
-                expect(spy).toHaveBeenCalledWith('test-env-uuid');
+        it('should handle database errors', async () => {
+            const errorMessage = 'Database not found';
+            globals_1.jest.spyOn(server['client'], 'getDatabase').mockRejectedValue(new Error(errorMessage));
+            await expect(server.get_database('invalid-uuid')).rejects.toThrow(errorMessage);
+        });
+    });
+    describe('Service Management', () => {
+        const mockService = {
+            id: 1,
+            uuid: 'test-service-uuid',
+            name: 'test-service',
+            description: 'Test service',
+            type: 'code-server',
+            status: 'running',
+            created_at: '2024-03-06T12:00:00Z',
+            updated_at: '2024-03-06T12:00:00Z',
+            project_uuid: 'test-project-uuid',
+            environment_name: 'production',
+            environment_uuid: 'test-env-uuid',
+            server_uuid: 'test-server-uuid',
+            domains: ['test-service.example.com'],
+        };
+        it('should list services', async () => {
+            const spy = globals_1.jest.spyOn(server['client'], 'listServices').mockResolvedValue([mockService]);
+            const result = await server.list_services();
+            expect(result).toEqual([mockService]);
+            expect(spy).toHaveBeenCalled();
+        });
+        it('should get service details', async () => {
+            const spy = globals_1.jest.spyOn(server['client'], 'getService').mockResolvedValue(mockService);
+            const result = await server.get_service('test-service-uuid');
+            expect(result).toEqual(mockService);
+            expect(spy).toHaveBeenCalledWith('test-service-uuid');
+        });
+        it('should create service', async () => {
+            const createData = {
+                type: 'code-server',
+                name: 'test-service',
+                description: 'Test service',
+                project_uuid: 'test-project-uuid',
+                environment_name: 'production',
+                server_uuid: 'test-server-uuid',
+                instant_deploy: true,
+            };
+            const mockResponse = {
+                uuid: 'test-service-uuid',
+                domains: ['test-service.example.com'],
+            };
+            const spy = globals_1.jest.spyOn(server['client'], 'createService').mockResolvedValue(mockResponse);
+            const result = await server.create_service(createData);
+            expect(result).toEqual(mockResponse);
+            expect(spy).toHaveBeenCalledWith(createData);
+        });
+        it('should delete service', async () => {
+            const mockResponse = { message: 'Service deleted' };
+            const spy = globals_1.jest.spyOn(server['client'], 'deleteService').mockResolvedValue(mockResponse);
+            const result = await server.delete_service('test-service-uuid', {
+                deleteConfigurations: true,
+                deleteVolumes: true,
+            });
+            expect(result).toEqual(mockResponse);
+            expect(spy).toHaveBeenCalledWith('test-service-uuid', {
+                deleteConfigurations: true,
+                deleteVolumes: true,
             });
         });
+        it('should handle service errors', async () => {
+            const errorMessage = 'Service not found';
+            globals_1.jest.spyOn(server['client'], 'getService').mockRejectedValue(new Error(errorMessage));
+            await expect(server.get_service('invalid-uuid')).rejects.toThrow(errorMessage);
+        });
     });
 });

package/dist/__tests__/resources/application-resources.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/resources/application-resources.test.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const application_resources_js_1 = require("../../resources/application-resources.js");
+const coolify_client_js_1 = require("../../lib/coolify-client.js");
+jest.mock('../../lib/coolify-client.js');
+describe('ApplicationResources', () => {
+    let resources;
+    let mockClient;
+    beforeEach(() => {
+        mockClient = new coolify_client_js_1.CoolifyClient({
+            baseUrl: 'http://test.coolify.io',
+            accessToken: 'test-token',
+        });
+        resources = new application_resources_js_1.ApplicationResources(mockClient);
+    });
+    describe('listApplications', () => {
+        it('should throw not implemented error', async () => {
+            await expect(resources.listApplications()).rejects.toThrow('Not implemented');
+        });
+    });
+    describe('getApplication', () => {
+        it('should throw not implemented error', async () => {
+            await expect(resources.getApplication('test-id')).rejects.toThrow('Not implemented');
+        });
+    });
+    describe('createApplication', () => {
+        it('should throw not implemented error', async () => {
+            await expect(resources.createApplication({ name: 'test-app' })).rejects.toThrow('Not implemented');
+        });
+    });
+    describe('deleteApplication', () => {
+        it('should throw not implemented error', async () => {
+            await expect(resources.deleteApplication('test-id')).rejects.toThrow('Not implemented');
+        });
+    });
+});