Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including riteway-jest with all npm packages installed. Try it out:

var ritewayJest = require("riteway-jest")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

riteway-jest v2.0.2

Unit tests that always supply a good bug report when they fail for Jest.

RITEway-Jest

Inspired by Eric Elliott's RITEway.

Why?

TLDR: I wanted RITEway's assert for Jest.

I love RITEway's API because it forces you to write good unit tests by it's given-should API and only exposing the equals assertion.

Only problem is RITEway is build using tape. You can't use it with Jest, which in turn has some advantages and disadvantages.

Disadvantages

Advantages

You might want to check out RITEway because you can learn these advantages first hand. I prefer RITEway for React apps and use RITEway-Jest for React Native apps.

Installation

npm i --save-dev riteway-jest

or

yarn add --dev riteway-jest

Then import it in your src/setupTests.js for React with CRA.

import 'riteway-jest/src/riteway-jest.js';

For React Native you need to add a key in your package.json to the jest key.

"jest": {
  "preset": "react-native",
  "setupFilesAfterEnv": ["node_modules/riteway-jest/src/riteway-jest.js"]
}

If you have a jest.config.js.

module.exports = {
  setupFilesAfterEnv: [
    'node_modules/riteway-jest/src/riteway-jest.js',
    // ... other setup files ...
  ],
  // ... other options ...
};

If ESLint yells at you, add a global key to your .eslintrc.json.

{
  "_comment": "<Your other settings here>",
  "globals": {
    "assert": true
  },
  "rules": {
    "_comment": "<Your rules here>"
  }
}

Usage

With pure functions.

const sum = (a = 0, b = 0) => a + b;

describe('sum()', () => {
  const should = 'return the correct sum';

  assert({
    given: 'no arguments',
    should: 'return 0',
    actual: sum(),
    expected: 0,
  });

  assert({
    given: 'zero',
    should,
    actual: sum(2, 0),
    expected: 2,
  });

  assert({
    given: 'negative numbers',
    should,
    actual: sum(1, -4),
    expected: -3,
  });
});

Using React Native Testing Library.

import React from 'react';
import { Text } from 'react-native';
import { render } from 'react-native-testing-library';

function MyText({ title }) {
  return <Text>{title}</Text>;
}

describe('Text component', () => {
  const createText = (props = {}) => render(<MyText {...props} />);

  {
    const props = { title: 'Foo' };
    const $ = createText(props).getByType;

    assert({
      given: 'a title',
      should: 'display the title',
      actual: $('Text').props.children,
      expected: props.title,
    });
  }
});

Using React Testing Library.

import PropTypes from 'prop-types';
import React from 'react';
import { cleanup, render } from 'react-testing-library';

function Button({ disabled, onClick, text }) {
  return (
    <button data-testid="foo" disabled={disabled} onClick={onClick}>
      {text}
    </button>
  );
}

Button.propTypes = {
  disabled: PropTypes.bool.isRequired,
  onClick: PropTypes.func.isRequired,
  text: PropTypes.string,
};

Button.defaultProps = {
  disabled: false,
  text: '',
};

describe('button component', () => {
  const createButton = (props = {}) =>
    render(<Button onClick={() => {}} {...props} />);

  {
    const props = { text: 'foo' };
    const $ = createButton(props).getByTestId;

    assert({
      given: 'a text',
      should: "render 'foo'",
      actual: $('foo').textContent,
      expected: props.text,
    });
    cleanup();
  }

  {
    const props = { disabled: true, text: 'foo' };
    const $ = createButton(props).getByText;

    assert({
      given: 'disabled',
      should: 'be disabled',
      actual: $('foo').hasAttribute('disabled'),
      expected: props.disabled,
    });
    cleanup();
  }
});

skip & only & todo

assert supports Jest's skip, only and todo functions.

// This test is explicitly skipped
assert.skip({
  given: 'something',
  should: 'be equal to something',
  actual: 'nothing',
  expected: 'something',
});

// This test gets executed
assert.only({
  given: 'something',
  should: 'be equal to something',
  actual: 'nothing',
  expected: 'something',
});

// This test is implicitly skipped because the .only() above
assert({
  given: 'something',
  should: 'be equal to something',
  actual: 'nothing',
  expected: 'something',
});

each is currently not supported.

Metadata

RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free