Ik heb twee tests in mijn testgroep. Een van de tests gebruikt it
en 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 test
zich in de officiële API van Jest bevindt , maar it
niet.
Antwoord 1, autoriteit 100%
De Jest docsstaat it
is 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 it
echt 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 thing
tot 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 describe
is 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 isinchesOfRain()
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. test
is voor unit-tests en it
is 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;