@nexical/cli 0.11.8 → 0.11.9

package/test/unit/deploy/providers/railway.test.ts

@@ -0,0 +1,328 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { RailwayProvider } from '../../../../src/deploy/providers/railway.js';
+import { execAsync } from '../../../../src/deploy/utils.js';
+import { logger } from '@nexical/cli-core';
+
+vi.mock('../../../../src/deploy/utils.js');
+vi.mock('@nexical/cli-core', () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+describe('RailwayProvider', () => {
+  let provider: RailwayProvider;
+  let mockContext: { cwd: string; options: Record<string, unknown>; config: any };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    provider = new RailwayProvider();
+    mockContext = {
+      cwd: '/mock',
+      options: {}, // Env undefined by default
+      config: { deploy: { backend: { projectName: 'my-proj' } } },
+    };
+    (execAsync as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      stdout: '',
+      stderr: '',
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    delete process.env.RAILWAY_API_TOKEN;
+    delete process.env.RAILWAY_TOKEN;
+    delete process.env.CUSTOM_RW_TOKEN;
+  });
+
+  describe('provision', () => {
+    it('should default to production environment if options.env is missing', async () => {
+      // mockContext.options.env is undefined
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'Linked',
+      }); // status
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'postgres',
+      }); // postgres check
+
+      await provider.provision(mockContext);
+
+      // Should stick to baseProjectName 'my-proj'
+      expect(execAsync).not.toHaveBeenCalledWith(
+        expect.stringContaining('my-proj-production'),
+        expect.anything(),
+      );
+    });
+
+    it('should error if project name missing', async () => {
+      mockContext.config.deploy.backend.projectName = undefined;
+      await expect(provider.provision(mockContext)).rejects.toThrow(
+        'Railway project name not found',
+      );
+    });
+
+    it('should handle dry run', async () => {
+      mockContext.options.dryRun = true;
+      await provider.provision(mockContext);
+      expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('[Dry Run]'));
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+
+    it('should handle deleted project', async () => {
+      // Use real Error to trigger 'instanceof Error' branch
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project is deleted' }),
+      );
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'Linked',
+      }); // init
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'postgres',
+      }); // postgres check
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith('railway unlink', expect.anything());
+    });
+
+    it('should handle unlink failure (deleted project)', async () => {
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project is deleted' }),
+      );
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        new Error('Unlink failed'),
+      ); // unlink fail
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'Linked',
+      }); // init
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'postgres',
+      }); // postgres check
+
+      await provider.provision(mockContext);
+      // Should proceed to init despite unlink fail
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('railway init'),
+        expect.anything(),
+      );
+    });
+
+    it('should check status and init if not linked', async () => {
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
+      );
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'Linked',
+      });
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'postgres',
+      });
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('railway init --name my-proj'),
+        expect.anything(),
+      );
+    });
+
+    it('should throw on auth failure', async () => {
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Unauthorized' }),
+      );
+
+      await expect(provider.provision(mockContext)).rejects.toThrow(
+        'Railway authentication failed',
+      );
+    });
+
+    it('should warn on generic status failure with Error object', async () => {
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        new Error('Timeout'),
+      ); // generic
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'postgres',
+      }); // postgres check pass
+
+      await provider.provision(mockContext);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Railway status check failed'),
+      );
+    });
+
+    it('should warn on generic status failure with string error', async () => {
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        'Timeout String',
+      );
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'postgres',
+      });
+
+      await provider.provision(mockContext);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Railway status check failed: Timeout String'),
+      );
+    });
+
+    it('should add postgres if missing', async () => {
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'ok',
+      }); // status ok
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'empty',
+      }); // postgres missing
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'db added',
+      }); // add db
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('railway add --database postgres'),
+        expect.anything(),
+      );
+    });
+
+    it('should handle second status check failure (swallow error)', async () => {
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'ok',
+      }); // status ok
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        new Error('Status2 fail'),
+      ); // status2 fail -> catch -> { stdout: '' }
+      // If stdout is empty, it proceeds to add postgres?
+      // Line 78: if (!status.includes('postgres')) -> '' doesn't include it -> true.
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'db added',
+      }); // add db
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('railway add --database postgres'),
+        expect.anything(),
+      );
+    });
+
+    it('should handle postgres status check failure (explicit throw in add logic check)', async () => {
+      // This tests the logic flow, but "Status2 fail" catch block return value triggers "add"
+      // My previous test above covers the catch block.
+    });
+
+    it('should warn if auto-add postgres fails', async () => {
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'ok',
+      }); // status ok
+      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
+        stdout: 'empty',
+      }); // postgres missing
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        new Error('Add failed'),
+      ); // add db fail
+
+      await provider.provision(mockContext);
+
+      expect(logger.warn).toHaveBeenCalledWith('Failed to auto-add PostgreSQL.');
+    });
+
+    it('should log generic setup failures', async () => {
+      const err = new Error('Generic failure') as any;
+      err.stderr = 'some stderr';
+      err.stdout = 'some stdout';
+
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
+      );
+      (execAsync as any).mockRejectedValueOnce(err);
+
+      await provider.provision(mockContext);
+
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Railway setup failed with error: Generic failure'),
+      );
+    });
+
+    it('should handle setup failure with empty output', async () => {
+      const errEmpty = new Error('Empty fail') as any;
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
+      );
+      (execAsync as any).mockRejectedValueOnce(errEmpty);
+
+      await provider.provision(mockContext);
+
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Railway setup failed with error: Empty fail'),
+      );
+    });
+
+    it('should handle non-Error exceptions in outer catch', async () => {
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
+      );
+      (execAsync as any).mockRejectedValueOnce('String setup error');
+
+      await provider.provision(mockContext);
+
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Railway setup failed with error: String setup error'),
+      );
+    });
+
+    it('should handle non-production environment', async () => {
+      mockContext.options.env = 'staging';
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
+      );
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('railway init --name my-proj-staging'),
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('getSecrets', () => {
+    it('should resolve token from env', async () => {
+      process.env.RAILWAY_API_TOKEN = 'tok';
+      const secrets = await provider.getSecrets(mockContext);
+      expect(secrets['RAILWAY_API_TOKEN']).toBe('tok');
+      delete process.env.RAILWAY_API_TOKEN;
+    });
+
+    it('should resolve token from configured env var', async () => {
+      mockContext.config.deploy.backend.options = { tokenEnvVar: 'CUSTOM_RW_TOKEN' };
+      process.env.CUSTOM_RW_TOKEN = 'custom-rw-tok';
+
+      const secrets = await provider.getSecrets(mockContext);
+      expect(secrets['RAILWAY_API_TOKEN']).toBe('custom-rw-tok');
+
+      delete process.env.CUSTOM_RW_TOKEN;
+    });
+
+    it('should error if token missing', async () => {
+      delete process.env.RAILWAY_API_TOKEN;
+      delete process.env.RAILWAY_TOKEN;
+      await expect(provider.getSecrets(mockContext)).rejects.toThrow('Railway Token not found');
+    });
+  });
+
+  describe('getVariables', () => {
+    it('should return empty', async () => {
+      expect(await provider.getVariables(mockContext)).toEqual({});
+    });
+  });
+
+  describe('getCIConfig', () => {
+    it('should return config', () => {
+      expect(provider.getCIConfig()).toHaveProperty('deploySteps');
+    });
+  });
+});

package/test/unit/deploy/registry.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ProviderRegistry } from '../../../src/deploy/registry.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { logger } from '@nexical/cli-core';
+
+vi.mock('node:fs/promises');
+vi.mock('@nexical/cli-core', () => ({
+  logger: {
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+  },
+}));
+
+// Mock jiti for local providers
+const mockJitiRequest = vi.fn();
+vi.mock('jiti', () => ({
+  createJiti: () => ({
+    import: mockJitiRequest,
+  }),
+}));
+
+describe('ProviderRegistry', () => {
+  let registry: ProviderRegistry;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    registry = new ProviderRegistry();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('getDeploymentProvider', () => {
+    it('should return undefined for non-existent provider', () => {
+      expect(registry.getDeploymentProvider('missing')).toBeUndefined();
+    });
+  });
+
+  describe('registerProviderFromModule', () => {
+    it('should register a valid deployment provider', () => {
+      const MockProvider = class {
+        name = 'valid-deploy';
+        provision() {}
+        getCIConfig() {}
+      };
+      (
+        registry as unknown as { registerProviderFromModule: (mod: any, name: string) => void }
+      ).registerProviderFromModule({ default: MockProvider }, 'test');
+      expect(registry.getDeploymentProvider('valid-deploy')).toBeDefined();
+    });
+
+    it('should register a valid repository provider', () => {
+      const MockProvider = class {
+        name = 'valid-repo';
+        configureSecrets() {}
+        generateWorkflow() {}
+      };
+      (
+        registry as unknown as { registerProviderFromModule: (mod: any, name: string) => void }
+      ).registerProviderFromModule({ default: MockProvider }, 'test');
+      expect(registry.getRepositoryProvider('valid-repo')).toBeDefined();
+    });
+
+    it('should handle named exports if default is missing', async () => {
+      const MockProvider = class {
+        name = 'named-export';
+        provision() {}
+        getCIConfig() {}
+      };
+      (
+        registry as unknown as { registerProviderFromModule: (mod: any, name: string) => void }
+      ).registerProviderFromModule({ Named: MockProvider }, 'test');
+      expect(registry.getDeploymentProvider('named-export')).toBeDefined();
+    });
+
+    it('should handle missing exported provider', async () => {
+      const mockModule = {};
+      await (
+        registry as unknown as {
+          registerProviderFromModule: (mod: any, name: string) => Promise<void>;
+        }
+      ).registerProviderFromModule(mockModule, 'test');
+      expect(registry.getDeploymentProvider('test')).toBeUndefined();
+    });
+
+    it('should handle instantiation failure', async () => {
+      const MockProvider = vi.fn().mockImplementation(() => {
+        throw new Error('Instantiate fail');
+      });
+      const mockModule = { Provider: MockProvider };
+      await (
+        registry as unknown as {
+          registerProviderFromModule: (mod: any, name: string) => Promise<void>;
+        }
+      ).registerProviderFromModule(mockModule, 'fail');
+      expect(registry.getDeploymentProvider('fail')).toBeUndefined();
+    });
+
+    it('should handle non-class provider', async () => {
+      const mockModule = { Provider: { name: 'static' } };
+      await (
+        registry as unknown as {
+          registerProviderFromModule: (mod: any, name: string) => Promise<void>;
+        }
+      ).registerProviderFromModule(mockModule, 'static');
+      expect(registry.getDeploymentProvider('static')).toBeUndefined();
+    });
+  });
+
+  describe('loadCoreProviders', () => {
+    it('should load core providers from found directory', async () => {
+      // Calculate the path where registry.ts expects providers
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      const dirname = path.resolve(__dirname, '../../../src/deploy/providers');
+      const mockProviderPath = path.join(dirname, 'mock.js');
+
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['mock.js'] as unknown as any);
+
+      // Mock the specific file that registry will import
+      vi.doMock(mockProviderPath, () => ({
+        default: class MockCore {
+          name = 'core-mock';
+          provision() {}
+          getCIConfig() {}
+        },
+      }));
+
+      await registry.loadCoreProviders();
+
+      // Assert
+      expect(fs.readdir).toHaveBeenCalled();
+      expect(registry.getDeploymentProvider('core-mock')).toBeDefined();
+    });
+
+    it('should warn if no providers directory found', async () => {
+      vi.spyOn(fs, 'access').mockRejectedValue(new Error('ENOENT'));
+      await registry.loadCoreProviders();
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Could not locate core providers'),
+      );
+    });
+
+    it('should warn if scanning providers fails', async () => {
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('Scan fail'));
+      await registry.loadCoreProviders();
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to scan core providers'),
+      );
+    });
+
+    it('should warn if loading a provider fails', async () => {
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['bad.js'] as unknown as any);
+      // We do NOT mock bad.js, so import() should fail
+      await registry.loadCoreProviders();
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load core provider'),
+      );
+    });
+
+    it('should ignore non-js/ts files', async () => {
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['README.md', 'type.d.ts'] as unknown as any);
+      const spy = vi.spyOn(
+        registry as unknown as { registerProviderFromModule: any },
+        'registerProviderFromModule',
+      );
+
+      await registry.loadCoreProviders();
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('loadLocalProviders', () => {
+    it('should load local providers using jiti', async () => {
+      const mockRoot = '/mock/root';
+      const deployDir = path.join(mockRoot, 'deploy');
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['custom.ts'] as unknown as any);
+
+      mockJitiRequest.mockResolvedValue({
+        default: class {
+          name = 'local-custom';
+          provision() {}
+          getCIConfig() {}
+        },
+      });
+
+      await registry.loadLocalProviders(mockRoot);
+
+      expect(mockJitiRequest).toHaveBeenCalledWith(path.join(deployDir, 'custom.ts'));
+      expect(registry.getDeploymentProvider('local-custom')).toBeDefined();
+    });
+
+    it('should ignore non-js/ts files', async () => {
+      const mockRoot = '/mock/root';
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['README.md', 'notes.txt'] as any);
+
+      await registry.loadLocalProviders(mockRoot);
+      expect(mockJitiRequest).not.toHaveBeenCalled();
+    });
+
+    it('should skip if directory missing', async () => {
+      vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('ENOENT'));
+      await registry.loadLocalProviders('/root');
+      expect(mockJitiRequest).not.toHaveBeenCalled();
+    });
+
+    it('should warn if loading local provider fails', async () => {
+      const mockRoot = '/mock/root';
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['broken.ts'] as any);
+      mockJitiRequest.mockRejectedValue(new Error('Jiti fail'));
+
+      await registry.loadLocalProviders(mockRoot);
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load local provider'),
+      );
+    });
+  });
+});

package/test/unit/deploy/utils.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi } from 'vitest';
+import { checkCommand } from '../../../src/deploy/utils.js';
+import { exec } from 'node:child_process';
+
+vi.mock('node:child_process', () => ({
+  exec: vi.fn(),
+}));
+
+describe('deploy utils', () => {
+  describe('checkCommand', () => {
+    it('should return true if command succeeds', async () => {
+      vi.mocked(exec).mockImplementation(((
+        _cmd: string,
+        callback: (err: Error | null, res: { stdout: string }) => void,
+      ) => {
+        callback(null, { stdout: 'ok' });
+        return {} as any;
+      }) as unknown as typeof exec);
+      expect(await checkCommand('foo')).toBe(true);
+    });
+
+    it('should return false if command fails', async () => {
+      vi.mocked(exec).mockImplementation(((_cmd: string, callback: (err: Error | null) => void) => {
+        callback(new Error('fail'));
+        return {} as any;
+      }) as unknown as typeof exec);
+      expect(await checkCommand('foo')).toBe(false);
+    });
+  });
+});