From 4012180cecd582d7aa1444585cad58a84eb2617c Mon Sep 17 00:00:00 2001
From: otsegelnyk <otsegelnyk@exoft.net>
Date: Tue, 29 Sep 2026 12:24:58 +0300
Subject: [PATCH 1/2] Fix sorting and filtering tests that passed without
 verifying anything

Sorting (search + profile):
- getDates used the label `Date "created"` (literal quotes, carried over from
  the Python suite), which matches nothing, so every created-date sort check
  compared an empty list. Use the real card labels; mixed-type All tabs read
  both "Date created" and "Date registered".
- Dates were read right after picking a sort option, while the list is still
  empty. applySort now waits for the index-card-search response with the
  matching `sort` param before reading.
- assertSorting requires at least two dates and getDates rejects unparseable
  ones, so an empty or broken read fails instead of passing.
- Tabs with fewer than two results skip visibly instead of passing.
- Users tab cards show no dates, so those two tests now check that each sort
  option sends the matching SHARE sort request.
- Profile preprints tab used the "registered" label; its cards show
  "Date created".

Filtering:
- Resource type: select the option by exact name and check the filter chip.
  The card check is limited to the first card's "Resource type:" line.
  Registration cards don't show a resource type, so there it relies on the
  chip and the result count. Previously it picked whichever option came
  first and looked for any "Registration" text, which every badge on that
  tab already matches.
- All-tab resource type: every card's type badge must match, instead of
  any one Preprint card being visible, which is already true unfiltered.
- Creator / users institution: every result card must contain the value;
  the old "visible somewhere" check passed on the unfiltered page.
- Clearing: compare the filtered count to the option's count, not the
  unfiltered total.

Sort and clearing tests switch tabs through openTab, which waits for the
tab's own search response. Otherwise they could read the previous tab's
result count.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/pages/BasePage.ts   |  27 +++++--
 src/pages/SearchPage.ts | 152 ++++++++++++++++++++++++++++++++--------
 tests/profile.spec.ts   |  36 +++++-----
 tests/search.spec.ts    |  58 +++++++++------
 4 files changed, 196 insertions(+), 77 deletions(-)

diff --git a/src/pages/BasePage.ts b/src/pages/BasePage.ts
index a1bbd34..aea42a4 100644
--- a/src/pages/BasePage.ts
+++ b/src/pages/BasePage.ts
@@ -46,15 +46,32 @@ export abstract class BasePage {
   }
 
 
-  async getDates(labelText: string): Promise<Date[]> {
-    const texts = await this.page
-      .locator('p', { hasText: `${labelText}:` })
-      .allInnerTexts();
-    return texts.map((text) => new Date(text.replace(`${labelText}: `, '').trim()));
+  /**
+   * Reads every "<label>: <Month D, YYYY>" date line on the page, in DOM order. Several
+   * labels can be passed for mixed-type result lists (e.g. `['Date created', 'Date
+   * registered']` - registration cards show their creation date under the latter).
+   * Throws on an unparseable date rather than letting `Invalid Date` (NaN) through, since
+   * NaN compares equal to itself in `assertSorting` and would hide a broken read.
+   */
+  async getDates(labelText: string | string[]): Promise<Date[]> {
+    const labels = Array.isArray(labelText) ? labelText : [labelText];
+    const labelPattern = new RegExp(`^\\s*(?:${labels.join('|')}):\\s*`);
+    const texts = await this.page.locator('p', { hasText: labelPattern }).allInnerTexts();
+    return texts.map((text) => {
+      const value = text.replace(labelPattern, '').trim();
+      const date = new Date(value);
+      if (Number.isNaN(date.getTime())) {
+        throw new Error(`Could not parse date "${value}" from "${text}"`);
+      }
+      return date;
+    });
   }
 
   /** Port of `pages/base.py`'s `BasePage.assert_sorting`. */
   assertSorting(dates: Date[], order: 'ascending' | 'descending' = 'ascending'): void {
+    // An empty or single-item list is trivially "sorted" - require real data so a
+    // selector that stops matching fails loudly instead of passing vacuously.
+    expect(dates.length, 'need at least two dates to verify sorting').toBeGreaterThan(1);
     const times = dates.map((date) => date.getTime());
     const sortedAscending = [...times].sort((a, b) => a - b);
     const expected = order === 'ascending' ? sortedAscending : [...sortedAscending].reverse();
diff --git a/src/pages/SearchPage.ts b/src/pages/SearchPage.ts
index d89c2a2..1b46459 100644
--- a/src/pages/SearchPage.ts
+++ b/src/pages/SearchPage.ts
@@ -278,6 +278,26 @@ export class SearchPage extends BasePage {
       .nth(Number(index) - 1);
   }
 
+  /** Exact-name match ("Book (18)" but not "BookChapter (1)"), unlike picking by list position. */
+  optionByName(name: string): Locator {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return this.page
+      .locator('ul[role="listbox"] li[role="option"]')
+      .filter({ hasText: new RegExp(`^\\s*${escaped}\\s*\\(\\d+\\)\\s*$`) });
+  }
+
+  /**
+   * Asserts every result card mentions `text`. Checking that the value shows up on
+   * *some* card isn't enough - popular values (e.g. the suite's own test users and
+   * institution) already appear on the unfiltered first page, so that passes whether
+   * or not the filter was applied.
+   */
+  async expectEveryResultCardToContain(text: string): Promise<void> {
+    const cards = this.page.locator('osf-resource-card');
+    await expect(cards.first()).toBeVisible();
+    await expect(cards.filter({ hasNotText: text })).toHaveCount(0);
+  }
+
   // ---------------------------------------------------------------------------
   // Port of `SearchPageHelpers`
   // ---------------------------------------------------------------------------
@@ -344,8 +364,7 @@ export class SearchPage extends BasePage {
     await this.waitForResultsLoad();
     const resultCountAfterFilterApplying = await this.getResultsCount();
     expect(resultCountAfterFilterApplying).toBeLessThanOrEqual(numberOfUsers as number);
-    const recordLocator = this.page.locator('p-accordion-panel a', { hasText: nameOfRecord }).first();
-    await expect(recordLocator).toBeVisible();
+    await this.expectEveryResultCardToContain(nameOfRecord);
   }
 
   async checkFilteringByDateCreated(dateCreatedRegistered: string): Promise<void> {
@@ -511,26 +530,44 @@ export class SearchPage extends BasePage {
     await expect(recordLocator).toContainText(nameOfRecord);
   }
 
+  /**
+   * Selects `resourceType` by exact option name. The original port picked whichever
+   * option came first (callers passed `''`) and then only looked for any `<p>`
+   * containing e.g. "Registration" - which every card's type badge on that tab already
+   * matches, filtered or not.
+   *
+   * Registration cards don't render a "Resource type:" line at all (verified live), so
+   * pass `verifyOnCard: false` there - the applied-filter chip plus the result count
+   * dropping to the option's count is then the proof the filter took effect.
+   */
   async checkFilteringByResourceType(
-    resourceTypeOption: string,
-    displayedResourceTypeOption: string
+    resourceType: string,
+    { verifyOnCard = true }: { verifyOnCard?: boolean } = {}
   ): Promise<void> {
     await this.resourceTypeMenu.click();
     await this.resourceTypeMultiselectDropdown.click();
-    await this.multiselectFilterInput.fill(resourceTypeOption);
-    if (!(await present(this.optionByIndex('1')))) {
-      test.skip(true, 'Record was not found in the list');
+    await this.multiselectFilterInput.fill(resourceType);
+    const option = this.optionByName(resourceType);
+    if (!(await present(option))) {
+      test.skip(true, `Resource type "${resourceType}" was not found in the list`);
     }
-    const numberOfRecords = await this.getRecordCount('1');
-    await this.optionCheckboxByIndex('1').click({ force: true });
+    const numberOfRecords = await this.pollForRecordCount(option);
+    await option.locator('input[type="checkbox"]').click({ force: true });
     await this.waitForResultsLoad();
     const resultCountAfterFilterApplying = await this.getResultsCount();
     expect(resultCountAfterFilterApplying).toBeLessThanOrEqual(numberOfRecords as number);
-    await this.chevronMenuFirstCard.click();
-    const resourceTypeInCardLocator = this.page
-      .locator('p', { hasText: displayedResourceTypeOption })
-      .first();
-    await expect(resourceTypeInCardLocator).toBeVisible();
+    await expect(
+      this.page.locator('.p-chip-label', { hasText: `Resource type: ${resourceType}` })
+    ).toBeVisible();
+    if (verifyOnCard) {
+      await this.chevronMenuFirstCard.click();
+      const resourceTypeInCard = this.page
+        .locator('osf-resource-card')
+        .first()
+        .locator('p', { hasText: 'Resource type:' })
+        .filter({ visible: true });
+      await expect(resourceTypeInCard).toContainText(resourceType);
+    }
   }
 
   async checkFilteringByAdditionalOptions(
@@ -581,10 +618,13 @@ export class SearchPage extends BasePage {
     const resultCountWithoutFilter = await this.getResultsCount();
     await this.dateCreatedMenu.click();
     await this.dateCreatedMultiselectDropdown.click();
+    // Compare against the option's own count, not the unfiltered total - "<= total"
+    // also holds when the filter silently isn't applied at all.
+    const numberOfRecords = await this.getRecordCount('1');
     await this.optionCheckboxByIndex('1').click({ force: true });
     await this.waitForResultsLoad();
     const resultCountAfterFilterApplying = await this.getResultsCount();
-    expect(resultCountAfterFilterApplying).toBeLessThanOrEqual(resultCountWithoutFilter as number);
+    expect(resultCountAfterFilterApplying).toBeLessThanOrEqual(numberOfRecords as number);
     await this.page.locator('span.p-chip-remove-icon').click();
     await this.waitForResultsLoad();
     // waitForResultsLoad's spinner-based wait can race ahead of the Angular
@@ -598,28 +638,78 @@ export class SearchPage extends BasePage {
       .toBe(resultCountWithoutFilter);
   }
 
-  async checkSortingByCreatedDate(createdRegistered: string): Promise<void> {
-    await this.sortByButton.click();
-    await this.sortByDateCreatedNewest.click();
-    let dates = await this.getDates(`Date "${createdRegistered}"`);
-    this.assertSorting(dates, 'descending');
+  /**
+   * Clicks a results tab and waits for the `index-card-search` request that click fires
+   * to complete, then for the re-rendered cards. A bare `tabLink.click()` followed by a
+   * count read can still see the previous tab's total (seen live: the All tab's 13 read
+   * as the Projects tab's baseline), so use this wherever a count is read right after
+   * switching tabs.
+   */
+  async openTab(tabLink: Locator): Promise<void> {
+    const request = this.page.waitForRequest((req) => req.url().includes('index-card-search'));
+    await tabLink.click();
+    await (await request).response();
+    await expect(this.searchResults.first()).toBeVisible();
+  }
 
+  /**
+   * Picks a sort option and waits for the SHARE `index-card-search` response carrying
+   * that exact `sort` value (e.g. `-dateCreated`), then for the re-rendered cards.
+   * Selecting an option clears the result list immediately and refills it only once
+   * that response lands - reading the cards straight after the click (as the original
+   * port did) sees an empty list, which every sort assertion vacuously passes on.
+   */
+  async applySort(option: Locator, sortParam: string): Promise<void> {
+    const response = this.page.waitForResponse(
+      (res) =>
+        res.url().includes('index-card-search') &&
+        new URL(res.url()).searchParams.get('sort') === sortParam
+    );
     await this.sortByButton.click();
-    await this.sortByDateCreatedOldest.click();
-    dates = await this.getDates(`Date "${createdRegistered}"`);
-    this.assertSorting(dates, 'ascending');
+    await option.click();
+    await response;
+    await expect(this.searchResults.first()).toBeVisible();
+  }
+
+  /**
+   * Sorting can't be verified with fewer than two results - skip visibly rather than
+   * pass on nothing. Callers switching tabs first must use `openTab` so this doesn't
+   * read the previous tab's count.
+   */
+  private async skipIfTooFewResultsToSort(): Promise<void> {
+    await expect(this.searchResults.first()).toBeVisible();
+    const resultCount = await this.getResultsCount();
+    if ((resultCount ?? 0) < 2) {
+      test.skip(true, `Only ${resultCount} result(s) - not enough to verify sorting`);
+    }
+  }
+
+  /**
+   * `created` / `registered` / `['created', 'registered']` select which card date line
+   * the created-date sort is checked against - registration cards label their creation
+   * date "Date registered", so mixed-type tabs pass both.
+   */
+  async checkSortingByCreatedDate(createdRegistered: string | string[]): Promise<void> {
+    const labels = (Array.isArray(createdRegistered) ? createdRegistered : [createdRegistered]).map(
+      (label) => `Date ${label}`
+    );
+    await this.skipIfTooFewResultsToSort();
+
+    await this.applySort(this.sortByDateCreatedNewest, '-dateCreated');
+    this.assertSorting(await this.getDates(labels), 'descending');
+
+    await this.applySort(this.sortByDateCreatedOldest, 'dateCreated');
+    this.assertSorting(await this.getDates(labels), 'ascending');
   }
 
   async checkSortingByModifiedDate(): Promise<void> {
-    await this.sortByButton.click();
-    await this.sortByDateModifiedNewest.click();
-    let dates = await this.getDates('Date modified');
-    this.assertSorting(dates, 'descending');
+    await this.skipIfTooFewResultsToSort();
 
-    await this.sortByButton.click();
-    await this.sortByDateModifiedOldest.click();
-    dates = await this.getDates('Date modified');
-    this.assertSorting(dates, 'ascending');
+    await this.applySort(this.sortByDateModifiedNewest, '-dateModified');
+    this.assertSorting(await this.getDates('Date modified'), 'descending');
+
+    await this.applySort(this.sortByDateModifiedOldest, 'dateModified');
+    this.assertSorting(await this.getDates('Date modified'), 'ascending');
   }
 
   async checkSearchInFilteringOptions(recordIndex = '1'): Promise<void> {
diff --git a/tests/profile.spec.ts b/tests/profile.spec.ts
index 70a9ab6..6ea0266 100644
--- a/tests/profile.spec.ts
+++ b/tests/profile.spec.ts
@@ -491,21 +491,21 @@ test.describe('Profile Page Projects Tab', () => {
 
   test('filtering by resource type on projects tab', async ({ profilePageShort }) => {
     await profilePageShort.projectsTabLink.click();
-    await profilePageShort.checkFilteringByResourceType('', 'Book');
+    await profilePageShort.checkFilteringByResourceType('Book');
   });
 
   test('clearing of applied filters on projects tab', async ({ profilePageShort }) => {
-    await profilePageShort.projectsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.projectsTabLink);
     await profilePageShort.checkClearingOfAppliedFilters();
   });
 
   test('sorting by created date on projects tab', async ({ profilePageShort }) => {
-    await profilePageShort.projectsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.projectsTabLink);
     await profilePageShort.checkSortingByCreatedDate('created');
   });
 
   test('sorting by modified date on projects tab', async ({ profilePageShort }) => {
-    await profilePageShort.projectsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.projectsTabLink);
     await profilePageShort.checkSortingByModifiedDate();
   });
 
@@ -632,7 +632,7 @@ test.describe('Profile Page All Tab', () => {
   });
 
   test('filtering by resource type on all tab', async ({ profilePageShort }) => {
-    await profilePageShort.checkFilteringByResourceType('', 'Registration');
+    await profilePageShort.checkFilteringByResourceType('Book');
   });
 
   test('clearing of applied filters on all tab', async ({ profilePageShort }) => {
@@ -640,7 +640,7 @@ test.describe('Profile Page All Tab', () => {
   });
 
   test('sorting by created date on all tab', async ({ profilePageShort }) => {
-    await profilePageShort.checkSortingByCreatedDate('created');
+    await profilePageShort.checkSortingByCreatedDate(['created', 'registered']);
   });
 
   test('sorting by modified date on all tab', async ({ profilePageShort }) => {
@@ -803,7 +803,7 @@ test.describe('Profile Page Registrations Tab', () => {
 
   test('filtering by resource type on registrations tab', async ({ profilePageShort }) => {
     await profilePageShort.registrationsTabLink.click();
-    await profilePageShort.checkFilteringByResourceType('', 'Registration');
+    await profilePageShort.checkFilteringByResourceType('StudyRegistration', { verifyOnCard: false });
   });
 
   test('filtering by data on registrations tab', async ({ profilePageShort }) => {
@@ -871,17 +871,17 @@ test.describe('Profile Page Registrations Tab', () => {
   });
 
   test('clearing of applied filters on registration tab', async ({ profilePageShort }) => {
-    await profilePageShort.registrationsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.registrationsTabLink);
     await profilePageShort.checkClearingOfAppliedFilters();
   });
 
   test('sorting by created date on registrations tab', async ({ profilePageShort }) => {
-    await profilePageShort.registrationsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.registrationsTabLink);
     await profilePageShort.checkSortingByCreatedDate('registered');
   });
 
   test('sorting by modified date on registrations tab', async ({ profilePageShort }) => {
-    await profilePageShort.registrationsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.registrationsTabLink);
     await profilePageShort.checkSortingByModifiedDate();
   });
 
@@ -1030,17 +1030,17 @@ test.describe('Profile Page Preprints Tab', () => {
   });
 
   test('clearing of applied filters on preprints tab', async ({ profilePageShort }) => {
-    await profilePageShort.preprintsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.preprintsTabLink);
     await profilePageShort.checkClearingOfAppliedFilters();
   });
 
   test('sorting by created date on preprints tab', async ({ profilePageShort }) => {
-    await profilePageShort.preprintsTabLink.click();
-    await profilePageShort.checkSortingByCreatedDate('registered');
+    await profilePageShort.openTab(profilePageShort.preprintsTabLink);
+    await profilePageShort.checkSortingByCreatedDate('created');
   });
 
   test('sorting by modified date on preprints tab', async ({ profilePageShort }) => {
-    await profilePageShort.preprintsTabLink.click();
+    await profilePageShort.openTab(profilePageShort.preprintsTabLink);
     await profilePageShort.checkSortingByModifiedDate();
   });
 
@@ -1130,7 +1130,7 @@ test.describe('Profile Page Files Tab', () => {
 
   test('filtering by resource type on files tab', async ({ profilePageShort }) => {
     await profilePageShort.filesTabLink.click();
-    await profilePageShort.checkFilteringByResourceType('', 'Book');
+    await profilePageShort.checkFilteringByResourceType('Book');
   });
 
   test('filtering by community schema on files tab', async ({ profilePageShort }) => {
@@ -1139,17 +1139,17 @@ test.describe('Profile Page Files Tab', () => {
   });
 
   test('clearing of applied filters on files tab', async ({ profilePageShort }) => {
-    await profilePageShort.filesTabLink.click();
+    await profilePageShort.openTab(profilePageShort.filesTabLink);
     await profilePageShort.checkClearingOfAppliedFilters();
   });
 
   test('sorting by created date on files tab', async ({ profilePageShort }) => {
-    await profilePageShort.filesTabLink.click();
+    await profilePageShort.openTab(profilePageShort.filesTabLink);
     await profilePageShort.checkSortingByCreatedDate('created');
   });
 
   test('sorting by modified date on files tab', async ({ profilePageShort }) => {
-    await profilePageShort.filesTabLink.click();
+    await profilePageShort.openTab(profilePageShort.filesTabLink);
     await profilePageShort.checkSortingByModifiedDate();
   });
 
diff --git a/tests/search.spec.ts b/tests/search.spec.ts
index dedb3ae..ca5b281 100644
--- a/tests/search.spec.ts
+++ b/tests/search.spec.ts
@@ -635,8 +635,14 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
       await searchPageShort.multiselectFilterInput.fill('preprin');
       const nameOfRecord = await searchPageShort.getRecordName('1');
       await searchPageShort.optionCheckboxByIndex('1').click({ force: true });
-      const resourceTypeInCard = page.locator(`p[class*="type"]:text-is("${nameOfRecord}")`).first();
-      await expect(resourceTypeInCard).toBeVisible();
+      await searchPageShort.waitForResultsLoad();
+      // The unfiltered All tab already shows some Preprint cards, so "a Preprint card is
+      // visible" proves nothing - every card's type badge has to match. (No "results <=
+      // option count" check here: SHARE's resourceType facet count is currently one
+      // lower than the filtered search's own total - 1857 vs 1858 - a backend mismatch.)
+      const typeBadges = page.locator('osf-resource-card p[class*="type"]');
+      await expect(typeBadges.first()).toBeVisible();
+      await expect(typeBadges.filter({ hasNotText: new RegExp(`^\\s*${nameOfRecord}\\s*$`) })).toHaveCount(0);
     });
 
     test('filtering by part of collection on all tab', async ({ searchPageShort }) => {
@@ -664,7 +670,7 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('sorting by created date on all tab', async ({ searchPageShort }) => {
-      await searchPageShort.checkSortingByCreatedDate('created');
+      await searchPageShort.checkSortingByCreatedDate(['created', 'registered']);
     });
 
     test('sorting by modified date on all tab', async ({ searchPageShort }) => {
@@ -872,7 +878,7 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('clearing of applied filters on preprints tab', async ({ searchPageShort }) => {
-      await searchPageShort.preprintsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.preprintsTabLink);
       await searchPageShort.checkClearingOfAppliedFilters();
     });
 
@@ -881,12 +887,12 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('sorting by created date on preprints tab', async ({ searchPageShort }) => {
-      await searchPageShort.preprintsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.preprintsTabLink);
       await searchPageShort.checkSortingByCreatedDate('created');
     });
 
     test('sorting by modified date on preprints tab', async ({ searchPageShort }) => {
-      await searchPageShort.preprintsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.preprintsTabLink);
       await searchPageShort.checkSortingByModifiedDate();
     });
 
@@ -987,7 +993,9 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
 
     test('filtering by resource type on registrations tab', async ({ searchPageShort }) => {
       await searchPageShort.registrationsTabLink.click();
-      await searchPageShort.checkFilteringByResourceType('', 'Registration');
+      await searchPageShort.checkFilteringByResourceType('StudyRegistration', {
+        verifyOnCard: false,
+      });
     });
 
     test('filtering by data on registrations tab', async ({ searchPageShort }) => {
@@ -1057,7 +1065,7 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('clearing of applied filters on registration tab', async ({ searchPageShort }) => {
-      await searchPageShort.registrationsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.registrationsTabLink);
       await searchPageShort.checkClearingOfAppliedFilters();
     });
 
@@ -1066,12 +1074,12 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('sorting by created date on registrations tab', async ({ searchPageShort }) => {
-      await searchPageShort.registrationsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.registrationsTabLink);
       await searchPageShort.checkSortingByCreatedDate('registered');
     });
 
     test('sorting by modified date on registrations tab', async ({ searchPageShort }) => {
-      await searchPageShort.registrationsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.registrationsTabLink);
       await searchPageShort.checkSortingByModifiedDate();
     });
 
@@ -1216,17 +1224,17 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('clearing of applied filters on files tab', async ({ searchPageShort }) => {
-      await searchPageShort.filesTabLink.click();
+      await searchPageShort.openTab(searchPageShort.filesTabLink);
       await searchPageShort.checkClearingOfAppliedFilters();
     });
 
     test('sorting by created date on files tab', async ({ searchPageShort }) => {
-      await searchPageShort.filesTabLink.click();
+      await searchPageShort.openTab(searchPageShort.filesTabLink);
       await searchPageShort.checkSortingByCreatedDate('created');
     });
 
     test('sorting by modified date on files tab', async ({ searchPageShort }) => {
-      await searchPageShort.filesTabLink.click();
+      await searchPageShort.openTab(searchPageShort.filesTabLink);
       await searchPageShort.checkSortingByModifiedDate();
     });
 
@@ -1351,7 +1359,7 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('clearing of applied filters on projects tab', async ({ searchPageShort }) => {
-      await searchPageShort.projectsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.projectsTabLink);
       await searchPageShort.checkClearingOfAppliedFilters();
     });
 
@@ -1372,12 +1380,12 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
     });
 
     test('sorting by created date on projects tab', async ({ searchPageShort }) => {
-      await searchPageShort.projectsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.projectsTabLink);
       await searchPageShort.checkSortingByCreatedDate('created');
     });
 
     test('sorting by modified date on projects tab', async ({ searchPageShort }) => {
-      await searchPageShort.projectsTabLink.click();
+      await searchPageShort.openTab(searchPageShort.projectsTabLink);
       await searchPageShort.checkSortingByModifiedDate();
     });
 
@@ -1475,14 +1483,21 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
   // TestSearchPageUsersTab (6 tests)
   // -------------------------------------------------------------------------------
   test.describe('Users Tab', () => {
+    // User cards display no dates at all (verified live), so the resulting order can't
+    // be read off the UI. These verify what the UI can: each option fires the matching
+    // SHARE `sort` request and the results re-render (`applySort` fails otherwise).
     test('sorting by created date on users tab', async ({ searchPageShort }) => {
       await searchPageShort.usersTabLink.click();
-      await searchPageShort.checkSortingByCreatedDate('created');
+      await expect(searchPageShort.searchResults.first()).toBeVisible();
+      await searchPageShort.applySort(searchPageShort.sortByDateCreatedNewest, '-dateCreated');
+      await searchPageShort.applySort(searchPageShort.sortByDateCreatedOldest, 'dateCreated');
     });
 
     test('sorting by modified date on users tab', async ({ searchPageShort }) => {
       await searchPageShort.usersTabLink.click();
-      await searchPageShort.checkSortingByModifiedDate();
+      await expect(searchPageShort.searchResults.first()).toBeVisible();
+      await searchPageShort.applySort(searchPageShort.sortByDateModifiedNewest, '-dateModified');
+      await searchPageShort.applySort(searchPageShort.sortByDateModifiedOldest, 'dateModified');
     });
 
     test('search results exist on users tab', async ({ searchPageShort }) => {
@@ -1492,7 +1507,7 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
       expect(await searchPageShort.firstCardObjectTypeLabel.innerText()).toBe('User');
     });
 
-    test('filtering on users tab', async ({ page, searchPageShort }) => {
+    test('filtering on users tab', async ({ searchPageShort }) => {
       await searchPageShort.usersTabLink.click();
       await expect(searchPageShort.searchResults.first()).toBeVisible();
       await searchPageShort.institutionAffiliationMenu.click();
@@ -1503,10 +1518,7 @@ test.describe('Search Page', { tag: ['@smoke', '@core'] }, () => {
       await searchPageShort.waitForResultsLoad();
       const resultCountAfterFilterApplying = await searchPageShort.getResultsCount();
       expect(resultCountAfterFilterApplying).toBe(numberOfUsers);
-      const institutionLocator = page
-        .locator('p-accordion-panel a', { hasText: nameOfInstitution })
-        .first();
-      await expect(institutionLocator).toBeVisible();
+      await searchPageShort.expectEveryResultCardToContain(nameOfInstitution);
     });
 
     test('clearing of applied filters on users tab', async ({ page, searchPageShort }) => {

From 25c2b9f6867067196cefaa38691f59592ca3b6ab Mon Sep 17 00:00:00 2001
From: otsegelnyk <otsegelnyk@exoft.net>
Date: Tue, 29 Sep 2026 16:04:20 +0300
Subject: [PATCH 2/2] fixed broken tests

---
 src/pages/SearchPage.ts | 114 +++++-----------------------------------
 1 file changed, 14 insertions(+), 100 deletions(-)

diff --git a/src/pages/SearchPage.ts b/src/pages/SearchPage.ts
index 1b46459..720d5dc 100644
--- a/src/pages/SearchPage.ts
+++ b/src/pages/SearchPage.ts
@@ -22,36 +22,18 @@ export class SearchPage extends BasePage {
     return `${settings.OSF_HOME}/search/`;
   }
 
-  /**
-   * The search page's initial load fires its own (empty-query) results request. If a
-   * test starts typing/clicking before that settles, its own request's loading-spinner
-   * cycle can overlap with - and finish before - the one triggered by the page's own
-   * load, so a naive `press('Enter')` -> `expect(...).toBeVisible()` can observe stale
-   * results mid-flicker. Settling here first (mirrors the Python `goto_short()`'s
-   * `time.sleep(1)`) means `waitForResultsLoad` afterward is observing only the
-   * request the test itself triggered.
-   */
+
   async goto(): Promise<this> {
     await super.goto();
     await waitUntilPageReady(this.page);
     return this;
   }
 
-  /**
-   * Waits out the loading-spinner cycle triggered by a search submission or tab
-   * switch. See `goto()` above for why a plain "wait for results visible" isn't
-   * enough on this page.
-   */
   async waitForResultsLoad(): Promise<void> {
     await hereThenGone(this.loadingIndicator);
   }
 
-  /**
-   * `div[data-analytics-scope="Search page main"]` (the original port of this
-   * locator) no longer exists anywhere in the app's markup - confirmed live via
-   * `tests/_debug_inspect.spec.ts` per `CLAUDE.md`'s "verify against the live DOM"
-   * rule. `osf-search-page` is the stable custom-element wrapper that replaced it.
-   */
+
   get identity(): Locator {
     return this.page.locator('osf-search-page');
   }
@@ -68,12 +50,7 @@ export class SearchPage extends BasePage {
     return this.page.locator('button[data-test-search-submit]');
   }
 
-  /**
-   * The page also has a hidden `div[role="button"]` panel-menu header sharing the
-   * same accessible name (a mobile/collapsed-nav duplicate) - plain `getByRole`
-   * matches both, so these are scoped to the results container to get only the
-   * real, visible `<button>` tab.
-   */
+
   private get resultsContainer(): Locator {
     return this.page.locator('osf-search-results-container');
   }
@@ -123,14 +100,6 @@ export class SearchPage extends BasePage {
     return this.page.locator('#trove\\:at-date');
   }
 
-  /**
-   * Every filter's multiselect dropdown (funder, license, subject, etc.) renders
-   * with the same generic `id="any-of"` - scoping to whichever accordion panel is
-   * currently expanded (`data-p-active="true"`) is what actually disambiguates them,
-   * not the id itself. All the `*MultiselectDropdown` getters below therefore
-   * resolve to this same locator - kept as separate named getters (rather than one
-   * shared one) purely to mirror which filter each call site is opening.
-   */
   private get activeAccordionMultiselectDropdown(): Locator {
     return this.page.locator('p-accordion-content[data-p-active="true"] p-multiselect#any-of');
   }
@@ -212,12 +181,7 @@ export class SearchPage extends BasePage {
     return this.page.locator('input[role="searchbox"].p-multiselect-filter');
   }
 
-  /**
-   * `p.type.py-1.px-3.font-bold` matches every result card's type label, not just the
-   * first - the Python `Locator` equivalent silently returned the first DOM match
-   * (Selenium's `find_element` semantics), so `.first()` here is required to keep the
-   * same behavior under Playwright's strict-mode locators.
-   */
+
   get firstCardObjectTypeLabel(): Locator {
     return this.page.locator('p.type.py-1.px-3.font-bold').first();
   }
@@ -252,13 +216,7 @@ export class SearchPage extends BasePage {
     return this.searchResults.first().locator('h2 a');
   }
 
-  /**
-   * `div[osfstoppropagation]` (the original port of this locator) no longer uniquely
-   * identifies the card's type badge - verified live via `tests/_debug_inspect.spec.ts`
-   * per `CLAUDE.md`'s "verify against the live DOM" rule, it now also matches every
-   * PrimeNG accordion-header div on the page. Reuse `firstCardObjectTypeLabel`, the
-   * locator `search.spec.ts` already uses successfully for this same type-badge text.
-   */
+
   get nodeType(): Locator {
     return this.firstCardObjectTypeLabel;
   }
@@ -286,12 +244,7 @@ export class SearchPage extends BasePage {
       .filter({ hasText: new RegExp(`^\\s*${escaped}\\s*\\(\\d+\\)\\s*$`) });
   }
 
-  /**
-   * Asserts every result card mentions `text`. Checking that the value shows up on
-   * *some* card isn't enough - popular values (e.g. the suite's own test users and
-   * institution) already appear on the unfiltered first page, so that passes whether
-   * or not the filter was applied.
-   */
+
   async expectEveryResultCardToContain(text: string): Promise<void> {
     const cards = this.page.locator('osf-resource-card');
     await expect(cards.first()).toBeVisible();
@@ -302,15 +255,7 @@ export class SearchPage extends BasePage {
   // Port of `SearchPageHelpers`
   // ---------------------------------------------------------------------------
 
-  /**
-   * Both option-list rows and additional-filter labels start out visible with just
-   * their name - the "(N)" count is filled in a moment later by a separate
-   * facet-counts request (same async-populate lag as the Subjects dropdown in
-   * checkFilteringBySubject) and can even flicker back to the bare name on a
-   * subsequent refresh. Capture the count inside the same poll iteration that
-   * finds it, rather than asserting it's present and re-reading afterward, so a
-   * flicker between those two reads can't hand back a stale null.
-   */
+
   private async pollForRecordCount(locator: Locator): Promise<number | null> {
     let count: number | null = null;
     await expect
@@ -398,15 +343,12 @@ export class SearchPage extends BasePage {
     const resultCountAfterFilterApplying = await this.getResultsCount();
     expect(resultCountAfterFilterApplying).toBeLessThanOrEqual(numberOfRecords as number);
     const popup = await clickExpectingPopup(this.page, this.firstSearchResultTitle);
-    // A subject can appear in more than one taxonomy path, so the Subjects
-    // section can render the same tag label twice (e.g. two "Life Sciences"
-    // chips) - .first() avoids a strict-mode violation on the duplicate.
+ 
     const subjectLocator = popup
       .locator(':is(div, section):has(> h3:text-is("Subjects"))')
       .locator('span', { hasText: nameOfRecord })
       .first();
-    // Same subject-taxonomy slowness as the filter dropdown above - the popup's
-    // Subjects section shows a skeleton loader before the real tags populate.
+
     await expect(subjectLocator).toBeVisible({ timeout: 35000 });
   }
 
@@ -611,9 +553,7 @@ export class SearchPage extends BasePage {
   }
 
   async checkClearingOfAppliedFilters(): Promise<void> {
-    // Callers click a tab link immediately before this - wait for that switch's
-    // own results refresh to settle before taking the "no filter" baseline reading,
-    // otherwise this can read the stale count from the previous tab/state.
+
     await this.waitForResultsLoad();
     const resultCountWithoutFilter = await this.getResultsCount();
     await this.dateCreatedMenu.click();
@@ -627,24 +567,12 @@ export class SearchPage extends BasePage {
     expect(resultCountAfterFilterApplying).toBeLessThanOrEqual(numberOfRecords as number);
     await this.page.locator('span.p-chip-remove-icon').click();
     await this.waitForResultsLoad();
-    // waitForResultsLoad's spinner-based wait can race ahead of the Angular
-    // re-render when the request settles faster than the spinner's own
-    // appear/disappear cycle can be observed (same class of flicker as the
-    // goto()/Subjects-dropdown cases documented above) - a single read here can
-    // land on the stale, still-filtered count. Poll the actual count instead of
-    // trusting one post-wait read.
+
     await expect
       .poll(() => this.getResultsCount(), { timeout: settings.LONG_TIMEOUT_MS })
       .toBe(resultCountWithoutFilter);
   }
 
-  /**
-   * Clicks a results tab and waits for the `index-card-search` request that click fires
-   * to complete, then for the re-rendered cards. A bare `tabLink.click()` followed by a
-   * count read can still see the previous tab's total (seen live: the All tab's 13 read
-   * as the Projects tab's baseline), so use this wherever a count is read right after
-   * switching tabs.
-   */
   async openTab(tabLink: Locator): Promise<void> {
     const request = this.page.waitForRequest((req) => req.url().includes('index-card-search'));
     await tabLink.click();
@@ -652,13 +580,7 @@ export class SearchPage extends BasePage {
     await expect(this.searchResults.first()).toBeVisible();
   }
 
-  /**
-   * Picks a sort option and waits for the SHARE `index-card-search` response carrying
-   * that exact `sort` value (e.g. `-dateCreated`), then for the re-rendered cards.
-   * Selecting an option clears the result list immediately and refills it only once
-   * that response lands - reading the cards straight after the click (as the original
-   * port did) sees an empty list, which every sort assertion vacuously passes on.
-   */
+
   async applySort(option: Locator, sortParam: string): Promise<void> {
     const response = this.page.waitForResponse(
       (res) =>
@@ -671,11 +593,7 @@ export class SearchPage extends BasePage {
     await expect(this.searchResults.first()).toBeVisible();
   }
 
-  /**
-   * Sorting can't be verified with fewer than two results - skip visibly rather than
-   * pass on nothing. Callers switching tabs first must use `openTab` so this doesn't
-   * read the previous tab's count.
-   */
+
   private async skipIfTooFewResultsToSort(): Promise<void> {
     await expect(this.searchResults.first()).toBeVisible();
     const resultCount = await this.getResultsCount();
@@ -684,11 +602,7 @@ export class SearchPage extends BasePage {
     }
   }
 
-  /**
-   * `created` / `registered` / `['created', 'registered']` select which card date line
-   * the created-date sort is checked against - registration cards label their creation
-   * date "Date registered", so mixed-type tabs pass both.
-   */
+
   async checkSortingByCreatedDate(createdRegistered: string | string[]): Promise<void> {
     const labels = (Array.isArray(createdRegistered) ? createdRegistered : [createdRegistered]).map(
       (label) => `Date ${label}`