Dr 3900 - item fields: languages

playwright/pages/item-metadata.page.ts

@@ -1,5 +1,8 @@
 import { Locator, Page, expect } from "@playwright/test";
 
+// sets which UUID is to be used for sample record navigation
+export type MetadataScenario = "DEFAULT" | "SAMPLE1" | "SAMPLE2";
+
 class FieldLocatorService {
   // Method returns an object containing both the Locator and the content/text Pattern
   public getNameLocatorAndPattern(
@@ -24,13 +27,39 @@ class FieldLocatorService {
     // return locator values and full-text for assertions
     return { locator: locator, pattern: fullExpectedPattern };
   }
+
+  public getBasicLocator(
+    allEntryContainers: Locator,
+    expectedText: string
+  ): { locator: Locator; pattern: RegExp } {
+    // Pattern:  define pattern here
+    const basicExpectedPattern = new RegExp(`^${expectedText}$`, "i");
+
+    // Filter the general locator to find the specific container
+    const locator = allEntryContainers.filter({
+      hasText: basicExpectedPattern,
+    });
+
+    // return locator values and full-text for assertions
+    return { locator: locator, pattern: basicExpectedPattern };
+  }
 }
 
 export default class ItemMetadataPage {
   readonly page: Page;
   private locatorService = new FieldLocatorService();
 
-  static itemResultURL: string = "/items/8b2b3160-c5d5-012f-d95c-58d385a7bc34";
+  // Sample URL-Record Mapping
+  private static readonly SCENARIOS: Record<MetadataScenario, string> = {
+    DEFAULT: "8b2b3160-c5d5-012f-d95c-58d385a7bc34",
+    SAMPLE1: "25a47180-c55f-012f-3759-58d385a7bc34", // Topics
+    SAMPLE2: "4649be20-9890-0138-2359-2360945aaf51", // Genres
+  };
+
+  async loadScenario(scenario: MetadataScenario): Promise<void> {
+    const uuid = ItemMetadataPage.SCENARIOS[scenario];
+    await this.page.goto(`/items/${uuid}`);
+  }
 
   // item-metadata
   readonly itemDataHeader: Locator;
@@ -64,6 +93,8 @@ export default class ItemMetadataPage {
   readonly descriptionText: Locator;
   readonly typeHeading: Locator;
   readonly typeText: Locator;
+  readonly languageHeading: Locator;
+  readonly languageText: Locator;
   readonly identifiersHeading: Locator;
   readonly identifiersText: Locator;
   readonly rightsHeading: Locator;
@@ -83,6 +114,7 @@ export default class ItemMetadataPage {
     { name: "Ratzer, Bernard", role: "Cartographer" },
     { name: "Kitchin, Thomas, 1718-1784", role: "Engraver" },
   ];
+  static readonly EXPECTED_LANGUAGE_VALUE = "English";
 
   constructor(page: Page) {
     this.page = page;
@@ -167,6 +199,10 @@ export default class ItemMetadataPage {
     });
     this.identifiersText = this.identifiersHeading.locator("+ p");
 
+    // Languages
+    this.languageHeading = this.page.getByText("Languages", { exact: true });
+    this.languageText = this.languageHeading.locator("+ p");
+
     // Rights Statement
     this.rightsHeading = this.page.getByText("Rights Statement", {
       exact: true,
@@ -297,6 +333,34 @@ export default class ItemMetadataPage {
     }
   }
 
+  async verifyLanguageValues(): Promise<void> {
+    await expect(this.languageHeading).toBeVisible();
+
+    const languageLink = this.languageText.getByRole("link");
+    await expect(languageLink).toBeVisible();
+    await expect(languageLink).toHaveText(
+      ItemMetadataPage.EXPECTED_LANGUAGE_VALUE
+    );
+  }
+
+  async verifyLanguageText(): Promise<void> {
+    await expect(this.languageHeading).toBeVisible();
+    await expect(this.languageText).toContainText(
+      ItemMetadataPage.EXPECTED_LANGUAGE_VALUE
+    );
+  }
+
+  async verifyLanguageLinks(): Promise<void> {
+    const languageLink = this.languageText.getByRole("link");
+
+    // If it's visible and has the right text, Playwright has already
+    // confirmed it's a functional link role.
+    await expect(languageLink).toBeVisible();
+    await expect(languageLink).toHaveText(
+      ItemMetadataPage.EXPECTED_LANGUAGE_VALUE
+    );
+  }
+
   async verifyRightsContent(): Promise<void> {
     // Structural check: Ensure the element exists and is visible
     await expect(this.rightsHeading).toBeVisible();

playwright/tests/item-metadata.spec.ts

@@ -5,10 +5,13 @@ let itemMetadataPage: ItemMetadataPage;
 
 test.beforeEach(async ({ page }) => {
   itemMetadataPage = new ItemMetadataPage(page);
-  await itemMetadataPage.loadPage(ItemMetadataPage.itemResultURL);
 });
 
-test.describe("Verify Metadata Fields", () => {
+test.describe("Verify Default Test Record", () => {
+  test.beforeEach(async ({ page }) => {
+    await itemMetadataPage.loadScenario("DEFAULT");
+  });
+
   test("should display Title heading and corresponding text", async () => {
     await expect(itemMetadataPage.titleHeading).toBeVisible();
     await itemMetadataPage.verifyTitleTextContent();
@@ -49,29 +52,46 @@ test.describe("Verify Metadata Fields", () => {
       await itemMetadataPage.verifyCatalogLinkIsPresent();
     });
   });
-});
 
-test.describe("Other Identifiers", () => {
-  test("should include Shelf Locator", async () => {
-    await itemMetadataPage.verifyShelfLocatorIsPresent();
+  test.describe("Other Identifiers", () => {
+    test("should include Shelf Locator", async () => {
+      await itemMetadataPage.verifyShelfLocatorIsPresent();
+    });
   });
-});
 
-test.describe("Names", () => {
-  test.beforeEach(async ({ page }) => {
-    await expect(itemMetadataPage.nameHeading).toBeVisible();
-    await expect(itemMetadataPage.nameText).toBeVisible();
-  });
+  test.describe("Names", () => {
+    test.beforeEach(async ({ page }) => {
+      await expect(itemMetadataPage.nameHeading).toBeVisible();
+      await expect(itemMetadataPage.nameText).toBeVisible();
+    });
 
-  test("should display the correct number of expected name fields", async () => {
-    await itemMetadataPage.verifyNameCount();
-  });
+    test("should display the correct number of expected name fields", async () => {
+      await itemMetadataPage.verifyNameCount();
+    });
+
+    test("should display link for name and text for Role", async () => {
+      await itemMetadataPage.verifyNameLinks();
+    });
 
-  test("should display link for name and text for Role", async () => {
-    await itemMetadataPage.verifyNameLinks();
+    test("should display correct name and role values", async () => {
+      await itemMetadataPage.verifyNameDataValues();
+    });
   });
+});
 
-  test("should display correct name and role values", async () => {
-    await itemMetadataPage.verifyNameDataValues();
+test.describe("Verify Sample Record 2", () => {
+  test.describe("Languages", () => {
+    test.beforeEach(async ({ page }) => {
+      // Load the SPECIFIC LANGUAGE-modified URL before each test in this block
+      await itemMetadataPage.loadScenario("SAMPLE2");
+    });
+
+    test("should include correct language values", async () => {
+      await itemMetadataPage.verifyLanguageText();
+    });
+
+    test("should contain links that are clickable", async () => {
+      await itemMetadataPage.verifyLanguageLinks();
+    });
   });
 });