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

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 è.

Nei documenti dice qui : itè un alias di test. Quindi sono esattamente gli stessi.

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.

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:

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

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.

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.

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;