instalar - resharper para visual studio 2013

Jasmine y Requirejs en Resharper 7

Question

Estoy intentando ejecutar un código JavaScript usando jazmín y Resharper 7 en Visual Studio 2012. Sigo el patrón de AMD con la ayuda de requirejs. Sin embargo, no he logrado hacer mi prueba en el corredor de prueba Resharper.

¿Alguien ha logrado hacer algo similar a eso?

Answer 1

Use un módulo llamado requireJS

define("my/sut", function () {

    var MySut = function () {
        return {
            answer: 42
        };
    };
    return MySut;
});

Y inicializa el SUT con el soporte asyncronus de Jasmine. No olvides las referencias!

/// <reference path="~/Scripts/require.js"/>
/// <reference path="../code/sut.js" />

describe("requireJS with Jasmine and Resharper", function () {

    it("should be executed", function () {

        // init SUT async
        var sut;
        runs(function () {
            require([''my/sut''], function (MyModel) {
                sut = new MyModel();
            });
        });
        waitsFor(function () {
            return sut;
        }, "The Value should be incremented", 100);

        // run the test
        runs(function () {
            expect(sut.answer).toBe(42);
        });
    });
});

Espero que esto funcione con más módulos. En mi caso, funcionó con waits for ''0'' ms.

Answer 2

Una versión simplificada de la respuesta mgsdev, coloque el código de carga en una declaración beforeEach, de esa manera puede escribir expectativas cortas.

módulo:

define("stringCalculator", function () {
    return {
        calculate: function (string) {
            var result = 0;
            string.split("+").forEach(function(number) {
                result += parseInt(number);
            });
            return result;
        }
    };
});

archivo de prueba: si la calculadora no está definida, intentará cargarla antes de cada expectativa.

/// <reference path="~/Scripts/require.js"/>
/// <reference path="~/code/stringCalculator.js"/>

describe("string calculator", function () {
    var calculator;

    beforeEach(function () {    
        if (!calculator) {
            require(["stringCalculator"], function (stringCalculator) {
                calculator = stringCalculator;
            });

            waitsFor(function () {
                return calculator;
            }, "loading external module", 1000);
        }
    });

    it("should add 1 and 2", function () {
        var result = calculator.calculate("1+2");
        expect(result).toEqual(3);
    });

    it("should add 2 and 2", function () {
        var result = calculator.calculate("2+2");
        expect(result).toEqual(4);
    });

    it("should add 1, 2 and 3", function() {
        var result = calculator.calculate("1+2+3");
        expect(result).toEqual(6);
    });
});

Answer 3

Si usa Jasmine 2.0 o posterior, puede admitir llamadas asincrónicas en su código. Simplemente pase el parámetro done a la función para su prueba unitaria, luego llame a done () cuando haya cargado sus módulos:

describe("add function", function(){
   it("calls renderNew", function(done){
      define("taskRenderer", [], function() {
         return {
            renderNew: function(){}
         };
      });

      require(["taskRenderer"], function(taskRenderer) {
         spyOn(taskRenderer, "renderNew");
         taskRenderer.renderNew();
         expect(taskRenderer.renderNew).toHaveBeenCalled();
         done();
      });
   }
}

De esta forma, en realidad no realiza su prueba hasta que los módulos estén cargados y la prueba no se marque prematuramente como finalizada.