Fixes #26970: fix bot name search on the Bots page (#27365)

* Fix bot name matching on the Bots page search

* Fixes #26970: migrate Bots search to API-based name/email lookup with robust partial email matching

* Fix flaky Playwright setup by making Table/User creation idempotent and hardening glossary/tag and cleanup flows

* Fixes #26970: avoid full bot scan by switching search result resolution to direct getBotByName lookups

* Fixes #26970: align bot user search with deleted toggle and tighten tour retry timeout handling

* Fixes #26970: keep bot search API-driven, align wildcard matching with name/email expectations, and revert unrelated Playwright changes

* fix: stabilize bot search behavior and flaky Playwright flows across bots, glossary, lineage, and announcements

* fix: limit PR scope to bot search by reverting unrelated Tour Playwright changes

* fix: remove unrelated Playwright changes and keep bot search scope focused

* fix: optimize bot search scalability with paginated user-index retrieval and bounded-concurrency bot resolution

* fix: harden Bots API search with bounded pagination/concurrency and consistent active-search refresh behavior

* fix: prevent stale bot search state and strengthen Bots Playwright coverage with deterministic positive/negative assertions

* test: scope Playwright fixes to bot flow and remove unrelated test changes

* Add local bot search and stabilize tests

* Fixes: keep Bot search API-driven for complete results and stabilize bot cleanup assertions in Playwright

* chore: revert out-of-scope bot Playwright test changes

* test: add bot search e2e coverage and tighten bot API response assertions

* test: stabilize bot search no-match assertions using filter placeholder testid

* fix: add search API wait in bot Playwright flow and refactor bot-user mapping helper

* fix: extract reusable searchbar helper with search API wait and deduplicate bot user mapping logic

* fix(playwright): make bot search test stable by removing brittle API wait

* Refactor bot search integration and Playwright synchronization for reliable name/email query behavior

* Fix bot search regressions by preserving getBotByName compatibility export, stabilizing BotListV1 memoized enrichment, and skipping Playwright search API wait for empty terms

* fix: stabilize bot search Playwright API wait to prevent encoded-query timeout flakes

* } from '../generated/api/teams/createUser';

* fix: eliminate Playwright search response race by pre-registering waiter and matching query-specific GET /search/query responses

* fix: normalize bot search queryFilter format and harden bot-user resolution flow

* refactor code

* fix bot search

* fix checkstyle

* fix display name search

* address gitar

* remove unwanted code

* address gitar and improve performance

* address gitar

* fix bot spec

---------

Co-authored-by: Harsh Vador <58542468+harsh-vador@users.noreply.github.com>
Co-authored-by: Harsh Vador <harsh.vador@somaiya.edu>

Author: siddhiguptas

openmetadata-ui/src/main/resources/ui/playwright/e2e/Pages/Bots.spec.ts

@@ -13,6 +13,7 @@
 import { expect, test } from '@playwright/test';
 import { PLAYWRIGHT_BASIC_TEST_TAG_OBJ } from '../../constant/config';
 import {
+  BOT_DETAILS,
   createBot,
   deleteBot,
   redirectToBotPage,
@@ -21,6 +22,8 @@ import {
   updateBotDetails,
   verifyGenerateTokenAPIContract,
 } from '../../utils/bot';
+import { searchFromSearchInput } from '../../utils/common';
+import { waitForAllLoadersToDisappear } from '../../utils/entity';
 
 // use the admin user to login
 test.use({ storageState: 'playwright/.auth/admin.json' });
@@ -48,6 +51,56 @@ test.describe(
         await updateBotDetails(page);
       });
 
+      await redirectToBotPage(page);
+
+      const searchInput = page.getByTestId('searchbar');
+      const createdBotLink = page.getByTestId(
+        `bot-link-${BOT_DETAILS.updatedBotName}`
+      );
+
+      await test.step('Search bot by display name', async () => {
+        await searchFromSearchInput(
+          page,
+          searchInput,
+          BOT_DETAILS.updatedBotName
+        );
+
+        await expect(createdBotLink).toBeVisible();
+      });
+
+      await test.step('Search bot by bot name', async () => {
+        await searchFromSearchInput(page, searchInput, BOT_DETAILS.botName);
+
+        await expect(createdBotLink).toBeVisible();
+      });
+
+      await test.step('Search bot by email', async () => {
+        await searchFromSearchInput(page, searchInput, BOT_DETAILS.botEmail);
+
+        await expect(createdBotLink).toBeVisible();
+      });
+
+      await test.step('Search with no match shows empty state', async () => {
+        await searchFromSearchInput(
+          page,
+          searchInput,
+          `${BOT_DETAILS.updatedBotName}-no-match`
+        );
+
+        await expect(
+          page.getByTestId('search-error-placeholder')
+        ).toBeVisible();
+      });
+
+      await test.step('Clear search restores full list', async () => {
+        await searchInput.clear();
+        await searchInput.fill('');
+        await expect(searchInput).toHaveValue('');
+        await waitForAllLoadersToDisappear(page);
+
+        await expect(createdBotLink).toBeVisible();
+      });
+
       await test.step('Verify generateToken API contract', async () => {
         await verifyGenerateTokenAPIContract(page);
       });

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

@@ -25,7 +25,7 @@ import { revokeToken } from './user';
 
 const botName = `a-bot-pw%test-${uuid()}`;
 
-const BOT_DETAILS = {
+export const BOT_DETAILS = {
   botName: botName,
   botEmail: `${botName}@mail.com`,
   description: `This is bot description for ${botName}`,
@@ -70,9 +70,15 @@ export const createBot = async (page: Page) => {
 
   await page.locator(descriptionBox).fill(BOT_DETAILS.description);
 
-  const saveResponse = page.waitForResponse('/api/v1/bots');
+  const saveResponse = page.waitForResponse(
+    (response) =>
+      response.url().includes('/api/v1/bots') &&
+      response.request().method() === 'POST'
+  );
   await page.click('[data-testid="save-user"]');
-  await saveResponse;
+  const createBotResponse = await saveResponse;
+
+  expect(createBotResponse.status()).toBe(201);
 
   // Verify bot is getting added in the bots listing page
   await expect(
@@ -115,7 +121,10 @@ export const deleteBot = async (page: Page) => {
 
   await toastNotification(page, /deleted successfully!/);
 
-  await expect(page.locator('.ant-table-tbody')).not.toContainText(botName);
+  await page.getByTestId('searchbar').clear();
+  await page.getByTestId('searchbar').fill(BOT_DETAILS.updatedBotName);
+  await waitForAllLoadersToDisappear(page);
+  await expect(page.getByTestId('search-error-placeholder')).toBeVisible();
 };
 
 export const updateBotDetails = async (page: Page) => {

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

@@ -198,6 +198,25 @@ export const clickOutside = async (page: Page) => {
   });
 };
 
+export const searchFromSearchInput = async (
+  page: Page,
+  searchInput: Locator,
+  searchTerm: string
+) => {
+  const searchResponsePromise = page.waitForResponse(
+    (response) =>
+      response.url().includes('/api/v1/search/query') &&
+      response.request().method() === 'GET'
+  );
+
+  await searchInput.clear();
+  await searchInput.fill(searchTerm);
+  await expect(searchInput).toHaveValue(searchTerm);
+
+  const searchResponse = await searchResponsePromise;
+  expect(searchResponse.status()).toBe(200);
+};
+
 export const visitOwnProfilePage = async (page: Page) => {
   await page.locator('[data-testid="dropdown-profile"] svg').click();
   await page.locator('[role="menu"].profile-dropdown').waitFor({

openmetadata-ui/src/main/resources/ui/src/components/Settings/Bot/BotListV1/BotListV1.component.test.tsx

@@ -10,9 +10,17 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-import { fireEvent, render, screen } from '@testing-library/react';
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from '@testing-library/react';
 import { MemoryRouter } from 'react-router-dom';
 import LimitWrapper from '../../../../hoc/LimitWrapper';
+import { getBots } from '../../../../rest/botsAPI';
+import { searchQuery } from '../../../../rest/searchAPI';
 import BotListV1 from './BotListV1.component';
 
 const mockHandleAddBotClick = jest.fn();
@@ -24,6 +32,37 @@ const mockProps = {
   handleShowDeleted: mockHandleShowDeleted,
 };
 
+const MOCK_BOTS = [
+  {
+    id: 'bot-1-id',
+    name: 'AutoClassification-bot',
+    fullyQualifiedName: 'AutoClassification-bot',
+    displayName: 'AutoClassificationBot',
+    description: 'Auto classify',
+    deleted: false,
+  },
+  {
+    id: 'bot-2-id',
+    name: 'testbot',
+    fullyQualifiedName: 'testbot',
+    displayName: 'testbots',
+    description: 'Test bot',
+    deleted: false,
+  },
+];
+
+const MOCK_SEARCH_USER_HIT = {
+  _source: {
+    id: 'user-2-id',
+    name: 'testbot',
+    fullyQualifiedName: 'testbot',
+    displayName: 'testbots',
+    email: 'testbot@test.com',
+    isBot: true,
+    entityType: 'user',
+  },
+};
+
 jest.mock('../../../../hoc/LimitWrapper', () => {
   return jest.fn().mockImplementation(() => <>LimitWrapper</>);
 });
@@ -39,6 +78,33 @@ jest.mock('../../../../utils/EntityUtils', () => ({
   getTitleCase: jest.fn((text) => text.charAt(0).toUpperCase() + text.slice(1)),
 }));
 
+jest.mock('../../../../rest/botsAPI', () => ({
+  getBots: jest.fn(),
+}));
+
+jest.mock('../../../../rest/searchAPI', () => ({
+  searchQuery: jest.fn(),
+}));
+
+const mockGetBots = getBots as jest.MockedFunction<typeof getBots>;
+const mockSearchQuery = searchQuery as jest.MockedFunction<typeof searchQuery>;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+
+  mockGetBots.mockResolvedValue({
+    data: MOCK_BOTS,
+    paging: { total: MOCK_BOTS.length },
+  } as unknown as Awaited<ReturnType<typeof getBots>>);
+
+  mockSearchQuery.mockResolvedValue({
+    hits: {
+      total: { value: 0 },
+      hits: [],
+    },
+  } as unknown as Awaited<ReturnType<typeof searchQuery>>);
+});
+
 describe('BotListV1', () => {
   it('renders the component', () => {
     render(<BotListV1 {...mockProps} />, { wrapper: MemoryRouter });
@@ -58,11 +124,70 @@ describe('BotListV1', () => {
     render(<BotListV1 {...mockProps} />, { wrapper: MemoryRouter });
     const addBotButton = screen.getByText('LimitWrapper');
     fireEvent.click(addBotButton);
-    // Add your assertions here
 
     expect(LimitWrapper).toHaveBeenCalledWith(
       expect.objectContaining({ resource: 'bot' }),
       {}
     );
   });
+
+  it('searches bot user index with wildcard across name, displayName, fqn, email', async () => {
+    mockSearchQuery.mockResolvedValueOnce({
+      hits: {
+        total: { value: 1 },
+        hits: [MOCK_SEARCH_USER_HIT],
+      },
+    } as unknown as Awaited<ReturnType<typeof searchQuery>>);
+
+    render(<BotListV1 {...mockProps} />, { wrapper: MemoryRouter });
+
+    await waitFor(() => {
+      expect(mockGetBots).toHaveBeenCalled();
+    });
+
+    const searchInput = await screen.findByTestId('searchbar');
+    await act(async () => {
+      fireEvent.change(searchInput, { target: { value: 'testbot' } });
+    });
+
+    await waitFor(() => {
+      const searchCall = mockSearchQuery.mock.calls.find((call) => {
+        const arg = call[0] as { query?: string; queryFilter?: unknown };
+        const filterStr = JSON.stringify(arg.queryFilter);
+
+        return (
+          arg.query === '' &&
+          filterStr.includes('*testbot*') &&
+          filterStr.includes('email.keyword') &&
+          filterStr.includes('name.keyword') &&
+          filterStr.includes('displayName.keyword') &&
+          filterStr.includes('fullyQualifiedName.keyword')
+        );
+      });
+
+      expect(searchCall).toBeDefined();
+    });
+  });
+
+  it('resolves matched bot user to bot entity via lowercased name match', async () => {
+    mockSearchQuery.mockResolvedValueOnce({
+      hits: {
+        total: { value: 1 },
+        hits: [MOCK_SEARCH_USER_HIT],
+      },
+    } as unknown as Awaited<ReturnType<typeof searchQuery>>);
+
+    render(<BotListV1 {...mockProps} />, { wrapper: MemoryRouter });
+
+    await waitFor(() => {
+      expect(mockGetBots).toHaveBeenCalled();
+    });
+
+    const searchInput = await screen.findByTestId('searchbar');
+    await act(async () => {
+      fireEvent.change(searchInput, { target: { value: 'testbot' } });
+    });
+
+    expect(await screen.findByTestId('bot-link-testbots')).toBeInTheDocument();
+  });
 });