@zohodesk/testinglibrary 0.1.9 → 0.1.12-experimental

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

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _getUsers = require("../../../../../core/playwright/helpers/auth/getUsers");
+var _configPathResolver = require("../../../../../core/playwright/helpers/configPathResolver");
+jest.mock('fs');
+jest.mock('path');
+jest.mock('../../../../../core/playwright/helpers/configPathResolver', () => ({
+  getConfigPath: jest.fn()
+}));
+describe('getListOfActors', () => {
+  const stageConfig = 'uat/conf';
+  const mode = 'dev';
+  const stage = 'uat';
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _path.default.join.mockImplementation((...args) => args.join('/'));
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
+  });
+  test('throws an error when config file cannot be loaded', () => {
+    _fs.default.existsSync.mockReturnValueOnce(true);
+    jest.mock('/uat/conf/dev/actors/index.js', () => {
+      throw new Error('Loading error');
+    }, {
+      virtual: true
+    });
+    expect(() => (0, _getUsers.getListOfActors)()).toThrow(`Error loading actor configuration from ${_path.default.join(_path.default.resolve(process.cwd(), 'uat/conf/dev/actors/index.js'))}`);
+  });
+  test('throws an error when beta feature config does not exist', () => {
+    _fs.default.existsSync.mockReturnValueOnce(true) // Main config file exists
+    .mockReturnValueOnce(false); // Beta feature config does not exist in either path
+
+    const betaFeature = 'nonExistentFeature';
+    expect(() => (0, _getUsers.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 exists', () => {
+    _fs.default.existsSync.mockReturnValueOnce(true);
+    const file = _path.default.join(_path.default.resolve(process.cwd(), `${stageConfig}/${mode}/actors/index.js`));
+    jest.doMock(file, () => ({
+      actors: []
+    }), {
+      virtual: true
+    });
+    const result = (0, _getUsers.getListOfActors)();
+    expect(result).toEqual({
+      actors: []
+    });
+  });
+  test('falls back to default configuration if main config file does not exist', () => {
+    _fs.default.existsSync.mockReturnValueOnce(false) // Main config file missing
+    .mockReturnValueOnce(true); // Beta feature config exists
+
+    const defaultConfigFile = _path.default.join(_path.default.resolve(process.cwd(), `${stage}/conf/default/actors/index.js`));
+    jest.doMock(defaultConfigFile, () => ({
+      actors: []
+    }), {
+      virtual: true
+    });
+    const result = (0, _getUsers.getListOfActors)();
+    expect(result).toEqual({
+      actors: []
+    });
+  });
+  test('loads beta feature configuration when betaFeature is provided', () => {
+    _fs.default.existsSync.mockReturnValueOnce(true) // Main config file exists
+    .mockReturnValueOnce(true); // Beta feature config exists
+
+    const betaFeature = 'parentchild';
+    const betaFeaturePath = _path.default.join(_path.default.resolve(process.cwd(), `${stageConfig}/${mode}/actors/beta/${betaFeature}/index.js`));
+    jest.doMock(betaFeaturePath, () => ({
+      betaActors: []
+    }), {
+      virtual: true
+    });
+    const result = (0, _getUsers.getListOfActors)(betaFeature);
+    expect(result).toEqual({
+      betaActors: []
+    });
+  });
+});

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

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _logCollector = require("../../../../../core/playwright/helpers/logCollector");
+function makeEmitter() {
+  const handlers = {};
+  return {
+    handlers,
+    on(event, handler) {
+      (handlers[event] = handlers[event] || []).push(handler);
+    },
+    removeListener() {},
+    emit(event, arg) {
+      (handlers[event] || []).forEach(handler => handler(arg));
+    }
+  };
+}
+function makeContext() {
+  const page = makeEmitter();
+  const emitter = makeEmitter();
+  return {
+    page,
+    context: {
+      ...emitter,
+      pages: () => [page]
+    }
+  };
+}
+const failedRequest = (url, errorText, resourceType = 'script', method = 'GET') => ({
+  url: () => url,
+  failure: () => ({
+    errorText
+  }),
+  method: () => method,
+  resourceType: () => resourceType
+});
+const response = (url, status, method = 'GET') => ({
+  url: () => url,
+  status: () => status,
+  request: () => ({
+    method: () => method
+  }),
+  fromServiceWorker: () => false
+});
+const consoleMessage = (text, url) => ({
+  type: () => 'error',
+  text: () => text,
+  location: () => ({
+    url
+  })
+});
+describe('LogCollector baseline-noise stripping', () => {
+  let collector;
+  let context;
+  let page;
+  beforeEach(() => {
+    collector = new _logCollector.LogCollector();
+    const ctx = makeContext();
+    context = ctx.context;
+    page = ctx.page;
+    collector.attachToContext(context);
+  });
+  test('drops ORB-blocked request failures (message pattern)', () => {
+    context.emit('requestfailed', failedRequest('https://app/some/script.js', 'net::ERR_BLOCKED_BY_ORB'));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops known noisy third-party URLs (url pattern)', () => {
+    context.emit('requestfailed', failedRequest('https://cdn/murphysdk/3.5.0/murphy.min.js', 'net::ERR_ABORTED'));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops noisy 4xx responses by URL (e.g. getHamburgerMenu)', () => {
+    context.emit('response', response('https://app/biz/getHamburgerMenu.do?version=stable', 404));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops CORS console errors (message pattern)', () => {
+    page.emit('console', consoleMessage("Access to font at 'https://x/f.woff' has been blocked by CORS policy: ...", 'https://app/page'));
+    expect(collector.events).toHaveLength(0);
+  });
+  test('drops baseline pageerrors (Access is denied / enable* not a function)', () => {
+    page.emit('pageerror', {
+      name: 'SecurityError',
+      message: 'Failed to read the localStorage: Access is denied for this document.',
+      stack: ''
+    });
+    page.emit('pageerror', {
+      name: 'TypeError',
+      message: 'n.enableDarkTheme is not a function',
+      stack: ''
+    });
+    expect(collector.events).toHaveLength(0);
+  });
+  test('keeps a real application pageerror', () => {
+    page.emit('pageerror', {
+      name: 'TypeError',
+      message: "Cannot read properties of undefined (reading 'id')",
+      stack: 'TypeError: ...'
+    });
+    expect(collector.events).toHaveLength(1);
+    expect(collector.events[0]).toMatchObject({
+      kind: 'pageerror',
+      name: 'TypeError'
+    });
+  });
+  test('flushes captured events to a jsonl file', () => {
+    const flushDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'log-collector-flush-'));
+    try {
+      page.emit('pageerror', {
+        name: 'TypeError',
+        message: "Cannot read properties of undefined (reading 'id')",
+        stack: 'TypeError: ...'
+      });
+      const filePath = collector.flushToFile(flushDir, 'w0-test-0');
+      const contents = _fs.default.readFileSync(filePath, 'utf8');
+      const line = JSON.parse(contents.trim());
+      expect(filePath).toContain('w0-test-0.jsonl');
+      expect(line).toMatchObject({
+        pattern: 'CODE',
+        kind: 'pageerror'
+      });
+      expect(contents).toContain("Cannot read properties of undefined (reading 'id')");
+      expect(contents.endsWith('\n')).toBe(true);
+      // In-memory events stay unannotated.
+      expect(collector.events[0].pattern).toBeUndefined();
+    } finally {
+      _fs.default.rmSync(flushDir, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  test('flushes ENVIRONMENT pattern annotation for document aborts', () => {
+    const flushDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'log-collector-flush-'));
+    try {
+      context.emit('requestfailed', failedRequest('https://app/agent/events/list/commentsubtabevent', 'net::ERR_ABORTED', 'document'));
+      const filePath = collector.flushToFile(flushDir, 'w0-env-0');
+      const line = JSON.parse(_fs.default.readFileSync(filePath, 'utf8').trim());
+      expect(line).toMatchObject({
+        pattern: 'ENVIRONMENT',
+        kind: 'requestfailed',
+        resourceType: 'document'
+      });
+    } finally {
+      _fs.default.rmSync(flushDir, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  test('returns null from flushToFile when no events were captured', () => {
+    expect(collector.flushToFile('/tmp', 'empty')).toBeNull();
+  });
+  test('keeps a document-navigation abort (real environment signal)', () => {
+    context.emit('requestfailed', failedRequest('https://app/agent/events/list/commentsubtabevent', 'net::ERR_ABORTED', 'document'));
+    expect(collector.events).toHaveLength(1);
+    expect(collector.events[0]).toMatchObject({
+      kind: 'requestfailed',
+      resourceType: 'document'
+    });
+  });
+});

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

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _runtimeLogPath = require("../../../../../core/playwright/helpers/runtimeLogPath");
+var _runtimeLogReader = require("../../../../../core/playwright/helpers/runtimeLogReader");
+const TEST_TITLE = 'runtime-log-reader-test';
+let tempDir;
+function writeRuntimeLog(events, {
+  workerIndex = 0,
+  retry = 0,
+  title = TEST_TITLE
+} = {}) {
+  const file = (0, _runtimeLogPath.resolveRuntimeLogFilePath)(tempDir, {
+    workerIndex,
+    retry,
+    title
+  });
+  _fs.default.mkdirSync(_path.default.dirname(file), {
+    recursive: true
+  });
+  _fs.default.writeFileSync(file, `${events.map(e => JSON.stringify(e)).join('\n')}\n`);
+  return file;
+}
+beforeEach(() => {
+  tempDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'runtime-log-reader-'));
+});
+afterEach(() => {
+  _fs.default.rmSync(tempDir, {
+    recursive: true,
+    force: true
+  });
+});
+describe('readRuntimeLogEventsForResult', () => {
+  test('reads project-side runtime log for a failing result', () => {
+    const events = [{
+      kind: 'pageerror',
+      message: 'inline boom'
+    }];
+    writeRuntimeLog(events);
+    const result = {
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE, tempDir)).toEqual(events);
+  });
+  test('skips malformed jsonl lines', () => {
+    const file = writeRuntimeLog([]);
+    _fs.default.writeFileSync(file, [JSON.stringify({
+      kind: 'console',
+      text: 'ok'
+    }), 'not-json', JSON.stringify({
+      kind: 'pageerror',
+      message: 'err'
+    })].join('\n') + '\n');
+    const result = {
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE, tempDir)).toEqual([{
+      kind: 'console',
+      text: 'ok'
+    }, {
+      kind: 'pageerror',
+      message: 'err'
+    }]);
+  });
+  test('returns an empty array when the runtime log file is missing', () => {
+    const result = {
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, 'missing-test', tempDir)).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(null, TEST_TITLE, tempDir)).toEqual([]);
+  });
+  test('returns an empty array when logsDir is missing', () => {
+    const result = {
+      status: 'failed',
+      workerIndex: 0,
+      retry: 0
+    };
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE)).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, TEST_TITLE, undefined)).toEqual([]);
+  });
+});
+describe('readRuntimeLogEvents', () => {
+  test('reads events from a jsonl file path', () => {
+    const file = writeRuntimeLog([{
+      kind: 'console',
+      text: 'ok'
+    }, {
+      kind: 'pageerror',
+      message: 'err'
+    }]);
+    expect((0, _runtimeLogReader.readRuntimeLogEvents)(file)).toEqual([{
+      kind: 'console',
+      text: 'ok'
+    }, {
+      kind: 'pageerror',
+      message: 'err'
+    }]);
+  });
+  test('returns an empty array for a missing file', () => {
+    expect((0, _runtimeLogReader.readRuntimeLogEvents)(null)).toEqual([]);
+    expect((0, _runtimeLogReader.readRuntimeLogEvents)(_path.default.join(tempDir, 'missing.jsonl'))).toEqual([]);
+  });
+});

package/build/test/core/playwright/helpers/auth/__tests__/checkAuthCookies.test.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _fileUtils = require("../../../../../../utils/fileUtils");
+var _checkAuthCookies = require("../../../../../../core/playwright/helpers/auth/checkAuthCookies");
+jest.mock('../../../../../../utils/fileUtils', () => ({
+  writeFileContents: jest.fn()
+}));
+function pageWithCookies(cookies) {
+  return {
+    context: () => ({
+      storageState: jest.fn().mockResolvedValue({
+        cookies
+      })
+    })
+  };
+}
+function writtenCookies() {
+  return JSON.parse(_fileUtils.writeFileContents.mock.calls[0][1]).cookies;
+}
+describe('storeFilteredStorageState', () => {
+  const authFile = '/tmp/.auth/user.json';
+  it('keeps cookies whose name contains "iamadt"', async () => {
+    const cookies = [{
+      name: '_iamadt',
+      value: 'a'
+    }];
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies(cookies), authFile);
+    expect(writtenCookies()).toEqual(cookies);
+  });
+  it('keeps cookies whose name contains "iambdt"', async () => {
+    const cookies = [{
+      name: '_iambdt',
+      value: 'b'
+    }];
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies(cookies), authFile);
+    expect(writtenCookies()).toEqual(cookies);
+  });
+  it('keeps a cookie whose name has the key as a substring, not just an exact match', async () => {
+    const cookies = [{
+      name: '_cseziamadt',
+      value: 'c'
+    }];
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies(cookies), authFile);
+    expect(writtenCookies()).toEqual(cookies);
+  });
+  it('drops cookies whose name does not contain either key', async () => {
+    const cookies = [{
+      name: 'crmcsr',
+      value: 'x'
+    }, {
+      name: 'JSESSIONID',
+      value: 'y'
+    }];
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies(cookies), authFile);
+    expect(writtenCookies()).toEqual([]);
+  });
+  it('matching is case-sensitive', async () => {
+    const cookies = [{
+      name: '_IAMADT',
+      value: 'z'
+    }];
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies(cookies), authFile);
+    expect(writtenCookies()).toEqual([]);
+  });
+  it('filters a mixed list down to only the matching cookies', async () => {
+    const cookies = [{
+      name: '_iamadt',
+      value: 'a'
+    }, {
+      name: 'crmcsr',
+      value: 'x'
+    }, {
+      name: '_iambdt',
+      value: 'b'
+    }, {
+      name: 'JSESSIONID',
+      value: 'y'
+    }];
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies(cookies), authFile);
+    expect(writtenCookies()).toEqual([{
+      name: '_iamadt',
+      value: 'a'
+    }, {
+      name: '_iambdt',
+      value: 'b'
+    }]);
+  });
+  it('writes to the given authFile path', async () => {
+    await (0, _checkAuthCookies.storeFilteredStorageState)(pageWithCookies([]), authFile);
+    expect(_fileUtils.writeFileContents).toHaveBeenCalledWith(authFile, expect.any(String));
+  });
+});

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

@@ -0,0 +1,19 @@
+"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"));
+jest.mock('../../../../../core/playwright/setup/config-utils', () => ({
+  getBrowsersList: jest.fn().mockReturnValue([])
+}));
+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,30 @@
+"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');
+jest.mock('../../../../../core/playwright/setup/config-utils', () => ({
+  getBrowsersList: jest.fn().mockReturnValue([])
+}));
+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

@@ -36,6 +36,9 @@ function cliArgsToObject(cliArgs, isKeyNeedToBeAdded) {
         value = true;
       }
       processEnv[key] = value;
+      if (typeof value === 'string' && /^-?\d+$/.test(value)) {
+        processEnv[key] = parseInt(value, 10);
+      }
     }
   });
   return processEnv;

package/build/utils/commonUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyCommonSpecs = copyCommonSpecs;
+var _fileUtils = require("./fileUtils");
+var _path = _interopRequireDefault(require("path"));
+var _configConstants = _interopRequireDefault(require("../core/playwright/constants/configConstants"));
+var _ConfigurationHelper = require("../core/playwright/configuration/ConfigurationHelper");
+const stage = (0, _ConfigurationHelper.getRunStage)();
+function copyCommonSpecs() {
+  const libraryPath = require.resolve("@zohodesk/testinglibrary");
+  // libraryPath will be build/index.js to go to the common specs we need to go one level up
+  const commonSpecPath = _path.default.resolve(libraryPath, '../', 'common');
+  const destDirectory = _path.default.resolve(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules', '.testingLib-common');
+  (0, _fileUtils.deleteFolder)(destDirectory);
+  (0, _fileUtils.copyDirectory)(commonSpecPath, destDirectory);
+}

package/build/utils/fileUtils.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.checkIfFileExists = checkIfFileExists;
+exports.checkIfFolderExistsWithPattern = checkIfFolderExistsWithPattern;
+exports.copyDirectory = copyDirectory;
 exports.deleteFile = deleteFile;
 exports.deleteFolder = deleteFolder;
 exports.readFileContents = readFileContents;
@@ -12,11 +14,14 @@ 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;
   }
 }
@@ -25,6 +30,7 @@ function readFileContents(filePath) {
     let fileContents = _fs.default.readFileSync(filePath, 'utf-8');
     return fileContents;
   } catch (err) {
+    _logger.Logger.error(err);
     return null;
   }
 }
@@ -40,6 +46,7 @@ function writeFileContents(filePath, content, writeOptions = {}) {
   try {
     _fs.default.writeFileSync(`${filePath}`, content, writeOptions);
   } catch (err) {
+    _logger.Logger.error(err);
     throw new Error(err);
   }
 }
@@ -48,6 +55,7 @@ function deleteFile(filePath) {
     try {
       _fs.default.unlinkSync(filePath);
     } catch (err) {
+      _logger.Logger.error(err);
       throw new Error(`Error while deleting the test data file: ${filePath}`);
     }
   } else {
@@ -57,11 +65,45 @@ function deleteFile(filePath) {
 function deleteFolder(folderPath) {
   if (_fs.default.existsSync(folderPath)) {
     try {
-      _fs.default.rmdirSync(folderPath, {
+      _fs.default.rmSync(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;
+  }
+}
+function copyDirectory(src, dest) {
+  if (!_fs.default.existsSync(dest)) {
+    _fs.default.mkdirSync(dest, {
+      recursive: true
+    });
+  }
+  const entries = _fs.default.readdirSync(src, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const srcPath = _path.default.join(src, entry.name);
+    const destPath = _path.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      _fs.default.copyFileSync(srcPath, destPath);
+    }
+  }
 }

package/build/utils/logger.js

@@ -4,35 +4,6 @@ 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';
@@ -51,7 +22,7 @@ class LoggerImpl {
   info() {}
   log(type, message) {
     const color = this.colors[type];
-    this.consoleLogger.log(`${color[0]}${message}${color[1]}`);
+    this.consoleLogger.log(`${color[0]}${message}${color[1]}\n`);
   }
 }
 const Logger = exports.Logger = new LoggerImpl();