not-node 5.1.44 → 6.0.0

package/test/init/middleware.js

@@ -1,65 +1,63 @@
-const InitMiddleware = require('../../src/init/middleware');
-const mock = require('mock-require');
+const InitMiddleware = require("../../src/init/lib/middleware");
+const mock = require("mock-require");
 
-module.exports = ({
-  expect
-}) => {
-  describe('Middleware', () => {
-    describe('run', () => {
-      it('config middleware empty', async () => {
-        const config = {
-          get() {
-            return false;
-          }
-        }
-        await (new InitMiddleware()).run({
-          config
-        });
-      });
+module.exports = ({ expect }) => {
+    describe("Middleware", () => {
+        describe("run", () => {
+            it("config middleware empty", async () => {
+                const config = {
+                    get() {
+                        return false;
+                    },
+                };
+                await new InitMiddleware().run({
+                    config,
+                });
+            });
 
-      mock('not-fake-mod', () => {});
-      mock('not-fake-mod-2-path', {
-        middleware() {}
-      });
+            mock("not-fake-mod", () => {});
+            mock("not-fake-mod-2-path", {
+                middleware() {},
+            });
 
-      mock('not-fake-mod-getMiddleware', {
-        getMiddleware(opts) {
-          expect(opts).to.be.deep.equal({
-            params: true
-          });
-          return () => {};
-        }
-      });
+            mock("not-fake-mod-getMiddleware", {
+                getMiddleware(opts) {
+                    expect(opts).to.be.deep.equal({
+                        params: true,
+                    });
+                    return () => {};
+                },
+            });
 
-      it('config middleware not empty', async () => {
-        const config = {
-          get() {
-            return {
-              'not-fake-mod': {},
-              'not-fake-mod-2': {
-                path: 'not-fake-mod-2-path'
-              },
-              'not-fake-mod-getMiddleware': {
-                params: true
-              },
-            };
-          }
-        };
-        const fakeServer = {
-          use(func) {
-            expect(typeof func).to.be.equal('function');
-          }
-        };
-        const master = {
-          getServer() {
-            return fakeServer;
-          }
-        };
-        await (new InitMiddleware()).run({
-          config,
-          master
+            it("config middleware not empty", async () => {
+                const config = {
+                    get() {
+                        return {
+                            "not-fake-mod": {},
+                            "not-fake-mod-2": {
+                                path: "not-fake-mod-2-path",
+                            },
+                            "not-fake-mod-getMiddleware": {
+                                params: true,
+                            },
+                        };
+                    },
+                };
+                const fakeServer = {
+                    use(func) {
+                        expect(typeof func).to.be.equal("function");
+                    },
+                };
+                const master = {
+                    getServer() {
+                        return fakeServer;
+                    },
+                };
+                await new InitMiddleware().run({
+                    config,
+                    master,
+                });
+            });
         });
-      });
     });
-  });
 };

package/test/init/modules.js

@@ -1,22 +1,22 @@
-const InitModules = require('../../src/init/modules');
+const InitModules = require("../../src/init/lib/modules");
 
-module.exports = ({expect})=>{
-  describe('Modules', ()=>{
-    describe('run', ()=>{
-      it('ok', async()=>{
-        let executed = false;
-        const master = {
-          getApp(){
-            return {
-              execInModules(str){
-                executed = str;
-              }
-            };
-          }
-        };
-        await (new InitModules()).run({master});
-        expect(executed).to.be.equal('initialize');
-      });
+module.exports = ({ expect }) => {
+    describe("Modules", () => {
+        describe("run", () => {
+            it("ok", async () => {
+                let executed = false;
+                const master = {
+                    getApp() {
+                        return {
+                            execInModules(str) {
+                                executed = str;
+                            },
+                        };
+                    },
+                };
+                await new InitModules().run({ master });
+                expect(executed).to.be.equal("initialize");
+            });
+        });
     });
-  });
 };

package/test/init/monitoring.js

@@ -1,26 +1,26 @@
-const InitMonitoring = require('../../src/init/monitoring');
-const mock = require('mock-require');
+const InitMonitoring = require("../../src/init/lib/monitoring");
+const mock = require("mock-require");
 
-module.exports = ({expect})=>{
-  describe('Monitoring', ()=>{
-    it('run', async ()=>{
-      let event = false;
-      mock('not-monitor', {
-        monitor:{
-          on(name, cb){
-            expect(name).to.be.equal('afterReportError');
-            expect(typeof cb).to.be.equal('function');
-            event = true;
-            cb(new Error('some error'));
-          }
-        }
-      });
-      await new InitMonitoring().run();
-      expect(event).to.be.equal(true);
-    });
+module.exports = ({ expect }) => {
+    describe("Monitoring", () => {
+        it("run", async () => {
+            let event = false;
+            mock("not-monitor", {
+                monitor: {
+                    on(name, cb) {
+                        expect(name).to.be.equal("afterReportError");
+                        expect(typeof cb).to.be.equal("function");
+                        event = true;
+                        cb(new Error("some error"));
+                    },
+                },
+            });
+            await new InitMonitoring().run();
+            expect(event).to.be.equal(true);
+        });
 
-    after(()=>{
-      mock.stop('not-monitor');
+        after(() => {
+            mock.stop("not-monitor");
+        });
     });
-  });
 };

package/test/init/routes.js

@@ -1,183 +1,197 @@
-const InitRoutes = require('../../src/init/routes');
-const {notError, notRequestError} = require('not-error');
-const mock = require('mock-require');
+const InitRoutes = require("../../src/init/lib/routes");
+const { notError, notRequestError } = require("not-error");
+const mock = require("mock-require");
 
-module.exports = ({expect})=>{
-  describe('Routes', ()=>{
-    mock('serve-static', ()=>{});
-    describe('finalError', ()=>{
-      it('Error, !statusCode', (done)=>{
-        const req = {
-          url: 'failure_path'
-        };
-        const res = {
-          status(code){
-            expect(code).to.be.equal(500);
-          },
-          json(dat){
-            expect(dat).to.be.deep.equal({
-              status: 'error',
-              message: 'Serious generic error'
+module.exports = ({ expect }) => {
+    describe("Routes", () => {
+        mock("serve-static", () => {});
+        describe("finalError", () => {
+            it("Error, !statusCode", (done) => {
+                const req = {
+                    url: "failure_path",
+                };
+                const res = {
+                    status(code) {
+                        expect(code).to.be.equal(500);
+                    },
+                    json(dat) {
+                        expect(dat).to.be.deep.equal({
+                            status: "error",
+                            message: "Serious generic error",
+                        });
+                        done();
+                    },
+                };
+                const master = {
+                    getApp() {
+                        return {
+                            report(err) {
+                                expect(err).to.be.instanceof(notError);
+                            },
+                        };
+                    },
+                };
+                const final = InitRoutes.finalError({ master });
+                final(new Error("Serious generic error"), req, res);
             });
-            done();
-          }
-        };
-        const master = {
-          getApp(){
-            return {
-              report(err){
-                expect(err).to.be.instanceof(notError);
-              }
-            };
-          }
-        };
-        const final = InitRoutes.finalError({master});
-        final(new Error('Serious generic error'), req, res);
-      });
 
-      it('!Error, !statusCode', (done)=>{
-        const req = {
-          url: 'failure_path'
-        };
-        const res = {
-          status(code){
-            expect(code).to.be.equal(500);
-            return this;
-          },
-          json(dat){
-            expect(dat).to.be.deep.equal({
-              status: 'error'
+            it("!Error, !statusCode", (done) => {
+                const req = {
+                    url: "failure_path",
+                };
+                const res = {
+                    status(code) {
+                        expect(code).to.be.equal(500);
+                        return this;
+                    },
+                    json(dat) {
+                        expect(dat).to.be.deep.equal({
+                            status: "error",
+                        });
+                        done();
+                    },
+                };
+                const master = {
+                    getApp() {
+                        return {
+                            report(err) {
+                                expect(err).to.be.instanceof(notError);
+                            },
+                        };
+                    },
+                };
+                const final = InitRoutes.finalError({ master });
+                final("Serious generic error", req, res);
             });
-            done();
-          }
-        };
-        const master = {
-          getApp(){
-            return {
-              report(err){
-                expect(err).to.be.instanceof(notError);
-              }
-            };
-          }
-        };
-        const final = InitRoutes.finalError({master});
-        final('Serious generic error', req, res);
-      });
 
+            it("notError, !statusCode", (done) => {
+                const req = {
+                    url: "failure_path",
+                };
+                const res = {};
+                const master = {
+                    getApp() {
+                        return {
+                            report(err) {
+                                expect(err).to.be.instanceof(notError);
+                                done();
+                            },
+                        };
+                    },
+                };
+                const final = InitRoutes.finalError({ master });
+                final(new notError("Serious not error", {}), req, res);
+            });
 
-      it('notError, !statusCode', (done)=>{
-        const req = {
-          url: 'failure_path'
-        };
-        const res = {};
-        const master = {
-          getApp(){
-            return {
-              report(err){
-                expect(err).to.be.instanceof(notError);
-                done();
-              }
-            };
-          }
-        };
-        const final = InitRoutes.finalError({master});
-        final(new notError('Serious not error', {}), req, res);
-      });
-
-
-      it('notRequestError, redirect, code = 404', (done)=>{
-        const req = {
-          url: 'failure_path'
-        };
-        const res = {
-          redirect(url){
-            expect(url).to.be.equal('redirect_url_fake');
-            done();
-          }
-        };
-        const master = {
-          getApp(){
-            return {
-              report(err){
-                expect(err).to.be.instanceof(notRequestError);
-              }
-            };
-          }
-        };
-        const final = InitRoutes.finalError({master});
-        final(new notRequestError('Serious not error', {code: 404, redirect: 'redirect_url_fake'}), req, res);
-      });
-
-      it('notRequestError, no redirect, code = 404', (done)=>{
-        const req = {
-          url: 'failure_path'
-        };
-        const res = {
-          status(code){
-            expect(code).to.be.equal(404);
-            return this;
-          },
-          json(dat){
-            expect(dat).to.be.deep.equal({
-              status: 'error',
-              message:  'Serious not error request',
-              errors:  {field: ['name']},
+            it("notRequestError, redirect, code = 404", (done) => {
+                const req = {
+                    url: "failure_path",
+                };
+                const res = {
+                    redirect(url) {
+                        expect(url).to.be.equal("redirect_url_fake");
+                        done();
+                    },
+                };
+                const master = {
+                    getApp() {
+                        return {
+                            report(err) {
+                                expect(err).to.be.instanceof(notRequestError);
+                            },
+                        };
+                    },
+                };
+                const final = InitRoutes.finalError({ master });
+                final(
+                    new notRequestError("Serious not error", {
+                        code: 404,
+                        redirect: "redirect_url_fake",
+                    }),
+                    req,
+                    res
+                );
             });
-            done();
-          }
-        };
-        const master = {
-          getApp(){
-            return {
-              report(err){
-                expect(err).to.be.instanceof(notRequestError);
-              }
-            };
-          }
-        };
-        const final = InitRoutes.finalError({master});
-        final(new notRequestError('Serious not error request', {code: 404, errors: {field: ['name']} }), req, res);
-      });
-    });
 
+            it("notRequestError, no redirect, code = 404", (done) => {
+                const req = {
+                    url: "failure_path",
+                };
+                const res = {
+                    status(code) {
+                        expect(code).to.be.equal(404);
+                        return this;
+                    },
+                    json(dat) {
+                        expect(dat).to.be.deep.equal({
+                            status: "error",
+                            message: "Serious not error request",
+                            errors: { field: ["name"] },
+                        });
+                        done();
+                    },
+                };
+                const master = {
+                    getApp() {
+                        return {
+                            report(err) {
+                                expect(err).to.be.instanceof(notRequestError);
+                            },
+                        };
+                    },
+                };
+                const final = InitRoutes.finalError({ master });
+                final(
+                    new notRequestError("Serious not error request", {
+                        code: 404,
+                        errors: { field: ["name"] },
+                    }),
+                    req,
+                    res
+                );
+            });
+        });
 
-    describe('run', ()=>{
-      it('run', async ()=>{
-        const fakeServer = { sarver: true, use(fn){
-          expect(typeof fn).to.be.equal('function');
-        }};
-        const fakeApp = {
-          report(){},
-          use(fn){
-            expect(typeof fn).to.be.equal('function');
-          },
-          expose(ser){
-            expect(ser).to.be.deep.equal(fakeServer);
-          },
-        };
-        mock('main-not-app-routes', (ser, app)=>{
-          expect(ser).to.be.deep.equal(fakeServer);
-          expect(app).to.be.deep.equal(fakeApp);
+        describe("run", () => {
+            it("run", async () => {
+                const fakeServer = {
+                    sarver: true,
+                    use(fn) {
+                        expect(typeof fn).to.be.equal("function");
+                    },
+                };
+                const fakeApp = {
+                    report() {},
+                    use(fn) {
+                        expect(typeof fn).to.be.equal("function");
+                    },
+                    expose(ser) {
+                        expect(ser).to.be.deep.equal(fakeServer);
+                    },
+                };
+                mock("main-not-app-routes", (ser, app) => {
+                    expect(ser).to.be.deep.equal(fakeServer);
+                    expect(app).to.be.deep.equal(fakeApp);
+                });
+                const options = {
+                    indexRoute: () => {},
+                    routesPath: "main-not-app-routes",
+                };
+                const master = {
+                    getServer() {
+                        return fakeServer;
+                    },
+                    getApp() {
+                        return fakeApp;
+                    },
+                };
+                const config = {
+                    get(str) {
+                        return str + "__fake";
+                    },
+                };
+                await new InitRoutes().run({ master, config, options });
+            });
         });
-        const options = {
-          indexRoute: ()=>{},
-          routesPath: 'main-not-app-routes'
-        };
-        const master = {
-          getServer(){
-            return fakeServer;
-          },
-          getApp(){
-            return fakeApp;
-          }
-        };
-        const config = {
-          get(str){
-            return str + '__fake';
-          }
-        };
-        await new InitRoutes().run({master, config, options});
-      });
     });
-  });
 };