Pricing
Explore test cases for search functionality covering exact match, autocomplete, filters, edge cases, and enterprise scenarios with automation tips.
Search functionality is one of the most heavily used and most poorly tested features in modern applications. A broken search experience does not just frustrate users. It directly impacts revenue, productivity, and trust. For ecommerce platforms, failed search means lost sales. For enterprise applications like CRM, ERP, and healthcare systems, broken search means employees cannot find the data they need to do their jobs. This guide provides ready to use test cases organized by category, with practical examples and strategies for automating search testing at scale.
Search is the fastest path between user intent and content. When users type a query, they expect relevant results immediately. Any failure in this chain, whether the search returns irrelevant results, crashes on special characters, or takes too long to respond, erodes confidence in the entire application.
The business impact is measurable. Ecommerce platforms with effective search functionality see significantly higher conversion rates compared to platforms where users browse without searching. In enterprise applications, employees who cannot find records, transactions, or documents through search resort to manual workarounds that waste time and introduce errors.
Testing search functionality requires systematic coverage across multiple dimensions: accuracy of results, handling of diverse inputs, UI behavior of the search interface, accessibility, and behavior under edge conditions. The test cases below cover each dimension comprehensively.
Positive test cases verify that search works correctly when users provide valid, expected inputs.
Enter a known, existing keyword into the search field and click the search button. Verify that results include items containing the exact keyword. Results should be relevant and ordered by relevance or the default sorting criteria.
Enter the first few characters of a known item (for example, "lap" for "laptop"). Verify that search returns results containing words that begin with or contain the entered characters. This validates prefix matching and substring search capabilities.
Enter a query containing two or more words (for example, "wireless keyboard"). Verify that results contain items matching the combination of keywords. Results matching all keywords should rank higher than results matching only one.
Begin typing a query and wait for autocomplete suggestions to appear. Select a suggestion and verify that the search executes correctly with the selected term and returns relevant results.
Apply a category filter (for example, "Electronics") before executing a search. Verify that search results are restricted to the selected category and remain relevant to the query.
Execute a search for a known term and verify that the displayed result count matches the actual number of results shown. If results are paginated, verify that the total count reflects all pages.
Enter a query using different capitalizations (for example, "LAPTOP", "Laptop", "laptop"). Verify that all variations return the same results, confirming that search is case insensitive.
Execute a search, click on a result item, and verify that the application navigates to the correct detail page. The back button should return the user to the search results with the previous query and results preserved.
Negative test cases verify that search handles invalid, unexpected, or edge case inputs gracefully.
Click the search button without entering any text. Verify that the application either displays a validation message ("Please enter a search term"), shows recent or popular searches, or handles the empty submission without errors.
Enter a term that has no matching results (for example, "xyzabc123"). Verify that the application displays a clear "no results found" message and optionally suggests alternative search terms or popular items.
Enter special characters individually and in combination with text (for example, "@#$%", "test@#ing"). Verify that the application does not crash, does not display error pages, and handles special characters gracefully, either by stripping them or by returning appropriate results.
Enter common SQL injection strings (for example, "' OR 1=1; " or "'; DROP TABLE products;"). Verify that the application sanitizes input properly and does not expose database errors, return unauthorized data, or execute malicious queries.
Enter a script tag in the search field (for example, a JavaScript alert). Verify that the application encodes or strips the input and does not execute any scripts in the browser. The search results page should not render any injected HTML or JavaScript.
Enter a string that exceeds reasonable query length (for example, 1000+ characters). Verify that the application either truncates the input to a maximum length, displays a validation message, or handles the long string without crashing or performance degradation.
Enter multiple spaces with no actual text and submit. Verify that the application treats whitespace only input the same as an empty query and does not return all records or throw an error.
If the search context expects text (for example, product names), enter only numbers (for example, "12345"). Verify that the application handles numeric input without errors and returns relevant results if any match, or a clean "no results" message if none do.
These test cases validate the visual design, interaction patterns, and usability of the search interface.
Inspect the search input field before any text is entered. Verify that appropriate placeholder text is displayed (for example, "Search products...", "What are you looking for?") that guides the user on expected input.
Confirm that the search box is prominently positioned (typically in the header or top navigation) and visible without scrolling on both desktop and mobile viewports.
Click the search icon or button. Verify that it initiates the search action. If the search box is collapsed by default, verify that clicking the icon expands the search input field.
If the application supports keyboard shortcuts (for example, "/" or Ctrl+K to focus the search box), verify that the shortcut works and places the cursor in the search field ready for input.
Click inside the search box. Verify that the cursor appears, the field border or background changes to indicate focus state, and any placeholder text remains visible until the user begins typing.
Enter text in the search field and look for a clear button (typically an "X" icon). Click it and verify that the search field is emptied and any previous results are cleared or the page returns to its default state.
Type a query in the search field and press Enter. Verify that the search executes and results are displayed, identical to clicking the search button.
Resize the browser window to various breakpoints (desktop, tablet, mobile). Verify that the search box adapts appropriately: maintaining usability, adjusting layout, or collapsing into a search icon with an expandable field on smaller screens.
Begin typing and verify that the autocomplete dropdown appears within a reasonable time (typically under 300 milliseconds). Verify that suggestions are relevant, keyboard navigable (arrow keys), and selectable via click or Enter key.
These test cases verify the accuracy, relevance, and presentation of search results.
Search for a specific term and evaluate whether the most relevant results appear at the top. Exact matches should rank higher than partial matches. Title matches should rank higher than description matches.
If the results page offers sorting options (relevance, date, price, alphabetical), apply each sort option and verify that results reorder correctly according to the selected criteria.
Apply available filters (category, date range, price range, status) to search results. Verify that results update to reflect only items matching the applied filters. Verify that filter counts, if displayed, are accurate.
After executing a search, inspect the results. Verify that the search terms are highlighted (bold, colored, or otherwise distinguished) within the result titles and descriptions to help users identify why each result matched.
Execute a search that returns more results than fit on a single page. Verify that pagination controls appear, page navigation works correctly, and the total result count is consistent across pages.
Execute a search and review all results across all pages. Verify that no single item appears more than once in the results.
Each search result should display the essential information users need to evaluate it: title, description or summary, relevant metadata (date, price, category), and a link to the full item. Verify that no result card is missing expected fields.
When a search returns no results, verify that the page displays a helpful message, suggests alternative actions (browse categories, check spelling, try broader terms), and does not display an empty or broken layout.
These test cases address scenarios unique to ecommerce platforms.
Enter a known product SKU or identifier. Verify that the exact product is returned as the first or only result.
Enter a brand name and verify that results display products from that brand, sorted by relevance or popularity.
Search for a product category, then apply a price range filter. Verify that all displayed results fall within the specified price range and that the result count updates accordingly.
Search for a product that is known to be out of stock. Verify that the product appears in results (if that is the expected behavior) with a clear "out of stock" indicator, or that it is excluded from results with no misleading display.
Enter a common misspelling of a popular product (for example, "iphon" instead of "iphone"). Verify that the application either corrects the spelling automatically ("Did you mean: iPhone?") or returns relevant results despite the typo through fuzzy matching.
If the search results page includes "Add to Cart" buttons, click one and verify that the product is added to the cart correctly with the right product details, quantity, and price.
Enter a query that could match products in multiple categories (for example, "black"). Verify that results span relevant categories and that category labels or groupings help users distinguish between categories.
These test cases address search functionality in business applications like CRM, ERP, and healthcare systems.
In a CRM or ERP system, search for a customer by full name and by partial name. Verify that the correct customer record is returned with associated account details.
Enter a transaction reference, order number, claim number, or case ID. Verify that the exact record is returned. Reference number searches should return precise results, not fuzzy matches.
Search for records created or modified within a specific date range. Verify that all returned records fall within the specified dates and that records outside the range are excluded.
In enterprise applications that support global search (for example, Salesforce Global Search), enter a query that matches records of different types (contacts, accounts, opportunities). Verify that results are categorized by record type and that each result links to the correct record.
Execute the same search as users with different permission levels. Verify that search results respect access controls: restricted records should not appear in search results for unauthorized users.
For ERP systems, test search functionality within specific modules (finance, supply chain, human resources). Verify that module specific search returns relevant records from that module and that cross module search, if supported, works correctly.
If the enterprise application supports multilingual data, enter search terms in different languages. Verify that results include records regardless of the language the data was entered in (if cross language search is supported) or that results correctly filter by the user's locale.
Use a screen reader to navigate to the search box. Verify that the search field has an appropriate aria label or associated label element that announces its purpose (for example, "Search products").
Complete an entire search workflow using only the keyboard: Tab to the search field, type a query, press Enter to search, Tab through results, and press Enter to select a result. Verify that focus indicators are visible and all actions are accessible.
When autocomplete suggestions appear, verify that screen readers announce the number of suggestions and that users can navigate suggestions using arrow keys with each option announced.
Manually executing 50+ search test cases across multiple browsers, devices, and data conditions is time intensive and error prone. Automation transforms search testing from a multi day manual effort into a continuous verification process that runs in minutes.
Search functionality poses specific challenges for traditional automation frameworks. Autocomplete dropdowns are dynamic elements that appear and disappear based on timing, making them difficult to locate with static locators. Search results load asynchronously, requiring careful synchronization. Enterprise application search boxes often use complex UI components with Shadow DOM encapsulation or dynamically generated IDs that break conventional locator strategies.
Selenium users frequently encounter NotFoundException and StaleElementReferenceException when automating search tests because the DOM changes rapidly during search interactions. Each of these exceptions requires custom handling logic that adds complexity and maintenance burden.
AI native test platform like Virtuoso QA eliminate these challenges architecturally. Natural Language Programming allows testers to write search tests in plain English:
Navigate to the homepage
Type "wireless keyboard" into the "Search" field
Click "Search"
Verify "wireless keyboard" appears in the search results
Verify search results count is greater than 0
The platform handles element identification using AI augmented object identification that builds a comprehensive model of each element based on all available selectors, IDs, and attributes. When autocomplete dropdowns appear, the AI identifies them based on context and behavior, not brittle locators.
Self healing maintains search test stability across application updates. When the search box changes from an input element to a custom component, or when result card layouts are redesigned, the AI adapts automatically with approximately 95% accuracy.
Cross browser verification runs these search tests across 2000+ OS, browser, and device combinations in parallel. Search behavior often varies across browsers, particularly for autocomplete, keyboard interactions, and result rendering. Comprehensive cross browser testing catches these inconsistencies before they reach users.
Try Virtuoso QA in Action
See how Virtuoso QA transforms plain English into fully executable tests within seconds.
