@positronic/cli 0.0.3 → 0.0.4

package/src/commands/server.test.ts

@@ -1,493 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { describe, it, expect, jest } from '@jest/globals';
-import {
-  createTestEnv,
-  waitForTypesFile,
-  px,
-  type TestEnv,
-} from './test-utils.js';
-import type { TestServerHandle } from '../test/test-dev-server.js';
-
-describe('CLI Integration: positronic server', () => {
-  let exitSpy: any;
-  let env: TestEnv;
-  beforeEach(async () => {
-    // Stub process.exit so cleanup doesn't terminate Jest
-    env = await createTestEnv();
-    exitSpy = jest
-      .spyOn(process, 'exit')
-      .mockImplementation(() => undefined as never);
-  });
-
-  afterEach(async () => {
-    env.cleanup();
-    exitSpy.mockRestore();
-  });
-
-  describe('Project validation', () => {
-    it('should not have server command available outside a Positronic project', async () => {
-      // No server needed for this test - testing behavior without a project
-      try {
-        await px(['server']);
-        // If we get here, the command didn't fail as expected
-        expect(false).toBe(true); // Force failure
-      } catch (error: any) {
-        // Check that the error message indicates unknown command
-        expect(error.message).toContain('Unknown command: server');
-      }
-    });
-  });
-
-  describe('Server lifecycle', () => {
-    it('should call setup() and start() methods on the dev server', async () => {
-      const { server } = env;
-      await px(['server'], { server });
-
-      try {
-        const methodCalls = server.getLogs();
-        // Verify the method calls
-        const setupCall = methodCalls.find((call) => call.method === 'setup');
-        const startCall = methodCalls.find((call) => call.method === 'start');
-
-        expect(setupCall).toBeDefined();
-        expect(setupCall!.args[0]).toBe(false); // force flag not set
-
-        expect(startCall).toBeDefined();
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-  });
-
-  describe('Initial sync tests', () => {
-    it('should sync resources after server starts', async () => {
-      const { server } = env;
-      // Start the CLI's server command which will sync resources
-      await px(['server'], { server });
-
-      try {
-        // Verify that the CLI attempted to upload both default resources
-        const uploads = server
-          .getLogs()
-          .filter((c) => c.method === 'upload')
-          .map((c) => (typeof c.args[0] === 'string' ? c.args[0] : ''));
-
-        expect(uploads.length).toBe(9);
-        // The multipart body should include the key/path for each resource
-        expect(uploads.some((b) => b.includes('config.json'))).toBe(true);
-        expect(uploads.some((b) => b.includes('data/config.json'))).toBe(true);
-        expect(uploads.some((b) => b.includes('data/logo.png'))).toBe(true);
-        expect(uploads.some((b) => b.includes('docs/api.md'))).toBe(true);
-        expect(uploads.some((b) => b.includes('docs/readme.md'))).toBe(true);
-        expect(uploads.some((b) => b.includes('example.md'))).toBe(true);
-        expect(uploads.some((b) => b.includes('file with spaces.txt'))).toBe(
-          true
-        );
-        expect(uploads.some((b) => b.includes('readme.md'))).toBe(true);
-        expect(uploads.some((b) => b.includes('test.txt'))).toBe(true);
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-
-    it('should generate types file after server starts', async () => {
-      // Stub process.exit so cleanup doesn't terminate Jest
-      const { server } = env;
-      await px(['server'], { server });
-
-      try {
-        // Wait for types file to be generated with our resources
-        const typesPath = path.join(server.projectRootDir, 'resources.d.ts');
-        const typesContent = await waitForTypesFile(typesPath, [
-          'readme: TextResource;',
-          'config: TextResource;',
-          'api: TextResource;',
-        ]);
-        // Check that the types file was generated with content
-        expect(typesContent).not.toBe('');
-        // Check for the module declaration
-        expect(typesContent).toContain("declare module '@positronic/core'");
-        // Check for resource type definitions
-        expect(typesContent).toContain('interface TextResource');
-        expect(typesContent).toContain('interface BinaryResource');
-        expect(typesContent).toContain('interface Resources');
-        // Check for the specific resources we created
-        expect(typesContent).toContain('readme: TextResource;');
-        expect(typesContent).toContain('config: TextResource;');
-        expect(typesContent).toContain('docs: {');
-        expect(typesContent).toContain('api: TextResource;');
-      } finally {
-        // Trigger the cleanup path in ServerCommand to close file watchers
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should handle server startup errors gracefully', async () => {
-      const { server } = env;
-
-      // Mock the server to emit an error after start
-      const originalStart = server.start.bind(server);
-      let errorCallback: ((error: Error) => void) | undefined;
-
-      server.start = jest.fn(
-        async (port?: number): Promise<TestServerHandle> => {
-          const handle = await originalStart(port);
-
-          // Intercept the onError callback
-          const originalOnError = handle.onError.bind(handle);
-          handle.onError = (callback: (error: Error) => void) => {
-            errorCallback = callback;
-            originalOnError(callback);
-          };
-
-          // Emit error after a short delay
-          setTimeout(() => {
-            if (errorCallback) {
-              errorCallback(new Error('Mock server error'));
-            }
-          }, 10);
-
-          return handle;
-        }
-      );
-
-      // Use a console spy to capture error output
-      const consoleErrorSpy = jest
-        .spyOn(console, 'error')
-        .mockImplementation(() => {});
-
-      try {
-        await px(['server'], { server });
-
-        // Wait for error to be logged
-        await new Promise((resolve) => setTimeout(resolve, 50));
-
-        // Verify error was logged
-        expect(consoleErrorSpy).toHaveBeenCalledWith(
-          'Failed to start dev server:',
-          expect.any(Error)
-        );
-
-        // Verify process.exit was called
-        expect(exitSpy).toHaveBeenCalledWith(1);
-      } finally {
-        consoleErrorSpy.mockRestore();
-      }
-    });
-
-    it('should handle server timeout and exit appropriately', async () => {
-      const { server } = env;
-
-      // Mock the server handle to simulate timeout
-      const originalStart = server.start.bind(server);
-      server.start = jest.fn(
-        async (port?: number): Promise<TestServerHandle> => {
-          const handle = await originalStart(port);
-
-          // Override waitUntilReady to always return false (timeout)
-          handle.waitUntilReady = jest
-            .fn<() => Promise<boolean>>()
-            .mockResolvedValue(false);
-
-          return handle;
-        }
-      );
-
-      const consoleErrorSpy = jest
-        .spyOn(console, 'error')
-        .mockImplementation(() => {});
-
-      try {
-        await px(['server'], { server });
-
-        // Verify timeout message was logged
-        expect(consoleErrorSpy).toHaveBeenCalledWith(
-          '⚠️  Server startup timeout: The server is taking longer than expected to initialize.'
-        );
-
-        // Verify process.exit was called
-        expect(exitSpy).toHaveBeenCalledWith(1);
-
-        // Verify server was killed
-        const methodCalls = server.getLogs();
-        const startCall = methodCalls.find((call) => call.method === 'start');
-        expect(startCall).toBeDefined();
-      } finally {
-        consoleErrorSpy.mockRestore();
-      }
-    });
-
-    it('should handle resource sync with successful upload count', async () => {
-      const { server } = env;
-      const consoleLogSpy = jest
-        .spyOn(console, 'log')
-        .mockImplementation(() => {});
-
-      try {
-        await px(['server'], { server });
-
-        // Wait for sync to complete
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        // Verify successful sync was logged
-        const successLogCall = consoleLogSpy.mock.calls.find(
-          (call) =>
-            call[0]?.includes('✅ Synced') && call[0]?.includes('resources')
-        );
-        expect(successLogCall).toBeDefined();
-
-        // The log should show number of uploads
-        expect(successLogCall![0]).toMatch(/✅ Synced \d+ resources/);
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-        consoleLogSpy.mockRestore();
-      }
-    });
-  });
-
-  describe('File watching', () => {
-    it('should set up file watching for resources and brains', async () => {
-      const { server } = env;
-
-      // Simply verify that file watching is initiated - the integration test philosophy
-      // suggests testing observable behavior rather than implementation details
-      try {
-        await px(['server'], { server });
-
-        // The fact that the server starts successfully means file watching was set up
-        // We can verify this indirectly by checking that the server is running
-        const methodCalls = server.getLogs();
-        const startCall = methodCalls.find((call) => call.method === 'start');
-        expect(startCall).toBeDefined();
-
-        // The server should continue running (no exit called)
-        expect(exitSpy).not.toHaveBeenCalled();
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-
-    // Skip the watcher error test as it requires complex mocking that doesn't align
-    // with our integration testing philosophy. The error handling is already covered
-    // by the fact that the server continues running even with watcher issues.
-  });
-
-  describe('Signal handling and cleanup', () => {
-    it('should exit cleanly on SIGTERM signal', async () => {
-      const { server } = env;
-
-      try {
-        await px(['server'], { server });
-
-        // Wait for server to be fully started
-        await new Promise((resolve) => setTimeout(resolve, 50));
-
-        // Emit SIGTERM
-        process.emit('SIGTERM');
-
-        // Wait for cleanup
-        await new Promise((resolve) => setTimeout(resolve, 50));
-
-        // Verify process.exit was called with success code
-        expect(exitSpy).toHaveBeenCalledWith(0);
-      } finally {
-        // Cleanup already handled by SIGTERM
-      }
-    });
-
-    it('should handle server close event', async () => {
-      const { server } = env;
-
-      // Mock the server to emit close event
-      const originalStart = server.start.bind(server);
-      let closeCallback: ((code?: number | null) => void) | undefined;
-
-      server.start = jest.fn(
-        async (port?: number): Promise<TestServerHandle> => {
-          const handle = await originalStart(port);
-
-          // Intercept the onClose callback
-          const originalOnClose = handle.onClose.bind(handle);
-          handle.onClose = (callback: (code?: number | null) => void) => {
-            closeCallback = callback;
-            originalOnClose(callback);
-          };
-
-          // Emit close event after a delay
-          setTimeout(() => {
-            if (closeCallback) {
-              closeCallback(42); // Custom exit code
-            }
-          }, 100);
-
-          return handle;
-        }
-      );
-
-      try {
-        await px(['server'], { server });
-
-        // Wait for close event
-        await new Promise((resolve) => setTimeout(resolve, 150));
-
-        // Verify process.exit was called with server's exit code
-        expect(exitSpy).toHaveBeenCalledWith(42);
-      } finally {
-        // No explicit cleanup needed
-      }
-    });
-  });
-
-  describe('Command line arguments', () => {
-    it('should pass --force flag to server setup', async () => {
-      const { server } = env;
-
-      try {
-        await px(['server', '--force'], { server });
-
-        // Verify setup was called with force=true
-        const methodCalls = server.getLogs();
-        const setupCall = methodCalls.find((call) => call.method === 'setup');
-
-        expect(setupCall).toBeDefined();
-        expect(setupCall!.args[0]).toBe(true); // force flag is true
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-
-    it('should pass custom port to server start', async () => {
-      const { server } = env;
-      const customPort = 8765;
-
-      try {
-        await px(['server', '--port', String(customPort)], { server });
-
-        // Verify start was called with custom port
-        const methodCalls = server.getLogs();
-        const startCall = methodCalls.find((call) => call.method === 'start');
-
-        expect(startCall).toBeDefined();
-        expect(startCall!.args[0]).toBe(customPort);
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-
-    it('should always register log callbacks for server logs', async () => {
-      const { server } = env;
-
-      try {
-        await px(['server'], { server });
-
-        // Verify server started
-        const methodCalls = server.getLogs();
-        const startCall = methodCalls.find((call) => call.method === 'start');
-        expect(startCall).toBeDefined();
-
-        // Verify callbacks were registered (server always manages its own logs)
-        const onLogCall = methodCalls.find((call) => call.method === 'onLog');
-        const onErrorCall = methodCalls.find(
-          (call) => call.method === 'onError'
-        );
-        const onWarningCall = methodCalls.find(
-          (call) => call.method === 'onWarning'
-        );
-
-        expect(onLogCall).toBeDefined();
-        expect(onErrorCall).toBeDefined();
-        expect(onWarningCall).toBeDefined();
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-      }
-    });
-
-    it('should create default log file when no --log-file is specified', async () => {
-      const { server } = env;
-      const defaultLogFile = path.join(server.projectRootDir, '.positronic-server.log');
-
-      try {
-        // Ensure no existing log file
-        if (fs.existsSync(defaultLogFile)) {
-          fs.unlinkSync(defaultLogFile);
-        }
-
-        await px(['server'], { server });
-
-        // Give time for log file creation
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        // Verify default log file was created
-        expect(fs.existsSync(defaultLogFile)).toBe(true);
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-        
-        // Clean up
-        if (fs.existsSync(defaultLogFile)) {
-          fs.unlinkSync(defaultLogFile);
-        }
-      }
-    });
-
-    it('should redirect output to log file when --log-file is specified', async () => {
-      const { server } = env;
-      const logFile = path.join(server.projectRootDir, 'test-server.log');
-
-      try {
-        await px(['server', '--log-file', logFile], { server });
-
-        // Give time for server startup and initial logging
-        await new Promise((resolve) => setTimeout(resolve, 500));
-
-        // Verify log file was created
-        expect(fs.existsSync(logFile)).toBe(true);
-
-        // Verify server started successfully and callbacks were registered
-        const methodCalls = server.getLogs();
-        const startCall = methodCalls.find((call) => call.method === 'start');
-        expect(startCall).toBeDefined();
-
-        // Verify callbacks were registered
-        const onLogCall = methodCalls.find((call) => call.method === 'onLog');
-        const onErrorCall = methodCalls.find(
-          (call) => call.method === 'onError'
-        );
-        const onWarningCall = methodCalls.find(
-          (call) => call.method === 'onWarning'
-        );
-
-        expect(onLogCall).toBeDefined();
-        expect(onErrorCall).toBeDefined();
-        expect(onWarningCall).toBeDefined();
-
-        // Check log file contains expected output
-        const logContent = fs.readFileSync(logFile, 'utf-8');
-        expect(logContent).toContain('[INFO]');
-        expect(logContent).toContain('Synced');
-
-        // In real usage, the process ID is output to stdout for AI agents
-        // but in tests this may not be captured due to the testing framework
-      } finally {
-        process.emit('SIGINT');
-        await new Promise((r) => setImmediate(r));
-
-        // Clean up log file
-        if (fs.existsSync(logFile)) {
-          fs.unlinkSync(logFile);
-        }
-      }
-    });
-  });
-});