Wie man den Winkelmesser-Test von Spec auf bestimmten Zustand verlässt?

Question

Ich habe eine Suite, die mehrere Spezifikationen enthält. Jede Spezifikation verwendet Code für einige Bibliotheken, die bei einem Fehler eine abgelehnte Zusage zurückgeben.

Ich kann leicht catch diese abgelehnten Versprechen in meiner Spezifikation. Was ich mich wundere ist, dass, wenn ich Winkelmesser die ganze Suite innerhalb dieser catch Funktion verlassen kann, weil die nächsten specs innerhalb der gleichen Suite vom Erfolg der vorherigen specs abhängig sind.

Pretend ich eine Suite haben testEverything genannt, die diese Spezifikationen hat openApp, signIn, checkUser, logout. Wenn fehlschlägt, werden alle folgenden Spezifikationen aufgrund der Abhängigkeit fehlschlagen.

Betrachten Sie diesen Code für openApp:

var myLib = require('./myLib.js'); 

describe('App', function() { 

    it('should get opened', function(done) { 

    myLib.openApp() 
    .then(function() { 

     console.log('Successfully opened app'); 

    }) 
    .catch(function(error) { 

     console.log('Failed opening app'); 

     if (error.critical) { 
     // Prevent next specs from running or simply quit test 
     } 

    }) 
    .finally(function() { 

     done(); 

    }); 

    }); 

}); 

Wie würde ich den ganzen Test beenden?

Answer 1

Ich habe es geschafft, einen Workaround zu finden. Nun ist der eigentliche Code, den ich benutzt habe, viel komplexer, aber die Idee ist dieselbe.

Ich habe eine globale Variable in der Konfigurationsdatei des Winkelmessers bail hinzugefügt. Betrachten Sie den folgenden Code am Anfang der Konfigurationsdatei:

(function() { 

    global.bail = false; 

})(); 

exports.config: { ... 

Der obige Code verwendet eine IIFE (sofort aufgerufen Funktion Ausdruck), die global Objekt bail Variable auf dem Transporteur definiert (die während des gesamten Tests zur Verfügung stehen würden).

Ich habe auch asynchrone Wrapper für die Jasmine Matcher geschrieben, die ich brauche, die einen expect Ausdruck gefolgt von einem Vergleich ausführen würde, und ein Versprechen zurückgeben (mit Q Modul). Beispiel:

var q = require('q'); 

function check(actual) { 

    return { 

     sameAs: function(expected) { 

      var deferred = q.defer(); 
      var expectation = {}; 

      expect(actual).toBe(expected); 

      expectation.result = (actual === expected); 

      if (expectation.result) { 

       deferred.resolve(expectation); 
      } 
      else { 
       deferred.reject(expectation); 
      } 

      return deferred.promise; 

     } 

    }; 

} 

module.exports = check; 

dann am Ende jeden spec, stellte ich den bail Wert basierend auf den Fortschritt des spec, die durch das Versprechen dieses asynchronen Matcher bestimmt werden würde. Betrachten Sie den folgenden als erste Spezifikation:

var check = require('myAsyncWrappers'); // Whatever the path is 

describe('Test', function() { 

    it('should bail on next spec if expectation fails', function(done) { 

     var myValue = 123; 

     check(myValue).sameAs('123') 
     .then(function(expectation) { 

      console.log('Expectation was met'); // Won't happen 

     }) 
     .catch(function(expectation) { 

      console.log('Expectation was not met'); // Will happen 

      bail = true; // The global variable 

     }) 
     .finally(function() { 

      done(); 

     }); 

    }); 

}); 

Schließlich, am Anfang der nächsten Spezifikation, überprüfe ich für bail und zurück, wenn nötig:

describe('Test', function() { 

    it('should be skipped due to bail being true', function(done) { 

     if (bail) { 

      console.log('Skipping spec due to previous failure'); 

      done(); 

      return; 

     } 

     // The rest of spec 

    }); 

}); 

Jetzt will ich erwähnen, dass es aus einem Modul gibt es genannt protractor-fail-fast, die den gesamten Test verbietet, wenn eine Erwartung fehlschlägt.

Aber in meinem Fall musste ich die globale Variable bail festlegen, je nachdem, welche Art von Erwartung fehlgeschlagen ist.Ich habe am Ende eine Bibliothek geschrieben (wirklich klein), die Fehler als kritisch und unkritisch unterscheidet und dann die Spezifikationen nur dann stoppt, wenn ein kritischer Fehler aufgetreten ist.

Answer 2

Es gibt ein Modul für npm namens protractor-fail-fast. Installieren Sie das Modul npm install protractor-fail-fast. Hier ist ein Beispiel von ihrer Seite, wo Sie diesen Code in Ihre conf Datei platzieren würde:

var failFast = require('protractor-fail-fast'); 

exports.config = { 
    plugins: [{ 
    package: 'protractor-fail-fast' 
    }], 

    onPrepare: function() { 
    jasmine.getEnv().addReporter(failFast.init()); 
    }, 

    afterLaunch: function() { 
    failFast.clean(); // Cleans up the "fail file" (see below) 
    } 
} 

Ihre url here ist.