@nestbox-ai/cli 1.0.48 → 1.0.49

package/test/document.test.ts

@@ -1,217 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerDocumentCommands } from '../src/commands/document';
-
-describe('Document Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerDocumentCommands', () => {
-    it('should register document command group', () => {
-      registerDocumentCommands(program);
-
-      const commands = program.commands;
-      const documentCommand = commands.find(cmd => cmd.name() === 'document');
-
-      expect(documentCommand).toBeDefined();
-      expect(documentCommand?.description()).toBe('Manage Nestbox documents');
-    });
-
-    it('should register doc subcommand group', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const subCommands = documentCommand?.commands || [];
-      const docCommand = subCommands.find(cmd => cmd.name() === 'doc');
-
-      expect(docCommand).toBeDefined();
-      expect(docCommand?.description()).toBe('Manage individual documents');
-    });
-
-    it('should register collection subcommand group', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const subCommands = documentCommand?.commands || [];
-      const collectionCommand = subCommands.find(cmd => cmd.name() === 'collection');
-
-      expect(collectionCommand).toBeDefined();
-      expect(collectionCommand?.description()).toBe('Manage document collections');
-    });
-
-    it('should register doc list subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
-      const collectionSubCommands = collectionCommand?.commands || [];
-      const listCommand = collectionSubCommands.find(cmd => cmd.name() === 'list');
-
-      expect(listCommand).toBeDefined();
-      expect(listCommand?.description()).toBe('List document collections for a specific instance');
-      
-      // Check options
-      const options = listCommand?.options || [];
-      const instanceOption = options.find(opt => opt.long === '--instance');
-      const projectOption = options.find(opt => opt.long === '--project');
-      
-      expect(instanceOption).toBeDefined();
-      expect(projectOption).toBeDefined();
-    });
-
-    it('should register doc create subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
-      const collectionSubCommands = collectionCommand?.commands || [];
-      const createCommand = collectionSubCommands.find(cmd => cmd.name() === 'create');
-
-      expect(createCommand).toBeDefined();
-      expect(createCommand?.description()).toBe('Create a new document collection for a specific instance');
-      
-      // Check options
-      const options = createCommand?.options || [];
-      const instanceOption = options.find(opt => opt.long === '--instance');
-      const projectOption = options.find(opt => opt.long === '--project');
-      
-      expect(instanceOption).toBeDefined();
-      expect(projectOption).toBeDefined();
-    });
-
-    it('should register doc get subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const docSubCommands = docCommand?.commands || [];
-      const getCommand = docSubCommands.find(cmd => cmd.name() === 'get');
-
-      expect(getCommand).toBeDefined();
-      expect(getCommand?.description()).toBe('Get a document from a collection');
-      
-      // Arguments are part of the command definition, not in args array
-      expect(getCommand?.name()).toBe('get');
-    });
-
-    it('should register doc delete subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const docSubCommands = docCommand?.commands || [];
-      const deleteCommand = docSubCommands.find(cmd => cmd.name() === 'delete');
-
-      expect(deleteCommand).toBeDefined();
-      expect(deleteCommand?.description()).toBe('Delete a document from a collection');
-      
-      // Arguments are part of the command definition, not in args array
-      expect(deleteCommand?.name()).toBe('delete');
-    });
-
-    it('should register doc update subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const docSubCommands = docCommand?.commands || [];
-      const updateCommand = docSubCommands.find(cmd => cmd.name() === 'update');
-
-      expect(updateCommand).toBeDefined();
-      expect(updateCommand?.description()).toBe('Update a document in a collection');
-      
-      // Arguments are part of the command definition, not in args array
-      expect(updateCommand?.name()).toBe('update');
-    });
-
-    it('should register collection add subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const docSubCommands = docCommand?.commands || [];
-      const addCommand = docSubCommands.find(cmd => cmd.name() === 'add');
-
-      expect(addCommand).toBeDefined();
-      expect(addCommand?.description()).toBe('Add a new document to a collection');
-      
-      // Check options
-      const options = addCommand?.options || [];
-      const instanceOption = options.find(opt => opt.long === '--instance');
-      const collectionOption = options.find(opt => opt.long === '--collection');
-      
-      expect(instanceOption).toBeDefined();
-      expect(collectionOption).toBeDefined();
-    });
-
-    it('should register collection search subcommand', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const docSubCommands = docCommand?.commands || [];
-      const searchCommand = docSubCommands.find(cmd => cmd.name() === 'search');
-
-      expect(searchCommand).toBeDefined();
-      expect(searchCommand?.description()).toBe('Search for documents in a collection');
-      
-      // Check arguments and options
-      expect(searchCommand?.name()).toBe('search');
-    });
-
-    it('should have all expected doc subcommands', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const docSubCommandNames = docCommand?.commands.map(cmd => cmd.name()) || [];
-      
-      expect(docSubCommandNames).toContain('add');
-      expect(docSubCommandNames).toContain('get');
-      expect(docSubCommandNames).toContain('delete');
-      expect(docSubCommandNames).toContain('update');
-      expect(docSubCommandNames).toContain('upload-file');
-      expect(docSubCommandNames).toContain('search');
-      expect(docSubCommandNames).toHaveLength(6);
-    });
-
-    it('should have all expected collection subcommands', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
-      const collectionSubCommandNames = collectionCommand?.commands.map(cmd => cmd.name()) || [];
-      
-      expect(collectionSubCommandNames).toContain('list');
-      expect(collectionSubCommandNames).toContain('create');
-      expect(collectionSubCommandNames).toContain('get');
-      expect(collectionSubCommandNames).toContain('delete');
-      expect(collectionSubCommandNames).toContain('update');
-      expect(collectionSubCommandNames).toHaveLength(5);
-    });
-
-    it('should have proper action functions for all subcommands', () => {
-      registerDocumentCommands(program);
-
-      const documentCommand = program.commands.find(cmd => cmd.name() === 'document');
-      const docCommand = documentCommand?.commands.find(cmd => cmd.name() === 'doc');
-      const collectionCommand = documentCommand?.commands.find(cmd => cmd.name() === 'collection');
-      
-      // Check doc subcommands
-      const docSubCommands = docCommand?.commands || [];
-      docSubCommands.forEach(cmd => {
-        expect(typeof cmd.action).toBe('function');
-      });
-
-      // Check collection subcommands
-      const collectionSubCommands = collectionCommand?.commands || [];
-      collectionSubCommands.forEach(cmd => {
-        expect(typeof cmd.action).toBe('function');
-      });
-    });
-  });
-});

package/test/generate.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerGenerateCommands } from '../src/commands/generate';
-
-describe('Generate Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerGenerateCommands', () => {
-    it('should register generate command group', () => {
-      registerGenerateCommands(program);
-
-      const commands = program.commands;
-      const generateCommand = commands.find(cmd => cmd.name() === 'generate');
-
-      expect(generateCommand).toBeDefined();
-      expect(generateCommand?.description()).toBe('Generate new projects and components');
-    });
-
-    it('should register generate project subcommand', () => {
-      registerGenerateCommands(program);
-
-      const generateCommand = program.commands.find(cmd => cmd.name() === 'generate');
-      const subCommands = generateCommand?.commands || [];
-      const projectCommand = subCommands.find(cmd => cmd.name() === 'project');
-
-      expect(projectCommand).toBeDefined();
-      expect(projectCommand?.description()).toBe('Generate a new project from templates');
-      
-      // Check that folder is an argument (it's in command name: "project <folder>")
-      expect(projectCommand?.name()).toBe('project');
-      
-      // Check options
-      const options = projectCommand?.options || [];
-      const langOption = options.find(opt => opt.long === '--lang');
-      const templateOption = options.find(opt => opt.long === '--template');
-      const nameOption = options.find(opt => opt.long === '--name');
-      const projectOption = options.find(opt => opt.long === '--project');
-      
-      expect(langOption).toBeDefined();
-      expect(langOption?.description).toBe('Project language (ts|js)');
-      
-      expect(templateOption).toBeDefined();
-      expect(templateOption?.description).toBe('Template type (agent|chatbot)');
-      
-      expect(nameOption).toBeDefined();
-      expect(nameOption?.description).toBe('Agent/Chatbot name (must be a valid function name)');
-      
-      expect(projectOption).toBeDefined();
-      expect(projectOption?.description).toBe('Project ID');
-    });
-
-    it('should contain expected subcommands', () => {
-      registerGenerateCommands(program);
-
-      const generateCommand = program.commands.find(cmd => cmd.name() === 'generate');
-      const subCommands = generateCommand?.commands || [];
-      const subCommandNames = subCommands.map(cmd => cmd.name());
-
-      expect(subCommandNames).toContain('project');
-    });
-  });
-});

package/test/image.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerImageCommands } from '../src/commands/image';
-
-describe('Image Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerImageCommands', () => {
-    it('should register image command group', () => {
-      registerImageCommands(program);
-
-      const commands = program.commands;
-      const imageCommand = commands.find(cmd => cmd.name() === 'image');
-
-      expect(imageCommand).toBeDefined();
-      expect(imageCommand?.description()).toBe('Manage Nestbox images');
-    });
-
-    it('should register image list subcommand', () => {
-      registerImageCommands(program);
-
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      const subCommands = imageCommand?.commands || [];
-      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
-
-      expect(listCommand).toBeDefined();
-      expect(listCommand?.description()).toBe('List images for a project');
-      
-      // Check options
-      const options = listCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      expect(projectOption).toBeDefined();
-      expect(projectOption?.description).toBe('Project ID or name (defaults to the current project)');
-    });
-
-    it('should have all expected image subcommands', () => {
-      registerImageCommands(program);
-
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      const subCommandNames = imageCommand?.commands.map(cmd => cmd.name()) || [];
-      
-      expect(subCommandNames).toContain('list');
-      expect(subCommandNames).toHaveLength(1);
-    });
-
-    it('should have proper action functions for all subcommands', () => {
-      registerImageCommands(program);
-
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      const subCommands = imageCommand?.commands || [];
-      
-      subCommands.forEach(cmd => {
-        expect(typeof cmd.action).toBe('function');
-      });
-    });
-
-    it('should register image list command with correct structure', () => {
-      registerImageCommands(program);
-
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      const listCommand = imageCommand?.commands.find(cmd => cmd.name() === 'list');
-      
-      expect(listCommand?.name()).toBe('list');
-      expect(listCommand?.description()).toBe('List images for a project');
-      expect(typeof listCommand?.action).toBe('function');
-    });
-
-    it('should have project option with correct configuration', () => {
-      registerImageCommands(program);
-
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      const listCommand = imageCommand?.commands.find(cmd => cmd.name() === 'list');
-      const options = listCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      
-      expect(projectOption).toBeDefined();
-      expect(projectOption?.description).toBe('Project ID or name (defaults to the current project)');
-      expect(projectOption?.long).toBe('--project');
-    });
-
-    it('should properly initialize when auth token is available', () => {
-      // This test verifies that the command registration doesn't fail when auth token is available
-      expect(() => {
-        registerImageCommands(program);
-      }).not.toThrow();
-      
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      expect(imageCommand).toBeDefined();
-    });
-
-    it('should handle the case when createApis function is called within command actions', () => {
-      registerImageCommands(program);
-
-      const imageCommand = program.commands.find(cmd => cmd.name() === 'image');
-      const listCommand = imageCommand?.commands.find(cmd => cmd.name() === 'list');
-      
-      // Verify that the action function exists and is callable
-      expect(listCommand?.action).toBeDefined();
-      expect(typeof listCommand?.action).toBe('function');
-    });
-  });
-});

package/test/mocks.ts

@@ -1,122 +0,0 @@
-import { vi } from 'vitest';
-
-// Mock external dependencies that are commonly used across all test files
-export const setupCommonMocks = () => {
-  // Mock utils/error
-  vi.mock('../src/utils/error', () => ({
-    withTokenRefresh: vi.fn(),
-    handle401Error: vi.fn()
-  }));
-
-  // Mock utils/auth
-  vi.mock('../src/utils/auth', () => ({
-    getAuthToken: vi.fn().mockReturnValue({
-      token: 'mock-token',
-      serverUrl: 'http://localhost:3000'
-    }),
-    listCredentials: vi.fn(),
-    removeCredentials: vi.fn()
-  }));
-
-  // Mock @nestbox-ai/admin
-  vi.mock('@nestbox-ai/admin', () => ({
-    Configuration: vi.fn(),
-    AuthApi: vi.fn(),
-    ProjectsApi: vi.fn(),
-    MachineAgentApi: vi.fn(),
-    MachineInstancesApi: vi.fn(),
-    MiscellaneousApi: vi.fn(),
-    DocumentsApi: vi.fn(),
-    OAuthLoginRequestDTOTypeEnum: {}
-  }));
-
-  // Mock utils/project
-  vi.mock('../src/utils/project', () => ({
-    resolveProject: vi.fn()
-  }));
-
-  // Mock utils/agent
-  vi.mock('../src/utils/agent', () => ({
-    createNestboxConfig: vi.fn(),
-    createZipFromDirectory: vi.fn(),
-    extractZip: vi.fn(),
-    findProjectRoot: vi.fn(),
-    isTypeScriptProject: vi.fn(),
-    loadNestboxConfig: vi.fn(),
-    runPredeployScripts: vi.fn()
-  }));
-
-  // Mock utils/user
-  vi.mock('../src/utils/user', () => ({
-    userData: vi.fn()
-  }));
-
-  // Mock chalk
-  vi.mock('chalk', () => ({
-    default: {
-      green: vi.fn((text) => text),
-      red: vi.fn((text) => text),
-      yellow: vi.fn((text) => text),
-      blue: vi.fn((text) => text)
-    }
-  }));
-
-  // Mock ora
-  vi.mock('ora', () => ({
-    default: vi.fn(() => ({
-      start: vi.fn().mockReturnThis(),
-      succeed: vi.fn().mockReturnThis(),
-      fail: vi.fn().mockReturnThis(),
-      text: ''
-    }))
-  }));
-
-  // Mock cli-table3
-  vi.mock('cli-table3', () => ({
-    default: vi.fn()
-  }));
-
-  // Mock inquirer
-  vi.mock('inquirer', () => ({
-    default: {
-      prompt: vi.fn()
-    }
-  }));
-
-  // Mock fs
-  vi.mock('fs', () => ({
-    default: {
-      existsSync: vi.fn(),
-      readFileSync: vi.fn(),
-      writeFileSync: vi.fn()
-    }
-  }));
-
-  // Mock yaml
-  vi.mock('yaml', () => ({
-    default: {
-      load: vi.fn()
-    }
-  }));
-
-  // Mock axios
-  vi.mock('axios', () => ({
-    default: {
-      get: vi.fn(),
-      post: vi.fn()
-    }
-  }));
-
-  // Mock open
-  vi.mock('open', () => ({
-    default: vi.fn()
-  }));
-
-  // Mock path
-  vi.mock('path', () => ({
-    default: {
-      join: vi.fn(),
-      resolve: vi.fn()
-    }
-  }));
-};

package/test/project.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerProjectCommands } from '../src/commands/project';
-
-describe('Project Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerProjectCommands', () => {
-    it('should register project command group', () => {
-      registerProjectCommands(program);
-
-      const commands = program.commands;
-      const projectCommand = commands.find(cmd => cmd.name() === 'project');
-
-      expect(projectCommand).toBeDefined();
-      expect(projectCommand?.description()).toBe('Manage Nestbox projects');
-    });
-
-    it('should register project use subcommand', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const subCommands = projectCommand?.commands || [];
-      const useCommand = subCommands.find(cmd => cmd.name() === 'use');
-
-      expect(useCommand).toBeDefined();
-      expect(useCommand?.description()).toBe('Set default project for all commands');
-      
-      // The command uses a required argument <project-name> which is part of the command definition
-      expect(useCommand?.name()).toBe('use');
-    });
-
-    it('should register project add subcommand', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const subCommands = projectCommand?.commands || [];
-      const addCommand = subCommands.find(cmd => cmd.name() === 'add');
-
-      expect(addCommand).toBeDefined();
-      expect(addCommand?.description()).toBe('Add a project with optional alias');
-      
-      // The command uses required and optional arguments which are part of the command definition
-      expect(addCommand?.name()).toBe('add');
-    });
-
-    it('should register project list subcommand', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const subCommands = projectCommand?.commands || [];
-      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
-
-      expect(listCommand).toBeDefined();
-      expect(listCommand?.description()).toBe('List all projects');
-    });
-
-    it('should have all expected project subcommands', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const subCommandNames = projectCommand?.commands.map(cmd => cmd.name()) || [];
-      
-      expect(subCommandNames).toContain('use');
-      expect(subCommandNames).toContain('add');
-      expect(subCommandNames).toContain('list');
-      expect(subCommandNames).toHaveLength(3);
-    });
-
-    it('should have proper action functions for all commands', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const subCommands = projectCommand?.commands || [];
-      
-      subCommands.forEach(cmd => {
-        expect(typeof cmd.action).toBe('function');
-      });
-    });
-
-    it('should register project use command with correct structure', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const useCommand = projectCommand?.commands.find(cmd => cmd.name() === 'use');
-      
-      expect(useCommand?.name()).toBe('use');
-      expect(useCommand?.description()).toBe('Set default project for all commands');
-      expect(typeof useCommand?.action).toBe('function');
-    });
-
-    it('should register project add command with correct structure', () => {
-      registerProjectCommands(program);
-
-      const projectCommand = program.commands.find(cmd => cmd.name() === 'project');
-      const addCommand = projectCommand?.commands.find(cmd => cmd.name() === 'add');
-      
-      expect(addCommand?.name()).toBe('add');
-      expect(addCommand?.description()).toBe('Add a project with optional alias');
-      expect(typeof addCommand?.action).toBe('function');
-    });
-  });
-});