@zohodesk/testinglibrary 0.1.9 → 0.1.16-experimental

package/build/test/core/playwright/buildInFixtures/__tests__/caseTimeout.test.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _caseTimeout = _interopRequireDefault(require("../../../../../core/playwright/builtInFixtures/caseTimeout"));
+var _caseTimeoutResolver = require("../../../../../core/playwright/helpers/caseTimeoutResolver");
+var _browserTypes = require("../../../../../core/playwright/constants/browserTypes");
+var _logger = require("../../../../../utils/logger");
+jest.mock('../../../../../utils/logger');
+describe('resolveCaseTimeoutMs', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('returns null when no timeout tag is present', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@smoke', '@edition_Free'], _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBeNull();
+  });
+  test('returns null when tags is not an array', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(undefined, _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBeNull();
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(null, _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBeNull();
+  });
+  test('parses @timeout_<n> as seconds for Chrome (factor 1)', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_180'], _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBe(180000);
+  });
+  test('applies Firefox 2x multiplier', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_180'], _browserTypes.BROWSER_PROJECT_MAPPING.FIREFOX)).toBe(360000);
+  });
+  test('returns 0 (no timeout) when tag is @timeout_0, regardless of browser', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_0'], _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBe(0);
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_0'], _browserTypes.BROWSER_PROJECT_MAPPING.FIREFOX)).toBe(0);
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_0'], _browserTypes.BROWSER_PROJECT_MAPPING.SAFARI)).toBe(0);
+  });
+  test('uses the first matching tag and logs a warning when multiple are present', () => {
+    const result = (0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_120', '@timeout_300'], _browserTypes.BROWSER_PROJECT_MAPPING.CHROME);
+    expect(result).toBe(120_000);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('Multiple @timeout_* tags found'));
+  });
+  test('ignores malformed timeout-like tags', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_', '@timeout_abc', '@timeout_-5', '@timeoutfoo'], _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBeNull();
+  });
+  test('ignores non-string entries in tags', () => {
+    expect((0, _caseTimeoutResolver.resolveCaseTimeoutMs)(['@timeout_60', null, undefined, 42], _browserTypes.BROWSER_PROJECT_MAPPING.CHROME)).toBe(60_000);
+  });
+});
+describe('caseTimeout fixture', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  function getFixture() {
+    return _caseTimeout.default.caseTimeout[0];
+  }
+  test('is registered as an auto fixture', () => {
+    expect(_caseTimeout.default.caseTimeout[1]).toEqual({
+      auto: true
+    });
+  });
+  test('calls testInfo.setTimeout with scaled value when tag matches', async () => {
+    const use = jest.fn();
+    const testInfo = {
+      project: {
+        name: _browserTypes.BROWSER_PROJECT_MAPPING.FIREFOX
+      },
+      setTimeout: jest.fn()
+    };
+    await getFixture()({
+      $tags: ['@timeout_30']
+    }, use, testInfo);
+    expect(testInfo.setTimeout).toHaveBeenCalledWith(60_000);
+    expect(use).toHaveBeenCalled();
+  });
+  test('does not call testInfo.setTimeout when no tag is present', async () => {
+    const use = jest.fn();
+    const testInfo = {
+      project: {
+        name: _browserTypes.BROWSER_PROJECT_MAPPING.CHROME
+      },
+      setTimeout: jest.fn()
+    };
+    await getFixture()({
+      $tags: ['@smoke']
+    }, use, testInfo);
+    expect(testInfo.setTimeout).not.toHaveBeenCalled();
+    expect(use).toHaveBeenCalled();
+  });
+  test('passes 0 through to testInfo.setTimeout for @timeout_0', async () => {
+    const use = jest.fn();
+    const testInfo = {
+      project: {
+        name: _browserTypes.BROWSER_PROJECT_MAPPING.SAFARI
+      },
+      setTimeout: jest.fn()
+    };
+    await getFixture()({
+      $tags: ['@timeout_0']
+    }, use, testInfo);
+    expect(testInfo.setTimeout).toHaveBeenCalledWith(0);
+  });
+});

package/build/test/core/playwright/buildInFixtures/__tests__/executionContext.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _customFixturesHelper = require("../../../../../core/playwright/helpers/customFixturesHelper");
+var _executionContext = _interopRequireDefault(require("../../../../../core/playwright/builtInFixtures/executionContext"));
+jest.mock('../../../../../core/playwright/helpers/customFixturesHelper');
+describe('executionContext', () => {
+  test('should pass actorInfo with details from getCustomAccountDetails to use', async () => {
+    const mockTags = ['tag1', 'tag2'];
+    const mockMainActorInfo = {
+      id: '1',
+      edition: 'enterprise',
+      orgName: 'orgName',
+      profile: 'admin',
+      email: 'xxx.x+uat@zohotest.com'
+    };
+    _customFixturesHelper.getCustomAccountDetails.mockReturnValue(mockMainActorInfo);
+    const use = jest.fn();
+    await _executionContext.default.executionContext({
+      $tags: mockTags
+    }, use);
+    expect(_customFixturesHelper.getCustomAccountDetails).toHaveBeenCalledWith(mockTags);
+    expect(use).toHaveBeenCalledWith({
+      actorInfo: mockMainActorInfo
+    });
+  });
+});

package/build/test/core/playwright/configuration/__tests__/Configuration.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const Configuration = require("../../../../../core/playwright/configuration/Configuration");
+const {
+  combineConfiguration
+} = require("../../../../../core/playwright/configuration/ConfigurationHelper");
+jest.mock('../../../../../core/playwright/configuration/ConfigurationHelper', () => ({
+  combineConfiguration: jest.fn()
+}));
+describe('Configuration Class', () => {
+  let config;
+  let sampleData;
+  beforeEach(() => {
+    // Sample data as a JSON object
+    sampleData = {
+      headless: false,
+      trace: true,
+      video: true,
+      bddMode: true
+    };
+
+    // Initialize the Configuration instance with sample data
+    config = new Configuration(sampleData);
+  });
+  test('should add new key-value pair to the configuration', () => {
+    config.add('newKey', 'newValue');
+    expect(config.get('newKey')).toBe('newValue');
+  });
+  test('should combine configurations correctly using addAll', () => {
+    const newConfig = new Configuration({
+      newKey1: 'newValue1',
+      trace: false // existing key to test override
+    });
+    const combinedConfig = {
+      headless: false,
+      trace: false,
+      // trace overridden
+      video: true,
+      bddMode: true,
+      newKey1: 'newValue1'
+    };
+    combineConfiguration.mockReturnValue(combinedConfig);
+    config.addAll(newConfig);
+    expect(combineConfiguration).toHaveBeenCalledWith(sampleData, newConfig.getAll());
+    expect(config.getAll()).toEqual(combinedConfig);
+  });
+  test('should return correct value for a given key', () => {
+    expect(config.get('headless')).toBe(false);
+    expect(config.get('trace')).toBe(true);
+    expect(config.get('video')).toBe(true);
+    expect(config.get('bddMode')).toBe(true);
+  });
+});

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

@@ -0,0 +1,45 @@
+"use strict";
+
+var _additionalProfiles = require("../../../../../core/playwright/helpers/additionalProfiles");
+jest.mock('../../../../../core/playwright/helpers/auth/getUsers', () => ({
+  getUserForSelectedEditionAndProfile: jest.fn((edition, profile, betaFeature, portalInfo) => {
+    return {
+      email: 'manager.m@zohotest.com',
+      id: '1',
+      edition: edition || 'enterprise',
+      orgName: 'orgName',
+      profile: profile || 'admin',
+      betaFeature: betaFeature || null,
+      portalInfo: portalInfo || null
+    };
+  })
+}));
+const defaultTags = ['@profile_admin', '@edition_enterprise'];
+const editionTags = ['@profile_admin', '@edition_enterprise', '@additional_profile_manager', '@additional_profile_agent'];
+const editionAndPortalTags = ['@profile_admin', '@edition_enterprise', '@beta_parentchild', '@portal_clientuat2', '@additional_profile_manager'];
+describe('additionalProfiles', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('should return empty object when no additional profile tags are present', () => {
+    const result = (0, _additionalProfiles.additionProfiles)(defaultTags);
+    expect(result).toEqual({});
+  });
+  test('should return additional profile actors when additional profile tags and editionInfo are present', () => {
+    const result = (0, _additionalProfiles.additionProfiles)(editionTags);
+    expect(Object.keys(result)).toEqual(['manager', 'agent']);
+    expect(result.manager).toHaveProperty('email');
+    expect(result.agent).toHaveProperty('email');
+    expect(result.manager.profile).toBe('manager');
+    expect(result.manager.betaFeature).toBe(null);
+    expect(result.agent.portalInfo).toBe(null);
+  });
+  test('should return additional profile actors when all actor details are present', () => {
+    const result = (0, _additionalProfiles.additionProfiles)(editionAndPortalTags);
+    expect(Object.keys(result)).toEqual(['manager']);
+    expect(result.manager).toHaveProperty('email');
+    expect(result.manager.profile).toBe('manager');
+    expect(result.manager.betaFeature).toBe("parentchild");
+    expect(result.manager.portalInfo).toBe("clientuat2");
+  });
+});

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

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _configFileNameProvider = require("../../../../../core/playwright/helpers/configFileNameProvider");
+var _configPathResolver = require("../../../../../core/playwright/helpers/configPathResolver");
+jest.mock('fs');
+jest.mock('path', () => ({
+  resolve: jest.fn()
+}));
+jest.mock("../../../../../core/playwright/helpers/configPathResolver", () => ({
+  getConfigPath: jest.fn()
+}));
+const mockCwd = '/mock/current/directory';
+_path.default.resolve = jest.fn();
+process.cwd = jest.fn(() => mockCwd);
+describe('getUATFileName', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _path.default.resolve.mockImplementation((...segments) => segments.join('/'));
+  });
+  test('should return pipeline-matched config path when file exists', () => {
+    const stage = 'uat';
+    const mode = 'cd';
+    _configPathResolver.getConfigPath.mockReturnValue(`${stage}/conf`);
+    _fs.existsSync.mockReturnValue(true);
+    const expected = `${process.cwd()}/${stage}/conf/${mode}/uat.config.js`;
+    const result = (0, _configFileNameProvider.getUATFileName)(stage, mode);
+    expect(_configPathResolver.getConfigPath).toHaveBeenCalledWith(stage);
+    expect(_fs.existsSync).toHaveBeenCalledWith(expected);
+    expect(result).toBe(expected);
+  });
+  test('should use default stage and mode when not provided', () => {
+    const mode = 'dev';
+    const stageConfigPath = 'uat/conf';
+    const expectedPath = `${mockCwd}/${stageConfigPath}/${mode}/uat.config.js`;
+    _fs.existsSync.mockReturnValue(true);
+    const result = (0, _configFileNameProvider.getUATFileName)(mode);
+    expect(_fs.existsSync).toHaveBeenCalledWith(`${mockCwd}/uat/conf/${mode}/uat.config.js`);
+    expect(result).toBe(expectedPath);
+  });
+  test('should return the default config files for pipeline matched files not exists', () => {
+    const mockStage = 'uat';
+    const mockMode = 'ci';
+    const stageConfigPath = 'uat/conf';
+    const nonExistingPath = `${mockCwd}/${stageConfigPath}/${mockMode}/uat.config.js`;
+    const expectedDefaultPath = `${mockCwd}/${mockStage}/conf/default/uat.config.js`;
+    _configPathResolver.getConfigPath.mockReturnValue(stageConfigPath);
+    _fs.existsSync.mockReturnValue(false);
+    const result = (0, _configFileNameProvider.getUATFileName)(mockStage, mockMode);
+    expect(_fs.existsSync).toHaveBeenCalledWith(nonExistingPath);
+    expect(result).toBe(expectedDefaultPath);
+  });
+});
+describe('getEnvConfigFilePath', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _path.default.resolve.mockImplementation((...segments) => segments.join('/'));
+  });
+  test('should return conf file path when file exists', () => {
+    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
+    _fs.existsSync.mockReturnValue(true);
+    const result = (0, _configFileNameProvider.getEnvConfigFilePath)('uat', 'cd');
+    expect(_configPathResolver.getConfigPath).toHaveBeenCalledWith('uat');
+    expect(_fs.existsSync).toHaveBeenCalled();
+    expect(result).toBe('uat/conf/cd/settings.json');
+  });
+  test('should return default path when file does not exist', () => {
+    _configPathResolver.getConfigPath.mockReturnValue('uat/conf');
+    _fs.existsSync.mockReturnValue(false);
+    const result = (0, _configFileNameProvider.getEnvConfigFilePath)('uat', 'ci');
+    expect(result).toBe('uat/conf/default/settings.json');
+  });
+});

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

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _propertiesReader = _interopRequireDefault(require("properties-reader"));
+var _configPathResolver = require("../../../../../core/playwright/helpers/configPathResolver");
+var _logger = require("../../../../../utils/logger");
+var _configConstants = _interopRequireDefault(require("../../../../../core/playwright/constants/configConstants"));
+jest.mock('fs');
+jest.mock('path');
+jest.mock('properties-reader');
+jest.mock('../../../../../utils/logger', () => ({
+  Logger: {
+    log: jest.fn(),
+    INFO_TYPE: 'info',
+    FAILURE_TYPE: 'failure'
+  }
+}));
+describe('getConfigPath', () => {
+  const mockProps = {
+    get: jest.fn(),
+    set: jest.fn()
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _propertiesReader.default.mockReturnValue(mockProps);
+    _path.default.resolve.mockImplementation((...args) => args.join('/'));
+  });
+  test('should return config path when properties file exists and has mapping', () => {
+    _fs.default.existsSync.mockReturnValue(true);
+    mockProps.get.mockReturnValue('uat/conf');
+    const result = (0, _configPathResolver.getConfigPath)('uat');
+    expect(_fs.default.existsSync).toHaveBeenCalledWith(expect.stringContaining(_configConstants.default.STAGE_CONFIG_MAP_FILE));
+    expect(_propertiesReader.default).toHaveBeenCalled();
+    expect(mockProps.get).toHaveBeenCalledWith('uat');
+    expect(result).toBe('uat/conf');
+    expect(_logger.Logger.log).not.toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, expect.any(String));
+  });
+  test('should log info and use default mapping if file does not exist', () => {
+    _fs.default.existsSync.mockReturnValue(false);
+    mockProps.get.mockImplementation(key => key === 'uat' ? 'uat/conf' : undefined);
+    const result = (0, _configPathResolver.getConfigPath)('uat');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('not found'));
+    expect(mockProps.set).toHaveBeenCalledWith('uat', 'uat/conf');
+    expect(result).toBe('uat/conf');
+  });
+  test('should log failure if config mapping not found for stage', () => {
+    _fs.default.existsSync.mockReturnValue(true);
+    mockProps.get.mockReturnValue(undefined);
+    const result = (0, _configPathResolver.getConfigPath)('stageX');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, expect.stringContaining('stageX'));
+    expect(result).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,51 @@
+"use strict";
+
+var _customFixturesHelper = require("../../../../../core/playwright/helpers/customFixturesHelper");
+var _logger = require("../../../../../utils/logger");
+var _getUsers = require("../../../../../core/playwright/helpers/auth/getUsers");
+jest.mock('../../../../../core/playwright/helpers/auth/getUsers', () => ({
+  getUserForSelectedEditionAndProfile: jest.fn((edition, profile, betaFeature, portalInfo) => ({
+    email: 'manager.m@zohotest.com',
+    id: '1',
+    edition: edition || 'enterprise',
+    orgName: 'orgName',
+    profile: profile || 'admin',
+    betaFeature: betaFeature || null,
+    portalInfo: portalInfo || null
+  })),
+  getDefaultActor: jest.fn(() => ({
+    edition: 'enterprise',
+    profile: 'admin'
+  }))
+}));
+jest.mock('../../../../../utils/logger', () => ({
+  Logger: {
+    log: jest.fn(),
+    FAILURE_TYPE: 'FAILURE'
+  }
+}));
+const mockTags = ['@profile_admin', '@edition_enterprise', '@beta_feature', '@portal_clientuat'];
+describe('getCustomAccountDetails', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('returns selected user when any tag info is present', () => {
+    const result = (0, _customFixturesHelper.getCustomAccountDetails)(mockTags);
+    expect(_getUsers.getUserForSelectedEditionAndProfile).toHaveBeenCalledWith('enterprise', 'admin', 'feature', 'clientuat');
+    expect(result).toHaveProperty('email', 'manager.m@zohotest.com');
+  });
+  test('logs and returns undefined if getCustomAccountDetails function throws', () => {
+    const error = new Error('failed to get user');
+    _getUsers.getUserForSelectedEditionAndProfile.mockImplementation(() => {
+      throw error;
+    });
+    const result = (0, _customFixturesHelper.getCustomAccountDetails)(mockTags);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, 'Error while getting accounts details:', error);
+    expect(result).toBeUndefined();
+  });
+  test('returns default actor when no tag info is not provided', () => {
+    const result = (0, _customFixturesHelper.getCustomAccountDetails)([]);
+    expect(_getUsers.getDefaultActor).toHaveBeenCalledTimes(1);
+    expect(result).toEqual((0, _getUsers.getDefaultActor)());
+  });
+});