mobile/android/fenix/app/src/androidTest/java/org/mozilla/fenix/ui/SearchTest.kt

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 package org.mozilla.fenix.ui
   6
   7 import android.content.Context
   8 import android.hardware.camera2.CameraManager
   9 import androidx.compose.ui.test.junit4.AndroidComposeTestRule
  10 import androidx.core.net.toUri
  11 import androidx.test.espresso.Espresso.openActionBarOverflowOrOptionsMenu
  12 import androidx.test.espresso.Espresso.pressBack
  13 import mozilla.components.concept.engine.utils.EngineReleaseChannel
  14 import okhttp3.mockwebserver.MockWebServer
  15 import org.junit.After
  16 import org.junit.Assume.assumeTrue
  17 import org.junit.Before
  18 import org.junit.Ignore
  19 import org.junit.Rule
  20 import org.junit.Test
  21 import org.mozilla.fenix.customannotations.SmokeTest
  22 import org.mozilla.fenix.ext.components
  23 import org.mozilla.fenix.ext.settings
  24 import org.mozilla.fenix.helpers.AppAndSystemHelper.assertNativeAppOpens
  25 import org.mozilla.fenix.helpers.AppAndSystemHelper.denyPermission
  26 import org.mozilla.fenix.helpers.AppAndSystemHelper.grantSystemPermission
  27 import org.mozilla.fenix.helpers.AppAndSystemHelper.runWithCondition
  28 import org.mozilla.fenix.helpers.AppAndSystemHelper.runWithSystemLocaleChanged
  29 import org.mozilla.fenix.helpers.AppAndSystemHelper.verifyKeyboardVisibility
  30 import org.mozilla.fenix.helpers.Constants.PackageName.ANDROID_SETTINGS
  31 import org.mozilla.fenix.helpers.Constants.searchEngineCodes
  32 import org.mozilla.fenix.helpers.HomeActivityTestRule
  33 import org.mozilla.fenix.helpers.MatcherHelper.itemContainingText
  34 import org.mozilla.fenix.helpers.MatcherHelper.itemWithText
  35 import org.mozilla.fenix.helpers.MockBrowserDataHelper.createBookmarkItem
  36 import org.mozilla.fenix.helpers.MockBrowserDataHelper.createHistoryItem
  37 import org.mozilla.fenix.helpers.MockBrowserDataHelper.createTabItem
  38 import org.mozilla.fenix.helpers.MockBrowserDataHelper.setCustomSearchEngine
  39 import org.mozilla.fenix.helpers.SearchDispatcher
  40 import org.mozilla.fenix.helpers.TestAssetHelper.getGenericAsset
  41 import org.mozilla.fenix.helpers.TestHelper.appContext
  42 import org.mozilla.fenix.helpers.TestHelper.clickSnackbarButton
  43 import org.mozilla.fenix.helpers.TestHelper.exitMenu
  44 import org.mozilla.fenix.helpers.TestHelper.longTapSelectItem
  45 import org.mozilla.fenix.helpers.TestHelper.mDevice
  46 import org.mozilla.fenix.helpers.TestHelper.verifySnackBarText
  47 import org.mozilla.fenix.helpers.TestSetup
  48 import org.mozilla.fenix.ui.robots.clickContextMenuItem
  49 import org.mozilla.fenix.ui.robots.clickPageObject
  50 import org.mozilla.fenix.ui.robots.homeScreen
  51 import org.mozilla.fenix.ui.robots.longClickPageObject
  52 import org.mozilla.fenix.ui.robots.multipleSelectionToolbar
  53 import org.mozilla.fenix.ui.robots.navigationToolbar
  54 import org.mozilla.fenix.ui.robots.searchScreen
  55 import java.util.Locale
  56
  57 /**
  58  *  Tests for verifying the search fragment
  59  *
  60  *  Including:
  61  * - Verify the toolbar, awesomebar, and shortcut bar are displayed
  62  * - Select shortcut button
  63  * - Select scan button
  64  *
  65  */
  66
  67 class SearchTest : TestSetup() {
  68     private lateinit var searchMockServer: MockWebServer
  69     private var queryString = "firefox"
  70     private val generalEnginesList = listOf("DuckDuckGo", "Google", "Bing")
  71     private val topicEnginesList = listOf("Amazon.com", "Wikipedia", "eBay")
  72
  73     @get:Rule
  74     val activityTestRule = AndroidComposeTestRule(
  75         HomeActivityTestRule(
  76             skipOnboarding = true,
  77             isPocketEnabled = false,
  78             isJumpBackInCFREnabled = false,
  79             isRecentTabsFeatureEnabled = false,
  80             isTCPCFREnabled = false,
  81             isWallpaperOnboardingEnabled = false,
  82             tabsTrayRewriteEnabled = false,
  83         ),
  84     ) { it.activity }
  85
  86     @Before
  87     override fun setUp() {
  88         super.setUp()
  89         searchMockServer = MockWebServer().apply {
  90             dispatcher = SearchDispatcher()
  91             start()
  92         }
  93     }
  94
  95     @After
  96     override fun tearDown() {
  97         searchMockServer.shutdown()
  98     }
  99
 100     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154189
 101     @Test
 102     fun verifySearchBarItemsTest() {
 103         navigationToolbar {
 104             verifyDefaultSearchEngine("Google")
 105             verifySearchBarPlaceholder("Search or enter address")
 106         }.clickUrlbar {
 107             verifyKeyboardVisibility(isExpectedToBeVisible = true)
 108             verifyScanButtonVisibility(visible = true)
 109             verifyVoiceSearchButtonVisibility(enabled = true)
 110             verifySearchBarPlaceholder("Search or enter address")
 111             typeSearch("mozilla ")
 112             verifyScanButtonVisibility(visible = false)
 113             verifyVoiceSearchButtonVisibility(enabled = true)
 114         }
 115     }
 116
 117     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154190
 118     @Test
 119     fun verifySearchSelectorMenuItemsTest() {
 120         homeScreen {
 121         }.openSearch {
 122             verifySearchView()
 123             verifySearchToolbar(isDisplayed = true)
 124             clickSearchSelectorButton()
 125             verifySearchShortcutListContains(
 126                 "DuckDuckGo", "Google", "Amazon.com", "Wikipedia", "Bing", "eBay",
 127                 "Bookmarks", "Tabs", "History", "Search settings",
 128             )
 129         }
 130     }
 131
 132     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154194
 133     @Test
 134     fun verifySearchPlaceholderForGeneralDefaultSearchEnginesTest() {
 135         generalEnginesList.forEach {
 136             homeScreen {
 137             }.openSearch {
 138                 clickSearchSelectorButton()
 139             }.clickSearchEngineSettings {
 140                 openDefaultSearchEngineMenu()
 141                 changeDefaultSearchEngine(it)
 142                 exitMenu()
 143             }
 144             navigationToolbar {
 145                 verifySearchBarPlaceholder("Search or enter address")
 146             }
 147         }
 148     }
 149
 150     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154195
 151     @Test
 152     fun verifySearchPlaceholderForNotDefaultGeneralSearchEnginesTest() {
 153         val generalEnginesList = listOf("DuckDuckGo", "Bing")
 154
 155         generalEnginesList.forEach {
 156             homeScreen {
 157             }.openSearch {
 158                 clickSearchSelectorButton()
 159                 selectTemporarySearchMethod(it)
 160                 verifySearchBarPlaceholder("Search the web")
 161             }.dismissSearchBar {}
 162         }
 163     }
 164
 165     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154196
 166     @Test
 167     fun verifySearchPlaceholderForTopicSpecificSearchEnginesTest() {
 168         val topicEnginesList = listOf("Amazon.com", "Wikipedia", "eBay")
 169
 170         topicEnginesList.forEach {
 171             homeScreen {
 172             }.openSearch {
 173                 clickSearchSelectorButton()
 174                 selectTemporarySearchMethod(it)
 175                 verifySearchBarPlaceholder("Enter search terms")
 176             }.dismissSearchBar {}
 177         }
 178     }
 179
 180     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1059459
 181     @SmokeTest
 182     @Test
 183     fun verifyQRScanningCameraAccessDialogTest() {
 184         val cameraManager = appContext.getSystemService(Context.CAMERA_SERVICE) as CameraManager
 185         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
 186
 187         homeScreen {
 188         }.openSearch {
 189             clickScanButton()
 190             denyPermission()
 191             clickScanButton()
 192             clickDismissPermissionRequiredDialog()
 193         }
 194         homeScreen {
 195         }.openSearch {
 196             clickScanButton()
 197             clickGoToPermissionsSettings()
 198             assertNativeAppOpens(ANDROID_SETTINGS)
 199         }
 200     }
 201
 202     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/235397
 203     @SmokeTest
 204     @Test
 205     fun scanQRCodeToOpenAWebpageTest() {
 206         val cameraManager = appContext.getSystemService(Context.CAMERA_SERVICE) as CameraManager
 207         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
 208
 209         homeScreen {
 210         }.openSearch {
 211             clickScanButton()
 212             grantSystemPermission()
 213             verifyScannerOpen()
 214         }
 215     }
 216
 217     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154191
 218     @Test
 219     fun verifyScanButtonAvailableOnlyForGeneralSearchEnginesTest() {
 220         generalEnginesList.forEach {
 221             homeScreen {
 222             }.openSearch {
 223                 clickSearchSelectorButton()
 224                 selectTemporarySearchMethod(it)
 225                 verifyScanButtonVisibility(visible = true)
 226             }.dismissSearchBar {}
 227         }
 228
 229         topicEnginesList.forEach {
 230             homeScreen {
 231             }.openSearch {
 232                 clickSearchSelectorButton()
 233                 selectTemporarySearchMethod(it)
 234                 verifyScanButtonVisibility(visible = false)
 235             }.dismissSearchBar {}
 236         }
 237     }
 238
 239     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/235395
 240     // Verifies a temporary change of search engine from the Search shortcut menu
 241     @SmokeTest
 242     @Test
 243     fun searchEnginesCanBeChangedTemporarilyFromSearchSelectorMenuTest() {
 244         val enginesList = listOf("DuckDuckGo", "Google", "Amazon.com", "Wikipedia", "Bing", "eBay")
 245
 246         enginesList.forEach {
 247             homeScreen {
 248             }.openSearch {
 249                 clickSearchSelectorButton()
 250                 verifySearchShortcutListContains(it)
 251                 selectTemporarySearchMethod(it)
 252                 verifySearchEngineIcon(it)
 253             }.submitQuery("mozilla ") {
 254                 verifyUrl("mozilla")
 255             }.goToHomescreen {}
 256         }
 257     }
 258
 259     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/233589
 260     @Test
 261     fun defaultSearchEnginesCanBeSetFromSearchSelectorMenuTest() {
 262         searchScreen {
 263             clickSearchSelectorButton()
 264         }.clickSearchEngineSettings {
 265             verifyToolbarText("Search")
 266             openDefaultSearchEngineMenu()
 267             changeDefaultSearchEngine("DuckDuckGo")
 268             exitMenu()
 269         }
 270         homeScreen {
 271         }.openSearch {
 272         }.submitQuery(queryString) {
 273             verifyUrl(queryString)
 274         }
 275     }
 276
 277     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/522918
 278     @Test
 279     fun verifyClearSearchButtonTest() {
 280         homeScreen {
 281         }.openSearch {
 282             typeSearch(queryString)
 283             clickClearButton()
 284             verifySearchBarPlaceholder("Search or enter address")
 285         }
 286     }
 287
 288     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1623441
 289     @Ignore("Test run timing out: https://github.com/mozilla-mobile/fenix/issues/27704")
 290     @SmokeTest
 291     @Test
 292     fun searchResultsOpenedInNewTabsGenerateSearchGroupsTest() {
 293         // setting our custom mockWebServer search URL
 294         val searchEngineName = "TestSearchEngine"
 295         setCustomSearchEngine(searchMockServer, searchEngineName)
 296
 297         // Performs a search and opens 2 dummy search results links to create a search group
 298         homeScreen {
 299         }.openSearch {
 300         }.submitQuery(queryString) {
 301             longClickPageObject(itemWithText("Link 1"))
 302             clickContextMenuItem("Open link in new tab")
 303             clickSnackbarButton("SWITCH")
 304             waitForPageToLoad()
 305             pressBack()
 306             longClickPageObject(itemWithText("Link 2"))
 307             clickContextMenuItem("Open link in new tab")
 308             clickSnackbarButton("SWITCH")
 309             waitForPageToLoad()
 310         }.openTabDrawer {
 311         }.openTabsListThreeDotMenu {
 312         }.closeAllTabs {
 313             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 314         }
 315     }
 316
 317     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1592229
 318     @Ignore("Test run timing out: https://github.com/mozilla-mobile/fenix/issues/27704")
 319     @Test
 320     fun verifyAPageIsAddedToASearchGroupOnlyOnceTest() {
 321         val firstPageUrl = getGenericAsset(searchMockServer, 1).url
 322         val secondPageUrl = getGenericAsset(searchMockServer, 2).url
 323         val originPageUrl =
 324             "http://localhost:${searchMockServer.port}/pages/searchResults.html?search=test%20search".toUri()
 325         // setting our custom mockWebServer search URL
 326         val searchEngineName = "TestSearchEngine"
 327         setCustomSearchEngine(searchMockServer, searchEngineName)
 328
 329         // Performs a search and opens 2 dummy search results links to create a search group
 330         homeScreen {
 331         }.openSearch {
 332         }.submitQuery(queryString) {
 333             longClickPageObject(itemWithText("Link 1"))
 334             clickContextMenuItem("Open link in new tab")
 335             clickSnackbarButton("SWITCH")
 336             waitForPageToLoad()
 337             pressBack()
 338             longClickPageObject(itemWithText("Link 1"))
 339             clickContextMenuItem("Open link in new tab")
 340             clickSnackbarButton("SWITCH")
 341             waitForPageToLoad()
 342             pressBack()
 343             longClickPageObject(itemWithText("Link 2"))
 344             clickContextMenuItem("Open link in new tab")
 345             clickSnackbarButton("SWITCH")
 346             waitForPageToLoad()
 347             pressBack()
 348             longClickPageObject(itemWithText("Link 1"))
 349             clickContextMenuItem("Open link in new tab")
 350             clickSnackbarButton("SWITCH")
 351             waitForPageToLoad()
 352         }.openTabDrawer {
 353         }.openTabsListThreeDotMenu {
 354         }.closeAllTabs {
 355             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 356         }.openRecentlyVisitedSearchGroupHistoryList(queryString) {
 357             verifyTestPageUrl(firstPageUrl)
 358             verifyTestPageUrl(secondPageUrl)
 359             verifyTestPageUrl(originPageUrl)
 360         }
 361     }
 362
 363     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1591782
 364     @Ignore("Failing due to known bug, see https://github.com/mozilla-mobile/fenix/issues/23818")
 365     @Test
 366     fun searchGroupIsGeneratedWhenNavigatingInTheSameTabTest() {
 367         // setting our custom mockWebServer search URL
 368         val searchEngineName = "TestSearchEngine"
 369         setCustomSearchEngine(searchMockServer, searchEngineName)
 370
 371         // Performs a search and opens 2 dummy search results links to create a search group
 372         homeScreen {
 373         }.openSearch {
 374         }.submitQuery(queryString) {
 375             clickPageObject(itemContainingText("Link 1"))
 376             waitForPageToLoad()
 377             pressBack()
 378             clickPageObject(itemContainingText("Link 2"))
 379             waitForPageToLoad()
 380         }.openTabDrawer {
 381         }.openTabsListThreeDotMenu {
 382         }.closeAllTabs {
 383             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 384         }
 385     }
 386
 387     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1591781
 388     @SmokeTest
 389     @Test
 390     fun searchGroupIsNotGeneratedForLinksOpenedInPrivateTabsTest() {
 391         // setting our custom mockWebServer search URL
 392         val searchEngineName = "TestSearchEngine"
 393         setCustomSearchEngine(searchMockServer, searchEngineName)
 394
 395         // Performs a search and opens 2 dummy search results links to create a search group
 396         homeScreen {
 397         }.openSearch {
 398         }.submitQuery(queryString) {
 399             longClickPageObject(itemWithText("Link 1"))
 400             clickContextMenuItem("Open link in private tab")
 401             longClickPageObject(itemWithText("Link 2"))
 402             clickContextMenuItem("Open link in private tab")
 403         }.openTabDrawer {
 404         }.toggleToPrivateTabs {
 405         }.openTabWithIndex(0) {
 406         }.openTabDrawer {
 407         }.openTabWithIndex(1) {
 408         }.openTabDrawer {
 409         }.openTabsListThreeDotMenu {
 410         }.closeAllTabs {
 411             togglePrivateBrowsingModeOnOff()
 412             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = false, searchTerm = queryString, groupSize = 3)
 413         }.openThreeDotMenu {
 414         }.openHistory {
 415             verifyHistoryItemExists(shouldExist = false, item = "3 sites")
 416         }
 417     }
 418
 419     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1592269
 420     @Ignore("Test run timing out: https://github.com/mozilla-mobile/fenix/issues/27704")
 421     @SmokeTest
 422     @Test
 423     fun deleteIndividualHistoryItemsFromSearchGroupTest() {
 424         val firstPageUrl = getGenericAsset(searchMockServer, 1).url
 425         val secondPageUrl = getGenericAsset(searchMockServer, 2).url
 426         // setting our custom mockWebServer search URL
 427         val searchEngineName = "TestSearchEngine"
 428         setCustomSearchEngine(searchMockServer, searchEngineName)
 429
 430         // Performs a search and opens 2 dummy search results links to create a search group
 431         homeScreen {
 432         }.openSearch {
 433         }.submitQuery(queryString) {
 434             longClickPageObject(itemWithText("Link 1"))
 435             clickContextMenuItem("Open link in new tab")
 436             clickSnackbarButton("SWITCH")
 437             waitForPageToLoad()
 438             mDevice.pressBack()
 439             longClickPageObject(itemWithText("Link 2"))
 440             clickContextMenuItem("Open link in new tab")
 441             clickSnackbarButton("SWITCH")
 442             waitForPageToLoad()
 443         }.openTabDrawer {
 444         }.openTabsListThreeDotMenu {
 445         }.closeAllTabs {
 446             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 447         }.openRecentlyVisitedSearchGroupHistoryList(queryString) {
 448             clickDeleteHistoryButton(firstPageUrl.toString())
 449             longTapSelectItem(secondPageUrl)
 450             multipleSelectionToolbar {
 451                 openActionBarOverflowOrOptionsMenu(activityTestRule.activity)
 452                 clickMultiSelectionDelete()
 453             }
 454             exitMenu()
 455         }
 456         homeScreen {
 457             // checking that the group is removed when only 1 item is left
 458             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = false, searchTerm = queryString, groupSize = 1)
 459         }
 460     }
 461
 462     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1592242
 463     @Ignore("Test run timing out: https://github.com/mozilla-mobile/fenix/issues/27704")
 464     @Test
 465     fun deleteSearchGroupFromHomeScreenTest() {
 466         val firstPageUrl = getGenericAsset(searchMockServer, 1).url
 467         // setting our custom mockWebServer search URL
 468         val searchEngineName = "TestSearchEngine"
 469         setCustomSearchEngine(searchMockServer, searchEngineName)
 470
 471         // Performs a search and opens 2 dummy search results links to create a search group
 472         homeScreen {
 473         }.openSearch {
 474         }.submitQuery(queryString) {
 475             longClickPageObject(itemWithText("Link 1"))
 476             clickContextMenuItem("Open link in new tab")
 477             clickSnackbarButton("SWITCH")
 478             waitForPageToLoad()
 479             mDevice.pressBack()
 480             longClickPageObject(itemWithText("Link 2"))
 481             clickContextMenuItem("Open link in new tab")
 482             clickSnackbarButton("SWITCH")
 483             waitForPageToLoad()
 484         }.openTabDrawer {
 485         }.openTabsListThreeDotMenu {
 486         }.closeAllTabs {
 487             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 488         }.openRecentlyVisitedSearchGroupHistoryList(queryString) {
 489             clickDeleteAllHistoryButton()
 490             confirmDeleteAllHistory()
 491             verifySnackBarText("Group deleted")
 492             verifyHistoryItemExists(shouldExist = false, firstPageUrl.toString())
 493         }.goBack {}
 494         homeScreen {
 495             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = false, queryString, groupSize = 3)
 496         }.openThreeDotMenu {
 497         }.openHistory {
 498             verifySearchGroupDisplayed(shouldBeDisplayed = false, queryString, groupSize = 3)
 499             verifyEmptyHistoryView()
 500         }
 501     }
 502
 503     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1592235
 504     @Ignore("Test run timing out: https://github.com/mozilla-mobile/fenix/issues/27704")
 505     @Test
 506     fun openAPageFromHomeScreenSearchGroupTest() {
 507         val firstPageUrl = getGenericAsset(searchMockServer, 1).url
 508         val secondPageUrl = getGenericAsset(searchMockServer, 2).url
 509         // setting our custom mockWebServer search URL
 510         val searchEngineName = "TestSearchEngine"
 511         setCustomSearchEngine(searchMockServer, searchEngineName)
 512
 513         // Performs a search and opens 2 dummy search results links to create a search group
 514         homeScreen {
 515         }.openSearch {
 516         }.submitQuery(queryString) {
 517             longClickPageObject(itemWithText("Link 1"))
 518             clickContextMenuItem("Open link in new tab")
 519             clickSnackbarButton("SWITCH")
 520             waitForPageToLoad()
 521             mDevice.pressBack()
 522             longClickPageObject(itemWithText("Link 2"))
 523             clickContextMenuItem("Open link in new tab")
 524             clickSnackbarButton("SWITCH")
 525             waitForPageToLoad()
 526         }.openTabDrawer {
 527         }.openTabsListThreeDotMenu {
 528         }.closeAllTabs {
 529             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 530         }.openRecentlyVisitedSearchGroupHistoryList(queryString) {
 531         }.openWebsite(firstPageUrl) {
 532             verifyUrl(firstPageUrl.toString())
 533         }.goToHomescreen {
 534         }.openRecentlyVisitedSearchGroupHistoryList(queryString) {
 535             longTapSelectItem(firstPageUrl)
 536             longTapSelectItem(secondPageUrl)
 537             openActionBarOverflowOrOptionsMenu(activityTestRule.activity)
 538         }
 539
 540         multipleSelectionToolbar {
 541         }.clickOpenNewTab {
 542             verifyNormalModeSelected()
 543         }.closeTabDrawer {}
 544         openActionBarOverflowOrOptionsMenu(activityTestRule.activity)
 545         multipleSelectionToolbar {
 546         }.clickOpenPrivateTab {
 547             verifyPrivateModeSelected()
 548         }
 549     }
 550
 551     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1592238
 552     @Ignore("Test run timing out: https://github.com/mozilla-mobile/fenix/issues/27704")
 553     @Test
 554     fun shareAPageFromHomeScreenSearchGroupTest() {
 555         val firstPageUrl = getGenericAsset(searchMockServer, 1).url
 556         // setting our custom mockWebServer search URL
 557         val searchEngineName = "TestSearchEngine"
 558         setCustomSearchEngine(searchMockServer, searchEngineName)
 559
 560         // Performs a search and opens 2 dummy search results links to create a search group
 561         homeScreen {
 562         }.openSearch {
 563         }.submitQuery(queryString) {
 564             longClickPageObject(itemWithText("Link 1"))
 565             clickContextMenuItem("Open link in new tab")
 566             clickSnackbarButton("SWITCH")
 567             waitForPageToLoad()
 568             mDevice.pressBack()
 569             longClickPageObject(itemWithText("Link 2"))
 570             clickContextMenuItem("Open link in new tab")
 571             clickSnackbarButton("SWITCH")
 572             waitForPageToLoad()
 573         }.openTabDrawer {
 574         }.openTabsListThreeDotMenu {
 575         }.closeAllTabs {
 576             verifyRecentlyVisitedSearchGroupDisplayed(shouldBeDisplayed = true, searchTerm = queryString, groupSize = 3)
 577         }.openRecentlyVisitedSearchGroupHistoryList(queryString) {
 578             longTapSelectItem(firstPageUrl)
 579         }
 580
 581         multipleSelectionToolbar {
 582             clickShareHistoryButton()
 583             verifyShareOverlay()
 584             verifyShareTabFavicon()
 585             verifyShareTabTitle()
 586             verifyShareTabUrl()
 587         }
 588     }
 589
 590     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1232633
 591     // Default search code for Google-US
 592     @Test
 593     fun defaultSearchCodeGoogleUS() {
 594         homeScreen {
 595         }.openSearch {
 596         }.submitQuery(queryString) {
 597             waitForPageToLoad()
 598         }.openThreeDotMenu {
 599         }.openHistory {
 600             // Full URL no longer visible in the nav bar, so we'll check the history record
 601             // A search group is sometimes created when searching with Google (probably redirects)
 602             try {
 603                 verifyHistoryItemExists(shouldExist = true, searchEngineCodes["Google"]!!)
 604             } catch (e: AssertionError) {
 605                 openSearchGroup(queryString)
 606                 verifyHistoryItemExists(shouldExist = true, searchEngineCodes["Google"]!!)
 607             }
 608         }
 609     }
 610
 611     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1232637
 612     // Default search code for Bing-US
 613     @Test
 614     fun defaultSearchCodeBingUS() {
 615         homeScreen {
 616         }.openThreeDotMenu {
 617         }.openSettings {
 618         }.openSearchSubMenu {
 619             openDefaultSearchEngineMenu()
 620             changeDefaultSearchEngine("Bing")
 621             exitMenu()
 622         }
 623
 624         homeScreen {
 625         }.openSearch {
 626         }.submitQuery(queryString) {
 627             waitForPageToLoad()
 628         }.openThreeDotMenu {
 629         }.openHistory {
 630             // Full URL no longer visible in the nav bar, so we'll check the history record
 631             // A search group is sometimes created when searching with Bing (probably redirects)
 632             try {
 633                 verifyHistoryItemExists(shouldExist = true, searchEngineCodes["Bing"]!!)
 634             } catch (e: AssertionError) {
 635                 openSearchGroup(queryString)
 636                 verifyHistoryItemExists(shouldExist = true, searchEngineCodes["Bing"]!!)
 637             }
 638         }
 639     }
 640
 641     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1232638
 642     // Default search code for DuckDuckGo-US
 643     @Test
 644     fun defaultSearchCodeDuckDuckGoUS() {
 645         homeScreen {
 646         }.openThreeDotMenu {
 647         }.openSettings {
 648         }.openSearchSubMenu {
 649             openDefaultSearchEngineMenu()
 650             changeDefaultSearchEngine("DuckDuckGo")
 651             exitMenu()
 652         }
 653         homeScreen {
 654         }.openSearch {
 655         }.submitQuery(queryString) {
 656             waitForPageToLoad()
 657         }.openThreeDotMenu {
 658         }.openHistory {
 659             // Full URL no longer visible in the nav bar, so we'll check the history record
 660             // A search group is sometimes created when searching with DuckDuckGo
 661             try {
 662                 verifyHistoryItemExists(shouldExist = true, item = searchEngineCodes["DuckDuckGo"]!!)
 663             } catch (e: AssertionError) {
 664                 openSearchGroup(queryString)
 665                 verifyHistoryItemExists(shouldExist = true, item = searchEngineCodes["DuckDuckGo"]!!)
 666             }
 667         }
 668     }
 669
 670     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2154215
 671     @SmokeTest
 672     @Test
 673     fun verifyHistorySearchWithBrowsingHistoryTest() {
 674         val firstPageUrl = getGenericAsset(searchMockServer, 1)
 675         val secondPageUrl = getGenericAsset(searchMockServer, 2)
 676
 677         createHistoryItem(firstPageUrl.url.toString())
 678         createHistoryItem(secondPageUrl.url.toString())
 679
 680         navigationToolbar {
 681         }.clickUrlbar {
 682             clickSearchSelectorButton()
 683             selectTemporarySearchMethod(searchEngineName = "History")
 684             typeSearch(searchTerm = "Mozilla")
 685             verifySuggestionsAreNotDisplayed(rule = activityTestRule, "Mozilla")
 686             clickClearButton()
 687             typeSearch(searchTerm = "generic")
 688             verifyTypedToolbarText("generic")
 689             verifySearchEngineSuggestionResults(
 690                 rule = activityTestRule,
 691                 searchSuggestions = arrayOf(
 692                     firstPageUrl.url.toString(),
 693                     secondPageUrl.url.toString(),
 694                 ),
 695                 searchTerm = "generic",
 696             )
 697         }.clickSearchSuggestion(firstPageUrl.url.toString()) {
 698             verifyUrl(firstPageUrl.url.toString())
 699         }
 700     }
 701
 702     @SmokeTest
 703     @Test
 704     fun verifySearchTabsWithOpenTabsTest() {
 705         runWithCondition(
 706             // This test will run only on Beta and RC builds
 707             // The new composable tabs tray is only available in Nightly and Debug.
 708             activityTestRule.activity.components.core.engine.version.releaseChannel == EngineReleaseChannel.RELEASE ||
 709                 activityTestRule.activity.components.core.engine.version.releaseChannel == EngineReleaseChannel.BETA,
 710         ) {
 711             val firstPageUrl = getGenericAsset(searchMockServer, 1)
 712             val secondPageUrl = getGenericAsset(searchMockServer, 2)
 713
 714             createTabItem(firstPageUrl.url.toString())
 715             createTabItem(secondPageUrl.url.toString())
 716
 717             navigationToolbar {
 718             }.clickUrlbar {
 719                 clickSearchSelectorButton()
 720                 selectTemporarySearchMethod(searchEngineName = "Tabs")
 721                 typeSearch(searchTerm = "Mozilla")
 722                 verifySuggestionsAreNotDisplayed(rule = activityTestRule, "Mozilla")
 723                 clickClearButton()
 724                 typeSearch(searchTerm = "generic")
 725                 verifyTypedToolbarText("generic")
 726                 verifySearchEngineSuggestionResults(
 727                     rule = activityTestRule,
 728                     searchSuggestions = arrayOf(
 729                         "Firefox Suggest",
 730                         firstPageUrl.url.toString(),
 731                         secondPageUrl.url.toString(),
 732                     ),
 733                     searchTerm = "generic",
 734                 )
 735             }.clickSearchSuggestion(firstPageUrl.url.toString()) {
 736                 verifyTabCounter("2")
 737             }.openTabDrawer {
 738                 verifyOpenTabsOrder(position = 1, title = firstPageUrl.url.toString())
 739                 verifyOpenTabsOrder(position = 2, title = secondPageUrl.url.toString())
 740             }
 741         }
 742     }
 743
 744     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2230212
 745     @SmokeTest
 746     @Test
 747     fun searchHistoryNotRememberedInPrivateBrowsingTest() {
 748         appContext.settings().shouldShowSearchSuggestionsInPrivate = true
 749
 750         val firstPageUrl = getGenericAsset(searchMockServer, 1)
 751         val searchEngineName = "TestSearchEngine"
 752
 753         setCustomSearchEngine(searchMockServer, searchEngineName)
 754         createBookmarkItem(firstPageUrl.url.toString(), firstPageUrl.title, 1u)
 755
 756         homeScreen {
 757         }.openNavigationToolbar {
 758         }.clickUrlbar {
 759         }.submitQuery("test page 1") {
 760         }.goToHomescreen {
 761         }.togglePrivateBrowsingMode()
 762
 763         homeScreen {
 764         }.openNavigationToolbar {
 765         }.clickUrlbar {
 766         }.submitQuery("test page 2") {
 767         }.openNavigationToolbar {
 768         }.clickUrlbar {
 769             typeSearch(searchTerm = "test page")
 770             verifySearchEngineSuggestionResults(
 771                 rule = activityTestRule,
 772                 searchSuggestions = arrayOf(
 773                     "TestSearchEngine search",
 774                     "test page 1",
 775                     "Firefox Suggest",
 776                     firstPageUrl.url.toString(),
 777                 ),
 778                 searchTerm = "test page 1",
 779             )
 780             // 2 search engine suggestions and 2 browser suggestions (1 history, 1 bookmark)
 781             verifySearchSuggestionsCount(activityTestRule, numberOfSuggestions = 4, searchTerm = "test page")
 782             verifySuggestionsAreNotDisplayed(
 783                 activityTestRule,
 784                 searchSuggestions = arrayOf(
 785                     "test page 2",
 786                 ),
 787             )
 788         }
 789     }
 790
 791     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1232631
 792     // Expected for app language set to Arabic
 793     @Test
 794     fun verifySearchEnginesFunctionalityUsingRTLLocaleTest() {
 795         val arabicLocale = Locale("ar", "AR")
 796
 797         runWithSystemLocaleChanged(arabicLocale, activityTestRule.activityRule) {
 798             homeScreen {
 799             }.openSearch {
 800                 verifyTranslatedFocusedNavigationToolbar("ابحث أو أدخِل عنوانا")
 801                 clickSearchSelectorButton()
 802                 verifySearchShortcutListContains(
 803                     "Google",
 804                     "Bing",
 805                     "Amazon.com",
 806                     "DuckDuckGo",
 807                     "ويكيبيديا (ar)",
 808                 )
 809                 selectTemporarySearchMethod("ويكيبيديا (ar)")
 810             }.submitQuery("firefox") {
 811                 verifyUrl("firefox")
 812             }
 813         }
 814     }
 815 }