unit-testing - unitarias - test unitarios angular 2

prueba unitaria parametrizada de jazmín

Question

Bueno, como un chico de C # NUnit esto podría ser extraño.

¿Pero permite el jazmín la prueba unitaria parametrizada?

No estoy seguro de si va en contra de "declarar" y "hacerlo" para que las cosas sean legibles para los no programadores.

He visto algunos complementos de terceros, pero son un poco antiguos, no estoy seguro de si se han agregado a jasmine. Si estoy dispuesto a usar un plug in

Solo para ayudar a cualquiera que encuentre esto en el futuro, me han dicho en el foro de jazmín. No hay soporte de primera clase para pruebas parametrizadas dentro de Jasmine.

Answer 1

Mejor solución (especialmente si usas TypeScript)

Otra solución es usar Array of Objects en lugar de Array of Arrays . Se ajusta mejor si utiliza algún sistema de escritura como TypeScript.

Tipo de problema

Imagina que tienes la siguiente prueba parametrizada:

it(''action(value) should reset the forms pool only if value is true'', () => {
  [
    [true, 1],
    [false, 0],
  ].forEach(([value, calledTimes]) => {
    spyResetFormsPool.calls.reset();

    component.action(value); // type error #1

    expect(spyResetFormsPool).toHaveBeenCalledTimes(calledTimes); // type error #2
  });
});

con TypeScript, no podrá compilarse dando dos errores:

error # 1:

error TS2345: Argumento de tipo ''número | boolean ''no se puede asignar a un parámetro de tipo'' boolean ''.

error # 2:

error TS2345: Argumento de tipo ''número | booleano ''no se puede asignar a un parámetro de tipo'' número ''. El tipo ''verdadero'' no se puede asignar al tipo ''número''.

Eso es porque TypeScript ve una matriz de '' número | booleano ''.

Podríamos resolver rápidamente esta advertencia utilizando un reparto explícito:

it(''action(value) should reset the forms pool only if value is true'', () => {
  [
    [true, 1],
    [false, 0],
  ].forEach(([value, calledTimes]) => {
    spyResetFormsPool.calls.reset();

    component.action(value as boolean); // necessary cast

    expect(spyResetFormsPool).toHaveBeenCalledTimes(calledTimes as number);  // necessary cast
  });
});

Sin embargo, esta solución no es muy agradable.

Solución

Una mejor manera es usar Array of Objects , para que los tipos se manejen correctamente de manera predeterminada y no hay necesidad de realizar una conversión explícita :

it(''action(value) should reset the forms pool only if value is true'', () => {
  [
    { value: true, calledTimes: 1 },
    { value: false, calledTimes: 0 },
  ].forEach(({ value, calledTimes }) => {
    spyResetFormsPool.calls.reset();

    component.action(value);

    expect(spyResetFormsPool).toHaveBeenCalledTimes(calledTimes);
  });
});

Answer 2

Así que empecé a combinar:

• YAML usando js-yaml
• jazmines
• Mecanografiado

para crear lo que creo son pruebas parametrizadas legibles como esta:

import YamlTableReader, {fixtureData, TestData} from "./YamlTableReader";    

describe("TestSuite", () => {
        describe("Real TestCase with Data Fixture", () => {

            // now using tagged template-string to auto convert into YamlTableReader. 

            var testdata = fixtureData ` 

            |   ID  | Value1 | Value2 | Squared |
            |   0   |1       | 1      | 1       |
            |   1   |2       | 2      | 4       |
            |   2   |3       | 3      | 91       |

            `;
            // This actually creates a test for each row of the table above
            testdata.describeEach("Square Test","[ID={ID}]:{Value1} x {Value2} should be equal to {Squared}",
                (row: {Value1: number, Value2: number, Squared: number}) => {
                    expect((row.Value1 * row.Value2)).toBe(row.Squared)
                }
            );
        });

Ejecutar esto dará los siguientes resultados:

Failures:
1) TestSuite 2 Real TestCase with Data Fixture Square Test : [ID=2]:3 x 3 should be equal to 91
  Message:
    Expected 9 to be 91.

Fuentes: https://github.com/deicongmbh/jasmine-param-tests

Answer 3

Basado en la respuesta de piotrek y en el artículo Pruebas parametrizadas en Javascript , también podría utilizar el siguiente enfoque que utiliza la sintaxis ES6:

[
  [''abc'', 3],
  [''ab'', 2],
  ['''', 0],
].forEach(([string, expectedLength]) => {
  it(`should return length ${expectedLength} for string "${string}"`, () => {
    expect(string.length).toBe(expectedLength);
  });
});

Lo he probado con el marco de prueba Jest, pero también debería funcionar con Jasmine.

Answer 4

No he trabajado con jasmine desde hace mucho tiempo, pero fue bastante fácil agregar pruebas parametrizadas:

  [''abc'', 3,
   ''ab'',  4,
   '''',    0].
it(''should contain string length'', function(string, expected){
   expect(string.length).toBe(expected);
});

Con solo unas pocas líneas de código de infraestructura:

Array.prototype.it = function(description, testCaseFunction) {
     _(this)
      .chunk(testCaseFunction.length)
      .each(function(innerArray){
                it(description + '' '' + JSON.stringify(innerArray), function(){
                   testCaseFunction.apply(this, innerArray);
                });     
      })
      .value();
};

Dependiendo de la sintaxis deseada y la disposición a cambiar los objetos js predeterminados, tiene muchas opciones: http://blog.piotrturski.net/2015/04/jasmine-parameterized-tests.html