JUnit

A simple promise based function for unit tests. I believe we shouldn't waste time on learning, debugging and waiting the unit test framework itself, that's why I created JUnit. It's just a curried function, everything inside is controllable, nothing will be fancy.

Install

Node.js

npm install junit then you can var junit = require("junit").default or import junit from "junit".

Browser

You can to use something like browserify or webpack, or download the bundled junit.js. A real world example.

Features

• Supports both Node.js and old browsers
• Should work well from ES3 to ES7
• Make it super easy to concurrently test async functions, designed for async-await
• Automatically garbage collect the unhandled error
• Full customizable report style
• Not a single global variable pollution
• Only one dependency, light weight and behavior predictable

FAQ

• I don't want to use async-await.

  No problem. Just replace all the await expresses with standard promise ones is enough.

• I cannot require('junit').

  For non-es6, use require('junit').default.

• IE6?

  The core framework of JUnit will work. But the default reporter only supports IE8>=, you may have to install & config to another reporter to support old browsers.

CLI

Install junit globally: npm i -g junit. It will automatically take advantage of the babel if you have installed it globally.

For example, created a file test/fib-test.js, it should export a function, if the function is async it should return a promise, such as:

import sleep from "yaku/lib/sleep";

module.exports = async it => {
    await sleep(3000);

    it("fib 01", () => eq(1 + 1, 2));

    it("fib 02", () => eq(1 + 2, 3));

    it("fib 03", () => eq(2 + 3, 5));
};

Run the tests via junit test/*.js.

For more documentation, run junit -h.

To watch and auto-rerun test please use noe:

noe -b junit -w 'test/*.js' -- 'test/*.js'

API

• junit(opts)
• run()
• eq(actual, expected, maxDepth)
• describe(msg, fn)
• junit.reporter(opts)
• junit.Promise
• junit.yutils

• junit(opts)

  A simple promise based module for unit tests.

  • param: opts { Object }

    Defaults:

      {
          filter: (msg) => true
    
          // Stop test when error occurred.
          isBail: true,
    
          isFailOnUnhandled: true,
    
          // If any test failed, throw on final.
          isThrowOnFinal: true,
    
          // Fail a test after timeout.
          timeout: 5000,
    
          reporter: {
              // You can even use jsdiff here to generate more fancy error info.
              formatAssertErr: (actual, expected) => {},
    
              logPass: (msg, span) => {},
              logFail: (msg, err, span) => {},
              logFinal: (total, tested, passed, failed) => {}
          }
      }

  • return: { Function }

    (msg, fn) => Function The msg can be anything. The fn's first param is a function (after) =>, you can pass a after hook to it.

  • example:

      import junit from "junit";
      var it = junit();
      (async () => {
          // Async tests.
          it("test 1", () =>
              // We use `it.eq` to assert on both simple type and complex object.
              it.eq("ok", "ok")
          );
    
          it("test 2", async () => {
              // No more callback hell while testing async functions.
              await new junit.Promise(r => setTimeout(r, 1000));
    
              return it.eq({ a: 1, b: 2 }, { a: 1, b: 2 });
          });
    
          // Run sync tests within the main async flow.
          await it("test 3", (after) =>
              after(() => {
                  // do some clean work after the test
              });
    
              it.eq("ok", "ok")
          );
    
          it.run();
      })();

  • example:

    Filter the tests, only the message starts with "test" will be tested.

      import junit from "junit";
      var it = junit({
          filter: (msg) => msg.indexOf("test")
      });
    
      (async () => {
          it("basic 1", () => it.eq(1, 1));
          it("test 1", () => it.eq(1, 1));
          it("test 2", () => it.eq(1, 1));
    
          // Get the result of the test.
          var { total, tested, passed, failed } = await it.run();
    
          console.log(total, tested, passed, failed);
      })();

• run()

  Start the tests.

  • return: { Promise }

    It will resolve { total, passed, failed }

• eq(actual, expected, maxDepth)

  A smart strict deep equality assertion helper function. If any of the arguments is promise, it will be auto-resolved before comparision.

  • param: actual { Any }

  • param: expected { Any }

  • param: maxDepth { Number = 7 }

    Optional. The max depth of the recursion check.

  • return: { Promise }

• describe(msg, fn)

  Extend the msg of the test with a new test closure.

  • param: msg { Any }

    The msg object of the test.

  • param: fn { Function }

    (it) => Promise The new msg closure.

  • return: { Promise }

  • example:

      import junit from "junit";
    
      var it = junit();
      var { eq } = it;
    
      it.describe("level 01", it => {
          it("test 01", () => eq(1, 1));
    
          it("test 02", () => eq(1, 1));
    
          it.describe("level 02", it => {
              it("test 01", () => eq(1, 1));
    
              it("test 02", () => eq(1, 1));
          });
      });
    
      it.run();

• junit.reporter(opts)

  An example reporter for junit.

  • param: opts { Object }

    Defaults:

      {
          prompt: String, // The prompt prefix
          mode: "console" // "console", "browser" or "none"
      }

  • return: { Function }

    () => Object.

  • example:

      var it = junit({ reporter: junit.reporter({ prompt: 'my-prompt > ' }) });

• junit.Promise

  The promise class that junit uses: Yaku

  • type: { Object }

• junit.yutils

  The promise helpers: Yaku Utils

  • type: { Object }