@zohodesk/testinglibrary 0.4.14-experimental → 0.4.16-experimental

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

@@ -1,56 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _properLockfile = _interopRequireDefault(require("proper-lockfile"));
-var _fs = require("fs");
-function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
-function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
-var _getLockFilePath = /*#__PURE__*/new WeakSet();
-var _createDirectoryIfNotExist = /*#__PURE__*/new WeakSet();
-class FileMutex {
-  constructor(directory, lockFileName, options = {}) {
-    _classPrivateMethodInitSpec(this, _createDirectoryIfNotExist);
-    _classPrivateMethodInitSpec(this, _getLockFilePath);
-    this.directory = directory;
-    this.lockFileName = lockFileName + ".lock";
-    this.options = options;
-  }
-  async acquire() {
-    _classPrivateMethodGet(this, _createDirectoryIfNotExist, _createDirectoryIfNotExist2).call(this);
-    const lockFilePath = _path.default.resolve(this.directory, this.lockFileName);
-    try {
-      if (!(0, _fs.existsSync)(lockFilePath)) {
-        console.warn(`[DEBUG] Recreating missing lock file:`, this.lockFileName);
-        (0, _fs.writeFileSync)(lockFilePath, 'locked');
-      }
-      await _properLockfile.default.lock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this), this.options);
-    } catch (err) {
-      throw new Error(`Failed to acquire lock after ${this.options.retries.retries} attempts: ${err.message}`);
-    }
-  }
-  async release() {
-    try {
-      await _properLockfile.default.unlock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this));
-      //unlinkSync(this.#getLockFilePath());
-    } catch (err) {
-      throw new Error(`Failed to release lock: ${err.message}`);
-    }
-  }
-}
-function _getLockFilePath2() {
-  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
-}
-function _createDirectoryIfNotExist2() {
-  if (!(0, _fs.existsSync)(this.directory)) {
-    (0, _fs.mkdirSync)(this.directory, {
-      recursive: true
-    });
-  }
-}
-var _default = exports.default = FileMutex;

package/build/setup-folder-structure/samples/authUsers-sample.json

@@ -1,9 +0,0 @@
-[
-    {
-        "useremail": "/ user name /",
-        "password": "/ password /",
-        "description": "/ description/",
-        "filename": "user.json",
-        "locator": "/ selector to identify page has been loaded completely /"
-    }
-]

package/build/setup-folder-structure/samples/env-config-sample.json

@@ -1,21 +0,0 @@
-{
-  "dev": {
-    "domain": "https://desk.localzoho.com/agent",
-    "orgName": "org-name",
-    "deptName": "dept-name",
-    "moduleName": "module-name",
-    "devURL": "Provide your devURL here"
-  },
-  "prod": {
-    "domain": "https://desk.localzoho.com/agent",
-    "orgName": "org-name",
-    "deptName": "dept-name",
-    "moduleName": "module-name"
-  },
-  "k8test": {
-    "domain": "https://desk.localzoho.com/agent",
-    "orgName": "org-name",
-    "deptName": "dept-name",
-    "moduleName": "module-name"
-  }
-}

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

@@ -1,94 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
-var _lockfile = _interopRequireDefault(require("lockfile"));
-var _path = _interopRequireDefault(require("path"));
-var _fs = _interopRequireDefault(require("fs"));
-jest.mock('lockfile');
-jest.mock('fs');
-describe('FileMutex', () => {
-  const mockDirectory = '/tmp';
-  const mockFileName = 'test_user';
-  const mockTimeout = {
-    wait: 5000,
-    retries: 5,
-    stale: 60000
-  };
-  let fileMutex;
-  beforeEach(() => {
-    fileMutex = new _fileMutex.default(mockDirectory, mockFileName, mockTimeout);
-  });
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-  describe('acquire', () => {
-    it('should resolve when lockfile.lock succeeds and call getLockFilePath correctly', async () => {
-      const expectedPath = _path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`));
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        expect(lockPath).toBe(expectedPath);
-        expect(options).toEqual(mockTimeout);
-        callback(null);
-      });
-      await expect(fileMutex.acquire()).resolves.toBeUndefined();
-      expect(_lockfile.default.lock).toHaveBeenCalledWith(expectedPath, mockTimeout, expect.any(Function));
-    });
-    it('should reject when lockfile.lock fails', async () => {
-      const mockError = new Error('Lock failed');
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        expect(lockPath).toBe(_path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`)));
-        expect(options).toEqual(mockTimeout);
-        callback(mockError);
-      });
-      await expect(fileMutex.acquire()).rejects.toThrow('Lock failed');
-      expect(_lockfile.default.lock).toHaveBeenCalled();
-    });
-    it('should create the directory if it does not exist and acquire the lock', async () => {
-      _fs.default.existsSync.mockReturnValue(false);
-      _fs.default.mkdirSync.mockImplementation((dir, options) => {
-        expect(dir).toBe(mockDirectory);
-        expect(options).toEqual({
-          recursive: true
-        });
-      });
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        expect(lockPath).toBe(_path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`)));
-        expect(options).toEqual(mockTimeout);
-        callback(null);
-      });
-      await expect(fileMutex.acquire()).resolves.toBeUndefined();
-      expect(_fs.default.existsSync).toHaveBeenCalledWith(mockDirectory);
-      expect(_fs.default.mkdirSync).toHaveBeenCalledWith(mockDirectory, {
-        recursive: true
-      });
-      expect(_lockfile.default.lock).toHaveBeenCalled();
-    });
-    it('should not create the directory if it already exists', async () => {
-      _fs.default.existsSync.mockReturnValue(true);
-      _lockfile.default.lock.mockImplementation((lockPath, options, callback) => {
-        callback(null);
-      });
-      await expect(fileMutex.acquire()).resolves.toBeUndefined();
-      expect(_fs.default.mkdirSync).not.toHaveBeenCalled();
-      expect(_lockfile.default.lock).toHaveBeenCalled();
-    });
-  });
-  describe('release', () => {
-    it('should resolve when lockfile.unlock succeeds and call getLockFilePath correctly', async () => {
-      const expectedPath = _path.default.resolve(_path.default.join(mockDirectory, `./${mockFileName}.lock`));
-      _lockfile.default.unlock.mockImplementation((path, callback) => {
-        callback(null);
-      });
-      await expect(fileMutex.release()).resolves.toBeUndefined();
-      expect(_lockfile.default.unlock).toHaveBeenCalledWith(expectedPath, expect.any(Function));
-    });
-    it('should reject when lockfile.unlock fails', async () => {
-      const mockError = new Error('Unlock failed');
-      _lockfile.default.unlock.mockImplementation((path, callback) => {
-        callback(mockError);
-      });
-      await expect(fileMutex.release()).rejects.toThrow('Unlock failed');
-      expect(_lockfile.default.unlock).toHaveBeenCalled();
-    });
-  });
-});

package/nobdd/src/App.js

@@ -1,7 +0,0 @@
-export function add(a, b) {
-  return a + b;
-}
-
-export function greet(name) {
-  return `Hello, ${name}!`;
-}