Jest断言帰納

9288 ワード

Jestは本当に便利で、手が簡単で、ほとんど配置がゼロです.学習Jest matchersを記録します.大部分の説明と例を添付します.

ノーマルマッチング

toBe-toBeはObjectを用いる.isは

に完全に等しいかどうかをテストします

.not-反対の使用例

をテストするために使用される

.toEqual-オブジェクトの値をチェックしたい場合は、toEqualに変更します.

toBe

最も簡単なテスト値の方法は、正確に一致するかどうかを見ることです.

test('two plus two is four', () => { 
    expect(2 + 2).toBe(4); 
});

toEqual

オブジェクトの値をチェックしたい場合は、toEqualに変更します.

test('object assignment', () => { 
    const data = {one: 1}; 
    data['two'] = 2; 
     expect(data).toEqual({one: 1, two: 2}); 
});

.not

反対の使用例をテストするために使用

test('null', () => {
  const n = null;
  expect(n).not.toBeUndefined();
  expect(n).not.toBeTruthy();
});

ブール値マッチング

toBeNullはnull

のみに一致する

toBeUndefind undefined

のみ一致

toBeDefined toBeUndefindとは逆

toBeTruthyは、任意のif文が真の

に一致する

toBeFalsy任意のif文に一致する

test('null', () => {
  const n = null;
  expect(n).toBeNull();
  expect(n).toBeDefined();
  expect(n).not.toBeUndefined();
  expect(n).not.toBeTruthy();
  expect(n).toBeFalsy();
});

test('zero', () => {
  const z = 0;
  expect(z).not.toBeNull();
  expect(z).toBeDefined();
  expect(z).not.toBeUndefined();
  expect(z).not.toBeTruthy();
  expect(z).toBeFalsy();
});

ディジタルマッチング

.toBeGreaterThan()-

より大きい

.toBeGreaterThanOrEqual()は

以上

.toBeLessThan()-

未満

.toBeLessThanOrEqual()-

以下

.toBeCloseTo()-浮動小数点数比較

toBeGreaterThan、toBeGreaterThanOrEqual、toBeLessThan、toBeLessThanOrEqual

test('two plus two', () => { 
const value = 2 + 2; 
 expect(value).toBeGreaterThan(3); 
 expect(value).toBeGreaterThanOrEqual(3.5); 
 expect(value).toBeLessThan(5); 
 expect(value).toBeLessThanOrEqual(4.5);

// toBe   toEqual  
 expect(value).toBe(4); 
 expect(value).toEqual(4); 
});

.toBeCloseTo()

比較浮動小数点数の等しい場合は、toBeCloseToを使用します.

test(' ', () => {
    const value = 0.1 + 0.2;        // 0.30000000000000004 
    expect(value).toBe(0.3);        //  ，  js  
    expect(value).toBeCloseTo(0.3); //  
});

文字列マッチング

toMatch-正規表現の文字

.toHaveLength(number)-長さのあるオブジェクトの長さを判断する

toMatch

正規表現の文字

test('there is no I in team', () => {
  expect('team').not.toMatch(/I/);
});

test('but there is a "stop" in Christoph', () => {
  expect('Christoph').toMatch(/stop/);
});

.toHaveLength(number)

長さのあるオブジェクトの長さを判断する

expect([1, 2, 3]).toHaveLength(3);
expect('abc').toHaveLength(3);
expect('').not.toHaveLength(5);

アレイマッチング

.toContain(item)-配列に特定のサブアイテムが含まれているかどうかを判断する

.toContaineEqual(item)-配列に特定のオブジェクトが含まれているかどうかを判断する

.toContain

配列に特定のサブアイテムが含まれているかどうかを判断

const shoppingList = [
  'diapers',
  'kleenex',
  'trash bags',
  'paper towels',
  'beer',
];

test(' （shopping list） （beer）', () => {
  expect(shoppingList).toContain('beer');
});

.toContainEqual(item)

配列に特定のオブジェクトが含まれているかどうかを判断できます.toEqualとtoContainの結合に似ています.

function myBeverages() {
    return [
        {delicious: true, sour: false},
        {delicious: false, sour: true}
    ]
}
test('is delicious and not sour', () => {
    const myBeverage = {delicious: true, sour: false};
    expect(myBeverages()).toContainEqual(myBeverage);
});

オブジェクトマッチング

.toMatchObject(object)-オブジェクトがネストされているkeyの下にあるvalueタイプ

を判断します.

.toHaveProperty(keyPath,value)-指定したpathの下にこの属性があるかどうかを判断する

.toMatchObject(object)

オブジェクトのネストされたkeyの下にあるvalueタイプを判断するには、オブジェクトを入力する必要があります.

const houseForSale = {
  bath: true,
  bedrooms: 4,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    area: 20,
    wallColor: 'white',
  },
};
const desiredHouse = {
  bath: true,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    wallColor: expect.stringMatching(/white|yellow/),
  },
};

test('the house has my desired features', () => {
  expect(houseForSale).toMatchObject(desiredHouse);
});

.toHaveProperty(keyPath, value)

指定したpathの下にこの属性があるかどうかを判断し、ネストされたpathは'.'を使用できます.分割して、配列を使うこともできます.

// Object containing house features to be tested
const houseForSale = {
  bath: true,
  bedrooms: 4,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    area: 20,
    wallColor: 'white',
  },
};

test('this house has my desired features', () => {
  // Simple Referencing
  expect(houseForSale).toHaveProperty('bath');
  expect(houseForSale).toHaveProperty('bedrooms', 4);

  expect(houseForSale).not.toHaveProperty('pool');

  // Deep referencing using dot notation
  expect(houseForSale).toHaveProperty('kitchen.area', 20);
  expect(houseForSale).toHaveProperty('kitchen.amenities', [
    'oven',
    'stove',
    'washer',
  ]);

  expect(houseForSale).not.toHaveProperty('kitchen.open');

  // Deep referencing using an array containing the keyPath
  expect(houseForSale).toHaveProperty(['kitchen', 'area'], 20);
  expect(houseForSale).toHaveProperty(
    ['kitchen', 'amenities'],
    ['oven', 'stove', 'washer'],
  );
  expect(houseForSale).toHaveProperty(['kitchen', 'amenities', 0], 'oven');

  expect(houseForSale).not.toHaveProperty(['kitchen', 'open']);
});

カスタムマッチング

expectを使用します.extendは自分のマッチング器をJestに追加します.カスタムマッチングは、2つのkeyを含むオブジェクトを返す必要があります.

{
    pass：false //‘ ’， 
    message： () => 'message string' //‘ ， ’
}

expect.extend({
  toBeDivisibleBy(received, argument) {
    const pass = received % argument == 0;
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to be divisible by ${argument}`,
        pass: true,
      };
    } else {
      return {
        message: () => `expected ${received} to be divisible by ${argument}`,
        pass: false,
      };
    }
  },
});

test('even and odd numbers', () => {
  expect(100).toBeDivisibleBy(2);
  expect(101).not.toBeDivisibleBy(2);
});

これらのヘルプ関数は、カスタムマッチングのthisにあります.

this.isNot

this.equals(a, b)

this.utils(matcherHint, printExpected and printReceived)

その他

toThrow-テストする特定の関数は、呼び出し時にエラー

を放出します.

.resolvesと.rejects-promise

をテストするために使用

.toHaveBeenCalled()-関数が呼び出されたかどうかを判断するために使用されます.

.toHaveBeenCalledTimes(number)-判断関数が何回か呼び出されたことがある

toThrow

テストする特定の関数は、呼び出し時にエラーを放出します.

function compileAndroidCode() {
  throw new ConfigError('you are using the wrong JDK');
}

test('compiling android goes as expected', () => {
  expect(compileAndroidCode).toThrow();
  expect(compileAndroidCode).toThrow(ConfigError);

  // You can also use the exact error message or a regexp
  expect(compileAndroidCode).toThrow('you are using the wrong JDK');
  expect(compileAndroidCode).toThrow(/JDK/);
});

.resolvesと.rejects

promiseのテストに使用


//resolves
test('resolves to lemon', () => {
  // make sure to add a return statement
  return expect(Promise.resolve('lemon')).resolves.toBe('lemon');
});

//rejects
test('resolves to lemon', async () => {
  await expect(Promise.resolve('lemon')).resolves.toBe('lemon');
  await expect(Promise.resolve('lemon')).resolves.not.toBe('octopus');
});

.toHaveBeenCalled()

.toHaveBeenCalled()にも別名があります.toBeCalled()は、関数が呼び出されたかどうかを判断するために使用されます.

describe('drinkAll', () => {
  test('drinks something lemon-flavored', () => {
    const drink = jest.fn();
    drinkAll(drink, 'lemon');
    expect(drink).toHaveBeenCalled();
  });

  test('does not drink something octopus-flavored', () => {
    const drink = jest.fn();
    drinkAll(drink, 'octopus');
    expect(drink).not.toHaveBeenCalled();
  });
});

.toHaveBeenCalledTimes(number)

TOHaveBeenCalledと同様に,判定関数が何度か呼び出された.

test('drinkEach drinks each drink', () => {
  const drink = jest.fn();
  drinkEach(drink, ['lemon', 'octopus']);
  expect(drink).toHaveBeenCalledTimes(2);
});