@nexical/cli 0.1.7 → 0.10.0

package/test/integration/commands/branch/get.test.ts

@@ -1,49 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import BranchesGetCommand from '../../../../src/commands/branch/get.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('BranchesGetCommand Integration', () => {
-    let command: BranchesGetCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            branches: {
-                get: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new BranchesGetCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should get branch details successfully', async () => {
-        mockClient.branches.get.mockResolvedValue({
-            id: '100',
-            name: 'integration-main',
-            previewUrl: 'http://int.com'
-        });
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '100' });
-
-        expect(mockClient.branches.get).toHaveBeenCalledWith(1, 2, 100);
-        expect(command.info).toHaveBeenCalledWith('Branch Details:');
-        expect(command.info).toHaveBeenCalledWith('  ID:   100');
-        expect(command.info).toHaveBeenCalledWith('  Name: integration-main');
-    });
-
-    it('should handle get failure', async () => {
-        mockClient.branches.get.mockRejectedValue(new Error('Not found'));
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '100' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to get branch: Not found');
-    });
-});

package/test/integration/commands/branch/list.test.ts

@@ -1,47 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import BranchesListCommand from '../../../../src/commands/branch/list.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('BranchesListCommand Integration', () => {
-    let command: BranchesListCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            branches: {
-                list: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new BranchesListCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should list branches successfully', async () => {
-        mockClient.branches.list.mockResolvedValue([
-            { id: '100', name: 'integration-main' },
-            { id: '101', name: 'integration-dev' }
-        ]);
-
-        await command.run({ teamId: '1', projectId: '2' });
-
-        expect(mockClient.branches.list).toHaveBeenCalledWith(1, 2);
-        expect(command.info).toHaveBeenCalledWith('Branches for Project 2:');
-        expect(command.info).toHaveBeenCalledWith('- integration-main (ID: 100)');
-    });
-
-    it('should handle list failure', async () => {
-        mockClient.branches.list.mockRejectedValue(new Error('Network error'));
-
-        await command.run({ teamId: '1', projectId: '2' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to list branches: Network error');
-    });
-});

package/test/integration/commands/job/get.test.ts

@@ -1,54 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import JobsGetCommand from '../../../../src/commands/job/get.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('JobsGetCommand Integration', () => {
-    let command: JobsGetCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            jobs: {
-                get: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new JobsGetCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should get job details successfully', async () => {
-        mockClient.jobs.get.mockResolvedValue({
-            id: '123',
-            type: 'build',
-            status: 'success',
-            createdAt: '2023-01-01T00:00:00Z',
-            finishedAt: '2023-01-01T00:05:00Z',
-            startedAt: '2023-01-01T00:01:00Z',
-            completedAt: '2023-01-01T00:05:00Z',
-            queue: 'default'
-        });
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '123' });
-
-        expect(mockClient.jobs.get).toHaveBeenCalledWith(1, 2, 3, 123);
-        expect(command.info).toHaveBeenCalledWith('Job Details:');
-        expect(command.info).toHaveBeenCalledWith('  ID:      123');
-        expect(command.info).toHaveBeenCalledWith('  Status:  success');
-    });
-
-    it('should handle get failure', async () => {
-        mockClient.jobs.get.mockRejectedValue(new Error('Job not found'));
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '123' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to get job: Job not found');
-    });
-});

package/test/integration/commands/job/list.test.ts

@@ -1,47 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import JobsListCommand from '../../../../src/commands/job/list.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('JobsListCommand Integration', () => {
-    let command: JobsListCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            jobs: {
-                list: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new JobsListCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should list jobs successfully', async () => {
-        mockClient.jobs.list.mockResolvedValue([
-            { id: '101', status: 'running', type: 'build' },
-            { id: '102', status: 'pending', type: 'deploy' }
-        ]);
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
-
-        expect(mockClient.jobs.list).toHaveBeenCalledWith(1, 2, 3);
-        expect(command.info).toHaveBeenCalledWith('Jobs for Branch 3:');
-        expect(command.info).toHaveBeenCalledWith('101 - build [running] (Started: Waiting)');
-    });
-
-    it('should handle list failure', async () => {
-        mockClient.jobs.list.mockRejectedValue(new Error('Network error'));
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to list jobs: Network error');
-    });
-});

package/test/integration/commands/job/logs.test.ts

@@ -1,47 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import JobsLogsCommand from '../../../../src/commands/job/logs.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('JobsLogsCommand Integration', () => {
-    let command: JobsLogsCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            jobs: {
-                getLogs: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new JobsLogsCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should get job logs successfully', async () => {
-        mockClient.jobs.getLogs.mockResolvedValue([
-            { timestamp: '2023T12:00:00', level: 'info', message: 'Build started' },
-            { timestamp: '2023T12:01:00', level: 'error', message: 'Build failed' }
-        ]);
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '123' });
-
-        expect(mockClient.jobs.getLogs).toHaveBeenCalledWith(1, 2, 3, 123);
-        expect(command.info).toHaveBeenCalledWith(expect.stringContaining('Build started'));
-        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Build failed'));
-    });
-
-    it('should handle log failure', async () => {
-        mockClient.jobs.getLogs.mockRejectedValue(new Error('Logs unavailable'));
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', jobId: '123' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to get logs: Logs unavailable');
-    });
-});

package/test/integration/commands/job/trigger.test.ts

@@ -1,57 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import JobsTriggerCommand from '../../../../src/commands/job/trigger.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('JobsTriggerCommand Integration', () => {
-    let command: JobsTriggerCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            jobs: {
-                create: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new JobsTriggerCommand([], {} as any);
-        vi.spyOn(command, 'success').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should trigger job successfully', async () => {
-        mockClient.jobs.create.mockResolvedValue({ id: 'job-new' });
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', type: 'build' });
-
-        expect(mockClient.jobs.create).toHaveBeenCalledWith(1, 2, 3, {
-            type: 'build',
-            inputs: {},
-        });
-        expect(command.success).toHaveBeenCalledWith('Job job-new triggered successfully!');
-    });
-
-    it('should trigger job with input', async () => {
-        mockClient.jobs.create.mockResolvedValue({ id: 'job-new' });
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', type: 'deploy', input: '{"env":"prod"}' });
-
-        expect(mockClient.jobs.create).toHaveBeenCalledWith(1, 2, 3, {
-            type: 'deploy',
-            inputs: { env: 'prod' },
-        });
-    });
-
-    it('should handle trigger failure', async () => {
-        mockClient.jobs.create.mockRejectedValue(new Error('Quota exceeded'));
-
-        await command.run({ teamId: '1', projectId: '2', branchId: '3', type: 'build' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to trigger job: Quota exceeded');
-    });
-});

package/test/integration/commands/login.test.ts

@@ -1,62 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import LoginCommand from '../../../src/commands/login.js';
-import { getClient, saveToken } from '../../../src/utils/nexical-client.js';
-
-vi.mock('../../../src/utils/nexical-client.js');
-
-describe('LoginCommand Integration', () => {
-    let command: LoginCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            auth: {
-                authenticateDevice: vi.fn(),
-            },
-            users: {
-                me: vi.fn(),
-            },
-            setToken: vi.fn(),
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new LoginCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'notice').mockImplementation(() => { });
-        vi.spyOn(command, 'success').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should authenticate successfully', async () => {
-        mockClient.auth.authenticateDevice.mockImplementation(async (_clientId: string, callback: any) => {
-            callback('USER-CODE', 'https://verify.url');
-            return 'new-token';
-        });
-        mockClient.users.me.mockResolvedValue({ fullName: 'Integration User', email: 'int@example.com' });
-
-        await command.run();
-
-        expect(command.info).toHaveBeenCalledWith('Starting device authentication...');
-        expect(mockClient.auth.authenticateDevice).toHaveBeenCalledWith('nexical-cli', expect.any(Function));
-
-        expect(command.notice).toHaveBeenCalledWith('Please visit: https://verify.url');
-        expect(command.notice).toHaveBeenCalledWith('And enter code: USER-CODE');
-
-        expect(saveToken).toHaveBeenCalledWith('new-token');
-        expect(mockClient.setToken).toHaveBeenCalledWith('new-token');
-        expect(mockClient.users.me).toHaveBeenCalled();
-        expect(command.success).toHaveBeenCalledWith('Successfully logged in as Integration User (int@example.com)');
-    });
-
-    it('should handle authentication failure', async () => {
-        mockClient.auth.authenticateDevice.mockRejectedValue(new Error('Auth failed'));
-
-        await command.run();
-
-        expect(command.error).toHaveBeenCalledWith('Login failed: Auth failed');
-        expect(saveToken).not.toHaveBeenCalled();
-    });
-});

package/test/integration/commands/project/create.test.ts

@@ -1,53 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import ProjectsCreateCommand from '../../../../src/commands/project/create.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('ProjectsCreateCommand Integration', () => {
-    let command: ProjectsCreateCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            projects: {
-                create: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new ProjectsCreateCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'success').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should create project successfully', async () => {
-        mockClient.projects.create.mockResolvedValue({
-            name: 'New Project',
-            id: 'proj-1'
-        });
-
-        await command.run({ teamId: '1', name: 'New Project', repo: 'git@repo', prod: 'http://prod.com' });
-
-        expect(mockClient.projects.create).toHaveBeenCalledWith(1, {
-            name: 'New Project',
-            repoUrl: 'git@repo',
-            productionUrl: 'http://prod.com',
-            mode: undefined
-        });
-        expect(command.success).toHaveBeenCalledWith('Project "New Project" set up successfully!');
-        expect(command.info).toHaveBeenCalledWith('ID: proj-1');
-    });
-
-    it('should handle creation failure', async () => {
-        mockClient.projects.create.mockRejectedValue(new Error('Project exists'));
-
-        await command.run({ teamId: '1', name: 'New Project' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to create project: Project exists');
-    });
-});

package/test/integration/commands/project/delete.test.ts

@@ -1,43 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import ProjectsDeleteCommand from '../../../../src/commands/project/delete.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('ProjectsDeleteCommand Integration', () => {
-    let command: ProjectsDeleteCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            projects: {
-                delete: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new ProjectsDeleteCommand([], {} as any);
-        vi.spyOn(command, 'success').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should delete project successfully', async () => {
-        mockClient.projects.delete.mockResolvedValue({});
-
-        await command.run({ teamId: '1', projectId: '2', confirm: true });
-
-        expect(mockClient.projects.delete).toHaveBeenCalledWith(1, 2);
-        expect(command.success).toHaveBeenCalledWith('Project 2 deleted.');
-    });
-
-    it('should handle deletion failure', async () => {
-        mockClient.projects.delete.mockRejectedValue(new Error('Project not found'));
-
-        await command.run({ teamId: '1', projectId: '2', confirm: true });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to delete project: Project not found');
-    });
-});

package/test/integration/commands/project/get.test.ts

@@ -1,51 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import ProjectsGetCommand from '../../../../src/commands/project/get.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('ProjectsGetCommand Integration', () => {
-    let command: ProjectsGetCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            projects: {
-                get: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new ProjectsGetCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should get project details successfully', async () => {
-        mockClient.projects.get.mockResolvedValue({
-            id: '101',
-            name: 'My Project',
-            repoUrl: 'git@repo',
-            productionUrl: 'http://prod.com',
-            mode: 'full'
-        });
-
-        await command.run({ teamId: '1', projectId: '101' });
-
-        expect(mockClient.projects.get).toHaveBeenCalledWith(1, 101);
-        expect(command.info).toHaveBeenCalledWith('Project Details:');
-        expect(command.info).toHaveBeenCalledWith('  ID:   101');
-        expect(command.info).toHaveBeenCalledWith('  Name: My Project');
-    });
-
-    it('should handle get failure', async () => {
-        mockClient.projects.get.mockRejectedValue(new Error('Project not found'));
-
-        await command.run({ teamId: '1', projectId: '101' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to get project: Project not found');
-    });
-});

package/test/integration/commands/project/list.test.ts

@@ -1,47 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import ProjectsListCommand from '../../../../src/commands/project/list.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('ProjectsListCommand Integration', () => {
-    let command: ProjectsListCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            projects: {
-                list: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new ProjectsListCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should list projects successfully', async () => {
-        mockClient.projects.list.mockResolvedValue([
-            { id: '101', name: 'Project A' },
-            { id: '102', name: 'Project B' }
-        ]);
-
-        await command.run({ teamId: '1' });
-
-        expect(mockClient.projects.list).toHaveBeenCalledWith(1);
-        expect(command.info).toHaveBeenCalledWith('Projects in Team 1:');
-        expect(command.info).toHaveBeenCalledWith('- Project A (ID: 101) [No Repo]');
-    });
-
-    it('should handle list failure', async () => {
-        mockClient.projects.list.mockRejectedValue(new Error('Network error'));
-
-        await command.run({ teamId: '1' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to list projects: Network error');
-    });
-});

package/test/integration/commands/project/update.test.ts

@@ -1,53 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import ProjectsUpdateCommand from '../../../../src/commands/project/update.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('ProjectsUpdateCommand Integration', () => {
-    let command: ProjectsUpdateCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            projects: {
-                update: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new ProjectsUpdateCommand([], {} as any);
-        vi.spyOn(command, 'success').mockImplementation(() => { });
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-        vi.spyOn(command, 'warn').mockImplementation(() => { });
-    });
-
-    it('should update project successfully', async () => {
-        mockClient.projects.update.mockResolvedValue({
-            id: '101',
-            name: 'Updated Name',
-            repoUrl: 'git@newrepo'
-        });
-
-        await command.run({ teamId: '1', projectId: '101', name: 'Updated Name', repo: 'git@newrepo' });
-
-        expect(mockClient.projects.update).toHaveBeenCalledWith(1, 101, {
-            name: 'Updated Name',
-            repoUrl: 'git@newrepo',
-        });
-        expect(command.success).toHaveBeenCalledWith('Project 101 updated!');
-
-    });
-
-    it('should handle update failure', async () => {
-        mockClient.projects.update.mockRejectedValue(new Error('Update failed'));
-
-        await command.run({ teamId: '1', projectId: '101', name: 'New Name' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to update project: Update failed');
-    });
-});

package/test/integration/commands/team/create.test.ts

@@ -1,53 +0,0 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import TeamsCreateCommand from '../../../../src/commands/team/create.js';
-import { getClient } from '../../../../src/utils/nexical-client.js';
-
-vi.mock('../../../../src/utils/nexical-client.js');
-
-describe('TeamsCreateCommand Integration', () => {
-    let command: TeamsCreateCommand;
-    let mockClient: any;
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-
-        mockClient = {
-            teams: {
-                create: vi.fn(),
-            },
-        };
-        vi.mocked(getClient).mockReturnValue(mockClient);
-
-        command = new TeamsCreateCommand([], {} as any);
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.spyOn(command, 'success').mockImplementation(() => { });
-        vi.spyOn(command, 'error').mockImplementation(() => { });
-    });
-
-    it('should create team successfully', async () => {
-        mockClient.teams.create.mockResolvedValue({
-            name: 'New Team',
-            id: 'team-1',
-            slug: 'new-team'
-        });
-
-        await command.run({ name: 'New Team', slug: 'new-team' });
-
-        expect(mockClient.teams.create).toHaveBeenCalledWith({
-            name: 'New Team',
-            slug: 'new-team'
-        });
-        expect(command.success).toHaveBeenCalledWith('Team "New Team" created successfully!');
-        expect(command.info).toHaveBeenCalledWith('ID: team-1');
-        expect(command.info).toHaveBeenCalledWith('Slug: new-team');
-    });
-
-    it('should handle creation failure', async () => {
-        mockClient.teams.create.mockRejectedValue(new Error('Slug taken'));
-
-        await command.run({ name: 'New Team', slug: 'team' });
-
-        expect(command.error).toHaveBeenCalledWith('Failed to create team: Slug taken');
-    });
-});