How to use assertFailuresAndSnapshot method in Jest

Jest cannot compare functions. Even if they are serialized into the same string, even if their source code is the same, function may refer to different variables through closures or bound to different this so we cannot say if functions are equal.

expect(function aaa() {}).toEqual(function aaa() {}); // fails

You may want to exclude methods before comparison explicitly or create custom matcher that will do that for you. But much better if you test what functions does instead. In your case you probably have separate test for ./reducer.js, right? You can just join both test: that one testing reducer in isolation and this one that checks object key names.

No, there is nothing built-in to javascript which allows you to get the number of minutes to offset for specific time zones/cities.

getTimeZoneOffset works for the current browser's settings

MomentJS Timezone extensions has some of this sort of functionality, which is of course reliant on the MomentJS library.

If you have access to Lat/Long values, then google provide a timezone API

Actually, you don't need to use Sinon to test debounces. Jest can mock all timers in JavaScript code.

Check out following code (it's TypeScript, but you can easily translate it to JavaScript):

import * as _ from 'lodash';

// Tell Jest to mock all timeout functions
jest.useFakeTimers();

describe('debounce', () => {

    let func: jest.Mock;
    let debouncedFunc: Function;

    beforeEach(() => {
        func = jest.fn();
        debouncedFunc = _.debounce(func, 1000);
    });

    test('execute just once', () => {
        for (let i = 0; i < 100; i++) {
            debouncedFunc();
        }

        // Fast-forward time
        jest.runAllTimers();

        expect(func).toBeCalledTimes(1);
    });
});

More information: Timer Mocks

If someone facing the similar issue. Do Check the following fields in your tsconfig

    "include": ["src/**/*"]

make sure you have included the file

    "exclude": ["node_modules", "dist"]

lastly check if you have specified typeRoots which is by defaults points to ./node_modules/@types and types includes jest

You are using ES6 features in your test, namely the import statement, so you need to compile them down to ES5 using a preset.

Create a babel.config.js and add @babel/preset-env, like so,

//babel.config.js
module.exports = {
  presets: ["@babel/preset-env"]
};

Next, in your package.json under the jest setting, let jest know where the root of your test code is located, and the module directories that will be recursively searched by jest, like so,

//package.json
"roots": [
  "test"
],
"moduleDirectories": [
  "test",
  "node_modules"
],

You got a little mistake in your HTML code. Your bind the @click event to your method without any this. make it:

 <v-btn flat color="green" id="addServiceBtn" @click="addService($event)">Add</v-btn>

jest handles this in two steps

1. isolate your test file by running jest with the testPathPattern (jest docs) command line argument

   node --inspect-brk ./node_modules/jest/bin/jest --testPathPattern="integration.test"
   

   here integration.test is supplied as a regular expression to filter for the correct test file

2. isolate your test function
   there are two ways to do this

   • one way is to use the testNamePattern (jest docs) command line argument

     node --inspect-brk ./node_modules/jest/bin/jest --testNamePattern="host events"
     

     here host events is supplied as a regular expression to filter for the correct test suite name

   • alternatively, you can add .only to your test function:

     • so that test("object works", async() => {/*...*/})

     • becomes test.only("object works", async() => {/*...*/})

Calling throwThis returns a Promise that should reject with an Error so the syntax should be:

test('Method should throw Error', async () => {

  let throwThis = async () => {
    throw new Error();
  };

  await expect(throwThis()).rejects.toThrow(Error);  // SUCCESS
});

Note that toThrow was fixed for promises in PR 4884 and only works in 21.3.0+.

So this will only work if you are using Jest version 22.0.0 or higher.

If you are using an earlier version of Jest you can pass a spy to catch:

test('Method should throw Error', async () => {

  let throwThis = async () => {
    throw new Error();
  };

  const spy = jest.fn();
  await throwThis().catch(spy);
  expect(spy).toHaveBeenCalled();  // SUCCESS
});

...and optionally check the Error thrown by checking spy.mock.calls[0][0].

You have to re-import or re-require your module. Check the doc or this issue for more information:

https://github.com/facebook/jest/issues/3236

https://facebook.github.io/jest/docs/en/jest-object.html#jestresetmodules

describe('MyModule', () => {
    beforeEach(() => {
        jest.resetModules()
    });

    describe('init', () => {
        const myModule = require('./MyModule');

        it('not throws exception when called', () => {
            expect(() => myModule.init()).not.toThrow();
        });
    })
    describe('do', () => {
        const myModule = require('./MyModule');

        it('throw when not init', () => {
            expect(() => myModule.do()).toThrow();
        });
    })
})