$ npm install --save-dev jest

// Package.json

{
  "scripts": {
    "test": "jest"
  }
}

$ npm run test

$ npm i -D babel-jest @babel/core @babel/preset-env @babel/preset-typescript @types/jest

// babel.config.js

module.exports = {
  presets: [
    ['@babel/preset-env', {targets: {node: 'current'}}],
    '@babel/preset-typescript',
  ],
};

import {add, sub} from 'math';

describe('Math', () => {
  describe('add', () => {
    it('should return 0 when add 0 to 0', () => {
      expect(add(0, 0)).toBe(0);
    });
    
    it('should return 1 when add 0 to 1', () => {
      expect(add(1, 0)).toBe(1);
    })
    
    it('should return 3.14 when add 0.14 to 3', () => {
      expect(add(3, 0.14)).toBe(3.14);
    })
  });
  
  describe('sub', () => {
    it('should return 0 when sub 0 to 0', () => {
      expect(sub(0, 0)).toBe(0);
    });
    
    it('should return 1 when sub 0 to 1', () => {
      expect(sub(1, 0)).toBe(1);
    })
    
    it('should return 3.14 when sub 0.86 to 4', () => {
      expect(sub(4, 0.86)).toBe(3.14);
    })
  });
});

describe('Battle', () => {
  it.todo('should design pikachu as a winner when pikachu fight against salameche');
});

describe('Battle', () => {
  it.todo('should make pikachu a winner when pikachu fight against salameche');
  
  it.todo('should make pikachu level up when pikachu fight against salameche');
});

describe('Battle', () => {
  describe('when pikachu fight against salamech', () => {
    beforeEach(() => {
		// Initialize pikachu and salameche battle here
    });

    it.todo('should make pikachu a winner');

    it.todo('should make pikachu level up');
  });
});

Scénario 1:
   Quand Pikachu et Salamèche s'affrontent
   Alors Pikachu est le premier à attaquer

 

Scénario 2:
   Quand Pikachu et Salamèche s'affrontent
   Alors Pikachu gagne

 

Scénario 3:
   Quand Pikachu et Bulbizarre s'affrontent
   Alors Bulbizarre gagne

 

Scénario 4:
   Quand Pikachu et Bulbizarre s'affrontent
   Alors Pikachu est le premier à attaquer

import {getUser} from './user-service';
import {info} from './logger'



export const findFriend = async (userId) => {
	try {
    	const user = await getUser(userId)
        return user.friends;
    } catch(err) {
    	console.error(err);
        return undefined;
    }
}

const loggerDummy = () => {
  throw new Error('Dummy')
}

const getUserStub = () => {
  return Promise
    .resolve({friends: []})
}

const getUserStub = jest.fn(() => {
  return Promise
    .resolve({friends: []})
})

const getUserMock = jest.fn((userID) => {
  if(userId === 'flo') {
    return Promise
    	.resolve({friends: ['martinique']})
  }
  
  
  return Promise
	.reject(new Error('Remi sans amis, sans famille'))
})

jest.spyOn(console, 'error');

expect(console.error).toHaveBeenCalled();

jest
  .spyOn(console, 'error')
  .mockImplementation(() => {});

const getUserStub = jest.fn(() => {
  return Promise
    .resolve({friends: []})
})

expect(getUserStub).toHaveBeenCalled();

import {getUser} from './user-service';
import {info} from './logger'



export const findFriend = async (userId) => {
    try {
    	const user = await getUser(userId)
        return user.friends;
    } catch(err) {
    	console.error(err);
        return undefined;
    }
}

import {getUser} from './user-service';

jest.mock('./user-service', () => {
  return {
    getUser: jest.fn()
  }
})

describe('findFriend', () => {
  beforeEach(() => {
    jest.spyOn(console, 'error').mockImplementation(() => {});
  })
  afterEach(() => {
    console.error.mockRestore();
    // (console.error as jest.Mock).mockRestore();
  })

  it('should find florent friend', async () => {
      getUser.mockImplementation(() => {
        return Promise.resolve({friends: ['martinique']})
      })
    
      const result = await findFriend('flo')
      expect(result).toEqual(['martinique'])
  })

  describe('when trying to find remi friend', () => {
    beforeEach(() => {
      getUser.mockImplementation(() => {
        return Promise.reject(new Error('oops'))
      })
    });
    
    it('should log error when find remi friend', async () => {
      const result = await findFriend('remi')
      expect(console.error).toHaveBeenCalledWith('oops');
    })

    it('should return undefined', async () => {
      const result = await findFriend('remi')
      expect(result).toBe(undefined);
    })
  })
})

Feature: Subscribers see different sets of stock images based on their subscription level
 
Scenario: Free subscribers see only the free articles
  Given Free Frieda has a free subscription
  When Free Frieda logs in with her valid credentials
  Then she sees a Free article on the home page

Scenario: Subscriber with a paid subscription can access both free and paid articles
  Given Paid Patty has a basic-level paid subscription
  When Paid Patty logs in with her valid credentials
  Then she sees a Free article and a Paid article on the home page

it('should display the captain\'s age', () => {
  render(<MyComponent />)

  expect(screen.getRole('heading'))
    .toHaveTextContent('21 ans et toutes ses dents !')
})

it('should display the captain\'s age', () => {
  render(<MyComponent />)

  expect(screen.getByText('21 ans et toutes ses dents !'))
    .toBeVisible()
})

it('should display the captain\'s age', async () => {
  render(<MyComponent />)

  await waitForElementToBeRemoved(() => screen.queryByText('loading...'));

  expect(screen.getByText('21 ans et toutes ses dents !')).toBeVisible();
})