tape-harness

    5.1.0 • Public • Published

    tape-harness

    A helper to run integration tests against an application

    Motivation

    When writing integration tests against a service you generally want to spawn up an instance of the application.

    Writing tests against an application can be tedious without a helper to do common setup & teardown before & after every test.

    The tape-harness package will setup your test harness / runner / application before each test block and spin them down after each test block.

    This functionality is similar to beforeEach or afterEach that might exist in other testing libraries but is instead implemented as a standalone library that's compatible with vanilla tape and tap

    Example

    Your test file

    // test/what.js
    'use strict';
    
    var tape = require('tape');
    var request = require('request');
    
    var MyTestHarness = require('./lib/test-harness.js');
    
    MyTestHarness.test('a test', {
        port: 8000
    }, function t(harness, assert) {
        request({
            url: 'http://localhost:' + harness.port + '/foo'
        }, function onResponse(err, resp, body) {
            assert.ifError(err);
    
            assert.equal(resp.statusCode, 200);
            assert.equal(resp.body, '/foo');
    
            assert.end();
        });
    });
    
    tape('a test without tape-harness', function t(assert) {
        var harness = new MyTestHarness({
            port: 8000
        });
        harness.bootstrap(function (err) {
            assert.ifError(err);
            request({
                url: 'http://localhost:' + harness.port + '/foo'
            }, function onResponse(err, resp, body) {
                assert.ifError(err);
    
                assert.equal(resp.statusCode, 200);
                assert.equal(resp.body, '/foo');
    
                harness.close(function (err) {
                    assert.ifError(err);
                    assert.end();
                });
            });
        });
    });

    Your actual test-harness.js

    // test-harness.js
    'use strict';
    
    var tape = require('tape');
    var http = require('http');
    var tapeHarness = require('tape-harness');
    
    MyTestHarness.test = tapeHarness(tape, MyTestHarness);
    
    module.exports = MyTestHarness;
    
    function MyTestHarness(opts) {
        if (!(this instanceof MyTestHarness)) {
            return new MyTestHarness(opts);
        }
    
        var self = this;
    
        self.assert = opts.assert;
        self.port = opts.port;
        self.server = http.createServer();
    
        self.server.on('request', onRequest);
    
        function onRequest(req, res) {
            res.end(req.url);
        }
    }
    
    MyTestHarness.prototype.bootstrap = function bootstrap(cb) {
        var self = this;
    
        self.server.once('listening', cb);
        self.server.listen(self.port);
    };
    
    MyTestHarness.prototype.close = function close(cb) {
        var self = this;
    
        self.server.close(cb);
    };

    ES6 example

    const fetch = require('node-fetch')
    
    const MyTestHarness = require('./lib/test-harness.js');
    
    MyTestHarness.test('a test', {
        port: 8000
    }, async function t(harness, assert) {
        const res = await fetch(`http://localhost:${harness.port}/foo`)
    
        const text = await res.text()
        assert.equal(res.status, 200)
        assert.equal(text, '/foo')
    });
    const tape = require('tape');
    const http = require('http');
    const tapeHarness = require('tape-harness');
    
    class TestHarness {
        constructor(opts) {
            this.port = opts.port
            this.server = http.createServer()
    
            this.server.on('request', (req, res) => {
                res.end(req.url)
            })
        }
    
        async bootstrap() {
            return new Promise((resolve) => {
                this.server.once('listening', resolve)
                this.server.listen(this.port)
            })
        }
    
        async close() {
            return new Promise((resolve, reject) => {
                this.server.close((err) => {
                    if (err) return reject(err)
                    resolve()
                })
            })
        }
    }
    
    TestHarness.test = tapeHarness(tape, TestHarness)

    Installation

    npm install tape-harness

    Tests

    npm test

    Contributors

    • Raynos

    MIT Licensed

    Keywords

    none

    Install

    npm i tape-harness

    DownloadsWeekly Downloads

    0

    Version

    5.1.0

    License

    none

    Unpacked Size

    64.5 kB

    Total Files

    14

    Last publish

    Collaborators

    • raynos