@zohodesk/testinglibrary 0.1.9 → 0.1.16-experimental

package/build/test/core/dataGenerator/authenticator/__tests__/Authenticator.test.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _Authenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/Authenticator"));
+describe('Authenticator', () => {
+  it('should throw an error when an unknown authentication type is present', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {
+        name: 'sample'
+      }
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['apikey', 'basic']
+        }
+      }
+    };
+    await expect(authenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('Unknown authentication type: "apikey"');
+  });
+  it('should route iam-oauth2-schema authentication and merge oauth2 config into payload', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['iam-oauth2-schema'],
+          oauth2: {
+            client_id: 'client_1',
+            client_secret: 'secret_1'
+          }
+        }
+      }
+    };
+    const result = await authenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      client_id: 'client_1',
+      client_secret: 'secret_1'
+    });
+  });
+  it('should treat authentication values case-insensitively and deduplicate them', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['IAM-OAUTH2-SCHEMA', 'iam-oauth2-schema', 'Iam-Oauth2-Schema'],
+          oauth2: {
+            scope: 'read'
+          }
+        }
+      }
+    };
+    const result = await authenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      scope: 'read'
+    });
+  });
+  it('should apply only the first supported authentication type', async () => {
+    const authenticator = new _Authenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          authentications: ['iam-oauth2-schema', 'org-oauth'],
+          oauth2: {
+            client_id: 'oauth-client'
+          },
+          org_oauth: {
+            org_id: 'org-101'
+          }
+        }
+      }
+    };
+    const result = await authenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      client_id: 'oauth-client'
+    });
+    expect(result.account.org_oauth).toBeUndefined();
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/JWTauthenticator.test.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _JWTauthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/JWTauthenticator"));
+describe('JWTauthenticator', () => {
+  let requestPostMock;
+  let page;
+  beforeEach(() => {
+    requestPostMock = jest.fn();
+    page = {
+      request: {
+        post: requestPostMock
+      }
+    };
+    process.env.DG_JWT_AUTH_URL = 'https://jwt-auth.example.com';
+    process.env.DG_DOMAIN_URL = 'https://domain.example.com';
+    process.env.DG_JWT_AUTHENTICATOR_API = 'https://authenticator.example.com/jwtToken';
+  });
+  afterEach(() => {
+    delete process.env.DG_JWT_AUTH_URL;
+    delete process.env.DG_DOMAIN_URL;
+    delete process.env.DG_JWT_AUTHENTICATOR_API;
+  });
+  it('should throw when jwt-oauth config is missing', async () => {
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {}
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo, page)).rejects.toThrow('JWT authentication failed: "jwt-oauth" is missing in actor configuration');
+    expect(requestPostMock).not.toHaveBeenCalled();
+  });
+  it('should fetch jwt access token and set it in authHeaders', async () => {
+    requestPostMock.mockResolvedValue({
+      ok: () => true,
+      status: () => 200,
+      text: async () => '',
+      json: async () => ({
+        access_token: 'access-token-123'
+      })
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user.one@example.com',
+      'data-generator': {
+        account: {
+          'jwt-oauth': {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id',
+            token_url: 'https://token.example.com/12345/oauth'
+          }
+        }
+      }
+    };
+    const result = await jwtAuthenticator.constructPayload(apiPayload, actorInfo, page);
+    expect(requestPostMock).toHaveBeenCalledTimes(1);
+    expect(requestPostMock).toHaveBeenCalledWith('https://authenticator.example.com/jwtToken', expect.objectContaining({
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      data: expect.objectContaining({
+        user_token: encodeURIComponent('user.one@example.com'),
+        jwt_secret: 'jwt-secret',
+        jwt_auth_url: 'https://jwt-auth.example.com',
+        response_type: 'token',
+        client_id: '12345.client-id',
+        token_url: 'https://token.example.com/12345/oauth',
+        domain_url: 'https://domain.example.com'
+      })
+    }));
+    expect(result.account.authHeaders.Authorization).toBe('Zoho-oauthtoken access-token-123');
+  });
+  it('should throw a descriptive error when authenticator API returns non-ok response', async () => {
+    requestPostMock.mockResolvedValue({
+      ok: () => false,
+      status: () => 500,
+      text: async () => 'internal error',
+      json: async () => ({})
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {
+          'jwt-oauth': {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id',
+            token_url: 'https://token.example.com/12345/oauth'
+          }
+        }
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo, page)).rejects.toThrow('JWT authenticator error! status: 500, body: internal error');
+  });
+  it('should throw when authenticator response has no access_token', async () => {
+    requestPostMock.mockResolvedValue({
+      ok: () => true,
+      status: () => 200,
+      text: async () => '',
+      json: async () => ({
+        token_type: 'Bearer'
+      })
+    });
+    const jwtAuthenticator = new _JWTauthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      email: 'user@example.com',
+      'data-generator': {
+        account: {
+          'jwt-oauth': {
+            jwt_secret: 'jwt-secret',
+            response_type: 'token',
+            client_id: '12345.client-id',
+            token_url: 'https://token.example.com/12345/oauth'
+          }
+        }
+      }
+    };
+    await expect(jwtAuthenticator.constructPayload(apiPayload, actorInfo, page)).rejects.toThrow('JWT authenticator did not return access_token');
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/OAuthAuthenticator.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _OAuthAuthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/OAuthAuthenticator"));
+describe('OAuthAuthenticator', () => {
+  it('should assign oauth2 from actor info into payload account', async () => {
+    const oauthAuthenticator = new _OAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          oauth2: {
+            client_id: 'new-client',
+            scope: 'tickets.read'
+          }
+        }
+      }
+    };
+    const result = await oauthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.oauth2).toEqual({
+      client_id: 'new-client',
+      scope: 'tickets.read'
+    });
+  });
+  it('should throw when oauth2 is absent in actor configuration', async () => {
+    const oauthAuthenticator = new _OAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {}
+      }
+    };
+    await expect(oauthAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('OAuth2 authentication failed: "oauth2" is missing in actor configuration');
+  });
+});

package/build/test/core/dataGenerator/authenticator/__tests__/OrgOAuthAuthenticator.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _OrgOAuthAuthenticator = _interopRequireDefault(require("../../../../../../src/core/dataGenerator/authenticator/OrgOAuthAuthenticator"));
+describe('OrgOAuthAuthenticator', () => {
+  it('should assign org_oauth from actor info into payload account', async () => {
+    const orgOAuthAuthenticator = new _OrgOAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {
+          org_oauth: {
+            org_id: 'org-1001',
+            region: 'us'
+          }
+        }
+      }
+    };
+    const result = await orgOAuthAuthenticator.constructPayload(apiPayload, actorInfo);
+    expect(result.account.org_oauth).toEqual({
+      org_id: 'org-1001',
+      region: 'us'
+    });
+  });
+  it('should throw when org_oauth is absent in actor configuration', async () => {
+    const orgOAuthAuthenticator = new _OrgOAuthAuthenticator.default();
+    const apiPayload = {
+      account: {}
+    };
+    const actorInfo = {
+      'data-generator': {
+        account: {}
+      }
+    };
+    await expect(orgOAuthAuthenticator.constructPayload(apiPayload, actorInfo)).rejects.toThrow('OrgOAuth authentication failed: "org_oauth" is missing in actor configuration');
+  });
+});

package/build/test/core/playwright/__tests__/runCommand.test.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _events = require("events");
+var _child_process = require("child_process");
+var _logger = require("../../../../utils/logger");
+var _runCommand = require("../../../../core/playwright/runCommand");
+jest.mock('child_process');
+jest.mock('../../../../utils/logger', () => ({
+  __esModule: true,
+  Logger: {
+    log: jest.fn(),
+    SUCCESS_TYPE: 'success',
+    FAILURE_TYPE: 'failure',
+    INFO_TYPE: 'info'
+  }
+}));
+describe('runCommand', () => {
+  let childProcess;
+  let processHandlers;
+  let processOnSpy;
+  let processExitSpy;
+  beforeEach(() => {
+    childProcess = new _events.EventEmitter();
+    childProcess.kill = jest.fn();
+    _child_process.spawn.mockReturnValue(childProcess);
+    processHandlers = {};
+    processOnSpy = jest.spyOn(process, 'on').mockImplementation((event, handler) => {
+      processHandlers[event] = handler;
+      return process;
+    });
+    processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+  });
+  afterEach(() => {
+    processOnSpy.mockRestore();
+    processExitSpy.mockRestore();
+  });
+  it('should spawn the child with the parent stdio and environment', () => {
+    (0, _runCommand.runCommand)('playwright', ['test']);
+    expect(_child_process.spawn).toHaveBeenCalledWith('playwright', ['test'], {
+      stdio: 'inherit',
+      env: {
+        ...process.env
+      }
+    });
+  });
+  it('should resolve and log the success message when the child exits cleanly', async () => {
+    const promise = (0, _runCommand.runCommand)('playwright', ['test'], {
+      successMessage: 'Test Ran Successfully'
+    });
+    childProcess.emit('exit', 0, null);
+    await expect(promise).resolves.toBeUndefined();
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.SUCCESS_TYPE, 'Test Ran Successfully');
+  });
+  it('should reject with the default message when the child exits with a failure', async () => {
+    const promise = (0, _runCommand.runCommand)('playwright', ['test']);
+    childProcess.emit('exit', 1, 'SIGTERM');
+    await expect(promise).rejects.toBe('Child Process Exited with Code 1 and Signal SIGTERM');
+  });
+  it('should reject with the caller message when bddgen exits with a failure', async () => {
+    const promise = (0, _runCommand.runCommand)('node', ['bddgen'], {
+      failureMessage: code => `BddGen exited with code ${code}`
+    });
+    childProcess.emit('exit', 2, null);
+    await expect(promise).rejects.toBe('BddGen exited with code 2');
+  });
+  it('should reject when the child fails to spawn', async () => {
+    const error = new Error('spawn ENOENT');
+    const promise = (0, _runCommand.runCommand)('playwright', ['test']);
+    childProcess.emit('error', error);
+    await expect(promise).rejects.toBe(error);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, error);
+  });
+  it('should not listen on the parent process unless the caller asks for it', () => {
+    (0, _runCommand.runCommand)('node', ['bddgen']);
+    expect(processHandlers.exit).toBeUndefined();
+    expect(processHandlers.SIGINT).toBeUndefined();
+  });
+  it('should kill the child and reject when the run is interrupted', async () => {
+    const promise = (0, _runCommand.runCommand)('playwright', ['test'], {
+      killOnParentExit: true
+    });
+    processHandlers.SIGINT();
+    await expect(promise).rejects.toBe('Cleaning up...');
+    expect(childProcess.kill).toHaveBeenCalled();
+  });
+  it('should kill the child and reject when the parent exits', async () => {
+    const promise = (0, _runCommand.runCommand)('playwright', ['test'], {
+      killOnParentExit: true
+    });
+    processHandlers.exit();
+    await expect(promise).rejects.toBe('Terminating Playwright Process...');
+    expect(childProcess.kill).toHaveBeenCalled();
+  });
+  it('should log the failure and exit when a CLI child exits with a failure', () => {
+    (0, _runCommand.runCommand)('playwright', ['merge-reports'], {
+      exitOnSuccess: true
+    });
+    childProcess.emit('exit', 1, 'SIGTERM');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, 'Child Process Exited with Code 1 and Signal SIGTERM');
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+  it('should not listen for SIGINT unless the caller owns the child lifetime', () => {
+    (0, _runCommand.runCommand)('playwright', ['merge-reports'], {
+      successMessage: 'Blob Reports Merged Successfully',
+      exitOnSuccess: true
+    });
+    expect(processHandlers.SIGINT).toBeUndefined();
+    expect(processHandlers.exit).toBeUndefined();
+  });
+  it('should exit with the child when the caller owns the process lifetime', () => {
+    (0, _runCommand.runCommand)('playwright', ['show-report'], {
+      exitOnSuccess: true
+    });
+    childProcess.emit('exit', 0, null);
+    expect(processExitSpy).toHaveBeenCalledWith(0);
+  });
+  it('should propagate the child exit code when merge-reports completes', () => {
+    (0, _runCommand.runCommand)('playwright', ['merge-reports'], {
+      successMessage: 'Blob Reports Merged Successfully',
+      exitOnSuccess: true
+    });
+    childProcess.emit('exit', 0, null);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.SUCCESS_TYPE, 'Blob Reports Merged Successfully');
+    expect(processExitSpy).toHaveBeenCalledWith(0);
+  });
+  it('should log spawn errors without rejecting a CLI command', () => {
+    const error = new Error('spawn ENOENT');
+    (0, _runCommand.runCommand)('playwright', ['codegen'], {
+      exitOnSuccess: true
+    });
+    childProcess.emit('error', error);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, error);
+    expect(processExitSpy).not.toHaveBeenCalled();
+  });
+  it('should kill the child on SIGINT and on the parent exit', () => {
+    (0, _runCommand.runCommand)('playwright', ['show-report'], {
+      exitOnSuccess: true,
+      killOnParentExit: true
+    });
+    processHandlers.exit();
+    expect(childProcess.kill).toHaveBeenCalledTimes(1);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, 'Terminating Playwright Process...');
+    processHandlers.SIGINT();
+    expect(childProcess.kill).toHaveBeenCalledTimes(2);
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, 'Cleaning up...');
+    expect(processExitSpy).toHaveBeenCalled();
+  });
+});

package/build/test/core/playwright/__tests__/tagProcessor.test.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _tagProcessor = _interopRequireDefault(require("../../../../../src/core/playwright/tagProcessor"));
+var _logger = require("../../../../utils/logger");
+jest.mock('../../../../utils/logger');
+describe('TagProcessor', () => {
+  const editionOrder = ['edition1', 'edition2', 'edition3', 'edition4'];
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('should return tagArgs if no edition is provided', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: null
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1');
+  });
+  test('should handle a single edition with <= operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '<=edition2'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
+  });
+  test('should handle a single edition with >= operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '>=edition2'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition1)');
+  });
+  test('should handle a single edition with < operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '<edition3'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition3 or @edition_edition4)');
+  });
+  test('should handle a single edition with > operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: '>edition1'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition1)');
+  });
+  test('should handle a single edition with no operator', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: 'edition2'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition1 or @edition_edition3 or @edition_edition4)');
+  });
+  test('should log a message if edition is not found', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: 'nonexistentEdition'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1');
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.INFO_TYPE, expect.stringContaining('No matching editions for nonexistentEdition found.'));
+  });
+  test('should handle multiple editions', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: 'tag1',
+      edition: 'edition1,edition3'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('tag1 and not (@edition_edition2 or @edition_edition4)');
+  });
+  test('should build tags correctly when tags are empty', () => {
+    const tagProcessor = new _tagProcessor.default(editionOrder);
+    const userArgs = {
+      tags: '',
+      edition: 'edition1'
+    };
+    const result = tagProcessor.processTags(userArgs);
+    expect(result).toBe('not (@edition_edition2 or @edition_edition3 or @edition_edition4)');
+  });
+});

package/build/test/core/playwright/__tests__/validateFeature.test.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _validateFeature = _interopRequireDefault(require("../../../../core/playwright/validateFeature"));
+var _parseUserArgs = _interopRequireDefault(require("../../../../core/playwright/helpers/parseUserArgs"));
+var _readConfigFile = require("../../../../core/playwright/readConfigFile");
+var _tagProcessor = _interopRequireDefault(require("../../../../core/playwright/tagProcessor"));
+var _testRunner = require("../../../../core/playwright/test-runner");
+var _logger = require("../../../../utils/logger");
+jest.mock('../../../../core/playwright/helpers/parseUserArgs', () => ({
+  __esModule: true,
+  default: jest.fn()
+}));
+jest.mock('../../../../core/playwright/readConfigFile');
+jest.mock('../../../../core/playwright/tagProcessor');
+jest.mock('../../../../core/playwright/test-runner', () => ({
+  __esModule: true,
+  runPreprocessing: jest.fn()
+}));
+jest.mock('../../../../utils/logger', () => ({
+  __esModule: true,
+  Logger: {
+    log: jest.fn(),
+    SUCCESS_TYPE: 'success',
+    FAILURE_TYPE: 'failure'
+  }
+}));
+describe('validateFeatureFiles', () => {
+  let tagProcessorInstance;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    tagProcessorInstance = {
+      processTags: jest.fn()
+    };
+    _tagProcessor.default.mockImplementation(() => tagProcessorInstance);
+  });
+  test('runPreprocessing with correct arguments and log success', async () => {
+    const mockUserArgs = {
+      mode: 'dev'
+    };
+    _parseUserArgs.default.mockReturnValue(mockUserArgs);
+    const mockConfig = {
+      editionOrder: ["beta", "enterprice"]
+    };
+    _readConfigFile.generateConfigFromFile.mockReturnValue(mockConfig);
+    _readConfigFile.isUserConfigFileAvailable.mockReturnValue(true);
+    const mockTagArgs = ['@beta_admin'];
+    tagProcessorInstance.processTags.mockReturnValue(mockTagArgs);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_parseUserArgs.default).toHaveBeenCalled();
+    expect(_readConfigFile.generateConfigFromFile).toHaveBeenCalled();
+    expect(_readConfigFile.isUserConfigFileAvailable).toHaveBeenCalled();
+    expect(tagProcessorInstance.processTags).toHaveBeenCalledWith(mockUserArgs);
+    expect(_testRunner.runPreprocessing).toHaveBeenCalledWith(mockTagArgs, expect.stringContaining('config-creator.js'));
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.SUCCESS_TYPE, 'Feature files validated successfully.');
+  });
+  test('runPreprocessing with playwright conf', async () => {
+    const mockTagArgs = ['@beta_admin'];
+    tagProcessorInstance.processTags.mockReturnValue(mockTagArgs);
+    _readConfigFile.isUserConfigFileAvailable.mockReturnValue(false);
+    _testRunner.runPreprocessing.mockResolvedValueOnce();
+    await (0, _validateFeature.default)();
+    expect(_testRunner.runPreprocessing).toHaveBeenCalledWith(mockTagArgs, expect.stringContaining('playwright.config.js'));
+  });
+  test('error when runPreprocessing fails', async () => {
+    const mockError = new Error('Test error');
+    _testRunner.runPreprocessing.mockRejectedValueOnce(mockError);
+    await await (0, _validateFeature.default)();
+    expect(_logger.Logger.log).toHaveBeenCalledWith(_logger.Logger.FAILURE_TYPE, `Error while validating the feature files - ${mockError}`);
+  });
+});