@zohodesk/testinglibrary 0.4.19-experimental → 0.4.21-experimental

package/build/decorators.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _decorators = require("./bdd-framework/decorators");
+var _decorators = require("playwright-bdd/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,73 +1,21 @@
 /* eslint-disable no-console */
 import { test as setup, expect } from '@zohodesk/testinglibrary';
-import path from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { getAuthFileDirectory } from '../../core/playwright';
-import { Logger } from '../../utils/logger';
+import {
+  performLoginSteps,
+  getDefaultActor
+} from '@zohodesk/testinglibrary/helpers';
 
-const userdata = require('./authUsers.json');
+const user = getDefaultActor();
 
-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 });
+async function verifyPageIsLoaded(page) {
+  //Implement your validation steps here
+  //Refer desk_client_app auth.setup.js
+  return true;
 }
 
-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);
+setup(`${user.edition} - Authentication`, async ({ page }) => {
 
-        await page.context().storageState({ path: authFile });
-      }
-    }
-  });
-});
+  //Implement performLoginSteps here
+  const { email, password } = user;
+  await performLoginSteps({ },verifyPageIsLoaded );
+});

package/build/setup-folder-structure/samples/editions-index.js

@@ -0,0 +1,3 @@
+const free = require('./free.json');
+const editions = { free};
+module.exports = editions;

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

@@ -0,0 +1,25 @@
+[
+    {
+      "id": "1",
+      "edition": "free",
+      "orgName": "orgFree",
+      "profiles": [
+        {
+          "profile": "admin",
+          "email": "admin+free@zohotest.com",
+          "password": "password@0987"
+        },
+        {
+          "profile": "agent",
+          "email": "agent@zohotest.com",
+          "password": "password@12345"
+        },
+        {
+          "profile": "lightagent",
+          "email": "lightagent@zohotest.com",
+          "password": "password@12345"
+        }
+      ]
+    }
+  ]
+  

package/{nobdd/uat/conf/default → build/setup-folder-structure/samples}/settings.json

@@ -1,6 +1,7 @@
 {
-  "environment": "ci",
+  "environment": "dev",
   "edition": "enterprise",
   "profile": "admin",
-  "domain": "https://zdesk-devops16.csez.zohocorpin.com:31025/agent"
-}
+  "domain": "https://zdesk-devops16.csez.zohocorpin.com:31025/agent",
+  "devUrl" : "" 
+}

package/build/setup-folder-structure/setupProject.js

@@ -10,8 +10,9 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../utils/logger");
 function getScriptsToBeAdded() {
   return {
-    "uat": "ZDTestingFramework test --mode=prod --headed",
-    "uat-debug": "ZDTestingFramework test --mode=prod --debug",
+    "uat": "ZDTestingFramework test --mode=dev --headed",
+    "uat-debug": "ZDTestingFramework test --mode=dev --debug",
+    "uat-validate": "ZDTestingFramework validate",
     "uat-report": "ZDTestingFramework report --port=9009",
     "codegen": "ZDTestingFramework codegen deskclientapp.localzoho.com/agent"
   };
@@ -71,7 +72,6 @@ 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,8 +84,21 @@ 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 env-config file inside UAT Folder');
-    (0, _fs.writeFileSync)(_path.default.resolve(uatFolder, './env-config.json'), getSetupFileAsString('env-config-sample.json'), null, 2);
+    _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);
   } 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

@@ -2,93 +2,70 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _fileMutex = _interopRequireDefault(require("../../../../../core/playwright/helpers/fileMutex"));
-var _lockfile = _interopRequireDefault(require("lockfile"));
+var _properLockfile = _interopRequireDefault(require("proper-lockfile"));
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
-jest.mock('lockfile');
+jest.mock('proper-lockfile');
 jest.mock('fs');
 describe('FileMutex', () => {
-  const mockDirectory = '/tmp';
-  const mockFileName = 'test_user';
-  const mockTimeout = {
-    wait: 5000,
-    retries: 5,
-    stale: 60000
+  const directory = '/tmp/locks';
+  const lockFileName = 'test-lock';
+  const options = {
+    stale: 10000,
+    retries: {
+      retries: 5,
+      factor: 1,
+      minTimeout: 5000,
+      maxTimeout: 8000
+    }
   };
+  const lockFilePath = _path.default.resolve(directory, lockFileName + '.lock');
   let fileMutex;
   beforeEach(() => {
-    fileMutex = new _fileMutex.default(mockDirectory, mockFileName, mockTimeout);
-  });
-  afterEach(() => {
+    fileMutex = new _fileMutex.default(directory, lockFileName, options);
     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 () => {
+    it('should create the directory if it does not exist', 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, {
+      _fs.default.mkdirSync.mockImplementation(() => {});
+      _properLockfile.default.lock.mockResolvedValue();
+      await fileMutex.acquire();
+      expect(_fs.default.existsSync).toHaveBeenCalledWith(directory);
+      expect(_fs.default.mkdirSync).toHaveBeenCalledWith(directory, {
         recursive: true
       });
-      expect(_lockfile.default.lock).toHaveBeenCalled();
     });
-    it('should not create the directory if it already exists', async () => {
+    it('should create the lock file if it does not exist', async () => {
+      _fs.default.existsSync.mockImplementation(filePath => filePath !== lockFilePath);
+      _fs.default.writeFileSync.mockImplementation(() => {});
+      _properLockfile.default.lock.mockResolvedValue();
+      await fileMutex.acquire();
+      expect(_fs.default.existsSync).toHaveBeenCalledWith(lockFilePath);
+      expect(_fs.default.writeFileSync).toHaveBeenCalledWith(lockFilePath, 'locked');
+    });
+    it('should acquire the lock using proper-lockfile', 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();
+      _properLockfile.default.lock.mockResolvedValue();
+      await fileMutex.acquire();
+      expect(_properLockfile.default.lock).toHaveBeenCalledWith(lockFilePath, options);
+    });
+    it('should throw an error if lock acquisition fails', async () => {
+      const errorMessage = 'Lock acquisition failed';
+      _properLockfile.default.lock.mockRejectedValue(new Error(errorMessage));
+      await expect(fileMutex.acquire()).rejects.toThrow(`Failed to acquire lock after ${options.retries.retries} attempts: ${errorMessage}`);
     });
   });
   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 release the lock using proper-lockfile', async () => {
+      _properLockfile.default.unlock.mockResolvedValue();
+      await fileMutex.release();
+      expect(_properLockfile.default.unlock).toHaveBeenCalledWith(lockFilePath);
     });
-    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();
+    it('should throw an error if lock release fails', async () => {
+      const errorMessage = 'Lock release failed';
+      _properLockfile.default.unlock.mockRejectedValue(new Error(errorMessage));
+      await expect(fileMutex.release()).rejects.toThrow(`Failed to release lock: ${errorMessage}`);
     });
   });
 });

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();
+    });
+  });
+});