Wat is het verschil tussen ‘it’ en ‘test’ in Jest?

Ik heb twee tests in mijn testgroep. Een van de tests gebruikt iten de andere gebruikt test. Beiden lijken erg op dezelfde manier te werken. Wat is het verschil tussen beide?

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);
        })
  });
});

Het lijkt erop dat testzich in de officiële API van Jest bevindt , maar itniet.

Antwoord 1, autoriteit 100%

De Jest docsstaat itis een alias van test. Dus functioneel gezien zijn ze precies hetzelfde. Ze bestaan ​​beide om een ​​leesbare Engelse zin van je toets te maken.

Antwoord 2, autoriteit 22%

Ze doen hetzelfde, maar hun namen zijn anders en daarmee hun interactie met de naam van de test.

test

Wat je schrijft:

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

Wat je krijgt als iets niet lukt:

yourModule > if it does this thing

it

Wat je schrijft:

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

Wat je krijgt als iets niet lukt:

yourModule > should do this thing

Het gaat dus om leesbaarheid, niet om functionaliteit.

Naar mijn mening heeft itecht een punt als het gaat om het lezen van het resultaat van een mislukte test die je niet zelf hebt geschreven. Het helpt om sneller te begrijpen waar de test over gaat.

Sommige ontwikkelaars verkorten ook de Should do this thingtot Does this thing, wat een beetje korter is en ook semantisch past bij de notatie it.

Antwoord 3, autoriteit 5%

Zoals de andere antwoorden hebben verduidelijkt, doen ze hetzelfde.

Ik geloof dat de twee worden aangeboden om 1) “RSpec” stijltests mogelijk te maken, zoals :

const myBeverage = {
  delicious: true,
  sour: false,
};
describe('my beverage', () => {
  it('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });
  it('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

of 2) “xUnit” stijltests zoals:

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

Documentatie:

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

Antwoord 4

Zoals de grapdocumentatie zegt, zijn ze hetzelfde:
het alias

test(naam, fn, time-out)

Ook onder de alias: it(name, fn, timeout)

En describeis alleen bedoeld voor als u uw tests liever in groepen wilt organiseren:
beschrijf

beschrijf(naam, fn)

describe(name, fn)maakt een blok dat verschillende gerelateerde tests groepeert. Als u bijvoorbeeld een myBeverage-object heeft dat heerlijk maar niet zuur zou moeten zijn, kunt u het testen met:

const myBeverage = {
  delicious: true,
  sour: false,
};
describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });
  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

Dit is niet vereist – u kunt de testblokken rechtstreeks op het hoogste niveau schrijven. Maar dit kan handig zijn als u uw tests liever in groepen wilt organiseren.

Antwoord 5

Je zou it()kunnen vervangen door xit()om tijdelijk uit te sluiten dat een test wordt uitgevoerd; het gebruik van it()en xit()is welsprekender dan het gebruik van test()en xit().

zie Tests focussen en uitsluiten

Antwoord 6

Het volgende is een fragment uit het document：link

test(name, fn, timeout)

Ook onder de alias: it(name, fn, timeout)

Alles wat je nodig hebt in een testbestand is de testmethode waarmee een test wordt uitgevoerd. Voor
laten we bijvoorbeeld zeggen dat er een functie is inchesOfRain()die zou moeten zijn
nul. Je hele test zou kunnen zijn: ……

Antwoord 7

Jest heeft niet gezegd waarom ze twee versies hebben voor exact dezelfde functionaliteit.

Mijn gok is dat het alleen voor conventies is. testis voor unit-tests en itis voor integratietests.

Antwoord 8

Ze zijn hetzelfde. Ik gebruik TypeScript als programmeertaal en als ik het definitiebestand van de Jest-pakketbroncode van /@types/jest/index.d.ts bekijk, zie ik de volgende code.

Natuurlijk zijn er veel verschillende namen van ‘test’, en je kunt ze allemaal gebruiken.

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;