¿Cuál es la diferencia entre 'it' y 'test' en broma?

282

Tengo dos pruebas en mi grupo de prueba. Uno lo usa, el otro usa prueba, y parecen estar funcionando de manera muy similar. ¿Cuál es la diferencia entre ellos?

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

ACTUALIZAR:

Parece que testestá en la API oficial de Jest , pero itno lo está.

C.Lee
fuente
itpodría estar allí para familiarizarse y migrar desde otros marcos.
Andrew Li
23
no hay diferencia. La documentación indica claramente que testestá bajo el alias it.
Claies

Respuestas:

398

En los documentos dice aquí : ites un alias de test. Entonces son exactamente lo mismo.

musicformellons
fuente
35

Hacen lo mismo, pero sus nombres son diferentes y con eso su interacción con el nombre de la prueba.

prueba

Lo que escribes:

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

Lo que obtienes si algo falla:

yourModule > if it does this thing

eso

Lo que escribes:

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

Lo que obtienes si algo falla:

yourModule > should do this thing

Entonces se trata de legibilidad, no de funcionalidad. En mi opinión, itrealmente tiene sentido cuando se trata de leer el resultado de una prueba reprobatoria que no ha escrito usted mismo. Ayuda a comprender más rápidamente de qué se trata el examen.

gwildu
fuente
44
algunos también prefieren en it('does this thing', () => {})lugar de it('should do this thing', () => {} ser más cortos
gwildu
Alternativamente, test('thing should do x')puede preferirse sobre it('Should do X')como ites a menudo vago.
mikemaccana
21

Como las otras respuestas han aclarado, hacen lo mismo.

Creo que los dos se ofrecen para permitir 1) pruebas de estilo " RSpec " como:

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

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

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

o 2) pruebas de estilo " xUnit " como:

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

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

Documentos:

Rico
fuente
2

como dice el jest docs, son lo mismo: https://jestjs.io/docs/en/api#testname-fn-timeout

prueba (nombre, fn, tiempo de espera)

También bajo el alias: it (nombre, fn, tiempo de espera)

y describe es solo para cuando prefiere que sus pruebas se organicen en grupos: https://jestjs.io/docs/en/api#describename-fn

describir (nombre, fn)

describe(name, fn)crea un bloque que agrupa varias pruebas relacionadas. Por ejemplo, si tiene un objeto myBeverage que se supone que es delicioso pero no ácido, puede probarlo 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();
  });
});

Esto no es obligatorio: puede escribir los bloques de prueba directamente en el nivel superior. Pero esto puede ser útil si prefiere que sus pruebas se organicen en grupos.

SeyyedKhandon
fuente
-4

Jest no ha mencionado por qué tienen dos versiones para exactamente la misma funcionalidad. Supongo que es solo por convención. test for unit lo prueba para pruebas de integración.

borato de kishor
fuente
-22

Ellos son la misma cosa. Estoy usando TypeScript como lenguaje de programación, y cuando busco en el archivo de definición del código fuente del paquete jest de /@types/jest/index.d.ts, puedo ver los siguientes códigos. Obviamente, hay muchos nombres diferentes de 'prueba', puede usar cualquiera de ellos.

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;

杨正云
fuente
25
El código que muestra no indica eso ity testson lo mismo. Simplemente significa que su tipo es el mismo. No lo creo beforeAlly afterAllson lo mismo a pesar de que su tipo es el mismo.
realUser404
2
xit and xtestse saltea las pruebas, it, fit, testson para ejecutar pruebas. Gracias por tu respuesta.
Akash