javascript - Hva er forskjellen mellom 'it' og 'test' i Jest?

Jeg har to tester i testgruppen min. Den ene testen bruker it og den andre bruker test. Begge ser ut til å fungere veldig likt. Hva er forskjellen mellom dem?

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

Oppdatering - nov 2022:

Det ser ut til at test og it er utskiftbare i henhold til den offisielle API-en til Jest. Som @gwildu beskrev her, bør du velge én over den andre for lesbarhetens skyld.

Svar #1

Jest-dokumentasjonen sier at it er et alias for test. Så de er helt like fra et funksjonelt synspunkt. De eksisterer begge for å gjøre det mulig å lage en lesbar engelsk setning fra testen din.

Svar #2

De gjør det samme, men navnene deres er forskjellige, og med det deres interaksjon med navnet på testen.

test :

Det du skriver:

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

Hva du får hvis noe mislykkes:

yourModule > if it does this thing

det :

Det du skriver:

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

Hva du får hvis noe mislykkes:

yourModule > should do this thing

Så det handler om lesbarhet, ikke om funksjonalitet.

Etter min mening har det virkelig et poeng når det gjelder å lese resultatet av en test som feiler og som du ikke har skrevet selv. Det hjelper å raskere forstå hva testen handler om.

Noen utviklere forkorter også Should do this thing til Does this thing som er litt kortere og også passer semantisk til it-notasjonen.

Svar #3

Som de andre svarene har klargjort, gjør de det samme.

Jeg tror de to tilbys for å tillate enten 1) «RSpec»-stil tester som:

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

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

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

eller 2) "xUnit" stiltester som:

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

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

Dokumentasjon:

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

Svar #4

Som jest-dokumentasjonen sier, er de det samme: det alias

test(navn, fn, tidsavbrudd)

Også under aliaset: it(name, fn, timeout)

Og describe er bare for når du foretrekker at testene dine er organisert i grupper: describe

beskriv(navn, fn)

describe(name, fn) oppretter en blokk som grupperer flere relaterte tester sammen. For eksempel, hvis du har et myBeverage-objekt som skal være deilig, men ikke surt, kan du teste det med:

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

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

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

Dette er ikke nødvendig - du kan skrive testblokkene direkte på toppnivå. Men dette kan være nyttig hvis du foretrekker at testene dine er organisert i grupper.

Relaterte artikler