@zohodesk/testinglibrary 0.4.7-experimental → 0.4.9-experimental

package/build/core/playwright/helpers/auth/getUsers.js

@@ -52,14 +52,22 @@ function getDefaultActor() {
   } = getDefaultActorConf();
   return getUserForSelectedEditionAndProfile(edition, profile);
 }
-function getListOfActors() {
+function getListOfActors(betaFeature) {
   const {
     uatDirectory
   } = (0, _readConfigFile.generateConfigFromFile)();
   const mode = getRunMode();
   let configFile = _path.default.join(uatDirectory, `conf/${mode}/actors/index.js`);
+  let betaReference = mode;
   if (!(0, _fs.existsSync)(configFile)) {
     configFile = _path.default.join(uatDirectory, `conf/default/actors/index.js`);
+    betaReference = "default";
+  }
+  if (betaFeature) {
+    configFile = _path.default.join(uatDirectory, `conf/${betaReference}/actors/beta/${betaFeature}/index.js`);
+    if (!(0, _fs.existsSync)(configFile)) {
+      throw new Error(`There is no beta feature configured with the name "${betaFeature}"`);
+    }
   }
   try {
     return require(configFile);
@@ -68,42 +76,21 @@ function getListOfActors() {
   }
 }
 function getUserForSelectedEditionAndProfile(preferedEdition, preferredProfile, betaFeature, testDataPortal = null) {
-  const actorsData = getListOfActors();
+  const actorsData = getListOfActors(betaFeature);
   if (!actorsData || !actorsData.editions) {
     throw new Error("The actors data is missing.");
   }
   const {
-    editions: userdata,
-    beta: betaPortals
+    editions: userdata
   } = actorsData;
   const defaultConf = getDefaultActorConf();
   const edition = preferedEdition || defaultConf.edition;
   const profile = preferredProfile || defaultConf.profile;
   let selectedProfile = {};
-  if (betaFeature && betaFeature !== null) {
-    if (!betaPortals.hasOwnProperty(betaFeature)) {
-      throw new Error(`There is no "${betaFeature}" beta feature configured.`);
-    }
-    const betaEdition = betaPortals[betaFeature].find(portal => portal.edition === edition);
-    if (!betaEdition) {
-      throw new Error(`There is no "${edition}" edition configured in "${betaFeature}" beta feature.`);
-    }
-    const {
-      profiles: betaProfiles,
-      ...betaEditionData
-    } = betaEdition;
-    selectedProfile = betaProfiles.find(user => user.profile === profile);
-    if (!selectedProfile) {
-      throw new Error(`There is no "${profile}" configured in edition of "${edition}" in "${betaFeature}" beta features.`);
-    }
-    return {
-      ...betaEditionData,
-      ...selectedProfile
-    };
-  }
 
   // TODO: We are returning the first data from array. We need to check the possiblity of having multiple users for same profile and possibly round robin
   // For this we need to get the data from ci environment.
+
   let testingPortal = null;
   if (!userdata.hasOwnProperty(edition)) {
     throw new Error(`There is no "${edition}" edition configured.`);

package/build/core/playwright/helpers/auth/loginSteps.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
+var _fileMutex = _interopRequireDefault(require("../fileMutex"));
+var _fileMutexConfig = require("../../constants/fileMutexConfig");
 var _accountLogin = _interopRequireDefault(require("./accountLogin"));
 var _checkAuthCookies = require("./checkAuthCookies");
 /* eslint-disable no-console */
@@ -17,25 +19,33 @@ async function performLoginSteps({
   password
 }, isLoggedIn) {
   const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFilePrefix}-cookies.json`));
-  await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
-  await page.goto(process.env.domain);
-
-  // await page.waitForNavigation();
-
-  // await page.waitForLoadState('networkidle')
-
-  await Promise.race([page.waitForNavigation(), page.waitForLoadState('networkidle'), page.waitForTimeout(5000)]);
-  const loginStatus = await isLoggedIn(page);
-  if (!loginStatus) {
-    await (0, _accountLogin.default)(page, useremail, password);
+  const lockFileName = useremail.replace(/[@.]/g, '_');
+  const fileMutex = new _fileMutex.default((0, _checkAuthCookies.getAuthFileDirectory)(), lockFileName, _fileMutexConfig.LOGIN_MUTEX_TIMEOUT);
+  try {
+    const cookiesExist = await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
     await page.goto(process.env.domain);
-
-    // await page.waitForLoadState();
-
-    await isLoggedIn(page);
-    await page.context().storageState({
-      path: authFile
-    });
+    await Promise.race([page.waitForNavigation(), page.waitForLoadState('networkidle'), page.waitForTimeout(5000)]);
+    const isAlreadyLoggedIn = await isLoggedIn(page);
+    if (cookiesExist && isAlreadyLoggedIn) {
+      console.log('Account is already logged in. Skipping lock.');
+    } else {
+      await fileMutex.acquire();
+      try {
+        if (!isAlreadyLoggedIn) {
+          await (0, _accountLogin.default)(page, useremail, password);
+          await page.goto(process.env.domain);
+          await isLoggedIn(page);
+          await page.context().storageState({
+            path: authFile
+          });
+        }
+      } finally {
+        await fileMutex.release();
+      }
+    }
+  } catch (error) {
+    console.error('Error during login:', error);
+    await fileMutex.release();
   }
 }
 var _default = exports.default = performLoginSteps;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAuthDirectoryIfNotExist = createAuthDirectoryIfNotExist;
+var _fs = require("fs");
+var _checkAuthCookies = require("./auth/checkAuthCookies");
+function createAuthDirectoryIfNotExist() {
+  const authDirectory = (0, _checkAuthCookies.getAuthFileDirectory)();
+  if (!(0, _fs.existsSync)(authDirectory)) {
+    console.log('Creating auth directory for the first time setup...');
+    (0, _fs.mkdirSync)(authDirectory, {
+      recursive: true
+    });
+  }
+}

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

@@ -0,0 +1,58 @@
+"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 _lockfile = _interopRequireDefault(require("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, timeout) {
+    _classPrivateMethodInitSpec(this, _createDirectoryIfNotExist);
+    _classPrivateMethodInitSpec(this, _getLockFilePath);
+    this.directory = directory;
+    this.lockFileName = lockFileName;
+    this.timeout = timeout;
+  }
+  async acquire() {
+    _classPrivateMethodGet(this, _createDirectoryIfNotExist, _createDirectoryIfNotExist2).call(this);
+    return new Promise((resolve, reject) => {
+      _lockfile.default.lock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this), this.timeout, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  async release() {
+    return new Promise((resolve, reject) => {
+      _lockfile.default.unlock(_classPrivateMethodGet(this, _getLockFilePath, _getLockFilePath2).call(this), err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+function _getLockFilePath2() {
+  return _path.default.resolve(_path.default.join(this.directory, `/${this.lockFileName}.lock`));
+}
+function _createDirectoryIfNotExist2() {
+  if (!(0, _fs.existsSync)(this.directory)) {
+    (0, _fs.mkdirSync)(this.directory, {
+      recursive: true
+    });
+  }
+}
+var _default = exports.default = FileMutex;

package/build/core/playwright/index.js

@@ -1,24 +1,37 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createBdd = void 0;
-Object.defineProperty(exports, "expect", {
+Object.defineProperty(exports, "createBdd", {
   enumerable: true,
   get: function () {
-    return _test.expect;
+    return _bddFramework.createBdd;
   }
 });
-Object.defineProperty(exports, "test", {
+Object.defineProperty(exports, "expect", {
   enumerable: true,
   get: function () {
-    return _playwrightBdd.test;
+    return _test.expect;
   }
 });
-var _playwrightBdd = require("playwright-bdd");
+exports.test = void 0;
+var _bddFramework = require("../../bdd-framework");
 var _test = require("@playwright/test");
-let createBdd = function () {
-  return (0, _playwrightBdd.createBdd)(_playwrightBdd.test);
-};
-exports.createBdd = createBdd;
+var _readConfigFile = require("./readConfigFile");
+var _builtInFixtures = _interopRequireDefault(require("./builtInFixtures"));
+var _getUserFixtures = _interopRequireDefault(require("./helpers/getUserFixtures"));
+const {
+  bddMode
+} = (0, _readConfigFile.generateConfigFromFile)();
+let base = bddMode ? _bddFramework.test : _test.test;
+const buildInFixtures = (0, _builtInFixtures.default)(bddMode);
+const buildInFixturesTest = base.extend({
+  ...buildInFixtures
+});
+const userFixtures = (0, _getUserFixtures.default)();
+const userFixturesTest = base.extend({
+  ...userFixtures
+});
+const test = exports.test = (0, _test.mergeTests)(buildInFixturesTest, userFixturesTest);

package/build/core/playwright/setup/config-creator.js

@@ -39,12 +39,12 @@ const testDir = (0, _configUtils.getTestDir)(bddMode, process.cwd(), {
   featureFilesFolder,
   stepDefinitionsFolder
 });
-const use = {
+const testOptions = (0, _configUtils.getTestUseOptions)({
   trace,
   video,
   viewport,
   testIdAttribute
-};
+});
 
 /**
  * Playwright configuration object
@@ -65,7 +65,7 @@ function getPlaywrightConfig() {
     expect: {
       timeout: expectTimeout
     },
-    use,
+    use: testOptions,
     projects: isAuthMode ? [{
       name: 'setup',
       testMatch: /.*\.setup\.js/,

package/build/core/playwright/setup/config-utils.js

@@ -7,12 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.getBrowsersList = getBrowsersList;
 exports.getProjects = getProjects;
 exports.getTestDir = getTestDir;
+exports.getTestUseOptions = getTestUseOptions;
 var _test = require("@playwright/test");
 var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
-var _playwrightBdd = require("playwright-bdd");
+var _bddFramework = require("../../../bdd-framework");
 var _logger = require("../../../utils/logger");
 var _browserTypes = require("../constants/browserTypes");
+var _configFileNameProvider = require("../helpers/configFileNameProvider");
 var _fileUtils = require("../../../utils/fileUtils");
 /**
  ** Playwright project configuration
@@ -146,15 +148,30 @@ function getPathsForFeatureFiles(cwd) {
 function getTestDir(bddMode, cwd, {
   stepDefinitionsFolder
 }) {
-  return bddMode ? (0, _playwrightBdd.defineBddConfig)({
-    features: getPathsForFeatureFiles(cwd),
-    steps: [_path.default.join(cwd, 'uat', '**', stepDefinitionsFolder, '*.spec.js'), require.resolve('../fixtures.js')],
-    importTestFrom: require.resolve('../fixtures.js'),
+  return bddMode ? (0, _bddFramework.defineBddConfig)({
+    paths: getPathsForFeatureFiles(cwd),
+    import: [_path.default.join(cwd, 'uat', '**', stepDefinitionsFolder, '*.spec.js')],
     featuresRoot: _path.default.join(cwd, 'uat'),
     outputDir: _path.default.join(cwd, 'uat', '.features-gen'),
-    disableWarnings: {
-      importTestFrom: true
-    },
     publish: true
   }) : _path.default.join(cwd, 'uat');
+}
+function getTestUseOptions({
+  viewport,
+  trace,
+  video,
+  testIdAttribute
+}) {
+  let defaultTestuseOptions = {
+    viewport,
+    testIdAttribute,
+    trace: trace ? 'on' : 'off',
+    video: video ? {
+      mode: 'on',
+      size: {
+        ...viewport
+      }
+    } : 'off'
+  };
+  return defaultTestuseOptions;
 }

package/build/core/playwright/test-runner.js

@@ -43,7 +43,7 @@ function getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless) {
 }
 function runPreprocessing(tagArgs, configPath) {
   const beforeCommand = 'node';
-  const bddGenPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('bddgen'));
+  const bddGenPath = _path.default.resolve(__dirname, '../', '../', 'bdd-framework', 'cli', 'index.js');
   const beforeArgs = [bddGenPath, '-c', configPath];
   if (tagArgs) {
     beforeArgs.push('--tags');

package/build/decorators.d.ts

@@ -1 +1 @@
-export * from 'playwright-bdd/decorators';
+export * from './bdd-framework/decorators';

package/build/decorators.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _decorators = require("playwright-bdd/decorators");
+var _decorators = require("./bdd-framework/decorators");
 Object.keys(_decorators).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _decorators[key]) return;

package/build/setup-folder-structure/samples/auth-setup-sample.js

@@ -1,21 +1,73 @@
 /* eslint-disable no-console */
 import { test as setup, expect } from '@zohodesk/testinglibrary';
-import {
-  performLoginSteps,
-  getDefaultActor
-} from '@zohodesk/testinglibrary/helpers';
+import path from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { getAuthFileDirectory } from '../../core/playwright';
+import { Logger } from '../../utils/logger';
 
-const user = getDefaultActor();
+const userdata = require('./authUsers.json');
 
-async function verifyPageIsLoaded(page) {
-  //Implement your validation steps here
-  //Refer desk_client_app auth.setup.js
-  return true;
+const authContent = { cookies: [] };
+
+const LOGIN_ERR_MESSAGE = 'Need go be logged in';
+// const AUTH_ERR_MESSAGE = `Founded Path - ${path.resolve(process.cwd(),'uat','playwright','.auth')} \n Find if file is Properly Created. Cookies Cannot Be Read .. `
+
+function convertCookiesToParse(cookies, authFilePath) {
+  try {
+    return JSON.parse(cookies);
+  } catch (err) {
+    Logger.error(err);
+    throw new Error(
+      ` Error while parsing cookies ${err} \n${path.resolve(
+        process.cwd(),
+        authFilePath
+      )} File is Empty`
+    );
+    // process.exit()
+  }
+}
+const authDirectory = getAuthFileDirectory(); //path.resolve(process.cwd(), 'uat', 'playwright', '.auth');
+if (!existsSync(authDirectory)) {
+  console.log('Creating auth directory for the first time setup...');
+  mkdirSync(authDirectory, { recursive: true });
 }
 
-setup(`${user.edition} - Authentication`, async ({ page }) => {
+userdata.forEach(data => {
+  const authFile = path.resolve(path.join(authDirectory, `${data.filename}`));
+  if (!existsSync(authFile)) {
+    console.log('creating auth file..');
+    writeFileSync(authFile, JSON.stringify(authContent, null, 2));
+  }
+  setup(data.description, async ({ page }) => {
+    try {
+      const cookies = readFileSync(authFile);
+      const parsedCookies = convertCookiesToParse(cookies, authFile);
+      await page
+        .context()
+        .addCookies(
+          parsedCookies.cookies === undefined ? [] : parsedCookies.cookies
+        );
+      await page.goto(page.getBaseUrl());
+      await page.waitForLoadState();
+      if (await page.url().includes(process.env.domain)) {
+        await page.waitForSelector(data.locator);
+      } else {
+        throw new Error(LOGIN_ERR_MESSAGE);
+      }
+    } catch (err) {
+      if (err.message === LOGIN_ERR_MESSAGE) {
+        await expect(page.locator('.load-bg')).toBeHidden();
+        await page.locator('#login_id').type(data.useremail);
+        await page.locator('#nextbtn').click();
+        await page.locator('#password').type(data.password);
+        await page.locator('#nextbtn').click();
+
+        await page.waitForLoadState('networkidle');
+
+        await page.waitForSelector(data.locator);
 
-  //Implement performLoginSteps here
-  const { email, password } = user;
-  await performLoginSteps({ },verifyPageIsLoaded );
-});
+        await page.context().storageState({ path: authFile });
+      }
+    }
+  });
+});

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

@@ -0,0 +1,9 @@
+[
+    {
+        "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

@@ -0,0 +1,21 @@
+{
+  "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/setup-folder-structure/setupProject.js

@@ -10,9 +10,8 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../utils/logger");
 function getScriptsToBeAdded() {
   return {
-    "uat": "ZDTestingFramework test --mode=dev --headed",
-    "uat-debug": "ZDTestingFramework test --mode=dev --debug",
-    "uat-validate": "ZDTestingFramework validate",
+    "uat": "ZDTestingFramework test --mode=prod --headed",
+    "uat-debug": "ZDTestingFramework test --mode=prod --debug",
     "uat-report": "ZDTestingFramework report --port=9009",
     "codegen": "ZDTestingFramework codegen deskclientapp.localzoho.com/agent"
   };
@@ -72,6 +71,7 @@ function createAuthenticationFile() {
         });
       }
       (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'auth.setup.js'), getSetupFileAsString('auth-setup-sample.js'), null, 2);
+      (0, _fs.writeFileSync)(_path.default.resolve(process.cwd(), 'uat', 'fixtures', 'authUsers.json'), getSetupFileAsString('authUsers-sample.json'), null, 2);
       _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating Authentication File ....');
     } catch (err) {
       _logger.Logger.error(err);
@@ -84,21 +84,8 @@ function createAuthenticationFile() {
 function createConfigJson() {
   const uatFolder = _path.default.resolve(process.cwd(), 'uat');
   if ((0, _fs.existsSync)(uatFolder)) {
-    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating settings.json file inside UAT Folder');
-    if (!(0, _fs.existsSync)(_path.default.resolve(uatFolder, 'conf', 'default'))) {
-      (0, _fs.mkdirSync)(_path.default.resolve(uatFolder, 'conf', 'default'), {
-        recursive: true
-      });
-    }
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', './settings.json'), getSetupFileAsString('settings.json'), null, 2);
-    if (!(0, _fs.existsSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions'))) {
-      (0, _fs.mkdirSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions'), {
-        recursive: true
-      });
-    }
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions', 'free.json'), getSetupFileAsString('free-sample.json'), null, 2);
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'editions', 'index.js'), getSetupFileAsString('editions-index.js'), null, 2);
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, 'conf', 'default', 'actors', 'index.js'), getSetupFileAsString('actors-index.js'), null, 2);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Creating env-config file inside UAT Folder');
+    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, './env-config.json'), getSetupFileAsString('env-config-sample.json'), null, 2);
   } else {
     _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Something went wrong. Please re-initialize the @zohodesk/testinglibrary');
   }

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

@@ -0,0 +1,94 @@
+"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();
+    });
+  });
+});