not-node 4.0.1 → 4.0.5

package/.eslintrc.json

@@ -31,6 +31,7 @@
     "node/prefer-global/url": ["error", "always"],
     "node/prefer-promises/dns": "error",
     "node/prefer-promises/fs": "error",
+    "node/no-unpublished-require": "warn",
     "indent": ["error", 2],
     "linebreak-style": [
       "error",

package/index.js

@@ -29,6 +29,8 @@ module.exports.Routine = require('./src/model/routine');
 module.exports.Common = require('./src/common');
 /** Fields library manager */
 module.exports.Fields = require('./src/fields');
+/** Form validation template **/
+module.exports.Form = require('./src/form');
 /** Application initialization procedures */
 module.exports.Init = require('./src/init').Init;
 /** Application object */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "4.0.1",
+  "version": "4.0.5",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {
@@ -78,6 +78,7 @@
     "eslint-plugin-promise": "^5.1.1",
     "eslint-plugin-sonarjs": "^0.10.0",
     "ink-docstrap": "^1.3.2",
+    "ioredis": "^4.28.1",
     "jsdoc": "^3.6.7",
     "mocha": "*",
     "mocha-suppress-logs": "^0.3.1",

package/src/domain.js

@@ -4,7 +4,7 @@
  *
  */
 const EventEmitter = require('events');
-const {executeObjectFunction, objHas, firstLetterToUpper} = require('./common');
+const {isFunc,isAsync, objHas, firstLetterToUpper} = require('./common');
 
 const Env = require('./env');
 const
@@ -133,6 +133,17 @@ class notDomain extends EventEmitter {
     return null;
   }
 
+  /**
+   *  Returns form
+   *  @param   {string}  name   'formName' or 'moduleName//formName'
+   *                  ('login', 'not-user//login')
+   *  @return {object}        form
+   **/
+  getForm(name) {
+    const type = 'form';
+    return this.getByPath(name, type);
+  }
+
   /**
    *  Returns model
    *  @param   {string}  name   'modelName' or 'moduleName//modelName'
@@ -141,11 +152,7 @@ class notDomain extends EventEmitter {
    **/
   getModel(name) {
     const type = 'model';
-    if (name.indexOf('//') > 0) {
-      return this.getByFullPath(name, type);
-    } else {
-      return this.getByShortPath(name, type);
-    }
+    return this.getByPath(name, type);
   }
 
   getByFullPath(name, type){
@@ -169,31 +176,23 @@ class notDomain extends EventEmitter {
 
   /**
    *  Returns file with model declarations
-   *  @param {string}   modelName  'modelName' or 'moduleName//modelName'
+   *  @param {string}   name  'modelName' or 'moduleName//modelName'
    *  @return  {object}        CommonJS module object
    **/
-  getModelFile(modelName) {
+  getModelFile(name) {
     const type = 'modelFile';
-    if (modelName.indexOf('//') > 0) {
-      return this.getByFullPath(modelName, type);
-    } else {
-      return this.getByShortPath(modelName, type);
-    }
+    return this.getByPath(name, type);
   }
 
   /**
    *  Returns specified by name or 'moduleName//modelName' model Schema
-   *  @param {string} modelName  'modelName' or 'moduleName//modelName'
+   *  @param {string} name  'modelName' or 'moduleName//modelName'
    *  @return {object}       model schema
    **/
 
-  getModelSchema(modelName) {
+  getModelSchema(name) {
     const type = 'modelSchema';
-    if (modelName.indexOf('//') > 0) {
-      return this.getByFullPath(modelName, type);
-    } else {
-      return this.getByShortPath(modelName, type);
-    }
+    return this.getByPath(name, type);
   }
 
   /**
@@ -204,25 +203,25 @@ class notDomain extends EventEmitter {
    **/
   getLogic(name) {
     const type = 'logic';
-    if (name.indexOf('//') > 0) {
-      return this.getByFullPath(name, type);
-    } else {
-      return this.getByShortPath(name, type);
-    }
+    return this.getByPath(name, type);
   }
 
 
   /**
    *  Returns file with logic declarations
-   *  @param {string}   logicName  'logicName' or 'moduleName//logicName'
+   *  @param {string}   name  'logicName' or 'moduleName//logicName'
    *  @return  {object}        CommonJS module object
    **/
-  getLogicFile(logicName) {
+  getLogicFile(name) {
     const type = 'logicFile';
-    if (logicName.indexOf('//') > 0) {
-      return this.getByFullPath(logicName, type);
+    return this.getByPath(name, type);
+  }
+
+  getByPath(name, type){
+    if (name.indexOf('//') > 0) {
+      return this.getByFullPath(name, type);
     } else {
-      return this.getByShortPath(logicName, type);
+      return this.getByShortPath(name, type);
     }
   }
 
@@ -251,7 +250,13 @@ class notDomain extends EventEmitter {
   async execInModules(methodName) {
     for (let mod of Object.values(this.modules)) {
       try{
-        await executeObjectFunction(mod, 'exec', [methodName]);
+        if(isFunc(mod.exec)){
+          if(isAsync(mod.exec)){
+            await mod.exec(methodName);
+          }else{
+            mod.exec(methodName);
+          }
+        }
       }catch(e){
         this.report(e);
       }
@@ -397,6 +402,10 @@ class notDomain extends EventEmitter {
         count: 0,
         list: []
       },
+      forms: {
+        count: 0,
+        list: []
+      },
       actions: {
         count: 0,
         list: []
@@ -412,8 +421,9 @@ class notDomain extends EventEmitter {
       stats.modules.content[modName] = modStatus;
       stats.routes.count += modStatus.routes.count;
       stats.models.count += modStatus.models.count;
+      stats.forms.count += modStatus.forms.count;
       stats.actions.count += modStatus.actions.count;
-      for (let t of ['routes', 'models', 'actions']) {
+      for (let t of ['routes', 'models', 'actions', 'forms']) {
         stats[t].list.push(...(modStatus[t].list.map(itmName => `${modName}//${itmName}`)));
       }
     }

package/src/form/index.js

@@ -0,0 +1,78 @@
+//DB related validation tools
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+//not-node
+const initFields = require('../fields').initFields;
+const {
+  byFieldsValidators
+} = require('../model/enrich');
+const {
+  notValidationError,
+  notError
+} = require('not-error');
+
+/**
+ * Generic form validation class
+ **/
+module.exports = class Form {
+  constructor({
+    FIELDS,
+    FORM_NAME
+  }) {
+    this.FORM_NAME = FORM_NAME;
+    this.FIELDS = FIELDS;
+    this.SCHEMA = byFieldsValidators(initFields(FIELDS, 'model'));
+    this.MODEL = mongoose.model(FORM_NAME, Schema(this.SCHEMA));
+  }
+
+  /**
+   * Extract data from ExpressRequest object and validates it
+   * returns it or throws
+   * @param {ExpressRequest} req expressjs request object
+   * @return {Promise<Object>} form data
+   * @throws {notValidationError}
+   **/
+  async run(req) {
+    let data = await this.extract(req);
+    await this.validate(data);
+    return data;
+  }
+
+  /**
+   * Extracts data, should be overriden
+   * @param {ExpressRequest} req expressjs request object
+   * @return {Object}        forma data
+   **/
+  async extract( /*req*/ ) {
+    return {};
+  }
+
+  /**
+   * Validates form data or throws
+   * @param {Object} data    form data
+   * @return {Object}
+   * @throws {notValidationError}
+   **/
+  async validate(data) {
+    try {
+      await this.MODEL.validate(data, this.FIELDS);
+    } catch (e) {
+      let fields = {};
+      if (e instanceof mongoose.Error.ValidationError) {
+        Object.keys(e.errors).forEach(name => {
+          fields[name] = [e.errors[name].message];
+        });
+        throw new notValidationError(e.message, fields, e, data);
+      } else {
+        throw new notError(
+          'core:form_validation_error', {
+            FORM_NAME: this.FORM_NAME,
+            FIELDS: this.FIELDS,
+            data
+          },
+          e
+        );
+      }
+    }
+  }
+};

package/src/init/db/index.js

@@ -6,6 +6,7 @@ module.exports = class InitDB{
   static default = path.resolve(__dirname, './mongoose.js');
 
   static drivers = {
+    'ioredis':        path.resolve(__dirname, './ioredis.js'),
     'redis':        path.resolve(__dirname, './redis.js'),
     'mongoose':     path.resolve(__dirname, './mongoose.js')
   };
@@ -40,7 +41,7 @@ module.exports = class InitDB{
         master,
         config,
         options,
-        conf,
+        conf: conf[driver],
         alias: driver
       });
     }

package/src/init/db/ioredis.js

@@ -0,0 +1,24 @@
+const log = require('not-log')(module, 'not-node//init');
+const ADDS = require('../additional');
+
+module.exports = class InitDBRedisIO{
+
+  static async initRedis({ conf, master, alias}) {
+    log.info('Setting up ioredis connection...');
+    const Redis = require('ioredis');
+    const redisClient = new Redis(conf);
+    redisClient.on('error', log.error);
+    master.setEnv(`db.${alias}`, redisClient);
+    log.log('redis client');
+    log.log(Object.keys(redisClient));
+  }
+
+  async run({config, options, master, conf, alias}){
+    await ADDS.run(`db.${alias}.pre`, {config, options, master, conf, alias});
+    await InitDBRedisIO.initRedis({conf, master, alias});
+    await ADDS.run(`db.${alias}.post`, {config, options, master, conf, alias});
+  }
+
+
+
+};

package/src/init/db/mongoose.js

@@ -28,6 +28,7 @@ module.exports = class InitDBMongoose{
   }
 
   async run({config, options, master, conf, alias}){
+    log.info(`db.${alias}.pre`);
     await ADDS.run(`db.${alias}.pre`, {config, options, master, conf, alias});
     await InitDBMongoose.initMongoose({conf, master, alias});
     await ADDS.run(`db.${alias}.post`, {config, options, master, conf, alias});

package/src/init/index.js

@@ -1,4 +1,5 @@
 //
+const os = require('os');
 const path = require('path');
 const logger = require('not-log');
 const log = logger(module, 'not-node:Init');
@@ -80,7 +81,7 @@ class Init {
   }
 
   static getEnv(key) {
-    return Env.setEnv(key);
+    return Env.getEnv(key);
   }
 
   static getApp() {
@@ -126,7 +127,7 @@ class Init {
     additional
   }) {
     try {
-      log.info('Kick start app...');
+      log.info('Kick start app...'+ os.platform()+os.arch());
       ADDS.init(additional);
       const initSequence = new InitSequence(STANDART_INIT_SEQUENCE);
       await ADDS.run('pre', {
@@ -149,6 +150,11 @@ class Init {
       };
       //running all prepared initalizers with current context
       await initSequence.run(context);
+      await ADDS.run('post', {
+        config,
+        options,
+        manifest
+      });
       log.info('Application initalization finished');
     } catch (e) {
       Init.throwError(e.message, 1);

package/src/init/middleware.js

@@ -18,7 +18,9 @@ module.exports = class InitMiddleware{
         } else {
           proc = require(warePath);
         }
-        master.getServer().use(proc);
+        if(typeof proc === 'function'){
+          master.getServer().use(proc);
+        }
       }
     }
     await ADDS.run('middleware.post', {config, options, master});

package/src/init/rateLimiter.js

@@ -29,7 +29,7 @@ module.exports = class InitRateLimiter{
     return new RateLimiterRedis({
       storeClient:  master.getEnv('db.redis'),
       keyPrefix:    'middleware',
-      points:       10,     // 10 requests
+      points:       100,     // 10 requests
       duration:     1,    // per 1 second by IP
     });
   }

package/src/init/routes.js

@@ -2,49 +2,73 @@
 
 const serveStatic = require('serve-static');
 const log = require('not-log')(module, 'not-node//init');
-const {notError, notRequestError} = require('not-error');
+const {
+  notError,
+  notValidationError,
+  notRequestError
+} = require('not-error');
 
 module.exports = class InitRoutes {
 
-  static finalError({master}){
-    return (err, req, res) => {
-      if(err instanceof notError){
+  static finalError({
+    master
+  }) {
+    return (err, req, res, next) => {
+      //reportable errors from known cases
+      if (err instanceof notError) {
         master.getApp().report(err);
-        if(err instanceof notRequestError){
-          if(err.getRedirect()){
-            res.redirect(err.getRedirect());
-          }else{
-
-            res.status(err.getCode()).json({
+        //if request params - ok, but result is not
+        if (err instanceof notRequestError) {
+          if (err.getRedirect()) {
+            return res.redirect(err.getRedirect());
+          } else {
+            return res.status(err.getCode()).json({
               status: 'error',
-              error: err.getResult().message,
+              message: err.getResult().message,
               errors: err.getResult().errors
             });
           }
+          //bad request params
+        }else if (err instanceof notValidationError){
+          return res.status(400).json({
+            status: 'error',
+            message:  err.message,
+            errors: err.getFieldsErrors()
+          });
         }
-      }else if (err instanceof Error && (res && res.status && res.json)){
+      }
+      //other cases
+      if (err instanceof Error && (res && res.status && res.json)) {
         res.status(err.statusCode || 500);
+        //reporting as unknown
         master.getApp().report(new notError(`Internal error(${res.statusCode}): %${req.url} - %${err.message}`, {}, err));
         res.json({
           status: 'error',
-          error: err.message
+          message: err.message
         });
-      }else{
+      } else {
         log.error('Unknown error:', err);
         res.status(500).json({
           status: 'error'
         });
       }
+      next();
     };
   }
 
-  async run({master, config, options}) {
+  async run({
+    master,
+    config,
+    options
+  }) {
     log.info('Setting up routes...');
     master.getApp().expose(master.getServer());
     require(options.routesPath)(master.getServer(), master.getApp());
-    master.getApp().use(serveStatic(config.get('staticPath')));
-    master.getApp().use(options.indexRoute);
-    master.getApp().use(InitRoutes.finalError({master}));
+    master.getServer().use(serveStatic(config.get('staticPath')));
+    master.getServer().use(options.indexRoute);
+    master.getServer().use(InitRoutes.finalError({
+      master
+    }));
   }
 
 };

package/src/init/sessions/mongoose.js

@@ -5,7 +5,7 @@ const ADDS = require('../additional');
 module.exports = class InitSessionsMongo{
   static createStore({config, master, expressSession}){
     const MongoDBStore = require('connect-mongodb-session')(expressSession);
-    const mongooseOptions = config.get('mongoose.options');
+    const mongooseOptions = config.get('db.mongoose.options');
     let store = new MongoDBStore({
       uri: `mongodb://${mongooseOptions.user}:${mongooseOptions.pass}@${mongooseOptions.host}/${mongooseOptions.db}`,
       databaseName: mongooseOptions.db,

package/src/manifest/module.js

@@ -47,6 +47,7 @@ class notModule {
     };
     this.models = {};
     this.logics = {};
+    this.forms = {};
     this.manifests = {};
     this.faulty = false;
     this.paths = {
@@ -164,7 +165,6 @@ class notModule {
     }
   }
 
-
   getModelSchema(modelName) {
     let modelFile = this.getModelFile(modelName);
     if (modelFile && objHas(modelFile, modelName) && modelFile.thisSchema) {
@@ -221,10 +221,15 @@ class notModule {
   }
 
   getStatus() {
+    const formsList = Object.keys(this.forms);
     const modelsList = Object.keys(this.models);
     const routesList = Object.keys(this.routes);
     const actionsList = this.getActionsList();
     return {
+      forms: {
+        count: formsList.length,
+        list: formsList
+      },
       models: {
         count: modelsList.length,
         list: modelsList,
@@ -272,11 +277,18 @@ class notModule {
     return content;
   }
 
-
   setManifest(key, val){
     this.manifests[key] = val;
   }
 
+  getForm(key) {
+    return this.forms[key];
+  }
+
+  setForm(key, val) {
+    this.forms[key] = val;
+  }
+
   setModel(key, val){
     this.models[key] = val;
   }
@@ -285,6 +297,10 @@ class notModule {
     this.routes[key] = val;
   }
 
+  setLogic(key, val){
+    this.logics[key] = val;
+  }
+
   getRoute(routeName) {
     if (this.routes && objHas(this.routes, routeName)) {
       return this.routes[routeName];

package/src/manifest/registrator/forms.js

@@ -0,0 +1,48 @@
+const path = require('path');
+const fs = require('fs');
+const {tryFile} = require('../../common');
+
+module.exports = class notModuleRegistratorForms{
+
+  static openFile = require;
+  
+  constructor({nModule}){
+    this.run({nModule});
+  }
+
+  run({nModule}){
+    const srcDir = notModuleRegistratorForms.getPath(nModule);
+    if (!srcDir) { return false; }
+    this.findAll(
+      {
+        nModule,
+        srcDir
+      }
+    );
+    return true;
+  }
+
+  static getPath(nModule){
+    return nModule.module.paths.forms;
+  }
+
+  /**
+  * Searching forms in directory
+  * @param {Object}     input
+  * @param {string}     input.srcDir
+  **/
+  findAll({nModule, srcDir}){
+    fs.readdirSync(srcDir).forEach((file) => {
+      let fromPath = path.join(srcDir, file);
+      if (!tryFile(fromPath)) { return; }
+      this.register({nModule, fromPath});
+    });
+  }
+
+  register({nModule, fromPath}){
+    const Form = notModuleRegistratorForms.openFile(fromPath);
+    const parts = path.parse(fromPath);
+    nModule.setForm(parts.name, new Form());
+  }
+
+};

package/src/manifest/registrator/index.js

@@ -5,6 +5,7 @@
 
 const
   notModuleRegistratorFields = require('./fields'),
+  notModuleRegistratorForms = require('./forms'),
   notModuleRegistratorModels = require('./models'),
   notModuleRegistratorLogics = require('./logics'),
   notModuleRegistratorRoutes = require('./routes'),
@@ -13,6 +14,7 @@ const
 
 const DEFAULT_REGISTRATORS = [
   notModuleRegistratorFields,
+  notModuleRegistratorForms,
   notModuleRegistratorModels,
   notModuleRegistratorLogics,
   notModuleRegistratorRoutes,

package/src/manifest/registrator/routes.js

@@ -167,7 +167,7 @@ module.exports = class notModuleRegistratorRoutes{
     });
   }
 
-  static registerManifest({nModule, manifest, routeName}) {
-    nModule.setManifest(routeName, manifest);
+  static registerManifest({nModule, routeManifest, routeName}) {
+    nModule.setManifest(routeName, routeManifest);
   }
 };

package/src/manifest/route.js

@@ -133,11 +133,41 @@ class notRoute{
     );
   }
 
+  extractReturn(notRouteData){
+    if(objHas(notRouteData.rule, 'return')){
+      return [...notRouteData.rule.return];
+    }else if(objHas(notRouteData.actionData, 'return')){
+      return [...notRouteData.actionData.return];
+    }else{
+      return undefined;
+    }
+  }
+
+  /**
+  * Removes fields from result object acctoding to actionData.return array
+  * if presented
+  * @param {ExpressRequest} req request object
+  * @param {object} result result returned by main action processor
+  */
+  filterResultByReturnRule(req, result){
+    const returnList = this.extractReturn(req.notRouteData);
+    if(result && (typeof result === 'object') && returnList && Array.isArray(returnList)){
+      let presented = Object.keys(result);
+      presented.forEach(fieldName => {
+        if(!returnList.includes(fieldName)){
+          delete result[fieldName];
+        }
+      });
+    }
+  }
+
   async executeRoute(modRoute, actionName, {req, res, next}){
     //waiting preparation
     let prepared = await this.executeFunction(modRoute, CONST_BEFORE_ACTION, [req, res, next]);
     //waiting results
     let result = await this.executeFunction(modRoute, actionName, [req, res, next, prepared]);
+    //filter result IF actionData.return specified
+    this.filterResultByReturnRule(req, result);
     //run after with results, continue without waiting when it finished
     return this.executeFunction(modRoute, CONST_AFTER_ACTION, [req, res, next, result]);
   }

package/src/model/proto.js

@@ -54,10 +54,9 @@ module.exports = class ModelFabricate{
     if (targetModule.thisStatics) {
       Object.assign(schema.statics, targetModule.thisStatics);
     }
-    this.extendSchemaFrom(targetModule.thisVirtuals, schema.virtual);
-    this.extendSchemaFrom(targetModule.thisPre, schema.pre);
-    this.extendSchemaFrom(targetModule.thisPost, schema.post);
-
+    this.extendSchemaFrom(targetModule.thisVirtuals, schema.virtual.bind(schema));
+    this.extendSchemaFrom(targetModule.thisPre, schema.pre.bind(schema));
+    this.extendSchemaFrom(targetModule.thisPost, schema.post.bind(schema));
   }
 
   static enrichByFields(targetModule){

package/test/init/routes.js

@@ -17,7 +17,7 @@ module.exports = ({expect})=>{
           json(dat){
             expect(dat).to.be.deep.equal({
               status: 'error',
-              error: 'Serious generic error'
+              message: 'Serious generic error'
             });
             done();
           }
@@ -120,7 +120,7 @@ module.exports = ({expect})=>{
           json(dat){
             expect(dat).to.be.deep.equal({
               status: 'error',
-              error:  'Serious not error request',
+              message:  'Serious not error request',
               errors:  {field: ['name']},
             });
             done();
@@ -142,8 +142,10 @@ module.exports = ({expect})=>{
 
 
     describe('run', ()=>{
-      it('', async ()=>{
-        const fakeServer = { sarver: true};
+      it('run', async ()=>{
+        const fakeServer = { sarver: true, use(fn){
+          expect(typeof fn).to.be.equal('function');
+        }};
         const fakeApp = {
           report(){},
           use(fn){

package/test/module/index.js

@@ -22,7 +22,7 @@ module.exports = (input)=>{
       notModuleRegistrator.setRegistrators(regs);
       expect(notModuleRegistrator.registrators.length).to.be.equal(0);
       notModuleRegistrator.resetRegistrators();
-      expect(notModuleRegistrator.registrators.length).to.be.equal(5);
+      expect(notModuleRegistrator.registrators.length).to.be.equal(6);
     });
 
     it('with paths', ()=>{

package/test/notDomain.js

@@ -184,7 +184,7 @@ describe('notDomain', function() {
     it('model name short', function() {
       const route = 'Jungle';
       const ctx = {
-        getByShortPath(){return null;}
+        getByPath(){return null;}
       };
       const res = notDomain.prototype.getModel.call(ctx, route);
       expect(res).to.be.null;
@@ -194,7 +194,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'module//Jungle';
       const ctx = {
-        getByFullPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getModel.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -206,7 +206,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'Jungle';
       const ctx = {
-        getByShortPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getModelFile.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -216,7 +216,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'module//Jungle';
       const ctx = {
-        getByFullPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getModelFile.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -229,7 +229,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'Jungle';
       const ctx = {
-        getByShortPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getModelSchema.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -239,7 +239,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'module//Jungle';
       const ctx = {
-        getByFullPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getModelSchema.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -252,7 +252,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'Jungle';
       const ctx = {
-        getByShortPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getLogic.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -262,7 +262,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'module//Jungle';
       const ctx = {
-        getByFullPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getLogic.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -274,7 +274,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'Jungle';
       const ctx = {
-        getByShortPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getLogicFile.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -284,7 +284,7 @@ describe('notDomain', function() {
       const id = Math.random();
       const route = 'module//Jungle';
       const ctx = {
-        getByFullPath(){return id;}
+        getByPath(){return id;}
       };
       const res = notDomain.prototype.getLogicFile.call(ctx, route);
       expect(res).to.be.equal(id);
@@ -711,6 +711,10 @@ describe('notDomain', function() {
                 actions: {
                   count: 2,
                   list: ['user//list', 'role//list']
+                },
+                forms: {
+                  count: 3,
+                  list: ['user//listAll', 'user//list', 'role//list']
                 }
               };
             }
@@ -737,10 +741,18 @@ describe('notDomain', function() {
               actions: {
                 count: 2,
                 list: ['user//list', 'role//list']
+              },
+              forms: {
+                count: 3,
+                list: ['user//listAll', 'user//list', 'role//list']
               }
             }
           }
         },
+        forms: {
+          count: 3,
+          list: ['not-user//user//listAll', 'not-user//user//list', 'not-user//role//list']
+        },
         routes: {
           count: 2,
           list: ["not-user//user","not-user//role"]

package/test/notInit.js

@@ -7,9 +7,10 @@ describe('initialization', function() {
   describe('notInit', ()=>{
     describe('getAbsolutePath', ()=>{
       it('all set', ()=>{
-        const res = Init.getAbsolutePath('../src/index', {
+        Init.options = {
           pathToApp: '/home/admin/server/test'
-        });
+        };
+        const res = Init.getAbsolutePath('../src/index', );
         expect(res).to.be.equal('/home/admin/server/src/index');
       });
     });

package/test/notModule.js

@@ -468,6 +468,9 @@ describe('notModule', function() {
         routes: {
           userRoute: {}
         },
+        forms: {
+          'route//action':{}
+        },
         getModelsStatuses() {
           return {
             user: {
@@ -505,6 +508,10 @@ describe('notModule', function() {
         actions: {
           count: 1,
           list: ['route//action']
+        },
+        forms: {
+          count: 1,
+          list: ['route//action']
         }
       });
     });