Improve Code Coverage (#562)

package.json

@@ -73,6 +73,7 @@
  "posthtml-include": "^1.1.0",
  "prettier": "^1.9.1",
  "rimraf": "^2.6.1",
+ "sinon": "^4.2.2",
  "sourcemap-validator": "^1.0.6",
  "stylus": "^0.54.5",
  "typescript": "^2.6.2"

src/Logger.js

@@ -25,7 +25,7 @@ class Logger {
  this.lines += message.split('\n').length;
  }
 
- console.log(message);
+ this._log(message);
  }
 
  log(message) {
@@ -119,6 +119,10 @@ class Logger {
  handleMessage(options) {
  this[options.method](...options.args);
  }
+
+ _log(message) {
+ console.log(message);
+ }
 }
 
 // If we are in a worker, make a proxy class which will

src/assets/WebManifestAsset.js

@@ -16,13 +16,13 @@ class WebManifestAsset extends Asset {
  icon.src = this.addURLDependency(icon.src);
  }
  }
- 
+
  if (Array.isArray(this.ast.screenshots)) {
  for (let shot of this.ast.screenshots) {
  shot.src = this.addURLDependency(shot.src);
  }
  }
- 
+
  if (this.ast.serviceworker && this.ast.serviceworker.src) {
  this.ast.serviceworker.src = this.addURLDependency(
  this.ast.serviceworker.src

src/utils/customErrors.js

@@ -1,15 +1,17 @@
-let serverErrorList = {
+const serverErrorList = {
  EACCES: "You don't have access to bind the server to port {port}.",
  EADDRINUSE: 'There is already a process listening on port {port}.'
 };
 
 function serverErrors(err, port) {
- let desc = serverErrorList[err.code].replace(/{port}/g, port);
- if (!desc) {
- desc = `Error: ${
- err.code
- } occurred while setting up server on port ${port}.`;
+ let desc = `Error: ${
+ err.code
+ } occurred while setting up server on port ${port}.`;
+
+ if (serverErrorList[err.code]) {
+ desc = serverErrorList[err.code].replace(/{port}/g, port);
  }
+
  return desc;
 }
 

src/utils/fs.js

@@ -6,6 +6,7 @@ exports.readFile = promisify(fs.readFile);
 exports.writeFile = promisify(fs.writeFile);
 exports.stat = promisify(fs.stat);
 exports.readdir = promisify(fs.readdir);
+exports.unlink = promisify(fs.unlink);
 
 exports.exists = function(filename) {
  return new Promise(resolve => {

test/asset.js

@@ -1,7 +1,24 @@
-const {strictEqual} = require('assert');
+const assert = require('assert');
 const Asset = require('../src/Asset');
 
 describe('Asset', () => {
+ it('should include default implementations', async () => {
+ const a = new Asset(__filename, undefined, {rootDir: '/root/dir'});
+ Object.assign(a, {
+ type: 'type',
+ contents: 'contents'
+ });
+
+ const err = new Error();
+
+ assert(a.shouldInvalidate() === false);
+ assert(a.mightHaveDependencies());
+ assert.deepEqual(await a.generate(), {
+ type: 'contents'
+ });
+ assert.equal(a.generateErrorMessage(err), err);
+ });
+
  describe('addURLDependency', () => {
  const bundleName = 'xyz';
  const options = {
@@ -18,21 +35,27 @@ describe('Asset', () => {
 
  it('should ignore urls', () => {
  const url = 'https://parceljs.org/assets.html';
- strictEqual(asset.addURLDependency(url), url);
+ assert.strictEqual(asset.addURLDependency(url), url);
  });
 
  it('should ignore empty string', () => {
- strictEqual(asset.addURLDependency(''), '');
+ assert.strictEqual(asset.addURLDependency(''), '');
  });
 
  it('should generate bundle name', () => {
- strictEqual(asset.addURLDependency('foo'), bundleName);
+ assert.strictEqual(asset.addURLDependency('foo'), bundleName);
  });
 
  it('should preserve query and hash', () => {
- strictEqual(asset.addURLDependency('foo#bar'), `${bundleName}#bar`);
- strictEqual(asset.addURLDependency('foo?bar'), `${bundleName}?bar`);
- strictEqual(
+ assert.strictEqual(
+ asset.addURLDependency('foo#bar'),
+ `${bundleName}#bar`
+ );
+ assert.strictEqual(
+ asset.addURLDependency('foo?bar'),
+ `${bundleName}?bar`
+ );
+ assert.strictEqual(
  asset.addURLDependency('foo?bar#baz'),
  `${bundleName}?bar#baz`
  );

test/bundler.js

@@ -1,4 +1,5 @@
 const assert = require('assert');
+const sinon = require('sinon');
 const {bundler, nextBundle} = require('./utils');
 
 describe('bundler', function() {
@@ -9,4 +10,43 @@ describe('bundler', function() {
  await nextBundle(b);
  assert(b.mainAsset);
  });
+
+ it('should defer bundling if a bundle is pending', async () => {
+ const b = bundler(__dirname + '/integration/html/index.html');
+ b.pending = true; // bundle in progress
+ const spy = sinon.spy(b, 'bundle');
+
+ // first bundle, with existing bundle pending
+ const bundlePromise = b.bundle();
+
+ // simulate bundle finished
+ b.pending = false;
+ b.emit('buildEnd');
+
+ // wait for bundle to complete
+ await bundlePromise;
+
+ assert(spy.calledTwice);
+ });
+
+ it('should enforce asset type path to be a string', () => {
+ const b = bundler(__dirname + '/integration/html/index.html');
+
+ assert.throws(() => {
+ b.addAssetType('.ext', {});
+ }, 'should be a module path');
+ });
+
+ it('should enforce setup before bundling', () => {
+ const b = bundler(__dirname + '/integration/html/index.html');
+ b.farm = true; // truthy
+
+ assert.throws(() => {
+ b.addAssetType('.ext', __filename);
+ }, 'before bundling');
+
+ assert.throws(() => {
+ b.addPackager('type', 'packager');
+ }, 'before bundling');
+ });
 });

test/customErrors.js

@@ -0,0 +1,29 @@
+const assert = require('assert');
+const customErrors = require('../src/utils/customErrors');
+
+const port = 1234;
+
+const EACCES = new Error();
+EACCES.code = 'EACCES';
+const EADDRINUSE = new Error();
+EADDRINUSE.code = 'EADDRINUSE';
+
+describe('customErrors', () => {
+ it('should include port in server errors', () => {
+ const msg = customErrors.serverErrors(EACCES, port);
+ assert(msg.includes(port));
+ });
+
+ it('should handle known server errors', () => {
+ let msg = customErrors.serverErrors(EACCES, port);
+ assert(msg.includes(`don't have access`));
+
+ msg = customErrors.serverErrors(EADDRINUSE, port);
+ assert(msg.includes('already'));
+ });
+
+ it('should handled unknown server errors', () => {
+ let msg = customErrors.serverErrors(new Error(), port);
+ assert(msg.includes(port));
+ });
+});

test/fs-cache.js

@@ -0,0 +1,142 @@
+const assert = require('assert');
+const path = require('path');
+const rimraf = require('rimraf');
+const fs = require('../src/utils/fs');
+const promisify = require('../src/utils/promisify');
+const {sleep} = require('./utils');
+const ncp = promisify(require('ncp'));
+const FSCache = require('../src/FSCache');
+
+const cachePath = path.join(__dirname, '.cache');
+const inputPath = path.join(__dirname, '/input');
+
+const getMTime = async file => {
+ const stat = await fs.stat(file);
+ const mtime = stat.mtime.getTime();
+ return mtime;
+};
+
+describe('FSCache', () => {
+ beforeEach(() => {
+ rimraf.sync(cachePath);
+ rimraf.sync(inputPath);
+ });
+
+ it('should create directory on ensureDirExists', async () => {
+ let exists = await fs.exists(cachePath);
+ assert(!exists);
+
+ const cache = new FSCache({cacheDir: cachePath});
+ await cache.ensureDirExists();
+
+ exists = await fs.exists(cachePath);
+ assert(exists);
+ });
+
+ it('should cache resources', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ await cache.write(__filename, {a: 'test', b: 1, dependencies: []});
+
+ let cached = await cache.read(__filename);
+ assert.equal(cached.a, 'test');
+ assert.equal(cached.b, 1);
+ });
+
+ it('should return null for invalidated resources', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ cache.invalidate(__filename);
+
+ let cached = await cache.read(__filename);
+ assert.equal(cached, null);
+ });
+
+ it('should remove file on delete', async () => {
+ let cache = new FSCache({cacheDir: cachePath});
+ await cache.write(__filename, {a: 'test', b: 1, dependencies: []});
+ await cache.delete(__filename);
+
+ let cached = await cache.read(__filename);
+ assert.equal(cached, null);
+ });
+
+ it('should remove from invalidated on write', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ cache.invalidate(__filename);
+
+ assert(cache.invalidated.has(__filename));
+
+ await cache.write(__filename, {a: 'test', b: 1, dependencies: []});
+
+ assert(!cache.invalidated.has(__filename));
+ });
+
+ it('should include mtime for dependencies included in parent', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ const mtime = await getMTime(__filename);
+
+ await cache.write(__filename, {
+ a: 'test',
+ b: 1,
+ dependencies: [
+ {
+ includedInParent: true,
+ name: __filename
+ },
+ {
+ name: __filename
+ }
+ ]
+ });
+
+ const cached = await cache.read(__filename);
+ assert.equal(cached.dependencies[0].mtime, mtime);
+ assert.equal(cached.dependencies[1].mtime, undefined);
+ });
+
+ it('should invalidate when dependency included in parent changes', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ await ncp(__dirname + '/integration/fs', inputPath);
+ const filePath = path.join(inputPath, 'test.txt');
+
+ await cache.write(__filename, {
+ dependencies: [
+ {
+ includedInParent: true,
+ name: filePath
+ }
+ ]
+ });
+
+ // delay and update dependency
+ await sleep(50);
+ await fs.writeFile(filePath, 'world');
+
+ const cached = await cache.read(__filename);
+ assert.equal(cached, null);
+ });
+
+ it('should return null on read error', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ const cached = await cache.read(
+ path.join(__dirname, '/does/not/exist.txt')
+ );
+
+ assert.equal(cached, null);
+ });
+
+ it('should continue without throwing on write error', async () => {
+ const cache = new FSCache({cacheDir: cachePath});
+ const filePath = path.join(__dirname, '/does/not/exist.txt');
+
+ assert.doesNotThrow(async () => {
+ await cache.write(__filename, {
+ dependencies: [
+ {
+ includedInParent: true,
+ name: filePath
+ }
+ ]
+ });
+ });
+ });
+});