Mocha: Erstellen und finalisieren Sie den Test programmgesteuert

Question

Ich möchte Proxy-Testergebnisse in Echtzeit auf andere Umgebung ausführen. Hier

ist eine Pseudo-Code, die ich will wirklich machen:

var test = proxy.getCurrentTest(); 
    // => {slow: 200, timeout: 2000, duration: 235, result: 'error'}; 

    var tmpIt = it('test1', function(){ 
     this.slow(test.slow); 
     this.timeout(test.timeout); 
    }); 
    tmpIt.close({ 
     duration: test.duration, 
     result: test.result 
    }); 
    // this should make this test red in the output, 
    // because the `result` is not 'success' 

Ist es irgendwie möglich, Testergebnis und Dauer einzustellen, ohne „wirklich“ es läuft? Und bekommen Sie die gesamte visuelle Mocha-Ausgabe zum Terminal?

bearbeiten: In dieser Frage geht es nicht darum, wie Variablen mit den Testergebnissen vom Kindprozess an den Hauptprozess übergeben werden. es funktioniert schon für mich.

Answer 1

Ich hoffe, ich habe die Anforderungen richtig verstanden. Was ich implementiert habe, ist ein Testergebnis Forwarder zu Mocha, der in Mocha integriert ist.

Zur Integration mit Mocha beschreibt diese Implementierung eine custom mocha interface Proxy-Testergebnisse von Tests in einer anderen Umgebung durchgeführt.

Um diese Schnittstelle zu verwenden, die -u Argument Mokka übergeben werden muss, wenn Mokka

> mocha -u ./path/to/proxy-interface ... 

Hinweis ausgeführt, dass ./path/to/proxy-interface ist der Weg, den Mokka in einem require Aufruf verwendet das Interface-Modul erforderlich ist. Die Proxy-Schnittstelle ist dafür verantwortlich, dem globalen Kontext eine proxyTest-Funktion zur Verfügung zu stellen, wie Mochas BDD-Schnittstelle mit it, ruft die übergebene Funktion auf, um die Testergebnisse zu erhalten und die Testergebnisse weiterzuleiten, während die Anzahl der angezeigten Tests beibehalten wird der Testläufer.

var Mocha = require('mocha'); 

var Suite = Mocha.Suite; 
var Test = Mocha.Test; 
var escapeRe = require('escape-string-regexp'); 

module.exports = function(suite) { 
    var suites = [suite]; 

    suite.on('pre-require', function(context, file, mocha) { 
    // A bit hacky since we require mocha internal common interface module 
    var common = require('mocha/lib/interfaces/common')(suites, context); 

    context.run = mocha.options.delay && common.runWithSuite(suite); 

    context.proxyTest = function(title, fn) { 
     var suite = suites[0]; 
     if (suite.pending) { 
     fn = null; 
     } 
     var test = new ProxyTest(title, fn); 
     test.file = file; 
     suite.addTest(test); 
     return test; 
    }; 
    }); 
}; 

var Runnable = Mocha.Runnable; 
var inherits = require('util').inherits; 

function ProxyTest(title, fn) { 
    Runnable.call(this, title, null); 
    this.pending = !fn; 
    this.type = 'test'; 
    this.body = (fn || '').toString(); 

    this.fn = fn; 
} 

inherits(ProxyTest, Runnable); 

ProxyTest.prototype.run = function(done) { 
    var proxiedTestResult = this.fn(); 

    this.duration = proxiedTestResult.duration; 
    this.timedOut = this.timeout() > proxiedTestResult.timeout; 

    done(proxiedTestResult.result); 
}; 

ProxyTest.prototype.clone = function() { 
    var test = new ProxyTest(this.title, this.fn); 
    test.timeout(this.timeout()); 
    test.slow(this.slow()); 
    test.enableTimeouts(this.enableTimeouts()); 
    test.retries(this.retries()); 
    test.currentRetry(this.currentRetry()); 
    test.globals(this.globals()); 
    test.parent = this.parent; 
    test.file = this.file; 
    test.ctx = this.ctx; 
    return test; 
}; 

Der obige Code überschreibt Mocha des Runnable Lauf Implementierung und läuft die übergebene Funktion Testergebnisse zu erhalten und setzt die erforderlichen Felder in der ProxyTest Schnittstelle mit Mokka Tests kompatibel zu sein.

Nutzungs

In Ihren Tests verwenden, um die proxyTest global einen neuen Test mit Mokka

var proxy = { 
    getErrorTestResult() { 
    return {slow: 200, timeout: 2000, duration: 50, result: 'error'}; 
    }, 

    getTimeoutTestResult() { 
    return {slow: 200, timeout: 2000, duration: 3000 }; 
    }, 

    getSlowTestResult() { 
    return {slow: 200, timeout: 2000, duration: 235 }; 
    }, 

    getSuccessTestResult() { 
    return {slow: 200, timeout: 2000, duration: 50 }; 
    } 
} 

proxyTest('error', proxy.getErrorTestResult); 
proxyTest('timeout', proxy.getTimeoutTestResult); 
proxyTest('slow', proxy.getSlowTestResult); 
proxyTest('success', proxy.getSuccessTestResult); 

Ausgabe

Implicati registrieren ons

Der Nachteil dieses Ansatzes besteht darin, dass eine benutzerdefinierte Schnittstelle zu Mokka übergeben werden muss UND, die Sie nicht Mokka BDD Vokabular wie describe verwenden können. Der zweite Nachteil kann beseitigt werden, wenn Sie „verlängern“ (in diesem Fall: einige Code kopieren), um die BDD-Schnittstelle von Mokka:

var Mocha = require('mocha'); 
/** 
* Module dependencies. 
*/ 

var Suite = Mocha.Suite; 
var Test = Mocha.Test; 
var escapeRe = require('escape-string-regexp'); 

/** 
* BDD-style interface - extended with proxy functionality: 
* 
*  describe('Array', function() { 
*  describe('#indexOf()', function() { 
*   it('should return -1 when not present', function() { 
*   // ... 
*   }); 
* 
*   it('should return the index when present', function() { 
*   // ... 
*   }); 
*  }); 
*  }); 
* 
* @param {Suite} suite Root suite. 
*/ 
module.exports = function(suite) { 
    var suites = [suite]; 

    suite.on('pre-require', function(context, file, mocha) { 
    // A bit hacky since we require mocha internal common interface module 
    var common = require('mocha/lib/interfaces/common')(suites, context); 

    context.before = common.before; 
    context.after = common.after; 
    context.beforeEach = common.beforeEach; 
    context.afterEach = common.afterEach; 
    context.run = mocha.options.delay && common.runWithSuite(suite); 
    /** 
    * Describe a "suite" with the given `title` 
    * and callback `fn` containing nested suites 
    * and/or tests. 
    */ 

    context.describe = context.context = function(title, fn) { 
     var suite = Suite.create(suites[0], title); 
     suite.file = file; 
     suites.unshift(suite); 
     fn.call(suite); 
     suites.shift(); 
     return suite; 
    }; 

    /** 
    * Pending describe. 
    */ 

    context.xdescribe = context.xcontext = context.describe.skip = function(title, fn) { 
     var suite = Suite.create(suites[0], title); 
     suite.pending = true; 
     suites.unshift(suite); 
     fn.call(suite); 
     suites.shift(); 
    }; 

    /** 
    * Exclusive suite. 
    */ 

    context.describe.only = function(title, fn) { 
     var suite = context.describe(title, fn); 
     mocha.grep(suite.fullTitle()); 
     return suite; 
    }; 

    /** 
    * Describe a specification or test-case 
    * with the given `title` and callback `fn` 
    * acting as a thunk. 
    */ 

    var it = context.it = context.specify = function(title, fn) { 
     var suite = suites[0]; 
     if (suite.pending) { 
     fn = null; 
     } 
     var test = new Test(title, fn); 
     test.file = file; 
     suite.addTest(test); 
     return test; 
    }; 

    /** 
    * Exclusive test-case. 
    */ 

    context.it.only = function(title, fn) { 
     var test = it(title, fn); 
     var reString = '^' + escapeRe(test.fullTitle()) + '$'; 
     mocha.grep(new RegExp(reString)); 
     return test; 
    }; 

    /** 
    * Pending test case. 
    */ 

    context.xit = context.xspecify = context.it.skip = function(title) { 
     context.it(title); 
    }; 

    /** 
    * Number of attempts to retry. 
    */ 
    context.it.retries = function(n) { 
     context.retries(n); 
    }; 

    context.proxyTest = function(title, fn) { 
     var suite = suites[0]; 
     if (suite.pending) { 
     fn = null; 
     } 
     var test = new ProxyTest(title, fn); 
     test.file = file; 
     suite.addTest(test); 
     return test; 
    }; 
    }); 
}; 

var Runnable = Mocha.Runnable; 
var inherits = require('util').inherits; 

function ProxyTest(title, fn) { 
    Runnable.call(this, title, null); 
    this.pending = !fn; 
    this.type = 'test'; 
    this.body = (fn || '').toString(); 

    this.fn = fn; 
} 

inherits(ProxyTest, Runnable); 

ProxyTest.prototype.run = function(done) { 
    var proxiedTestResult = this.fn(); 

    this.duration = proxiedTestResult.duration; 
    this.timedOut = this.timeout() > proxiedTestResult.timeout; 

    done(proxiedTestResult.result); 
}; 

ProxyTest.prototype.clone = function() { 
    var test = new ProxyTest(this.title, this.fn); 
    test.timeout(this.timeout()); 
    test.slow(this.slow()); 
    test.enableTimeouts(this.enableTimeouts()); 
    test.retries(this.retries()); 
    test.currentRetry(this.currentRetry()); 
    test.globals(this.globals()); 
    test.parent = this.parent; 
    test.file = this.file; 
    test.ctx = this.ctx; 
    return test; 
};