not-node 6.2.18 → 6.2.19

package/test/module/fields.js

@@ -1,4 +1,3 @@
-const FIELDS = require("../../src/fields");
 const path = require("path");
 const notModuleRegistratorFields = require("../../src/manifest/registrator/fields");
 
@@ -87,9 +86,14 @@ module.exports = ({ expect }) => {
 
         describe("register", function () {
             it("file is lib", (done) => {
+                const libPath = path.resolve(
+                    __dirname,
+                    "../testies/module/fields/collection.js"
+                );
                 const ctx = {
-                    registerFields({ lib, fieldsImportRules }) {
-                        expect(fieldsImportRules).to.be.deep.equal({
+                    registerFields({ lib, fromPath, nModule }) {
+                        expect(fromPath).to.be.deep.equal(libPath);
+                        expect(nModule.fieldsImportRules).to.be.deep.equal({
                             one: true,
                         });
                         expect(lib).to.be.have.keys(["collectionItem"]);
@@ -102,19 +106,15 @@ module.exports = ({ expect }) => {
                             one: true,
                         },
                     },
-                    fromPath: path.resolve(
-                        __dirname,
-                        "../testies/module/fields/collection.js"
-                    ),
+                    fromPath: libPath,
                 };
                 notModuleRegistratorFields.prototype.register.call(ctx, param);
-                expect(result).to.be.deep.equal(list);
             });
 
             it("file is single field", (done) => {
                 const ctx = {
-                    registerField({ name, field, fieldsImportRules }) {
-                        expect(fieldsImportRules).to.be.deep.equal({
+                    registerField({ name, field, nModule }) {
+                        expect(nModule.fieldsImportRules).to.be.deep.equal({
                             one: true,
                         });
                         expect(field).to.be.have.keys(["ui", "model"]);
@@ -134,13 +134,30 @@ module.exports = ({ expect }) => {
                     ),
                 };
                 notModuleRegistratorFields.prototype.register.call(ctx, param);
-                expect(result).to.be.deep.equal(list);
             });
         });
 
         describe("registerFields", function () {
             it("file is a lib", () => {
-                const ctx = {};
+                const fField = {
+                    ui: {
+                        component: "UITextfield",
+                        placeholder: "collectionItem",
+                        label: "collectionItem",
+                        readonly: true,
+                    },
+                    model: {
+                        type: String,
+                        searchable: true,
+                        required: true,
+                    },
+                };
+                const ctx = {
+                    registerField({ name, field }) {
+                        expect(name).to.be.equal("collectionItem");
+                        expect(field).to.be.deep.equal(fField);
+                    },
+                };
                 const param = {
                     fieldsImportRules: {},
                     lib: require(path.resolve(
@@ -152,29 +169,37 @@ module.exports = ({ expect }) => {
                     ctx,
                     param
                 );
-                expect(Object.keys(FIELDS.LIB).includes("collectionItem")).to.be
-                    .true;
             });
         });
 
         describe("registerField", function () {
             it("file is a single field", () => {
+                const fPath = path.resolve(
+                    __dirname,
+                    "../testies/module/fields/single.js"
+                );
+                let FIELDS = {};
                 const ctx = {
                     extendByFrontValidators() {},
                 };
                 const param = {
                     name: "single",
-                    field: require(path.resolve(
-                        __dirname,
-                        "../testies/module/fields/single.js"
-                    )),
-                    fieldsImportRules: {},
+                    field: require(fPath),
+                    fromPath: fPath,
+                    nModule: {
+                        setField(name, val) {
+                            FIELDS[name] = val;
+                        },
+                        getName() {
+                            return "test_module";
+                        },
+                    },
                 };
                 notModuleRegistratorFields.prototype.registerField.call(
                     ctx,
                     param
                 );
-                expect(Object.keys(FIELDS.LIB).includes("single")).to.be.true;
+                expect(Object.keys(FIELDS).includes("single")).to.be.true;
             });
         });
     });

package/test/module/index.js

@@ -1,10 +1,10 @@
-const notModuleRegistrator = require("../../src/manifest/registrator");
+const BatchRunner = require("../../src/manifest/batchRunner");
 
 module.exports = (input) => {
     const { expect } = input;
 
-    describe("notModuleRegistrator", () => {
-        it("setRegistrators", (done) => {
+    describe("BatchRunner", () => {
+        it("setProcessors", (done) => {
             const param = "query";
             const regs = [
                 {
@@ -14,17 +14,26 @@ module.exports = (input) => {
                     },
                 },
             ];
-            notModuleRegistrator.setRegistrators(regs);
-            expect(notModuleRegistrator.registrators).to.be.deep.equal(regs);
-            notModuleRegistrator.registrators[0].run(param);
+            const runner = new BatchRunner();
+            runner.setProcessors(regs);
+            expect(runner.processors).to.be.deep.equal(regs);
+            runner.processors[0].run(param);
         });
 
-        it("resetRegistrators", () => {
-            const regs = [];
-            notModuleRegistrator.setRegistrators(regs);
-            expect(notModuleRegistrator.registrators.length).to.be.equal(0);
-            notModuleRegistrator.resetRegistrators();
-            expect(notModuleRegistrator.registrators.length).to.be.equal(6);
+        it("resetBatchRunners", () => {
+            const regs = [
+                () => {},
+                () => {},
+                () => {},
+                () => {},
+                () => {},
+                () => {},
+            ];
+            const runner = new BatchRunner();
+            runner.setProcessors(regs);
+            expect(runner.processors.length).to.be.equal(6);
+            runner.resetProcessors();
+            expect(runner.processors.length).to.be.equal(0);
         });
 
         it("with paths", () => {
@@ -33,14 +42,16 @@ module.exports = (input) => {
                     paths: {},
                 },
             };
-            notModuleRegistrator.setRegistrators([]);
-            const res = notModuleRegistrator.registerContent({ nModule });
+            const runner = new BatchRunner();
+            runner.setProcessors([]);
+            const res = runner.exec({ nModule });
             expect(res).to.be.true;
         });
 
         it("without paths", function () {
             const nModule = { module: {} };
-            const res = notModuleRegistrator.registerContent({ nModule });
+            const runner = new BatchRunner();
+            const res = runner.exec({ nModule });
             expect(res).to.be.false;
         });
 

package/test/notApp.js

@@ -1,205 +1,239 @@
-const expect = require('chai').expect,
-  notApp = require('../src/app');
-const mock = require('mock-require');
+const expect = require("chai").expect,
+    notApp = require("../src/app");
+const mock = require("mock-require");
+const { notAppIdentity } = require("..");
 
-mock('not-inform',{
-  Inform: class FakeInformer{}
+mock("not-inform", {
+    Inform: class FakeInformer {},
 });
 
-describe('noApp', function() {
-
-  describe('Constructor', function() {
-    it('With options', function() {
-      let app = new notApp({
-        someOption: true
-      });
-      expect(app.getOptions()).to.deep.equal({
-        someOption: true
-      });
-      expect(app.getModulesNames()).to.deep.equal([]);
+describe("noApp", function () {
+    describe("Constructor", function () {
+        it("With options", function () {
+            let app = new notApp({
+                someOption: true,
+            });
+            expect(app.getOptions()).to.deep.equal({
+                someOption: true,
+            });
+            expect(app.getModulesNames()).to.deep.equal([]);
+        });
     });
-  });
 
-  describe('getManifest', function() {
-    it('getManifest', function() {
-      const ctx = {
-        collectManifest() {
-          return {
-            manifest: true
-          };
-        }
-      };
-      const res = notApp.prototype.getManifest.call(ctx);
-      expect(res).to.deep.equal({
-        manifest: true
-      });
+    describe("getManifest", function () {
+        it("getManifest", function () {
+            notAppIdentity.identity = class {
+                static of() {
+                    return class {
+                        static isRoot() {}
+                        static isUser() {}
+                        static getRole() {}
+                        static getPrimaryRole() {}
+                        static getUserId() {}
+                        static getSessionId() {}
+                    };
+                }
+            };
+            const ctx = {
+                collectManifest() {
+                    return {
+                        manifest: true,
+                    };
+                },
+            };
+            const res = notApp.prototype.getManifest.call(ctx);
+            expect(res).to.deep.equal({
+                manifest: true,
+            });
+        });
     });
-  });
 
-  describe('collectManifest', function() {
-    it('modules - empty', function() {
-      const ctx = {
-        modules: {}
-      };
-      const res = notApp.prototype.collectManifest.call(ctx);
-      expect(res).to.deep.equal({});
-    });
+    describe("collectManifest", function () {
+        it("modules - empty", function () {
+            const ctx = {
+                modules: {},
+                getModulesNames() {
+                    return Object.keys({});
+                },
+            };
+            const res = notApp.prototype.collectManifest.call(ctx);
+            expect(res).to.deep.equal({});
+        });
 
-    it('modules - empty', function() {
-      const ctx = {
-        modules: {
-          user: {
-            getManifest() {
-              return {
+        it("modules - empty", function () {
+            const fModules = {
                 user: {
-                  url: '/api/:modelName',
-                  modelName: 'user',
-                  actions: {
-                    tst: {
-                      mathod: 'get'
-                    }
-                  }
-                }
-              };
-            }
-          },
-          far: {
-            getManifest() {
-              return {
+                    getManifest() {
+                        return {
+                            user: {
+                                url: "/api/:modelName",
+                                modelName: "user",
+                                actions: {
+                                    tst: {
+                                        mathod: "get",
+                                    },
+                                },
+                            },
+                        };
+                    },
+                },
                 far: {
-                  url: '/api/:modelName',
-                  modelName: 'far',
-                  actions: {
-                    pst: {
-                      mathod: 'get'
-                    }
-                  }
-                }
-              };
-            }
-          }
-        }
-      };
-      const res = notApp.prototype.collectManifest.call(ctx);
-      expect(res).to.deep.equal({
-        user: {
-          url: '/api/:modelName',
-          modelName: 'user',
-          actions: {
-            tst: {
-              mathod: 'get'
-            }
-          }
-        },
-        far: {
-          url: '/api/:modelName',
-          modelName: 'far',
-          actions: {
-            pst: {
-              mathod: 'get'
-            }
-          }
-        }
-      });
+                    getManifest() {
+                        return {
+                            far: {
+                                url: "/api/:modelName",
+                                modelName: "far",
+                                actions: {
+                                    pst: {
+                                        mathod: "get",
+                                    },
+                                },
+                            },
+                        };
+                    },
+                },
+            };
+            const ctx = {
+                getModulesNames() {
+                    return Object.keys(fModules);
+                },
+                getModule(name) {
+                    return fModules[name];
+                },
+                modules: fModules,
+            };
+            const res = notApp.prototype.collectManifest.call(ctx);
+            expect(res).to.deep.equal({
+                user: {
+                    url: "/api/:modelName",
+                    modelName: "user",
+                    actions: {
+                        tst: {
+                            mathod: "get",
+                        },
+                    },
+                },
+                far: {
+                    url: "/api/:modelName",
+                    modelName: "far",
+                    actions: {
+                        pst: {
+                            mathod: "get",
+                        },
+                    },
+                },
+            });
+        });
     });
-  });
 
-  describe('expose', function() {
-    it('ok', function() {
-      let exposed = [];
-      const ctx = {
-        forEachMod(cb) {
-          [
-            [
-              'mod1',
-              {
-                expose(app, n) {
-                  exposed.push(n);
-                }
-              }
-            ],
-            ['mod2', {}]
-          ].forEach(item => cb(...item));
-        }
-      };
-      notApp.prototype.expose.call(ctx);
-      expect(exposed).to.deep.equal(['mod1']);
+    describe("expose", function () {
+        it("ok", function () {
+            let exposed = [];
+            const ctx = {
+                forEachMod(cb) {
+                    [
+                        [
+                            "mod1",
+                            {
+                                expose(app, n) {
+                                    exposed.push(n);
+                                },
+                            },
+                        ],
+                        ["mod2", {}],
+                    ].forEach((item) => cb(...item));
+                },
+            };
+            notApp.prototype.expose.call(ctx);
+            expect(exposed).to.deep.equal(["mod1"]);
+        });
     });
-  });
 
+    describe("getActionManifestForUser", function () {
+        it("model and action exists", function () {
+            const ctx = {
+                collectManifest() {
+                    return {
+                        user: {
+                            actions: {
+                                tst: {
+                                    lf: true,
+                                },
+                            },
+                        },
+                    };
+                },
+            };
+            const model = "user",
+                action = "tst",
+                user = {
+                    auth: true,
+                };
+            const res = notApp.prototype.getActionManifestForUser.call(
+                ctx,
+                model,
+                action,
+                user
+            );
+            expect(res).to.deep.equal({
+                lf: true,
+            });
+        });
 
+        it("model not exists", function () {
+            const ctx = {
+                collectManifest() {
+                    return {
+                        book: {
+                            actions: {
+                                tst: {
+                                    lf: true,
+                                },
+                            },
+                        },
+                    };
+                },
+            };
+            const model = "user",
+                action = "tst",
+                user = {
+                    auth: true,
+                };
+            const res = notApp.prototype.getActionManifestForUser.call(
+                ctx,
+                model,
+                action,
+                user
+            );
+            expect(res).to.deep.equal(false);
+        });
 
-  describe('getActionManifestForUser', function() {
-    it('model and action exists', function() {
-      const ctx = {
-        collectManifest() {
-          return {
-            user: {
-              actions: {
-                tst: {
-                  lf: true
-                }
-              }
-            }
-          };
-        }
-      };
-      const model = 'user',
-        action = 'tst',
-        user = {
-          auth: true
-        };
-      const res = notApp.prototype.getActionManifestForUser.call(ctx, model, action, user);
-      expect(res).to.deep.equal({
-        lf: true
-      });
-    });
-
-    it('model not exists', function() {
-      const ctx = {
-        collectManifest() {
-          return {
-            book: {
-              actions: {
-                tst: {
-                  lf: true
-                }
-              }
-            }
-          };
-        }
-      };
-      const model = 'user',
-        action = 'tst',
-        user = {
-          auth: true
-        };
-      const res = notApp.prototype.getActionManifestForUser.call(ctx, model, action, user);
-      expect(res).to.deep.equal(false);
+        it("action not exists", function () {
+            const ctx = {
+                collectManifest() {
+                    return {
+                        user: {
+                            actions: {
+                                look: {
+                                    lf: true,
+                                },
+                            },
+                        },
+                    };
+                },
+            };
+            const model = "user",
+                action = "tst",
+                user = {
+                    auth: true,
+                };
+            const res = notApp.prototype.getActionManifestForUser.call(
+                ctx,
+                model,
+                action,
+                user
+            );
+            expect(res).to.deep.equal(false);
+        });
     });
-
-    it('action not exists', function() {
-      const ctx = {
-        collectManifest() {
-          return {
-            user: {
-              actions: {
-                look: {
-                  lf: true
-                }
-              }
-            }
-          };
-        }
-      };
-      const model = 'user',
-        action = 'tst',
-        user = {
-          auth: true
-        };
-      const res = notApp.prototype.getActionManifestForUser.call(ctx, model, action, user);
-      expect(res).to.deep.equal(false);
-    });
-  });
-
 });