test(teams): fix TeamsDragAndDrop on 1.13 (backport #31932) (#31933)

* test(teams): backport addTeamHierarchy hardening to 1.13

1.13 never received the addTeamHierarchy waits that main and 2.0 carry, so
the helper returns while the teams table is still refetching: it opens the
modal on a plain click a toast can swallow, resolves on the first
`/api/v1/teams` response regardless of method or status, and never waits
for the modal to close or the row to render.

Backports the team.ts changes from #25894, #30334 and #31734.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* test(teams): stop the teams landing from eating the test budget

TeamsDragAndDrop's beforeEach spent the whole 60s test timeout before any
test body ran. settingClick already ends in waitForAllLoadersToDisappear
(30s), and the hook then called it a second time. The Teams table's antd
spinner is the shared `data-testid="loader"`, and it stays up until both
the child-teams fetch and the per-team asset-count aggregation settle — on
a long-lived deployment that is tens of seconds, so the two waits together
consumed the budget and the hook timed out on the second one.

Give the suite test.slow(true) so the landing has headroom, and hard-delete
the four teams the suite creates. Without that cleanup every nightly run
left four more teams under Organization, growing the aggregation the
landing waits on and making the next run slower.

Fold the duplicated navigation into visitTeamsPage and reuse it from
TeamsHierarchy, which had the same hook with looser glob waits.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* test(teams): surface a failed cleanup delete

hardDeleteTeamByName issued the DELETE and ignored the result, so a delete
rejected on permissions or failing with a 500 left the team behind with no
signal in the run — quietly reintroducing the accumulation this cleanup
exists to prevent. Assert the response instead, with the status and body in
the message.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* test(teams): only tolerate a 404 on the cleanup lookup

The lookup guard keyed off `ok()`, which is false for an auth error or a 500
just as it is for a 404. A broken lookup therefore took the same path as a
team that was already gone: return without deleting, and report success.

Tolerate 404 alone — the spec may have deleted the team itself, and a
recursive delete of its parent takes its children — and assert every other
lookup failure.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* test(teams): attempt every cleanup delete before asserting

The assertion sat inside hardDeleteTeamByName, so the first team that failed
to delete threw out of the caller's loop and the remaining names were never
attempted — leaving those teams on the deployment, which is the accumulation
the cleanup exists to prevent.

Move the assertion up into hardDeleteTeamsByName: the per-team helper now
reports a failure instead of throwing (network errors included), every name
is attempted, and one assertion at the end names every team that survived
along with the status and body that explain why.

Wrap the call in try/finally in the spec so the API context is disposed even
when cleanup fails.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: harsh-vador

openmetadata-ui/src/main/resources/ui/playwright/e2e/Features/TeamsDragAndDrop.spec.ts

@@ -12,8 +12,8 @@
  */
 import { expect, test } from '@playwright/test';
 import { PLAYWRIGHT_BASIC_TEST_TAG_OBJ } from '../../constant/config';
-import { GlobalSettingOptions } from '../../constant/settings';
 import {
+  createNewPage,
   redirectToHomePage,
   toastNotification,
   uuid,
@@ -23,9 +23,11 @@ import {
   dragAndDropElement,
   openDragDropDropdown,
 } from '../../utils/dragDrop';
-import { waitForAllLoadersToDisappear } from '../../utils/entity';
-import { settingClick } from '../../utils/sidebar';
-import { addTeamHierarchy } from '../../utils/team';
+import {
+  addTeamHierarchy,
+  hardDeleteTeamsByName,
+  visitTeamsPage,
+} from '../../utils/team';
 
 // use the admin user to login
 test.use({ storageState: 'playwright/.auth/admin.json' });
@@ -89,28 +91,32 @@ test.describe(
   'Teams drag and drop should work properly',
   PLAYWRIGHT_BASIC_TEST_TAG_OBJ,
   () => {
+    // Every test re-enters Settings > Teams, and that landing waits on the
+    // hierarchy table's asset-count aggregation, which grows with the catalog.
+    // On a long-lived deployment the hook alone can outlast the 60s default.
+    test.slow(true);
+
     test.beforeEach(async ({ page }) => {
       await redirectToHomePage(page);
+      await visitTeamsPage(page);
+    });
 
-      const getOrganizationResponse = page.waitForResponse(
-        (response) =>
-          response.url().includes('/api/v1/teams/name/') &&
-          response.status() === 200
-      );
-      const permissionResponse = page.waitForResponse(
-        (response) =>
-          response.url().includes('/api/v1/permissions/team/name/') &&
-          response.status() === 200
-      );
+    test.afterAll(async ({ browser }) => {
+      const { apiContext, afterAction } = await createNewPage(browser);
 
-      await settingClick(page, GlobalSettingOptions.TEAMS);
-      await permissionResponse;
-      await getOrganizationResponse;
-      await waitForAllLoadersToDisappear(page);
+      try {
+        await hardDeleteTeamsByName(apiContext, [
+          teamNameBusiness,
+          teamNameDivision,
+          teamNameDepartment,
+          teamNameGroup,
+        ]);
+      } finally {
+        await afterAction();
+      }
     });
 
     test('Add teams in hierarchy', async ({ page }) => {
-      test.slow();
       for (const teamDetails of DRAG_AND_DROP_TEAM_DETAILS) {
         await addTeamHierarchy(page, teamDetails);
 
@@ -158,7 +164,6 @@ test.describe(
       test(`Should drag and drop on ${TEAM_TYPE_BY_NAME[droppableTeamName]} team type`, async ({
         page,
       }) => {
-        test.slow();
         // Nested team will be shown once anything is moved under it
         if (index !== 0) {
           await openDragDropDropdown(page, teams[index - 1]);
@@ -182,7 +187,6 @@ test.describe(
     }
 
     test(`Should drag and drop team on table level`, async ({ page }) => {
-      test.slow();
       // Open department team dropdown as it is moved under it from last test
       await openDragDropDropdown(page, teamNameDepartment);
 

openmetadata-ui/src/main/resources/ui/playwright/e2e/Features/TeamsHierarchy.spec.ts

@@ -20,6 +20,7 @@ import {
   addTeamHierarchy,
   getNewTeamDetails,
   searchTeam,
+  visitTeamsPage,
 } from '../../utils/team';
 
 // use the admin user to login
@@ -46,17 +47,7 @@ test.describe(
 
     test.beforeEach(async ({ page }) => {
       await redirectToHomePage(page);
-
-      const getOrganizationResponse = page.waitForResponse(
-        '/api/v1/teams/name/*'
-      );
-      const permissionResponse = page.waitForResponse(
-        '/api/v1/permissions/team/name/*'
-      );
-
-      await settingClick(page, GlobalSettingOptions.TEAMS);
-      await permissionResponse;
-      await getOrganizationResponse;
+      await visitTeamsPage(page);
     });
 
     test('Add teams in hierarchy', async ({ page }) => {
@@ -111,8 +102,6 @@ test.describe(
     });
 
     test('Delete Parent Team', async ({ page }) => {
-      await settingClick(page, GlobalSettingOptions.TEAMS);
-
       await page.getByRole('link', { name: businessTeamName }).click();
 
       await page.click('[data-testid="manage-button"]');

openmetadata-ui/src/main/resources/ui/playwright/utils/team.ts

@@ -33,6 +33,162 @@ import { settingClick } from './sidebar';
 
 const TEAM_TYPES = ['Department', 'Division', 'Group'];
 
+const ADD_TEAM_MODAL = '[role="dialog"].ant-modal';
+// A success toast self-dismisses after 3.5s; give it a beat past that.
+const TOAST_DISMISS_TIMEOUT = 6_000;
+const MODAL_OPEN_TIMEOUT = 10_000;
+const MODAL_RETRY_TIMEOUT = 60_000;
+
+type AddTeamTrigger = 'add-team' | 'add-placeholder-button';
+
+/**
+ * Click an add-team trigger and return the modal it opens.
+ *
+ * The backend fans async-delete/job notifications out to every socket of the
+ * logged-in user, so a parallel worker's toast can drop over the button in the
+ * window between Playwright's hit-target check and the dispatched click — the
+ * toast swallows the click and the modal never opens. Success toasts carry no
+ * close button, so let them expire and click again; clicking with `force` only
+ * dispatches INTO the toast.
+ */
+export const openAddTeamModal = async (
+  page: Page,
+  trigger: AddTeamTrigger = 'add-team'
+) => {
+  const addButton = page.getByTestId(trigger);
+  const addTeamModal = page.locator(ADD_TEAM_MODAL).last();
+
+  await expect(async () => {
+    await page
+      .getByTestId('alert-bar')
+      .first()
+      .waitFor({ state: 'detached', timeout: TOAST_DISMISS_TIMEOUT })
+      .catch(() => undefined);
+
+    await expect(addButton).toBeEnabled();
+    await addButton.click();
+
+    await expect(addTeamModal).toBeVisible({ timeout: MODAL_OPEN_TIMEOUT });
+  }).toPass({ timeout: MODAL_RETRY_TIMEOUT, intervals: [1_000] });
+
+  return addTeamModal;
+};
+
+/**
+ * Land on Settings > Teams with the hierarchy table settled.
+ *
+ * The table spins on its own child-teams fetch plus the per-team asset-count
+ * aggregation, so navigation alone is not enough — a caller that acts right
+ * after the click drags rows that are still being repainted. Wait on the two
+ * calls that gate the first paint, then on the table itself.
+ */
+export const visitTeamsPage = async (page: Page) => {
+  const organizationResponse = page.waitForResponse(
+    (response) =>
+      response.url().includes('/api/v1/teams/name/') && response.ok()
+  );
+  const permissionResponse = page.waitForResponse(
+    (response) =>
+      response.url().includes('/api/v1/permissions/team/name/') && response.ok()
+  );
+
+  await settingClick(page, GlobalSettingOptions.TEAMS);
+  await Promise.all([permissionResponse, organizationResponse]);
+
+  await expect(page.getByTestId('team-hierarchy-table')).toBeVisible();
+  await waitForAllLoadersToDisappear(page);
+};
+
+interface TeamCleanupFailure {
+  teamName: string;
+  reason: string;
+}
+
+/**
+ * Hard-delete one team created through the UI, children included.
+ *
+ * Reports a failure rather than throwing so a caller cleaning up several teams
+ * still attempts the rest — a throw here would leave the remaining teams behind
+ * and recreate the accumulation this cleanup exists to prevent.
+ *
+ * Specs that build teams through the UI have no entity handle to call
+ * `TeamClass.delete` on, so the id is resolved by name first. Delete-by-name is
+ * not an option: `TeamResource` pins that route to `recursive=false`, and these
+ * teams are nested by the time cleanup runs.
+ *
+ * 404 on the lookup is the one tolerated outcome — the spec may have deleted
+ * the team as part of what it asserts, and a recursive delete of its parent
+ * takes its children with it.
+ */
+const hardDeleteTeamByName = async (
+  apiContext: APIRequestContext,
+  teamName: string
+): Promise<TeamCleanupFailure | undefined> => {
+  let failure: TeamCleanupFailure | undefined;
+
+  try {
+    const teamResponse = await apiContext.get(
+      `/api/v1/teams/name/${encodeURIComponent(teamName)}`
+    );
+
+    if (!teamResponse.ok()) {
+      if (teamResponse.status() !== 404) {
+        failure = {
+          teamName,
+          reason: `lookup returned ${teamResponse.status()} ${await teamResponse.text()}`,
+        };
+      }
+    } else {
+      const { id } = await teamResponse.json();
+      const deleteResponse = await apiContext.delete(
+        `/api/v1/teams/${id}?hardDelete=true&recursive=true`
+      );
+
+      if (!deleteResponse.ok()) {
+        failure = {
+          teamName,
+          reason: `delete returned ${deleteResponse.status()} ${await deleteResponse.text()}`,
+        };
+      }
+    }
+  } catch (error) {
+    failure = { teamName, reason: (error as Error).message };
+  }
+
+  return failure;
+};
+
+/**
+ * Hard-delete teams created through the UI, children included.
+ *
+ * Deletes are sequential: a recursive delete takes a team's children with it,
+ * so issuing them in parallel would race the ones already removed. Every name
+ * is attempted before anything is asserted, and the assertion then names every
+ * team that survived — cleanup that fails quietly is what lets teams pile up on
+ * a long-lived deployment in the first place.
+ */
+export const hardDeleteTeamsByName = async (
+  apiContext: APIRequestContext,
+  teamNames: string[]
+) => {
+  const failures: TeamCleanupFailure[] = [];
+
+  for (const teamName of teamNames) {
+    const failure = await hardDeleteTeamByName(apiContext, teamName);
+
+    if (failure) {
+      failures.push(failure);
+    }
+  }
+
+  expect(
+    failures,
+    `Failed to clean up teams: ${failures
+      .map(({ teamName, reason }) => `"${teamName}" (${reason})`)
+      .join(', ')}`
+  ).toEqual([]);
+};
+
 interface SearchTeamOptions {
   expectEmptyResults?: boolean;
   expectNotFound?: boolean;
@@ -252,16 +408,12 @@ export const addTeamHierarchy = async (
   index?: number,
   isHierarchy = false
 ) => {
-  const getTeamsResponse = page.waitForResponse('/api/v1/teams*');
-
-  // Fetching the add button and clicking on it
-  if (index && index > 0) {
-    await page.click('[data-testid="add-placeholder-button"]');
-  } else {
-    await page.click('[data-testid="add-team"]');
-  }
+  const addTeamModal = await openAddTeamModal(
+    page,
+    index && index > 0 ? 'add-placeholder-button' : 'add-team'
+  );
 
-  await getTeamsResponse;
+  await expect(page.locator('[data-testid="name"]')).toBeVisible();
 
   // Entering team details
   await validateFormNameFieldInput({
@@ -285,9 +437,30 @@ export const addTeamHierarchy = async (
   await page.locator(descriptionBox).fill(teamDetails.description);
 
   // Saving the created team
-  const saveTeamResponse = page.waitForResponse('/api/v1/teams');
+  const saveTeamResponse = page.waitForResponse(
+    (response) =>
+      response.url().includes('/api/v1/teams') &&
+      response.request().method() === 'POST' &&
+      response.ok()
+  );
+  const teamsListResponse = page.waitForResponse(
+    (response) =>
+      response.url().includes('/api/v1/teams?parentTeam=') &&
+      response.url().includes('fields=') &&
+      response.request().method() === 'GET'
+  );
   await page.click('[form="add-team-form"]');
   await saveTeamResponse;
+  const teamsListResponseResult = await teamsListResponse;
+
+  expect(teamsListResponseResult.status()).toBe(200);
+  await expect(addTeamModal).toBeHidden({ timeout: 60000 });
+  await waitForAllLoadersToDisappear(page);
+  await expect(
+    page.locator(`[data-row-key="${teamDetails.name}"]`)
+  ).toBeVisible({
+    timeout: 60000,
+  });
 };
 
 export const removeOrganizationPolicyAndRole = async (
@@ -592,7 +765,7 @@ export const executionOnOwnerTeam = async (
 
   await addEmailTeam(page, data.email);
 
-  await page.getByTestId('add-placeholder-button').click();
+  await openAddTeamModal(page, 'add-placeholder-button');
 
   const newTeamData = await createTeam(page);