Qual'è la differenza tra 'it' e 'test' in jest?


281

Ho due test nel mio gruppo di test. Uno lo utilizza l'altro utilizza il test e sembrano funzionare in modo molto simile. Qual'è la differenza tra loro?

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

AGGIORNARE:

Sembra che testsia nell'API ufficiale di Jest , ma itnon lo è.


itpotrebbe essere lì solo per familiarità e migrazione da altri framework.
Andrew Li,

23
non c'è differenza. La documentazione afferma chiaramente che testè sotto lo pseudonimo it.
Claies,

Risposte:



34

Fanno la stessa cosa, ma i loro nomi sono diversi e con ciò la loro interazione con il nome del test.

test

Cosa scrivi:

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

Cosa ottieni se qualcosa fallisce:

yourModule > if it does this thing

esso

Ciò che scrivi:

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

Cosa ottieni se qualcosa fallisce:

yourModule > should do this thing

Quindi si tratta di leggibilità, non di funzionalità. A mio avviso, itha davvero senso quando si tratta di leggere il risultato di un test fallito che non hai scritto tu stesso. Aiuta a capire più velocemente di cosa tratta il test.


4
alcuni preferiscono anche it('does this thing', () => {})invece di it('should do this thing', () => {}essere il più corto
gwildu il

In alternativa, test('thing should do x')può essere preferito rispetto a it('Should do X')come itè spesso vago.
mikemaccana,

21

Come le altre risposte hanno chiarito, fanno la stessa cosa.

Credo che i due siano offerti per consentire 1) Test di stile " RSpec " come:

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

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

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

oppure 2) test di stile " xUnit " come:

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

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

Documenti:


2

come dicono i documenti jest, sono gli stessi: https://jestjs.io/docs/en/api#testname-fn-timeout

test (nome, fn, timeout)

Anche sotto lo pseudonimo: it (name, fn, timeout)

e descrivi è solo per quando preferisci che i tuoi test siano organizzati in gruppi: https://jestjs.io/docs/en/api#describename-fn

descrivi (nome, fn)

describe(name, fn)crea un blocco che raggruppa diversi test correlati. Ad esempio, se hai un oggetto myBeverage che dovrebbe essere delizioso ma non acido, puoi testarlo con:

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

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

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

Questo non è necessario: puoi scrivere i blocchi di prova direttamente al livello superiore. Ma questo può essere utile se preferisci che i tuoi test siano organizzati in gruppi.


-4

Jest non ha menzionato il motivo per cui hanno due versioni per la stessa identica funzionalità. La mia ipotesi è che è solo per convenzione. test per unit test per test di integrazione.


-22

Sono la stessa cosa. Sto usando TypeScript come linguaggio di programmazione e quando guardo il file di definizione dal codice sorgente del pacchetto jest da /@types/jest/index.d.ts, posso vedere i seguenti codici. Ovviamente ci sono molti nomi diversi di 'test', puoi usarli tutti.

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
Il codice che mostri non lo indica ite testsono la stessa cosa. Significa solo che il loro tipo è lo stesso. Non lo penso beforeAlle afterAllsono la stessa cosa anche se il loro tipo è lo stesso.
realUser404,

2
xit and xtestsalta i test, it, fit, testdevono eseguire i test. Grazie per la tua risposta.
Akash,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.