Jest

I solved this by adding a helper function I found here

const isJSON = (str:string) => {
    try {
        const json = JSON.parse(str);
        if (Object.prototype.toString.call(json).slice(8,-1) !== 'Object') {
        return false
        }
    } catch (e) {
        return false
    }
    return true
}

and then am able to do this :

expect(isJSON(body)).toBe(true)

A working solution nowadays would be to use userEvent.tab() instead of fireEvent.keyDown().

import '@testing-library/jest-dom'
import userEvent from '@testing-library/user-event'

import { render, screen } from '@testing-library/react'
import Component from './buttons'

it('changes focus on tab', async () => {
  render(<Component />)
  const one = screen.getByTestId('one')
  const two = screen.getByTestId('two')

  one.focus()
  expect(one).toHaveFocus()

  await userEvent.tab()
  expect(two).toHaveFocus()
})

You cannot use jest.spyOn(axios, 'default') when you call axios directly (no default). Changing your implementation in api.js to be axios.default(...args) makes the test pass.

A potential change you can make is to use jest.mock('axios') instead of using jest.spyOn.

import axios from 'axios';
import { callApi } from './api';

jest.mock('axios');

// Make sure to resolve with a promise
axios.mockResolvedValue();

describe('callApi()', () => {
  it('calls `axios()` with `endpoint`, `method` and `body`', () => {
    const endpoint = '/endpoint';
    const method = 'post';
    const data = { foo: 'bar' };

    // call function
    callApi(endpoint, method, data);

    // assert axios()
    expect(axios).toBeCalledWith({ url: endpoint, method, data});
  });
}); 

For me it was not a snapshot issue, but a cache issue. Run

jest --clearCache

to get rid of it.

You can define a manual-mock in the [root]/__mocks__/node-uuid.js where [root] is the directory where the node_modules directory is located:

module.exports = { v4: jest.fn(() => 1) }

Jest has describe.each(table) which I haven't seen being used a lot, but it's really helpful for reusing tests which have common/same results.

In case for identical expectations for both of the test subjects you can do it like this:

const aCutePet = pet => {
  it("should be small", () => {
    expect(pet.size).toBeLessThan(10);
  });

  it(`should be able to smile`, () => {
    expect(pet).toHaveProperty('can_smile', true)
  });
}

describe.each([
  [new Doge],
  [new Octocat]
])("The %O", aCutePet);

The output:

  The Doge { size: 3, can_smile: true }
    ✓ should be small (1ms)
    ✓ should be able to smile (1ms)
  The Octocat { size: 5, can_smile: true }
    ✓ should be small
    ✓ should be able to smile (1ms)

If your Jest test environment is jsdom (the default) then it provides a browser-like environment that includes a mock for performance on the global Window object, so performance.now will be defined automatically.

If your Jest test environment is node then you will need to provide your own performance global.

That can be done by adding a setup file to the setupFilesAfterEnv array:

jest.config.js

module.exports = {
  setupFilesAfterEnv: [ './setup.js' ]
}

...and within the setup file defining a global performance:

setup.js

global.performance = require('perf_hooks').performance;

I was able to figure out a way to achieve what I wanted. It involves instantiating variables in setupTests.js and then exporting getters for them.

//setupTests.js
const { endpointNames } = require('../../src/common/endpointNames.js');
const BackendServer = require('../server.js');
const server = new BackendServer(
    '../backing_files_test/',
    'test',
);
const supertester = require('supertest')(server.server);

// drop, recreate, and populate the database once before any tests run
beforeAll(async () => {
    await supertester.post(endpointNames.DROP_ALL_TABLES);
    await supertester.post(endpointNames.CREATE_ALL_TABLES);
    await supertester.post(endpointNames.POPULATE_ALL_TABLES);
});

// clean up the local setupTests server instance after all the tests are done
afterAll(async () => {
    await server.closeMySQLConnectionPool();
});

const getServer = () => { //        <==== ADD THESE 2 FUNCTIONS
    return server;
};

const getSupertester = () => { //   <==== ADD THESE 2 FUNCTIONS
    return supertester;
};

module.exports = { getServer, getSupertester }; //   <==== EXPORT THEM

I added a couple functions to the end of setupTests.js that, when called, will return whatever the local variables point to at the time. In this case, server and supertester are declared with const, so I could have exported them directly I think, but in other cases I had some variables that I wanted to share that were declared with let, so I left it this way.

Now I have functions exported from setupTests.js that I can import in my test files like this:

//test1.test.js
const { endpointNames } = require('../../src/common/endpointNames.js');
const { getServer, getSupertester } = require('./setupTests.js');

test('blah blah', () => {
    /* Some test using getSupertester().post() or getServer().someFunction() ... */
});

So now I can have local variables inside setupTests.js that are accessible in my .test.js files.

This makes my whole testing process cleaner because I only need to set up and tear down one server, which means only 1 connection pool for my SQL server and less code duplication of having to instantiate and clean up a new server in every .test.js file.

Cheers.

From Jest 23 onwards toThrow matcher can be used for promise returning functions.

  test("Rejects on error", () => {
    expect.assertions(1);
    return expect(promiseHttpsGet(null)).rejects.toThrow(Error);
  });

Or the async/await version:

  test("Throws on error", async () => {
    expect.assertions(1);
    await expect(promiseHttpsGet(null)).rejects.toThrow(Error);
  });