javascript - attribute - Cómo cambiar la implementación simulada en base a una sola prueba

title html css

Question

Me gustaría cambiar la implementación de una dependencia simulada en base a una sola prueba extendiendo el comportamiento de la simulación predeterminada y volviendo a la implementación original cuando se ejecuta la siguiente prueba.

Más brevemente esto es lo que estoy tratando de lograr:

1. simulacro de dependencia
2. Cambiar / extender la implementación simulada en una sola prueba.
3. volver a la simulación original cuando se ejecuta la siguiente prueba

Actualmente estoy usando Jest v21 .

Aquí es cómo se vería una típica prueba de Jest:

__mocks__/myModule.js

const myMockedModule = jest.genMockFromModule(''../myModule'');

myMockedModule.a = jest.fn(() => true);
myMockedModule.b = jest.fn(() => true);

export default myMockedModule;

__tests__/myTest.js

import myMockedModule from ''../myModule'';

// Mock myModule
jest.mock(''../myModule'');

beforeEach(() => {
  jest.clearAllMocks();
});

describe(''MyTest'', () => {
  it(''should test with default mock'', () => {
    myMockedModule.a(); // === true
    myMockedModule.b(); // === true
  });

  it(''should override myMockedModule.b mock result (and leave the other methods untouched)'', () => {
    // Extend change mock
    myMockedModule.a(); // === true
    myMockedModule.b(); // === ''overridden''
    // Restore mock to original implementation with no side eeffects
  });

  it(''should revert back to default myMockedModule mock'', () => {
    myMockedModule.a(); // === true
    myMockedModule.b(); // === true
  });
});

Probé algunas estrategias, pero no encontré ninguna solución que pudiera definir satisfactoria.

1 - mockFn.mockImplementationOnce(fn)

pros

• Vuelve a la implementación original después de la primera llamada.

contras

• Se romperá si la prueba llama b más veces
• No volverá a la implementación original hasta que no se llame a b (se filtra en la siguiente prueba)

código:

it(''should override myModule.b mock result (and leave the other methods untouched)'', () => {

  myMockedModule.b.mockImplementationOnce(() => ''overridden'');

  myModule.a(); // === true
  myModule.b(); // === ''overridden''
});

2 - jest.doMock (nombre de módulo, fábrica, opciones)

pros

• Se vuelve a imitar explícitamente en cada prueba

contras

• No se puede definir una implementación simulada predeterminada para todas las pruebas
• No se puede extender una implementación predeterminada forzando a volver a declarar cada método simulado

código:

it(''should override myModule.b mock result (and leave the other methods untouched)'', () => {

  jest.doMock(''../myModule'', () => {
    return {
      a: jest.fn(() => true,
      b: jest.fn(() => ''overridden'',
    }
  });

  myModule.a(); // === true
  myModule.b(); // === ''overridden''
});

3 - Simulación manual con métodos de establecimiento (como se explica here )

pros

• Control total sobre resultados burlados.

contras

• Lote de código repetitivo
• Difícil de mantener a largo plazo

código:

__mocks__/myModule.js

const myMockedModule = jest.genMockFromModule(''../myModule'');

let a = true;
let b = true;

myMockedModule.a = jest.fn(() => a);
myMockedModule.b = jest.fn(() => b);

myMockedModule.__setA = (value) => { a = value };
myMockedModule.__setB = (value) => { b = value };
myMockedModule.__reset = () => {
  a = true;
  b = true;
};
export default myMockedModule;

__tests__/myTest.js

it(''should override myModule.b mock result (and leave the other methods untouched)'', () => {
  myModule.__setB(''overridden'');

  myModule.a(); // === true
  myModule.b(); // === ''overridden''

  myModule.__reset();
});

4 - jest.spyOn (object, methodName)

contras

• No puedo revertir mockImplementation al valor de retorno mockImplementation original, por lo tanto afectando las siguientes pruebas

código:

beforeEach(() => {
  jest.clearAllMocks();
  jest.restoreAllMocks();
});

// Mock myModule
jest.mock(''../myModule'');

it(''should override myModule.b mock result (and leave the other methods untouched)'', () => {

  const spy = jest.spyOn(myMockedModule, ''b'').mockImplementation(() => ''overridden'');

  myMockedModule.a(); // === true
  myMockedModule.b(); // === ''overridden''

  // How to get back to the original mocked value?
});

Gracias de antemano por cualquier entrada / sugerencia!

Answer 1

Poco tarde a la fiesta, pero si alguien más está teniendo problemas con esto.

Utilizamos TypeScript, ES6 y babel para el desarrollo nativo reactivo.

Por lo general, __mocks__ módulos NPM externos en el directorio raíz __mocks__ .

Quería anular una función específica de un módulo en la clase Auth de aws-amplify para una prueba específica.

    import { Auth } from ''aws-amplify'';
    import GetJwtToken from ''./GetJwtToken'';
    ...
    it(''When idToken should return "123"'', async () => {
      const spy = jest.spyOn(Auth, ''currentSession'').mockImplementation(() => ({
        getIdToken: () => ({
          getJwtToken: () => ''123'',
        }),
      }));

      const result = await GetJwtToken();
      expect(result).toBe(''123'');
      spy.mockRestore();
    });

Gist: https://gist.github.com/thomashagstrom/e5bffe6c3e3acec592201b6892226af2

Tutorial: https://medium.com/p/b4ac52a005d#19c5

Answer 2

Un buen patrón para la prueba de escritura es crear una función de configuración de fábrica que devuelva los datos que necesita para probar el módulo actual.

A continuación se muestra un código de ejemplo que sigue a su segundo ejemplo, aunque permite la provisión de valores predeterminados y de anulación de manera reutilizable.

const spyReturns = returnValue => jest.fn(() => returnValue);

describe("scenario", () => {
  const setup = (mockOverrides) => {
    const mockedFunctions =  {
      a: spyReturns(true),
      b: spyReturns(true),
      ...mockOverrides
    }
    return {
      mockedModule: jest.doMock(''../myModule'', () => mockedFunctions);
    }
  }

  it("should return true for module a", () => {
    const {mockedModule} = setup();
    expect(mockedModule.a()).toEqual(true)
  });

  it("should return override for module a", () => {
    const EXPECTED_VALUE = "override"
    const {mockedModule} = setup({ a: spyReturns(EXPECTED_VALUE)});

    expect(mockedModule.a()).toEqual(EXPECTED_VALUE)
  })
});

Answer 3

Utilice mockFn.mockImplementation(fn) .

Ponga la implementación predeterminada en el beforeEach . El simulacro se reiniciará antes de cada prueba.

Para anular, use mockImplementation en la prueba.

Esto anulará el comportamiento del simulacro para cualquiera / todas las llamadas en la prueba, y será sobrescrito por la implementación de beforeEach antes de la siguiente prueba.

Por ejemplo:

import { funcToMock } from ''./somewhere'';
jest.mock(''./somewhere'');

beforeEach(() => {
  funcToMock.mockImplementation(() => { /* default implementation */ });
});

test(''case that needs a different implementation of funcToMock'', () => {
  funcToMock.mockImplementation(() => { /* implementation specific to this test */ });
  // ...
});