From ec74b43e2b7c29ab37e9f20706891bfdf7121cdf Mon Sep 17 00:00:00 2001 From: Alexandru2909 Date: Wed, 30 Mar 2022 13:19:26 +0300 Subject: [PATCH] [fenix] For https://github.com/mozilla-mobile/fenix/issues/24512 - Remove Event.wrapper for RecentlyClosedTabs metrics --- .../mozilla/fenix/components/metrics/Event.kt | 12 ---- .../components/metrics/GleanMetricsService.kt | 37 ---------- .../RecentlyClosedController.kt | 29 ++++---- .../recentlyclosed/RecentlyClosedFragment.kt | 13 ++-- .../DefaultRecentlyClosedControllerTest.kt | 69 ++++++++++++++----- 5 files changed, 71 insertions(+), 89 deletions(-) diff --git a/app/src/main/java/org/mozilla/fenix/components/metrics/Event.kt b/app/src/main/java/org/mozilla/fenix/components/metrics/Event.kt index 4b6f03ba65..57a3396bb0 100644 --- a/app/src/main/java/org/mozilla/fenix/components/metrics/Event.kt +++ b/app/src/main/java/org/mozilla/fenix/components/metrics/Event.kt @@ -57,18 +57,6 @@ sealed class Event { object HistorySearchTermGroupRemoveAll : Event() object HistorySearchIconTapped : Event() object HistorySearchResultTapped : Event() - object RecentlyClosedTabsOpened : Event() - object RecentlyClosedTabsClosed : Event() - object RecentlyClosedTabsShowFullHistory : Event() - object RecentlyClosedTabsOpenTab : Event() - object RecentlyClosedTabsDeleteTab : Event() - object RecentlyClosedTabsMenuClose : Event() - object RecentlyClosedTabsMenuShare : Event() - object RecentlyClosedTabsMenuDelete : Event() - object RecentlyClosedTabsMenuOpenInNormalTab : Event() - object RecentlyClosedTabsMenuOpenInPrivateTab : Event() - object RecentlyClosedTabsEnterMultiselect : Event() - object RecentlyClosedTabsExitMultiselect : Event() object ReaderModeAvailable : Event() object ReaderModeOpened : Event() object ReaderModeClosed : Event() diff --git a/app/src/main/java/org/mozilla/fenix/components/metrics/GleanMetricsService.kt b/app/src/main/java/org/mozilla/fenix/components/metrics/GleanMetricsService.kt index 72713db049..a5a3cff00d 100644 --- a/app/src/main/java/org/mozilla/fenix/components/metrics/GleanMetricsService.kt +++ b/app/src/main/java/org/mozilla/fenix/components/metrics/GleanMetricsService.kt @@ -34,7 +34,6 @@ import org.mozilla.fenix.GleanMetrics.ReaderMode import org.mozilla.fenix.GleanMetrics.RecentBookmarks import org.mozilla.fenix.GleanMetrics.RecentSearches import org.mozilla.fenix.GleanMetrics.RecentTabs -import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs import org.mozilla.fenix.GleanMetrics.RecentlyVisitedHomepage import org.mozilla.fenix.GleanMetrics.SearchTerms import org.mozilla.fenix.GleanMetrics.StartOnHome @@ -222,42 +221,6 @@ private val Event.wrapper: EventWrapper<*>? is Event.HistorySearchResultTapped -> EventWrapper( { History.searchResultTapped.record(it) } ) - is Event.RecentlyClosedTabsOpened -> EventWrapper( - { RecentlyClosedTabs.opened.record(it) } - ) - is Event.RecentlyClosedTabsClosed -> EventWrapper( - { RecentlyClosedTabs.closed.record(it) } - ) - is Event.RecentlyClosedTabsShowFullHistory -> EventWrapper( - { RecentlyClosedTabs.showFullHistory.record(it) } - ) - is Event.RecentlyClosedTabsOpenTab -> EventWrapper( - { RecentlyClosedTabs.openTab.record(it) } - ) - is Event.RecentlyClosedTabsDeleteTab -> EventWrapper( - { RecentlyClosedTabs.deleteTab.record(it) } - ) - is Event.RecentlyClosedTabsMenuClose -> EventWrapper( - { RecentlyClosedTabs.menuClose.record(it) } - ) - is Event.RecentlyClosedTabsMenuShare -> EventWrapper( - { RecentlyClosedTabs.menuShare.record(it) } - ) - is Event.RecentlyClosedTabsMenuDelete -> EventWrapper( - { RecentlyClosedTabs.menuDelete.record(it) } - ) - is Event.RecentlyClosedTabsMenuOpenInNormalTab -> EventWrapper( - { RecentlyClosedTabs.menuOpenInNormalTab.record(it) } - ) - is Event.RecentlyClosedTabsMenuOpenInPrivateTab -> EventWrapper( - { RecentlyClosedTabs.menuOpenInPrivateTab.record(it) } - ) - is Event.RecentlyClosedTabsEnterMultiselect -> EventWrapper( - { RecentlyClosedTabs.enterMultiselect.record(it) } - ) - is Event.RecentlyClosedTabsExitMultiselect -> EventWrapper( - { RecentlyClosedTabs.exitMultiselect.record(it) } - ) is Event.ReaderModeAvailable -> EventWrapper( { ReaderMode.available.record(it) } ) diff --git a/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedController.kt b/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedController.kt index ea5b33a081..81c62c9ab9 100644 --- a/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedController.kt +++ b/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedController.kt @@ -14,12 +14,12 @@ import mozilla.components.browser.state.store.BrowserStore import mozilla.components.concept.engine.prompt.ShareData import mozilla.components.feature.recentlyclosed.RecentlyClosedTabsStorage import mozilla.components.feature.tabs.TabsUseCases +import mozilla.components.service.glean.private.NoExtras import org.mozilla.fenix.BrowserDirection +import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs import org.mozilla.fenix.HomeActivity import org.mozilla.fenix.R import org.mozilla.fenix.browser.browsingmode.BrowsingMode -import org.mozilla.fenix.components.metrics.Event -import org.mozilla.fenix.components.metrics.MetricController @Suppress("TooManyFunctions") interface RecentlyClosedController { @@ -35,7 +35,7 @@ interface RecentlyClosedController { fun handleBackPressed(): Boolean } -@Suppress("TooManyFunctions") +@Suppress("TooManyFunctions", "LongParameterList") class DefaultRecentlyClosedController( private val navController: NavController, private val browserStore: BrowserStore, @@ -43,7 +43,6 @@ class DefaultRecentlyClosedController( private val recentlyClosedTabsStorage: RecentlyClosedTabsStorage, private val tabsUseCases: TabsUseCases, private val activity: HomeActivity, - private val metrics: MetricController, private val lifecycleScope: CoroutineScope, private val openToBrowser: (url: String, mode: BrowsingMode?) -> Unit ) : RecentlyClosedController { @@ -53,9 +52,9 @@ class DefaultRecentlyClosedController( override fun handleOpen(tabs: Set, mode: BrowsingMode?) { if (mode == BrowsingMode.Normal) { - metrics.track(Event.RecentlyClosedTabsMenuOpenInNormalTab) + RecentlyClosedTabs.menuOpenInNormalTab.record(NoExtras()) } else if (mode == BrowsingMode.Private) { - metrics.track(Event.RecentlyClosedTabsMenuOpenInPrivateTab) + RecentlyClosedTabs.menuOpenInPrivateTab.record(NoExtras()) } recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) tabs.forEach { tab -> handleOpen(tab, mode) } @@ -63,25 +62,25 @@ class DefaultRecentlyClosedController( override fun handleSelect(tab: TabState) { if (recentlyClosedStore.state.selectedTabs.isEmpty()) { - metrics.track(Event.RecentlyClosedTabsEnterMultiselect) + RecentlyClosedTabs.enterMultiselect.record(NoExtras()) } recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Select(tab)) } override fun handleDeselect(tab: TabState) { if (recentlyClosedStore.state.selectedTabs.size == 1) { - metrics.track(Event.RecentlyClosedTabsExitMultiselect) + RecentlyClosedTabs.exitMultiselect.record(NoExtras()) } recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Deselect(tab)) } override fun handleDelete(tab: TabState) { - metrics.track(Event.RecentlyClosedTabsDeleteTab) + RecentlyClosedTabs.deleteTab.record(NoExtras()) browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tab)) } override fun handleDelete(tabs: Set) { - metrics.track(Event.RecentlyClosedTabsMenuDelete) + RecentlyClosedTabs.menuDelete.record(NoExtras()) recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) tabs.forEach { tab -> browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tab)) @@ -89,7 +88,7 @@ class DefaultRecentlyClosedController( } override fun handleNavigateToHistory() { - metrics.track(Event.RecentlyClosedTabsShowFullHistory) + RecentlyClosedTabs.showFullHistory.record(NoExtras()) navController.navigate( RecentlyClosedFragmentDirections.actionGlobalHistoryFragment(), NavOptions.Builder().setPopUpTo(R.id.historyFragment, true).build() @@ -97,7 +96,7 @@ class DefaultRecentlyClosedController( } override fun handleShare(tabs: Set) { - metrics.track(Event.RecentlyClosedTabsMenuShare) + RecentlyClosedTabs.menuShare.record(NoExtras()) val shareData = tabs.map { ShareData(url = it.url, title = it.title) } navController.navigate( RecentlyClosedFragmentDirections.actionGlobalShareFragment( @@ -108,7 +107,7 @@ class DefaultRecentlyClosedController( override fun handleRestore(item: TabState) { lifecycleScope.launch { - metrics.track(Event.RecentlyClosedTabsOpenTab) + RecentlyClosedTabs.openTab.record(NoExtras()) tabsUseCases.restore(item, recentlyClosedTabsStorage.engineStateStorage()) browserStore.dispatch( @@ -123,11 +122,11 @@ class DefaultRecentlyClosedController( override fun handleBackPressed(): Boolean { return if (recentlyClosedStore.state.selectedTabs.isNotEmpty()) { - metrics.track(Event.RecentlyClosedTabsExitMultiselect) + RecentlyClosedTabs.exitMultiselect.record(NoExtras()) recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) true } else { - metrics.track(Event.RecentlyClosedTabsClosed) + RecentlyClosedTabs.closed.record(NoExtras()) false } } diff --git a/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedFragment.kt b/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedFragment.kt index f264fdde55..7ec813dbcc 100644 --- a/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedFragment.kt +++ b/app/src/main/java/org/mozilla/fenix/library/recentlyclosed/RecentlyClosedFragment.kt @@ -21,13 +21,13 @@ import mozilla.components.lib.state.ext.consumeFrom import mozilla.components.lib.state.ext.flowScoped import mozilla.components.support.base.feature.UserInteractionHandler import mozilla.components.support.ktx.kotlinx.coroutines.flow.ifChanged +import mozilla.telemetry.glean.private.NoExtras import org.mozilla.fenix.BrowserDirection +import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs import org.mozilla.fenix.HomeActivity import org.mozilla.fenix.R import org.mozilla.fenix.browser.browsingmode.BrowsingMode import org.mozilla.fenix.components.StoreProvider -import org.mozilla.fenix.components.metrics.Event -import org.mozilla.fenix.components.metrics.MetricController import org.mozilla.fenix.databinding.FragmentRecentlyClosedTabsBinding import org.mozilla.fenix.ext.requireComponents import org.mozilla.fenix.ext.setTextColor @@ -44,8 +44,6 @@ class RecentlyClosedFragment : LibraryPageFragment(), UserIntera private lateinit var recentlyClosedInteractor: RecentlyClosedFragmentInteractor private lateinit var recentlyClosedController: RecentlyClosedController - private lateinit var metrics: MetricController - override fun onResume() { super.onResume() showToolbar(getString(R.string.library_recently_closed_tabs)) @@ -69,7 +67,7 @@ class RecentlyClosedFragment : LibraryPageFragment(), UserIntera return when (item.itemId) { R.id.close_history -> { close() - metrics.track(Event.RecentlyClosedTabsMenuClose) + RecentlyClosedTabs.menuClose.record(NoExtras()) true } R.id.share_history_multi_select -> { @@ -95,9 +93,7 @@ class RecentlyClosedFragment : LibraryPageFragment(), UserIntera override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setHasOptionsMenu(true) - metrics = requireComponents.analytics.metrics.also { - it.track(Event.RecentlyClosedTabsOpened) - } + RecentlyClosedTabs.opened.record(NoExtras()) } override fun onCreateView( @@ -120,7 +116,6 @@ class RecentlyClosedFragment : LibraryPageFragment(), UserIntera recentlyClosedStore = recentlyClosedFragmentStore, activity = activity as HomeActivity, tabsUseCases = requireComponents.useCases.tabsUseCases, - metrics = metrics, recentlyClosedTabsStorage = requireComponents.core.recentlyClosedTabsStorage.value, lifecycleScope = lifecycleScope, openToBrowser = ::openItem diff --git a/app/src/test/java/org/mozilla/fenix/library/recentlyclosed/DefaultRecentlyClosedControllerTest.kt b/app/src/test/java/org/mozilla/fenix/library/recentlyclosed/DefaultRecentlyClosedControllerTest.kt index 6b202d2fba..eb84dc945d 100644 --- a/app/src/test/java/org/mozilla/fenix/library/recentlyclosed/DefaultRecentlyClosedControllerTest.kt +++ b/app/src/test/java/org/mozilla/fenix/library/recentlyclosed/DefaultRecentlyClosedControllerTest.kt @@ -8,7 +8,6 @@ import androidx.navigation.NavController import androidx.navigation.NavOptions import io.mockk.mockk import io.mockk.coEvery -import io.mockk.verifyAll import io.mockk.clearMocks import io.mockk.every import io.mockk.verify @@ -25,14 +24,19 @@ import mozilla.components.concept.engine.prompt.ShareData import mozilla.components.feature.recentlyclosed.RecentlyClosedTabsStorage import mozilla.components.feature.tabs.TabsUseCases import mozilla.components.support.test.robolectric.testContext +import mozilla.telemetry.glean.testing.GleanTestRule import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue import org.junit.Before +import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith +import org.mozilla.fenix.GleanMetrics.RecentlyClosedTabs import org.mozilla.fenix.HomeActivity import org.mozilla.fenix.R import org.mozilla.fenix.browser.browsingmode.BrowsingMode -import org.mozilla.fenix.components.metrics.Event import org.mozilla.fenix.components.metrics.MetricController import org.mozilla.fenix.ext.directionsEq import org.mozilla.fenix.ext.optionsEq @@ -47,6 +51,9 @@ class DefaultRecentlyClosedControllerTest { private val tabsUseCases: TabsUseCases = mockk(relaxed = true) private val metrics: MetricController = mockk(relaxed = true) + @get:Rule + val gleanTestRule = GleanTestRule(testContext) + @Before fun setUp() { coEvery { tabsUseCases.restore.invoke(any(), any(), true) } just Runs @@ -93,6 +100,7 @@ class DefaultRecentlyClosedControllerTest { actualBrowsingModes.add(mode) } ) + assertFalse(RecentlyClosedTabs.menuOpenInNormalTab.testHasValue()) controller.handleOpen(tabs.toSet(), BrowsingMode.Normal) @@ -101,7 +109,8 @@ class DefaultRecentlyClosedControllerTest { assertEquals(tabs[1].url, tabUrls[1]) assertEquals(BrowsingMode.Normal, actualBrowsingModes[0]) assertEquals(BrowsingMode.Normal, actualBrowsingModes[1]) - verifyAll { metrics.track(Event.RecentlyClosedTabsMenuOpenInNormalTab) } + assertTrue(RecentlyClosedTabs.menuOpenInNormalTab.testHasValue()) + assertNull(RecentlyClosedTabs.menuOpenInNormalTab.testGetValue().last().extra) clearMocks(metrics) tabUrls.clear() @@ -114,18 +123,23 @@ class DefaultRecentlyClosedControllerTest { assertEquals(tabs[1].url, tabUrls[1]) assertEquals(BrowsingMode.Private, actualBrowsingModes[0]) assertEquals(BrowsingMode.Private, actualBrowsingModes[1]) - verifyAll { metrics.track(Event.RecentlyClosedTabsMenuOpenInPrivateTab) } + assertTrue(RecentlyClosedTabs.menuOpenInPrivateTab.testHasValue()) + assertEquals(1, RecentlyClosedTabs.menuOpenInPrivateTab.testGetValue().size) + assertNull(RecentlyClosedTabs.menuOpenInPrivateTab.testGetValue().single().extra) } @Test fun `handle selecting first tab`() { val selectedTab = createFakeTab() every { recentlyClosedStore.state.selectedTabs } returns emptySet() + assertFalse(RecentlyClosedTabs.enterMultiselect.testHasValue()) createController().handleSelect(selectedTab) verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Select(selectedTab)) } - verify { metrics.track(Event.RecentlyClosedTabsEnterMultiselect) } + assertTrue(RecentlyClosedTabs.enterMultiselect.testHasValue()) + assertEquals(1, RecentlyClosedTabs.enterMultiselect.testGetValue().size) + assertNull(RecentlyClosedTabs.enterMultiselect.testGetValue().single().extra) } @Test @@ -136,18 +150,21 @@ class DefaultRecentlyClosedControllerTest { createController().handleSelect(selectedTab) verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Select(selectedTab)) } - verify(exactly = 0) { metrics.track(Event.RecentlyClosedTabsEnterMultiselect) } + assertFalse(RecentlyClosedTabs.enterMultiselect.testHasValue()) } @Test fun `handle deselect last tab`() { val deselectedTab = createFakeTab() every { recentlyClosedStore.state.selectedTabs } returns setOf(deselectedTab) + assertFalse(RecentlyClosedTabs.exitMultiselect.testHasValue()) createController().handleDeselect(deselectedTab) verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Deselect(deselectedTab)) } - verify { metrics.track(Event.RecentlyClosedTabsExitMultiselect) } + assertTrue(RecentlyClosedTabs.exitMultiselect.testHasValue()) + assertEquals(1, RecentlyClosedTabs.exitMultiselect.testGetValue().size) + assertNull(RecentlyClosedTabs.exitMultiselect.testGetValue().single().extra) } @Test @@ -158,24 +175,28 @@ class DefaultRecentlyClosedControllerTest { createController().handleDeselect(deselectedTab) verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.Deselect(deselectedTab)) } - verify(exactly = 0) { metrics.track(Event.RecentlyClosedTabsExitMultiselect) } + assertFalse(RecentlyClosedTabs.exitMultiselect.testHasValue()) } @Test fun handleDelete() { val item: TabState = mockk(relaxed = true) + assertFalse(RecentlyClosedTabs.deleteTab.testHasValue()) createController().handleDelete(item) verify { browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(item)) } - verify { metrics.track(Event.RecentlyClosedTabsDeleteTab) } + assertTrue(RecentlyClosedTabs.deleteTab.testHasValue()) + assertEquals(1, RecentlyClosedTabs.deleteTab.testGetValue().size) + assertNull(RecentlyClosedTabs.deleteTab.testGetValue().single().extra) } @Test fun `delete multiple tabs`() { val tabs = createFakeTabList(2) + assertFalse(RecentlyClosedTabs.menuDelete.testHasValue()) createController().handleDelete(tabs.toSet()) @@ -183,11 +204,14 @@ class DefaultRecentlyClosedControllerTest { browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tabs[0])) browserStore.dispatch(RecentlyClosedAction.RemoveClosedTabAction(tabs[1])) } - verify { metrics.track(Event.RecentlyClosedTabsMenuDelete) } + assertTrue(RecentlyClosedTabs.menuDelete.testHasValue()) + assertNull(RecentlyClosedTabs.menuDelete.testGetValue().last().extra) } @Test fun handleNavigateToHistory() { + assertFalse(RecentlyClosedTabs.showFullHistory.testHasValue()) + createController().handleNavigateToHistory() verify { @@ -198,12 +222,15 @@ class DefaultRecentlyClosedControllerTest { optionsEq(NavOptions.Builder().setPopUpTo(R.id.historyFragment, true).build()) ) } - verify { metrics.track(Event.RecentlyClosedTabsShowFullHistory) } + assertTrue(RecentlyClosedTabs.showFullHistory.testHasValue()) + assertEquals(1, RecentlyClosedTabs.showFullHistory.testGetValue().size) + assertNull(RecentlyClosedTabs.showFullHistory.testGetValue().single().extra) } @Test fun `share multiple tabs`() { val tabs = createFakeTabList(2) + assertFalse(RecentlyClosedTabs.menuShare.testHasValue()) createController().handleShare(tabs.toSet()) @@ -216,37 +243,48 @@ class DefaultRecentlyClosedControllerTest { directionsEq(RecentlyClosedFragmentDirections.actionGlobalShareFragment(data)) ) } - verify { metrics.track(Event.RecentlyClosedTabsMenuShare) } + assertTrue(RecentlyClosedTabs.menuShare.testHasValue()) + assertEquals(1, RecentlyClosedTabs.menuShare.testGetValue().size) + assertNull(RecentlyClosedTabs.menuShare.testGetValue().single().extra) } @Test fun handleRestore() = runBlocking { val item: TabState = mockk(relaxed = true) + assertFalse(RecentlyClosedTabs.openTab.testHasValue()) createController(scope = this).handleRestore(item) coVerify { tabsUseCases.restore.invoke(eq(item), any(), true) } - verify { metrics.track(Event.RecentlyClosedTabsOpenTab) } + assertTrue(RecentlyClosedTabs.openTab.testHasValue()) + assertEquals(1, RecentlyClosedTabs.openTab.testGetValue().size) + assertNull(RecentlyClosedTabs.openTab.testGetValue().single().extra) } @Test fun `exist multi-select mode when back is pressed`() { every { recentlyClosedStore.state.selectedTabs } returns createFakeTabList(3).toSet() + assertFalse(RecentlyClosedTabs.exitMultiselect.testHasValue()) createController().handleBackPressed() verify { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) } - verifyAll { metrics.track(Event.RecentlyClosedTabsExitMultiselect) } + assertTrue(RecentlyClosedTabs.exitMultiselect.testHasValue()) + assertEquals(1, RecentlyClosedTabs.exitMultiselect.testGetValue().size) + assertNull(RecentlyClosedTabs.exitMultiselect.testGetValue().single().extra) } @Test fun `report closing the fragment when back is pressed`() { every { recentlyClosedStore.state.selectedTabs } returns emptySet() + assertFalse(RecentlyClosedTabs.closed.testHasValue()) createController().handleBackPressed() verify(exactly = 0) { recentlyClosedStore.dispatch(RecentlyClosedFragmentAction.DeselectAll) } - verifyAll { metrics.track(Event.RecentlyClosedTabsClosed) } + assertTrue(RecentlyClosedTabs.closed.testHasValue()) + assertEquals(1, RecentlyClosedTabs.closed.testGetValue().size) + assertNull(RecentlyClosedTabs.closed.testGetValue().single().extra) } private fun createController( @@ -260,7 +298,6 @@ class DefaultRecentlyClosedControllerTest { RecentlyClosedTabsStorage(testContext, mockk(), mockk()), tabsUseCases, activity, - metrics, scope, openToBrowser )