Quiero reemplazar este código de prueba:

expect(events.length).toEqual(2);

expect(events[0].item).toEqual("A");
expect(events[0].newIndex).toEqual(0);
expect(events[0].type).toEqual(CollectionChangeType.Insert);

expect(events[1].item).toEqual("D");
expect(events[1].oldIndex).toEqual(2);
expect(events[1].type).toEqual(CollectionChangeType.Remove);

... con la forma más corta (que en realidad es más exhaustiva en mi caso) ...

expect(events).toEqual([
    CollectionChange.insert("A", "A", 0),
    CollectionChange.remove("D", "D", 2)
]);

Sin embargo, la salida en el caso de errores es demasiado difícil de leer.

Se esperaba [{type: 0, item: 'A', itemId: 'A', newIndex: 0, oldIndex: -1}, {type: 2, item: 'D', itemId: 'D', newIndex: -1 , oldIndex: 3}] para igualar [{type: 0, item: 'A', itemId: 'A', newIndex: 0, oldIndex: -1}, {type: 2, item: 'D', itemId: ' D ', newIndex: -1, oldIndex: 2}].

¿Hay alguna manera de personalizar esta salida? Por ejemplo, estaría feliz con:

Array items differ at indices:

[1] expected { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 3 }
    but saw  { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 2 }

¿Puedo modificar la lógica en caso de comparación de matriz para hacer esto?

0
Drew Noakes 2 sep. 2014 a las 14:57

2 respuestas

La mejor respuesta

Puede crear su propio marcador de jazmín que tenga un mensaje más detallado. Vea este enlace para más detalles

Hice una versión simple en jazmín 1.3 que podría ayudarlo a comenzar.

describe("example", function ()
{
    beforeEach(function ()
    {
        this.addMatchers({

            arrayComparison: function (expected)
            {
                var actual = this.actual;
                this.message = function() { return "Array items differ at indices:\n\n[1] expected " + expected + "\n but saw " + actual; }
                return this.actual == expected;
            }
        });
    });
    it("should compare arrays", function ()
        {
            var array1 = { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 3 };
            var array2 = { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 2 };
            expect(array1).arrayComparison(array2);
        });
});
1
Onosa 2 sep. 2014 a las 14:52

Escribir un formateador personalizado para obtener un resultado bonito es inconveniente, ya que te obliga a escribir un formateador personalizado para cada prueba en la que está involucrado tu objeto personalizado. P.ej. debe duplicar la lógica de formato personalizado para [{key: new MyObject() }] y [new MyObject()]. Sería mucho más conveniente si hubiera una forma de especificar cómo MyObject se serializa.

Esto se puede hacer a través del método jasmineToString. Si esta función está presente en la función, Jasmine imprimirá su valor de retorno en lugar de procesar recursivamente el objeto. Esto funciona en todas las versiones de Jasmine (1.3, 2.0, 2.1, 2.3).

Aquí hay un ejemplo (con pruebas que fallan deliberadamente):

function MyObject(id) {
    this.id = id;
    this.junk = 'bla bla'; // I do not want to see this.
}

it('should be pretty', function() {
    MyObject.prototype.jasmineToString = function() {
        return 'MyObject(' + this.id + ')';
    };
    expect([new MyObject(123)]).toBe(new MyObject('different'));
    // "Expected [ MyObject(123) ] to be MyObject(different)."
});
it('should be ugly', function() {
    MyObject.prototype.jasmineToString = undefined;
    expect([new MyObject(123)]).toBe(new MyObject('different'));
    // "Expected [ MyObject({ id: 123, junk: 'bla bla' }) ] to be ..."
});
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jasmine/2.3.4/jasmine.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/jasmine/2.3.4/jasmine.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jasmine/2.3.4/jasmine-html.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jasmine/2.3.4/boot.js"></script>
0
Rob W 13 ago. 2015 a las 15:10