Chai 'expect' wird nicht innerhalb eines Callbacks ausgeführt

Question

Ich schreibe Unit-Tests für meine Funktion, die Informationen von einer REST-API abruft. Ich verwende ramdaFuture Typ (source).
Der folgende Test funktioniert seltsam:

it('should return Maybe of Nothing', done => { 

    let response = { 
     status: 200, 
     json:() => { 
     return { 
      results: [] 
     } 
     } 
    } 

    let fakeFetch = { 
     fetch:() => { 
     return new Promise((resolve, reject) => { 
      resolve(response) 
     }) 
     } 
    } 

    //     String -> Future Error Maybe 
    let result = Utils.fetchGiantBomb(faker.random.word(), fakeFetch.fetch); 

    result.fork(err => { 
     assert.fail(err, 'expected to return Maybe of Nothing'); 
     done(); 
    }, data => { 
     expect(Maybe.isJust(data)).to.be.true; 
     done(); 
    }) 

    }) 

dataMaybe.Nothing vom Typ sein sollte. Wenn ich Maybe.isNothing erwarte den Test besteht, aber ich möchte sehen, was passiert, wenn der Test fehlschlägt, so setze ich es auf Maybe.isJust, die falsch zurückgeben. Nachdem ich dies eine Weile beobachtet habe, habe ich bemerkt, dass, wenn die expect fehlgeschlagen ist, es auf die Fehlerbehandlung (err Callback) hochspringt, die dann nur die Ausführung einer Assertion stoppen (was zu einem 2000ms Timeout führt).

In den Future Quellen sah ich, dass, wenn der Erfolg Rückruf fehlschlägt, führt es den Fehler Callback. Wie kann ich diesen Test abschließen, damit angezeigt wird, dass die Daten nicht den Erwartungen entsprechen?

Answer 1

Ich denke, das Problem ist, dass, wenn Ihr REST-Aufruf fehlschlägt, done() nie aufgerufen wird.

Nicht sicher, ob expect hat eine .catch Methode, wenn es fehlschlägt, aber man kann versuchen

.catch(done); 

am Ende Ihrer erwarten Funktion hinzuzufügen.

Hoffe, dass hilft.

Answer 2

future.fork(errorHandler, successHandler) Aufruf wird dafür sorgen, dass alle derzeit in den successHandler geworfen Ausnahmen werden die errorHandler breiten sie durch.

Ein Weg, um dies (wenn auch vielleicht nicht ideal, da es nicht dokumentiert ist) ist future._fork(errorHandler, successHandler) zu nennen, statt future.fork, wo in den successHandler geworfen Fehler werden nicht erfaßt werden.

Alternativ unterstützt eine Reihe von Test-Frameworks einen Fehler an den done Rückruf vorbei wie:

result.fork(err => { 
    done('Expected to return Maybe of Nothing: ' + err); 
}, data => { 
    expect(Maybe.isJust(data)).to.be.true; 
    done(); 
}) 

Answer 3

denke ich Ramda soll nicht die Ausnahme dort fängt. Aber ich weiß nicht, was sie versuchen zu tun.

Es sieht aus wie Sie Mocha verwenden. Es ist vielleicht eine gute Idee, deine Zukunft zuerst in Versprechen zu verwandeln und dann die Verheißung zu beachten. dh:

const futureToPromise = future => { 
    return new Promise((resolve, reject) => future.fork(reject, resolve)) 
} 

it('should return Maybe of Nothing',() => { 

    let response = { 
    status: 200, 
    json:() => { 
     return { 
     results: [] 
     } 
    } 
    } 

    let fakeFetch = { 
    fetch:() => { 
     return new Promise((resolve, reject) => { 
     resolve(response) 
     }) 
    } 
    } 

    // String -> Future Error Maybe 
    let result = Utils.fetchGiantBomb(faker.random.word(), fakeFetch.fetch); 
    // return it because Mocha can handle this 
    return futureToPromise(result).then(data => { 
    expect(Maybe.isJust(data)).to.be.true; 
    },() => { 
    // fail 
    assert.fail(err, 'expected to return Maybe of Nothing'); 
    }) 
})