fixed container issues

Author: DavertMik

lib/actor.js

@@ -70,29 +70,11 @@ class Actor {
  * @ignore
  */
 module.exports = function (obj = {}) {
-  if (!store.actor) {
-    store.actor = new Actor()
-  }
-  const actor = store.actor
-
-  const translation = container.translation()
-
-  if (Object.keys(obj).length > 0) {
-    Object.keys(obj).forEach((action) => {
-      const actionAlias = translation.actionAliasFor(action)
-
-      const currentMethod = obj[action]
-      const ms = new MetaStep('I', action)
-      if (translation.loaded) {
-        ms.name = actionAlias
-        ms.actor = translation.I
-      }
-      ms.setContext(actor)
-      actor[action] = actor[actionAlias] = ms.run.bind(ms, currentMethod)
-    })
-  }
+  const actor = container.actor() || new Actor()
 
-  container.started().then(() => {
+  // load all helpers once container initialized
+  container.started(() => {
+    const translation = container.translation()
     const helpers = container.helpers()
 
     // add methods from enabled helpers
@@ -114,8 +96,33 @@ module.exports = function (obj = {}) {
           }
         })
     })
+
+    // add translated custom steps from actor
+    Object.keys(obj).forEach((key) => {
+      const actionAlias = translation.actionAliasFor(key)
+      if (!actor[actionAlias]) {
+        actor[actionAlias] = actor[key]
+      }
+    })
+
+    store.actor = actor
+    container.append({
+      support: {
+        [translation.I]: actor,
+        I: actor,
+      },
+    })
   })
 
+  // add custom steps from actor
+  Object.keys(obj).forEach((key) => {
+    const ms = new MetaStep('I', key)
+    ms.setContext(actor)
+    actor[key] = ms.run.bind(ms, obj[key])
+  })
+
+  // store.actor = actor;
+
   return actor
 }
 

lib/codecept.js

@@ -185,6 +185,8 @@ class Codecept {
    * @returns {Promise<void>}
    */
   async run(test) {
+    await container.started()
+
     return new Promise((resolve, reject) => {
       const mocha = container.mocha()
       mocha.files = this.testFiles

lib/command/workers/runTests.js

@@ -39,13 +39,14 @@ const codecept = new Codecept(config, options)
 codecept.init(testRoot)
 codecept.loadTests()
 const mocha = container.mocha()
-filterTests()
+filterTests();
 
-;(async function () {
+// run tests
+(async function () {
   if (mocha.suite.total()) {
     await runTests()
   }
-})()
+})();
 
 async function runTests() {
   try {

lib/container.js

@@ -1,8 +1,7 @@
 const glob = require('glob')
 const path = require('path')
-const { isPromise } = require('util/types')
 const { MetaStep } = require('./step')
-const { fileExists, isFunction, isAsyncFunction, installedLocally } = require('./utils')
+const { methodsOfObject, fileExists, isFunction, isAsyncFunction, installedLocally } = require('./utils')
 const Translation = require('./translation')
 const MochaFactory = require('./mochaFactory')
 const recorder = require('./recorder')
@@ -11,12 +10,13 @@ const WorkerStorage = require('./workerStorage')
 const store = require('./store')
 const ai = require('./ai')
 
-let asyncHelperPromise = Promise.resolve()
+let asyncHelperPromise
 
 let container = {
   helpers: {},
   support: {},
   plugins: {},
+  actor: null,
   /**
    * @type {Mocha | {}}
    * @ignore
@@ -37,24 +37,25 @@ class Container {
    * @param {*} opts
    */
   static create(config, opts) {
-    const mochaConfig = config.mocha || {}
-    if (config.grep && !opts.grep) {
-      mochaConfig.grep = config.grep
-    }
-    this.createMocha = () => {
-      container.mocha = MochaFactory.create(mochaConfig, opts || {})
-    }
-    this.createMocha()
+    asyncHelperPromise = Promise.resolve()
+
     container.helpers = createHelpers(config.helpers || {})
     container.translation = loadTranslation(config.translation || null, config.vocabularies || [])
     container.support = createSupportObjects(config.include || {})
     container.plugins = createPlugins(config.plugins || {}, opts)
 
+    createMocha(config, opts)
+    createActor()
+
     if (opts && opts.ai) ai.enable(config.ai) // enable AI Assistant
     if (config.gherkin) loadGherkinSteps(config.gherkin.steps || [])
     if (opts && typeof opts.timeouts === 'boolean') store.timeouts = opts.timeouts
   }
 
+  static actor() {
+    return container.actor
+  }
+
   /**
    * Get all plugins
    *
@@ -125,6 +126,7 @@ class Container {
   static append(newContainer) {
     const deepMerge = require('./utils').deepMerge
     container = deepMerge(container, newContainer)
+    container.actor = container.support.I
   }
 
   /**
@@ -139,9 +141,14 @@ class Container {
     container.support = newSupport || {}
     container.plugins = newPlugins || {}
     container.translation = loadTranslation()
+    asyncHelperPromise = Promise.resolve()
+    store.actor = null
   }
 
-  static async started() {
+  static async started(fn = null) {
+    if (fn) {
+      asyncHelperPromise = asyncHelperPromise.then(fn)
+    }
     return asyncHelperPromise
   }
 
@@ -259,14 +266,6 @@ function createSupportObjects(config) {
     objects[name] = {} // placeholders
   }
 
-  if (!config.I) {
-    objects.I = require('./actor')()
-
-    if (container.translation.I !== 'I') {
-      objects[container.translation.I] = objects.I
-    }
-  }
-
   container.support = objects
 
   function lazyLoad(name) {
@@ -361,6 +360,14 @@ function createPlugins(config, options = {}) {
   return plugins
 }
 
+function createActor() {
+  const actor = require('./actor')
+  container.support.I = container.support.I || actor()
+
+  container.actor = container.support.I
+  if (container.translation.I !== 'I') container.support[container.translation.I] = container.actor
+}
+
 function getSupportObject(config, name) {
   const module = config[name]
   if (typeof module === 'string') {
@@ -399,23 +406,12 @@ function loadSupportObject(modulePath, supportObjectName) {
   if (modulePath.charAt(0) === '.') {
     modulePath = path.join(global.codecept_dir, modulePath)
   }
+
   try {
     const obj = require(modulePath)
 
-    if (typeof obj === 'function') {
-      const fobj = obj()
-
-      if (fobj.constructor.name === 'Actor') {
-        const methods = getObjectMethods(fobj)
-        Object.keys(methods).forEach((key) => {
-          fobj[key] = methods[key]
-        })
-
-        return methods
-      }
-    }
     if (typeof obj !== 'function' && Object.getPrototypeOf(obj) !== Object.prototype && !Array.isArray(obj)) {
-      const methods = getObjectMethods(obj)
+      const methods = methodsOfObject(obj)
       Object.keys(methods)
         .filter((key) => !key.startsWith('_'))
         .forEach((key) => {
@@ -452,22 +448,6 @@ function loadSupportObject(modulePath, supportObjectName) {
 /**
  * Method collect own property and prototype
  */
-function getObjectMethods(obj) {
-  const methodsSet = new Set()
-  let protoObj = Reflect.getPrototypeOf(obj)
-  do {
-    if (protoObj.constructor.prototype !== Object.prototype) {
-      const keys = Reflect.ownKeys(protoObj)
-      keys.forEach((k) => methodsSet.add(k))
-    }
-  } while ((protoObj = Reflect.getPrototypeOf(protoObj)))
-  Reflect.ownKeys(obj).forEach((k) => methodsSet.add(k))
-  const methods = {}
-  for (const key of methodsSet.keys()) {
-    if (key !== 'constructor') methods[key] = obj[key]
-  }
-  return methods
-}
 
 function loadTranslation(locale, vocabularies) {
   if (!locale) {
@@ -509,3 +489,11 @@ function getHelperModuleName(helperName, config) {
   // built-in helpers
   return `./helper/${helperName}`
 }
+
+function createMocha(config, opts) {
+  const mochaConfig = config.mocha || {}
+  if (config.grep && !opts.grep) {
+    mochaConfig.grep = config.grep
+  }
+  container.mocha = MochaFactory.create(mochaConfig, opts || {})
+}

lib/interfaces/inject.js

@@ -0,0 +1,24 @@
+const parser = require('../parser')
+
+const getInjectedArguments = (fn, test) => {
+  const container = require('../container')
+  const testArgs = {}
+  const params = parser.getParams(fn) || []
+  const objects = container.support()
+  for (const key of params) {
+    testArgs[key] = {}
+    if (test && test.inject && test.inject[key]) {
+      // @FIX: need fix got inject
+      testArgs[key] = test.inject[key]
+      continue
+    }
+    if (!objects[key]) {
+      throw new Error(`Object of type ${key} is not defined in container`)
+    }
+    testArgs[key] = container.support(key)
+  }
+
+  return testArgs
+}
+
+module.exports.getInjectedArguments = getInjectedArguments