@zohodesk/testinglibrary 0.0.1 → 0.0.2-n20-experimental

package/build/test/core/playwright/helpers/__tests__/fileMutex.test.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+jest.mock('fs');
+describe('FileMutex', () => {
+  const directory = '/tmp/locks';
+  const lockFileName = 'test-lock';
+  const fileDeletionTimeoutConfig = {
+    timeout: 1000
+  };
+  const lockFilePath = _path.default.resolve(directory, lockFileName + '.lock');
+  let fileMutex;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fileMutex = new _fileMutex.default(directory, lockFileName, fileDeletionTimeoutConfig);
+  });
+  describe('acquire', () => {
+    it('should create the lock file if it does not exist', async () => {
+      _fs.writeFileSync.mockImplementation(() => {});
+      await fileMutex.acquire();
+      expect(_fs.writeFileSync).toHaveBeenCalledWith(fileMutex.lockFilePath, 'locked');
+    });
+    it('should wait for lock file deletion if it exists', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === fileMutex.lockFilePath);
+      _fs.watch.mockImplementation((dir, callback) => {
+        setTimeout(() => {
+          _fs.existsSync.mockImplementation(() => false);
+          callback('rename', fileMutex.lockFileName);
+        }, fileDeletionTimeoutConfig);
+        return {
+          close: jest.fn()
+        };
+      });
+      await fileMutex.acquire();
+      expect(_fs.watch).toHaveBeenCalledWith(directory, expect.any(Function));
+    });
+    it('should reject if watch timeout exceeds', async () => {
+      _fs.existsSync.mockImplementation(filePath => filePath === lockFilePath);
+      _fs.watch.mockImplementation(() => {
+        return {
+          close: jest.fn()
+        };
+      });
+      await expect(fileMutex.acquire()).rejects.toThrow('Watch timeout exceeded');
+    });
+  });
+  describe('release', () => {
+    it('should delete the lock file if it exists', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
+      await fileMutex.release();
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).toHaveBeenCalledWith(lockFilePath);
+    });
+    it('should release lock by deleting lock file', async () => {
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {});
+      await fileMutex.release();
+      expect(_fs.unlinkSync).toHaveBeenCalledWith(lockFilePath);
+    });
+    it('should not attempt to delete the lock file if it does not exist', async () => {
+      _fs.existsSync.mockReturnValue(false);
+      await fileMutex.release();
+      expect(_fs.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.unlinkSync).not.toHaveBeenCalled();
+    });
+    it('should log an error if deleting the lock file fails', async () => {
+      const errorMessage = 'Error deleting lock file';
+      _fs.existsSync.mockReturnValue(true);
+      _fs.unlinkSync.mockImplementation(() => {
+        throw new Error(errorMessage);
+      });
+      await expect(fileMutex.release()).rejects.toThrow(errorMessage);
+    });
+  });
+});

package/build/test/core/playwright/helpers/__tests__/getUsers_ListOfActors.test.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+jest.mock('fs');
+jest.mock('path');
+jest.mock('../../../../../core/playwright/readConfigFile', () => ({
+  generateConfigFromFile: jest.fn(() => ({
+    uatDirectory: '/test/directory'
+  })),
+  getRunMode: jest.fn(() => 'dev')
+}));
+const {
+  getListOfActors
+} = require('../../../../../core/playwright/helpers/auth/getUsers');
+describe('getListOfActors', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _path.default.join.mockImplementation((...args) => args.join('/'));
+  });
+  test('throws an error when config file cannot be loaded', () => {
+    _fs.existsSync.mockReturnValueOnce(true); // Main config file exists
+
+    jest.mock('/test/directory/conf/dev/actors/index.js', () => {
+      throw new Error('Loading error');
+    }, {
+      virtual: true
+    });
+    expect(() => getListOfActors()).toThrow('Error loading actor configuration from /test/directory/conf/dev/actors/index.js');
+  });
+  test('throws an error when beta feature config does not exist', () => {
+    _fs.existsSync.mockReturnValueOnce(true) // Main config file exists
+    .mockReturnValueOnce(false); // Beta feature config does not exist in either path
+
+    const betaFeature = 'nonExistentFeature';
+    expect(() => getListOfActors(betaFeature)).toThrow(`There is no beta feature configured with the name "${betaFeature}"`);
+  });
+  test('loads main configuration when betaFeature is not provided and main config file exists', () => {
+    _fs.existsSync.mockReturnValueOnce(true);
+    jest.doMock('/test/directory/conf/dev/actors/index.js', () => ({
+      actors: []
+    }), {
+      virtual: true
+    });
+    const result = getListOfActors();
+    expect(result).toEqual({
+      actors: []
+    });
+  });
+  test('falls back to default configuration if main config file does not exist', () => {
+    _fs.existsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
+    jest.doMock('/test/directory/conf/default/actors/index.js', () => ({
+      actors: []
+    }), {
+      virtual: true
+    });
+    const result = getListOfActors();
+    expect(result).toEqual({
+      actors: []
+    });
+  });
+  test('loads beta feature configuration when betaFeature is provided', () => {
+    _fs.existsSync.mockReturnValueOnce(true) // Main config file exists
+    .mockReturnValueOnce(true); // Beta feature config exists
+
+    const betaFeature = 'parentchild';
+    const betaFeaturePath = `/test/directory/conf/dev/actors/beta/${betaFeature}/index.js`;
+    jest.doMock(betaFeaturePath, () => ({
+      betaActors: []
+    }), {
+      virtual: true
+    });
+    const result = getListOfActors(betaFeature);
+    expect(result).toEqual({
+      betaActors: []
+    });
+    expect(_path.default.join).toHaveBeenCalledWith('/test/directory', `conf/dev/actors/beta/${betaFeature}/index.js`);
+  });
+});

package/build/test/core/playwright/runner/__tests__/RunnerHelper.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _RunnerHelper = _interopRequireDefault(require("../../../../../core/playwright/runner/RunnerHelper"));
+var _SpawnRunner = _interopRequireDefault(require("../../../../../core/playwright/runner/SpawnRunner"));
+describe('RunnerHelper', () => {
+  describe('createRunner', () => {
+    it('should throw error on invalid runner type', () => {
+      expect(() => _RunnerHelper.default.createRunner('invalid-type', {})).toThrow("Invalid runner type");
+    });
+    it('should create a valid runner class', () => {
+      const runnerInstance = _RunnerHelper.default.createRunner('spawn', {});
+      expect(runnerInstance).toBeInstanceOf(_SpawnRunner.default); // Directly pass the result
+    });
+  });
+});

package/build/test/core/playwright/runner/__tests__/SpawnRunner.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _RunnerHelper = _interopRequireDefault(require("../../../../../core/playwright/runner/RunnerHelper"));
+var _Runner = _interopRequireDefault(require("../../../../../core/playwright/runner/Runner"));
+var _Configuration = _interopRequireDefault(require("../../../../../core/playwright/configuration/Configuration"));
+jest.mock('child_process');
+jest.mock('../../../../../utils/logger');
+describe('SpawnRunner', () => {
+  let spawnRunner;
+  const runnerObj = new _Runner.default();
+  beforeEach(() => {
+    const config = new _Configuration.default({});
+    config.add("bddMode", true);
+    runnerObj.setConfig(config);
+    runnerObj.setTagArgs(["--headed"]);
+    spawnRunner = _RunnerHelper.default.createRunner('spawn', runnerObj);
+  });
+  describe('run', () => {
+    it('should call runPreprocessing when bddMode is true', () => {
+      const runPreprocessingSpy = jest.spyOn(spawnRunner, 'runPreprocessing').mockResolvedValue();
+      const runPlaywrightSpy = jest.spyOn(spawnRunner, 'runPlaywright').mockResolvedValue();
+      spawnRunner.run();
+      expect(runPreprocessingSpy).toHaveBeenCalled();
+    });
+  });
+});

package/build/utils/cliArgsToObject.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cliArgsToObject = cliArgsToObject;
+exports.objectToCliArgs = objectToCliArgs;
+function isMatchForOption(option) {
+  return /^--./.test(option);
+}
+
+/**
+ * Converts an array of command-line arguments into an object.
+ *
+ * @param {string[]} cliArgs - An array of command-line arguments.
+ * @param {boolean} [isKeyNeedToBeAdded=true] - Indicates whether the keys should be added to the resulting object.
+ * @returns {Object} An object representing the command-line arguments, where keys are argument names (without '--') and values are argument values.
+ * If `isKeyNeedToBeAdded` is set to `false`, only values are included in the object with numeric indexes as keys.
+ *
+ * @example
+ * // Example usage:
+ * const args = ['--port=8080', '--verbose', 'input.txt'];
+ * const result = cliArgsToObject(args);
+ * // result will be: { port: '8080', verbose: true }
+ */
+// eslint-disable-next-line no-unused-vars
+function cliArgsToObject(cliArgs, isKeyNeedToBeAdded) {
+  const processEnv = {};
+  cliArgs.forEach(option => {
+    if (isMatchForOption(option)) {
+      const equIndex = option.indexOf('=');
+      let key = option.slice(2, equIndex);
+      let value = option.slice(equIndex + 1);
+      if (equIndex === -1) {
+        key = option.slice(2);
+        value = true;
+      }
+      processEnv[key] = value;
+      if (!isNaN(parseInt(value))) {
+        processEnv[key] = parseInt(value);
+      }
+    }
+  });
+  return processEnv;
+}
+
+/**
+ * Converts an object to an array of command-line arguments.
+ *
+ * @param {Object} objectToBeConverted - The object to be converted to command-line arguments.
+ * @param {(string|function(string): boolean)} [isKeyNeedToBeAdded=true] - A string representing a key, or a function that determines whether a key should be added to the resulting array.
+ * @returns {string[]} An array of command-line arguments generated from the object's key-value pairs. Keys are transformed into argument names (with '--') and values are added as argument values.
+ *
+ * @example
+ * // Example usage:
+ * const options = { port: 8080, verbose: true, input: 'input.txt' };
+ * const args = objectToCliArgs(options);
+ * // args will be: ['--port=8080', '--verbose', '--input=input.txt']
+ */
+function objectToCliArgs(objectToBeConverted, isKeyNeedToBeAdded) {
+  const argsArray = [];
+  Object.keys(objectToBeConverted).forEach(key => {
+    if (isKeyNeedToBeAdded(key)) {
+      if (typeof objectToBeConverted[key] === 'boolean' && objectToBeConverted[key]) {
+        argsArray.push(`--${key}`);
+      } else {
+        argsArray.push(`--${key}=${objectToBeConverted[key]}`);
+      }
+    }
+  });
+  return argsArray;
+}

package/build/utils/fileUtils.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkIfFileExists = checkIfFileExists;
+exports.checkIfFolderExistsWithPattern = checkIfFolderExistsWithPattern;
+exports.deleteFile = deleteFile;
+exports.deleteFolder = deleteFolder;
+exports.readFileContents = readFileContents;
+exports.writeFileContents = writeFileContents;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("./logger");
+var glob = _interopRequireWildcard(require("glob"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function checkIfFileExists(file) {
+  try {
+    _fs.default.accessSync(file, _fs.default.constants.F_OK);
+    return true;
+  } catch (err) {
+    _logger.Logger.error(err);
+    return false;
+  }
+}
+function readFileContents(filePath) {
+  try {
+    let fileContents = _fs.default.readFileSync(filePath, 'utf-8');
+    return fileContents;
+  } catch (err) {
+    _logger.Logger.error(err);
+    return null;
+  }
+}
+function writeFileContents(filePath, content, writeOptions = {}) {
+  const directoryPath = _path.default.dirname(filePath);
+
+  // Check if the directory exists
+  if (!_fs.default.existsSync(directoryPath)) {
+    _fs.default.mkdirSync(directoryPath, {
+      recursive: true
+    });
+  }
+  try {
+    _fs.default.writeFileSync(`${filePath}`, content, writeOptions);
+  } catch (err) {
+    _logger.Logger.error(err);
+    throw new Error(err);
+  }
+}
+function deleteFile(filePath) {
+  if (checkIfFileExists(filePath)) {
+    try {
+      _fs.default.unlinkSync(filePath);
+    } catch (err) {
+      _logger.Logger.error(err);
+      throw new Error(`Error while deleting the test data file: ${filePath}`);
+    }
+  } else {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `File Does not Exist in the path ${filePath}`);
+  }
+}
+function deleteFolder(folderPath) {
+  if (_fs.default.existsSync(folderPath)) {
+    try {
+      _fs.default.rmdirSync(folderPath, {
+        recursive: true
+      });
+    } catch (err) {
+      _logger.Logger.error(err);
+      throw new Error(`Error while deleting the test data file: ${folderPath}`);
+    }
+  }
+}
+
+// This function uses glob to check if a folder exists with a specific pattern
+// Glob is define patterns for matching file and directory names based on wildcards
+function checkIfFolderExistsWithPattern(folderPath) {
+  try {
+    if (glob.sync(folderPath).length > 0) {
+      return true;
+    }
+    return false;
+  } catch (err) {
+    _logger.Logger.error(err);
+    return false;
+  }
+}

package/build/utils/getFilePath.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getFilePathWithExtension;
+var _os = require("os");
+const isWindows = (0, _os.platform)().toLowerCase() === 'win32';
+function getFilePathWithExtension(binName) {
+  return isWindows ? `${binName}.cmd` : binName;
+}

package/build/utils/logger.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Logger = void 0;
+// const SUCCESS_TYPE = 'success';
+// const FAILURE_TYPE = 'failure';
+// const INFO_TYPE = 'info';
+
+// function logger() {
+//   this.colors = {
+//     'success': ['\x1b[36m', '\x1b[0m'],
+//     'failure': ['\x1b[31m', '\x1b[0m'],
+//     'info': ['\x1b[33m', '\x1b[0m']
+//   }
+//   this.consoleLogger = console;
+//   return {
+//     SUCCESS_TYPE,
+//     FAILURE_TYPE,
+//     INFO_TYPE,
+//     error: () => { },
+//     info: () => { },
+//     log: (type, message) => {
+//       const color = this.colors[type];
+//       console.log(type, color)
+//       this.consoleLogger.log(`${color[0]}${message}${color[1]}`)
+//     }
+//   }
+// }
+
+// module.exports = {
+//   Logger: logger()
+// }
+
+class LoggerImpl {
+  constructor() {
+    this.SUCCESS_TYPE = 'success';
+    this.FAILURE_TYPE = 'failure';
+    this.INFO_TYPE = 'info';
+    this.colors = {
+      'success': ['\x1b[36m', '\x1b[0m'],
+      'failure': ['\x1b[31m', '\x1b[0m'],
+      'info': ['\x1b[33m', '\x1b[0m']
+    };
+    this.consoleLogger = console;
+  }
+  error(err) {
+    this.consoleLogger.error(err);
+  }
+  info() {}
+  log(type, message) {
+    const color = this.colors[type];
+    this.consoleLogger.log(`${color[0]}${message}${color[1]}`);
+  }
+}
+const Logger = exports.Logger = new LoggerImpl();

package/build/utils/rootPath.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBinPath = getBinPath;
+exports.getExecutableBinaryPath = getExecutableBinaryPath;
+exports.getRootNodeModulesPath = getRootNodeModulesPath;
+exports.getRootPath = getRootPath;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _logger = require("./logger");
+var _getFilePath = _interopRequireDefault(require("./getFilePath"));
+// TODO: Publish and check this change of finding package.json working fine.
+function findPath(directory, pathToFind) {
+  const filePath = _path.default.join(directory, pathToFind);
+  if (_fs.default.existsSync(filePath)) {
+    return filePath;
+  }
+  const parentDir = _path.default.dirname(directory);
+  if (parentDir === directory) {
+    return null;
+  }
+  return findPath(parentDir, pathToFind);
+}
+function findPackageJSON(startDir) {
+  return findPath(startDir, 'package.json');
+}
+function findBinaryPath(directory, command) {
+  const binaryPath = _path.default.join('.bin', (0, _getFilePath.default)(command));
+  return findPath(directory, binaryPath);
+}
+function getRootPath() {
+  return findPackageJSON(_path.default.resolve(__dirname));
+}
+function getRootNodeModulesPath() {
+  const rootPath = getRootPath();
+  return _path.default.resolve(_path.default.dirname(rootPath), 'node_modules');
+}
+function getBinPath(command) {
+  const packageNodeModulesPath = getRootNodeModulesPath();
+  return findBinaryPath(packageNodeModulesPath, command);
+}
+function getExecutableBinaryPath(command) {
+  const binPath = getBinPath(command);
+  if (binPath !== null) {
+    return binPath;
+  } else {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error: Could not find executable bin ${command} file. Make sure to npm install before proceeding`);
+    process.exit();
+  }
+}

package/build/utils/stepDefinitionsFormatter.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.delimiters = void 0;
+exports.findDelimiterFromStep = findDelimiterFromStep;
+const delimiters = exports.delimiters = ["Given", "When", "Then", "And"];
+function findDelimiterFromStep(step) {
+  return delimiters.find(delimiter => step.includes(delimiter));
+}

package/changelog.md

@@ -0,0 +1,167 @@
+# Testing Framework
+
+## Framework that abstracts the configuration for playwright and Jest
+# 0.2.4
+- Issue fixes on custom fixtures
+  - Page Fixture
+  - i18n Fixture
+  
+# 0.2.1
+**Issue Fixes**
+- Fixes issue in actors configuration
+- Added Error Logger
+
+# 0.2.0
+**Major Breaking Change**
+- Removed Env-config.json in favour of conf/*/settings.json
+- Mode in uat.config.js is deprecated. Use command args instead
+
+**Enhancements**
+- Playwright version updated to 1.42.1
+- Playwright-bdd version updated to 6.1.1
+- Tags Support
+- Added getMetaInfo fixture to get the actors Info data
+
+**Issue Fixes**
+- Fixes #10- Mode config not working properly
+
+# 0.1.9
+**Enhancements**
+- Added option to specify browsers in command line.
+  - npm run uat -- --browsers='chrome,firefox'
+- Playwright version updated to 1.41.1
+- Added option to Skip Browser download
+- Added New Command re-run-failed to run only the failed cases
+**Major Change**
+- Default fixtures moved inside the library.(Page, Context, i18N, unauthenticatedPage)
+**Internal Library Change**
+Examples folder updated to latest testing library version.
+
+# 0.1.8
+**Issue Fixes**
+- Fix #9 Custom report generate Error on Windows
+- Add Tags annotations only on bddMode
+
+**Enhancements**
+- Added Failed steps in test summary
+
+# 0.1.7
+**Enhancements**
+- Added option to run  teardown logic.
+- Added support for tag based filtering.
+- Playwright-bdd version updated to 5.6.0.
+- New fixture added to add tag as annotations in test report
+
+**Issue Fixes**
+- Edition command option. Fixed the edition tags not generated properly
+
+# 0.1.6
+
+**Enhancements**
+- New Command option Added `--edition`.
+- New Configuration Added `editionOrder`.
+  `In uat.config.js, editionOrder: ['Free', 'Express']`
+- Cache Layer added
+
+**USAGE**
+ - npm run uat --edition="Free"
+
+
+
+# 0.1.5
+
+**Enhancements**
+
+- Playwright version updated to `1.40.1`
+- And and But Support added
+- Added Code Suggestions support
+- Custom Reporter added. Now the report will be available in json format.
+- New Commands added.
+
+  `- help: npx ZDTestingFramework help`
+
+  - Will list down the commands available in the tool
+
+  `- clearCaches: npx ZDTestingFramework clearCaches`
+
+  - Will clear the exisiting cookies in the authentication setup
+
+**Issue Fixes**
+
+- Fixed Issue that occurs while quitting node process.
+
+# 0.1.4
+
+- `testIdAttribute` config added
+- Fixed issue while reading boolean configuration values
+
+# 0.1.3
+
+- uat config sample file updated with `bddMode` and `viewport` values
+- user configuration issue fix when the value is undefined
+
+# 0.1.2
+
+- Bdd version updated to `5.4.0`
+- Playwright version updated to `1.39.0`
+
+# 0.1.1
+
+- Fixed post install script error
+- Fixed error `@cucumber/gherkin` not found. Cause of this issue is updating @cucumber/cucumber to 9.5.0. Reverting this version to 9.2.0
+- Removed testing library exports
+
+# 0.1.0
+
+- Removed eslint as dev dependencies as it causes `npm aliases not supported error` for npm version < 6
+
+# 0.0.9
+
+- Video sized in report adjusted to viewport size
+- Changes in package.json scripts while setting up project
+
+# 0.0.8
+
+- Tags Support
+- Enable running without bddmode feature
+- viewport configuration
+- Internal Change - Code refactoring
+
+# 0.0.7
+
+- Removed react and react-dom as dependencies. Added this as peer dependency
+
+# 0.0.6
+
+## Provided Initial Support for cucumber feature files
+
+    - Playwright-bdd and cucumber added as dependencies
+    - Added config bddMode which toggles the feature files processing
+    - Added expect timeout and test timeout as an option
+    - Decorators support for given, when and then. Typescript support needed to use this feature
+
+## Internal Library change
+
+    - Provided support for import/export statements
+
+# 0.0.5
+
+- Added Init command to initialize the folder structure and configuration for testing
+- Renamed config.json to env-config.json
+- Configured report file path directory and Handled Edge case in Cookies Handling
+
+# 0.0.4
+
+- Issue Fixes while loading the storage state
+
+# 0.0.3
+
+- Added Support for custom config generator based on user preferences
+
+# 0.0.2
+
+- Fix for Finding directories inside node_modules folder
+
+# 0.0.1
+
+- test and report command support