@olton/easytest NPM

EasyTest

Simple testing framework for JavaScript and TypeScript, written in pure JavaScript.

Core features:

No need to import it, test, describe or ecpext in your test file. These functions are available globally.
You can use both js and ts test files in the same project.
Asynchronous code testing.
TypeScript testing out of the box.
Global DOM object for testing HTML objects.
Built-in coverage tool.
Verbose or non verbose mode.
Mock functions.
Big set of built-in matchers.
Extend expect function with your own matchers.
Compatible with codecov report viewer.
A lot of expects in one test case.
Setup and Teardown functions (beforeEach, afterEach, beforeAll, afterAll).

Support for PayPal to serhii@pimenov.com.ua

NPM Downloads

Installation

npm install @olton/easytest -D

Usage

To use EasyTest you don't need to import it, test or describe in your test file. Create a test file with *.test.js or *.test.ts extension (for example). You can use both of them in the same project.

function hello() {
    return "Hello"
}

describe(`Common tests suite`, () => {
    it(`says hello`, () => {
        return expect(hello()).toBe("Hello")
    })
})

test(`Bad test 2 !== 1`, () => {
    return expect(2).toBe(1)
})

Async tests

async function fetchData() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve("Data received");
        }, 1000);
    });
}

describe('Async function tests', async () => {
    it('should return data after 1 second', async () => {
        const data = await fetchData();
        return expect(data).toBe("Bad Data");
    });
});

Update package.json to run tests with easytest command.

{
    "scripts": {
        "test": "easytest"
    }
}

Functions

describe - create test suite
it - create a test case
expect - create assertion
beforeEach - run before each test case
afterEach - run after each test case
beforeAll - run before all test cases
afterAll - run after all test cases
test - create simple test
mocker - create mock function
DOM - create DOM object (not global)

Matchers

EasyTest contains a big set of built-in matchers:

A simple comparison
A strong comparison
Type checking
Number checking
String checking
Array checking
Object checking
Color checking
IP, Email, Url checking
JSON, XML checking
Date, RegExp, Symbol checking
Function checking
HTML element checking
and more...

TypeScript

To use EasyTest with TypeScript you need to install tsx package.

npm install tsx -D

and then

{
    "scripts": {
        "test": "cross-env NODE_OPTIONS=\"--import tsx\" easytest"
    }
}

cross-env

Run scripts that set and use environment variables across platforms.

npm install --save-dev cross-env

Configuration

To configure EasyTest you need to create a easytest.json file in the root of your project. Also, you can use argument --config=fileName to specify a configuration file.

{
    "scripts": {
        "test": "easytest --config=myconfig.json"
    }
}

EasyTest designed as a config-free testing framework. But you can configure it to your needs. The default values are:

{
  "include": ["**/*.spec.{t,j}s", "**/*.spec.{t,j}sx", "**/*.test.{t,j}s", "**/*.test.{t,j}sx"],
  "exclude": ["node_modules/**"],
  "coverage": false,
  "verbose": false,
  "dom": false,
  "test": "*",  
  "report": {
    "type": "lcov",
    "dir": "coverage"
  }
}

You can use cli arguments to configure EasyTest:

--config=file_name.json - path to the configuration file.
--coverage - enable coverage tool.
--verbose - enable verbose mode.
--include=**/*.spec.{t,j}s - include files for testing.
--exclude=node_modules/** - exclude files from testing.
--test=test_name - execute only tests whose name contains value.
--dom - enable global DOM.

{
  "scripts": {
    "test": "easytest --coverage --verbose --include=**/core.spec.{t,j}s"
  }
}

DOM Environment

EasyTest has a global DOM object for testing HTML objects (we use JSDOM to create DOM environment). To enable global DOM, you need to use parameter --dom in the command line, or set dom to true in the configuration file.

{
    "scripts": {
        "test": "easytest --dom"
    }
}

Extend expect

You can extend the expect function with your own matchers.

import {Expect} from "@olton/easytest";

class MyExpect extends Expect {
    toBeEven() {
        let received = this.received
        let result = received % 2 === 0
        if (!result) {
            this.message = `Expected ${received} to be even`
        }
    }
}

const expect = (received) => new MyExpect(received)

test(`Custom expect`, () => {
    expect(2).toBeEven()
})