@trevordsouzabrite/test-package 1.0.0

package/tests/ApplicantResourcesPageTest.spec.ts

@@ -0,0 +1,117 @@
+// spec: specs/Applicant Resources Page Test Plan.md
+// seed: seed.spec.ts
+
+import { test, expect } from '@playwright/test';
+import { ApplicantPage } from '@pages/ApplicantPage';
+import { WebActions } from '@lib/WebActions';
+import { expectApplicantAuthenticatedHeaderFooterVisible } from '@lib/ApplicantPortalAssertions';
+
+  
+test.describe('Applicant Resources Page Tests', () => {
+  let applicantPage: ApplicantPage;
+  let webActions: WebActions;
+  test.beforeEach(async ({ page }) => {
+    applicantPage = new ApplicantPage(page);
+    webActions = new WebActions(page, page.context());
+    await applicantPage.gotoURL('/polkphpapplicant/s/?language=en_US');
+    await webActions.waitForElementAttached(applicantPage.Logout_Btn);
+    
+    //Click on the Resources link in the header
+    await applicantPage.clickResourcesLink();
+    await webActions.waitForElementAttached(applicantPage.ResourcesTitle_Text);
+  });
+
+  test('Verify the header & footer sections are visible on the resources page @auth', async ({ page }) => {
+    //Verify the resources page elements are visible
+    await expectApplicantAuthenticatedHeaderFooterVisible(applicantPage);
+    //Verify the resources page elements are visible
+    await expect.soft(applicantPage.ResourcesTitle_Text).toBeVisible();
+  });
+
+  test('Verify the resources page elements are visible @auth', async ({ page }) => {
+    //Verify the resources page elements are visible
+    await webActions.waitForElementAttached(applicantPage.PolkHealthCarePlanMemberHandbook_Lnk);
+    await expect.soft(applicantPage.PolkHealthCarePlanMemberHandbook_Lnk).toBeVisible();
+    await expect.soft(applicantPage.UniversalHouseholdAuthorizationForm_Lnk).toBeVisible();
+    await expect.soft(applicantPage.UniversalSharedDataInformationSystem_Lnk).toBeVisible();
+    await expect.soft(applicantPage.EligibilityIncomeVerificationStatement_Lnk).toBeVisible();
+    await expect.soft(applicantPage.ThirdPartySupport_Lnk).toBeVisible();
+  });
+
+  test('Verify the links open successfully in a new tab @auth', async ({ page }) => {
+    //Click on the Polk HealthCare Plan Member Handbook link
+    let href = await applicantPage.PolkHealthCarePlanMemberHandbook_Lnk.getAttribute('href');
+    console.log(`Href: ${href}`);
+    const [newPage1] = await Promise.all([
+      page.context().waitForEvent('page'),   // wait for new tab
+      applicantPage.PolkHealthCarePlanMemberHandbook_Lnk.click() // action that opens it
+    ]);
+    await newPage1.waitForLoadState("domcontentloaded");
+    if (!href) throw new Error('Missing href');
+    let response = await page.request.get(href);
+    expect.soft(response.status()).toBe(200);
+    expect.soft(response.headers()['content-type']).toContain('application/pdf');
+    expect.soft(newPage1.url()).toContain(href);
+    await newPage1.close();
+    
+    //Click on the Universal Household Authorization Form link
+    href = await applicantPage.UniversalHouseholdAuthorizationForm_Lnk.getAttribute('href');
+    console.log(`Href: ${href}`);
+    const [newPage2] = await Promise.all([
+      page.context().waitForEvent('page'),   // wait for new tab
+      applicantPage.UniversalHouseholdAuthorizationForm_Lnk.click() // action that opens it
+    ]);
+    await newPage2.waitForLoadState("domcontentloaded");
+    if (!href) throw new Error('Missing href');
+    response = await page.request.get(href);
+    expect.soft(response.status()).toBe(200);
+    expect.soft(response.headers()['content-type']).toContain('application/pdf');
+    expect.soft(newPage2.url()).toContain(href);
+    await newPage2.close();
+
+    //Click on the Universal Shared Data Information System link
+    href = await applicantPage.UniversalSharedDataInformationSystem_Lnk.getAttribute('href');
+    console.log(`Href: ${href}`);
+    const [newPage3] = await Promise.all([
+      page.context().waitForEvent('page'),   // wait for new tab
+      applicantPage.UniversalSharedDataInformationSystem_Lnk.click() // action that opens it
+    ]);
+    await newPage3.waitForLoadState("domcontentloaded");
+    if (!href) throw new Error('Missing href');
+    response = await page.request.get(href);
+    expect.soft(response.status()).toBe(200);
+    expect.soft(response.headers()['content-type']).toContain('application/pdf');
+    expect.soft(newPage3.url()).toContain(href);
+    await newPage3.close();
+
+    //Click on the Eligibility Income Verification Statement link
+    href = await applicantPage.EligibilityIncomeVerificationStatement_Lnk.getAttribute('href');
+    console.log(`Href: ${href}`);
+    const [newPage4] = await Promise.all([
+      page.context().waitForEvent('page'),   // wait for new tab
+      applicantPage.EligibilityIncomeVerificationStatement_Lnk.click() // action that opens it
+    ]);
+    await newPage4.waitForLoadState("domcontentloaded");
+    if (!href) throw new Error('Missing href');
+    response = await page.request.get(href);
+    expect.soft(response.status()).toBe(200);
+    expect.soft(response.headers()['content-type']).toContain('application/pdf');
+    expect.soft(newPage4.url()).toContain(href);
+    await newPage4.close();
+
+    //Click on the Third Party Support link
+    href = await applicantPage.ThirdPartySupport_Lnk.getAttribute('href');
+    console.log(`Href: ${href}`);
+    const [newPage5] = await Promise.all([
+      page.context().waitForEvent('page'),   // wait for new tab
+      applicantPage.ThirdPartySupport_Lnk.click() // action that opens it
+    ]);
+    await newPage5.waitForLoadState("domcontentloaded");
+    if (!href) throw new Error('Missing href');
+    response = await page.request.get(href);
+    expect.soft(response.status()).toBe(200);
+    expect.soft(response.headers()['content-type']).toContain('application/pdf');
+    expect.soft(newPage5.url()).toContain(href);
+    await newPage5.close();
+  });
+});

package/tests/ApplicantSelfRegisterPageTest.spec.ts

@@ -0,0 +1,254 @@
+// spec: specs/Applicant Self Register Page Test Plan.md
+// seed: seed.spec.ts
+
+import { test, expect } from '@playwright/test';
+import { ApplicantPage } from '@pages/ApplicantPage';
+import { WebActions } from '@lib/WebActions';
+import selfRegisterTextData from '../test-data/selfRegister/textMessages.json';
+import suffixData from '../test-data/selfRegister/suffix.json';
+import mailingAddressStatesData from '../test-data/selfRegister/mailingAddressStates.json';
+import registrationFieldData from '../test-data/selfRegister/registrationFieldData.json';
+  
+test.describe('Applicant Self Register Page Tests', () => {
+  let applicantPage: ApplicantPage;
+  let webActions: WebActions;
+  test.beforeEach(async ({ page }) => {
+    applicantPage = new ApplicantPage(page);
+    webActions = new WebActions(page, page.context());
+    await applicantPage.gotoURL('/polkphpapplicant/s/?language=en_US');
+    await applicantPage.clickLoginButton();
+    await applicantPage.clickSignUpLink();
+    await webActions.waitForElementAttached(applicantPage.PhysicalAddress_AddressField);
+  });
+
+  test('1. Verify all the elements of the self register page are visible @no-auth', async ({ page }) => {
+    //Verify the self register page elements are visible
+    await expect.soft(applicantPage.SelfRegisterFormTitle_Text).toBeVisible();
+    await expect.soft(applicantPage.FirstNameField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.FirstNameField_Input).toBeVisible();
+    await expect.soft(applicantPage.MiddleNameField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.MiddleNameField_Input).toBeVisible();
+    await expect.soft(applicantPage.LastNameField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.LastNameField_Input).toBeVisible();
+    await expect.soft(applicantPage.SuffixField_Lbl).toBeVisible();
+    
+    await expect.soft(applicantPage.SuffixField_dd).toBeVisible();
+    await applicantPage.clickSuffixField();
+    await expect.soft(applicantPage.SuffixField_ddl).toBeVisible();
+    await expect.soft(applicantPage.DOBField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.DOBField_Input).toBeVisible();
+    await applicantPage.clickDOBField();
+    await expect.soft(applicantPage.DOBField_DatePicker).toBeVisible();
+    await expect.soft(applicantPage.EmailField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.EmailField_Input).toBeVisible();
+
+    await expect.soft(applicantPage.PhysicalAddress_Section).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_Title).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_AddressField).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_CountryField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_CountryField_dd).toBeVisible();
+    await applicantPage.clickPhysicalAddressCountryField();
+    await expect.soft(applicantPage.PhysicalAddress_CountryField_ddl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_StreetField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_StreetField_Input).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_CityField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_CityField_Input).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_StateField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_StateField_dd).toBeVisible();
+    await applicantPage.clickPhysicalAddressStateField();
+    await expect.soft(applicantPage.PhysicalAddress_StateField_ddl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_Zip_Lbl).toBeVisible();
+    await expect.soft(applicantPage.PhysicalAddress_Zip_Input).toBeVisible();
+    
+    await expect.soft(applicantPage.MailingAddress_Section).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_Title).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_SameAsPhysical_Toggle).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_AddressField).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_CountryField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_CountryField_dd).toBeVisible();
+    await applicantPage.clickMailingAddressCountryField();
+    await expect.soft(applicantPage.MailingAddress_CountryField_ddl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_StreetField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_StreetField_Input).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_CityField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_CityField_Input).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_StateField_Lbl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_StateField_dd).toBeVisible();
+    await applicantPage.clickMailingAddressStateField();
+    await expect.soft(applicantPage.MailingAddress_StateField_ddl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_Zip_Lbl).toBeVisible();
+    await expect.soft(applicantPage.MailingAddress_Zip_Input).toBeVisible();
+  });
+
+  test('2.Verify agreement / informational copy is present @no-auth', async ({ page }) => {
+    await expect.soft(applicantPage.Agreement_Text).toBeVisible();
+    expect.soft(await applicantPage.Agreement_Text.textContent()).toContain(selfRegisterTextData.agreementText);
+  }); 
+
+  test('3.Verify required-field validation on submit @no-auth', async ({ page }) => {
+    //Scroll to the register button and click it
+    await applicantPage.Register_Btn.scrollIntoViewIfNeeded();
+    await applicantPage.clickRegisterButton();
+    //Scroll to the top of the page to see the error messages
+    await applicantPage.SelfRegisterFormTitle_Text.scrollIntoViewIfNeeded();
+    //Verify the first name field has the error class & error message is displayed
+    await expect.soft(applicantPage.FirstNameField_Lbl).toContainClass('slds-has-error');
+    expect.soft(await applicantPage.FirstNameField_Lbl.textContent()).toContain(selfRegisterTextData.requiredFieldError);
+    //Verify the last name field has the error class & error message is displayed
+    await expect.soft(applicantPage.LastNameField_Lbl).toContainClass('slds-has-error');
+    expect.soft(await applicantPage.LastNameField_Lbl.textContent()).toContain(selfRegisterTextData.requiredFieldError);
+    //Verify the email field has the error class & error message is displayed
+    await expect.soft(applicantPage.EmailField_Lbl).toContainClass('slds-has-error');
+    expect.soft(await applicantPage.EmailField_Lbl.textContent()).toContain(selfRegisterTextData.requiredFieldError);
+    await applicantPage.FirstNameField_Input.fill(registrationFieldData.firstName);
+    await applicantPage.LastNameField_Input.fill(registrationFieldData.lastName);
+    await applicantPage.EmailField_Input.fill(registrationFieldData.validEmail);
+    await applicantPage.clickRegisterButton();
+    await expect.soft(applicantPage.PhysicalAddress_FieldError_Text).toBeVisible();
+    expect.soft(await applicantPage.PhysicalAddress_FieldError_Text.textContent()).toContain(selfRegisterTextData.physicalAddressFieldError);
+    await expect.soft(applicantPage.MailingAddress_FieldError_Text).toBeVisible();
+    expect.soft(await applicantPage.MailingAddress_FieldError_Text.textContent()).toContain(selfRegisterTextData.mailingAddressFieldError);
+  });
+
+  test('4. Verify invalid email format @no-auth', async ({ page }) => {
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.errorEmail, registrationFieldData.physicalAddress, registrationFieldData.mailingAddress);
+    await applicantPage.clickRegisterButton();
+    await applicantPage.EmailField_Lbl.scrollIntoViewIfNeeded();
+    await expect.soft(applicantPage.EmailField_Lbl).toContainClass('slds-has-error');
+    expect.soft(await applicantPage.EmailField_Lbl.textContent()).toContain(selfRegisterTextData.invalidEmailError);  
+  });
+
+  test('5.Verify date of birth constraints @no-auth', async ({ page }) => {
+    //Use current date and a random number to generate a unique name and email
+    const currentDate = await applicantPage.getCurrentDate();
+    const number = await applicantPage.generateRandomNumber();
+
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName + currentDate + number, registrationFieldData.lastName + currentDate + number, registrationFieldData.validEmail + currentDate + number + '@gmail.com', registrationFieldData.physicalAddress, registrationFieldData.mailingAddress);
+    await applicantPage.clickDOBField();
+    //Get the tomorrow's date in the format of MMM DD, YYYY
+    const tomorrowDate = await applicantPage.getTomorrowDateWithFormat();
+    await applicantPage.DOBField_Input.fill(tomorrowDate);
+    await applicantPage.clickRegisterButton();
+    expect.soft(page.url()).not.toContain('successpage');
+  });
+
+  test('6. Verify Physical Address should only be in State of Florida @no-auth', async ({ page }) => {
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.validEmail, registrationFieldData.errorStateAddress,'');
+    await expect.soft(applicantPage.PhysicalAddress_FieldError_Text).toBeVisible();
+    expect.soft(await applicantPage.PhysicalAddress_FieldError_Text.textContent()).toContain(selfRegisterTextData.physicalAddressStateError);
+  });
+
+  test('7a. Verify Mailing Address should only be in Mailing must be in Florida @no-auth', async ({ page }) => {
+    //Error Message for Mailing Address should only be in Florida, US.
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.validEmail, '', registrationFieldData.errorStateAddress);
+    await expect.soft(applicantPage.MailingAddress_FieldError_Text).toBeVisible();
+    expect.soft(await applicantPage.MailingAddress_FieldError_Text.textContent()).toContain(selfRegisterTextData.mailingAddressStateError);
+  });
+
+  test('7b. Verify Mailing Address should only be ZIP must be in the approved Polk list @no-auth', async ({ page }) => {
+    //Error Message for Mailing Address should only be in Approved Zip Codes of Business Rules
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.validEmail, registrationFieldData.physicalAddress, registrationFieldData.errorZIPAddress);
+    await expect.soft(applicantPage.MailingAddress_FieldError_Text).toBeVisible();
+    expect.soft(await applicantPage.MailingAddress_FieldError_Text.textContent()).toContain(selfRegisterTextData.mailingAddressZIPError);
+  });
+
+  test('8. Verify **Same as Physical** toggle on Mailing Address @no-auth', async ({ page }) => {
+    
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.validEmail, registrationFieldData.physicalAddress, '');
+    await applicantPage.clickSameAsPhysicalToggle();
+    //To Check if the toggle is checked
+    await expect.soft(applicantPage.MailingAddress_SameAsPhysical_Toggle).toHaveAttribute('checked');
+    //To check if the physical address are filled in the mailing address fields
+    const physicalAddress_Country = await applicantPage.PhysicalAddress_CountryField_dd.inputValue();
+    console.log(physicalAddress_Country);
+    const physicalAddress_Street = await applicantPage.PhysicalAddress_StreetField_Input.inputValue();
+    console.log(physicalAddress_Street);
+    const physicalAddress_City = await applicantPage.PhysicalAddress_CityField_Input.inputValue();
+    console.log(physicalAddress_City);
+    const physicalAddress_State = await applicantPage.PhysicalAddress_StateField_dd.inputValue();
+    console.log(physicalAddress_State);
+    const physicalAddress_Zip = await applicantPage.PhysicalAddress_Zip_Input.inputValue();
+    console.log(physicalAddress_Zip);
+    expect.soft(await applicantPage.MailingAddress_CountryField_dd.inputValue()).toBe(physicalAddress_Country);
+    expect.soft(await applicantPage.MailingAddress_StreetField_Input.inputValue()).toBe(physicalAddress_Street);
+    expect.soft(await applicantPage.MailingAddress_CityField_Input.inputValue()).toBe(physicalAddress_City);
+    expect.soft(await applicantPage.MailingAddress_StateField_dd.inputValue()).toBe(physicalAddress_State);
+    expect.soft(await applicantPage.MailingAddress_Zip_Input.inputValue()).toBe(physicalAddress_Zip);
+    //To Check if the mailing address fields are disabled
+    await expect.soft(applicantPage.MailingAddress_AddressField).toBeDisabled();
+    await expect.soft(applicantPage.MailingAddress_CountryField_dd).toBeDisabled();
+    await expect.soft(applicantPage.MailingAddress_StreetField_Input).toBeDisabled();
+    await expect.soft(applicantPage.MailingAddress_CityField_Input).toBeDisabled();
+    await expect.soft(applicantPage.MailingAddress_StateField_dd).toBeDisabled();
+    await expect.soft(applicantPage.MailingAddress_Zip_Input).toBeDisabled();
+  });
+
+  test('9. Verify physical vs mailing address independence when **Same as Physical** is off @no-auth', async ({ page }) => {
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.validEmail, registrationFieldData.physicalAddress, registrationFieldData.mailingAddress);
+    await expect.soft(applicantPage.MailingAddress_SameAsPhysical_Toggle).not.toHaveAttribute('checked');
+    //Only the Street, City and Zip will be different in the address fields
+    const physicalAddress_Street = await applicantPage.PhysicalAddress_StreetField_Input.inputValue();
+    console.log(physicalAddress_Street);
+    const physicalAddress_City = await applicantPage.PhysicalAddress_CityField_Input.inputValue(); 
+    console.log(physicalAddress_City);
+    const physicalAddress_Zip = await applicantPage.PhysicalAddress_Zip_Input.inputValue();
+    console.log(physicalAddress_Zip);
+    const mailingAddress_Street = await applicantPage.MailingAddress_StreetField_Input.inputValue();
+    console.log(mailingAddress_Street);
+    const mailingAddress_City = await applicantPage.MailingAddress_CityField_Input.inputValue();
+    console.log(mailingAddress_City);
+    const mailingAddress_Zip = await applicantPage.MailingAddress_Zip_Input.inputValue();
+    console.log(mailingAddress_Zip);
+    //To check if the physical address is different from the mailing address
+    expect.soft(mailingAddress_Street).not.toBe(physicalAddress_Street);
+    expect.soft(mailingAddress_City).not.toBe(physicalAddress_City);
+    expect.soft(mailingAddress_Zip).not.toBe(physicalAddress_Zip);
+  });
+
+  test('10. Successful self-registration (happy path) @no-auth', async ({ page }) => {
+    //Use current date, a random number, and random text to generate a unique name and email
+    const currentDate = await applicantPage.getCurrentDate();
+    const number = await applicantPage.generateRandomNumber();
+    const randomText = await applicantPage.generateRandomText(3);
+
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName + randomText, registrationFieldData.lastName + randomText, registrationFieldData.firstName + currentDate + number + '@gmail.com', registrationFieldData.physicalAddress, registrationFieldData.mailingAddress);
+    await applicantPage.clickRegisterButton();
+    await webActions.waitForElementAttached(applicantPage.SuccessPage_Text);
+    await expect.soft(page.url()).toContain('successpage');
+    await expect.soft(applicantPage.SuccessPage_Text).toBeVisible();
+    expect.soft(await applicantPage.SuccessPage_Text.textContent()).toContain(selfRegisterTextData.successMessage);
+  });
+
+  test('11. Registering with the Same Name & Email (Duplicate Registration) @no-auth', async ({ page }) => {
+    //Error Message for Duplicate Registration
+    await applicantPage.fillMandatoryFields(registrationFieldData.firstName, registrationFieldData.lastName, registrationFieldData.validEmail, registrationFieldData.physicalAddress, registrationFieldData.mailingAddress);
+    await applicantPage.clickRegisterButton();
+    await expect.soft(applicantPage.ErrorMessage_Text).toBeVisible();
+    expect.soft(await applicantPage.ErrorMessage_Text.textContent()).toContain(selfRegisterTextData.duplicateRegistrationError);
+  });
+
+  test('12. Registering with the Long Names @no-auth', async ({ page }) => {
+    //Error Message for Long Names
+    await applicantPage.fillMandatoryFields(registrationFieldData.longFirstName, registrationFieldData.longLastName, registrationFieldData.longEmail, registrationFieldData.physicalAddress, registrationFieldData.mailingAddress);
+    await applicantPage.clickRegisterButton();
+    await expect.soft(applicantPage.ErrorMessage_Text).toBeVisible();
+    expect.soft(await applicantPage.ErrorMessage_Text.textContent()).toContain(selfRegisterTextData.longNamesError);
+  });
+
+  test('15. Validating the values present in Suffix Dropdown @no-auth', async ({ page }) => {
+    await applicantPage.clickSuffixField();
+    const options = await applicantPage.SuffixField_ddl.locator(page.getByRole('option')).allInnerTexts();
+    console.log(options);
+    const suffix = suffixData.suffixOptions;
+    await expect.soft(options).toEqual(suffix);
+  });
+
+  test('16. Validating the values present in Mailing Address - State Dropdown @no-auth', async ({ page }) => {
+    await applicantPage.clickMailingAddressStateField();
+    const options = await applicantPage.MailingAddress_StateField_ddl.locator(page.getByRole('option')).allInnerTexts();
+    console.log(options);
+    const states = mailingAddressStatesData.mailingAddressStateOptions;
+    await expect.soft(options).toEqual(states);
+  });
+
+});

package/tests/auth.setup.ts

@@ -0,0 +1,42 @@
+import { test as setup , expect } from '@playwright/test';
+import { ApplicantPage } from '@pages/ApplicantPage';
+import dotenv from 'dotenv';
+import { testConfig } from 'testConfig';
+import { authFile, saveAuthState } from './authState';
+
+let applicantPage: ApplicantPage;
+const ENV = process.env.ENV || process.env.npm_config_ENV || 'qa';
+console.log(`Authentication file path: ${authFile}`);
+dotenv.config();
+
+setup('authenticate @auth', async ({ page }) => {
+  // Perform authentication steps. Replace these actions with your own.
+  applicantPage = new ApplicantPage(page);
+
+  if (!testConfig.login || !testConfig.password) {
+    throw new Error('LOGIN and PASSWORD must be set before running auth.setup.ts');
+  }
+
+  await applicantPage.gotoURL(`${testConfig[ENV]}/polkphpapplicant/s/loginpage?language=en_US`, {
+    handleConsentUpdate: false,
+  });
+  await applicantPage.UsernameField_Input.waitFor({ state: 'attached' })
+  await applicantPage.UsernameField_Input.fill(testConfig.login);
+  await applicantPage.PasswordField_Input.fill(testConfig.password);
+  await applicantPage.LoginSubmit_Btn.click();
+
+  await applicantPage.completeConsentFormUpdateIfRequired();
+
+  // Wait until the page receives the cookies.
+  //
+  // Sometimes login flow sets cookies in the process of several redirects.
+  // Wait for the final URL to ensure that the cookies are actually set.
+  await applicantPage.Home_Lnk.waitFor({ state: 'attached' });
+  // Alternatively, you can wait until the page reaches a state where all cookies are set.
+  await expect(applicantPage.Logout_Btn).toBeVisible();
+
+  // End of authentication steps.
+
+  await saveAuthState(page.context());
+});
+

package/tests/authState.ts

@@ -0,0 +1,15 @@
+import type { BrowserContext } from '@playwright/test';
+import fs from 'fs';
+import path from 'path';
+
+export const authFile = path.resolve(__dirname, '../playwright/.auth/user.json');
+
+export async function saveAuthState(context: BrowserContext): Promise<void> {
+  const authDir = path.dirname(authFile);
+  fs.mkdirSync(authDir, { recursive: true });
+
+  const state = await context.storageState();
+  const tempFile = path.join(authDir, `user.${process.pid}.${Date.now()}.tmp.json`);
+  fs.writeFileSync(tempFile, `${JSON.stringify(state, null, 2)}\n`);
+  fs.renameSync(tempFile, authFile);
+}

package/tests/example.spec.ts

@@ -0,0 +1,18 @@
+import { test, expect } from '@playwright/test';
+
+test('has title', async ({ page }) => {
+  await page.goto('https://playwright.dev/');
+
+  // Expect a title "to contain" a substring.
+  await expect(page).toHaveTitle(/Playwright/);
+});
+
+test('get started link', async ({ page }) => {
+  await page.goto('https://playwright.dev/');
+
+  // Click the get started link.
+  await page.getByRole('link', { name: 'Get started' }).click();
+
+  // Expects page to have a heading with the name of Installation.
+  await expect(page.getByRole('heading', { name: 'Installation' })).toBeVisible();
+});

package/tests/seed.spec.ts

@@ -0,0 +1,7 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('Test group', () => {
+  test('seed', async ({ page }) => {
+    // generate code here.
+  });
+});