Cleanup tests for toolbar controller

app/src/main/java/org/mozilla/fenix/browser/BaseBrowserFragment.kt

@@ -203,7 +203,7 @@ abstract class BaseBrowserFragment : Fragment(), UserInteractionHandler, Session
 
         return getSessionById()?.also { session ->
             val browserToolbarController = DefaultBrowserToolbarController(
-                activity = requireActivity(),
+                activity = requireActivity() as HomeActivity,
                 navController = findNavController(),
                 readerModeController = DefaultReaderModeController(
                     readerViewFeature,
@@ -224,7 +224,6 @@ abstract class BaseBrowserFragment : Fragment(), UserInteractionHandler, Session
                 scope = viewLifecycleOwner.lifecycleScope,
                 tabCollectionStorage = requireComponents.core.tabCollectionStorage,
                 topSiteStorage = requireComponents.core.topSiteStorage,
-                sharedViewModel = sharedViewModel,
                 onTabCounterClicked = {
                     TabTrayDialogFragment.show(parentFragmentManager)
                 },

app/src/main/java/org/mozilla/fenix/components/toolbar/BrowserToolbarController.kt

@@ -4,7 +4,6 @@
 
 package org.mozilla.fenix.components.toolbar
 
-import android.app.Activity
 import android.content.Intent
 import androidx.annotation.VisibleForTesting
 import androidx.navigation.NavController
@@ -40,7 +39,6 @@ import org.mozilla.fenix.ext.nav
 import org.mozilla.fenix.ext.navigateSafe
 import org.mozilla.fenix.ext.sessionsOfType
 import org.mozilla.fenix.ext.settings
-import org.mozilla.fenix.home.SharedViewModel
 import org.mozilla.fenix.settings.deletebrowsingdata.deleteAndQuit
 import org.mozilla.fenix.utils.Do
 
@@ -59,9 +57,9 @@ interface BrowserToolbarController {
     fun handleReaderModePressed(enabled: Boolean)
 }
 
-@SuppressWarnings("LargeClass", "TooManyFunctions")
+@Suppress("LargeClass", "TooManyFunctions")
 class DefaultBrowserToolbarController(
-    private val activity: Activity,
+    private val activity: HomeActivity,
     private val navController: NavController,
     private val readerModeController: ReaderModeController,
     private val sessionManager: SessionManager,
@@ -75,7 +73,6 @@ class DefaultBrowserToolbarController(
     private val scope: CoroutineScope,
     private val tabCollectionStorage: TabCollectionStorage,
     private val topSiteStorage: TopSiteStorage,
-    private val sharedViewModel: SharedViewModel,
     private val onTabCounterClicked: () -> Unit,
     private val onCloseTab: (Session) -> Unit
 ) : BrowserToolbarController {
@@ -146,7 +143,7 @@ class DefaultBrowserToolbarController(
                     // When closing the last tab we must show the undo snackbar in the home fragment
                     if (sessionManager.sessionsOfType(it.private).count() == 1) {
                         // The tab tray always returns to normal mode so do that here too
-                        (activity as HomeActivity).browsingModeManager.mode = BrowsingMode.Normal
+                        activity.browsingModeManager.mode = BrowsingMode.Normal
                         navController.navigate(BrowserFragmentDirections.actionGlobalHome(sessionToDelete = it.id))
                     } else {
                         onCloseTab.invoke(it)
@@ -155,20 +152,18 @@ class DefaultBrowserToolbarController(
                 }
             }
             is TabCounterMenuItem.NewTab -> {
-                (activity as HomeActivity).browsingModeManager.mode =
+                activity.browsingModeManager.mode = BrowsingMode.fromBoolean(item.isPrivate)
-                    BrowsingMode.fromBoolean(item.isPrivate)
                 navController.popBackStack(R.id.homeFragment, false)
             }
         }
     }
 
     override fun handleBrowserMenuDismissed(lowPrioHighlightItems: List<ToolbarMenu.Item>) {
+        val settings = activity.settings()
         lowPrioHighlightItems.forEach {
             when (it) {
-                ToolbarMenu.Item.AddToHomeScreen -> activity.settings().installPwaOpened = true
+                ToolbarMenu.Item.AddToHomeScreen -> settings.installPwaOpened = true
-                ToolbarMenu.Item.OpenInApp -> activity.settings().openInAppOpened = true
+                ToolbarMenu.Item.OpenInApp -> settings.openInAppOpened = true
-                else -> {
-                }
             }
         }
     }
@@ -178,7 +173,7 @@ class DefaultBrowserToolbarController(
     }
 
     @ExperimentalCoroutinesApi
-    @SuppressWarnings("ComplexMethod", "LongMethod")
+    @Suppress("ComplexMethod", "LongMethod")
     override fun handleToolbarItemInteraction(item: ToolbarMenu.Item) {
         val sessionUseCases = activity.components.useCases.sessionUseCases
         trackToolbarItemInteraction(item)
@@ -203,21 +198,22 @@ class DefaultBrowserToolbarController(
                 currentSession
             )
             ToolbarMenu.Item.AddToTopSites -> {
-                ioScope.launch {
+                scope.launch {
-                    currentSession?.let {
+                    ioScope.launch {
-                        topSiteStorage.addTopSite(it.title, it.url)
+                        currentSession?.let {
-                    }
+                            topSiteStorage.addTopSite(it.title, it.url)
-                    MainScope().launch {
+                        }
-                        FenixSnackbar.make(
+                    }.join()
-                            view = swipeRefresh,
+
-                            duration = Snackbar.LENGTH_SHORT,
+                    FenixSnackbar.make(
-                            isDisplayedWithBrowserToolbar = true
+                        view = swipeRefresh,
+                        duration = Snackbar.LENGTH_SHORT,
+                        isDisplayedWithBrowserToolbar = true
+                    )
+                        .setText(
+                            swipeRefresh.context.getString(R.string.snackbar_added_to_top_sites)
                         )
-                            .setText(
+                        .show()
-                                swipeRefresh.context.getString(R.string.snackbar_added_to_top_sites)
-                            )
-                            .show()
-                    }
                 }
             }
             ToolbarMenu.Item.AddToHomeScreen, ToolbarMenu.Item.InstallToHomeScreen -> {
@@ -341,15 +337,7 @@ class DefaultBrowserToolbarController(
         }
     }
 
-    private fun reportSiteIssue(reportUrl: String, private: Boolean) {
+    @Suppress("ComplexMethod")
-        if (private) {
-            activity.components.useCases.tabsUseCases.addPrivateTab.invoke(reportUrl)
-        } else {
-            activity.components.useCases.tabsUseCases.addTab.invoke(reportUrl)
-        }
-    }
-
-    @SuppressWarnings("ComplexMethod")
     private fun trackToolbarItemInteraction(item: ToolbarMenu.Item) {
         val eventItem = when (item) {
             ToolbarMenu.Item.Back -> Event.BrowserMenuItemTapped.Item.BACK
@@ -386,7 +374,6 @@ class DefaultBrowserToolbarController(
     }
 
     companion object {
-        const val ANIMATION_DELAY = 50L
         internal const val TELEMETRY_BROWSER_IDENTIFIER = "browserMenu"
     }
 }

app/src/test/java/org/mozilla/fenix/components/toolbar/DefaultBrowserToolbarControllerTest.kt

@@ -4,27 +4,26 @@
 
 package org.mozilla.fenix.components.toolbar
 
-import android.content.Context
 import android.content.Intent
-import androidx.lifecycle.LifecycleCoroutineScope
 import androidx.navigation.NavController
 import androidx.navigation.NavDirections
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import io.mockk.MockKAnnotations
 import io.mockk.Runs
 import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.RelaxedMockK
 import io.mockk.just
 import io.mockk.mockk
+import io.mockk.mockkObject
 import io.mockk.mockkStatic
 import io.mockk.slot
+import io.mockk.unmockkStatic
 import io.mockk.verify
 import io.mockk.verifyOrder
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.newSingleThreadContext
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runBlockingTest
-import kotlinx.coroutines.test.setMain
 import mozilla.appservices.places.BookmarkRoot
 import mozilla.components.browser.session.Session
 import mozilla.components.browser.session.SessionManager
@@ -37,9 +36,11 @@ import mozilla.components.feature.search.SearchUseCases
 import mozilla.components.feature.session.SessionUseCases
 import mozilla.components.feature.tab.collections.TabCollection
 import mozilla.components.feature.tabs.TabsUseCases
+import mozilla.components.support.test.rule.MainCoroutineRule
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mozilla.fenix.HomeActivity
@@ -69,26 +70,30 @@ import org.mozilla.fenix.settings.deletebrowsingdata.deleteAndQuit
 @RunWith(FenixRobolectricTestRunner::class)
 class DefaultBrowserToolbarControllerTest {
 
-    private val mainThreadSurrogate = newSingleThreadContext("UI thread")
+    @get:Rule
-    private var swipeRefreshLayout: SwipeRefreshLayout = mockk(relaxed = true)
+    val coroutinesTestRule = MainCoroutineRule()
-    private var activity: HomeActivity = mockk(relaxed = true)
+
-    private var analytics: Analytics = mockk(relaxed = true)
+    @MockK private lateinit var swipeRefreshLayout: SwipeRefreshLayout
-    private var navController: NavController = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var activity: HomeActivity
-    private var findInPageLauncher: () -> Unit = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var analytics: Analytics
-    private val sessionManager: SessionManager = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var navController: NavController
-    private val engineView: EngineView = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var findInPageLauncher: () -> Unit
-    private val currentSession: Session = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var bookmarkTapped: (Session) -> Unit
-    private val openInFenixIntent: Intent = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var onTabCounterClicked: () -> Unit
-    private val currentSessionAsTab: Tab = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var onCloseTab: (Session) -> Unit
-    private val metrics: MetricController = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var sessionManager: SessionManager
-    private val searchUseCases: SearchUseCases = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var engineView: EngineView
-    private val sessionUseCases: SessionUseCases = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var currentSession: Session
-    private val scope: LifecycleCoroutineScope = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var openInFenixIntent: Intent
-    private val browserAnimator: BrowserAnimator = mockk(relaxed = true)
+    @RelaxedMockK private lateinit var currentSessionAsTab: Tab
-    private val snackbar = mockk<FenixSnackbar>(relaxed = true)
+    @RelaxedMockK private lateinit var metrics: MetricController
-    private val tabCollectionStorage = mockk<TabCollectionStorage>(relaxed = true)
+    @RelaxedMockK private lateinit var searchUseCases: SearchUseCases
-    private val topSiteStorage = mockk<TopSiteStorage>(relaxed = true)
+    @RelaxedMockK private lateinit var sessionUseCases: SessionUseCases
-    private val readerModeController = mockk<ReaderModeController>(relaxed = true)
+    @RelaxedMockK private lateinit var browserAnimator: BrowserAnimator
+    @RelaxedMockK private lateinit var snackbar: FenixSnackbar
+    @RelaxedMockK private lateinit var tabCollectionStorage: TabCollectionStorage
+    @RelaxedMockK private lateinit var topSiteStorage: TopSiteStorage
+    @RelaxedMockK private lateinit var readerModeController: ReaderModeController
     private val store: BrowserStore = BrowserStore(initialState = BrowserState(
         listOf(
             createTab("https://www.mozilla.org", id = "reader-inactive-tab"),
@@ -96,41 +101,22 @@ class DefaultBrowserToolbarControllerTest {
         ))
     )
 
-    private lateinit var controller: DefaultBrowserToolbarController
-
     @Before
     fun setUp() {
-        Dispatchers.setMain(mainThreadSurrogate)
+        MockKAnnotations.init(this)
-
-        controller = DefaultBrowserToolbarController(
-            activity = activity,
-            navController = navController,
-            findInPageLauncher = findInPageLauncher,
-            engineView = engineView,
-            browserAnimator = browserAnimator,
-            customTabSession = null,
-            openInFenixIntent = openInFenixIntent,
-            scope = scope,
-            swipeRefresh = swipeRefreshLayout,
-            tabCollectionStorage = tabCollectionStorage,
-            topSiteStorage = topSiteStorage,
-            bookmarkTapped = mockk(),
-            readerModeController = readerModeController,
-            sessionManager = sessionManager,
-            sharedViewModel = mockk(),
-            onTabCounterClicked = { },
-            onCloseTab = {}
-        )
 
         mockkStatic(
             "org.mozilla.fenix.ext.SessionKt"
         )
-        every { any<Session>().toTab(any<Context>()) } returns currentSessionAsTab
+        every { any<Session>().toTab(any()) } returns currentSessionAsTab
 
         mockkStatic(
             "org.mozilla.fenix.settings.deletebrowsingdata.DeleteAndQuitKt"
         )
-        every { deleteAndQuit(any(), any(), snackbar) } just Runs
+        every { deleteAndQuit(any(), any(), any()) } just Runs
+
+        mockkObject(FenixSnackbar.Companion)
+        every { FenixSnackbar.make(any(), any(), any(), any()) } returns snackbar
 
         every { activity.components.analytics } returns analytics
         every { analytics.metrics } returns metrics
@@ -146,15 +132,16 @@ class DefaultBrowserToolbarControllerTest {
 
     @After
     fun tearDown() {
-        Dispatchers.resetMain() // reset main dispatcher to the original Main dispatcher
+        unmockkStatic("org.mozilla.fenix.ext.SessionKt")
-        mainThreadSurrogate.close()
+        unmockkStatic("org.mozilla.fenix.settings.deletebrowsingdata.DeleteAndQuitKt")
     }
 
     @Test
-    fun handleBrowserToolbarPaste() {
+    fun handleBrowserToolbarPaste() = runBlockingTest {
         every { currentSession.id } returns "1"
 
         val pastedText = "Mozilla"
+        val controller = createController(scope = this)
         controller.handleToolbarPaste(pastedText)
 
         verify {
@@ -167,9 +154,10 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleBrowserToolbarPasteAndGoSearch() {
+    fun handleBrowserToolbarPasteAndGoSearch() = runBlockingTest {
         val pastedText = "Mozilla"
 
+        val controller = createController(scope = this)
         controller.handleToolbarPasteAndGo(pastedText)
         verifyOrder {
             currentSession.searchTerms = "Mozilla"
@@ -178,9 +166,10 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleBrowserToolbarPasteAndGoUrl() {
+    fun handleBrowserToolbarPasteAndGoUrl() = runBlockingTest {
         val pastedText = "https://mozilla.org"
 
+        val controller = createController(scope = this)
         controller.handleToolbarPasteAndGo(pastedText)
         verifyOrder {
             currentSession.searchTerms = ""
@@ -188,6 +177,14 @@ class DefaultBrowserToolbarControllerTest {
         }
     }
 
+    @Test
+    fun handleTabCounterClick() = runBlockingTest {
+        val controller = createController(scope = this)
+        controller.handleTabCounterClick()
+
+        verify { onTabCounterClicked() }
+    }
+
     @Test
     fun `handle BrowserMenu dismissed with all options available`() = runBlockingTest {
         val itemList: List<ToolbarMenu.Item> = listOf(
@@ -197,26 +194,7 @@ class DefaultBrowserToolbarControllerTest {
 
         val activity = HomeActivity()
 
-        controller = DefaultBrowserToolbarController(
+        val controller = createController(scope = this, activity = activity)
-            activity = activity,
-            navController = navController,
-            findInPageLauncher = findInPageLauncher,
-            engineView = engineView,
-            browserAnimator = browserAnimator,
-            customTabSession = null,
-            openInFenixIntent = openInFenixIntent,
-            scope = this,
-            swipeRefresh = swipeRefreshLayout,
-            tabCollectionStorage = tabCollectionStorage,
-            topSiteStorage = topSiteStorage,
-            bookmarkTapped = mockk(),
-            readerModeController = mockk(),
-            sessionManager = mockk(),
-            sharedViewModel = mockk(),
-            onTabCounterClicked = { },
-            onCloseTab = { }
-        )
-
         controller.handleBrowserMenuDismissed(itemList)
 
         assertEquals(true, activity.settings().installPwaOpened)
@@ -224,9 +202,10 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarClick() {
+    fun handleToolbarClick() = runBlockingTest {
         every { currentSession.id } returns "1"
 
+        val controller = createController(scope = this)
         controller.handleToolbarClick()
 
         verify { metrics.track(Event.SearchBarTapped(Event.SearchBarTapped.Source.BROWSER)) }
@@ -239,51 +218,56 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarBackPress() {
+    fun handleToolbarBackPress() = runBlockingTest {
         val item = ToolbarMenu.Item.Back
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.BACK)) }
-        verify { sessionUseCases.goBack }
+        verify { sessionUseCases.goBack(currentSession) }
     }
 
     @Test
-    fun handleToolbarForwardPress() {
+    fun handleToolbarForwardPress() = runBlockingTest {
         val item = ToolbarMenu.Item.Forward
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.FORWARD)) }
-        verify { sessionUseCases.goForward }
+        verify { sessionUseCases.goForward(currentSession) }
     }
 
     @Test
-    fun handleToolbarReloadPress() {
+    fun handleToolbarReloadPress() = runBlockingTest {
         val item = ToolbarMenu.Item.Reload
 
         every { activity.components.useCases.sessionUseCases } returns sessionUseCases
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.RELOAD)) }
-        verify { sessionUseCases.reload }
+        verify { sessionUseCases.reload(currentSession) }
     }
 
     @Test
-    fun handleToolbarStopPress() {
+    fun handleToolbarStopPress() = runBlockingTest {
         val item = ToolbarMenu.Item.Stop
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.STOP)) }
-        verify { sessionUseCases.stopLoading }
+        verify { sessionUseCases.stopLoading(currentSession) }
     }
 
     @Test
-    fun handleToolbarSettingsPress() = runBlocking {
+    fun handleToolbarSettingsPress() = runBlockingTest {
         val item = ToolbarMenu.Item.Settings
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.SETTINGS)) }
@@ -294,9 +278,21 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarBookmarksPress() {
+    fun handleToolbarBookmarkPress() = runBlockingTest {
+        val item = ToolbarMenu.Item.Bookmark
+
+        val controller = createController(scope = this)
+        controller.handleToolbarItemInteraction(item)
+
+        verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.BOOKMARK)) }
+        verify { bookmarkTapped(currentSession) }
+    }
+
+    @Test
+    fun handleToolbarBookmarksPress() = runBlockingTest {
         val item = ToolbarMenu.Item.Bookmarks
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.BOOKMARKS)) }
@@ -307,9 +303,10 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarHistoryPress() {
+    fun handleToolbarHistoryPress() = runBlockingTest {
         val item = ToolbarMenu.Item.History
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.HISTORY)) }
@@ -320,13 +317,14 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarRequestDesktopOnPress() {
+    fun handleToolbarRequestDesktopOnPress() = runBlockingTest {
         val requestDesktopSiteUseCase: SessionUseCases.RequestDesktopSiteUseCase =
             mockk(relaxed = true)
         val item = ToolbarMenu.Item.RequestDesktop(true)
 
         every { sessionUseCases.requestDesktopSite } returns requestDesktopSiteUseCase
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.DESKTOP_VIEW_ON)) }
@@ -339,13 +337,14 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarRequestDesktopOffPress() {
+    fun handleToolbarRequestDesktopOffPress() = runBlockingTest {
         val requestDesktopSiteUseCase: SessionUseCases.RequestDesktopSiteUseCase =
             mockk(relaxed = true)
         val item = ToolbarMenu.Item.RequestDesktop(false)
 
         every { sessionUseCases.requestDesktopSite } returns requestDesktopSiteUseCase
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.DESKTOP_VIEW_OFF)) }
@@ -360,30 +359,15 @@ class DefaultBrowserToolbarControllerTest {
     @Test
     fun handleToolbarAddToTopSitesPressed() = runBlockingTest {
         val item = ToolbarMenu.Item.AddToTopSites
+        every {
+            swipeRefreshLayout.context.getString(R.string.snackbar_added_to_top_sites)
+        } returns "Added to top sites!"
 
-        controller = DefaultBrowserToolbarController(
+        val controller = createController(scope = this)
-            activity = activity,
-            navController = navController,
-            findInPageLauncher = findInPageLauncher,
-            engineView = engineView,
-            browserAnimator = browserAnimator,
-            customTabSession = null,
-            openInFenixIntent = openInFenixIntent,
-            scope = this,
-            swipeRefresh = swipeRefreshLayout,
-            tabCollectionStorage = tabCollectionStorage,
-            topSiteStorage = topSiteStorage,
-            bookmarkTapped = mockk(),
-            readerModeController = mockk(),
-            sessionManager = sessionManager,
-            sharedViewModel = mockk(),
-            onTabCounterClicked = { },
-            onCloseTab = { }
-        )
-        controller.ioScope = this
-
         controller.handleToolbarItemInteraction(item)
 
+        verify { topSiteStorage.addTopSite(currentSession.title, currentSession.url) }
+        verify { snackbar.setText("Added to top sites!") }
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.ADD_TO_TOP_SITES)) }
     }
 
@@ -391,26 +375,29 @@ class DefaultBrowserToolbarControllerTest {
     fun handleToolbarAddonsManagerPress() = runBlockingTest {
         val item = ToolbarMenu.Item.AddonsManager
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.ADDONS_MANAGER)) }
     }
 
     @Test
-    fun handleToolbarAddToHomeScreenPress() {
+    fun handleToolbarAddToHomeScreenPress() = runBlockingTest {
         val item = ToolbarMenu.Item.AddToHomeScreen
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.ADD_TO_HOMESCREEN)) }
     }
 
     @Test
-    fun handleToolbarSharePress() {
+    fun handleToolbarSharePress() = runBlockingTest {
         val item = ToolbarMenu.Item.Share
 
         every { currentSession.url } returns "https://mozilla.org"
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.SHARE)) }
@@ -418,9 +405,10 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarFindInPagePress() {
+    fun handleToolbarFindInPagePress() = runBlockingTest {
         val item = ToolbarMenu.Item.FindInPage
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { findInPageLauncher() }
@@ -428,12 +416,13 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarSaveToCollectionPressWhenAtLeastOneCollectionExists() {
+    fun handleToolbarSaveToCollectionPressWhenAtLeastOneCollectionExists() = runBlockingTest {
         val item = ToolbarMenu.Item.SaveToCollection
         val cachedTabCollections: List<TabCollection> = mockk(relaxed = true)
         every { activity.components.useCases.sessionUseCases } returns sessionUseCases
         every { activity.components.core.tabCollectionStorage.cachedTabCollections } returns cachedTabCollections
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify {
@@ -458,12 +447,13 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarSaveToCollectionPressWhenNoCollectionsExists() {
+    fun handleToolbarSaveToCollectionPressWhenNoCollectionsExists() = runBlockingTest {
         val item = ToolbarMenu.Item.SaveToCollection
         val cachedTabCollectionsEmpty: List<TabCollection> = emptyList()
         every { activity.components.useCases.sessionUseCases } returns sessionUseCases
         every { activity.components.core.tabCollectionStorage.cachedTabCollections } returns cachedTabCollectionsEmpty
 
+        val controller = createController(scope = this)
         controller.handleToolbarItemInteraction(item)
 
         verify { metrics.track(Event.BrowserMenuItemTapped(Event.BrowserMenuItemTapped.Item.SAVE_TO_COLLECTION)) }
@@ -486,26 +476,8 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarOpenInFenixPress() {
+    fun handleToolbarOpenInFenixPress() = runBlockingTest {
-        controller = DefaultBrowserToolbarController(
+        val controller = createController(scope = this, customTabSession = currentSession)
-            activity = activity,
-            navController = navController,
-            findInPageLauncher = findInPageLauncher,
-            engineView = engineView,
-            browserAnimator = browserAnimator,
-            customTabSession = currentSession,
-            openInFenixIntent = openInFenixIntent,
-            scope = scope,
-            swipeRefresh = swipeRefreshLayout,
-            tabCollectionStorage = tabCollectionStorage,
-            topSiteStorage = topSiteStorage,
-            bookmarkTapped = mockk(),
-            readerModeController = mockk(),
-            sessionManager = sessionManager,
-            sharedViewModel = mockk(),
-            onTabCounterClicked = { },
-            onCloseTab = { }
-        )
 
         val item = ToolbarMenu.Item.OpenInFenix
 
@@ -526,25 +498,7 @@ class DefaultBrowserToolbarControllerTest {
         val item = ToolbarMenu.Item.Quit
         val testScope = this
 
-        controller = DefaultBrowserToolbarController(
+        val controller = createController(scope = testScope)
-            activity = activity,
-            navController = navController,
-            findInPageLauncher = findInPageLauncher,
-            engineView = engineView,
-            browserAnimator = browserAnimator,
-            customTabSession = null,
-            openInFenixIntent = openInFenixIntent,
-            scope = testScope,
-            swipeRefresh = swipeRefreshLayout,
-            tabCollectionStorage = tabCollectionStorage,
-            topSiteStorage = topSiteStorage,
-            bookmarkTapped = mockk(),
-            readerModeController = mockk(),
-            sessionManager = sessionManager,
-            sharedViewModel = mockk(),
-            onTabCounterClicked = { },
-            onCloseTab = { }
-        )
 
         controller.handleToolbarItemInteraction(item)
 
@@ -552,7 +506,7 @@ class DefaultBrowserToolbarControllerTest {
     }
 
     @Test
-    fun handleToolbarCloseTabPressWithLastPrivateSession() {
+    fun handleToolbarCloseTabPressWithLastPrivateSession() = runBlockingTest {
         every { currentSession.id } returns "1"
         val browsingModeManager = object : BrowsingModeManager {
             override var mode = BrowsingMode.Private
@@ -568,13 +522,14 @@ class DefaultBrowserToolbarControllerTest {
         every { sessionManager.sessions } returns sessions
         every { activity.browsingModeManager } returns browsingModeManager
 
+        val controller = createController(scope = this)
         controller.handleTabCounterItemInteraction(item)
         verify { navController.navigate(BrowserFragmentDirections.actionGlobalHome(sessionToDelete = "1")) }
         assertEquals(BrowsingMode.Normal, browsingModeManager.mode)
     }
 
     @Test
-    fun handleToolbarCloseTabPress() {
+    fun handleToolbarCloseTabPress() = runBlockingTest {
         val tabsUseCases: TabsUseCases = mockk(relaxed = true)
         val removeTabUseCase: TabsUseCases.RemoveTabUseCase = mockk(relaxed = true)
         val item = TabCounterMenuItem.CloseTab
@@ -583,31 +538,59 @@ class DefaultBrowserToolbarControllerTest {
         every { activity.components.useCases.tabsUseCases } returns tabsUseCases
         every { tabsUseCases.removeTab } returns removeTabUseCase
 
+        val controller = createController(scope = this)
         controller.handleTabCounterItemInteraction(item)
         verify { removeTabUseCase.invoke(currentSession) }
     }
 
     @Test
-    fun handleToolbarNewTabPress() {
+    fun handleToolbarNewTabPress() = runBlockingTest {
         val browsingModeManager: BrowsingModeManager = DefaultBrowsingModeManager(BrowsingMode.Private) {}
         val item = TabCounterMenuItem.NewTab(false)
 
         every { activity.browsingModeManager } returns browsingModeManager
 
+        val controller = createController(scope = this)
         controller.handleTabCounterItemInteraction(item)
         assertEquals(BrowsingMode.Normal, activity.browsingModeManager.mode)
         verify { navController.popBackStack(R.id.homeFragment, false) }
     }
 
     @Test
-    fun handleToolbarNewPrivateTabPress() {
+    fun handleToolbarNewPrivateTabPress() = runBlockingTest {
         val browsingModeManager: BrowsingModeManager = DefaultBrowsingModeManager(BrowsingMode.Normal) {}
         val item = TabCounterMenuItem.NewTab(true)
 
         every { activity.browsingModeManager } returns browsingModeManager
 
+        val controller = createController(scope = this)
         controller.handleTabCounterItemInteraction(item)
         assertEquals(BrowsingMode.Private, activity.browsingModeManager.mode)
         verify { navController.popBackStack(R.id.homeFragment, false) }
     }
+
+    private fun createController(
+        scope: CoroutineScope,
+        activity: HomeActivity = this.activity,
+        customTabSession: Session? = null
+    ) = DefaultBrowserToolbarController(
+        activity = activity,
+        navController = navController,
+        findInPageLauncher = findInPageLauncher,
+        engineView = engineView,
+        browserAnimator = browserAnimator,
+        customTabSession = customTabSession,
+        openInFenixIntent = openInFenixIntent,
+        scope = scope,
+        swipeRefresh = swipeRefreshLayout,
+        tabCollectionStorage = tabCollectionStorage,
+        topSiteStorage = topSiteStorage,
+        bookmarkTapped = bookmarkTapped,
+        readerModeController = readerModeController,
+        sessionManager = sessionManager,
+        onTabCounterClicked = onTabCounterClicked,
+        onCloseTab = onCloseTab
+    ).apply {
+        ioScope = scope
+    }
 }