koa-classic-server 2.6.1 → 3.0.0-alpha.0

package/__tests__/deprecation-warnings.test.js

@@ -1,217 +1,105 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
-//  TEST FOR DEPRECATED OPTION NAMES (enableCaching, cacheMaxAge)
-//  This test verifies backward compatibility and deprecation warnings
+//  TEST FOR REMOVED OPTION NAMES (enableCaching, cacheMaxAge)
+//  These options were removed in v3.0.0 — passing them must throw an Error.
 //
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-const supertest = require('supertest');
 const koaClassicServer = require('../index.cjs');
 const Koa = require('koa');
 const path = require('path');
 
 const rootDir = path.join(__dirname, 'publicWwwTest');
 
-describe('Deprecated option names (backward compatibility)', () => {
+describe('Removed option names (v3.0.0 breaking changes)', () => {
 
-    describe('Using deprecated enableCaching option', () => {
-        let app;
-        let server;
-        let consoleWarnSpy;
-
-        beforeAll(() => {
-            // Spy on console.warn to capture deprecation warnings
-            consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-
-            app = new Koa();
-
-            // Use deprecated option name
-            app.use(koaClassicServer(rootDir, {
-                enableCaching: true  // DEPRECATED: should use browserCacheEnabled
-            }));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-            consoleWarnSpy.mockRestore();
-        });
-
-        test('should display deprecation warning for enableCaching', () => {
-            expect(consoleWarnSpy).toHaveBeenCalled();
-            const warningMessage = consoleWarnSpy.mock.calls[0][1];
-            expect(warningMessage).toContain('DEPRECATION WARNING');
-            expect(warningMessage).toContain('enableCaching');
-            expect(warningMessage).toContain('browserCacheEnabled');
-        });
-
-        test('should still work with deprecated option', async () => {
-            const response = await supertest(server).get('/test-page.html');
-
-            // Should return the file
-            expect(response.status).toBe(200);
-
-            // Should have caching headers (because enableCaching: true was set)
-            expect(response.headers['etag']).toBeDefined();
-            expect(response.headers['last-modified']).toBeDefined();
-            expect(response.headers['cache-control']).toContain('public');
-        });
+    test('should throw when "enableCaching" is passed', () => {
+        expect(() => {
+            const app = new Koa();
+            app.use(koaClassicServer(rootDir, { enableCaching: true }));
+        }).toThrow('"enableCaching" option was removed in v3.0.0');
     });
 
-    describe('Using deprecated cacheMaxAge option', () => {
-        let app;
-        let server;
-        let consoleWarnSpy;
-
-        beforeAll(() => {
-            consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-
-            app = new Koa();
-
-            // Use deprecated option name
-            app.use(koaClassicServer(rootDir, {
-                enableCaching: true,  // Also deprecated
-                cacheMaxAge: 7200     // DEPRECATED: should use browserCacheMaxAge
-            }));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-            consoleWarnSpy.mockRestore();
-        });
-
-        test('should display deprecation warning for cacheMaxAge', () => {
-            const warningCalls = consoleWarnSpy.mock.calls;
-            const cacheMaxAgeWarning = warningCalls.find(call =>
-                call[1] && call[1].includes('cacheMaxAge')
-            );
-
-            expect(cacheMaxAgeWarning).toBeDefined();
-            expect(cacheMaxAgeWarning[1]).toContain('DEPRECATION WARNING');
-            expect(cacheMaxAgeWarning[1]).toContain('browserCacheMaxAge');
-        });
-
-        test('should use the deprecated cacheMaxAge value', async () => {
-            const response = await supertest(server).get('/test-page.html');
-
-            expect(response.status).toBe(200);
-            expect(response.headers['cache-control']).toContain('max-age=7200');
-        });
+    test('should throw when "cacheMaxAge" is passed', () => {
+        expect(() => {
+            const app = new Koa();
+            app.use(koaClassicServer(rootDir, { cacheMaxAge: 3600 }));
+        }).toThrow('"cacheMaxAge" option was removed in v3.0.0');
     });
 
-    describe('Using new option names (no warnings)', () => {
-        let app;
-        let server;
-        let consoleWarnSpy;
-
-        beforeAll(() => {
-            consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-
-            app = new Koa();
-
-            // Use NEW option names
-            app.use(koaClassicServer(rootDir, {
-                browserCacheEnabled: true,
-                browserCacheMaxAge: 3600
-            }));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-            consoleWarnSpy.mockRestore();
-        });
-
-        test('should NOT display deprecation warnings', () => {
-            // Filter out warnings from other tests (like index option deprecation)
-            const cachingWarnings = consoleWarnSpy.mock.calls.filter(call =>
-                call[1] && (call[1].includes('enableCaching') || call[1].includes('cacheMaxAge'))
-            );
-
-            expect(cachingWarnings.length).toBe(0);
-        });
-
-        test('should work correctly with new option names', async () => {
-            const response = await supertest(server).get('/test-page.html');
-
-            expect(response.status).toBe(200);
-            expect(response.headers['etag']).toBeDefined();
-            expect(response.headers['cache-control']).toContain('max-age=3600');
-        });
+    test('should throw even when new option is also provided alongside "cacheMaxAge"', () => {
+        expect(() => {
+            const app = new Koa();
+            app.use(koaClassicServer(rootDir, { cacheMaxAge: 3600, browserCacheMaxAge: 3600 }));
+        }).toThrow('"cacheMaxAge" option was removed in v3.0.0');
     });
 
-    describe('Using both old and new names (new takes precedence)', () => {
-        let app;
-        let server;
-        let consoleWarnSpy;
-
-        beforeAll(() => {
-            consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-
-            app = new Koa();
+    test('should throw even when new option is also provided alongside "enableCaching"', () => {
+        expect(() => {
+            const app = new Koa();
+            app.use(koaClassicServer(rootDir, { enableCaching: false, browserCacheEnabled: false }));
+        }).toThrow('"enableCaching" option was removed in v3.0.0');
+    });
+});
 
-            // Use BOTH old and new names - new should take precedence
-            app.use(koaClassicServer(rootDir, {
-                enableCaching: true,           // OLD (deprecated)
-                browserCacheEnabled: false,    // NEW (should take precedence)
-                cacheMaxAge: 7200,             // OLD (deprecated)
-                browserCacheMaxAge: 9999       // NEW (should take precedence)
-            }));
+describe('New option names (browserCacheEnabled / browserCacheMaxAge)', () => {
+    const supertest = require('supertest');
+    let app;
+    let server;
+    let consoleWarnSpy;
 
-            server = app.listen();
-        });
+    beforeAll(() => {
+        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
 
-        afterAll(() => {
-            server.close();
-            consoleWarnSpy.mockRestore();
-        });
+        app = new Koa();
+        app.use(koaClassicServer(rootDir, {
+            browserCacheEnabled: true,
+            browserCacheMaxAge: 3600
+        }));
 
-        test('should NOT display warnings when new names are also provided', () => {
-            // When both old and new names are provided, no warning should be shown
-            const cachingWarnings = consoleWarnSpy.mock.calls.filter(call =>
-                call[1] && (call[1].includes('enableCaching') || call[1].includes('cacheMaxAge'))
-            );
+        server = app.listen();
+    });
 
-            expect(cachingWarnings.length).toBe(0);
-        });
+    afterAll(() => {
+        server.close();
+        consoleWarnSpy.mockRestore();
+    });
 
-        test('new option values should take precedence over old ones', async () => {
-            const response = await supertest(server).get('/test-page.html');
+    test('should not warn about removed options', () => {
+        const removedWarnings = consoleWarnSpy.mock.calls.filter(call =>
+            call[1] && (call[1].includes('enableCaching') || call[1].includes('cacheMaxAge'))
+        );
+        expect(removedWarnings.length).toBe(0);
+    });
 
-            expect(response.status).toBe(200);
+    test('should work correctly with new option names', async () => {
+        const response = await supertest(server).get('/test-page.html');
 
-            // browserCacheEnabled: false should take precedence over enableCaching: true
-            // So there should be NO caching headers
-            expect(response.headers['etag']).toBeUndefined();
-            expect(response.headers['cache-control']).toContain('no-cache');
-        });
+        expect(response.status).toBe(200);
+        expect(response.headers['etag']).toBeDefined();
+        expect(response.headers['cache-control']).toContain('max-age=3600');
     });
+});
 
-    describe('Default behavior (no caching options specified)', () => {
-        let app;
-        let server;
-
-        beforeAll(() => {
-            app = new Koa();
-            app.use(koaClassicServer(rootDir));
-            server = app.listen();
-        });
+describe('Default behavior (no caching options specified)', () => {
+    const supertest = require('supertest');
+    let app;
+    let server;
 
-        afterAll(() => {
-            server.close();
-        });
+    beforeAll(() => {
+        app = new Koa();
+        app.use(koaClassicServer(rootDir));
+        server = app.listen();
+    });
 
-        test('should default to browserCacheEnabled: false', async () => {
-            const response = await supertest(server).get('/test-page.html');
+    afterAll(() => {
+        server.close();
+    });
 
-            expect(response.status).toBe(200);
+    test('should default to browserCacheEnabled: false', async () => {
+        const response = await supertest(server).get('/test-page.html');
 
-            // Default is caching disabled
-            expect(response.headers['cache-control']).toContain('no-cache');
-        });
+        expect(response.status).toBe(200);
+        expect(response.headers['cache-control']).toContain('no-cache');
     });
 });

package/__tests__/dt-unknown.test.js

@@ -190,13 +190,17 @@ describe('DT_UNKNOWN filesystem support (NixOS buildFHSEnv, overlayfs, FUSE)', (
         });
 
         test('should return false for DT_UNKNOWN entry pointing to a regular file', async () => {
-            // Files should NOT be treated as directories
-            // If only files exist and no index pattern matches, dir listing should show
+            // Files should NOT be treated as directories.
+            // Use a RegExp index pattern to force the readdir-based slow-path in
+            // findIndexFile (the string fast-path uses stat() directly and would bypass
+            // the mock). The regex never matches, so no index file is found and the
+            // directory listing is shown, confirming the DT_UNKNOWN files are treated
+            // as regular files (not directories).
             const spy = mockReaddirWithDtUnknown(tmpDir, ['style.css', 'readme.txt']);
 
             const app = new Koa();
             app.use(koaClassicServer(tmpDir, {
-                index: ['index.html'],
+                index: [/NOMATCH_SENTINEL/],
                 showDirContents: true
             }));
             const server = app.listen();
@@ -254,8 +258,9 @@ describe('DT_UNKNOWN filesystem support (NixOS buildFHSEnv, overlayfs, FUSE)', (
             try {
                 const res = await request.get('/');
                 expect(res.status).toBe(200);
-                expect(res.text).toContain('EJS DT_UNKNOWN');
-                expect(res.text).not.toContain('Index of');
+                const body = res.text !== undefined ? res.text : res.body.toString('utf8');
+                expect(body).toContain('EJS DT_UNKNOWN');
+                expect(body).not.toContain('Index of');
             } finally {
                 server.close();
                 spy.mockRestore();
@@ -276,8 +281,9 @@ describe('DT_UNKNOWN filesystem support (NixOS buildFHSEnv, overlayfs, FUSE)', (
             try {
                 const res = await request.get('/');
                 expect(res.status).toBe(200);
-                expect(res.text).toContain('EJS DT_UNKNOWN');
-                expect(res.text).not.toContain('Index of');
+                const body = res.text !== undefined ? res.text : res.body.toString('utf8');
+                expect(body).toContain('EJS DT_UNKNOWN');
+                expect(body).not.toContain('Index of');
             } finally {
                 server.close();
                 spy.mockRestore();
@@ -285,11 +291,16 @@ describe('DT_UNKNOWN filesystem support (NixOS buildFHSEnv, overlayfs, FUSE)', (
         });
 
         test('should not find index in directory with only subdirectories (all DT_UNKNOWN)', async () => {
+            // Use a RegExp to force the readdir-based slow-path (the string fast-path
+            // would stat() index.html directly, finding the real file on disk).
+            // The regex never matches, so the mocked readdir result (['subdir']) is used:
+            // 'subdir' has DT_UNKNOWN → stat fallback → isDirectory() → not a file →
+            // fileNames stays empty → no index found → directory listing shown.
             const spy = mockReaddirWithDtUnknown(tmpDir, ['subdir']);
 
             const app = new Koa();
             app.use(koaClassicServer(tmpDir, {
-                index: ['index.html'],
+                index: [/NOMATCH_SENTINEL/],
                 showDirContents: true
             }));
             const server = app.listen();
@@ -298,7 +309,7 @@ describe('DT_UNKNOWN filesystem support (NixOS buildFHSEnv, overlayfs, FUSE)', (
             try {
                 const res = await request.get('/');
                 expect(res.status).toBe(200);
-                // No file matches index.html, so directory listing should appear
+                // No file matches the pattern, so directory listing should appear
                 expect(res.text).toContain('Index of');
             } finally {
                 server.close();

package/__tests__/hidden-fixtures/.dot-dir/inside.txt

@@ -0,0 +1 @@
+dot dir file

package/__tests__/hidden-fixtures/.env

@@ -0,0 +1,2 @@
+SECRET_KEY=mysecretvalue
+DB_PASSWORD=hidden123

package/__tests__/hidden-fixtures/.well-known/acme-challenge.txt

@@ -0,0 +1 @@
+acme

package/__tests__/hidden-fixtures/config/secrets/password.txt

@@ -0,0 +1 @@
+password

package/__tests__/hidden-fixtures/data.key

@@ -0,0 +1 @@
+key data

package/__tests__/hidden-fixtures/file.secret

@@ -0,0 +1 @@
+secret data

package/__tests__/hidden-fixtures/index.html

@@ -0,0 +1 @@
+regular

package/__tests__/hidden-fixtures/normal.txt

@@ -0,0 +1 @@
+normal

package/__tests__/hidden-fixtures/subdir/.env

@@ -0,0 +1 @@
+NESTED_SECRET=nestedvalue

package/__tests__/hidden-fixtures/subdir/regular.txt

@@ -0,0 +1 @@
+regular in subdir