Mocha: programowo utworzymy i sfinalizujemy test

Question

Chcę, aby wyniki testów proxy działały w innym środowisku w czasie rzeczywistym.

Oto niektóre pseudo kod, który chcę zrobić Real:

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' 

Czy to zresztą możliwe ustawienie wyniku testu i czas bez „naprawdę” działa to? I uzyskać wszystkie wizualne wyniki mokka do terminala?

edit: to pytanie nie jest o tym, jak przekazać zmienne z wynikami badań tworzą proces podrzędny do głównego procesu. to już działa dla mnie.

Answer 1

Mam nadzieję, że poprawnie zrozumiałem wymagania. To, co zaimplementowałem, to spedytor wyników testu do mokki, która została zintegrowana z mokką.

Aby zintegrować z mokką, ta implementacja opisuje wyniki testów proxy przeprowadzonych w innych środowiskach.

Aby użyć tego interfejsu -u argumentem ma być przekazany do mocha gdy uruchomiony Mocha

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

Zauważ, że ./path/to/proxy-interface jest ścieżką, która wykorzystuje mokka w require wywołanie wymaga modułu interfejsu.

Interfejs proxy jest odpowiedzialny za udostępnienie funkcji proxyTest do kontekstu globalnego, takiego jak interfejs BDD mocha z it, wywołanie funkcji przekazanej, aby uzyskać wyniki testu i przekazanie wyników testu z zachowaniem liczby testów wykonanych wyświetlanych przez biegacz testowy. powyżej

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; 
}; 

Kod zastępuje realizację Runnable run mokka i uruchamia funkcję przekazany do uzyskania wyników badań i ustawia wymagane pola w interfejsie ProxyTest być zgodne z testami mocha.

Wykorzystanie

w badaniach użyć proxyTest globalny aby zarejestrować nowy test z mocha

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); 

Wyjście

Implicati ons

Wadą tego podejścia jest to, że interfejs zwyczaj musi być przekazane do mocha I, że nie można wykorzystać mokka BDD słownictwa jak describe. Drugą wadą mogą być wyeliminowane, jeśli „przedłużyć” (w tym przypadku: kopiowanie kodu) interfejs BDD 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; 
};