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

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

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

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.

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:

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

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.

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.

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;