javascript - test - karma js

¿Jasmine está antes de cada uno sincrónico?

Question

Si tiene múltiples beforeEach ''s, ¿siempre se ejecutarán uno tras otro?

beforeEach(function() {});
beforeEach(function() {});
beforeEach(function() {});
beforeEach(function() {});
beforeEach(function() {});

Parece que lo harán. Intenté probarlo con mi código:

describe(''Directive: Statement'', function() {
  var el, scope, statements;

  beforeEach(module(''simulatedSelves''));
  beforeEach(module(''templates''));
  beforeEach(inject(function($compile, $rootScope) {
    console.log(1);
    scope = $rootScope.$new();

    statements = [];
    scope.statement = {
      text: ''test'',
      arr: []
    };
    scope.statement.parent = statements;
    statements.push(scope.statement);

    el = angular.element(''<statement statement=statement></statement>'');
    $compile(el)(scope);
    scope.$digest();
  }));
  beforeEach(function() {
    var counter = 0;
    console.log(2);
    for (var i = 0; i < 1000000; i++) {
      counter++;
    }
    console.log(counter);
  });
  beforeEach(function() {
    console.log(3);
  });

  it(''test statement has correct properties'', function() {
    // stuff
  });
});

Registra:

1
2
1000000
3

Dado que el beforeEach con el bucle long for registra sus cosas antes que la que registra 3 , creo que el beforeEach ejecuta de forma síncrona. ¿Es eso cierto?

Answer 1

Sí, todo antes. beforeEach s se ejecutará en el orden que usted defina.

Si exploras Jasmine, finalmente llegas a esta definición :

Suite.prototype.beforeEach = function(fn) {
  this.beforeFns.unshift(fn);
};

A medida que agrega describe s, Suite se genera y anida. Cada Suite se inicializa con this.beforeFns = [] , que se agrega como puede ver. Tenga en cuenta que el unshift agrega al lado izquierdo de la matriz, por lo que esperaría que se definiera más tarde antes de que beforeEach una se ejecute primero. Esto se resuelve más tarde cuando Jasmine se acerca a los padres de la suite de beforeEach , reúne todas beforeEach listas anteriores y luego las invierte para ejecutarlas en el orden que desee.

var beforeAndAfterFns = function(suite) {
  return function() {
    var befores = [],
      afters = [];

    while(suite) {
      befores = befores.concat(suite.beforeFns);
      afters = afters.concat(suite.afterFns);

      suite = suite.parentSuite;
    }

    return {
      befores: befores.reverse(),
      afters: afters
    };
  };
};

Como señala Dan , hasta ahora hemos supuesto que todos sus beforeEach son sincrónicos. A partir de Jasmine 2, puede configurar asincrónico beforeEach s así:

beforeEach(function(done) {
  setTimeout(function() {
    console.log(''Async'');
    done();
  }, 1000)
});

En el tiempo de ejecución, Jasmine le envía la función completada y se ejecuta de forma asincrónica si su función toma un argumento . ( Function.length devuelve la cantidad de argumentos que espera la función).

for(iterativeIndex = recursiveIndex; iterativeIndex < length; iterativeIndex++) {
  var queueableFn = queueableFns[iterativeIndex];
  if (queueableFn.fn.length > 0) {
    attemptAsync(queueableFn);
    return;
  } else {
    attemptSync(queueableFn);
  }
}

attemptAsync espera que usted llame a done() antes de que QueueRunner pase a la siguiente beforeEach enganche, por lo que el orden sigue funcionando! Con buena pinta.

describe(''beforeEach'', function() {
  var data = null;

  beforeEach(function() { data = []; });
  beforeEach(function() { data.push(1); });
  beforeEach(function(done) {
    setTimeout(function() {
      data.push(''Async'');
      done();
    }, 1000);
  });
  beforeEach(function() { data.push(2); });
  beforeEach(function() { data.push(3); });

  it(''runs in order'', function(){
    expect(data).toEqual([1, ''Async'', 2, 3]);
  });
});