Comment pensez-vous vous moquez de MySQL (sans ORM) dans Node.js?

Il peut être une bonne idée de faire abstraction de votre base de données dans sa propre classe qui utilise mysql. Ensuite, vous pouvez passer de la catégorie de l'instance pour votre modèle de constructeurs au lieu de les charger à l'aide de require().

Avec cette configuration, vous pouvez passer à un simulacre d'instance db à vos modèles à l'intérieur de votre unité de fichiers de test.

Voici un petit exemple:

//db.js
var Db = function() {
   this.driver = require('mysql');
};
Db.prototype.query = function(sql, callback) {
   this.driver... callback (err, results);
}
module.exports = Db;

//someModel.js
var SomeModel = function (params) {
   this.db = params.db
}
SomeModel.prototype.getSomeTable (params) {
   var sql = ....
   this.db.query (sql, function ( err, res ) {...}
}
module.exports = SomeModel;

//in app.js
var db = new (require('./db.js'))();
var someModel = new SomeModel ({db:db});
var otherModel = new OtherModel ({db:db})

//in app.test.js
var db = {
   query: function (sql, callback) { ... callback ({...}) }
}
var someModel = new SomeModel ({db:db});

J'ai fini par partir avec @kgilpin de réponse et à la fin quelque chose comme ça pour tester Mysql dans une AWS Lambda:

const sinon = require('sinon');
const LambdaTester = require('lambda-tester');
const myLambdaHandler = require( '../../lambdas/myLambda' ).handler;
const mockMysql = sinon.mock(require('mysql'));
const chai = require('chai');
const expect = chai.expect;
describe('Database Write Requests', function() {
beforeEach(() => {
mockMysql.expects('createConnection').returns({
connect: () => {
console.log('Succesfully connected');
},
query: (query, vars, callback) => {
callback(null, succesfulDbInsert);
},
end: () => {
console.log('Connection ended');
}
});
});
after(() => {
mockMysql.restore();
});
describe( 'A call to write to the Database with correct schema', function() {
it( 'results in a write success', function() {
return LambdaTester(myLambdaHandler)
.event(anObject)
.expectResult((result) => {
expect(result).to.equal(succesfulDbInsert);
});
});
});
describe( 'database errors', function() {
before(() => {
mockMysql.expects('createConnection').returns({
connect: () => {
console.log('Succesfully connected');
},
query: (query, vars, callback) => {
callback('Database error!', null);
},
end: () => {
console.log('Connection ended');
}
});
});
after(() => {
mockMysql.restore();
});
it( 'results in a callback error response', function() {
return LambdaTester(myLambdaHandler)
.event(anObject)
.expectError((err) => {
expect(err.message).to.equal('Something went wrong');
});
});
});
});

Je ne voulais pas de réelles connexions de base de données j'ai donc manuellement moqué de tous les mysql réponses.

Ajouté par une autre fonction à .returns vous pouvez vous moquer de n'importe quelle méthode hors de createConnection.

Depuis l'utilisation du pilote mysql nécessite d'abord de créer une connexion, et de l'utilisation des api de retour de la connexion du contrôleur - vous besoin d'une approche en deux étapes.

Il y a deux façons de le faire.

cogner la createConnection, et le retour d'un écrasé de connexion

Lors de l'installation:

const sinon = require('sinon');
const mysql = require('mysql');
const {createConnection} = mysql;
let mockConnection;
sinon.stub(mysql, 'createConnection').callsFake((...args) => {
mockConnection = sinon.stub(createConnection.apply(mysql, args))
.expects('query').withArgs(.... )//program it how you like :)
return mockConnection;
})
const mockConnectionFactory = 
sinon.stub(mysql)
.expects('createConnection')

Au Cours De Démontage:

mysql.createConnection.restore();

Noter qu'ici, la query méthode est moqué sur une instance, et n'a aucune incidence sur le sous-jacent technique, de sorte que seules les createConnection doit être restauré.

cogner la .méthode de requête sur la connexion prototype

Cette technique est un peu plus délicat, car le mysql pilote n'expose pas officiellement, c'est la connexion pour l'importation. (eh bien, vous pouvez simplement importer juste le module de mise en œuvre de la connexion, mais il n'y a aucune garantie que le refactoring ne bougera pas de là).
Afin d'obtenir une référence au prototype - j'ai l'habitude de créer une connexion et traverse le constructeur de prototype de la chaîne:

J'ai l'habitude de le faire en une seule ligne, mais je vais le décomposer à des mesures et de l'expliquer ici:

Lors de l'installation:

const realConnection = mysql.createConnection({})
const mockTarget = realConnection.constructor.prototype;
//Then - brutally
consdt mock = sinon.mock(mockTarget).expect('query'....
//OR - as I prefer the surgical manner
sinon.stub(mockTarget, 'query').expect('query'....

Au Cours De Démontage

//brutal
mock.restore()
//- OR - surgical:
mockTarget.query.restore()

Noter que nous n'avons pas se moquer de la createConnection méthode ici. Tous les paramètres des validations arrivera encore (ce qui, je veux qu'ils se produisent. J'aspire à travailler avec un maximum d'authentiques pièces - donc se moquer de l'absolu minimum requis pour obtenir un test rapide). Toutefois - l' query est moqué sur le prototype, et qui doit être restauré.

Notez également que si vous travaillez chirurgicalement, le verify sera sur la moqué de méthode, et non sur la mockTarget.

Voici une bonne ressource à ce sujet: http://devdocs.io/sinon~6-stubs/