onbuzz 4.9.13 → 4.10.0

package/src/modules/fileExplorer/__tests__/zipDownload.test.js

@@ -1,237 +1,237 @@
-/**
- * File Explorer – ZIP download route tests
- * Tests the POST /download-zip route handler structure and default behavior.
- */
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { createFileExplorerRouter } from '../routes.js';
-
-// ── Utility: replicate the gitignore parsing logic from the route handler ──
-function parseGitignore(content) {
-  return content.split('\n')
-    .map(line => line.trim())
-    .filter(line => line && !line.startsWith('#'));
-}
-
-describe('File Explorer – ZIP download route', () => {
-
-  test('createFileExplorerRouter returns an Express router', () => {
-    const router = createFileExplorerRouter();
-    // Express routers expose .use, .get, .post, etc.
-    expect(typeof router).toBe('function');
-    expect(typeof router.use).toBe('function');
-    expect(typeof router.get).toBe('function');
-    expect(typeof router.post).toBe('function');
-  });
-
-  test('router has a POST handler registered for /download-zip', () => {
-    const router = createFileExplorerRouter();
-
-    // Express stores route layers in router.stack
-    const postLayers = router.stack.filter(layer => {
-      if (!layer.route) return false;
-      return layer.route.path === '/download-zip' &&
-             layer.route.methods.post === true;
-    });
-
-    expect(postLayers.length).toBe(1);
-  });
-
-  test('download-zip handler rejects missing path with 400', async () => {
-    const router = createFileExplorerRouter();
-
-    // Find the download-zip route layer
-    const layer = router.stack.find(l =>
-      l.route && l.route.path === '/download-zip'
-    );
-    // The route has middleware (express.json) then the handler
-    // Get the last handler in the route stack
-    const handlers = layer.route.stack;
-    const routeHandler = handlers[handlers.length - 1].handle;
-
-    const req = { body: {} };
-    let statusCode = null;
-    let responseBody = null;
-    const res = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn((body) => {
-        responseBody = body;
-        return res;
-      }),
-      setHeader: jest.fn()
-    };
-
-    // Capture status
-    res.status.mockImplementation((code) => {
-      statusCode = code;
-      return res;
-    });
-
-    await routeHandler(req, res);
-
-    expect(statusCode).toBe(400);
-    expect(responseBody).toEqual({ error: 'Path is required' });
-  });
-
-  test('default ignore patterns include node_modules, .git, and .env', async () => {
-    // Verify from the source that the default patterns are as expected.
-    // We import and inspect the route source indirectly via the handler behavior.
-    // The defaults are hardcoded: ['node_modules', '.git', '.env']
-    // We verify this by reading the module source patterns.
-    //
-    // Since the patterns are inline in the handler, we confirm them by
-    // calling the handler with a non-existent path and checking the error
-    // rather than the patterns directly. Instead, we can verify the pattern
-    // list is correct by examining the module export.
-    //
-    // For a more direct test, we verify the source expectation:
-    const expectedDefaults = ['node_modules', '.git', '.env'];
-
-    // We read the route module source to confirm defaults.
-    // This is a static assertion based on the known source code.
-    // The handler sets: let ignorePatterns = ['node_modules', '.git', '.env'];
-    expect(expectedDefaults).toEqual(['node_modules', '.git', '.env']);
-  });
-
-  test('defaultConfig export has expected shape', async () => {
-    const { defaultConfig } = await import('../routes.js');
-    expect(defaultConfig).toBeDefined();
-    expect(defaultConfig).toHaveProperty('showHidden');
-    expect(defaultConfig).toHaveProperty('allowedExtensions');
-    expect(defaultConfig).toHaveProperty('maxDepth');
-    expect(defaultConfig).toHaveProperty('restrictedPaths');
-  });
-
-  // ── Additional coverage ───────────────────────────────────────────────
-
-  test('handler rejects non-directory path with 400', async () => {
-    const router = createFileExplorerRouter();
-    const layer = router.stack.find(l =>
-      l.route && l.route.path === '/download-zip'
-    );
-    const handlers = layer.route.stack;
-    const routeHandler = handlers[handlers.length - 1].handle;
-
-    // Provide a path that fs.stat resolves as a file (not directory)
-    const req = { body: { path: '/some/file.txt' } };
-    let statusCode = null;
-    let responseBody = null;
-    const res = {
-      status: jest.fn((code) => { statusCode = code; return res; }),
-      json: jest.fn((body) => { responseBody = body; return res; }),
-      setHeader: jest.fn(),
-      headersSent: false
-    };
-
-    // The handler will call fs.stat on the path which will throw since
-    // the path doesn't exist. The catch block sets 500 with error.message.
-    await routeHandler(req, res);
-
-    // The handler should have returned an error status (either 400 for non-dir or 500 for not found)
-    expect(statusCode).toBeGreaterThanOrEqual(400);
-    expect(responseBody).toBeDefined();
-    expect(responseBody.error).toBeDefined();
-  });
-
-  test('parseGitignore strips comments', () => {
-    const content = '# This is a comment\nnode_modules\n# Another comment\ndist';
-    const patterns = parseGitignore(content);
-    expect(patterns).not.toContain('# This is a comment');
-    expect(patterns).not.toContain('# Another comment');
-    expect(patterns).toContain('node_modules');
-    expect(patterns).toContain('dist');
-  });
-
-  test('parseGitignore strips empty lines', () => {
-    const content = 'node_modules\n\n\n*.log\n\ndist';
-    const patterns = parseGitignore(content);
-    expect(patterns).toEqual(['node_modules', '*.log', 'dist']);
-    expect(patterns).toHaveLength(3);
-  });
-
-  test('parseGitignore strips comments and empty lines together', () => {
-    const content = '# comment\nnode_modules\n\n*.log\n# another comment\ndist';
-    const patterns = parseGitignore(content);
-    expect(patterns).toEqual(['node_modules', '*.log', 'dist']);
-    expect(patterns).not.toContain('# comment');
-  });
-
-  test('parseGitignore patterns are merged with defaults', () => {
-    const defaults = ['node_modules', '.git', '.env'];
-    const gitignoreContent = 'dist\n*.log\n# build artifacts\nbuild';
-    const parsed = parseGitignore(gitignoreContent);
-    const merged = [...new Set([...defaults, ...parsed])];
-
-    expect(merged).toContain('node_modules');
-    expect(merged).toContain('.git');
-    expect(merged).toContain('.env');
-    expect(merged).toContain('dist');
-    expect(merged).toContain('*.log');
-    expect(merged).toContain('build');
-    // No duplicates if a pattern is in both
-    const withOverlap = [...new Set([...defaults, ...parseGitignore('node_modules\ncoverage')])];
-    expect(withOverlap.filter(p => p === 'node_modules')).toHaveLength(1);
-  });
-
-  test('handler sets Content-Type application/zip', async () => {
-    // We verify the handler calls res.setHeader('Content-Type', 'application/zip')
-    // by inspecting the route source behavior. Since we can't easily run the full
-    // handler (it requires real filesystem + exec), we verify the header name
-    // is set by examining the route structure exists and testing with a mock
-    // that captures setHeader calls before the handler errors on fs.stat.
-    const router = createFileExplorerRouter();
-    const layer = router.stack.find(l =>
-      l.route && l.route.path === '/download-zip'
-    );
-    const handlers = layer.route.stack;
-    const routeHandler = handlers[handlers.length - 1].handle;
-
-    // Use a path that won't exist - the handler will throw at fs.stat
-    // but we can verify that the handler structure is correct
-    const req = { body: { path: '/nonexistent/dir' } };
-    const setHeaderCalls = [];
-    const res = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn().mockReturnThis(),
-      setHeader: jest.fn((name, value) => { setHeaderCalls.push({ name, value }); }),
-      headersSent: false
-    };
-
-    await routeHandler(req, res);
-
-    // Handler errored before reaching setHeader (fs.stat fails) — that's expected.
-    // For a more direct assertion, we verify the source contract: the route
-    // source sets 'Content-Type' to 'application/zip' and 'Content-Disposition'
-    // with the directory name. Since we cannot mock fs in ESM easily, we assert
-    // the route handler exists and the static expectation is correct.
-    expect(routeHandler).toBeDefined();
-    expect(typeof routeHandler).toBe('function');
-
-    // Verify the known Content-Type value from source inspection
-    const expectedContentType = 'application/zip';
-    expect(expectedContentType).toBe('application/zip');
-  });
-
-  test('handler sets Content-Disposition with directory name', () => {
-    // The route source constructs: `attachment; filename="${dirName}.zip"`
-    // where dirName = path.basename(dirPath). Verify the pattern:
-    const pathModule = { basename: (p) => p.split('/').pop() };
-    const dirPath = '/home/user/my-project';
-    const dirName = pathModule.basename(dirPath);
-    const expectedDisposition = `attachment; filename="${dirName}.zip"`;
-
-    expect(expectedDisposition).toBe('attachment; filename="my-project.zip"');
-    expect(dirName).toBe('my-project');
-  });
-
-  test('parseGitignore handles whitespace-only lines', () => {
-    const content = '  \nnode_modules\n   \t  \ndist';
-    const patterns = parseGitignore(content);
-    expect(patterns).toEqual(['node_modules', 'dist']);
-  });
-
-  test('parseGitignore handles trailing whitespace in patterns', () => {
-    const content = 'node_modules  \n*.log \ndist\t';
-    const patterns = parseGitignore(content);
-    expect(patterns).toEqual(['node_modules', '*.log', 'dist']);
-  });
-});
+/**
+ * File Explorer – ZIP download route tests
+ * Tests the POST /download-zip route handler structure and default behavior.
+ */
+import { jest, describe, test, expect } from '@jest/globals';
+import { createFileExplorerRouter } from '../routes.js';
+
+// ── Utility: replicate the gitignore parsing logic from the route handler ──
+function parseGitignore(content) {
+  return content.split('\n')
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('#'));
+}
+
+describe('File Explorer – ZIP download route', () => {
+
+  test('createFileExplorerRouter returns an Express router', () => {
+    const router = createFileExplorerRouter();
+    // Express routers expose .use, .get, .post, etc.
+    expect(typeof router).toBe('function');
+    expect(typeof router.use).toBe('function');
+    expect(typeof router.get).toBe('function');
+    expect(typeof router.post).toBe('function');
+  });
+
+  test('router has a POST handler registered for /download-zip', () => {
+    const router = createFileExplorerRouter();
+
+    // Express stores route layers in router.stack
+    const postLayers = router.stack.filter(layer => {
+      if (!layer.route) return false;
+      return layer.route.path === '/download-zip' &&
+             layer.route.methods.post === true;
+    });
+
+    expect(postLayers.length).toBe(1);
+  });
+
+  test('download-zip handler rejects missing path with 400', async () => {
+    const router = createFileExplorerRouter();
+
+    // Find the download-zip route layer
+    const layer = router.stack.find(l =>
+      l.route && l.route.path === '/download-zip'
+    );
+    // The route has middleware (express.json) then the handler
+    // Get the last handler in the route stack
+    const handlers = layer.route.stack;
+    const routeHandler = handlers[handlers.length - 1].handle;
+
+    const req = { body: {} };
+    let statusCode = null;
+    let responseBody = null;
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn((body) => {
+        responseBody = body;
+        return res;
+      }),
+      setHeader: jest.fn()
+    };
+
+    // Capture status
+    res.status.mockImplementation((code) => {
+      statusCode = code;
+      return res;
+    });
+
+    await routeHandler(req, res);
+
+    expect(statusCode).toBe(400);
+    expect(responseBody).toEqual({ error: 'Path is required' });
+  });
+
+  test('default ignore patterns include node_modules, .git, and .env', async () => {
+    // Verify from the source that the default patterns are as expected.
+    // We import and inspect the route source indirectly via the handler behavior.
+    // The defaults are hardcoded: ['node_modules', '.git', '.env']
+    // We verify this by reading the module source patterns.
+    //
+    // Since the patterns are inline in the handler, we confirm them by
+    // calling the handler with a non-existent path and checking the error
+    // rather than the patterns directly. Instead, we can verify the pattern
+    // list is correct by examining the module export.
+    //
+    // For a more direct test, we verify the source expectation:
+    const expectedDefaults = ['node_modules', '.git', '.env'];
+
+    // We read the route module source to confirm defaults.
+    // This is a static assertion based on the known source code.
+    // The handler sets: let ignorePatterns = ['node_modules', '.git', '.env'];
+    expect(expectedDefaults).toEqual(['node_modules', '.git', '.env']);
+  });
+
+  test('defaultConfig export has expected shape', async () => {
+    const { defaultConfig } = await import('../routes.js');
+    expect(defaultConfig).toBeDefined();
+    expect(defaultConfig).toHaveProperty('showHidden');
+    expect(defaultConfig).toHaveProperty('allowedExtensions');
+    expect(defaultConfig).toHaveProperty('maxDepth');
+    expect(defaultConfig).toHaveProperty('restrictedPaths');
+  });
+
+  // ── Additional coverage ───────────────────────────────────────────────
+
+  test('handler rejects non-directory path with 400', async () => {
+    const router = createFileExplorerRouter();
+    const layer = router.stack.find(l =>
+      l.route && l.route.path === '/download-zip'
+    );
+    const handlers = layer.route.stack;
+    const routeHandler = handlers[handlers.length - 1].handle;
+
+    // Provide a path that fs.stat resolves as a file (not directory)
+    const req = { body: { path: '/some/file.txt' } };
+    let statusCode = null;
+    let responseBody = null;
+    const res = {
+      status: jest.fn((code) => { statusCode = code; return res; }),
+      json: jest.fn((body) => { responseBody = body; return res; }),
+      setHeader: jest.fn(),
+      headersSent: false
+    };
+
+    // The handler will call fs.stat on the path which will throw since
+    // the path doesn't exist. The catch block sets 500 with error.message.
+    await routeHandler(req, res);
+
+    // The handler should have returned an error status (either 400 for non-dir or 500 for not found)
+    expect(statusCode).toBeGreaterThanOrEqual(400);
+    expect(responseBody).toBeDefined();
+    expect(responseBody.error).toBeDefined();
+  });
+
+  test('parseGitignore strips comments', () => {
+    const content = '# This is a comment\nnode_modules\n# Another comment\ndist';
+    const patterns = parseGitignore(content);
+    expect(patterns).not.toContain('# This is a comment');
+    expect(patterns).not.toContain('# Another comment');
+    expect(patterns).toContain('node_modules');
+    expect(patterns).toContain('dist');
+  });
+
+  test('parseGitignore strips empty lines', () => {
+    const content = 'node_modules\n\n\n*.log\n\ndist';
+    const patterns = parseGitignore(content);
+    expect(patterns).toEqual(['node_modules', '*.log', 'dist']);
+    expect(patterns).toHaveLength(3);
+  });
+
+  test('parseGitignore strips comments and empty lines together', () => {
+    const content = '# comment\nnode_modules\n\n*.log\n# another comment\ndist';
+    const patterns = parseGitignore(content);
+    expect(patterns).toEqual(['node_modules', '*.log', 'dist']);
+    expect(patterns).not.toContain('# comment');
+  });
+
+  test('parseGitignore patterns are merged with defaults', () => {
+    const defaults = ['node_modules', '.git', '.env'];
+    const gitignoreContent = 'dist\n*.log\n# build artifacts\nbuild';
+    const parsed = parseGitignore(gitignoreContent);
+    const merged = [...new Set([...defaults, ...parsed])];
+
+    expect(merged).toContain('node_modules');
+    expect(merged).toContain('.git');
+    expect(merged).toContain('.env');
+    expect(merged).toContain('dist');
+    expect(merged).toContain('*.log');
+    expect(merged).toContain('build');
+    // No duplicates if a pattern is in both
+    const withOverlap = [...new Set([...defaults, ...parseGitignore('node_modules\ncoverage')])];
+    expect(withOverlap.filter(p => p === 'node_modules')).toHaveLength(1);
+  });
+
+  test('handler sets Content-Type application/zip', async () => {
+    // We verify the handler calls res.setHeader('Content-Type', 'application/zip')
+    // by inspecting the route source behavior. Since we can't easily run the full
+    // handler (it requires real filesystem + exec), we verify the header name
+    // is set by examining the route structure exists and testing with a mock
+    // that captures setHeader calls before the handler errors on fs.stat.
+    const router = createFileExplorerRouter();
+    const layer = router.stack.find(l =>
+      l.route && l.route.path === '/download-zip'
+    );
+    const handlers = layer.route.stack;
+    const routeHandler = handlers[handlers.length - 1].handle;
+
+    // Use a path that won't exist - the handler will throw at fs.stat
+    // but we can verify that the handler structure is correct
+    const req = { body: { path: '/nonexistent/dir' } };
+    const setHeaderCalls = [];
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis(),
+      setHeader: jest.fn((name, value) => { setHeaderCalls.push({ name, value }); }),
+      headersSent: false
+    };
+
+    await routeHandler(req, res);
+
+    // Handler errored before reaching setHeader (fs.stat fails) — that's expected.
+    // For a more direct assertion, we verify the source contract: the route
+    // source sets 'Content-Type' to 'application/zip' and 'Content-Disposition'
+    // with the directory name. Since we cannot mock fs in ESM easily, we assert
+    // the route handler exists and the static expectation is correct.
+    expect(routeHandler).toBeDefined();
+    expect(typeof routeHandler).toBe('function');
+
+    // Verify the known Content-Type value from source inspection
+    const expectedContentType = 'application/zip';
+    expect(expectedContentType).toBe('application/zip');
+  });
+
+  test('handler sets Content-Disposition with directory name', () => {
+    // The route source constructs: `attachment; filename="${dirName}.zip"`
+    // where dirName = path.basename(dirPath). Verify the pattern:
+    const pathModule = { basename: (p) => p.split('/').pop() };
+    const dirPath = '/home/user/my-project';
+    const dirName = pathModule.basename(dirPath);
+    const expectedDisposition = `attachment; filename="${dirName}.zip"`;
+
+    expect(expectedDisposition).toBe('attachment; filename="my-project.zip"');
+    expect(dirName).toBe('my-project');
+  });
+
+  test('parseGitignore handles whitespace-only lines', () => {
+    const content = '  \nnode_modules\n   \t  \ndist';
+    const patterns = parseGitignore(content);
+    expect(patterns).toEqual(['node_modules', 'dist']);
+  });
+
+  test('parseGitignore handles trailing whitespace in patterns', () => {
+    const content = 'node_modules  \n*.log \ndist\t';
+    const patterns = parseGitignore(content);
+    expect(patterns).toEqual(['node_modules', '*.log', 'dist']);
+  });
+});