@putout/plugin-tape [![NPM version][NPMIMGURL]][NPMURL]

[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-tape.svg?style=flat&longCache=true
[NPMURL]: https://npmjs.org/package/@putout/plugin-tape "npm"

> Tape-inspired TAP-compatible simplest high speed test runner with superpowers.
>
> (c) 📼Supertape

🐊Putout plugin helps to apply best parctises for tests written with 📼Supertape.

Install

``
npm i @putout/plugin-tape -D
`

Rules

- ✅ add-args;
- ✅ add-t-end;
- ✅ apply-destructuring;
- ✅ apply-stub;
- ✅ apply-with-name;
- ✅ convert-called-with-args;
- ✅ convert-called-with-no-args-to-called-with;
- ✅ convert-called-with-to-called-with-no-args;
- ✅ convert-deep-equal-to-equal;
- ✅ convert-does-not-throw-to-try-catch;
- ✅ convert-emitter-to-promise;
- ✅ convert-equal-to-called-once;
- ✅ convert-equal-to-deep-equal;
- ✅ convert-equal-to-not-ok;
- ✅ convert-equal-to-ok;
- ✅ convert-equals-to-equal;
- ✅ convert-match-regexp-to-string;
- ✅ convert-ok-to-called-with;
- ✅ convert-ok-to-match;
- ✅ convert-tape-to-supertape;
- ✅ convert-throws-to-try-catch;
- ✅ declare;
- ✅ jest;
- ✅ remove-default-messages;
- ✅ remove-only;
- ✅ remove-skip;
- ✅ remove-useless-not-called-args;
- ✅ remove-useless-t-end;
- ✅ switch-expected-with-result;
- ✅ sync-with-name;

Config

`json
{
"rules": {
"tape/jest": "on",
"tape/apply-stub": "on",
"tape/apply-destructuring": "on",
"tape/apply-with-name": "on",
"tape/add-t-end": "on",
"tape/remove-useless-t-end": "on",
"tape/sync-with-name": "on",
"tape/switch-expected-with-result": "on",
"tape/convert-tape-to-supertape": "on",
"tape/convert-throws-to-try-catch": "on",
"tape/convert-does-not-throw-to-try-catch": "on",
"tape/convert-called-with-args": "on",
"tape/convert-called-with-to-called-with-no-args": "on",
"tape/convert-called-with-no-args-to-called-with": "on",
"tape/convert-equal-to-called-once": "on",
"tape/convert-equal-to-deep-equal": "on",
"tape/convert-equals-to-equal": "on",
"tape/convert-deep-equal-to-equal": "on",
"tape/convert-emitter-to-promise": "on",
"tape/convert-ok-to-match": "on",
"tape/convert-ok-to-called-with": "on",
"tape/convert-match-regexp-to-string": "on",
"tape/add-args": "on",
"tape/declare": "on",
"tape/remove-default-messages": "on",
"tape/remove-useless-not-called-args": "on",
"tape/remove-only": "on",
"tape/remove-skip": "on"
}
}
`

jest

🐊Putout gives ability to switch easily from Jest to 📼Supertape. Checkout in 🐊Putout Editor.

$3

`js
it('should equal', () => {
expect(a).toEqual(b);
});
`

$3

`js
import {test} from 'supertape';

test('should equal', () => {
t.equal(a, b);
t.end();
});
`

switch-expected-with-result

📼Supertape uses more natural way of
comparing: first you pass result and then expected.

It gives you ability to use value instead of expected and
understand code faster: no need to search for a second argument.
While result is always a variable, so it most likely much shorter.

$3

`js
test('plugin-apply-destructuring: transform: array: destructuring', (t) => {
t.equal(expected, result);
t.end();
});
`

$3

`js
test('plugin-apply-destructuring: transform: array: destructuring', (t) => {
t.equal(result, expected);
t.end();
});
`

convert-tape-to-supertape

$3

`js
const test = require('tape');
`

$3

`js
const test = require('supertape');
`

convert-throws-to-try-catch

$3

`js
const test = require('supertape');

test('some message', (t) => {
t.throws(copymitter, /from should be a string!/, 'should throw when no args');
t.end();
});
`

$3

`js
const {tryCatch} = require('try-catch');
const test = require('supertape');

test('some message', (t) => {
const [error] = tryCatch(copymitter);

t.equal(error.message, 'from should be a string!');
t.end();
});
`

convert-does-not-throw-to-try-catch

$3

`js
const test = require('supertape');

test('some message', (t) => {
t.doesNotThrow(copymitter, 'should throw when no args');
t.end();
});
`

$3

`js
const test = require('supertape');
const {tryCatch} = require('try-catch');

test('some test', (t) => {
const [error] = tryCatch(copymitter);

t.notOk(error, 'should not throw when no args');
t.end();
});
`

convert-called-with-args

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledWith(fn, 'hello');
t.end();
});
`

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledWith(fn, ['hello']);
t.end();
});
`

convert-equal-to-called-once

No need to use equal, supertape supports calledOnce.

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.equal(fn.callCount, 1);
t.end();
});
`

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledOnce(fn);
t.end();
});
`

convert-deep-equal-to-equal

Use equal when comparing with primitives, deepEqual for Objects and Arrays;

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
t.deepEqual(x, 5);
t.end();
});
`

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
t.equal(x, 5);
t.end();
});
`

convert-called-with-to-called-with-no-args

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledWith(fn);
t.end();
});
`

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledWithNoArgs(fn);
t.end();
});
`

convert-called-with-no-args-to-called-with

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledWithNoArgs(fn, [1, 2]);
t.end();
});
`

$3

`js
const test = require('supertape');
const {stub} = test;

test('some message', (t) => {
const fn = stub();
fn();

t.calledWith(fn, [1, 2]);
t.end();
});
`

convert-emitter-to-promise

$3

`js
test('copymitter', (t) => {
const cp = copymitter(from, to, ['1']);

cp.on('end', (t) => {
t.end();
});
});
`

$3

`js
const {once} = require('node:events');

test('copymitter', async (t) => {
const cp = copymitter(from, to, ['1']);

await once(cp, 'end');

t.end();
});
`

apply-destructuring

Check out in 🐊Putout Editor.

$3

`js
const test = require('supertape');
`

$3

`js
const {test} = require('supertape');
`

apply-stub

Apply stub functions created. Look how it works in 🐊Putout Editor.

$3

`js
const a = async () => true;
const b = async () => {};
const c = async () => throwError('hello');

const d = async () => {
throw Error('hello');
};
`

$3

`js
const a = stub().resolves(true);
const b = stub().resolves();
const c = stub().rejects(Error('hello'));
const d = stub().rejects(Error('hello'));
`

apply-with-name

$3

`js
test('should call init before show', (t) => {
const init = stub();
const show = stub();

t.calledInOrder([init, show]);
t.end();
});
`

$3

`js
test('should call init before show', (t) => {
const init = stub().withName('init');
const show = stub().withName('show');

t.calledInOrder([init, show]);
t.end();
});
`

sync-with-name

$3

`js
test('should call init before show', (t) => {
const init = stub().withName('show');
const show = stub().withName('show');

t.calledInOrder([init, show]);
t.end();
});
`

$3

`js
test('should call init before show', (t) => {
const init = stub().withName('init');
const show = stub().withName('show');

t.calledInOrder([init, show]);
t.end();
});
`

declare

$3

`js
test('xxx', (t) => {
const a = stub();
t.end();
});
`

$3

`js
import {test, stub} from 'supertape';

test('xxx', (t) => {
const a = stub();
t.end();
});
`

add-args

$3

`js
test('xxx', () => {
t.end();
});
`

$3

`js
test('xxx', (t) => {
t.end();
});
`

add-t-end

$3

`js
test('xxx', () => {});
`

$3

`js
test('xxx', (t) => {
t.end();
});
`

remove-useless-t-end

$3

`js
test('test: remove me', () => {
t.end();
t.end();
});
`

$3

`js
test('test: remove me', () => {
t.end();
});
`

convert-ok-to-match

$3

`js
t.ok(result.includes('hello'));
`

$3

`js
t.match(result, /hello/);
`

convert-ok-to-called-with

$3

`js
t.ok(set.calledWith(1, 2));
`

$3

`js
t.calledWith(set, [1, 2]);
`

convert-equal-to-not-ok

$3

`js
t.equal(error, null);
`

$3

`js
t.notOk(error);
`

convert-equal-to-ok

$3

`js
t.equal(result, true);
`

$3

`js
t.ok(result);
`

convert-equal-to-deep-equal

$3

`js
const expected = {
hello: 'world',
};

t.equal(error, expected);
t.end();
`

$3

`js
const expected = {
hello: 'world',
};

t.deepEqual(error, expected);
t.end();
`

convert-equals-to-equal

Checkout in 🐊Putout Editor.

$3

`js
t.equals(e.message, 'token should be a string!', 'should throw');
`

$3

`js
t.equal(e.message, 'token should be a string!', 'should throw');
`

convert-match-regexp-to-string

$3

`js
t.match(result, RegExp('hello'));
`

$3

`js
t.match(result, 'hello');
`

remove-default-messages

📼Supertape will put this information for you, and it is always the same.
No need to repeat the same information twice on one line, better to avoid it.

$3

`js
t.equal(result, expected, 'should equal');
`

$3

`js
t.equal(result, expected);
`

remove-useless-not-called-args

$3

`js
t.notCalled(fn, []);
`

$3

`js
t.notCalled(fn);
`

remove-only

$3

`js
test.only('some test', (t) => {
t.end();
});

testDeclareBeforeReference.only('some test', (t) => {
t.end();
});
`

$3

`js
test('some test', (t) => {
t.end();
});

testDeclareBeforeReference('some test', (t) => {
t.end();
});
`

remove-skip

$3

`js
test.skip('some test', (t) => {
t.end();
});
`

$3

`js
test('some test', (t) => {
t.end();
});
``

License

MIT