Wie verspotten Sie MySQL (ohne ORM) in Node.js?

Ich bin mit Node.js mit felixge ist node-mysql client. Ich bin nicht mit einem ORM.

Teste ich das Gelübde abgelegt hat und in der Lage sein wollen, zu verspotten, meine Datenbank, eventuell mit Sinon. Da ich nicht wirklich ein DAL per se (abgesehen von node-mysql), ich bin nicht wirklich sicher, wie gehen über diese. Meine Modelle sind meist einfache CRUD mit einer Menge von Getter.

Irgendwelche Ideen auf, wie dies zu erreichen?

InformationsquelleAutor der Frage Josh Smith | 2011-12-05

28

Mit sinon, können Sie ein mock-oder stub-um ein ganzes Modul. Zum Beispiel, nehmen wir an, die mysql - Modul hat eine Funktion query:
```
var mock;

mock = sinon.mock(require('mysql'))
mock.expects('query').with(queryString, queryParams).yields(null, rows);
```
queryStringqueryParams sind der input, den Sie erwarten. rows ist die Ausgabe, die Sie erwarten.

Wenn Ihre Klasse unter test jetzt mysql benötigen, und fordert die query Methode hat, wird abgefangen und überprüft durch sinon.

In der test-Erwartung Abschnitt sollten Sie haben:
```
mock.verify()
```
und in Ihrem teardown, die Sie wiederherstellen sollte mysql wieder zu normaler Funktionalität:
```
mock.restore()
```
InformationsquelleAutor der Antwort kgilpin

Kann es eine gute Idee zu abstrahieren Ihre Datenbank in eigene Klasse, die mysql einsetzt. Dann kann passieren, dass die Klasse' instance, um dem Modell die Konstruktoren statt, Sie laden es mithilfe von require().

Mit dieser Einrichtung können Sie ein mock-db-instance für Ihre Modelle, die innerhalb Ihrer unit-test-Dateien.

Hier ist ein kleines Beispiel:

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

InformationsquelleAutor der Antwort Bijou Trouvaille

5

Ich bin nicht ganz vertraut mit node.js aber in einem traditionellen Programmierung von Sinn, zu erreichen, testen wie, dass, würden Sie brauchen, zu abstrahieren von der Daten-access-Methode. Könnte man nicht erstellen, die eine DAL-Klasse wie:
```
var DataContainer = function () {
}

DataContainer.prototype.getAllBooks = function() {
    //call mysql api select methods and return results...
}
```
Nun im Rahmen eines Tests, patch-deine getAllBooks Klasse während der Initialisierung wie:
```
DataContainer.prototype.getAllBooks = function() {
    //Here is where you'd return your mock data in whatever format is expected.
    return [];
}
```
Wenn der test-code aufgerufen wird, getAllBooks ersetzt werden durch eine version, die gibt mock-Daten anstelle der eigentlich Aufruf von mysql. Wieder, dies ist eine grobe übersicht, da bin ich nicht ganz vertraut mit node.js

InformationsquelleAutor der Antwort doogle
3

Können Sie mock aus externen Abhängigkeiten mit horaa

Und ich glaube auch felixge Knoten Sandbox-Modul kann auch etwas ähnliches tun.

Also mit kgilpin gleichen Kontext, in horaa würde es so Aussehen:
```
var mock = horaa('mysql');
mock.hijack('query', function(queryString, queryParam) {
    //do your fake db query (e.g., return fake expected data)
});

//SUT calls and asserts

mock.restore('query');
```
InformationsquelleAutor der Antwort dule

Landete ich mit @kgilpin Antwort und am Ende mit etwas wie dieses zu testen, Mysql in einer 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');
       });
   });
 });
});

Ich wollte nicht alle aktuellen Datenbank-verbindungen, so dass ich manuell verspottet alle mysql-Reaktionen.

Durch eine weitere Funktion .returns können Sie mock-jede Methode, die aus der createConnection.

InformationsquelleAutor der Antwort cameck

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.