Ninja Pumpkin Mutants

    classy-test

    1.2.0 • Public • Published

    Classy Test

    Build Status

    Opinionated class based testing framework.

    Features

    • Extensible es6 class test case. Leverage more with less code.
    • Structured tests name syntax - testMyComponentCanAdd.
    • TAP reporting with node-tap
    • Full A+ promise support through bluebird

    Install

    $ npm install classy-test

    Usage

    Command Line Interface

    $ node node_modules/classy-test/bin/classy-test-cli.js

    Exported Module

    const ClassyTestRunner = require("classy-test");
    new ClassyTestRunner().run();

    API

    ClassyTestRunner([options])

    options

    directories

    Type: string[]
    Default: ['test']

    Relative paths to all directories that should be searched for test case files.

    extension

    Type: string (test file extension)
    Default: '.test.js'

    Set the default file extension for your test files.

    disableLogging

    Type: boolean (disable interal classy test logging)
    Default: false

    This is used for our internal testing to make the logs cleaner. It is exposed has a "quality-of-life" feature.

    Examples

    Simple

    Component

    my-project/lib/component.js

    "use strict";
     
    class SimpleComponent {
        constructor(numbers) {
            this.numbers = numbers;
        }
     
        sum() {
            return this.numbers.reduce((a, b) => a + b);
        }
     
        sort() {
            return this.numbers.sort();
        }
    }
     
    module.exports = SimpleComponent;

    Test File

    my-project/test/component.test.js

    "use strict";
     
    const Component = require("../lib/component"),
        classyTest = require("classy-test"),
        assert = require("chai").assert;
     
    // extend base test case.
    class ComponentTestCase extends classyTest.BaseTestCase {
        constructor() {
            super();
        }
     
        // prefix all test functions in your test case with 'test'
        testSum() {
            assert.equal(new Component([1, 2, 3, 4]).sum(), 10);
        }
     
        testSort() {
            assert.deepEqual(new Component([4, 1, 5, 2, 3]).sort(), [1, 2, 3, 4, 5]);
        }
    }
     
    // export an array of test cases you want to run
    module.exports = [
        ComponentTestCase
    ];

    Promise Support

    "use strict";
     
    const classyTest = require("../index.js"),
        assert = require("chai").assert;
     
    class Invoice {
        // simulate async database interaction
        static getById(id) {
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    if (id) {
                        resolve({
                            id: 123,
                            amount: 100,
                            currency: "USD"
                        });
                    } else {
                        reject(new Error("invoice_not_found"));
                    }
                }, 200);
            });
        }
    }
     
    // test case for all your project needs
    class ProjectBaseTestCase extends classyTest.BaseTestCase {
        constructor() {
            super();
        }
     
        setup() {
            super.setup();
            return this.bootstrapDatabase();
        }
     
        teardown() {
            super.teardown();
            return this.teardownDatabase();
        }
     
        bootstrapDatabase() {
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve();
                }, 500)
            });
        }
     
        teardownDatabase() {
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    resolve();
                }, 500)
            });
        }
    }
     
    // Simple test case extended our base project test case
    class InvoiceTestCase extends ProjectBaseTestCase {
        constructor() {
            super();
        }
     
        testGetById() {
            return Invoice.getById(123).then(invoice => {
                assert.deepEqual(invoice, {
                    id: 123,
                    amount: 100,
                    currency: "USD"
                });
            }).catch(console.error);
        }
     
        testGetByIdError() {
            return Invoice.getById(null).then(() => {
                assert.isFalse(true, "the underlying promise should have failed. This block should never be run");
            }).catch(error => {
                assert.equal(error.message, "invoice_not_found");
            });
        }
    }
     
    module.exports = [InvoiceTestCase];

    For more examples check here.

    Team

    John Rake

    License

    MIT © John Rake

    Install

    npm i classy-test

    DownloadsWeekly Downloads

    1

    Version

    1.2.0

    License

    MIT

    Last publish

    Collaborators

    • vikeen