oxygen-cli 1.22.0 → 1.99.0-alpha.0

package/build/lib/parallel-launcher.js

@@ -0,0 +1,333 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("source-map-support/register");
+
+var Runners = _interopRequireWildcard(require("../runners"));
+
+var _parallelLimit = _interopRequireDefault(require("async/parallelLimit"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var Duration = require('duration');
+
+const PARALLEL_COUNT = 50;
+
+class ParallelLauncher {
+  constructor(config, reporter) {
+    this._config = config;
+    this.reporter = reporter;
+    this._queue = null;
+    this._activeThreads = 0;
+    this.runners = [];
+    this.createdRunnersStat = [];
+  }
+
+  async run(capsSet) {
+    const collection = [];
+
+    if (!this._config.parallel) {
+      throw new Error('Cannot start the parallel testing - "parallel" settings are missing.');
+    }
+
+    const concurrency = !isNaN(this._config.parallel.concurrency) ? this._config.parallel.concurrency : 1;
+    const suites = this._config.suites;
+
+    if (!suites || !Array.isArray(suites)) {
+      throw new Error('Cannot start the parallel testing - no suites are defined.');
+    }
+
+    let workersConfig = [];
+    const testCaps = capsSet ? Array.isArray(capsSet) ? capsSet[0] : capsSet : null;
+    let suiteIndex = 0;
+    suites.forEach(suiteDef => {
+      const suiteKey = suiteDef.key || suiteDef.id || suiteDef.name;
+
+      if (concurrency == 0) {
+        if (suiteDef.paramManager) {
+          for (let i = 0; i < suiteDef.paramManager.rows; i++) {
+            const mockParamManager = new ParamManagerMock(suiteDef.paramManager.getValues());
+            suiteDef.paramManager.readNext();
+            const workerId = `${suiteKey}-${suiteIndex}/${i}`;
+            const suiteCopy = { ...suiteDef,
+              iterationCount: 1,
+              paramManager: mockParamManager
+            };
+            const testConfig = { ...this._config,
+              suites: [suiteCopy],
+              _groupResult: {
+                suiteKey: suiteKey,
+                _meta: {
+                  suiteIterationNum: i + 1
+                }
+              }
+            };
+            workersConfig.push({
+              workerId,
+              testConfig,
+              testCaps,
+              startupDelay: 200
+            });
+            const self = this;
+            collection.push(function (callback) {
+              const cb = error => {
+                if (error) {
+                  callback(error, null);
+                }
+              };
+
+              self._launchTest({
+                workerId,
+                testConfig,
+                testCaps,
+                startupDelay: 200
+              }, cb).then(result => {
+                callback(null, result);
+              }).catch(error => {
+                callback(error, null);
+              });
+            });
+          }
+        } else {
+          const workerId = `${suiteKey}-${suiteIndex}`;
+          const suiteCopy = { ...suiteDef,
+            iterationCount: 1
+          };
+          const testConfig = { ...this._config,
+            suites: [suiteCopy],
+            _groupResult: {
+              suiteKey: suiteKey,
+              _meta: {
+                suiteIterationNum: 1
+              }
+            }
+          };
+          workersConfig.push({
+            workerId,
+            testConfig,
+            testCaps,
+            startupDelay: 200
+          });
+          const self = this;
+          collection.push(function (callback) {
+            const cb = error => {
+              if (error) {
+                callback(error, null);
+              }
+            };
+
+            self._launchTest({
+              workerId,
+              testConfig,
+              testCaps,
+              startupDelay: 200
+            }, cb).then(result => {
+              callback(null, result);
+            }).catch(error => {
+              callback(error, null);
+            });
+          });
+        }
+      } else if (concurrency == 0 && Array.isArray(suiteDef.cases)) {
+        let caseIndex = 0;
+        suiteDef.cases.forEach(caseDef => {
+          const caseKey = caseDef.key || caseDef.id || caseDef.name;
+
+          if (caseDef.paramManager) {
+            for (let i = 0; i < caseDef.paramManager.rows; i++) {
+              const mockParamManager = new ParamManagerMock(caseDef.paramManager.getValues());
+              caseDef.paramManager.readNext();
+              const workerId = `${caseKey}-${suiteIndex}/${caseIndex}/${i}`;
+              const caseCopy = { ...caseDef,
+                iterationCount: 1,
+                paramManager: mockParamManager
+              };
+              const suiteCopy = { ...suiteDef,
+                cases: [caseCopy]
+              };
+              const testConfig = { ...this._config,
+                suites: [suiteCopy],
+                _groupResult: {
+                  suiteKey: suiteKey,
+                  caseKey: caseKey,
+                  _meta: {
+                    caseIterationNum: i + 1
+                  }
+                }
+              };
+              workersConfig.push({
+                workerId,
+                testConfig,
+                testCaps,
+                startupDelay: 0
+              });
+            }
+          } else {
+            const workerId = `${caseKey}-${suiteIndex}/${caseIndex}`;
+            const suiteCopy = { ...suiteDef,
+              cases: [caseDef]
+            };
+            const testConfig = { ...this._config,
+              suites: [suiteCopy]
+            };
+            workersConfig.push({
+              workerId,
+              testConfig,
+              testCaps,
+              startupDelay: 0
+            });
+          }
+
+          caseIndex++;
+        });
+      } else {
+        const suiteKey = suiteDef.key || suiteDef.id || suiteDef.name;
+        const workerId = `${suiteKey}-${suiteIndex}`;
+        const testConfig = { ...this._config,
+          suites: [suiteDef]
+        };
+        workersConfig.push({
+          workerId,
+          testConfig,
+          testCaps,
+          startupDelay: 0
+        });
+      }
+
+      suiteIndex++;
+    });
+    this.reporter.onBeforeStart(collection.length);
+    console.log('Collections length', collection.length);
+    const start = new Date();
+    await (0, _parallelLimit.default)(collection, PARALLEL_COUNT);
+    let total = 0;
+    console.log('Created Runners Stat', this.createdRunnersStat);
+    const runnersIds = Object.keys(this.createdRunnersStat);
+    console.log('Created Runners count', runnersIds.length);
+    runnersIds.map(item => {
+      const cazes = this.createdRunnersStat[item].length;
+      total += cazes;
+      console.log('Runner', item, ' run ', cazes, ' cases');
+    });
+    console.log('Parallel count', PARALLEL_COUNT);
+    console.log('Total: ', total);
+    const end = new Date();
+    const duration = new Duration(start, end);
+    console.log('Duration: ', duration.toString(1));
+    this.reporter.onAfterEnd();
+  }
+
+  _instantiateRunner() {
+    if (this._config.framework && typeof this._config.framework === 'string') {
+      if (Object.prototype.hasOwnProperty.call(Runners, this._config.framework)) {
+        return new Runners[this._config.framework]();
+      }
+
+      return null;
+    }
+
+    return new Runners.oxygen();
+  }
+
+  async _launchTest({
+    workerId,
+    testConfig,
+    testCaps,
+    startupDelay
+  }, callback) {
+    if (!callback) {
+      return;
+    }
+
+    await this._sleep(startupDelay);
+    this._activeThreads++;
+    let runner;
+
+    if (PARALLEL_COUNT <= this.runners.length) {
+      runner = this.runners.shift();
+      let arr = this.createdRunnersStat[runner._id];
+      let newArray;
+
+      if (Array.isArray(arr)) {
+        newArray = [...arr, workerId];
+      } else {
+        newArray = [workerId];
+      }
+
+      this.createdRunnersStat[runner._id] = newArray;
+    } else {
+      runner = this._instantiateRunner();
+      this.createdRunnersStat[runner._id] = [workerId];
+    }
+
+    if (!runner) {
+      const framework = this._config.framework;
+      callback(new Error(`Cannot find runner for the specified framework: ${framework}.`));
+      return;
+    }
+
+    try {
+      await runner.init(testConfig, testCaps, this.reporter);
+      const result = await runner.run();
+      await runner.dispose(result.status || null);
+      callback();
+    } catch (e) {
+      console.error('Failed to launch the test:', e);
+
+      if (this._queue) {
+        this._queue.kill();
+      }
+
+      if (e.error) {
+        var errMsg = '';
+        var err = e.error;
+        if (err.type) errMsg += err.type + ' - ';
+        if (err.message) errMsg += err.message;else errMsg = err.toString();
+        callback(new Error(errMsg));
+      } else {
+        callback(e);
+      }
+    }
+
+    this.runners.push(runner);
+  }
+
+  _sleep(duration) {
+    return new Promise(resolve => setTimeout(resolve, duration));
+  }
+
+}
+
+exports.default = ParallelLauncher;
+
+class ParamManagerMock {
+  constructor(values) {
+    this.values = values;
+  }
+
+  init() {}
+
+  getMode() {}
+
+  readNext() {}
+
+  readPrev() {}
+
+  getValues() {
+    return this.values;
+  }
+
+  get rows() {
+    return 1;
+  }
+
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/lib/parallel-launcher.js"],"names":["Duration","require","PARALLEL_COUNT","ParallelLauncher","constructor","config","reporter","_config","_queue","_activeThreads","runners","createdRunnersStat","run","capsSet","collection","parallel","Error","concurrency","isNaN","suites","Array","isArray","workersConfig","testCaps","suiteIndex","forEach","suiteDef","suiteKey","key","id","name","paramManager","i","rows","mockParamManager","ParamManagerMock","getValues","readNext","workerId","suiteCopy","iterationCount","testConfig","_groupResult","_meta","suiteIterationNum","push","startupDelay","self","callback","cb","error","_launchTest","then","result","catch","cases","caseIndex","caseDef","caseKey","caseCopy","caseIterationNum","onBeforeStart","length","console","log","start","Date","total","runnersIds","Object","keys","map","item","cazes","end","duration","toString","onAfterEnd","_instantiateRunner","framework","prototype","hasOwnProperty","call","Runners","oxygen","_sleep","runner","shift","arr","_id","newArray","init","dispose","status","e","kill","errMsg","err","type","message","Promise","resolve","setTimeout","values","getMode","readPrev"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n// import _ from 'lodash';\r\nimport * as Runners from '../runners';\r\n// import queue from 'async/queue';\r\nimport parallelLimit from 'async/parallelLimit';\r\n// import { parseUrlEncoded } from 'chrome-har/lib/util';\r\n// import oxutil from './util';\r\nvar Duration = require('duration');\r\n// const SCOPE_SUITE = 'suite';\r\n// const SCOPE_CASE = 'case';\r\n\r\nconst PARALLEL_COUNT = 50;\r\n\r\nexport default class ParallelLauncher {\r\n    constructor(config, reporter) {\r\n        this._config = config;\r\n        this.reporter = reporter;\r\n        this._queue = null;\r\n        this._activeThreads = 0;\r\n        this.runners = [];\r\n        this.createdRunnersStat = [];\r\n    }\r\n\r\n    async run(capsSet) {\r\n        const collection = [];\r\n        // console.log('~~this._config', JSON.stringify(this._config, null, 2));\r\n        // console.log('~~capsSet', capsSet);\r\n\r\n        if (!this._config.parallel) {\r\n            throw new Error('Cannot start the parallel testing - \"parallel\" settings are missing.');\r\n        }\r\n        const concurrency = !isNaN(this._config.parallel.concurrency) ? this._config.parallel.concurrency : 1;\r\n        // const scope = this._config.parallel.scope;\r\n        // flatten all suites and create one unified array of all the test cases\r\n        const suites = this._config.suites;\r\n        if (!suites || !Array.isArray(suites)) {\r\n            throw new Error('Cannot start the parallel testing - no suites are defined.');\r\n        }\r\n        let workersConfig = [];\r\n        // let workersCount = concurrency;\r\n        // if no capabilities are specified, run single instance with default arguments\r\n        // alternatively, pick the first capabilities set (load test is limited to a single browser type)\r\n        const testCaps = capsSet ? (Array.isArray(capsSet) ? capsSet[0] : capsSet) : null;\r\n        // if concurrency set to max and parameter file is defined, \r\n        // then run as many parallel tests as rows in the file\r\n        let suiteIndex = 0;\r\n\r\n        suites.forEach(suiteDef => {\r\n\r\n            // console.log('~~suiteDef', suiteDef);\r\n            // console.log('~~suiteDef.paramManager', suiteDef.paramManager);\r\n            // console.log('~~concurrency', concurrency);\r\n\r\n            const suiteKey = suiteDef.key || suiteDef.id || suiteDef.name;\r\n            if (concurrency == 0) {\r\n                // console.log('~~if');\r\n                // console.log('~~suiteDef.paramManager.rows', suiteDef.paramManager.rows);\r\n                if (suiteDef.paramManager) {\r\n                    for (let i = 0; i < suiteDef.paramManager.rows; i++) {\r\n                        const mockParamManager = new ParamManagerMock(suiteDef.paramManager.getValues());\r\n                        suiteDef.paramManager.readNext();\r\n                        const workerId = `${suiteKey}-${suiteIndex}/${i}`;\r\n                        const suiteCopy = { ...suiteDef, iterationCount: 1, paramManager: mockParamManager };\r\n                        const testConfig = {\r\n                            ...this._config, suites: [ suiteCopy ],\r\n                            _groupResult: {\r\n                                suiteKey: suiteKey,\r\n                                _meta: { suiteIterationNum: i + 1 }\r\n                            }\r\n                        };\r\n                        workersConfig.push({ workerId, testConfig, testCaps, startupDelay: 200 });\r\n\r\n                        const self = this;\r\n                        collection.push(function(callback) {\r\n                            const cb = (error) => {\r\n                                if (error) {\r\n                                    // console.log('~~cb error', error);\r\n                                    callback(error, null);\r\n                                }\r\n                            };\r\n                            self._launchTest({ workerId, testConfig, testCaps, startupDelay: 200 }, cb).then((result) => {\r\n                                callback(null, result);\r\n                            }).catch(error => {\r\n                                callback(error, null);\r\n                            });\r\n                        });\r\n\r\n                        // workersCount++;\r\n                    }\r\n                } else {\r\n                    const workerId = `${suiteKey}-${suiteIndex}`;\r\n                    const suiteCopy = { ...suiteDef, iterationCount: 1 };\r\n                    const testConfig = {\r\n                        ...this._config, suites: [ suiteCopy ],\r\n                        _groupResult: {\r\n                            suiteKey: suiteKey,\r\n                            _meta: { suiteIterationNum: 1 }\r\n                        }\r\n                    };\r\n                    workersConfig.push({ workerId, testConfig, testCaps, startupDelay: 200 });\r\n                    const self = this;\r\n                    collection.push(function(callback) {\r\n                        const cb = (error) => {\r\n                            if (error) {\r\n                                // console.log('~~cb error', error);\r\n                                callback(error, null);\r\n                            }\r\n                        };\r\n                        self._launchTest({ workerId, testConfig, testCaps, startupDelay: 200 }, cb).then((result) => {\r\n                            callback(null, result);\r\n                        }).catch(error => {\r\n                            callback(error, null);\r\n                        });\r\n                    });\r\n                }\r\n            }\r\n            // check if any of cases have param file attached\r\n            else if (concurrency == 0 && Array.isArray(suiteDef.cases)) {\r\n                let caseIndex = 0;\r\n                suiteDef.cases.forEach(caseDef => {\r\n                    const caseKey = caseDef.key || caseDef.id || caseDef.name;\r\n                    if (caseDef.paramManager) {\r\n                        //workersCount += caseDef.paramManager.rows;\r\n                        for (let i = 0; i < caseDef.paramManager.rows; i++) {\r\n                            const mockParamManager = new ParamManagerMock(caseDef.paramManager.getValues());\r\n                            caseDef.paramManager.readNext();\r\n                            const workerId = `${caseKey}-${suiteIndex}/${caseIndex}/${i}`;\r\n                            const caseCopy = { ...caseDef, iterationCount: 1, paramManager: mockParamManager };\r\n                            const suiteCopy = { ...suiteDef, cases: [ caseCopy ]};\r\n                            const testConfig = {\r\n                                ...this._config, suites: [ suiteCopy ],\r\n                                _groupResult: {\r\n                                    suiteKey: suiteKey,\r\n                                    caseKey: caseKey,\r\n                                    _meta: { caseIterationNum: i + 1 }\r\n                                }\r\n                            };\r\n                            workersConfig.push({ workerId, testConfig, testCaps, startupDelay: 0 });\r\n                            // workersCount++;\r\n                        }\r\n                    }\r\n                    else {\r\n                        const workerId = `${caseKey}-${suiteIndex}/${caseIndex}`;\r\n                        const suiteCopy = { ...suiteDef, cases: [ caseDef ]};\r\n                        const testConfig = { ...this._config, suites: [ suiteCopy ] };\r\n                        workersConfig.push({ workerId, testConfig, testCaps, startupDelay: 0 });\r\n                        // workersCount++;\r\n                    }\r\n                    caseIndex++;\r\n                });\r\n                // workersCount++;\r\n            }\r\n            else {\r\n                const suiteKey = suiteDef.key || suiteDef.id || suiteDef.name;\r\n                const workerId = `${suiteKey}-${suiteIndex}`;\r\n                const testConfig = { ...this._config, suites: [ suiteDef ] };\r\n                workersConfig.push({ workerId, testConfig, testCaps, startupDelay: 0 });\r\n            }\r\n            suiteIndex++;\r\n        });\r\n\r\n        // console.log('workersConfig', JSON.stringify(workersConfig, null, 4));\r\n\r\n        // console.log('~~workersCount', workersCount);\r\n\r\n        // this._queue = queue((task, cb) => this._launchTest(task, cb), workersCount);\r\n        // this._queue.error((err, task) => {\r\n        //     console.log('Error in queue:', err);\r\n        // });\r\n\r\n        this.reporter.onBeforeStart(collection.length);\r\n\r\n        console.log('Collections length', collection.length);\r\n\r\n        const start = new Date();\r\n        await parallelLimit(collection, PARALLEL_COUNT);\r\n\r\n        let total = 0;\r\n        console.log('Created Runners Stat', this.createdRunnersStat);\r\n        const runnersIds = Object.keys(this.createdRunnersStat);\r\n        console.log('Created Runners count', runnersIds.length);\r\n\r\n        runnersIds.map((item) => {\r\n            const cazes = this.createdRunnersStat[item].length;\r\n            total += cazes;\r\n            console.log('Runner', item, ' run ', cazes, ' cases');\r\n        });\r\n\r\n        console.log('Parallel count', PARALLEL_COUNT);\r\n        console.log('Total: ', total);\r\n        const end = new Date();\r\n        const duration = new Duration(start, end);\r\n        console.log('Duration: ', duration.toString(1));\r\n\r\n        // // push all workers to the queue\r\n        // workersConfig.forEach(workerConfig => this._queue.push(workerConfig));\r\n\r\n        // await this._queue.drain();\r\n\r\n        this.reporter.onAfterEnd();\r\n    }\r\n\r\n    /*********************************\r\n     * Private methods\r\n     *********************************/\r\n    _instantiateRunner() {\r\n        if (this._config.framework && typeof this._config.framework === 'string') {\r\n            if (Object.prototype.hasOwnProperty.call(Runners, this._config.framework)) {\r\n                return new Runners[this._config.framework]();\r\n            }\r\n            return null;\r\n        }\r\n        return new Runners.oxygen();\r\n    }\r\n\r\n    async _launchTest({ workerId, testConfig, testCaps, startupDelay }, callback) {\r\n        // console.log('~~_launchTest', arguments);\r\n        if (!callback) {\r\n            return;\r\n        }\r\n        await this._sleep(startupDelay);\r\n        this._activeThreads++;\r\n\r\n        let runner;\r\n\r\n        if (PARALLEL_COUNT <= this.runners.length) {\r\n            runner = this.runners.shift();\r\n\r\n            let arr = this.createdRunnersStat[runner._id];\r\n            let newArray;\r\n\r\n            if (Array.isArray(arr)) {\r\n                newArray = [...arr, workerId];\r\n            } else {\r\n                newArray = [workerId];\r\n            }\r\n\r\n            this.createdRunnersStat[runner._id] = newArray;\r\n\r\n        } else {\r\n            runner = this._instantiateRunner();\r\n            this.createdRunnersStat[runner._id] = [workerId];\r\n        }\r\n\r\n        if (!runner) {\r\n            const framework = this._config.framework;\r\n            callback(new Error(`Cannot find runner for the specified framework: ${framework}.`));\r\n            return;\r\n        }\r\n        try {\r\n            // generate firefox \"profile\" value if profile options are specified\r\n            //await oxutil.generateFirefoxOptionsProfile(testCaps);\r\n            // initialize oxygen\r\n\r\n            await runner.init(testConfig, testCaps, this.reporter);\r\n            // console.log('~~initRv', initRv);\r\n\r\n            // run Oxygen test \r\n            const result = await runner.run();\r\n            // console.log('~~result', result);\r\n\r\n            await runner.dispose(result.status || null);\r\n            callback();\r\n        }\r\n        catch (e) {\r\n            console.error('Failed to launch the test:', e);\r\n            // stop processing the queue\r\n            if (this._queue) {\r\n                this._queue.kill();\r\n            }\r\n            // if this is custom error message\r\n            if (e.error) {\r\n                var errMsg = '';\r\n                var err = e.error;\r\n                if (err.type)\r\n                    errMsg += err.type + ' - ';\r\n                if (err.message)\r\n                    errMsg += err.message;\r\n                else\r\n                    errMsg = err.toString();\r\n                callback(new Error(errMsg));\r\n            }\r\n            else {\r\n                callback(e);    // call back with the original exception\r\n            }\r\n        }\r\n\r\n        this.runners.push(runner);\r\n    }\r\n\r\n    _sleep(duration) {\r\n        return new Promise((resolve) => setTimeout(resolve, duration));\r\n    }\r\n}\r\n\r\nclass ParamManagerMock {\r\n    constructor(values) {\r\n        this.values = values;\r\n    }\r\n\r\n    init() {\r\n\r\n    }\r\n\r\n    getMode() {\r\n\r\n    }\r\n\r\n    readNext() {\r\n\r\n    }\r\n\r\n    readPrev() {\r\n\r\n    }\r\n\r\n    getValues() {\r\n        return this.values;\r\n    }\r\n\r\n    get rows() {\r\n        return 1;\r\n    }\r\n}\r\n"]}

package/build/lib/param-manager.js

@@ -1,37 +1,60 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
 require("source-map-support/register");
 
 var _OxygenError = _interopRequireDefault(require("../errors/OxygenError"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-module.exports = function (filePath, mode, fileType) {
-  var defer = require('when').defer;
+const path = require('path');
+
+const ExcelReader = require('./param-reader-excel');
 
-  var path = require('path');
+const CsvReader = require('./param-reader-csv');
 
-  var ExcelReader = require('./param-reader-excel');
+const JsonReader = require('./param-reader-json');
 
-  var CsvReader = require('./param-reader-csv');
+const errHelper = require('../errors/helper');
 
-  var JsonReader = require('./param-reader-json');
+const DEFAULT_MODE = 'seq';
 
-  var errHelper = require('../errors/helper');
+class ParameterManager {
+  constructor({
+    paramFile = null,
+    fileType = null,
+    paramMode = DEFAULT_MODE,
+    values = null
+  }) {
+    this.filePath = paramFile;
+    this.fileType = fileType;
+    this.mode = paramMode;
+    this.table = null;
+    this.currentRow = null;
+    this.prevRow = null;
 
-  var module = {};
+    if (values && Array.isArray(values)) {
+      this.table = values;
+      this.currentRow = this.mode === 'random' ? random(0, this.table.length) : 0;
+    }
+  }
 
-  var _whenInitialized = defer();
+  async init() {
+    if (!this.filePath) {
+      return;
+    }
 
-  module.init = function () {
-    var ext = path.extname(filePath);
+    let ext = path.extname(this.filePath);
 
-    if (fileType) {
-      ext = fileType;
+    if (this.fileType) {
+      ext = this.fileType;
     }
 
-    var reader = null;
-    var self = this;
+    let reader = null;
 
     if (ext === '.xlsx' || ext === '.xls') {
       reader = new ExcelReader();
@@ -40,29 +63,24 @@ module.exports = function (filePath, mode, fileType) {
     } else if (ext === '.json' || ext === '.js') {
       reader = new JsonReader();
     } else {
-      _whenInitialized.reject(new _OxygenError.default(errHelper.errorCode.PARAMETERS_ERROR, 'Unsupported parameters file type: ' + ext));
-
-      return _whenInitialized.promise;
+      new _OxygenError.default(errHelper.errorCode.PARAMETERS_ERROR, `Unsupported parameters file type: ${ext}`);
+      return;
     }
 
-    this.mode = mode;
-    reader.read(filePath, fileType || null).then(function (result) {
-      self.table = result;
-      self.currentRow = self.mode === 'random' ? random(0, self.table.length) : 0;
-
-      _whenInitialized.resolve(null);
-    }).catch(function (err) {
-      _whenInitialized.reject(new _OxygenError.default(errHelper.errorCode.PARAMETERS_ERROR, `${errHelper.errorCode.PARAMETERS_ERROR}: Unable to load parameters file. 
-${err.message}`));
-    });
-    return _whenInitialized.promise;
-  };
+    try {
+      const result = await reader.read(this.filePath, this.fileType || null);
+      this.table = result;
+      this.currentRow = this.mode === 'random' ? random(0, this.table.length) : 0;
+    } catch (e) {
+      new _OxygenError.default(errHelper.errorCode.PARAMETERS_ERROR, `${errHelper.errorCode.PARAMETERS_ERROR}: Unable to load parameters file.\n${e.message}`);
+    }
+  }
 
-  module.getMode = function () {
+  getMode() {
     return this.mode;
-  };
+  }
 
-  module.readNext = function () {
+  readNext() {
     this.prevRow = this.currentRow;
 
     if (this.mode === 'random') {
@@ -74,30 +92,31 @@ ${err.message}`));
     if (this.currentRow > this.table.length - 1) {
       this.currentRow = 0;
     }
-  };
+  }
 
-  module.readPrev = function () {
-    if (typeof this.prevRow !== 'undefined') {
+  readPrev() {
+    if (typeof this.prevRow !== 'undefined' && this.prevRow != null) {
       this.currentRow = this.prevRow;
     }
-  };
+  }
 
-  module.getValues = function () {
+  getValues() {
     if (!this.table || this.table.length === 0) {
       throw new _OxygenError.default(errHelper.errorCode.PARAMETERS_ERROR, 'Parameters table is empty');
     }
 
     return this.table[this.currentRow];
-  };
+  }
 
-  module.__defineGetter__('rows', function () {
+  get rows() {
     return this.table.length;
-  });
-
-  function random(min, max) {
-    return Math.floor(Math.random() * (max - min)) + min;
   }
 
-  return module;
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/lib/param-manager.js"],"names":["module","exports","filePath","mode","fileType","defer","require","path","ExcelReader","CsvReader","JsonReader","errHelper","_whenInitialized","init","ext","extname","reader","self","reject","OxError","errorCode","PARAMETERS_ERROR","promise","read","then","result","table","currentRow","random","length","resolve","catch","err","message","getMode","readNext","prevRow","readPrev","getValues","__defineGetter__","min","max","Math","floor"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-2018 CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\nimport OxError from '../errors/OxygenError';\r\nmodule.exports = function (filePath, mode, fileType /*optional*/) {\r\n    var defer = require('when').defer;\r\n    var path = require('path');\r\n    var ExcelReader = require('./param-reader-excel');\r\n    var CsvReader = require('./param-reader-csv');\r\n    var JsonReader = require('./param-reader-json');\r\n    var errHelper = require('../errors/helper');\r\n    var module = {};\r\n    var _whenInitialized = defer();\r\n\r\n    module.init = function() {\r\n        var ext = path.extname(filePath);\r\n\r\n        if (fileType) {\r\n            ext = fileType;\r\n        }\r\n        var reader = null;\r\n        var self = this;\r\n        // choose the right converter based on either xls or xlsx file extension\r\n        if (ext === '.xlsx' || ext === '.xls') {\r\n            reader = new ExcelReader();\r\n        }\r\n        else if (ext === '.csv' || ext === '.txt') {\r\n            reader = new CsvReader();\r\n        }\r\n        else if (ext === '.json' || ext === '.js') {\r\n            reader = new JsonReader();\r\n        }\r\n        else {\r\n            _whenInitialized.reject(new OxError(errHelper.errorCode.PARAMETERS_ERROR, 'Unsupported parameters file type: ' + ext));\r\n            return _whenInitialized.promise;\r\n        }\r\n\r\n        this.mode = mode;\r\n\r\n        reader.read(filePath, fileType || null)\r\n            .then(function(result) {\r\n                self.table = result;\r\n                // initialize currentRow according with parameter reading mode (random or sequential)\r\n                self.currentRow = self.mode === 'random' ? random(0, self.table.length) : 0;\r\n                _whenInitialized.resolve(null);\r\n            })\r\n            .catch(function(err) {\r\n                _whenInitialized.reject(\r\n                    new OxError(\r\n                        errHelper.errorCode.PARAMETERS_ERROR,\r\n                        `${errHelper.errorCode.PARAMETERS_ERROR}: Unable to load parameters file. \r\n${err.message}`\r\n                    )\r\n                );\r\n            });\r\n\r\n        return _whenInitialized.promise;\r\n    };\r\n\r\n    module.getMode = function() {\r\n        return this.mode;\r\n    };\r\n\r\n    module.readNext = function () {\r\n        this.prevRow = this.currentRow;\r\n        if (this.mode === 'random') {\r\n            this.currentRow = random(0, this.table.length);\r\n        } else {\r\n            this.currentRow++;\r\n        }\r\n\r\n        if (this.currentRow > this.table.length - 1) {\r\n            this.currentRow = 0;\r\n        }\r\n    };\r\n\r\n    module.readPrev = function () {\r\n        if (typeof this.prevRow !== 'undefined') {\r\n            this.currentRow = this.prevRow;\r\n        }\r\n    };\r\n\r\n    module.getValues = function() {\r\n        if (!this.table || this.table.length === 0) {\r\n            throw new OxError(errHelper.errorCode.PARAMETERS_ERROR, 'Parameters table is empty');\r\n        }\r\n        return this.table[this.currentRow];\r\n    };\r\n\r\n    module.__defineGetter__('rows', function() {\r\n        return this.table.length;\r\n    });\r\n\r\n    function random(min, max) {\r\n        return Math.floor(Math.random() * (max - min)) + min;\r\n    }\r\n\r\n    return module;\r\n};\r\n"]}
+}
+
+exports.default = ParameterManager;
+
+function random(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/lib/param-manager.js"],"names":["path","require","ExcelReader","CsvReader","JsonReader","errHelper","DEFAULT_MODE","ParameterManager","constructor","paramFile","fileType","paramMode","values","filePath","mode","table","currentRow","prevRow","Array","isArray","random","length","init","ext","extname","reader","OxError","errorCode","PARAMETERS_ERROR","result","read","e","message","getMode","readNext","readPrev","getValues","rows","min","max","Math","floor"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\nimport OxError from '../errors/OxygenError';\r\n\r\n// const defer = require('when').defer;\r\nconst path = require('path');\r\nconst ExcelReader = require('./param-reader-excel');\r\nconst CsvReader = require('./param-reader-csv');\r\nconst JsonReader = require('./param-reader-json');\r\nconst errHelper = require('../errors/helper');\r\n\r\nconst DEFAULT_MODE = 'seq';\r\n\r\nexport default class ParameterManager {\r\n    constructor({ paramFile = null, fileType = null, paramMode = DEFAULT_MODE, values = null}) {\r\n        this.filePath = paramFile;\r\n        this.fileType = fileType;\r\n        this.mode = paramMode;\r\n        this.table = null;\r\n        this.currentRow = null;\r\n        this.prevRow = null;\r\n        // if values were provided, initialize manager with pre-defined table\r\n        if (values && Array.isArray(values)) {\r\n            this.table = values;\r\n            // initialize currentRow according with parameter reading mode (random or sequential)\r\n            this.currentRow = this.mode === 'random' ? random(0, this.table.length) : 0;\r\n        }\r\n    }\r\n\r\n    async init() {\r\n        if (!this.filePath) {\r\n            return;\r\n        }\r\n        let ext = path.extname(this.filePath);\r\n\r\n        if (this.fileType) {\r\n            ext = this.fileType;\r\n        }\r\n        let reader = null;\r\n        // choose the right converter based on either xls or xlsx file extension\r\n        if (ext === '.xlsx' || ext === '.xls') {\r\n            reader = new ExcelReader();\r\n        }\r\n        else if (ext === '.csv' || ext === '.txt') {\r\n            reader = new CsvReader();\r\n        }\r\n        else if (ext === '.json' || ext === '.js') {\r\n            reader = new JsonReader();\r\n        }\r\n        else {\r\n            new OxError(errHelper.errorCode.PARAMETERS_ERROR, `Unsupported parameters file type: ${ext}`);\r\n            return;\r\n        }\r\n\r\n        try {\r\n            const result = await reader.read(this.filePath, this.fileType || null);\r\n            this.table = result;\r\n            // initialize currentRow according with parameter reading mode (random or sequential)\r\n            this.currentRow = this.mode === 'random' ? random(0, this.table.length) : 0;\r\n        }\r\n        catch (e) {\r\n            new OxError(\r\n                errHelper.errorCode.PARAMETERS_ERROR,\r\n                `${errHelper.errorCode.PARAMETERS_ERROR}: Unable to load parameters file.\\n${e.message}`\r\n            );\r\n        }\r\n    }\r\n    getMode() {\r\n        return this.mode;\r\n    }\r\n\r\n    readNext() {\r\n        this.prevRow = this.currentRow;\r\n        if (this.mode === 'random') {\r\n            this.currentRow = random(0, this.table.length);\r\n        } else {\r\n            this.currentRow++;\r\n        }\r\n\r\n        if (this.currentRow > this.table.length - 1) {\r\n            this.currentRow = 0;\r\n        }\r\n    }\r\n\r\n    readPrev() {\r\n        if (typeof this.prevRow !== 'undefined' && this.prevRow != null) {\r\n            this.currentRow = this.prevRow;\r\n        }\r\n    }\r\n\r\n    getValues() {\r\n        if (!this.table || this.table.length === 0) {\r\n            throw new OxError(errHelper.errorCode.PARAMETERS_ERROR, 'Parameters table is empty');\r\n        }\r\n        return this.table[this.currentRow];\r\n    }\r\n\r\n    get rows() {\r\n        return this.table.length;\r\n    }\r\n}\r\n\r\nfunction random(min, max) {\r\n    return Math.floor(Math.random() * (max - min)) + min;\r\n}"]}