Moqueur/stubbing Mangouste modèle méthode save

Les bases

Dans les tests unitaires, on ne doit pas frapper la DB. J'ai pu penser une seule exception: le fait de frapper une mémoire DB, mais même qui se trouve déjà dans le domaine des tests d'intégration que vous n'aurez besoin que l'état sauvegardé dans la mémoire de processus complexes (et donc pas vraiment unités de fonctionnalité). Donc, oui pas de DB.

Ce que vous voulez de test pour les tests unitaires, c'est que vos affaires de la logique de résultats à corriger les appels de l'API à l'interface entre votre application et la base de données. Vous pouvez et devriez probablement supposer que la DB API/pilote développeurs ont fait un bon travail de test que tout en dessous de l'API se comporte comme prévu. Toutefois, vous aussi vous voulez couvrir dans vos tests comment une logique d'entreprise réagit aux différentes API valide les résultats tels que la réussite de sauve, de défaillances dues à la cohérence des données, des défaillances en raison de problèmes de connexion, etc.

Cela signifie que ce que vous avez besoin et veulent se moquer de tout ce qui est en dessous du pilote de base de données de l'interface. Vous, cependant, besoin de modèle de comportement de sorte que votre logique métier peut être testé pour tous les résultats de la DB appels.

Plus facile à dire qu'à faire car cela signifie que vous devez avoir accès à l'API via la technologie que vous utilisez et vous avez besoin de savoir l'API.

La réalité de la mangouste

Coller à l'essentiel, nous voulons moquer des appels effectués par le sous-jacent 'pilote' qui mangouste utilise. En supposant qu'il est nœud-mongodb-natif nous avons besoin pour se moquer de ces appels. Comprendre l'interaction entre la mangouste et le pilote natif n'est pas facile, mais il s'agit généralement vers le bas pour les méthodes de mongoose.Collection parce que ce dernier s'étend mongoldb.Collection et ne pas réimplémenter des méthodes comme insert. Si nous sommes en mesure de contrôler le comportement de insert dans ce cas particulier, alors nous savons que nous moqué de la DB accès au niveau de l'API. Vous pouvez remonter à la source de ces deux projets, qui Collection.insert est vraiment le pilote natif de la méthode.

Pour votre exemple, j'ai créé un public dépôt Git avec un paquet complet, mais je vais poster tous les éléments ici dans la réponse.

La solution

Personnellement, je trouve le "recommandé" à la façon de travailler avec la mangouste tout à fait inutilisable: les modèles sont généralement créés dans les modules où l'schémas sont définis, mais ils ont déjà besoin d'une connexion. Pour les fins d'avoir plusieurs connexions de parler complètement différentes bases de données mongodb dans le même projet et pour des fins de test, ce qui rend la vie vraiment difficile. En fait, dès que les préoccupations sont entièrement séparés de la mangouste, au moins pour moi, devient presque inutilisable.

Donc, la première chose que j'ai créer est la description du package de fichier, un module avec un schéma et un générique de "modèle générateur":

paquet.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
};

Un tel générateur de modèle a ses inconvénients: il y a des éléments qui peuvent avoir besoin d'être attaché au modèle, et il serait judicieux de les placer dans le même module, où le schéma est créé. Donc, trouver un moyen générique pour ajouter ces est un peu délicat. Par exemple, un module pourrait exporter de l'après-actions à exécuter automatiquement lorsqu'un modèle est généré pour une connexion donnée, etc. (le piratage).

Maintenant, nous allons simuler l'API. Je vais rester simple et ne se moquer de ce dont j'ai besoin pour les tests en question. Il est essentiel que je voudrais pour se moquer de l'API en général, et non les méthodes de différentes instances. Ce dernier peut être utile dans certains cas, ou lorsque rien ne vient en aide, mais j'aurais besoin d'avoir accès à des objets créés à l'intérieur de ma logique métier (sauf injecté ou fournis par le biais de certains modèle de fabrique), et cela signifie la modification de la source principale. Dans le même temps, se moquant de l'API dans un endroit a un inconvénient: c'est une solution générique, ce qui serait probablement une mise en œuvre réussie de l'exécution. Pour tester les cas d'erreur, les moqueries dans les cas les tests eux-mêmes pourraient être requis, mais dans une logique d'entreprise, vous pourriez ne pas avoir un accès direct à l'instance, par exemple, de post créé à l'intérieur profond.

Donc, nous allons jeter un coup d'oeil au cas général de se moquer de succès de l'appel API:

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;

En général, aussi longtemps que les modèles sont créés après la modification de la mangouste, il est envisageable que le ci-dessus se moque sont fait par test de base pour simuler les comportements. Assurez-vous de revenir à l'origine du comportement, cependant, avant chaque test!

Enfin, c'est la façon dont nos tests pour tous les possible de sauvegarder les données des opérations pourrait ressembler. Attention, ce ne sont pas spécifiques à notre Post modèle et pourrait être fait pour tous les autres modèles avec exactement la même maquette en place.

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

Il est essentiel de noter que nous sommes encore en test le très faible niveau des fonctionnalités, mais nous pouvons utiliser cette même approche pour tester toute la logique d'entreprise qui utilise Post.create ou post.save en interne.

La finale très peu, nous allons exécuter les tests:

~/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)

Je dois dire, ce n'est pas drôle de le faire de cette façon. Mais de cette façon c'est vraiment du pur tests unitaires de la logique métier sans en mémoire ou de la vraie et de la DBs assez générique.