chore(utils): add getPaths helper as separate util (#674)

Author: knagaitsev

src/utils/getFilenameFromUrl.js

@@ -4,30 +4,13 @@ import querystring from 'querystring';
 
 import mem from 'mem';
 
-function getPaths(stats, options) {
-  const childStats = stats.stats ? stats.stats : [stats];
-  const publicPaths = [];
-
-  for (const { compilation } of childStats) {
-    // The `output.path` is always present and always absolute
-    const outputPath = compilation.getPath(compilation.outputOptions.path);
-    const publicPath = options.publicPath
-      ? compilation.getPath(options.publicPath)
-      : compilation.outputOptions.publicPath
-      ? compilation.getPath(compilation.outputOptions.publicPath)
-      : '';
-
-    publicPaths.push({ outputPath, publicPath });
-  }
-
-  return publicPaths;
-}
+import getPaths from './getPaths';
 
 const memoizedParse = mem(parse);
 
 export default function getFilenameFromUrl(context, url) {
   const { options } = context;
-  const paths = getPaths(context.stats, options);
+  const paths = getPaths(context);
 
   let filename;
   let urlObject;

src/utils/getPaths.js

@@ -0,0 +1,19 @@
+export default function getPaths(context) {
+  const { stats, options } = context;
+  const childStats = stats.stats ? stats.stats : [stats];
+  const publicPaths = [];
+
+  for (const { compilation } of childStats) {
+    // The `output.path` is always present and always absolute
+    const outputPath = compilation.getPath(compilation.outputOptions.path);
+    const publicPath = options.publicPath
+      ? compilation.getPath(options.publicPath)
+      : compilation.outputOptions.publicPath
+      ? compilation.getPath(compilation.outputOptions.publicPath)
+      : '';
+
+    publicPaths.push({ outputPath, publicPath });
+  }
+
+  return publicPaths;
+}

test/api.test.js

@@ -198,12 +198,18 @@ describe('API', () => {
   });
 
   describe('context property', () => {
-    it('should contain public properties', () => {
+    it('should contain public properties', (done) => {
       expect(instance.context.state).toBeDefined();
       expect(instance.context.options).toBeDefined();
       expect(instance.context.compiler).toBeDefined();
       expect(instance.context.watching).toBeDefined();
       expect(instance.context.outputFileSystem).toBeDefined();
+
+      // the compilation needs to finish, as it will still be running
+      // after the test is done if not finished, potentially impacting other tests
+      compiler.hooks.done.tap('wdm-test', () => {
+        done();
+      });
     });
   });
 });

test/fixtures/webpack.public-path.config.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const path = require('path');
+
+module.exports = {
+  mode: 'development',
+  context: path.resolve(__dirname),
+  entry: './simple.js',
+  output: {
+    filename: 'bundle.js',
+    path: path.resolve(__dirname, '../outputs/public-path'),
+    publicPath: '/public/path/',
+  },
+  infrastructureLogging: {
+    level: 'none'
+  },
+  stats: 'errors-warnings'
+};

test/helpers/listenAndCompile.js

@@ -0,0 +1,25 @@
+export default (app, compiler, done) => {
+  let complete = 0;
+  // wait until the app is listening and the done hook is called
+  const progress = () => {
+    complete += 1;
+    if (complete === 2) {
+      done();
+    }
+  };
+
+  const listen = app.listen((error) => {
+    if (error) {
+      // if there is an error, don't wait for the compilation to finish
+      return done(error);
+    }
+
+    return progress();
+  });
+
+  compiler.hooks.done.tap('wdm-test', () => {
+    return progress();
+  });
+
+  return listen;
+};

test/utils/getFilenameFromUrl.test.js

@@ -0,0 +1,152 @@
+import path from 'path';
+
+import express from 'express';
+
+import middleware from '../../src';
+import getFilenameFromUrl from '../../src/utils/getFilenameFromUrl';
+
+import getCompiler from '../helpers/getCompiler';
+import listenAndCompile from '../helpers/listenAndCompile';
+import webpackSimpleConfig from '../fixtures/webpack.simple.config';
+import webpackPublicPathConfig from '../fixtures/webpack.public-path.config';
+import webpackMultiConfig from '../fixtures/webpack.array.config';
+
+describe('getFilenameFromUrl', () => {
+  const configs = [
+    {
+      title: 'simple config with path /',
+      config: webpackSimpleConfig,
+      middlewareConfig: {},
+      url: '/',
+      expected: path.resolve(__dirname, '../outputs/simple/index.html'),
+    },
+    {
+      title: 'simple config with path /index.html',
+      config: webpackSimpleConfig,
+      middlewareConfig: {},
+      url: '/index.html',
+      expected: path.resolve(__dirname, '../outputs/simple/index.html'),
+    },
+    {
+      title: 'simple config with path /path',
+      config: webpackSimpleConfig,
+      middlewareConfig: {},
+      url: '/path',
+      expected: path.resolve(__dirname, '../outputs/simple/path'),
+    },
+    {
+      title: 'simple config with path /path/file.html',
+      config: webpackSimpleConfig,
+      middlewareConfig: {},
+      url: '/path/file.html',
+      expected: path.resolve(__dirname, '../outputs/simple/path/file.html'),
+    },
+    {
+      title: 'simple config with index false and path /',
+      config: webpackSimpleConfig,
+      middlewareConfig: {
+        index: false,
+      },
+      url: '/',
+      expected: path.resolve(__dirname, '../outputs/simple'),
+    },
+    {
+      title: 'simple config with index file.html and path /',
+      config: webpackSimpleConfig,
+      middlewareConfig: {
+        index: 'file.html',
+      },
+      url: '/',
+      expected: path.resolve(__dirname, '../outputs/simple/file.html'),
+    },
+
+    {
+      title: 'publicPath config with path /',
+      config: webpackPublicPathConfig,
+      middlewareConfig: {},
+      url: '/',
+      expected: null,
+    },
+    {
+      title: 'publicPath config with path /public/path/',
+      config: webpackPublicPathConfig,
+      middlewareConfig: {},
+      url: '/public/path/',
+      expected: path.resolve(__dirname, '../outputs/public-path/index.html'),
+    },
+    {
+      title: 'publicPath config with path /public/path/more/file.html',
+      config: webpackPublicPathConfig,
+      middlewareConfig: {},
+      url: '/public/path/more/file.html',
+      expected: path.resolve(
+        __dirname,
+        '../outputs/public-path/more/file.html'
+      ),
+    },
+
+    {
+      title: 'multi config with path /',
+      config: webpackMultiConfig,
+      middlewareConfig: {},
+      url: '/',
+      expected: null,
+    },
+    {
+      title: 'multi config with path /static-one/',
+      config: webpackMultiConfig,
+      middlewareConfig: {},
+      url: '/static-one/',
+      expected: path.resolve(__dirname, '../outputs/array/js1/index.html'),
+    },
+    {
+      title: 'multi config with path /static-two/',
+      config: webpackMultiConfig,
+      middlewareConfig: {},
+      url: '/static-two/',
+      expected: path.resolve(__dirname, '../outputs/array/js2/index.html'),
+    },
+  ];
+
+  configs.forEach((config) => {
+    describe(config.title, () => {
+      let instance;
+      let listen;
+      let app;
+      let compiler;
+
+      beforeEach((done) => {
+        compiler = getCompiler(config.config);
+
+        instance = middleware(compiler, config.middlewareConfig);
+
+        app = express();
+        app.use(instance);
+
+        listen = listenAndCompile(app, compiler, done);
+      });
+
+      afterEach((done) => {
+        if (instance) {
+          instance.close();
+        }
+
+        if (listen) {
+          listen.close(done);
+        } else {
+          done();
+        }
+      });
+
+      it('should return correct filename from url', () => {
+        const filename = getFilenameFromUrl(instance.context, config.url);
+        const { expected } = config;
+        if (expected) {
+          expect(filename).toEqual(expected);
+        } else {
+          expect(filename).toBeUndefined();
+        }
+      });
+    });
+  });
+});

test/utils/getPaths.test.js

@@ -0,0 +1,87 @@
+import path from 'path';
+
+import express from 'express';
+
+import middleware from '../../src';
+import getPaths from '../../src/utils/getPaths';
+
+import getCompiler from '../helpers/getCompiler';
+import listenAndCompile from '../helpers/listenAndCompile';
+import webpackSimpleConfig from '../fixtures/webpack.simple.config';
+import webpackPublicPathConfig from '../fixtures/webpack.public-path.config';
+import webpackMultiConfig from '../fixtures/webpack.array.config';
+
+describe('getPaths', () => {
+  const configs = [
+    {
+      title: 'simple config',
+      config: webpackSimpleConfig,
+      expected: [
+        {
+          outputPath: path.resolve(__dirname, '../outputs/simple'),
+          publicPath: '',
+        },
+      ],
+    },
+    {
+      title: 'publicPath config',
+      config: webpackPublicPathConfig,
+      expected: [
+        {
+          outputPath: path.resolve(__dirname, '../outputs/public-path'),
+          publicPath: '/public/path/',
+        },
+      ],
+    },
+    {
+      title: 'multi config',
+      config: webpackMultiConfig,
+      expected: [
+        {
+          outputPath: path.resolve(__dirname, '../outputs/array/js1'),
+          publicPath: '/static-one/',
+        },
+        {
+          outputPath: path.resolve(__dirname, '../outputs/array/js2'),
+          publicPath: '/static-two/',
+        },
+      ],
+    },
+  ];
+
+  configs.forEach((config) => {
+    describe(config.title, () => {
+      let instance;
+      let listen;
+      let app;
+      let compiler;
+
+      beforeEach((done) => {
+        compiler = getCompiler(config.config);
+
+        instance = middleware(compiler);
+
+        app = express();
+        app.use(instance);
+
+        listen = listenAndCompile(app, compiler, done);
+      });
+
+      afterEach((done) => {
+        if (instance) {
+          instance.close();
+        }
+
+        if (listen) {
+          listen.close(done);
+        } else {
+          done();
+        }
+      });
+
+      it('should return correct paths', () => {
+        expect(getPaths(instance.context)).toEqual(config.expected);
+      });
+    });
+  });
+});