Jest is a new trending popular testing framework recommended by Facebook. 
It comes with everything you need to write automated tests.

Jest is an awesome test framework for javascript projects 
(and react, and other things that compile to javascript). 
It supports parallel testing, watching & retrying, mocking, snapshotting...

- We have 3 types of automated tests:
    - Unit tests: test a unit of an application without external resources (eg db) 
    - Integration tests: test the application with external resources.
    - Functional or end-to-end tests: test the application through its UI.

for unit test, you should NOT talking external database,
otherwize, you are doing integration test

develop a unit test 3 simple steps: (A, A , A)
- Arrange – setup the testing objects and prepare the prerequisites for your test.
- Act – perform the actual work of the test.
- Assert – verify the result.

const test = require("../src/string");

describe('string', () => {

    // toBe
    it('should return Hi name', () => {
        const result = test.string('Xing');
        expect(result).toBe('Hi, Xing')
    });

    // toContain
    it('should return Hi name', () => {
        const result = test.string('Xing');
        expect(result).toContain('Xing')
    });

    // toMatch
    it('should return Hi name', () => {
        const result = test.string('Xing');
        expect(result).toMatch(/Xing/);
    });
});

to perform integration tests in our express application we'll be using a module called supertest

"scripts": {
    "testfile": "timestamp=$(date \"+%c\"); jest --no-color 2>TestResults/TestResult_${timestamp}.txt",
    "test": "jest --watchAll"
  },
  
...
or 

"scripts": {
    "testfile": "timestamp=$(date \"+%Y%m%d%H%M%S\"); jest --no-color 2>TestResults/TestResult_${timestamp}.txt",
    "test": "jest --watchAll"
  },
  

expect(result).toEqual(expect.arrayContaining(['USD', 'AUD', 'EUR']));

module.exports.getProduct = function (productId) {
    return {
        id: productId,
        price: 10,
        size: 10
    };
}

expect(result).toMatchObject({
    id: 1,
    price: 10
});
expect(result).toHaveProperty('size', 10);
expect(result).toHaveProperty('id', 1);

it('should throw if username is falsy', () => {
    // Null
    // undefined
    // NaN
    // ''
    // 0
    // false
    const args = [null, undefined, NaN, '', 0, false];
    args.forEach(arg => {
        expect(() => {
            test.registerUser(arg)
        }).toThrow();
    });
})

If they’re too general, they don’t give you much confidence that your code works. 
If they’re too specific, they become fragile and can break easily. 

Mocking is replacing a real implementation of a function with a fake or mock function. 
It allows us to isolate our application code from its external resources.

// Equality
expect(...).toBe(); 
expect(...).toEqual();
// Truthiness
expect(...).toBeDefined(); 
expect(...).toBeNull(); 
expect(...).toBeTruthy();
expect(...).toBeFalsy();
// Numbers
expect(...).toBeGreaterThan(); 
expect(...).toBeGreaterThanOrEqual(); 
expect(...).toBeLessThan(); 
expect(...).toBeLessThanOrEqual();
// Strings
expect(...).toMatch(/regularExp/);
// Arrays
expect(...).toContain();
// Objects
expect(...).toBe(); 
// check for the equality of object references 
expect(...).toEqual(); 
// check for the equality of properties 
expect(...).toMatchObject();
// Exceptions
expect(() => { someCode }).toThrow();

//jest.fn().mockReturnValue(1);
//jest.fn().mockResolvedValue(1);
//jest.fn().mockRejectedValue(new Error('...'));

test('the data is peanut butter', done => {
  function callback(data) {
    expect(data).toBe('peanut butter');
    done();
  }

  fetchData(callback);
});
If done() is never called, the test will fail, which is what you want to happen.

If you find yourself doing too much mocking, 
that’s when you need to replace your unit test with an integration test. 

With integration tests, we test our application with a real database. 
As a best practice, separate your test database from the development or production
databases. 

You should write each integration test as if it is the only test in the world. 
Start with a clean state (database). 
Populate the database only with the data required by the test. 
Nothing more, nothing less. 
Clean up after your test using the afterEach function.

"scripts": {
    "testfile": "timestamp=$(date \"+%Y%m%d%H%M%S\"); jest --coverage --verbose --no-color 2>TestResults/TestResult_${timestamp}.txt",
    "test": "jest --watchAll --verbose",
    "testcoverage": "jest --coverage --watchAll --verbose"
  },

we need a real database. You populate this database with data for testing. 
Now we send an http request to an endpoint we want to test and then make an assertion. 
That assertion may involve inspecting the result or the database.