jasmine-browser-runner 0.7.0 → 1.0.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:
@@ -60,18 +60,95 @@ To use a browser other than Firefox, add a `browser` field to
 }
 ```
 
-Its value can be `"internet explorer"`, `"firefox"`, `"safari"`, 
+Its value can be `"firefox"`, `"safari"`, 
 `"MicrosoftEdge"`, `"chrome"`, or `"headlessChrome"`.
 
 ## ES module support
 
 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-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.
+an ES module rather than a regular script.
+
+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
 

package/bin/jasmine-browser-runner

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
 var path = require('path'),
-  jasmineCore = require('jasmine-core'),
+  jasmineCore = require('../lib/jasmineCore'),
   Command = require('../lib/command'),
   jasmineBrowser = require('../index.js');
+const UsageError = require('../lib/usage_error');
 
 var command = new Command({
   baseDir: path.resolve(),
@@ -13,6 +14,9 @@ var command = new Command({
 });
 
 command.run(process.argv.slice(2)).catch(function(error) {
-  console.error(error);
+  if (!(error instanceof UsageError)) {
+    console.error(error);
+  }
+
   process.exitCode = 1;
 });

package/config.js.ejs

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

package/index.js

@@ -1,34 +1,46 @@
-const DefaultReporter = require('./lib/default_reporter'),
+const ConsoleReporter = require('./lib/console_reporter'),
   webdriverModule = require('./lib/webdriver'),
   Server = require('./lib/server'),
   Runner = require('./lib/runner'),
   ModuleLoader = require('./lib/moduleLoader');
 
 async function createReporters(options) {
-  if (!options.reporters) {
-    return [new DefaultReporter(options)];
+  const result = [];
+
+  if (options.useConsoleReporter !== false) {
+    const consoleReporter = new ConsoleReporter();
+    consoleReporter.setOptions({ color: options.color });
+    result.push(consoleReporter);
   }
 
-  const result = [];
-  // 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 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}`
-        );
+  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 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}`
+          );
+        }
       }
     }
   }
 
+  if (result.length === 0) {
+    throw new Error(
+      'No reporters were specified. Either add a reporter or remove ' +
+        '`useConsoleReporter: false`.'
+    );
+  }
+
   return result;
 }
 
@@ -49,17 +61,11 @@ 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) {
     options = options || {};
-    if (options.browser && options.browser.name === 'internet explorer') {
-      options.jsonDomReporter = true;
-    } else {
-      options.batchReporter = true;
-    }
-
     deps = deps || {};
     const ServerClass = deps.Server || Server;
     const RunnerClass = deps.Runner || Runner;
@@ -84,12 +90,19 @@ module.exports = {
 
         const details = await runner.run(options);
 
+        // Use 0 only for complete success
+        // Avoid 1 because Node uses that for unhandled exceptions etc., and
+        // some users have CI systems that want to distinguish between spec
+        // failures and crashes.
         if (details.overallStatus === 'passed') {
           setExitCode(0);
+        } else if (anyLoadErrors(details)) {
+          // Use node's general failure code
+          setExitCode(1);
         } else if (details.overallStatus === 'incomplete') {
           setExitCode(2);
         } else {
-          setExitCode(1);
+          setExitCode(3);
         }
 
         return details;
@@ -108,5 +121,14 @@ module.exports = {
   },
   Server,
   Runner,
-  DefaultReporter,
+  ConsoleReporter,
 };
+
+function anyLoadErrors(jasmineDoneInfo) {
+  const failures = jasmineDoneInfo.failedExpectations || [];
+  const loadError = failures.find(function(fe) {
+    return fe.globalErrorType === 'load';
+  });
+
+  return !!loadError;
+}

package/lib/command.js

@@ -1,14 +1,15 @@
 const path = require('path');
 const fs = require('fs');
-const { loadConfig, validateConfig, defaultConfig } = require('./config');
+const {
+  loadConfig,
+  validateConfig,
+  defaultConfig,
+  defaultEsmConfig,
+} = require('./config');
+const UsageError = require('./usage_error');
 
 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 +23,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 +44,7 @@ const subCommands = [
       {
         name: 'color',
         type: 'bool',
+        reversable: true,
         description: 'turn on or off color output',
       },
       {
@@ -43,19 +53,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',
       },
       {
@@ -91,7 +97,8 @@ class Command {
     });
 
     if (!toRun) {
-      return this.help();
+      this.help();
+      throw new UsageError();
     } else if (toRun.options) {
       return this[toRun.name](parseOptions(toRun, args.slice(1)));
     } else {
@@ -141,7 +148,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,7 +157,13 @@ 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}.`);
   }
 
@@ -161,7 +174,17 @@ class Command {
   }
 
   async runSpecs(options) {
-    await this._config.jasmineBrowser.runSpecs(await 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);
   }
 
   async _loadConfig(options) {
@@ -210,9 +233,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

@@ -52,24 +52,24 @@ function validateConfig(config) {
   }
 }
 
-const defaultConfig =
-  '{\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' +
-  '}';
+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 };
+module.exports = {
+  loadConfig,
+  validateConfig,
+  defaultConfig,
+  defaultEsmConfig,
+};

package/lib/console_reporter.js

@@ -0,0 +1,311 @@
+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) {
+    if (result.failedExpectations) {
+      failureCount += result.failedExpectations.length;
+    }
+
+    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.debugLogs) {
+      printNewline();
+      print(indent('Debug logs:', 2));
+      printNewline();
+
+      for (const entry of result.debugLogs) {
+        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/runner.js

@@ -18,22 +18,6 @@ function getBatch(driver) {
   );
 }
 
-async function jsDomReporterResults(webdriver) {
-  const resultsEl = await new Promise(function(resolve) {
-    function poll() {
-      webdriver.findElement({ id: 'jasmine-jsonDomReporter-done' }).then(
-        el => resolve(el),
-        () => setTimeout(poll, 1000)
-      );
-    }
-
-    poll();
-  });
-
-  const text = await resultsEl.getText();
-  return JSON.parse(text);
-}
-
 function proxyToReporters(batch, reporters) {
   batch.forEach(function(result) {
     const fn = result[0];
@@ -91,8 +75,6 @@ function urlParams(runOptions) {
       filterUndefined({
         random: runOptions.random,
         seed: runOptions.seed,
-        failFast: runOptions.failFast,
-        throwFailures: runOptions.stopOnFailure,
         spec: runOptions.filter,
       })
     )
@@ -122,21 +104,7 @@ class Runner {
       this._options.host + urlParams(runOptions)
     );
 
-    if (runOptions.jsonDomReporter) {
-      console.log(
-        "Note: Results won't be shown until the entire suite has finished running."
-      );
-      let results = await jsDomReporterResults(this._options.webdriver);
-      proxyToReporters(results, this._options.reporters);
-
-      if (!isDone(results)) {
-        throw new Error("Didn't find a jasmineDone event");
-      }
-
-      return runDetails(results);
-    } else {
-      return await runTillEnd(this._options.webdriver, this._options.reporters);
-    }
+    return await runTillEnd(this._options.webdriver, this._options.reporters);
   }
 }
 

package/lib/server.js

@@ -15,11 +15,10 @@ class Server {
    */
   constructor(options) {
     this.options = options;
-    this.clearReporters = options.clearReporters || false;
-    this.batchReporter = options.batchReporter || false;
-    this.jsonDomReporter = options.jsonDomReporter || false;
+    this.useHtmlReporter =
+      options.useHtmlReporter === undefined ? true : options.useHtmlReporter;
     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 +28,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,25 +51,18 @@ 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');
     }
 
-    if (this.batchReporter) {
-      result.push('/__support__/batchReporter.js');
-    }
-
-    if (this.jsonDomReporter) {
-      result.push('/__support__/jsonDomReporter.js');
-    }
-
+    result.push('/__support__/batchReporter.js');
     return result;
   }
 
@@ -118,15 +114,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 +136,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 +212,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 +236,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
  */
 
 /**
@@ -104,7 +116,7 @@
  * @type boolean | undefined
  */
 /**
- * The browser name. Valid values include "internet explorer", "firefox",
+ * The browser name. Valid values include "firefox",
  * "safari", "MicrosoftEdge", "chrome", and "headlessChrome".
  * @name BrowserInfo#name
  * @type string | undefined

package/lib/usage_error.js

@@ -0,0 +1,9 @@
+class UsageError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
+UsageError.prototype.name = 'UsageError';
+
+module.exports = UsageError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jasmine-browser-runner",
-  "version": "0.7.0",
+  "version": "1.0.0",
   "description": "Serve and run your Jasmine specs in a browser",
   "bin": "bin/jasmine-browser-runner",
   "exports": "./index.js",
@@ -9,45 +9,48 @@
     "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",
     "testing",
     "tdd"
   ],
-  "engines": {
-    "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.8.0",
-    "jasmine-core": "^3.6.0",
-    "selenium-webdriver": "^4.0.0-alpha.1"
+    "selenium-webdriver": "^4.1.0"
+  },
+  "peerDependencies": {
+    "jasmine-core": "^4.0.0"
   },
   "devDependencies": {
-    "eslint": "^6.8.0",
-    "eslint-plugin-jasmine": "^2.10.1",
+    "eslint": "^7.32.0",
+    "eslint-plugin-jasmine": "^4.1.3",
+    "jasmine": "^4.0.0",
+    "jasmine-core": "^4.0.0",
     "prettier": "^1.17.1",
     "shelljs": "^0.8.3",
     "temp": "^0.9.4"

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_reporter.js

@@ -1,19 +0,0 @@
-const ConsoleReporter = require('jasmine').ConsoleReporter;
-const util = require('util');
-
-function DefaultReporter(options) {
-  options = options || {};
-  ConsoleReporter.call(this);
-
-  this.setOptions({
-    print: function() {
-      process.stdout.write(util.format.apply(this, arguments));
-    },
-    randomSeedReproductionCmd: function(seed) {
-      return 'jasmine-browser-runner runSpecs --seed=' + seed;
-    },
-    showColors: options.color === 'undefined' ? true : options.color,
-  });
-}
-
-module.exports = DefaultReporter;

package/lib/support/jsonDomReporter.js

@@ -1,45 +0,0 @@
-/* eslint-env browser, jasmine */
-
-// This is mainly intended for use with IE. When controlling IE,
-// webdriver.executeScript is unreliable. It tends to fail if too
-// much JS is running on the page when it's called or if the return
-// value of the executed JS is non-tiny. Both of these are common
-// conditions in Jasmine. JsonDomReporter works around the problem
-// by exposing all data through the DOM, so that the runner can
-// entirely avoid calling webdriver.executeScript. The drawback is
-// that results can't be shown until all specs have finished.
-function JsonDomReporter() {
-  var events = [];
-
-  this.jasmineStarted = function(info) {
-    events.push(['jasmineStarted', info]);
-  };
-
-  this.suiteStarted = function(info) {
-    events.push(['suiteStarted', info]);
-  };
-
-  this.specStarted = function(info) {
-    events.push(['specStarted', info]);
-  };
-
-  this.jasmineDone = function(info) {
-    events.push(['jasmineDone', info]);
-
-    var resultsEl = document.createElement('div');
-    resultsEl.id = 'jasmine-jsonDomReporter-done';
-    resultsEl.textContent = JSON.stringify(events);
-    document.body.appendChild(resultsEl);
-  };
-
-  this.suiteDone = function(info) {
-    events.push(['suiteDone', info]);
-  };
-
-  this.specDone = function(info) {
-    events.push(['specDone', info]);
-  };
-}
-
-window.jsonDomReporter = new JsonDomReporter();
-jasmine.getEnv().addReporter(window.jsonDomReporter);