@mjasano/devtunnel 1.1.0 → 1.4.0

package/test/server.test.js

@@ -0,0 +1,204 @@
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const http = require('node:http');
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+
+let serverProcess;
+const serverPort = 3099;
+
+function makeRequest(method, path, body = null) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'localhost',
+      port: serverPort,
+      path,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data });
+        }
+      });
+    });
+
+    req.on('error', reject);
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+}
+
+function waitForServer(port, timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+
+    const check = () => {
+      const req = http.get(`http://localhost:${port}/health`, (res) => {
+        if (res.statusCode === 200) {
+          resolve();
+        } else {
+          retry();
+        }
+      });
+
+      req.on('error', retry);
+      req.setTimeout(1000);
+    };
+
+    const retry = () => {
+      if (Date.now() - start > timeout) {
+        reject(new Error('Server startup timeout'));
+      } else {
+        setTimeout(check, 200);
+      }
+    };
+
+    check();
+  });
+}
+
+describe('DevTunnel Server API', () => {
+  before(async () => {
+    const serverPath = path.join(__dirname, '..', 'server.js');
+    serverProcess = spawn('node', [serverPath], {
+      env: { ...process.env, PORT: serverPort },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    serverProcess.stdout.on('data', (data) => {
+      console.log(`[server] ${data.toString().trim()}`);
+    });
+
+    serverProcess.stderr.on('data', (data) => {
+      console.error(`[server] ${data.toString().trim()}`);
+    });
+
+    await waitForServer(serverPort);
+  });
+
+  after(() => {
+    if (serverProcess) {
+      serverProcess.kill('SIGTERM');
+    }
+  });
+
+  describe('GET /health', () => {
+    it('should return health status', async () => {
+      const { status, data } = await makeRequest('GET', '/health');
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.status, 'ok');
+      assert.strictEqual(typeof data.sessions, 'number');
+      assert.strictEqual(typeof data.tunnels, 'number');
+    });
+  });
+
+  describe('GET /api/system', () => {
+    it('should return system information', async () => {
+      const { status, data } = await makeRequest('GET', '/api/system');
+      assert.strictEqual(status, 200);
+      assert.ok(data.hostname);
+      assert.ok(data.platform);
+      assert.ok(data.arch);
+      assert.strictEqual(typeof data.uptime, 'number');
+      assert.ok(data.cpu);
+      assert.ok(data.memory);
+      assert.ok(Array.isArray(data.loadavg));
+    });
+  });
+
+  describe('GET /api/sessions', () => {
+    it('should return empty session list initially', async () => {
+      const { status, data } = await makeRequest('GET', '/api/sessions');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data));
+    });
+  });
+
+  describe('GET /api/tunnels', () => {
+    it('should return empty tunnel list initially', async () => {
+      const { status, data } = await makeRequest('GET', '/api/tunnels');
+      assert.strictEqual(status, 200);
+      assert.ok(Array.isArray(data));
+    });
+  });
+
+  describe('GET /api/files', () => {
+    it('should return file listing', async () => {
+      const { status, data } = await makeRequest('GET', '/api/files');
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.path, '');
+      assert.ok(Array.isArray(data.items));
+    });
+  });
+
+  describe('POST /api/files/write', () => {
+    it('should reject request without path', async () => {
+      const { status, data } = await makeRequest('POST', '/api/files/write', {
+        content: 'test',
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.error, 'Path required');
+    });
+  });
+
+  describe('POST /api/files/delete', () => {
+    it('should reject request without path', async () => {
+      const { status, data } = await makeRequest('POST', '/api/files/delete', {});
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.error, 'Path required');
+    });
+
+    it('should return 404 for non-existent file', async () => {
+      const { status, data } = await makeRequest('POST', '/api/files/delete', {
+        path: 'non-existent-file-12345.txt',
+      });
+      assert.strictEqual(status, 404);
+      assert.strictEqual(data.error, 'File not found');
+    });
+  });
+
+  describe('POST /api/files/rename', () => {
+    it('should reject request without paths', async () => {
+      const { status, data } = await makeRequest('POST', '/api/files/rename', {});
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.error, 'Both oldPath and newPath required');
+    });
+
+    it('should return 404 for non-existent source file', async () => {
+      const { status, data } = await makeRequest('POST', '/api/files/rename', {
+        oldPath: 'non-existent-file-12345.txt',
+        newPath: 'new-name.txt',
+      });
+      assert.strictEqual(status, 404);
+      assert.strictEqual(data.error, 'File not found');
+    });
+  });
+
+  describe('POST /api/tunnels', () => {
+    it('should reject request without valid port', async () => {
+      const { status, data } = await makeRequest('POST', '/api/tunnels', {});
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.error, 'Valid port number required');
+    });
+
+    it('should reject request with invalid port type', async () => {
+      const { status, data } = await makeRequest('POST', '/api/tunnels', {
+        port: 'invalid',
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.error, 'Valid port number required');
+    });
+  });
+});