add test

- routes
- Mongo

Author: Nimrockdev

globalConfig.json

@@ -0,0 +1 @@
+{"mongoUri":"mongodb://127.0.0.1:51986/jest?","mongoDBName":"jest"}

jest-mongodb-config.js

@@ -0,0 +1,12 @@
+module.exports = {
+    mongodbMemoryServerOptions: {
+      instance: {
+        dbName: 'jest'
+      },
+      binary: {
+        version: '4.0.2', // Version of MongoDB
+        skipMD5: true
+      },
+      autoStart: false
+    }
+  };

jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+    testEnvironment: 'node',
+    timers: 'fake',
+    preset: '@shelf/jest-mongodb'
+  }

package-lock.json

@@ -5,7 +5,8 @@
     "main": "server/server.js",
     "scripts": {
         "dev": "nodemon server/server.js",
-        "start": "node server/server.js"
+        "start": "node server/server.js",
+        "test": "jest --forceExit"
     },
     "repository": {
         "type": "git",
@@ -32,7 +33,16 @@
         "underscore": "^1.11.0"
     },
     "devDependencies": {
+        "@shelf/jest-mongodb": "^1.2.4",
         "dotenv": "^8.2.0",
-        "nodemon": "^2.0.4"
+        "jest": "^26.6.3",
+        "nodemon": "^2.0.4",
+        "supertest": "^6.1.3"
+    },
+    "jest": {
+        "testEnvironment": "node",
+        "coveragePathIgnorePatterns": [
+            "/node_modules/"
+        ]
     }
 }

package.json

@@ -4,6 +4,7 @@ const config = require('../config/config');
 let checkToken = (req, res, next) => {
 
     let token = req.get('token');
+
     jwt.verify(token, config.dev, (err, decoded) => {
         if (err) {
             return res.status(401).json({

server/middlewares/authentication.js

@@ -4,7 +4,7 @@ let app = express();
 
 app.use((req, res, next)=>{
     app.locals.counter = (++app.locals.counter || 1);
-    console.log(`Visitor counter ${app.locals.counter}`);
+    //console.log(`Visitor counter ${app.locals.counter}`);
     next();
 });
 

server/middlewares/counter.js

@@ -15,6 +15,7 @@ app.get('/category', (req, res) => {
                     err
                 })
             };
+            console.log(categories)
             res.status(200).json({
                 ok: true,
                 categories

server/routes/category.js

@@ -40,11 +40,11 @@ app.post('/login', (req, res) => {
 
         }
 
-        console.log(config.TOKEN_EXPIRATION);
+        // console.log(config.TOKEN_EXPIRATION);
         let token = jwt.sign({
             userDB
         }, config.dev, { expiresIn: config.TOKEN_EXPIRATION });
-        console.log(token);
+        // console.log(token);
 
         res.status(200).json({
             oK: true,

server/routes/login.js

@@ -115,7 +115,7 @@ app.get('/products/searchCategoryDesc/:word', (req, res) => {
         .populate('category')
         .exec((err, products) => {
             if (err) {
-                return res.status(500).json({
+                return res.status(404).json({
                     ok: false,
                     err
                 })

server/routes/products.js

@@ -39,7 +39,9 @@ mongoose
 
 app.listen(config.port, () => {
 
-    console.log(`API Server Listening on http://localhost:${config.port}`);
-    console.log(`Environment: ${config.dev}`);
+    // console.log(`API Server Listening on http://localhost:${config.port}`);
+    // console.log(`Environment: ${config.dev}`);
 
-});
+});
+
+module.exports = app;

server/server.js

@@ -0,0 +1,163 @@
+const config = require('../server/config/config');
+const request = require('supertest');
+const app = require('../server/server');
+const mongoose = require('mongoose');
+const categoryModel = require('../server/models/category');
+
+var id;
+var desc;
+
+let token;
+describe('Devarc Test... ', () => {
+
+    beforeAll(async (done) => {
+        await mongoose.connect(config.urlDB, { useNewUrlParser: true, useCreateIndex: true  }, (err) => {
+            if (err) {
+                console.error(err);
+                process.exit(1);
+            }
+            done();
+        });
+
+    });
+
+
+    beforeAll((done) => {
+        request(app)
+          .post('/login')
+          .send({
+            email: '[email protected]',
+            password: '',
+          })
+          .end((err, response) => {
+            token = response.body.token; // save the token!
+            done();
+          });
+
+      });   
+
+
+    test('should return status 200 and text message on the initial page', async () => {
+        const res = await request(app).get('/');
+        expect(res.statusCode).toEqual(200);
+        expect(res.text).toBe('Devarc is online');
+    });
+    
+    test('should return status 200 and return products', async () => {
+        const res = await request(app).get('/products/');
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.numProductos).toBeGreaterThan(0);
+    });
+
+    test('should return status 200 and return product 600ec6adddd7fc0015d10a6e', async () => {
+        const res = await request(app).get('/products/searchByID/600ec6adddd7fc0015d10a6e');
+        expect(res.statusCode).toEqual(200);
+        expect(res.body.numProductos).toBeGreaterThan(0);
+    });
+
+    test('should return status 400 for not found product', async () => {
+        const res = await request(app).get('/products/searchByID/AAA');
+        expect(res.statusCode).toEqual(400);
+    }); 
+    
+    test('should return status 401 Invalid token', async () => {
+        const res = await request(app).get('/users');
+        expect(res.statusCode).toEqual(401);
+    });     
+
+    test('should return status 200 Invalid token', async () => {
+        return request(app)
+        .get('/users')
+        .set('token', token)
+        .then((response) => {
+          expect(response.statusCode).toBe(200);
+          expect(response.type).toBe('application/json');
+        });
+    });     
+
+
+    test('should return users', async () => {
+        return request(app)
+        .get('/users')
+        .set('token', token)
+        .then((response) => {          
+          expect(response.body.Users).toBeGreaterThan(0);
+          expect(response.type).toBe('application/json');
+        });
+    }); 
+
+    test('should return Lenovo Mouse a1 product test', async () => {
+        return request(app)
+        .get('/products/searchByID/5f7701c99449505900f23333')
+        .set('token', token)
+        .then((response) => {          
+          expect(response.body.numProductos).toBe(1)
+          expect(response.type).toBe('application/json');
+
+          let product = response.body.products[0];
+          expect(product.avaiable).toEqual(true);
+
+        });
+    }); 
+
+    
+    // test('should return id category of Test8', async () => {
+    //     var data = { 'description': 'Test8' };
+        
+    //     request(app)
+    //     .post('/category')
+    //     .send(data)
+    //     .then((response) => {   
+    //         id = response.body.category._id;
+    //         expect(response.statusCode).toBe(201);
+    //         expect(response.body.category._id).toBe(id);
+    //         expect(response.body.category._id).not.toBeNull();
+    //     });
+        
+    
+    // }); 
+
+    // it('should remove Category Test8 Category and return null successfully', async () => {
+        
+    //     await categoryModel.findByIdAndRemove({description : 'Test8'})
+    //     const cateDeleted = await categoryModel.findById({_id : id})                   
+    //     expect(cateDeleted).toBeNull() ;
+
+    // });
+
+    test('should return description pañales of id 600587e86bd460001551ce6b', async () => {
+        let descCategory;
+        //Category.find({})
+        categoryModel.find({ _id : '600587e86bd460001551ce6b'})            
+                .exec((err, category) => {
+                    if (err) {  expect(err).toBe(err); };
+                    descCategory = category[0].description;
+                    expect(descCategory).toEqual('pañales');      
+                });
+  
+    }); 
+
+    it('should create & save Category Test 2 successfully', async () => {
+        var data = { 'description': 'Test 2' };
+        const validCategory = new categoryModel(data);
+        const savedCategory = await validCategory.save();
+        id = savedCategory._id;
+        expect(savedCategory._id).toBeDefined();
+        expect(savedCategory.description).toBe(validCategory.description);
+    });
+
+
+    it('should remove Category Test 2 Category and return null successfully', async () => {
+        
+        await categoryModel.findByIdAndRemove({_id : id})
+        const cateDeleted = await categoryModel.findById({_id : id})                   
+        expect(cateDeleted).toBeNull() ;
+
+    });
+
+    afterAll(() => {   
+        mongoose.connection.close();
+    });
+
+
+})