javascript - reutilizacion - test sobre el reciclaje para niños

¿Cuál es una buena manera de reutilizar el código de prueba con Jasmine?

Question

Estoy usando la biblioteca jazmín BDD Javascript y realmente lo estoy disfrutando. Tengo un código de prueba que me gustaría volver a usar (por ejemplo, probar varias implementaciones de una clase base o ejecutar las mismas pruebas en un contexto ligeramente diferente) y no estoy seguro de cómo hacerlo usando Jasmine. Sé que podría mover el código de las funciones de jazmín a clases reutilizables, pero me gusta la forma en que lee el código intercalado con las funciones de Jasmine (describirlo) y no quiero separar las especificaciones del código de prueba a menos que Tiene que. ¿Alguien que está usando Jasmine se ha enterado de este problema y cómo lo ha manejado?

Answer 1

Aquí hay un artículo de un chico de Pivotal Labs que detalla cómo envolver una llamada de descripción:

Secando Jasmine Specs con comportamiento compartido

Fragmento del artículo que muestra parte de la función de envoltura:

function sharedBehaviorForGameOf(context) {
  describe("(shared)", function() {
    var ball, game;
    beforeEach(function() {
      ball = context.ball;
      game = context.game;
    });
  });
}

Answer 2

Este es el enfoque que he tomado, inspirado por este artículo:

https://gist.github.com/traviskaufman/11131303

que se basa en la documentación propia de Jasmine:

http://jasmine.github.io/2.0/introduction.html#section-The_%3Ccode%3Ethis%3C/code%3E_keyword

Al configurar las dependencias compartidas como propiedades del prototipo de la función beforeEach , puede extender beforeEach para hacer que estas dependencias estén disponibles a través de this .

Ejemplo:

describe(''A suite'', function() {
    // Shared setup for nested suites
    beforeEach(function() {
        // For the sake of simplicity this is just a string
        // but it could be anything
        this.sharedDependency = ''Some dependency'';
    });

    describe(''A nested suite'', function() {
        var dependency;

        beforeEach(function() {
            // This works!
            dependency = this.sharedDependency;                
        });

        it(''Dependency should be defined'', function() {
            expect(dependency).toBeDefined();
        });
    });

    describe(''Check if string split method works'', function() {
        var splitToArray;

        beforeEach(function() {
            splitToArray = this.sharedDependency.split();                
        });

        it(''Some other test'', function() { ... });
    });
});

Sé que mi ejemplo es inútil, pero debe cumplir su función como ejemplo de código.

Por supuesto, esta es solo una de las muchas cosas que podrías hacer para lograr lo que dices, estoy seguro de que se pueden aplicar patrones de diseño más complejos por encima o por debajo de este.

¡Espero eso ayude!

Answer 3

Esto es similar a la respuesta de la estrella, pero después de resolverlo encontré algunas diferencias para señalar. La desventaja es que si la especificación falla, simplemente verá "debería cumplir con las especificaciones de ahorro comunes" en el informe Jasmine. El seguimiento de la pila es la única forma de encontrar dónde falló.

// common specs to execute
self.executeCommonSpecifications = function (vm) {
  // I found having the describe( wrapper here doesn''t work
  self.shouldCallTheDisplayModelsSaveMethod(vm);
}
self.shouldCallTheDisplaysSaveMethod = function (vm) {
  expect(vm.save.calls.count()).toBe(1);
};

// spec add an it so that the beforeEach is called before calling this
beforeEach(function(){
  // this gets called if wrapped in the it
  vm.saveChanges();
}
it(''should adhere to common saving specifications'', function () {
  executeSavingDisplaysCommonSpecifications(vm);
});

Answer 4

Hay un buen artículo en el sitio web de thoughbot: https://robots.thoughtbot.com/jasmine-and-shared-examples

Aquí hay una breve muestra:

appNamespace.jasmine.sharedExamples = {
  "rectangle": function() {
    it("has four sides", function() {
      expect(this.subject.sides).toEqual(4);
    });
  },
 };

Y con algunas funciones de subrayado para definir itShouldBehaveLike

window.itShouldBehaveLike = function() {
  var exampleName      = _.first(arguments),
      exampleArguments = _.select(_.rest(arguments), function(arg) { return !_.isFunction(arg); }),
      innerBlock       = _.detect(arguments, function(arg) { return _.isFunction(arg); }),
      exampleGroup     = appNamespace.jasmine.sharedExamples[exampleName];

  if(exampleGroup) {
    return describe(exampleName, function() {
      exampleGroup.apply(this, exampleArguments);
      if(innerBlock) { innerBlock(); }
    });
  } else {
    return it("cannot find shared behavior: ''" + exampleName + "''", function() {
      expect(false).toEqual(true);
    });
  }
};

Answer 5

No estoy seguro de cómo funciona la solución de @ starmer. Como mencioné en el comentario, cuando uso su código, el context siempre está indefinido.

En cambio, lo que tienes que hacer (como lo menciona @moefinley) es pasar una referencia a una función de constructor. He escrito una publicación de blog que describe este enfoque con un ejemplo. Aquí está la esencia de esto:

describe(''service interface'', function(){
    function createInstance(){
        return /* code to create a new service or pass in an existing reference */
    }

    executeSharedTests(createInstance);
});

function executeSharedTests(createInstanceFn){
    describe(''when adding a new menu entry'', function(){
        var subjectUnderTest;

        beforeEach(function(){
            //create an instance by invoking the constructor function
            subjectUnderTest = createInstanceFn();
        });

        it(''should allow to add new menu entries'', function(){
            /* assertion code here, verifying subjectUnderTest works properly */
        });
    });
}

Answer 6

Se me indicó que envuelva una llamada de descripción en una función que le pase un parámetro.