not-node 5.1.44 → 5.1.45

package/test/init/http.js

@@ -1,258 +1,276 @@
-const InitHTTP = require('../../src/init/http');
-const mock = require('mock-require');
-const path = require('path');
+const InitHTTP = require("../../src/init/lib/http");
+const mock = require("mock-require");
+const path = require("path");
 
-module.exports = ({expect})=>{
-  describe('HTTP', ()=>{
-    describe('listenPromise', ()=>{
-      it('ok', (done)=>{
-        const config = {
-          get(str){
-            return {
-              'port': 80
-            }[str];
-          }
-        };
-        const master = {
-          getHTTPServer(){
-            return {
-              listen(port, fn){
-                expect(typeof port).to.be.equal('number');
-                expect(typeof fn).to.be.equal('function');
-                fn();
-              }
-            };
-          }
-        };
-        InitHTTP.prototype.listenPromise.call({}, {config, master})
-          .then(()=>{done();})
-          .catch(done);
-      });
-
-      it('error', async()=>{
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': true,
-              'port': 80
-            }[str];
-          }
-        };
-        const master = {
-          getHTTPServer(){
-            return {
-              listen(port, fn){
-                expect(typeof port).to.be.equal('number');
-                expect(typeof fn).to.be.equal('function');
-                fn(new Error('some error'));
-              }
-            };
-          }
-        };
-        try {
-          await InitHTTP.prototype.listenPromise.call({}, {config, master})
-        } catch (e) {
-          expect(e).to.be.instanceof(Error);
-          expect(e.message).to.be.equal('some error');
-        }
-      });
-    });
+module.exports = ({ expect }) => {
+    describe("HTTP", () => {
+        describe("listenPromise", () => {
+            it("ok", (done) => {
+                const config = {
+                    get(str) {
+                        return {
+                            port: 80,
+                        }[str];
+                    },
+                };
+                const master = {
+                    getHTTPServer() {
+                        return {
+                            listen(port, fn) {
+                                expect(typeof port).to.be.equal("number");
+                                expect(typeof fn).to.be.equal("function");
+                                fn();
+                            },
+                        };
+                    },
+                };
+                InitHTTP.prototype.listenPromise
+                    .call({}, { config, master })
+                    .then(() => {
+                        done();
+                    })
+                    .catch(done);
+            });
 
-    describe('getSSLOptions', ()=>{
-      it('files exists', ()=>{
-        const config = {
-          get(str){
-            return {
-              'ssl:keys:private': path.join(__dirname, '../testies/fake.private'),
-              'ssl:keys:chain': path.join(__dirname,'../testies/fake.chain'),
-              'ssl:keys:cert': path.join(__dirname,'../testies/fake.cert'),
-            }[str];
-          }
-        };
-        const res = InitHTTP.getSSLOptions({config});
-        expect(res).to.have.keys(['ca', 'cert', 'key']);
-        expect(res).to.be.deep.equal({
-          key: "private\n",
-          cert: "cert\n",
-          ca: "chain\n"
+            it("error", async () => {
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": true,
+                            port: 80,
+                        }[str];
+                    },
+                };
+                const master = {
+                    getHTTPServer() {
+                        return {
+                            listen(port, fn) {
+                                expect(typeof port).to.be.equal("number");
+                                expect(typeof fn).to.be.equal("function");
+                                fn(new Error("some error"));
+                            },
+                        };
+                    },
+                };
+                try {
+                    await InitHTTP.prototype.listenPromise.call(
+                        {},
+                        { config, master }
+                    );
+                } catch (e) {
+                    expect(e).to.be.instanceof(Error);
+                    expect(e.message).to.be.equal("some error");
+                }
+            });
         });
-      });
-    });
-
-
-    describe('isSecure', ()=>{
-      it('false', ()=>{
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': false
-            }[str];
-          }
-        };
-        expect(InitHTTP.isSecure({config})).to.be.equal(false);
-      });
 
-      it('true', ()=>{
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': true
-            }[str];
-          }
-        };
-        expect(InitHTTP.isSecure({config})).to.be.equal(true);
-      });
-    });
-
-    describe('run', ()=>{
-      it('secure', async()=>{
-        let runnerCalled = false;
-        const ctx = {
-          async runHTTPS(){
-            runnerCalled = true;
-          },
-          async runHTTP(){
+        describe("getSSLOptions", () => {
+            it("files exists", () => {
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:keys:private": path.join(
+                                __dirname,
+                                "../testies/fake.private"
+                            ),
+                            "ssl:keys:chain": path.join(
+                                __dirname,
+                                "../testies/fake.chain"
+                            ),
+                            "ssl:keys:cert": path.join(
+                                __dirname,
+                                "../testies/fake.cert"
+                            ),
+                        }[str];
+                    },
+                };
+                const res = InitHTTP.getSSLOptions({ config });
+                expect(res).to.have.keys(["ca", "cert", "key"]);
+                expect(res).to.be.deep.equal({
+                    key: "private\n",
+                    cert: "cert\n",
+                    ca: "chain\n",
+                });
+            });
+        });
 
-          },
-        };
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': true
-            }[str];
-          }
-        };
-        await InitHTTP.prototype.run.call(ctx, {config});
-        expect(runnerCalled).to.be.true;
-      });
+        describe("isSecure", () => {
+            it("false", () => {
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": false,
+                        }[str];
+                    },
+                };
+                expect(InitHTTP.isSecure({ config })).to.be.equal(false);
+            });
 
-      it('!secure', async()=>{
-        let runnerCalled = false;
-        const ctx = {
-          async runHTTPS(){},
-          async runHTTP(){
-            runnerCalled = true;
-          },
-        };
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': false
-            }[str];
-          }
-        };
-        await InitHTTP.prototype.run.call(ctx, {config});
-        expect(runnerCalled).to.be.true;
-      });
-    });
+            it("true", () => {
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": true,
+                        }[str];
+                    },
+                };
+                expect(InitHTTP.isSecure({ config })).to.be.equal(true);
+            });
+        });
 
+        describe("run", () => {
+            it("secure", async () => {
+                let runnerCalled = false;
+                const ctx = {
+                    async runHTTPS() {
+                        runnerCalled = true;
+                    },
+                    async runHTTP() {},
+                };
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": true,
+                        }[str];
+                    },
+                };
+                await InitHTTP.prototype.run.call(ctx, { config });
+                expect(runnerCalled).to.be.true;
+            });
 
-    describe('runHTTP', ()=>{
-      before(()=>{
-        mock('http', {
-          createServer(param){
-            param.created = true;
-            return param;
-          }
+            it("!secure", async () => {
+                let runnerCalled = false;
+                const ctx = {
+                    async runHTTPS() {},
+                    async runHTTP() {
+                        runnerCalled = true;
+                    },
+                };
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": false,
+                        }[str];
+                    },
+                };
+                await InitHTTP.prototype.run.call(ctx, { config });
+                expect(runnerCalled).to.be.true;
+            });
         });
-      });
-
-      it('simple run', async()=>{
-        let runnerCalled = false;
-        const ctx = {
-          async listenPromise(){
-            runnerCalled = true;
-          }
-        };
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': true
-            }[str];
-          }
-        };
-        const master = {
-          getServer(){
-            return {
-              created: false,
-              set(key, val){
-                expect(key).to.be.equal('protocol');
-                expect(val).to.be.equal('http');
-              }
-            };
-          },
-          setHTTPServer(f){
-            expect(f).to.be.ok;
-            expect(f.created).to.be.true;
-          },
-        };
-        await InitHTTP.prototype.runHTTP.call(ctx, {master, config});
-        expect(runnerCalled).to.be.true;
-      });
 
-      after(()=>{
-        mock.stop('http');
-      });
-    });
+        describe("runHTTP", () => {
+            before(() => {
+                mock("http", {
+                    createServer(param) {
+                        param.created = true;
+                        return param;
+                    },
+                });
+            });
 
+            it("simple run", async () => {
+                let runnerCalled = false;
+                const ctx = {
+                    async listenPromise() {
+                        runnerCalled = true;
+                    },
+                };
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": true,
+                        }[str];
+                    },
+                };
+                const master = {
+                    getServer() {
+                        return {
+                            created: false,
+                            set(key, val) {
+                                expect(key).to.be.equal("protocol");
+                                expect(val).to.be.equal("http");
+                            },
+                        };
+                    },
+                    setHTTPServer(f) {
+                        expect(f).to.be.ok;
+                        expect(f.created).to.be.true;
+                    },
+                };
+                await InitHTTP.prototype.runHTTP.call(ctx, { master, config });
+                expect(runnerCalled).to.be.true;
+            });
 
-    describe('runHTTPS', ()=>{
-      before(()=>{
-        mock('https', {
-          createServer(keys, param){
-            param.created = true;
-            param.keys = keys;
-            return param;
-          }
+            after(() => {
+                mock.stop("http");
+            });
         });
-      });
 
-      it('simple run', async()=>{
-        let runnerCalled = false;
-        const ctx = {
-          async listenPromise(){
-            runnerCalled = true;
-          }
-        };
-        const config = {
-          get(str){
-            return {
-              'ssl:enabled': true,
-              'ssl:keys:private': path.join(__dirname, '../testies/fake.private'),
-              'ssl:keys:chain': path.join(__dirname,'../testies/fake.chain'),
-              'ssl:keys:cert': path.join(__dirname,'../testies/fake.cert'),
-            }[str];
-          }
-        };
-        const master = {
-          getServer(){
-            return {
-              created: false,
-              set(key, val){
-                expect(key).to.be.equal('protocol');
-                expect(val).to.be.equal('https');
-              }
-            };
-          },
-          setHTTPServer(f){
-            expect(f).to.be.ok;
-            expect(f.created).to.be.true;
-            expect(f.keys).to.have.keys(['ca', 'cert', 'key']);
-            expect(f.keys).to.be.deep.equal({
-              key: "private\n",
-              cert: "cert\n",
-              ca: "chain\n"
+        describe("runHTTPS", () => {
+            before(() => {
+                mock("https", {
+                    createServer(keys, param) {
+                        param.created = true;
+                        param.keys = keys;
+                        return param;
+                    },
+                });
             });
-          },
-        };
-        await InitHTTP.prototype.runHTTPS.call(ctx, {master, config});
-        expect(runnerCalled).to.be.true;
-      });
 
-      after(()=>{
-        mock.stop('https');
-      });
-    });
+            it("simple run", async () => {
+                let runnerCalled = false;
+                const ctx = {
+                    async listenPromise() {
+                        runnerCalled = true;
+                    },
+                };
+                const config = {
+                    get(str) {
+                        return {
+                            "ssl:enabled": true,
+                            "ssl:keys:private": path.join(
+                                __dirname,
+                                "../testies/fake.private"
+                            ),
+                            "ssl:keys:chain": path.join(
+                                __dirname,
+                                "../testies/fake.chain"
+                            ),
+                            "ssl:keys:cert": path.join(
+                                __dirname,
+                                "../testies/fake.cert"
+                            ),
+                        }[str];
+                    },
+                };
+                const master = {
+                    getServer() {
+                        return {
+                            created: false,
+                            set(key, val) {
+                                expect(key).to.be.equal("protocol");
+                                expect(val).to.be.equal("https");
+                            },
+                        };
+                    },
+                    setHTTPServer(f) {
+                        expect(f).to.be.ok;
+                        expect(f.created).to.be.true;
+                        expect(f.keys).to.have.keys(["ca", "cert", "key"]);
+                        expect(f.keys).to.be.deep.equal({
+                            key: "private\n",
+                            cert: "cert\n",
+                            ca: "chain\n",
+                        });
+                    },
+                };
+                await InitHTTP.prototype.runHTTPS.call(ctx, { master, config });
+                expect(runnerCalled).to.be.true;
+            });
 
-  });
+            after(() => {
+                mock.stop("https");
+            });
+        });
+    });
 };

package/test/init/informer.js

@@ -1,29 +1,25 @@
-const mock = require('mock-require');
+const mock = require("mock-require");
 
-class FakeInform{};
+class FakeInform {}
 
+const InitInformer = require("../../src/init/lib/informer");
 
-
-const InitInformer = require('../../src/init/informer');
-
-module.exports = ({expect})=>{
-  describe('Informer', ()=>{
-    describe('run', ()=>{
-      it('ok', async()=>{
-        mock('not-inform', { Inform: FakeInform});
-        const fakeApp = {
-          informer: false
-        };
-        const master = {
-          getApp(){
-            return fakeApp;
-          }
-        };
-        await (new InitInformer()).run({master});
-        expect(fakeApp.informer).to.be.instanceof(FakeInform);
-      });
+module.exports = ({ expect }) => {
+    describe("Informer", () => {
+        describe("run", () => {
+            it("ok", async () => {
+                mock("not-inform", { Inform: FakeInform });
+                const fakeApp = {
+                    informer: false,
+                };
+                const master = {
+                    getApp() {
+                        return fakeApp;
+                    },
+                };
+                await new InitInformer().run({ master });
+                expect(fakeApp.informer).to.be.instanceof(FakeInform);
+            });
+        });
     });
-
-  });
-
 };

package/test/init/methodoverride.js

@@ -1,35 +1,33 @@
-const InitMethodOverride = require('../../src/init/methodoverride');
-const mock = require('mock-require');
+const InitMethodOverride = require("../../src/init/lib/methodoverride");
+const mock = require("mock-require");
 
-module.exports = ({
-  expect
-}) => {
-  describe('MethodOverride', () => {
-    describe('run', () => {
-      it('run, middleware returned and set', async () => {
-        let useCalled = false;
-        let middlewareGeneratorCalled = false;
-        mock('method-override', ()=>{
-          middlewareGeneratorCalled = true;
-          return ()=>{};
+module.exports = ({ expect }) => {
+    describe("MethodOverride", () => {
+        describe("run", () => {
+            it("run, middleware returned and set", async () => {
+                let useCalled = false;
+                let middlewareGeneratorCalled = false;
+                mock("method-override", () => {
+                    middlewareGeneratorCalled = true;
+                    return () => {};
+                });
+                const master = {
+                    getServer() {
+                        return {
+                            use(func) {
+                                expect(typeof func).to.be.equal("function");
+                                useCalled = true;
+                            },
+                        };
+                    },
+                };
+                await new InitMethodOverride().run({ master });
+                expect(useCalled).to.be.true;
+                expect(middlewareGeneratorCalled).to.be.true;
+            });
+        });
+        after(() => {
+            mock.stop("method-override");
         });
-        const master = {
-          getServer() {
-            return {
-              use(func) {
-                expect(typeof func).to.be.equal('function');
-                useCalled = true;
-              }
-            };
-          }
-        };
-        await (new InitMethodOverride()).run({master});
-        expect(useCalled).to.be.true;
-        expect(middlewareGeneratorCalled).to.be.true;
-      });
-    });
-    after(()=>{
-      mock.stop('method-override');
     });
-  });
 };