peach a19a732be8 commit message | 2 rokov pred | |
---|---|---|
.. | ||
build | 2 rokov pred | |
node_modules | 2 rokov pred | |
LICENSE | 2 rokov pred | |
README.md | 2 rokov pred | |
package.json | 2 rokov pred |
A parameterised testing library for Jest inspired by mocha-each.
jest-each allows you to provide multiple arguments to your test
/describe
which results in the test/suite being run once per row of parameters.
.test
to runs multiple tests with parameterised data
.it
.test.only
to only run the parameterised tests
.it.only
or .fit
.test.skip
to skip the parameterised tests
.it.skip
or .xit
or .xtest
.test.concurrent
.it.concurrent
.test.concurrent.only
.it.concurrent.only
.test.concurrent.skip
.it.concurrent.skip
.describe
to runs test suites with parameterised data.describe.only
to only run the parameterised suite of tests
.fdescribe
.describe.skip
to skip the parameterised suite of tests
.xdescribe
done
printf
formatting:
%p
- pretty-format.%s
- String.%d
- Number.%i
- Integer.%f
- Floating point value.%j
- JSON.%o
- Object.%#
- Index of the test case.%%
- single percent sign ('%'). This does not consume an argument..test
.test
with Tagged Template Literals
.describe
npm i --save-dev jest-each
yarn add -D jest-each
jest-each is a default export so it can be imported with whatever name you like.
// es6
import each from 'jest-each';
// es5
const each = require('jest-each').default;
each([parameters]).test(name, testFn)
each
:Array
of Arrays with the arguments that are passed into the testFn
for each row
[1, 2, 3] -> [[1], [2], [3]]
.test
:String
the title of the test
.
printf
formatting:%p
- pretty-format.%s
- String.%d
- Number.%i
- Integer.%f
- Floating point value.%j
- JSON.%o
- Object.%#
- Index of the test case.%%
- single percent sign ('%'). This does not consume an argument.$variable
$variable.path.to.value
$#
to inject the index of the test case$variable
with the printf
formatting except for %%
Function
the test logic, this is the function that will receive the parameters of each row as function argumentseach([parameters]).describe(name, suiteFn)
each
:Array
of Arrays with the arguments that are passed into the suiteFn
for each row
[1, 2, 3] -> [[1], [2], [3]]
.describe
:String
the title of the describe
printf
formatting:%p
- pretty-format.%s
- String.%d
- Number.%i
- Integer.%f
- Floating point value.%j
- JSON.%o
- Object.%#
- Index of the test case.%%
- single percent sign ('%'). This does not consume an argument.$variable
$variable.path.to.value
$#
to inject the index of the test case$variable
with the printf
formatting except for %%
Function
the suite of test
/it
s to be ran, this is the function that will receive the parameters in each row as function arguments.test(name, fn)
Alias: .it(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).test('returns the result of adding %d to %d', (a, b, expected) => {
expect(a + b).toBe(expected);
});
each([
{a: 1, b: 1, expected: 2},
{a: 1, b: 2, expected: 3},
{a: 2, b: 1, expected: 3},
]).test('returns the result of adding $a to $b', ({a, b, expected}) => {
expect(a + b).toBe(expected);
});
.test.only(name, fn)
Aliases: .it.only(name, fn)
or .fit(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).test.only('returns the result of adding %d to %d', (a, b, expected) => {
expect(a + b).toBe(expected);
});
.test.skip(name, fn)
Aliases: .it.skip(name, fn)
or .xit(name, fn)
or .xtest(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).test.skip('returns the result of adding %d to %d', (a, b, expected) => {
expect(a + b).toBe(expected);
});
.test.concurrent(name, fn)
Aliases: .it.concurrent(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).test.concurrent(
'returns the result of adding %d to %d',
(a, b, expected) => {
expect(a + b).toBe(expected);
},
);
.test.concurrent.only(name, fn)
Aliases: .it.concurrent.only(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).test.concurrent.only(
'returns the result of adding %d to %d',
(a, b, expected) => {
expect(a + b).toBe(expected);
},
);
.test.concurrent.skip(name, fn)
Aliases: .it.concurrent.skip(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).test.concurrent.skip(
'returns the result of adding %d to %d',
(a, b, expected) => {
expect(a + b).toBe(expected);
},
);
.test(name, fn(done))
Alias: .it(name, fn(done))
each([['hello'], ['mr'], ['spy']]).test(
'gives 007 secret message: %s',
(str, done) => {
const asynchronousSpy = message => {
expect(message).toBe(str);
done();
};
callSomeAsynchronousFunction(asynchronousSpy)(str);
},
);
.describe(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).describe('.add(%d, %d)', (a, b, expected) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test('does not mutate first arg', () => {
a + b;
expect(a).toBe(a);
});
test('does not mutate second arg', () => {
a + b;
expect(b).toBe(b);
});
});
each([
{a: 1, b: 1, expected: 2},
{a: 1, b: 2, expected: 3},
{a: 2, b: 1, expected: 3},
]).describe('.add($a, $b)', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test('does not mutate first arg', () => {
a + b;
expect(a).toBe(a);
});
test('does not mutate second arg', () => {
a + b;
expect(b).toBe(b);
});
});
.describe.only(name, fn)
Aliases: .fdescribe(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).describe.only('.add(%d, %d)', (a, b, expected) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
});
.describe.skip(name, fn)
Aliases: .xdescribe(name, fn)
each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
]).describe.skip('.add(%d, %d)', (a, b, expected) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
});
each[tagged template].test(name, suiteFn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.test('returns $expected when adding $a to $b', ({a, b, expected}) => {
expect(a + b).toBe(expected);
});
each
takes a tagged template string with:|
${value}
syntax..test
:String
the title of the test
, use $variable
in the name string to inject test values into the test title from the tagged template expressions
$variable.path.to.value
$#
to inject the index of the table row.Function
the test logic, this is the function that will receive the parameters of each row as function argumentseach[tagged template].describe(name, suiteFn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.describe('$a + $b', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test('does not mutate first arg', () => {
a + b;
expect(a).toBe(a);
});
test('does not mutate second arg', () => {
a + b;
expect(b).toBe(b);
});
});
each
takes a tagged template string with:|
${value}
syntax..describe
:String
the title of the test
, use $variable
in the name string to inject test values into the test title from the tagged template expressions
$variable.path.to.value
Function
the suite of test
/it
s to be ran, this is the function that will receive the parameters in each row as function arguments.test(name, fn)
Alias: .it(name, fn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.test('returns $expected when adding $a to $b', ({a, b, expected}) => {
expect(a + b).toBe(expected);
});
.test.only(name, fn)
Aliases: .it.only(name, fn)
or .fit(name, fn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.test.only('returns $expected when adding $a to $b', ({a, b, expected}) => {
expect(a + b).toBe(expected);
});
.test.skip(name, fn)
Aliases: .it.skip(name, fn)
or .xit(name, fn)
or .xtest(name, fn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.test.skip('returns $expected when adding $a to $b', ({a, b, expected}) => {
expect(a + b).toBe(expected);
});
.test(name, fn(done))
Alias: .it(name, fn(done))
each`
str
${'hello'}
${'mr'}
${'spy'}
`.test('gives 007 secret message: $str', ({str}, done) => {
const asynchronousSpy = message => {
expect(message).toBe(str);
done();
};
callSomeAsynchronousFunction(asynchronousSpy)(str);
});
.describe(name, fn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.describe('$a + $b', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test('does not mutate first arg', () => {
a + b;
expect(a).toBe(a);
});
test('does not mutate second arg', () => {
a + b;
expect(b).toBe(b);
});
});
.describe.only(name, fn)
Aliases: .fdescribe(name, fn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.describe.only('$a + $b', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
});
.describe.skip(name, fn)
Aliases: .xdescribe(name, fn)
each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`.describe.skip('$a + $b', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
});
MIT