jasmine-browser-runner 0.6.0 → 0.10.0

package/README.md

@@ -8,13 +8,13 @@ using either headless Chrome or Saucelabs.
 # Getting started
 
 ```bash
-npm install --save-dev jasmine-browser-runner
+npm install --save-dev jasmine-browser-runner jasmine-core
 ```
 
 or
 
 ```bash
-yarn add -D jasmine-browser-runner
+yarn add -D jasmine-browser-runner jasmine-core
 ```
 
 Add a `spec/support/jasmine-browser.json`. For example:
@@ -67,15 +67,97 @@ Its value can be `"internet explorer"`, `"firefox"`, `"safari"`,
 
 If a source, spec, or helper file's name ends in `.mjs`, it will be loaded as
 an ES module rather than a regular script. Note that ES modules are not 
-available in all browsers supported by jasmine-browser. Currently, 
-jasmine-browser does not try to determine whether the browser supports ES
+available in all browsers supported by jasmine-browser-runner. Currently, 
+jasmine-browser-runner does not try to determine whether the browser supports ES
 modules. ES modules will silently fail to load in browsers that don't
 support them. Other kinds of load-time errors are detected and reported as suite
 errors.
 
+To allow spec files to import source files via relative paths, set the `specDir`
+config field to something that's high enough up to include both spec and source
+files, and set `srcFiles` to `[]`. You can autogenerate such a configuration by
+running `npx jasmine-browser-runner init --esm`.
+
+## Use with Rails
+
+You can use jasmine-browser-runner to test your Rails application's JavaScript,
+whether you use the Asset Pipeline or Webpacker.
+
+### Webpacker
+
+1. Run `yarn add --dev jasmine-browser-runner`.
+2. Run `npx jasmine-browser-runner init`.
+3. Edit `spec/support/jasmine-browser.json` as follows:
+```
+{
+  "srcDir": ".",
+  "srcFiles": [],
+  "specDir": "public/packs/js",
+  "specFiles": [
+    "specs-*.js"
+  ],
+  "helpers": [],
+  // ...
+}
+```
+4. Create `app/javascript/packs/specs.js` (or `app/javascript/packs/specs.jsx`
+   if you use JSX) as follows:
+```
+(function() {
+  'use strict';
+
+  function requireAll(context) {
+    context.keys().forEach(context);
+  }
+
+  requireAll(require.context('spec/javascript/helpers/', true, /\.js/));
+  requireAll(require.context('spec/javascript/', true, /[sS]pec\.js/));
+})();
+```
+5. Add `'spec/javascript'` to the `additional_paths` array in `config/webpacker.yml`.
+6. Put your spec files in `spec/javascript`.
+
+To run the specs:
+
+1. Run `bin/webpack --watch`.
+2. Run `npx jasmine-browser-runner`.
+3. visit <http://localhost:8888>.
+
+### Asset Pipeline
+
+1. Run `yarn init` if there isn't already `package.json` file in the root of
+   the Rails application.
+2. Run `yarn add --dev jasmine-browser-runner`.
+3. Run `npx jasmine-browser-runner init`.
+5. Edit `spec/support/jasmine-browser.json` as follows:
+```
+{
+  "srcDir": "public/assets",
+  "srcFiles": [
+    "application-*.js"
+  ],
+  "specDir": "spec/javascript",
+  "specFiles": [
+    "**/*[sS]pec.?(m)js"
+  ],
+  "helpers": [
+    "helpers/**/*.?(m)js"
+  ],
+  // ...
+}
+```
+6. Put your spec files in `spec/javascript`.
+
+To run the specs:
+
+1. Either run `bundle exec rake assets:precompile` or start the Rails 
+   application in an environment that's configured to precompile assets.
+2. Run `npx jasmine-browser-runner`.
+3. Visit <http://localhost:8888>.
+
 ## Saucelabs support
 
-jasmine-browser can run your Jasmine specs on [Saucelabs](https://saucelabs.com/).
+jasmine-browser-runner can run your Jasmine specs on [Saucelabs](https://saucelabs.com/).
 To use Saucelabs, set `browser.name`, `browser.useSauce`, and `browser.sauce`
 in your config file as follows:
 

package/bin/{jasmine-browser → jasmine-browser-runner}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 var path = require('path'),
-  jasmineCore = require('jasmine-core'),
+  jasmineCore = require('../lib/jasmineCore'),
   Command = require('../lib/command'),
   jasmineBrowser = require('../index.js');
 

package/config.js.ejs

@@ -0,0 +1 @@
+jasmine.getEnv().configure(<%- JSON.stringify(envConfig) %>);

package/index.js

@@ -1,39 +1,47 @@
-const ConsoleReporter = require('jasmine').ConsoleReporter,
+const ConsoleReporter = require('./lib/console_reporter'),
   webdriverModule = require('./lib/webdriver'),
-  util = require('util'),
   Server = require('./lib/server'),
-  Runner = require('./lib/runner');
+  Runner = require('./lib/runner'),
+  ModuleLoader = require('./lib/moduleLoader');
 
-function createReporters(options) {
-  if (!options.reporters) {
-    return createDefaultReporter(options);
+async function createReporters(options) {
+  const result = [];
+
+  if (options.useConsoleReporter !== false) {
+    const consoleReporter = new ConsoleReporter();
+    consoleReporter.setOptions({ color: options.color });
+    result.push(consoleReporter);
   }
 
-  const result = [];
+  if (options.reporters) {
+    // Resolve relative paths relative to the cwd, rather than the default
+    // which is the directory containing the moduleLoader module.
+    const loader = new ModuleLoader(process.cwd());
 
-  for (const reporterName of options.reporters) {
-    try {
-      const Reporter = require(reporterName);
-      result.push(new Reporter());
-    } catch (e) {
-      throw new Error(
-        `Failed to register reporter ${reporterName}: ${e.message}`
-      );
+    for (const reporterOrModuleName of options.reporters) {
+      if (typeof reporterOrModuleName === 'object') {
+        result.push(reporterOrModuleName);
+      } else {
+        try {
+          const Reporter = await loader.load(reporterOrModuleName);
+          result.push(new Reporter());
+        } catch (e) {
+          throw new Error(
+            `Failed to register reporter ${reporterOrModuleName}: ${e.message}`
+          );
+        }
+      }
     }
   }
 
-  return result;
-}
+  if (result.length === 0) {
+    throw new Error(
+      'No reporters were specified. Either add a reporter or remove ' +
+        '`useConsoleReporter: false`.'
+    );
+  }
 
-function createDefaultReporter(options) {
-  const reporter = new ConsoleReporter();
-  reporter.setOptions({
-    print: function() {
-      process.stdout.write(util.format.apply(this, arguments));
-    },
-    showColors: options.color === 'undefined' ? true : options.color,
-  });
-  return [reporter];
+  return result;
 }
 
 /**
@@ -53,7 +61,7 @@ module.exports = {
   },
   /**
    * Runs the specs.
-   * @param {RunSpecsOptions} options
+   * @param {Configuration} options
    * @return {Promise<JasmineDoneInfo>} A promise that resolves to the {@link https://jasmine.github.io/api/edge/global.html#JasmineDoneInfo|overall result} when the suite has finished running.
    */
   runSpecs: async function(options, deps) {
@@ -71,41 +79,46 @@ module.exports = {
       deps.buildWebdriver || webdriverModule.buildWebdriver;
     const setExitCode = deps.setExitCode || (code => (process.exitCode = code));
     const server = new ServerClass(options);
-    const webdriver = buildWebdriver(options.browser);
 
-    const reporters = createReporters(options);
+    const reporters = await createReporters(options);
     const useSauce = options.browser && options.browser.useSauce;
     const portRequest = useSauce ? 5555 : 0;
     await server.start({ port: portRequest });
-    const host = `http://localhost:${server.port()}`;
-    const runner = new RunnerClass({ webdriver, reporters, host });
-
-    console.log('Running tests in the browser...');
 
     try {
-      const details = await runner.run(options);
+      const webdriver = buildWebdriver(options.browser);
 
-      if (details.overallStatus === 'passed') {
-        setExitCode(0);
-      } else if (details.overallStatus === 'incomplete') {
-        setExitCode(2);
-      } else {
-        setExitCode(1);
-      }
+      try {
+        const host = `http://localhost:${server.port()}`;
+        const runner = new RunnerClass({ webdriver, reporters, host });
 
-      return details;
-    } finally {
-      await server.stop();
+        console.log('Running tests in the browser...');
 
-      if (useSauce) {
-        await webdriver.executeScript(
-          `sauce:job-result=${process.exitCode === 0}`
-        );
-      }
+        const details = await runner.run(options);
 
-      await webdriver.close();
+        if (details.overallStatus === 'passed') {
+          setExitCode(0);
+        } else if (details.overallStatus === 'incomplete') {
+          setExitCode(2);
+        } else {
+          setExitCode(1);
+        }
+
+        return details;
+      } finally {
+        if (useSauce) {
+          await webdriver.executeScript(
+            `sauce:job-result=${process.exitCode === 0}`
+          );
+        }
+
+        await webdriver.close();
+      }
+    } finally {
+      await server.stop();
     }
   },
   Server,
   Runner,
+  ConsoleReporter,
 };

package/lib/command.js

@@ -1,14 +1,14 @@
 const path = require('path');
 const fs = require('fs');
-const defaultConfig = require('./default_config');
+const {
+  loadConfig,
+  validateConfig,
+  defaultConfig,
+  defaultEsmConfig,
+} = require('./config');
 
 const commonOptions = [
   { name: 'config', type: 'string', description: 'path to the config file' },
-  {
-    name: 'clear-reporters',
-    type: 'bool',
-    description: 'clear default reporters in the HTML page',
-  },
   { name: 'port', type: 'number', description: 'port to run the server on' },
 ];
 
@@ -22,6 +22,14 @@ const subCommands = [
   {
     name: 'init',
     description: 'initialize a new Jasmine project',
+    options: [
+      {
+        name: 'esm',
+        type: 'bool',
+        description:
+          'configure for use with ES modules (<script type="module">)',
+      },
+    ],
   },
   {
     name: 'serve',
@@ -35,6 +43,7 @@ const subCommands = [
       {
         name: 'color',
         type: 'bool',
+        reversable: true,
         description: 'turn on or off color output',
       },
       {
@@ -43,19 +52,15 @@ const subCommands = [
         description:
           'filter specs to run only those that match the given string',
       },
-      {
-        name: 'stop-on-failure',
-        type: 'bool',
-        description: 'stop spec execution on expectation failure',
-      },
       {
         name: 'fail-fast',
         type: 'bool',
-        description: 'stop Jasmine execution on spec failure',
+        description: 'stop Jasmine execution on the first failure',
       },
       {
         name: 'random',
         type: 'bool',
+        reversable: true,
         description: 'turn on or off randomization',
       },
       {
@@ -141,7 +146,7 @@ class Command {
     this._logger.log('jasmine-core v' + this._config.jasmineCore.version());
   }
 
-  init() {
+  init(options) {
     const dest = 'spec/support/jasmine-browser.json';
 
     if (fs.existsSync(dest)) {
@@ -150,33 +155,40 @@ class Command {
     }
 
     fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.writeFileSync(dest, defaultConfig);
+
+    if (options.esm) {
+      fs.writeFileSync(dest, defaultEsmConfig());
+    } else {
+      fs.writeFileSync(dest, defaultConfig());
+    }
+
     this._logger.log(`Wrote configuration to ${dest}.`);
   }
 
   async serve(options) {
-    await this._config.jasmineBrowser.startServer(this._loadConfig(options));
+    await this._config.jasmineBrowser.startServer(
+      await this._loadConfig(options)
+    );
   }
 
   async runSpecs(options) {
-    await this._config.jasmineBrowser.runSpecs(this._loadConfig(options));
+    const config = await this._loadConfig(options);
+
+    if (options['fail-fast']) {
+      config.env = {
+        ...config.env,
+        stopSpecOnExpectationFailure: true,
+        stopOnSpecFailure: true,
+      };
+    }
+
+    await this._config.jasmineBrowser.runSpecs(config);
   }
 
-  _loadConfig(options) {
-    const configFile = options.config || 'spec/support/jasmine-browser.json';
-    delete options.config;
-    delete options.unknown;
-    Object.keys(options).forEach(function(opt) {
-      const camelCase = opt.replace(/-./g, function(input) {
-        return input[1].toUpperCase();
-      });
-      if (camelCase !== opt) {
-        options[camelCase] = options[opt];
-        delete options[opt];
-      }
-    });
-    const fullPath = path.resolve(this._config.baseDir, configFile);
-    return Object.assign({}, require(fullPath), options);
+  async _loadConfig(options) {
+    const config = await loadConfig(this._config.baseDir, options);
+    validateConfig(config);
+    return config;
   }
 }
 
@@ -219,9 +231,13 @@ function commandText(command) {
 }
 
 function optionText(option) {
-  return option.type === 'bool'
-    ? `--[no-]${option.name}`
-    : `--${option.name}=<value>`;
+  if (option.type !== 'bool') {
+    return `--${option.name}=<value>`;
+  } else if (option.reversable) {
+    return `--[no-]${option.name}`;
+  } else {
+    return `--${option.name}`;
+  }
 }
 
 function wrapDescription(indentLevel, prefixWidth, maxWidth, text) {

package/lib/config.js

@@ -0,0 +1,75 @@
+const path = require('path');
+const fs = require('fs');
+const ModuleLoader = require('./moduleLoader');
+
+async function loadConfig(baseDir, cliOptions) {
+  const options = { ...cliOptions };
+  const specifiedConfigFile = options.config;
+  delete options.config;
+  delete options.unknown;
+
+  Object.keys(options).forEach(function(opt) {
+    const camelCase = opt.replace(/-./g, function(input) {
+      return input[1].toUpperCase();
+    });
+    if (camelCase !== opt) {
+      options[camelCase] = options[opt];
+      delete options[opt];
+    }
+  });
+
+  const candidates = (specifiedConfigFile
+    ? [specifiedConfigFile]
+    : ['spec/support/jasmine-browser.js', 'spec/support/jasmine-browser.json']
+  )
+    .filter(name => !!name)
+    .map(name => path.resolve(baseDir, name));
+
+  const fullPath = candidates.find(p => fs.existsSync(p));
+
+  if (!fullPath) {
+    const msg =
+      'Could not find configuration file.\nTried:\n' +
+      candidates.map(p => `* ${p}`).join('\n');
+    throw new Error(msg);
+  }
+
+  const moduleLoader = new ModuleLoader();
+  return Object.assign({}, await moduleLoader.load(fullPath), options);
+}
+
+function validateConfig(config) {
+  for (const k of ['specDir', 'srcDir']) {
+    if (!config[k]) {
+      throw new Error('Configuration is missing ' + k);
+    }
+  }
+
+  for (const k of ['specFiles', 'srcFiles', 'helpers']) {
+    if (config[k] && !Array.isArray(config[k])) {
+      throw new Error(`Configuration's ${k} property is not an array`);
+    }
+  }
+}
+
+function defaultConfig() {
+  return fs.readFileSync(require.resolve('./examples/default_config.json'), {
+    encoding: 'utf8',
+  });
+}
+
+function defaultEsmConfig() {
+  return fs.readFileSync(
+    require.resolve('./examples/default_esm_config.json'),
+    {
+      encoding: 'utf8',
+    }
+  );
+}
+
+module.exports = {
+  loadConfig,
+  validateConfig,
+  defaultConfig,
+  defaultEsmConfig,
+};

package/lib/console_reporter.js

@@ -0,0 +1,307 @@
+const util = require('util');
+module.exports = exports = ConsoleReporter;
+
+/**
+ * @classdesc A reporter that prints spec and suite results to the console.
+ * A ConsoleReporter is installed unless {@link Configuration#useConsoleReporter}
+ * is set to false.
+ *
+ * @constructor
+ * @example
+ * const {ConsoleReporter} = require('jasmine');
+ * const reporter = new ConsoleReporter();
+ */
+function ConsoleReporter() {
+  let print = function() {
+      process.stdout.write(util.format.apply(this, arguments));
+    },
+    showColors = true,
+    jasmineCorePath = null,
+    specCount,
+    executableSpecCount,
+    failureCount,
+    failedSpecs = [],
+    pendingSpecs = [],
+    ansi = {
+      green: '\x1B[32m',
+      red: '\x1B[31m',
+      yellow: '\x1B[33m',
+      none: '\x1B[0m',
+    },
+    failedSuites = [],
+    stackFilter = defaultStackFilter;
+
+  /**
+   * Configures the reporter.
+   * @function
+   * @name ConsoleReporter#setOptions
+   * @param {ConsoleReporterOptions} options
+   */
+  this.setOptions = function(options) {
+    if (options.print) {
+      print = options.print;
+    }
+
+    /**
+     * @interface ConsoleReporterOptions
+     */
+    /**
+     * Whether to colorize the output
+     * @name ConsoleReporterOptions#color
+     * @type Boolean|undefined
+     * @default true
+     */
+    if (options.color !== undefined) {
+      showColors = options.color;
+    }
+
+    if (options.jasmineCorePath) {
+      jasmineCorePath = options.jasmineCorePath;
+    }
+    if (options.stackFilter) {
+      stackFilter = options.stackFilter;
+    }
+  };
+
+  this.jasmineStarted = function(options) {
+    specCount = 0;
+    executableSpecCount = 0;
+    failureCount = 0;
+    if (options && options.order && options.order.random) {
+      print('Randomized with seed ' + options.order.seed);
+      printNewline();
+    }
+    print('Started');
+    printNewline();
+  };
+
+  this.jasmineDone = function(result) {
+    printNewline();
+    printNewline();
+    if (failedSpecs.length > 0) {
+      print('Failures:');
+    }
+    for (let i = 0; i < failedSpecs.length; i++) {
+      specFailureDetails(failedSpecs[i], i + 1);
+    }
+
+    for (let i = 0; i < failedSuites.length; i++) {
+      suiteFailureDetails(failedSuites[i]);
+    }
+
+    if (
+      result &&
+      result.failedExpectations &&
+      result.failedExpectations.length > 0
+    ) {
+      suiteFailureDetails(result);
+    }
+
+    if (pendingSpecs.length > 0) {
+      print('Pending:');
+    }
+    for (let i = 0; i < pendingSpecs.length; i++) {
+      pendingSpecDetails(pendingSpecs[i], i + 1);
+    }
+
+    if (specCount > 0) {
+      printNewline();
+
+      if (executableSpecCount !== specCount) {
+        print(
+          'Ran ' +
+            executableSpecCount +
+            ' of ' +
+            specCount +
+            plural(' spec', specCount)
+        );
+        printNewline();
+      }
+      let specCounts =
+        executableSpecCount +
+        ' ' +
+        plural('spec', executableSpecCount) +
+        ', ' +
+        failureCount +
+        ' ' +
+        plural('failure', failureCount);
+
+      if (pendingSpecs.length) {
+        specCounts +=
+          ', ' +
+          pendingSpecs.length +
+          ' pending ' +
+          plural('spec', pendingSpecs.length);
+      }
+
+      print(specCounts);
+    } else {
+      print('No specs found');
+    }
+
+    printNewline();
+    const seconds = result ? result.totalTime / 1000 : 0;
+    print('Finished in ' + seconds + ' ' + plural('second', seconds));
+    printNewline();
+
+    if (result && result.overallStatus === 'incomplete') {
+      print('Incomplete: ' + result.incompleteReason);
+      printNewline();
+    }
+
+    if (result && result.order && result.order.random) {
+      print('Randomized with seed ' + result.order.seed);
+      print(
+        ' (jasmine-browser-runner runSpecs --seed=' + result.order.seed + ')'
+      );
+      printNewline();
+    }
+  };
+
+  this.specDone = function(result) {
+    specCount++;
+
+    if (result.status == 'pending') {
+      pendingSpecs.push(result);
+      executableSpecCount++;
+      print(colored('yellow', '*'));
+      return;
+    }
+
+    if (result.status == 'passed') {
+      executableSpecCount++;
+      print(colored('green', '.'));
+      return;
+    }
+
+    if (result.status == 'failed') {
+      failureCount++;
+      failedSpecs.push(result);
+      executableSpecCount++;
+      print(colored('red', 'F'));
+    }
+  };
+
+  this.suiteDone = function(result) {
+    if (result.failedExpectations && result.failedExpectations.length > 0) {
+      failureCount++;
+      failedSuites.push(result);
+    }
+  };
+
+  return this;
+
+  function printNewline() {
+    print('\n');
+  }
+
+  function colored(color, str) {
+    return showColors ? ansi[color] + str + ansi.none : str;
+  }
+
+  function plural(str, count) {
+    return count == 1 ? str : str + 's';
+  }
+
+  function repeat(thing, times) {
+    const arr = [];
+    for (let i = 0; i < times; i++) {
+      arr.push(thing);
+    }
+    return arr;
+  }
+
+  function indent(str, spaces) {
+    const lines = (str || '').split('\n');
+    const newArr = [];
+    for (let i = 0; i < lines.length; i++) {
+      newArr.push(repeat(' ', spaces).join('') + lines[i]);
+    }
+    return newArr.join('\n');
+  }
+
+  function defaultStackFilter(stack) {
+    if (!stack) {
+      return '';
+    }
+
+    const filteredStack = stack
+      .split('\n')
+      .filter(function(stackLine) {
+        return stackLine.indexOf(jasmineCorePath) === -1;
+      })
+      .join('\n');
+    return filteredStack;
+  }
+
+  function specFailureDetails(result, failedSpecNumber) {
+    printNewline();
+    print(failedSpecNumber + ') ');
+    print(result.fullName);
+    printFailedExpectations(result);
+
+    if (result.trace) {
+      printNewline();
+      print(indent('Trace:', 2));
+      printNewline();
+
+      for (const entry of result.trace) {
+        print(indent(`${entry.timestamp}ms: ${entry.message}`, 4));
+        printNewline();
+      }
+    }
+  }
+
+  function suiteFailureDetails(result) {
+    printNewline();
+    print('Suite error: ' + result.fullName);
+    printFailedExpectations(result);
+  }
+
+  function printFailedExpectations(result) {
+    for (let i = 0; i < result.failedExpectations.length; i++) {
+      const failedExpectation = result.failedExpectations[i];
+      printNewline();
+      print(indent('Message:', 2));
+      printNewline();
+      print(colored('red', indent(failedExpectation.message, 4)));
+      printNewline();
+      print(indent('Stack:', 2));
+      printNewline();
+      print(indent(stackFilter(failedExpectation.stack), 4));
+    }
+
+    // When failSpecWithNoExpectations = true and a spec fails because of no expectations found,
+    // jasmine-core reports it as a failure with no message.
+    //
+    // Therefore we assume that when there are no failed or passed expectations,
+    // the failure was because of our failSpecWithNoExpectations setting.
+    //
+    // Same logic is used by jasmine.HtmlReporter, see https://github.com/jasmine/jasmine/blob/main/src/html/HtmlReporter.js
+    if (
+      result.failedExpectations.length === 0 &&
+      result.passedExpectations.length === 0
+    ) {
+      printNewline();
+      print(indent('Message:', 2));
+      printNewline();
+      print(colored('red', indent('Spec has no expectations', 4)));
+    }
+
+    printNewline();
+  }
+
+  function pendingSpecDetails(result, pendingSpecNumber) {
+    printNewline();
+    printNewline();
+    print(pendingSpecNumber + ') ');
+    print(result.fullName);
+    printNewline();
+    let pendingReason = 'No reason given';
+    if (result.pendingReason && result.pendingReason !== '') {
+      pendingReason = result.pendingReason;
+    }
+    print(indent(colored('yellow', pendingReason), 2));
+    printNewline();
+  }
+}

package/lib/examples/default_config.json

@@ -0,0 +1,21 @@
+{
+  "srcDir": "src",
+  "srcFiles": [
+    "**/*.js"
+  ],
+  "specDir": "spec",
+  "specFiles": [
+    "**/*[sS]pec.js"
+  ],
+  "helpers": [
+    "helpers/**/*.js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "stopOnSpecFailure": false,
+    "random": true
+  },
+  "browser": {
+    "name": "firefox"
+  }
+}

package/lib/examples/default_esm_config.json

@@ -0,0 +1,19 @@
+{
+  "srcDir": "src",
+  "srcFiles": [],
+  "specDir": ".",
+  "specFiles": [
+    "spec/**/*[sS]pec.?(m)js"
+  ],
+  "helpers": [
+    "spec/helpers/**/*.?(m)js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "stopOnSpecFailure": false,
+    "random": true
+  },
+  "browser": {
+    "name": "firefox"
+  }
+}

package/lib/jasmineCore.js

@@ -0,0 +1,11 @@
+try {
+  module.exports = require('jasmine-core');
+} catch (e) {
+  if (e.code === 'MODULE_NOT_FOUND') {
+    throw new Error(
+      "Could not load jasmine-core. Please make sure that it's installed."
+    );
+  } else {
+    throw e;
+  }
+}

package/lib/moduleLoader.js

@@ -0,0 +1,38 @@
+const path = require('path');
+const url = require('url');
+
+class ModuleLoader {
+  constructor(parentDir, deps) {
+    deps = deps || {};
+    this.require_ = deps.requireShim || requireShim;
+    this.import_ = deps.importShim || importShim;
+    this.parentDir_ = parentDir;
+  }
+
+  async load(filePath) {
+    if (filePath.endsWith('.json')) {
+      return this.require_(filePath);
+    } else {
+      // The ES module spec requires absolute import paths to be valid URLs. As
+      // of v16, Node enforces this on Windows but not on other OSes.
+      if (path.isAbsolute(filePath)) {
+        filePath = url.pathToFileURL(filePath);
+      } else if (filePath.startsWith('./') || filePath.startsWith('../')) {
+        filePath = url.pathToFileURL(path.resolve(this.parentDir_, filePath));
+      }
+
+      const module = await this.import_(filePath);
+      return module.default;
+    }
+  }
+}
+
+function requireShim(path) {
+  return require(path);
+}
+
+function importShim(path) {
+  return import(path);
+}
+
+module.exports = ModuleLoader;

package/lib/runner.js

@@ -91,8 +91,6 @@ function urlParams(runOptions) {
       filterUndefined({
         random: runOptions.random,
         seed: runOptions.seed,
-        failFast: runOptions.failFast,
-        throwFailures: runOptions.stopOnFailure,
         spec: runOptions.filter,
       })
     )

package/lib/server.js

@@ -15,11 +15,12 @@ class Server {
    */
   constructor(options) {
     this.options = options;
-    this.clearReporters = options.clearReporters || false;
+    this.useHtmlReporter =
+      options.useHtmlReporter === undefined ? true : options.useHtmlReporter;
     this.batchReporter = options.batchReporter || false;
     this.jsonDomReporter = options.jsonDomReporter || false;
     this.projectBaseDir = options.projectBaseDir || path.resolve();
-    this.jasmineCore = options.jasmineCore || require('jasmine-core');
+    this.jasmineCore = options.jasmineCore || require('./jasmineCore');
     this.jasmineCssFiles = this.jasmineCore.files.cssFiles.map(function(
       fileName
     ) {
@@ -29,11 +30,15 @@ class Server {
       .map(function(fileName) {
         return unWindows(path.join('/__jasmine__', fileName));
       })
-      .concat(
-        this.jasmineCore.files.bootFiles.map(function(fileName) {
-          return unWindows(path.join('/__boot__', fileName));
-        })
-      );
+      .concat(this.bootFiles());
+  }
+
+  bootFiles() {
+    const bootFiles = this.jasmineCore.files.bootFiles.map(function(fileName) {
+      return unWindows(path.join('/__boot__', fileName));
+    });
+    bootFiles.splice(1, 0, '/__config__/config.js');
+    return bootFiles;
   }
 
   allCss() {
@@ -48,14 +53,14 @@ class Server {
   getUrls(baseDir, globs, urlRoot) {
     return findFiles(path.join(this.projectBaseDir, baseDir), globs || []).map(
       function(p) {
-        return unWindows(path.join(urlRoot, p));
+        return isUrl(p) ? p : unWindows(path.join(urlRoot, p));
       }
     );
   }
 
   getSupportFiles() {
     var result = ['/__support__/loadEsModule.js'];
-    if (this.clearReporters) {
+    if (!this.useHtmlReporter) {
       result.push('/__support__/clearReporters.js');
     }
 
@@ -118,15 +123,18 @@ class Server {
       express.static(path.join(this.projectBaseDir, this.options.srcDir))
     );
 
-    var template = ejs.compile(
+    var indexTemplate = ejs.compile(
       fs.readFileSync(path.resolve(__dirname, '../run.html.ejs')).toString()
     );
+    var configTemplate = ejs.compile(
+      fs.readFileSync(path.resolve(__dirname, '../config.js.ejs')).toString()
+    );
 
     var self = this;
     app.get('/', function(req, res) {
       try {
         res.send(
-          template({
+          indexTemplate({
             cssFiles: self.allCss(),
             jasmineJsFiles: self.jasmineJs(),
             userJsFiles: self.userJs(),
@@ -137,6 +145,19 @@ class Server {
         console.error(error);
       }
     });
+    app.get('/__config__/config.js', function(req, res) {
+      try {
+        res.append('Content-type', 'application/javascript');
+        res.send(
+          configTemplate({
+            envConfig: self.options.env || {},
+          })
+        );
+      } catch (error) {
+        res.status(500).send('An error occurred');
+        console.error(error);
+      }
+    });
 
     var port = findPort(serverOptions.port, this.options.port);
     return new Promise(resolve => {
@@ -200,6 +221,10 @@ function findPort(serverPort, optionsPort) {
   return 8888;
 }
 
+function isUrl(s) {
+  return s.startsWith('http://') || s.startsWith('https://');
+}
+
 function findFiles(baseDir, globs) {
   const { includeGlobs, excludeGlobs } = globs.reduce(
     function(ongoing, g) {
@@ -220,12 +245,16 @@ function findFiles(baseDir, globs) {
   const result = [];
 
   for (const g of includeGlobs) {
-    const files = glob.sync(g, { ignore: excludeGlobs, cwd: baseDir });
+    if (isUrl(g)) {
+      result.push(g);
+    } else {
+      const files = glob.sync(g, { ignore: excludeGlobs, cwd: baseDir });
 
-    for (const f of files) {
-      // De-duplicate
-      if (result.indexOf(f) === -1) {
-        result.push(f);
+      for (const f of files) {
+        // De-duplicate
+        if (result.indexOf(f) === -1) {
+          result.push(f);
+        }
       }
     }
   }

package/lib/types.js

@@ -9,9 +9,10 @@
  * @see Server
  */
 /**
- * Whether to remove Jasmine's default reporters before executing the suite.
- * @name ServerCtorOptions#clearReporters
+ * Whether to use Jasmine's default HTML reporter.
+ * @name ServerCtorOptions#useHtmlReporter
  * @type boolean | undefined
+ * @default true
  */
 /**
  * An array of CSS file paths or {@link https://github.com/isaacs/node-glob#glob-primer|globs}
@@ -71,26 +72,37 @@
  */
 
 /**
- * @interface RunSpecsOptions
+ * Specifies the properties of the configuration file, as well as
+ * the argument to runSpecs.
+ *
+ * @interface Configuration
  * @augments ServerCtorOptions
- * @augments RunnerRunOptions
  */
 /**
  * The browser to run the specs in.
- * @name RunSpecsOptions#browser
+ * @name Configuration#browser
  * @type string | BrowserInfo | undefined
  */
 /**
- * Whether to use color in the console output. Defaults to true.
- * @name RunSpecsOptions#color
+ * Whether to use color in the console output.
+ * @name Configuration#color
  * @type boolean | undefined
+ * @default true
+ */
+/**
+ * An array of {@link https://jasmine.github.io/api/edge/Reporter.html|reporters}
+ * or names of modules defining reporters. If an entry is a string, it should be
+ * the {@link https://nodejs.org/api/esm.html#esm_import_specifiers|import specifier}
+ * for a module that default exports a reporter constructor. The constructor will
+ * be called with no arguments.
+ * @name Configuration#reporters
+ * @type Array<string | Reporter>
  */
 /**
- * The name of a module to get a reporter from. The module will be loaded
- * using `require` and its default export must be a constructor that creates a
- * {@link https://jasmine.github.io/api/edge/Reporter.html|reporter}.
- * @name RunSpecsOptions#color
+ * Whether to use the built-in {@link ConsoleReporter}.
+ * @name Configuration#useConsoleReporter
  * @type boolean | undefined
+ * @default true
  */
 
 /**

package/package.json

@@ -1,27 +1,30 @@
 {
   "name": "jasmine-browser-runner",
-  "version": "0.6.0",
+  "version": "0.10.0",
   "description": "Serve and run your Jasmine specs in a browser",
-  "main": "index.js",
-  "bin": "bin/jasmine-browser",
+  "bin": "bin/jasmine-browser-runner",
+  "exports": "./index.js",
   "files": [
     "MIT.LICENSE",
     "README.md",
     "package.json",
     "index.js",
+    "config.js.ejs",
     "run.html.ejs",
     "bin/*.js",
-    "lib/**/*.js"
+    "lib/**/*.js",
+    "lib/examples/default_config.json",
+    "lib/examples/default_esm_config.json"
   ],
   "scripts": {
-    "posttest": "eslint bin/* lib/*.js lib/**/*.js spec/**/*.js scripts/*.js index.js --ignore-path=.styleIgnore && prettier --check --ignore-path=.styleIgnore lib/*.js lib/**/*.js spec/**/*.js scripts/*.js index.js",
+    "posttest": "eslint bin/* lib spec scripts index.js --ignore-path=.styleIgnore && prettier --check --ignore-path=.styleIgnore lib/*.js lib/**/*.js spec/**/*.js scripts/*.js index.js",
     "test": "jasmine",
     "cleanup": "prettier --write --ignore-path=.styleIgnore lib/*.js lib/**/*.js spec/**/*.js scripts/*.js index.js",
     "release": "node scripts/release.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jasmine/jasmine-browser.git"
+    "url": "git+https://github.com/jasmine/jasmine-browser-runner.git"
   },
   "keywords": [
     "jasmine",
@@ -29,25 +32,28 @@
     "tdd"
   ],
   "engines": {
-    "node": ">= 10.0"
+    "node": ">=14"
   },
   "author": "Slackersoft",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/jasmine/jasmine-browser/issues"
+    "url": "https://github.com/jasmine/jasmine-browser-runner/issues"
   },
-  "homepage": "https://github.com/jasmine/jasmine-browser#readme",
+  "homepage": "https://github.com/jasmine/jasmine-browser-runner#readme",
   "dependencies": {
-    "ejs": "^2.6.1",
+    "ejs": "^3.1.6",
     "express": "^4.16.4",
     "glob": "^7.1.7",
-    "jasmine": "^3.6.0",
-    "jasmine-core": "^3.6.0",
-    "selenium-webdriver": "^4.0.0-alpha.1"
+    "selenium-webdriver": "^4.1.0"
+  },
+  "peerDependencies": {
+    "jasmine-core": "^3.9.0"
   },
   "devDependencies": {
-    "eslint": "^5.16.0",
-    "eslint-plugin-jasmine": "^2.10.1",
+    "eslint": "^8.3.0",
+    "eslint-plugin-jasmine": "^4.1.3",
+    "jasmine": "^3.9.0",
+    "jasmine-core": "^3.9.0",
     "prettier": "^1.17.1",
     "shelljs": "^0.8.3",
     "temp": "^0.9.4"
@@ -69,7 +75,7 @@
       "expectAsync": "readonly"
     },
     "parserOptions": {
-      "ecmaVersion": 2018
+      "ecmaVersion": 11
     },
     "plugins": [
       "jasmine"
@@ -91,7 +97,13 @@
       "block-spacing": "error",
       "comma-dangle": [
         "error",
-        "always-multiline"
+        {
+          "arrays": "always-multiline",
+          "objects": "always-multiline",
+          "imports": "always-multiline",
+          "exports": "always-multiline",
+          "functions": "never"
+        }
       ],
       "func-call-spacing": [
         "error",
@@ -108,11 +120,13 @@
       "space-before-blocks": "error",
       "no-console": "off"
     },
-    "overrides": {
-      "files": "spec/**/*.js",
-      "env": {
-        "jasmine": true
+    "overrides": [
+      {
+        "files": "spec/**/*.js",
+        "env": {
+          "jasmine": true
+        }
       }
-    }
+    ]
   }
 }

package/run.html.ejs

@@ -8,6 +8,8 @@
   <% cssFiles.forEach(function(cssFile) { %>
     <link rel="stylesheet" href="<%= cssFile %>" type="text/css" media="screen"/>
   <% }) %>
+</head>
+<body>
   <% jasmineJsFiles.forEach(function(jsFile) { %>
     <script src="<%= jsFile %>" type="text/javascript"></script>
   <% }) %>
@@ -19,8 +21,6 @@
     <% } %>
   <% }) %>
 
-</head>
-<body>
 <div id="jasmine_content"></div>
 </body>
 </html>

package/lib/default_config.js

@@ -1,19 +0,0 @@
-module.exports =
-  '{\n' +
-  '  "srcDir": "src",\n' +
-  '  "srcFiles": [\n' +
-  '    "**/*.?(m)js"\n' +
-  '  ],\n' +
-  '  "specDir": "spec",\n' +
-  '  "specFiles": [\n' +
-  '    "**/*[sS]pec.?(m)js"\n' +
-  '  ],\n' +
-  '  "helpers": [\n' +
-  '    "helpers/**/*.?(m)js"\n' +
-  '  ],\n' +
-  '  "random": true,\n' +
-  '  "stopSpecOnExpectationFailure": false,\n' +
-  '  "browser": {\n' +
-  '    "name": "firefox"\n' +
-  '  }\n' +
-  '}';