Be MEAN: Node.JS (AULA 9 pt.2/2) TDD

Author: nncl

nodejs/class-9/part-2/mongoose-tests/controller/pokemon-controller.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Model = require('./pokemon-schema');
+
+const CRUD = {
+    create: function (data, callback) {
+        const Suissamon = new Model(data);
+        Suissamon.save(callback);
+    },
+    retrieve: function (query, callback) {
+        Model.find(query, callback);
+    },
+    update: function (query, mod, options) {
+        options = options || {};
+        Model.update(query, mod, options, function (err, data) {
+            if (err) {
+                return console.log('ERRO: ', err);
+            }
+            return console.log('Alterou:', data);
+        });
+    },
+    delete: function (query) {
+        Model.remove(query, function (err, data) {
+            if (err) {
+                return console.log('ERRO: ', err);
+            }
+            return console.log('Deletou:', data);
+        });
+    },
+};
+
+module.exports = CRUD;

nodejs/class-9/part-2/mongoose-tests/controller/pokemon-controller.spec.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const expect = require('chai').expect;
+const controller = require('./pokemon-controller');
+
+describe('Pokemons` Controller', () => {
+    const pokemon = {
+        name: 'Jean',
+        description: 'Pokemonzudo S2',
+        type: 'Fire',
+        attack: 85,
+        defense: 85,
+        height: 1.80
+    };
+
+    after(done => {
+        let Model = require('./pokemon-schema');
+        Model.remove({});
+        done();
+    });
+
+    describe('create a new pokemon', () => {
+        it('expect a new pokemon had been created', done => {
+            controller.create(pokemon, (err, data)=> {
+                expect(err).to.not.exist;
+                expect(data._id).to.exist;
+                expect(data.name).to.be.eq('Jean');
+                expect(data.description).to.exist;
+                expect(data.type).to.be.eq('Fire');
+                expect(data.attack).to.exist;
+                expect(data.defense).to.exist;
+                expect(data.height).to.exist;
+                done();
+            });
+        });
+    });
+
+    describe('find all pokemon', () => {
+        it('expect to find all pokemon that had been created', done => {
+            controller.retrieve({}, (err, data)=> {
+                expect(err).to.not.exist;
+                expect(data).to.be.an('array');
+                expect(data).to.have.length.above(1);
+                done();
+            });
+        });
+    });
+});

nodejs/class-9/part-2/mongoose-tests/controller/pokemon-schema.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+mongoose.connect('mongodb://localhost/test');
+
+const pokemonSchema = new Schema({
+    name: String,
+    description: String,
+    type: String,
+    attack: Number,
+    defense: Number,
+    height: Number
+});
+
+module.exports = mongoose.model('Pokemon', pokemonSchema);

nodejs/class-9/part-2/mongoose-tests/getters/schema-getter.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+mongoose.connect('mongodb://localhost/test');
+
+let onlyUpperCase = (v) => v.toUpperCase();
+
+const CommentsSchema = new Schema({
+    title: String,
+    body: String,
+    date: Date
+});
+
+const BlogPostSchema = new Schema({
+    title: {type: String, get: onlyUpperCase},
+    body: String,
+    comments: [CommentsSchema]
+});
+
+module.exports = mongoose.model('BlogPost', BlogPostSchema);

nodejs/class-9/part-2/mongoose-tests/getters/schema-getter.spec.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const Blog = require('./schema-getter');
+const util = require('util');
+const expect = require('chai').expect;
+
+describe('BlogPostSchema', () => {
+    const title = 'nodejs power of c++ and v8';
+
+    before(done=> {
+        Blog.create({
+            title: title
+        }).then(blog=> {
+            util.log(blog);
+            done(); // async
+        });
+    });
+
+    after(done=> {
+        Blog.remove({title: title})
+            .then(deleted=> {
+                util.log(deleted.result);
+                done();
+            });
+    });
+
+    describe('testing getters', ()=> {
+        it('title shown as upperCased', ()=> {
+            Blog.findOne({title: title})
+                .then(blog => {
+                    util.log(blog.title);
+                    expect(blog.title).to.be.equal(title.toUpperCase());
+                });
+        });
+    });
+});

nodejs/class-9/part-2/mongoose-tests/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "validate",
+  "version": "1.0.0",
+  "description": "",
+  "main": "schema-validate-age.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "nncl",
+  "license": "ISC",
+  "dependencies": {
+    "mongoose": "^4.6.0"
+  },
+  "devDependencies": {
+    "chai": "^3.5.0"
+  }
+}

nodejs/class-9/part-2/mongoose-tests/setters/schema-setter-spec.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const User = require('./schema-setter');
+const expect = require('chai').expect;
+const _email = 'NNCL@LIVE.com';
+
+describe('User`s Schema test', () => {
+
+    describe('Setter to Uppercase Test', ()=>{
+        it('email saved as lowercase on database', ()=>{
+            const user = new User({email : _email});
+            expect(user.email).to.be.equal(_email.toLowerCase());
+        });
+    });
+
+});

nodejs/class-9/part-2/mongoose-tests/setters/schema-setter.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+let toLower = (v) => v.toLowerCase();
+
+const UserSchema = new Schema({
+    email: {
+        type: String
+        , set: toLower
+    }
+});
+
+module.exports = mongoose.model('Users', UserSchema);

nodejs/class-9/part-2/mongoose-tests/validate/schema-validate-age.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+mongoose.connect('mongodb://localhost/test');
+
+const greaterThanEighteen = age => age >= 18;
+
+const UserSchema = new Schema({
+    age: {
+        type: Number
+        , validate: {
+            validator: greaterThanEighteen
+            , message: 'Your age ({VALUE}) is not permitted'
+        }
+    }
+});
+
+module.exports = mongoose.model('user', UserSchema);

nodejs/class-9/part-2/mongoose-tests/validate/schema-validate-age.spec.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const User = require('./schema-validate-age');
+const expect = require('chai').expect;
+
+describe('User Validate', () => {
+
+    describe('Age validator to 18 or older', ()=>{
+        it('age only accept 18 or greater', ()=>{
+            let u = new User();
+            u.age = 24;
+
+            expect(u.validateSync()).to.be.undefined; // do not exist any error
+        });
+    });
+
+    describe('Age validator 17 or younger', ()=>{
+        it('age only accept 17 or younger', ()=>{
+            let u = new User();
+            u.age = 2;
+            const validate = u.validateSync();
+            expect(validate.message).to.be.eq('user validation failed');
+            expect(validate.errors).to.be.exist; // errors exist
+        });
+    });
+
+});