not-node 5.1.44 → 6.0.0

package/test/init/bodyparser.js

@@ -1,44 +1,42 @@
-const InitBodyparser = require('../../src/init/bodyparser');
-const mock = require('mock-require');
+const InitBodyparser = require("../../src/init/lib/bodyparser");
+const mock = require("mock-require");
 
-module.exports = ({
-  expect
-}) => {
-  describe('BodyParser', () => {
-    describe('run', () => {
-      it('run, middleware returned and set', async () => {
-        let useCalled = false;
-        let middlewareGeneratorCalled = 0;
-        mock('body-parser', {
-          json(param){
-            expect(typeof param).to.be.equal('object');
-            middlewareGeneratorCalled++;
-            return ()=>{};
-          },
-          urlencoded(param){
-            expect(typeof param).to.be.equal('object');
-            middlewareGeneratorCalled++;
-            return ()=>{};
-          },
+module.exports = ({ expect }) => {
+    describe("BodyParser", () => {
+        describe("run", () => {
+            it("run, middleware returned and set", async () => {
+                let useCalled = false;
+                let middlewareGeneratorCalled = 0;
+                mock("body-parser", {
+                    json(param) {
+                        expect(typeof param).to.be.equal("object");
+                        middlewareGeneratorCalled++;
+                        return () => {};
+                    },
+                    urlencoded(param) {
+                        expect(typeof param).to.be.equal("object");
+                        middlewareGeneratorCalled++;
+                        return () => {};
+                    },
+                });
+                const master = {
+                    getServer() {
+                        return {
+                            use(func) {
+                                expect(typeof func).to.be.equal("function");
+                                useCalled = true;
+                            },
+                        };
+                    },
+                };
+                await new InitBodyparser().run({ master });
+                expect(useCalled).to.be.true;
+                expect(middlewareGeneratorCalled).to.be.equal(2);
+            });
         });
-        const master = {
-          getServer() {
-            return {
-              use(func) {
-                expect(typeof func).to.be.equal('function');
-                useCalled = true;
-              }
-            };
-          }
-        };
-        await (new InitBodyparser()).run({master});
-        expect(useCalled).to.be.true;
-        expect(middlewareGeneratorCalled).to.be.equal(2);
-      });
-    });
 
-    after(()=>{
-      mock.stop('body-parser');
+        after(() => {
+            mock.stop("body-parser");
+        });
     });
-  });
 };

package/test/init/compression.js

@@ -1,36 +1,34 @@
-const InitCompression = require('../../src/init/compression');
-const mock = require('mock-require');
+const InitCompression = require("../../src/init/lib/compression");
+const mock = require("mock-require");
 
-module.exports = ({
-  expect
-}) => {
-  describe('Compression', () => {
-    describe('run', () => {
-      it('run, middleware returned and set', async () => {
-        let useCalled = false;
-        let compressionCalled = false;
-        mock('compression', ()=>{
-          compressionCalled = true;
-          return ()=>{};
+module.exports = ({ expect }) => {
+    describe("Compression", () => {
+        describe("run", () => {
+            it("run, middleware returned and set", async () => {
+                let useCalled = false;
+                let compressionCalled = false;
+                mock("compression", () => {
+                    compressionCalled = true;
+                    return () => {};
+                });
+                const master = {
+                    getServer() {
+                        return {
+                            use(func) {
+                                expect(typeof func).to.be.equal("function");
+                                useCalled = true;
+                            },
+                        };
+                    },
+                };
+                await new InitCompression().run({ master });
+                expect(useCalled).to.be.true;
+                expect(compressionCalled).to.be.true;
+            });
         });
-        const master = {
-          getServer() {
-            return {
-              use(func) {
-                expect(typeof func).to.be.equal('function');
-                useCalled = true;
-              }
-            };
-          }
-        };
-        await (new InitCompression()).run({master});
-        expect(useCalled).to.be.true;
-        expect(compressionCalled).to.be.true;
-      });
-    });
 
-    after(()=>{
-      mock.stop('compression');
+        after(() => {
+            mock.stop("compression");
+        });
     });
-  });
 };

package/test/init/cors.js

@@ -1,46 +1,45 @@
-const InitCORS = require('../../src/init/cors');
-const mock = require('mock-require');
+const InitCORS = require("../../src/init/lib/cors");
+const mock = require("mock-require");
 
-mock('cors', ()=>{
-  return ()=>{};
+mock("cors", () => {
+    return () => {};
 });
 
-module.exports = ({expect})=>{
-  describe('InitCORS', ()=>{
-    it('getOriginFilter', ()=>{
-        const res = InitCORS.getOriginFilter(['name1', 'name3']);
-        res('name', (a, b)=>{
-          expect(a).to.be.null;
-          expect(b).to.be.false;
+module.exports = ({ expect }) => {
+    describe("InitCORS", () => {
+        it("getOriginFilter", () => {
+            const res = InitCORS.getOriginFilter(["name1", "name3"]);
+            res("name", (a, b) => {
+                expect(a).to.be.null;
+                expect(b).to.be.false;
+            });
+            res("name1", (a, b) => {
+                expect(a).to.be.null;
+                expect(b).to.be.true;
+            });
         });
-        res('name1', (a, b)=>{
-          expect(a).to.be.null;
-          expect(b).to.be.true;
-        });
-
-    });
 
-    it('run', async () => {
-      let mdSet = false;
-      const config = {
-        get(str){
-          return {
-            'cors': ['domain1', 'domain2']
-          }[str];
-        }
-      };
-      const master = {
-        getServer(){
-          return {
-            use(md){
-              expect(typeof md).to.be.equal('function');
-              mdSet = true;
-            }
-          };
-        }
-      };
-      await new InitCORS().run({config, master});
-      expect(mdSet).to.be.equal(true);
+        it("run", async () => {
+            let mdSet = false;
+            const config = {
+                get(str) {
+                    return {
+                        cors: ["domain1", "domain2"],
+                    }[str];
+                },
+            };
+            const master = {
+                getServer() {
+                    return {
+                        use(md) {
+                            expect(typeof md).to.be.equal("function");
+                            mdSet = true;
+                        },
+                    };
+                },
+            };
+            await new InitCORS().run({ config, master });
+            expect(mdSet).to.be.equal(true);
+        });
     });
-  });
 };

package/test/init/db.js

@@ -1,70 +1,66 @@
-const path = require('path');
-const mock = require('mock-require');
-const InitDB = require('../../src/init/db');
-const pathToIncrement = path.resolve(__dirname, '../../src/model/increment');
+const path = require("path");
+const mock = require("mock-require");
+const InitDB = require("../../src/init/lib/db");
+const pathToIncrement = path.resolve(__dirname, "../../src/model/increment");
 
-class Schema{
-  constructor(){
-    this.statics = {};
-  }
-};
-
-module.exports = ({
-  expect
-}) => {
+class Schema {
+    constructor() {
+        this.statics = {};
+    }
+}
 
-  describe('DB', () => {
-    describe('run', () => {
-      it('simple', async () => {
-        console.log(pathToIncrement);
-        const config = {
-          get(str) {
-            return {
-              'mongoose': {
-                "uri": "mongodb://localhost/base?authSource=base",
-                "options": {
-                  "host": "localhost",
-                  "autoIndex": false,
-                  "poolSize": 10,
-                  "bufferMaxEntries": 0
-                }
-              }
-            }[str];
-          }
-        };
-        mock('mongoose', {
-          async connect(uri, opts) {
-            expect(typeof uri).to.be.equal('string');
-            expect(typeof opts).to.be.equal('object');
-          },
-          model(){
-            return {
-              getNext(){},
-              rebase(){},
-            };
-          },
-          Schema,
-          fakeMongoose: true
+module.exports = ({ expect }) => {
+    describe("DB", () => {
+        describe("run", () => {
+            it("simple", async () => {
+                console.log(pathToIncrement);
+                const config = {
+                    get(str) {
+                        return {
+                            mongoose: {
+                                uri: "mongodb://localhost/base?authSource=base",
+                                options: {
+                                    host: "localhost",
+                                    autoIndex: false,
+                                    poolSize: 10,
+                                    bufferMaxEntries: 0,
+                                },
+                            },
+                        }[str];
+                    },
+                };
+                mock("mongoose", {
+                    async connect(uri, opts) {
+                        expect(typeof uri).to.be.equal("string");
+                        expect(typeof opts).to.be.equal("object");
+                    },
+                    model() {
+                        return {
+                            getNext() {},
+                            rebase() {},
+                        };
+                    },
+                    Schema,
+                    fakeMongoose: true,
+                });
+                mock(pathToIncrement, {
+                    init() {},
+                });
+                const master = {
+                    setMongoose(itm) {
+                        expect(itm.fakeMongoose).to.be.true;
+                    },
+                };
+                await new InitDB().run({ config, master });
+            });
         });
-        mock(pathToIncrement, {
-          init(){}
+        after(() => {
+            mock.stop("mongoose");
+            mock.stop(pathToIncrement);
+            const mod = require(pathToIncrement);
+            delete mod.model;
+            delete mod.next;
+            delete mod.rebase;
         });
-        const master = {
-          setMongoose(itm){
-            expect(itm.fakeMongoose).to.be.true;
-          }
-        };
-        await new InitDB().run({config, master});
-      });
-
-    });
-    after(() => {
-      mock.stop('mongoose');
-      mock.stop(pathToIncrement);
-      const mod =  require(pathToIncrement);
-      delete mod.model;
-      delete mod.next;
-      delete mod.rebase;
     });
-  });
 };

package/test/init/env.js

@@ -1,126 +1,121 @@
-const InitEnv = require('../../src/init/env');
+const InitEnv = require("../../src/init/lib/env");
 
-
-function getFromLib(vals, path, def){
-  if(Object.prototype.hasOwnProperty.call(vals, path)){
-    return vals[path];
-  }else{
-    return def;
-  }
+function getFromLib(vals, path, def) {
+    if (Object.prototype.hasOwnProperty.call(vals, path)) {
+        return vals[path];
+    } else {
+        return def;
+    }
 }
 
+module.exports = ({ expect }) => {
+    describe("Envs", () => {
+        describe("getProxyPort", () => {
+            it("proxy:port - number", () => {
+                const config = {
+                    get(path) {
+                        return path === "proxy:port" ? 8080 : null;
+                    },
+                };
+                const port = InitEnv.getProxyPort(config);
+                expect(port).to.be.equal(8080);
+            });
 
-module.exports = ({expect})=>{
-  describe('Envs', ()=>{
-    describe('getProxyPort', ()=>{
-      it('proxy:port - number', ()=>{
-        const config = {
-          get(path){
-            return path === 'proxy:port' ? 8080:null;
-          }
-        };
-        const port = InitEnv.getProxyPort(config);
-        expect(port).to.be.equal(8080);
-      });
+            it("port - string", () => {
+                const config = {
+                    get(path) {
+                        return path === "port" ? "80" : null;
+                    },
+                };
+                const port = InitEnv.getProxyPort(config);
+                expect(port).to.be.equal(80);
+            });
+        });
 
-      it('port - string', ()=>{
-        const config = {
-          get(path){
-            return path === 'port' ? '80':null;
-          }
-        };
-        const port = InitEnv.getProxyPort(config);
-        expect(port).to.be.equal(80);
-      });
-    });
+        describe("getFullServerName", () => {
+            it("proxy:secure - true, proxy:port - 8080", () => {
+                const vals = {
+                    "proxy:secure": true,
+                    "proxy:port": 8080,
+                    host: "hostname",
+                };
 
+                const config = {
+                    get(path) {
+                        return getFromLib(vals, path, null);
+                    },
+                };
+                const address = InitEnv.getFullServerName(config);
+                expect(address).to.be.equal("https://hostname:8080");
+            });
 
-    describe('getFullServerName', ()=>{
-      it('proxy:secure - true, proxy:port - 8080', ()=>{
-        const vals = {
-          'proxy:secure': true,
-          'proxy:port': 8080,
-          'host': 'hostname'
-        };
+            it("proxy:secure - false, proxy:port - 80", () => {
+                const vals = {
+                    "proxy:secure": false,
+                    "proxy:port": 80,
+                    host: "hostname",
+                };
 
-        const config = {
-          get(path){
-            return getFromLib(vals, path, null);
-          }
-        };
-        const address = InitEnv.getFullServerName(config);
-        expect(address).to.be.equal('https://hostname:8080');
-      });
+                const config = {
+                    get(path) {
+                        return getFromLib(vals, path, null);
+                    },
+                };
+                const address = InitEnv.getFullServerName(config);
+                expect(address).to.be.equal("http://hostname");
+            });
+        });
 
-      it('proxy:secure - false, proxy:port - 80', ()=>{
-        const vals = {
-          'proxy:secure': false,
-          'proxy:port': 80,
-          'host': 'hostname'
-        };
+        describe("run", () => {
+            it("path:ws - empty", async () => {
+                const vals = {
+                    "proxy:secure": true,
+                    "proxy:port": 8080,
+                    host: "hostname",
+                    "path:ws": undefined,
+                };
+                const master = {
+                    getAbsolutePath(str) {
+                        return str + "_fake_absolute";
+                    },
+                };
+                const options = {
+                    pathToApp: "pathToApp__fake",
+                    pathToNPM: "pathToNPM__fake",
+                };
+                const config = {
+                    get(path) {
+                        return getFromLib(vals, path, null);
+                    },
+                    set() {},
+                };
+                await new InitEnv().run({ master, options, config });
+            });
 
-        const config = {
-          get(path){
-            return getFromLib(vals, path, null);
-          }
-        };
-        const address = InitEnv.getFullServerName(config);
-        expect(address).to.be.equal('http://hostname');
-      });
+            it("path:ws - not empty", async () => {
+                const vals = {
+                    "proxy:secure": true,
+                    "proxy:port": 8080,
+                    host: "hostname",
+                    "path:ws": "some_path",
+                };
+                const master = {
+                    getAbsolutePath(str) {
+                        return str + "_fake_absolute";
+                    },
+                };
+                const options = {
+                    pathToApp: "pathToApp__fake",
+                    pathToNPM: "pathToNPM__fake",
+                };
+                const config = {
+                    get(path) {
+                        return getFromLib(vals, path, null);
+                    },
+                    set() {},
+                };
+                await new InitEnv().run({ master, options, config });
+            });
+        });
     });
-
-    describe('run', ()=>{
-      it('path:ws - empty', async ()=>{
-        const vals = {
-          'proxy:secure': true,
-          'proxy:port': 8080,
-          'host': 'hostname',
-          'path:ws': undefined
-        };
-        const master = {
-          getAbsolutePath(str){
-            return str+'_fake_absolute';
-          }
-        };
-        const options = {
-          pathToApp: 'pathToApp__fake',
-          pathToNPM: 'pathToNPM__fake',
-        };
-        const config = {
-          get(path){
-            return getFromLib(vals, path, null);
-          },
-          set(){}
-        };
-        await new InitEnv().run({master, options, config});
-      });
-
-      it('path:ws - not empty', async ()=>{
-        const vals = {
-          'proxy:secure': true,
-          'proxy:port': 8080,
-          'host': 'hostname',
-          'path:ws': 'some_path'
-        };
-        const master = {
-          getAbsolutePath(str){
-            return str+'_fake_absolute';
-          }
-        };
-        const options = {
-          pathToApp: 'pathToApp__fake',
-          pathToNPM: 'pathToNPM__fake',
-        };
-        const config = {
-          get(path){
-            return getFromLib(vals, path, null);
-          },
-          set(){}
-        };
-        await new InitEnv().run({master, options, config});
-      });
-
-    });
-
-  });
 };