test avec plusieurs promesses thens utilisant testdoublejs

Question

J'utilise testdouble pour stubbing appels dans mon projet Node.js. Cette fonction particulière encapsule une promesse et a plusieurs appels then dans la fonction elle-même.

function getUser (rethink, username) { 
    return new Promise((resolve, reject) => { 
    let r = database.connect(); 
    r.then(conn => database.table(tablename).filter({username})) 
    .then(data => resolve(data)) 
    .error(err => reject(err)); 
}); 
} 

Je suis désireux de déterminer si le bien sont gérées resolve et reject en fonction des conditions d'erreur. Supposons qu'il y ait une certaine logique personnalisée que j'ai besoin de valider.

Pour mon test

import getUser from './user'; 
import td from 'testdouble'; 
test(t => { 
    const db = td.object(); 
    const connect = td.function(); 
    td.when(connect('options')).thenResolve(); 
    const result = getUser(db, 'testuser'); 
    t.verify(result); 
} 

La question est que le résultat de connexion doit être une promesse, donc je resolve puis avec une valeur qui doit être une autre promesse qui résout ou rejette.

La ligne, il est relatif à est le résultat de database.connect() n'est pas une promesse.

TypeError: Cannot read property 'then' of undefined 

Quelqu'un at-il réussi à bloquer ce type d'appel avec Test Double? à double test

Answer 1

donc compris la résolution. Il y a quelques choses à noter dans la solution et que nous avons rencontrées. En bref, la résolution a fini par être ce ...

td.when(database.connect()).thenResolve({then: (resolve) => resolve('ok')}); 

Cela résout un thenable qui est retourné lors d'un double test voit base de données se connecter. Ensuite, les appels suivants peuvent également être ajoutés.

Il y a aussi une partie de noter que si vous envoyez un objet à database.connect() vous devez être conscient qu'il est en train de faire === l'égalité de vérification et vous aurez besoin d'avoir une référence à cet objet pour lui d'utiliser correctement td.when.

Answer 2

fournit des talons pour les tests unitaires. Et dans votre cas, 'db' est l'objet dont nous avons besoin pour nous moquer. Création du db se moquant par

td.object(Database) // Database is the class or constructor of your db

sera le bon choix, mais simplement se moquer de ces méthodes dont vous avez besoin dans ce cas, je ne prendrais pas de cette façon.

est ici le module testé, 'some.js':

function getUser (database, username) { 
    return new Promise((resolve, reject) => { 
    let r = database.connect(); 
    r.then(conn => database.table('table').filter({username:username})) 
     .then(data => resolve(data)) 
     .catch(err => reject(err)); 
    }); 
} 

module.exports = getUser; 

Et le fichier de test, en utilisant mocha et chai.expect, qui pourrait aussi être tout autre module de test unitaire ici:

let td = require('testdouble'); 
let expect = require('chai').expect; 

const getUser = require('./some'); 

describe('some.js',()=>{ 
    it('getUser',()=>{ 
    const db = {}; 
    const name = 'name'; 
    db.connect = td.function(); 
    db.table = td.function('table'); 
    db.filter = td.function('filter'); 
    td.when(db.connect()).thenResolve(db); 
    td.when(db.table('table')).thenReturn(db); 
    td.when(db.filter({username: name})).thenResolve('some user data'); 
    return getUser(db, name) 
     .then(user=>{ 
     expect(user).to.equal('some user data') 
     }) 
     .catch(e=>assert(e)) 
    }) 
}) 

Alors s'il vous plaît laissez-moi savoir si l'un de ceux-ci vous confondre.