not-node 6.2.18 → 6.2.19

package/test/init/additional.js

@@ -1,36 +1,34 @@
-const ADDS = require('../../src/init/additional');
+const ADDS = require("../../src/init/additional");
 
-module.exports = ({expect})=>{
-
-  describe('Addtional', ()=>{
-    it('init/run', async ()=>{
-      ADDS.init(5);
-      const res = await ADDS.run('m', 'asd');
-      expect(res).to.be.undefined;
-      ADDS.init({
-        m(){
-          return Array.from(arguments).join('.');
-        },
-        async t(){
-          return Array.from(arguments).join('.');
-        },
-        obj:{
-          data:{
-            collection:{
-              runnable(){
-                return 'executed';
-              }
-            }
-          }
-        }
-      });
-      const res1 = await ADDS.run('m', 'asd');
-      expect(res1).to.be.equal('asd');
-      const res2 = await ADDS.run('t', 'sd');
-      expect(res2).to.be.equal('sd');
-      const res3 = await ADDS.run('obj.data.collection.runnable');
-      expect(res3).to.be.equal('executed');
+module.exports = ({ expect }) => {
+    describe("Addtional", () => {
+        it("init/run", async () => {
+            ADDS.init(5);
+            const res = await ADDS.run("m", "asd");
+            expect(res).to.be.undefined;
+            ADDS.init({
+                m() {
+                    return Array.from(arguments).join(".");
+                },
+                async t() {
+                    return Array.from(arguments).join(".");
+                },
+                obj: {
+                    data: {
+                        collection: {
+                            runnable() {
+                                return "executed";
+                            },
+                        },
+                    },
+                },
+            });
+            const res1 = await ADDS.run("m", "asd");
+            expect(res1).to.be.equal("asd");
+            const res2 = await ADDS.run("t", "sd");
+            expect(res2).to.be.equal("sd");
+            const res3 = await ADDS.run("obj.data.collection.runnable");
+            expect(res3).to.be.equal("executed");
+        });
     });
-  });
-
 };

package/test/init/app.js

@@ -1,10 +1,20 @@
+const path = require("node:path");
 const ADDS = require("../../src/init/additional");
 const InitApp = require("../../src/init/lib/app");
-
+const createFakeEmit = (val, err) => {
+    return async () => {
+        if (err) {
+            throw err;
+        } else {
+            return val;
+        }
+    };
+};
 module.exports = ({ expect }) => {
     describe("App", () => {
         describe("createApp", () => {
             it("not emits to call", async () => {
+                const fEmit = createFakeEmit();
                 let constructorCalled = false;
                 const fakeMongoose = {
                     this: "is fake indeed",
@@ -27,7 +37,12 @@ module.exports = ({ expect }) => {
                     },
                 };
 
-                await InitApp.createApp({ master, config, options });
+                await InitApp.createApp({
+                    master,
+                    config,
+                    options,
+                    emit: fEmit,
+                });
                 expect(constructorCalled).to.be.true;
             });
 
@@ -68,7 +83,12 @@ module.exports = ({ expect }) => {
                     },
                 };
 
-                await InitApp.createApp({ master, config, options });
+                await InitApp.createApp({
+                    master,
+                    config,
+                    options,
+                    emit: ADDS.run.bind(ADDS),
+                });
                 expect(constructorCalled).to.be.true;
                 expect(preCalled).to.be.true;
                 expect(postCalled).to.be.true;
@@ -114,7 +134,12 @@ module.exports = ({ expect }) => {
                     setEnv() {},
                 };
 
-                await InitApp.setAppEnvs({ master, config, options });
+                await InitApp.setAppEnvs({
+                    master,
+                    config,
+                    options,
+                    emit: ADDS.run.bind(ADDS),
+                });
 
                 expect(preCalled).to.be.true;
                 expect(postCalled).to.be.true;
@@ -173,7 +198,12 @@ module.exports = ({ expect }) => {
                     },
                 };
 
-                await InitApp.importModules({ master, config, options });
+                await InitApp.importModules({
+                    master,
+                    config,
+                    options,
+                    emit: ADDS.run.bind(ADDS),
+                });
 
                 expect(preCalled).to.be.true;
                 expect(postCalled).to.be.true;
@@ -218,7 +248,12 @@ module.exports = ({ expect }) => {
                         return fakeManifest;
                     },
                 };
-                await InitApp.importModules({ master, config, options });
+                await InitApp.importModules({
+                    master,
+                    config,
+                    options,
+                    emit: ADDS.run.bind(ADDS),
+                });
                 expect(preCalled).to.be.true;
                 expect(postCalled).to.be.true;
             });
@@ -226,6 +261,7 @@ module.exports = ({ expect }) => {
 
         describe("createReporter", () => {
             it("ok", async () => {
+                const fEmit = createFakeEmit();
                 let reporterConstructed = false;
                 class FakeReporter {
                     constructor(opts) {
@@ -247,7 +283,12 @@ module.exports = ({ expect }) => {
                         return fakeManifest;
                     },
                 };
-                await InitApp.createReporter({ master, config, options });
+                await InitApp.createReporter({
+                    master,
+                    config,
+                    options,
+                    emit: fEmit,
+                });
                 expect(reporterConstructed).to.be.true;
             });
 
@@ -335,7 +376,17 @@ module.exports = ({ expect }) => {
                         expect(modsPath).to.be.equal("modulesPath_fake");
                     },
                     importModuleFrom(modPath, modName) {
-                        expect(modPath).to.be.equal("npmPath_fake/" + modName);
+                        console.log(
+                            path.resolve("src/core"),
+                            path.resolve("npmPath_fake/" + modName)
+                        );
+                        console.log(modPath, modName);
+                        expect(
+                            [
+                                path.resolve("src/core"),
+                                path.resolve("npmPath_fake/" + modName),
+                            ].includes(path.resolve(modPath))
+                        ).to.be.true;
                     },
                 };
                 const master = {
@@ -357,12 +408,17 @@ module.exports = ({ expect }) => {
                     },
                 };
                 try {
-                    await new InitApp().run({ master, config, options });
+                    await new InitApp().run({
+                        master,
+                        config,
+                        options,
+                        emit: ADDS.run.bind(ADDS),
+                    });
                 } catch (e) {
+                    expect(e.message).to.be.equal("Post throwed");
                     expect(constructorCalled).to.be.true;
                     expect(preCalled).to.be.true;
                     expect(postCalled).to.be.true;
-                    expect(e.message).to.be.equal("Post throwed");
                 }
             });
         });

package/test/init/bodyparser.js

@@ -29,7 +29,10 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitBodyparser().run({ master });
+                await new InitBodyparser().run({
+                    master,
+                    emit: require("../fakes").createFakeEmit(),
+                });
                 expect(useCalled).to.be.true;
                 expect(middlewareGeneratorCalled).to.be.equal(2);
             });

package/test/init/compression.js

@@ -21,7 +21,10 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitCompression().run({ master });
+                await new InitCompression().run({
+                    emit: require("../fakes").createFakeEmit(),
+                    master,
+                });
                 expect(useCalled).to.be.true;
                 expect(compressionCalled).to.be.true;
             });

package/test/init/cors.js

@@ -38,7 +38,11 @@ module.exports = ({ expect }) => {
                     };
                 },
             };
-            await new InitCORS().run({ config, master });
+            await new InitCORS().run({
+                config,
+                master,
+                emit: require("../fakes").createFakeEmit(),
+            });
             expect(mdSet).to.be.equal(true);
         });
     });

package/test/init/csp.js

@@ -1,3 +1,3 @@
-module.exports = ({expect})=>{
-  describe('CSP', ()=>{});
+module.exports = ({ expect }) => {
+    describe("CSP", () => {});
 };

package/test/init/db.js

@@ -51,7 +51,11 @@ module.exports = ({ expect }) => {
                         expect(itm.fakeMongoose).to.be.true;
                     },
                 };
-                await new InitDB().run({ config, master });
+                await new InitDB().run({
+                    emit: require("../fakes").createFakeEmit(),
+                    config,
+                    master,
+                });
             });
         });
         after(() => {

package/test/init/env.js

@@ -89,7 +89,12 @@ module.exports = ({ expect }) => {
                     },
                     set() {},
                 };
-                await new InitEnv().run({ master, options, config });
+                await new InitEnv().run({
+                    master,
+                    options,
+                    config,
+                    emit: require("../fakes").createFakeEmit(),
+                });
             });
 
             it("path:ws - not empty", async () => {
@@ -114,7 +119,12 @@ module.exports = ({ expect }) => {
                     },
                     set() {},
                 };
-                await new InitEnv().run({ master, options, config });
+                await new InitEnv().run({
+                    master,
+                    options,
+                    config,
+                    emit: require("../fakes").createFakeEmit(),
+                });
             });
         });
     });

package/test/init/express.js

@@ -44,7 +44,10 @@ module.exports = ({ expect }) => {
                         return this._server;
                     },
                 };
-                await new InitExpress().run({ master });
+                await new InitExpress().run({
+                    emit: require("../fakes").createFakeEmit(),
+                    master,
+                });
                 expect(nextCalled).to.be.true;
             });
         });

package/test/init/fileupload.js

@@ -22,7 +22,10 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitFileupload().run({ master });
+                await new InitFileupload().run({
+                    emit: require("../fakes").createFakeEmit(),
+                    master,
+                });
                 expect(useCalled).to.be.true;
                 expect(middlewareGeneratorCalled).to.be.true;
             });

package/test/init/http.js

@@ -25,7 +25,14 @@ module.exports = ({ expect }) => {
                     },
                 };
                 InitHTTP.prototype.listenPromise
-                    .call({}, { config, master })
+                    .call(
+                        {},
+                        {
+                            emit: require("../fakes").createFakeEmit(),
+                            config,
+                            master,
+                        }
+                    )
                     .then(() => {
                         done();
                     })
@@ -55,7 +62,11 @@ module.exports = ({ expect }) => {
                 try {
                     await InitHTTP.prototype.listenPromise.call(
                         {},
-                        { config, master }
+                        {
+                            emit: require("../fakes").createFakeEmit(),
+                            config,
+                            master,
+                        }
                     );
                 } catch (e) {
                     expect(e).to.be.instanceof(Error);
@@ -134,7 +145,10 @@ module.exports = ({ expect }) => {
                         }[str];
                     },
                 };
-                await InitHTTP.prototype.run.call(ctx, { config });
+                await InitHTTP.prototype.run.call(ctx, {
+                    emit: require("../fakes").createFakeEmit(),
+                    config,
+                });
                 expect(runnerCalled).to.be.true;
             });
 
@@ -153,7 +167,10 @@ module.exports = ({ expect }) => {
                         }[str];
                     },
                 };
-                await InitHTTP.prototype.run.call(ctx, { config });
+                await InitHTTP.prototype.run.call(ctx, {
+                    emit: require("../fakes").createFakeEmit(),
+                    config,
+                });
                 expect(runnerCalled).to.be.true;
             });
         });

package/test/init/middleware.js

@@ -1,10 +1,19 @@
 const InitMiddleware = require("../../src/init/lib/middleware");
 const mock = require("mock-require");
-
+const createFakeEmit = (val, err) => {
+    return async () => {
+        if (err) {
+            throw err;
+        } else {
+            return val;
+        }
+    };
+};
 module.exports = ({ expect }) => {
     describe("Middleware", () => {
         describe("run", () => {
             it("config middleware empty", async () => {
+                const fEmit = createFakeEmit();
                 const config = {
                     get() {
                         return false;
@@ -12,6 +21,7 @@ module.exports = ({ expect }) => {
                 };
                 await new InitMiddleware().run({
                     config,
+                    emit: fEmit,
                 });
             });
 
@@ -30,6 +40,7 @@ module.exports = ({ expect }) => {
             });
 
             it("config middleware not empty", async () => {
+                const fEmit = createFakeEmit();
                 const config = {
                     get() {
                         return {
@@ -56,6 +67,7 @@ module.exports = ({ expect }) => {
                 await new InitMiddleware().run({
                     config,
                     master,
+                    emit: fEmit,
                 });
             });
         });

package/test/init/routes.js

@@ -168,6 +168,7 @@ module.exports = ({ expect }) => {
                     expose(ser) {
                         expect(ser).to.be.deep.equal(fakeServer);
                     },
+                    async execInModules() {},
                 };
                 mock("main-not-app-routes", (ser, app) => {
                     expect(ser).to.be.deep.equal(fakeServer);

package/test/init/sessions/mongoose.js

@@ -52,7 +52,11 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitSessionsMongo().run({ master, config });
+                await new InitSessionsMongo().run({
+                    master,
+                    config,
+                    emit: require("../../fakes").createFakeEmit(),
+                });
                 expect(events.sort()).to.be.deep.equal(
                     ["error", "connected"].sort()
                 );

package/test/init/sessions/redis.js

@@ -58,7 +58,11 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitSessionsRedis().run({ master, config });
+                await new InitSessionsRedis().run({
+                    master,
+                    config,
+                    emit: require("../../fakes").createFakeEmit(),
+                });
             });
         });
     });

package/test/init/sessions.js

@@ -1,5 +1,14 @@
 const InitSessions = require("../../src/init/lib/sessions");
 const mock = require("mock-require");
+const createFakeEmit = (val, err) => {
+    return async () => {
+        if (err) {
+            throw err;
+        } else {
+            return val;
+        }
+    };
+};
 
 module.exports = ({ expect }) => {
     describe("Sessions", () => {
@@ -31,19 +40,7 @@ module.exports = ({ expect }) => {
 
             describe("run", () => {
                 it("driver loaded ok", async () => {
-                    let constRunned = false;
-                    let runRunned = false;
-                    mock(
-                        "../../src/init/sessions/redis.js",
-                        class A {
-                            constructor() {
-                                constRunned = true;
-                            }
-                            async run() {
-                                runRunned = true;
-                            }
-                        }
-                    );
+                    const fEmit = createFakeEmit();
                     const config = {
                         get() {
                             return {
@@ -52,13 +49,21 @@ module.exports = ({ expect }) => {
                         },
                     };
                     await new InitSessions().run({
+                        emit: fEmit,
                         config,
+                        master: {
+                            getEnv() {
+                                return {};
+                            },
+                            getServer() {
+                                return { use() {} };
+                            },
+                        },
                     });
-                    expect(constRunned).to.be.true;
-                    expect(runRunned).to.be.true;
                 });
 
                 it("driver loaded, but not class", async () => {
+                    const fEmit = createFakeEmit();
                     try {
                         mock("../../src/init/sessions/mongo.js", 2);
                         const config = {
@@ -69,6 +74,7 @@ module.exports = ({ expect }) => {
                             },
                         };
                         await new InitSessions().run({
+                            emit: fEmit,
                             config,
                         });
                     } catch (e) {

package/test/init/static.js

@@ -114,7 +114,10 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitStatic().run({ master });
+                await new InitStatic().run({
+                    emit: require("../fakes").createFakeEmit(),
+                    master,
+                });
             });
         });
     });

package/test/init/template.js

@@ -27,7 +27,11 @@ module.exports = ({ expect }) => {
                         };
                     },
                 };
-                await new InitTemplate().run({ master, config });
+                await new InitTemplate().run({
+                    emit: require("../fakes").createFakeEmit(),
+                    master,
+                    config,
+                });
                 expect(setCalled).to.be.equal(2);
             });
         });

package/test/model/versioning.js

@@ -1,5 +1,5 @@
 const {
-    VersioningExceptioNoPreviousVersions,
+    VersioningExceptionNoPreviousVersions,
 } = require("../../src/model/exceptions.js");
 
 const expect = require("chai").expect,
@@ -267,12 +267,12 @@ module.exports = ({ mongoose }) => {
                     await ModelVersioning.isNew(modelProto.Document, latest);
                 } catch (e) {
                     expect(e).to.be.instanceOf(
-                        VersioningExceptioNoPreviousVersions
+                        VersioningExceptionNoPreviousVersions
                     );
                     return;
                 }
                 throw new Error(
-                    "no exception from inside, VersioningExceptioNoPreviousVersions"
+                    "no exception from inside, VersioningExceptionNoPreviousVersions"
                 );
             });