Mocking/stubbing Mongoose Modell save-Methode

Die Grundlagen

In unit-Tests sollte man nicht auf die DB. Ich denken konnte, mit einer Ausnahme: durch eine in-memory-DB, aber auch das liegt bereits im Bereich integration-Prüfung, wie Sie bräuchte nur den Zustand, gespeichert in der Speicher für komplexe Prozesse (und damit nicht wirklich Funktionseinheiten). Also, ja keine eigentliche DB.

Was Sie testen möchten, in unit-tests ist, dass Sie Ihre business-Logik Ergebnisse in den korrekten API-Aufrufe an der Schnittstelle zwischen der Anwendung und der DB. Sie kann und sollte wohl davon ausgehen, dass die DB-API/Treiber Entwickler haben einen guten job gemacht zu testen, dass alles unterhalb der API verhält sich wie erwartet. Allerdings sollten Sie auch das cover in den tests, wie Sie Ihre business-Logik reagiert auf unterschiedliche gültigen API-Ergebnisse, wie erfolgreich spart, Ausfälle durch, um die Konsistenz der Daten, Fehler aufgrund von Verbindungsproblemen etc.

Dies bedeutet, dass das, was Sie brauchen und wollen, zu verhöhnen, ist alles was unterhalb der DB-Treiber-Schnittstelle. Sie müssten jedoch auf das Modell, dass das Verhalten, so dass Sie Ihre business Logik kann getestet werden, für alle Ergebnisse der DB-Aufrufe.

Leichter gesagt als getan sein, weil das bedeutet, dass Sie benötigen, um Zugriff auf die API über die Technologie, die Sie verwenden, und Sie müssen wissen, die API.

Die Realität des Mungos

Festhalten an den Grundlagen, die wir wollen, zu verspotten, die Anrufe, die durchgeführt, indem die zugrunde liegenden 'Treiber', dass mongoose verwendet. Vorausgesetzt, es ist Knoten-mongodb-native wir müssen mock aus dieser Aufrufe. Verstehen das zusammenspiel zwischen Mungo und der native Treiber ist nicht leicht, aber es kommt in der Regel nach unten, um die Methoden in mongoose.Collection weil letztere erstreckt sich mongoldb.Collection und nicht implementieren Sie Methoden, wie Sie insert. Wenn wir in der Lage zu kontrollieren das Verhalten insert in diesem speziellen Fall, dann wissen wir, dass wir verspottet werden aus dem DB-Zugriff auf API-Ebene. Sie können die trace es in der Quelle der beiden Projekte, dass Collection.insert ist wirklich die native-Treiber-Methode.

Für Ihre speziellen Beispiel, das ich erstellt ein öffentliches Git-repository mit einem vollständigen Paket, aber ich werde alle die Elemente, die hier in die Antwort.

Die Lösung

Persönlich finde ich die "empfohlene" Weg der Zusammenarbeit mit mongoose ziemlich unbrauchbar: die Modelle werden in der Regel erstellt die Module, wo die entsprechenden schemas sind definiert, doch Sie müssen bereits eine Verbindung. Für die Zwecke, die mehrere verbindungen zu sprechen, die zu ganz verschiedenen mongodb-Datenbanken im selben Projekt und für Testzwecke das macht das Leben wirklich schwer. In der Tat, sobald Belange vollständig getrennt Mungo, zumindest für mich, wird fast unbrauchbar.

Also das erste, was ich Schaffe, ist die Paket-Beschreibung Datei, ein Modul mit einem schema und einem generischen Modell "generator":

Paket.json

{
  "name": "xxx",
  "version": "0.1.0",
  "private": true,
  "main": "./src",
  "scripts": {
    "test" : "mocha --recursive"
  },
  "dependencies": {
    "mongoose": "*"
  },
  "devDependencies": {
    "mocha": "*",
    "chai": "*"
  }
}

src/post.js

var mongoose = require("mongoose");

var PostSchema = new mongoose.Schema({
    title: { type: String },
    postDate: { type: Date, default: Date.now }
}, {
    timestamps: true
});

module.exports = PostSchema;

src/index.js

var model = function(conn, schema, name) {
    var res = conn.models[name];
    return res || conn.model.bind(conn)(name, schema);
};

module.exports = {
    PostSchema: require("./post"),
    model: model
};

Solches Modell generator hat seine Nachteile: es gibt Elemente, die können, müssen befestigt werden, um das Modell und würde es Sinn machen, legen Sie Sie in den gleichen Modul, in dem das schema erstellt wird. So finden sich in eine Allgemeine Möglichkeit, diejenigen hinzuzufügen, die ist ein bisschen tricky. Zum Beispiel könnte ein Modul export-post-Aktionen werden automatisch ausgeführt, wenn ein Modell erzeugt wird, die für eine gegebene Verbindung etc. (hacking).

Lassen Sie uns nun zu verhöhnen die API. Ich werde es einfach halten und nur Schein, was muss ich für die tests in Frage. Es ist wichtig, dass ich möchte, zu verhöhnen, als sich die API im Allgemeinen, nicht einzelne Methoden der einzelnen Instanzen. Letzteres könnte in einigen Fällen hilfreich sein, oder wenn sonst nichts hilft, aber ich brauchen würde, um Zugriff auf Objekte innerhalb meiner business-Logik (es sei denn, injiziert oder über einige factory-Muster), und dies würde bedeuten, ändern die wichtigste Quelle. Zur gleichen Zeit, machten Sie sich über die API in one place hat einen Nachteil: es ist eine generische Lösung, die wahrscheinlich erfolgreiche Ausführung. Für die Prüfung Fehler-Fällen, die Verspottung in den Fällen, in den tests selbst benötigt werden könnten, dann aber in Ihrem business-Logik, die Sie möglicherweise nicht haben einen direkten Zugang zu der Instanz von z.B. post geschaffen, die tief im inneren.

So, lassen Sie uns einen Blick auf den Allgemeinen Fall der Spott erfolgreiche API-Aufruf:

test/mock.js

var mongoose = require("mongoose");

//this method is propagated from node-mongodb-native
mongoose.Collection.prototype.insert = function(docs, options, callback) {
    //this is what the API would do if the save succeeds!
    callback(null, docs);
};

module.exports = mongoose;

In der Regel, so lange wie Modelle erstellt werden nach ändern Mungo, ist es denkbar, dass die oben verspottet werden pro test-Grundlage, um Verhalten zu simulieren. Stellen Sie sicher, um wieder auf das ursprüngliche Verhalten, jedoch vor jedem test!

Schließlich ist dies, wie unsere tests für alle möglichen Daten speichern Operationen Aussehen könnte. Achten, diese sind nicht spezifisch für unsere Post Modell und könnte getan werden, für alle anderen Modelle mit exakt der gleichen mock im Ort.

test/test_model.js

//now we have mongoose with the mocked API
//but it is essential that our models are created AFTER 
//the API was mocked, not in the main source!
var mongoose = require("./mock"),
    assert = require("assert");

var underTest = require("../src");

describe("Post", function() {
    var Post;

    beforeEach(function(done) {
        var conn = mongoose.createConnection();
        Post = underTest.model(conn, underTest.PostSchema, "Post");
        done();
    });

    it("given valid data post.save returns saved document", function(done) {
        var post = new Post({
            title: 'My test post',
            postDate: Date.now()
        });
        post.save(function(err, doc) {
            assert.deepEqual(doc, post);
            done(err);
        });
    });

    it("given valid data Post.create returns saved documents", function(done) {
        var post = new Post({
            title: 'My test post',
            postDate: 876543
        });
        var posts = [ post ];
        Post.create(posts, function(err, docs) {
            try {
                assert.equal(1, docs.length);
                var doc = docs[0];
                assert.equal(post.title, doc.title);
                assert.equal(post.date, doc.date);
                assert.ok(doc._id);
                assert.ok(doc.createdAt);
                assert.ok(doc.updatedAt);
            } catch (ex) {
                err = ex;
            }
            done(err);
        });
    });

    it("Post.create filters out invalid data", function(done) {
        var post = new Post({
            foo: 'Some foo string',
            postDate: 876543
        });
        var posts = [ post ];
        Post.create(posts, function(err, docs) {
            try {
                assert.equal(1, docs.length);
                var doc = docs[0];
                assert.equal(undefined, doc.title);
                assert.equal(undefined, doc.foo);
                assert.equal(post.date, doc.date);
                assert.ok(doc._id);
                assert.ok(doc.createdAt);
                assert.ok(doc.updatedAt);
            } catch (ex) {
                err = ex;
            }
            done(err);
        });
    });

});

Ist es wichtig zu beachten, dass wir noch in der Testphase, die sehr low-level-Funktionalität, aber wir können mit dieser Ansatz für die Prüfung jeglicher business-Logik, die verwendet Post.create oder post.save intern.

Das Letzte bit, lassen Sie die tests ausführen:

~/source/web/xxx $ npm test

> xxx@0.1.0 test /Users/osklyar/source/web/xxx
> mocha --recursive

Post
  ✓ given valid data post.save returns saved document
  ✓ given valid data Post.create returns saved documents
  ✓ Post.create filters out invalid data

3 passing (52ms)

Ich muss sagen, dies ist kein Spaß, es zu tun auf diese Weise. Aber so ist es wirklich Reine unit-Tests der business-Logik ohne in-memory-oder real-DBs und ziemlich generisch.