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

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.

Dans les documents, il est dit ici : itest un alias de test. Ils sont donc exactement les mêmes.

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.

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:

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

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.

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.

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;