Quelle est la différence entre "it" et "test" dans Jest ?

Question

J'ai deux tests dans mon groupe d'essai. L'un des tests utilise it et l'autre utilise test . Les deux semblent fonctionner de manière très similaire. Quelle est la différence entre eux ?

describe('updateAll', () => {
  it('no force', () => {
    return updateAll(TableName, ["fileName"], {compandId: "test"})
        .then(updatedItems => {
          let undefinedCount = 0;
          for (let item of updatedItems) {
            undefinedCount += item === undefined ? 1 : 0;
          }
          // console.log("result", result);
          expect(undefinedCount).toBe(updatedItems.length);
        })
  });

  test('force update', () => {
    return updateAll(TableName, ["fileName"], {compandId: "test"}, true)
        .then(updatedItems => {
          let undefinedCount = 0;
          for (let item of updatedItems) {
            undefinedCount += item === undefined ? 1 : 0;
          }
          // console.log("result", result);
          expect(undefinedCount).toBe(0);
        })
  });
});

---

Il semble que test est en l'API officielle de Jest mais it ne l'est pas.

Answer 1

Le site Documentation sur Jest état it est un alias de test . Ils sont donc exactement les mêmes.

Answer 2

Ils font la même chose, mais leurs noms sont différents et avec cela leur interaction avec le nom du test.

test

Ce que vous écrivez :

describe('yourModule', () => {
  test('if it does this thing', () => {});
  test('if it does the other thing', () => {});
});

Ce que vous obtenez si quelque chose échoue :

yourModule > if it does this thing

it

Ce que vous écrivez :

describe('yourModule', () => {
  it('should do this thing', () => {});
  it('should do the other thing', () => {});
});

Ce que vous obtenez si quelque chose échoue :

yourModule > should do this thing

Il s'agit donc de lisibilité et non de fonctionnalité.

A mon avis, it a vraiment raison lorsqu'il s'agit de lire le résultat d'un test raté que vous n'avez pas écrit vous-même. Cela permet de comprendre plus rapidement l'objet du test.

Certains développeurs raccourcissent également le Should do this thing à Does this thing qui est un peu plus court et correspond aussi sémantiquement à l'approche it la notation.

Answer 3

Comme les autres réponses l'ont précisé, ils font la même chose.

Je crois que les deux sont proposés pour permettre soit 1) " RSpec des tests de style "comme" :

const myBeverage = {
  delicious: true,
  sour: false,
};

describe('my beverage', () => {
  it('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  it('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

ou 2) " xUnit des tests de style "comme" :

function sum(a, b) {
  return a + b;
}

test('sum adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});

Documentation :

• https://jestjs.io/docs/en/api.html#describename-fn
• https://jestjs.io/docs/en/api.html#testname-fn-timeout

Answer 4

Comme le dit la documentation sur la plaisanterie, ils sont identiques : il alias

test(nom, fn, timeout)

Aussi sous l'alias : it(name, fn, timeout)

Et describe est juste pour quand vous préférez que vos tests soient organisés en groupes : décrire

describe(nom, fn)

describe(name, fn) crée un bloc qui regroupe plusieurs tests connexes. Par exemple, si vous avez un objet myBeverage qui est censé être délicieux mais pas acide, vous pouvez le tester avec :

const myBeverage = {
  delicious: true,
  sour: false,
};

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

Ce n'est pas nécessaire - vous pouvez écrire les blocs de test directement au niveau supérieur. Mais cela peut être pratique si vous préférez que vos tests soient organisés en groupes.

Answer 5

Vous pouvez remplacer it() par xit() pour exclure temporairement un test de l'exécution ; utiliser it() et xit() est plus éloquent que d'utiliser test() et xit().

voir Tests de focalisation et d'exclusion