Quelle est la différence entre 'it' et 'test' en plaisantant?


282

J'ai deux tests dans mon groupe de test. L'un l'utilise l'autre utilise le test, et ils 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);
        })
  });
});

METTRE À JOUR:

Il semble que ce testsoit dans l'API officielle de Jest , mais ce itn'est pas le cas.


itpourrait être là pour la familiarité et la migration à partir d'autres cadres.
Andrew Li

23
il n'y a pas de différence. La documentation indique clairement qu'elle testest sous l'alias it.
Claies

Réponses:



35

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

tester

Ce que vous écrivez:

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

Ce que vous obtenez en cas d'échec:

yourModule > if it does this thing

il

Ce que vous écrivez:

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

Ce que vous obtenez en cas d'échec:

yourModule > should do this thing

Il s'agit donc de lisibilité et non de fonctionnalité. À mon avis, a itvraiment un point quand il s'agit de lire le résultat d'un test d'échec que vous n'avez pas écrit vous-même. Il permet de comprendre plus rapidement en quoi consiste le test.


4
certains préfèrent également it('does this thing', () => {})plutôt it('should do this thing', () => {}que son plus court
gwildu

Alternativement, test('thing should do x')peut être préféré à ce it('Should do X')qui itest souvent vague.
mikemaccana

21

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

Je crois que les deux sont proposés pour permettre soit 1) des tests de style " RSpec " 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) des tests de style " xUnit " comme:

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

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

Documents:


2

comme le disent les plaisanteries, ce sont les mêmes: https://jestjs.io/docs/en/api#testname-fn-timeout

test (nom, fn, timeout)

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

et décrire est juste pour quand vous préférez que vos tests soient organisés en groupes: https://jestjs.io/docs/en/api#describename-fn

décrire (nom, fn)

describe(name, fn)crée un bloc qui regroupe plusieurs tests associés. 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();
  });
});

Cela n'est pas obligatoire - 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.


-4

Jest n'a pas expliqué pourquoi ils ont deux versions pour la même fonctionnalité. Je suppose que c'est uniquement pour la convention. test pour les tests unitaires pour les tests d'intégration.


-22

Ce sont les mêmes choses. J'utilise TypeScript comme langage de programmation, et quand je regarde dans le fichier de définition du code source du package jest de /@types/jest/index.d.ts, je peux voir les codes suivants. Évidemment, il existe de nombreux noms différents de «test», vous pouvez utiliser n'importe lequel d'entre eux.

declare var beforeAll: jest.Lifecycle;
declare var beforeEach: jest.Lifecycle;
declare var afterAll: jest.Lifecycle;
declare var afterEach: jest.Lifecycle;
declare var describe: jest.Describe;
declare var fdescribe: jest.Describe;
declare var xdescribe: jest.Describe;
declare var it: jest.It;
declare var fit: jest.It;
declare var xit: jest.It;
declare var test: jest.It;
declare var xtest: jest.It;


25
Le code que vous montrez n'indique pas cela itet testc'est la même chose. Cela signifie simplement que leur type est le même. Je ne pense pas cela beforeAllet afterAllc'est la même chose même si leur type est le même.
realUser404

2
xit and xtestsaute les tests, it, fit, testdoit exécuter des tests. Merci pour votre réponse.
Akash
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.