For #24098: Update tests for tabs tray metrics.

app/src/main/java/org/mozilla/fenix/tabstray/browser/InactiveTabsAutoCloseDialogController.kt

@@ -9,7 +9,6 @@ import mozilla.components.browser.state.state.TabSessionState
 import mozilla.components.browser.state.store.BrowserStore
 import mozilla.components.browser.tabstray.TabsTray
 import mozilla.telemetry.glean.private.NoExtras
-import org.mozilla.fenix.components.metrics.MetricController
 import org.mozilla.fenix.utils.Settings
 import org.mozilla.fenix.GleanMetrics.TabsTray as TabsTrayMetrics
 
@@ -18,7 +17,6 @@ class InactiveTabsAutoCloseDialogController(
     private val settings: Settings,
     private val tabFilter: (TabSessionState) -> Boolean,
     private val tray: TabsTray,
-    private val metrics: MetricController
 ) {
     /**
      * Dismiss the auto-close dialog.
@@ -26,7 +24,7 @@ class InactiveTabsAutoCloseDialogController(
     fun close() {
         markDialogAsShown()
         refreshInactiveTabsSection()
-        org.mozilla.fenix.GleanMetrics.TabsTray.autoCloseSeen.record(NoExtras())
+        TabsTrayMetrics.autoCloseSeen.record(NoExtras())
 
         TabsTrayMetrics.autoCloseDimissed.record(NoExtras())
     }

app/src/test/java/org/mozilla/fenix/components/metrics/GleanMetricsServiceTest.kt

@@ -22,7 +22,6 @@ import org.mozilla.fenix.GleanMetrics.History
 import org.mozilla.fenix.GleanMetrics.RecentBookmarks
 import org.mozilla.fenix.GleanMetrics.RecentlyVisitedHomepage
 import org.mozilla.fenix.GleanMetrics.SyncedTabs
-import org.mozilla.fenix.GleanMetrics.TabsTray
 import org.mozilla.fenix.GleanMetrics.TopSites
 import org.mozilla.fenix.helpers.FenixRobolectricTestRunner
 
@@ -228,73 +227,6 @@ class GleanMetricsServiceTest {
         assertEquals("123", events[0].extra!!["addon_id"])
     }
 
-    @Test
-    fun `TabsTray events are correctly recorded`() {
-        assertFalse(TabsTray.opened.testHasValue())
-        gleanService.track(Event.TabsTrayOpened)
-        assertTrue(TabsTray.opened.testHasValue())
-
-        assertFalse(TabsTray.closed.testHasValue())
-        gleanService.track(Event.TabsTrayClosed)
-        assertTrue(TabsTray.closed.testHasValue())
-
-        assertFalse(TabsTray.openedExistingTab.testHasValue())
-        gleanService.track(Event.OpenedExistingTab("Test"))
-        assertTrue(TabsTray.openedExistingTab.testHasValue())
-        var events = TabsTray.openedExistingTab.testGetValue()
-        assertEquals(1, events.size)
-        assertEquals("tabs_tray", events[0].category)
-        assertEquals("opened_existing_tab", events[0].name)
-        assertEquals(1, events[0].extra!!.size)
-        assertEquals("Test", events[0].extra!!["source"])
-
-        assertFalse(TabsTray.closedExistingTab.testHasValue())
-        gleanService.track(Event.ClosedExistingTab("Test"))
-        assertTrue(TabsTray.closedExistingTab.testHasValue())
-        events = TabsTray.closedExistingTab.testGetValue()
-        assertEquals(1, events.size)
-        assertEquals("tabs_tray", events[0].category)
-        assertEquals("closed_existing_tab", events[0].name)
-        assertEquals(1, events[0].extra!!.size)
-        assertEquals("Test", events[0].extra!!["source"])
-
-        assertFalse(TabsTray.privateModeTapped.testHasValue())
-        gleanService.track(Event.TabsTrayPrivateModeTapped)
-        assertTrue(TabsTray.privateModeTapped.testHasValue())
-
-        assertFalse(TabsTray.normalModeTapped.testHasValue())
-        gleanService.track(Event.TabsTrayNormalModeTapped)
-        assertTrue(TabsTray.normalModeTapped.testHasValue())
-
-        assertFalse(TabsTray.syncedModeTapped.testHasValue())
-        gleanService.track(Event.TabsTraySyncedModeTapped)
-        assertTrue(TabsTray.syncedModeTapped.testHasValue())
-
-        assertFalse(TabsTray.newTabTapped.testHasValue())
-        gleanService.track(Event.NewTabTapped)
-        assertTrue(TabsTray.newTabTapped.testHasValue())
-
-        assertFalse(TabsTray.newPrivateTabTapped.testHasValue())
-        gleanService.track(Event.NewPrivateTabTapped)
-        assertTrue(TabsTray.newPrivateTabTapped.testHasValue())
-
-        assertFalse(TabsTray.menuOpened.testHasValue())
-        gleanService.track(Event.TabsTrayMenuOpened)
-        assertTrue(TabsTray.menuOpened.testHasValue())
-
-        assertFalse(TabsTray.saveToCollection.testHasValue())
-        gleanService.track(Event.TabsTraySaveToCollectionPressed)
-        assertTrue(TabsTray.saveToCollection.testHasValue())
-
-        assertFalse(TabsTray.shareAllTabs.testHasValue())
-        gleanService.track(Event.TabsTrayShareAllTabsPressed)
-        assertTrue(TabsTray.shareAllTabs.testHasValue())
-
-        assertFalse(TabsTray.closeAllTabs.testHasValue())
-        gleanService.track(Event.TabsTrayCloseAllTabsPressed)
-        assertTrue(TabsTray.closeAllTabs.testHasValue())
-    }
-
     @Test
     fun `default browser events are correctly recorded`() {
         assertFalse(Events.defaultBrowserChanged.testHasValue())

app/src/test/java/org/mozilla/fenix/tabstray/DefaultTabsTrayControllerTest.kt

@@ -36,7 +36,6 @@ import org.junit.runner.RunWith
 import org.mozilla.fenix.GleanMetrics.TabsTray
 import org.mozilla.fenix.R
 import org.mozilla.fenix.browser.browsingmode.BrowsingModeManager
-import org.mozilla.fenix.components.metrics.Event
 import org.mozilla.fenix.components.metrics.MetricController
 import org.mozilla.fenix.home.HomeFragment
 import org.mozilla.fenix.ext.maxActiveTime
@@ -83,8 +82,12 @@ class DefaultTabsTrayControllerTest {
             every { getProfilerTime() } returns Double.MAX_VALUE
         }
 
+        assertFalse(TabsTray.newPrivateTabTapped.testHasValue())
+
         createController().handleOpeningNewTab(true)
 
+        assertTrue(TabsTray.newPrivateTabTapped.testHasValue())
+
         verifyOrder {
             profiler.getProfilerTime()
             navController.navigate(
@@ -121,21 +124,27 @@ class DefaultTabsTrayControllerTest {
 
     @Test
     fun `GIVEN private mode WHEN handleOpeningNewTab is called THEN Event#NewPrivateTabTapped is added to telemetry`() {
+        assertFalse(TabsTray.newPrivateTabTapped.testHasValue())
+
         createController().handleOpeningNewTab(true)
 
-        verify { metrics.track(Event.NewPrivateTabTapped) }
+        assertTrue(TabsTray.newPrivateTabTapped.testHasValue())
     }
 
     @Test
     fun `GIVEN private mode WHEN handleOpeningNewTab is called THEN Event#NewTabTapped is added to telemetry`() {
+        assertFalse(TabsTray.newTabTapped.testHasValue())
+
         createController().handleOpeningNewTab(false)
 
-        verify { metrics.track(Event.NewTabTapped) }
+        assertTrue(TabsTray.newTabTapped.testHasValue())
     }
 
     @Test
     fun `WHEN handleTabDeletion is called THEN Event#ClosedExistingTab is added to telemetry`() {
         val tab: TabSessionState = mockk { every { content.private } returns true }
+        assertFalse(TabsTray.closedExistingTab.testHasValue())
+
         every { browserStore.state } returns mockk()
         try {
             mockkStatic("mozilla.components.browser.state.selector.SelectorsKt")
@@ -143,7 +152,7 @@ class DefaultTabsTrayControllerTest {
             every { browserStore.state.getNormalOrPrivateTabs(any()) } returns listOf(tab)
 
             createController().handleTabDeletion("testTabId", "unknown")
-            verify { metrics.track(Event.ClosedExistingTab("unknown")) }
+            assertTrue(TabsTray.closedExistingTab.testHasValue())
         } finally {
             unmockkStatic("mozilla.components.browser.state.selector.SelectorsKt")
         }
@@ -440,14 +449,16 @@ class DefaultTabsTrayControllerTest {
     fun `GIVEN private mode selected WHEN sendNewTabEvent is called THEN NewPrivateTabTapped is tracked in telemetry`() {
         createController().sendNewTabEvent(true)
 
-        verify { metrics.track(Event.NewPrivateTabTapped) }
+        assertTrue(TabsTray.newPrivateTabTapped.testHasValue())
     }
 
     @Test
     fun `GIVEN normal mode selected WHEN sendNewTabEvent is called THEN NewTabTapped is tracked in telemetry`() {
+        assertFalse(TabsTray.newTabTapped.testHasValue())
+
         createController().sendNewTabEvent(false)
 
-        verify { metrics.track(Event.NewTabTapped) }
+        assertTrue(TabsTray.newTabTapped.testHasValue())
     }
 
     @Test
@@ -511,13 +522,15 @@ class DefaultTabsTrayControllerTest {
             }
         }
         every { browserStore.state } returns mockk()
+        assertFalse(TabsTray.closeAllInactiveTabs.testHasValue())
+
         try {
             mockkStatic("mozilla.components.browser.state.selector.SelectorsKt")
             every { browserStore.state.potentialInactiveTabs } returns listOf(inactiveTab)
 
             createController().handleDeleteAllInactiveTabs()
 
-            verify { metrics.track(Event.TabsTrayCloseAllInactiveTabs) }
+            assertTrue(TabsTray.closeAllInactiveTabs.testHasValue())
         } finally {
             unmockkStatic("mozilla.components.browser.state.selector.SelectorsKt")
         }

app/src/test/java/org/mozilla/fenix/tabstray/NavigationInteractorTest.kt

@@ -28,6 +28,7 @@ import mozilla.components.service.glean.testing.GleanTestRule
 import mozilla.components.support.test.robolectric.testContext
 import mozilla.components.support.test.rule.MainCoroutineRule
 import org.junit.Assert
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
@@ -77,6 +78,9 @@ class NavigationInteractorTest {
     @Test
     fun `onTabTrayDismissed calls dismissTabTray on DefaultNavigationInteractor`() {
         var dismissTabTrayInvoked = false
+
+        assertFalse(TabsTray.closed.testHasValue())
+
         createInteractor(
             dismissTabTray = {
                 dismissTabTrayInvoked = true
@@ -84,9 +88,7 @@ class NavigationInteractorTest {
         ).onTabTrayDismissed()
 
         assertTrue(dismissTabTrayInvoked)
-        verify {
+        assertTrue(TabsTray.closed.testHasValue())
-            metrics.track(Event.TabsTrayClosed)
-        }
     }
 
     @Test
@@ -190,8 +192,11 @@ class NavigationInteractorTest {
         mockkStatic("org.mozilla.fenix.collections.CollectionsDialogKt")
 
         every { any<CollectionsDialog>().show(any()) } answers { }
+        assertFalse(TabsTray.saveToCollection.testHasValue())
+
         createInteractor().onSaveToCollections(listOf(testTab))
-        verify(exactly = 1) { metrics.track(Event.TabsTraySaveToCollectionPressed) }
+
+        assertTrue(TabsTray.saveToCollection.testHasValue())
 
         unmockkStatic("org.mozilla.fenix.collections.CollectionsDialogKt")
     }

app/src/test/java/org/mozilla/fenix/tabstray/TabLayoutMediatorTest.kt

@@ -12,7 +12,6 @@ import io.mockk.verify
 import org.junit.Test
 import org.mozilla.fenix.browser.browsingmode.BrowsingMode
 import org.mozilla.fenix.browser.browsingmode.BrowsingModeManager
-import org.mozilla.fenix.components.metrics.MetricController
 import org.mozilla.fenix.tabstray.TrayPagerAdapter.Companion.POSITION_NORMAL_TABS
 import org.mozilla.fenix.tabstray.TrayPagerAdapter.Companion.POSITION_PRIVATE_TABS
 import org.mozilla.fenix.tabstray.TrayPagerAdapter.Companion.POSITION_SYNCED_TABS
@@ -21,14 +20,13 @@ class TabLayoutMediatorTest {
     private val modeManager: BrowsingModeManager = mockk(relaxed = true)
     private val tabsTrayStore: TabsTrayStore = mockk(relaxed = true)
     private val interactor: TabsTrayInteractor = mockk(relaxed = true)
-    private val metrics: MetricController = mockk(relaxed = true)
     private val tabLayout: TabLayout = mockk(relaxed = true)
     private val tab: TabLayout.Tab = mockk(relaxed = true)
     private val viewPager: ViewPager2 = mockk(relaxed = true)
 
     @Test
     fun `page to normal tab position when mode is also normal`() {
-        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore, metrics)
+        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore)
 
         every { modeManager.mode }.answers { BrowsingMode.Normal }
         every { tabLayout.getTabAt(POSITION_NORMAL_TABS) }.answers { tab }
@@ -42,7 +40,7 @@ class TabLayoutMediatorTest {
 
     @Test
     fun `page to private tab position when mode is also private`() {
-        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore, metrics)
+        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore)
 
         every { modeManager.mode }.answers { BrowsingMode.Private }
         every { tabLayout.getTabAt(POSITION_PRIVATE_TABS) }.answers { tab }
@@ -55,7 +53,7 @@ class TabLayoutMediatorTest {
 
     @Test
     fun `selectTabAtPosition will dispatch the correct TabsTrayStore action`() {
-        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore, metrics)
+        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore)
 
         every { tabLayout.getTabAt(POSITION_NORMAL_TABS) }.answers { tab }
         every { tabLayout.getTabAt(POSITION_PRIVATE_TABS) }.answers { tab }
@@ -76,7 +74,7 @@ class TabLayoutMediatorTest {
 
     @Test
     fun `lifecycle methods adds and removes observer`() {
-        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore, metrics)
+        val mediator = TabLayoutMediator(tabLayout, viewPager, interactor, modeManager, tabsTrayStore)
 
         every { modeManager.mode }.answers { BrowsingMode.Private }
 

app/src/test/java/org/mozilla/fenix/tabstray/TabLayoutObserverTest.kt

@@ -8,71 +8,83 @@ import com.google.android.material.tabs.TabLayout
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
+import mozilla.components.service.glean.testing.GleanTestRule
 import mozilla.components.support.test.libstate.ext.waitUntilIdle
 import mozilla.components.support.test.middleware.CaptureActionsMiddleware
+import mozilla.components.support.test.robolectric.testContext
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
-import org.mozilla.fenix.components.metrics.Event
+import org.junit.runner.RunWith
-import org.mozilla.fenix.components.metrics.MetricController
+import org.mozilla.fenix.GleanMetrics.TabsTray
+import org.mozilla.fenix.helpers.FenixRobolectricTestRunner
 
+@RunWith(FenixRobolectricTestRunner::class) // for gleanTestRule
 class TabLayoutObserverTest {
     private val interactor = mockk<TabsTrayInteractor>(relaxed = true)
     private lateinit var store: TabsTrayStore
-    private lateinit var metrics: MetricController
     private val middleware = CaptureActionsMiddleware<TabsTrayState, TabsTrayAction>()
 
+    @get:Rule
+    val gleanTestRule = GleanTestRule(testContext)
+
     @Before
     fun setup() {
         store = TabsTrayStore(middlewares = listOf(middleware))
-        metrics = mockk(relaxed = true)
     }
 
     @Test
     fun `WHEN tab is selected THEN notify the interactor`() {
-        val observer = TabLayoutObserver(interactor, metrics)
+        val observer = TabLayoutObserver(interactor)
         val tab = mockk<TabLayout.Tab>()
         every { tab.position } returns 1
+        assertFalse(TabsTray.privateModeTapped.testHasValue())
 
         observer.onTabSelected(tab)
 
         store.waitUntilIdle()
 
         verify { interactor.onTrayPositionSelected(1, false) }
-        verify { metrics.track(Event.TabsTrayPrivateModeTapped) }
+        assertTrue(TabsTray.privateModeTapped.testHasValue())
 
         every { tab.position } returns 0
+        assertFalse(TabsTray.normalModeTapped.testHasValue())
 
         observer.onTabSelected(tab)
 
         store.waitUntilIdle()
 
         verify { interactor.onTrayPositionSelected(0, true) }
-        verify { metrics.track(Event.TabsTrayNormalModeTapped) }
+        assertTrue(TabsTray.normalModeTapped.testHasValue())
 
         every { tab.position } returns 2
+        assertFalse(TabsTray.syncedModeTapped.testHasValue())
 
         observer.onTabSelected(tab)
 
         store.waitUntilIdle()
 
         verify { interactor.onTrayPositionSelected(2, true) }
-        verify { metrics.track(Event.TabsTraySyncedModeTapped) }
+        assertTrue(TabsTray.syncedModeTapped.testHasValue())
     }
 
     @Test
     fun `WHEN observer is first started THEN do not smooth scroll`() {
-        val observer = TabLayoutObserver(interactor, metrics)
+        val observer = TabLayoutObserver(interactor)
         val tab = mockk<TabLayout.Tab>()
         every { tab.position } returns 1
+        assertFalse(TabsTray.privateModeTapped.testHasValue())
 
         observer.onTabSelected(tab)
 
         verify { interactor.onTrayPositionSelected(1, false) }
-        verify { metrics.track(Event.TabsTrayPrivateModeTapped) }
+        assertTrue(TabsTray.privateModeTapped.testHasValue())
 
         observer.onTabSelected(tab)
 
         verify { interactor.onTrayPositionSelected(1, true) }
-        verify { metrics.track(Event.TabsTrayPrivateModeTapped) }
+        assertTrue(TabsTray.privateModeTapped.testHasValue())
     }
 }

app/src/test/java/org/mozilla/fenix/tabstray/TabsTrayFragmentTest.kt

@@ -31,17 +31,19 @@ import io.mockk.verify
 import kotlinx.coroutines.CoroutineScope
 import mozilla.components.browser.menu.BrowserMenu
 import mozilla.components.browser.state.store.BrowserStore
+import mozilla.components.service.glean.testing.GleanTestRule
 import mozilla.components.support.test.robolectric.testContext
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertSame
+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.TabsTray
 import org.mozilla.fenix.NavGraphDirections
 import org.mozilla.fenix.R
-import org.mozilla.fenix.components.metrics.Event
 import org.mozilla.fenix.components.metrics.MetricController
 import org.mozilla.fenix.databinding.ComponentTabstray2Binding
 import org.mozilla.fenix.databinding.ComponentTabstrayFabBinding
@@ -67,6 +69,9 @@ class TabsTrayFragmentTest {
     @get:Rule
     val mockkRule = MockkRetryTestRule()
 
+    @get:Rule
+    val gleanTestRule = GleanTestRule(testContext)
+
     @Before
     fun setup() {
         context = mockk(relaxed = true)
@@ -246,10 +251,12 @@ class TabsTrayFragmentTest {
             }
             every { fragment.getTrayMenu(any(), any(), any(), any(), any()) } returns menuBuilder
 
+            assertFalse(TabsTray.menuOpened.testHasValue())
+
             fragment.setupMenu(navigationInteractor)
             tabsTrayBinding.tabTrayOverflow.performClick()
 
-            verify { metrics.track(Event.TabsTrayMenuOpened) }
+            assertTrue(TabsTray.menuOpened.testHasValue())
             verify { menuBuilder.build() }
             verify { menu.showWithTheme(tabsTrayBinding.tabTrayOverflow) }
         } finally {

app/src/test/java/org/mozilla/fenix/tabstray/TabsTrayMiddlewareTest.kt

@@ -13,11 +13,13 @@ import mozilla.components.service.glean.testing.GleanTestRule
 import mozilla.components.support.test.libstate.ext.waitUntilIdle
 import mozilla.components.support.test.robolectric.testContext
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 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.Metrics
 import org.mozilla.fenix.GleanMetrics.TabsTray
 import org.mozilla.fenix.components.metrics.Event
 import org.mozilla.fenix.components.metrics.MetricController
@@ -68,10 +70,15 @@ class TabsTrayMiddlewareTest {
 
     @Test
     fun `WHEN inactive tabs are updated THEN report the count of inactive tabs`() {
+
+        assertFalse(TabsTray.hasInactiveTabs.testHasValue())
+        assertFalse(Metrics.inactiveTabsCount.testHasValue())
+
         store.dispatch(TabsTrayAction.UpdateInactiveTabs(emptyList()))
         store.waitUntilIdle()
-        verify { metrics.track(Event.TabsTrayHasInactiveTabs(0)) }
+        assertTrue(TabsTray.hasInactiveTabs.testHasValue())
-        verify { metrics.track(Event.InactiveTabsCountUpdate(0)) }
+        assertTrue(Metrics.inactiveTabsCount.testHasValue())
+        assertEquals(0, Metrics.inactiveTabsCount.testGetValue())
     }
 
     @Test
@@ -93,6 +100,8 @@ class TabsTrayMiddlewareTest {
 
     @Test
     fun `WHEN multi select mode from menu is entered THEN relevant metrics are collected`() {
+        assertFalse(TabsTray.enterMultiselectMode.testHasValue())
+
         store.dispatch(TabsTrayAction.EnterSelectMode)
         store.waitUntilIdle()
 

app/src/test/java/org/mozilla/fenix/tabstray/browser/InactiveTabsControllerTest.kt

@@ -14,23 +14,34 @@ import io.mockk.verify
 import mozilla.components.browser.state.state.TabSessionState
 import mozilla.components.browser.state.store.BrowserStore
 import mozilla.components.browser.tabstray.TabsTray
+import mozilla.components.service.glean.testing.GleanTestRule
+import org.mozilla.fenix.GleanMetrics.TabsTray as TabsTrayMetrics
 import mozilla.components.support.test.libstate.ext.waitUntilIdle
+import mozilla.components.support.test.robolectric.testContext
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
 import mozilla.components.browser.state.state.createTab as createTabState
 import org.junit.Test
+import org.junit.runner.RunWith
 import org.mozilla.fenix.components.AppStore
-import org.mozilla.fenix.components.metrics.Event
 import org.mozilla.fenix.components.metrics.MetricController
+import org.mozilla.fenix.helpers.FenixRobolectricTestRunner
 import org.mozilla.fenix.tabstray.TabsTrayState
 import org.mozilla.fenix.tabstray.TabsTrayStore
 import org.mozilla.fenix.utils.Settings
 
+@RunWith(FenixRobolectricTestRunner::class) // for gleanTestRule
 class InactiveTabsControllerTest {
 
     private val metrics: MetricController = mockk(relaxed = true)
     private val settings: Settings = mockk(relaxed = true)
     private val appStore = AppStore()
 
+    @get:Rule
+    val gleanTestRule = GleanTestRule(testContext)
+
     @Test
     fun `WHEN expanded THEN notify filtered card`() {
         val store = TabsTrayStore(
@@ -44,7 +55,7 @@ class InactiveTabsControllerTest {
         val tray: TabsTray = mockk(relaxed = true)
         val tabsSlot = slot<List<TabSessionState>>()
         val controller =
-            InactiveTabsController(store, appStore, tray, mockk(relaxed = true), settings)
+            InactiveTabsController(store, appStore, tray, settings)
 
         controller.updateCardExpansion(true)
 
@@ -60,24 +71,32 @@ class InactiveTabsControllerTest {
     fun `WHEN expanded THEN track telemetry event`() {
         val store = TabsTrayStore()
         val controller = InactiveTabsController(
-            store, appStore, mockk(relaxed = true), metrics, settings
+            store, appStore, mockk(relaxed = true), settings
         )
 
+        assertFalse(TabsTrayMetrics.inactiveTabsExpanded.testHasValue())
+        assertFalse(TabsTrayMetrics.inactiveTabsCollapsed.testHasValue())
+
         controller.updateCardExpansion(true)
 
-        verify { metrics.track(Event.TabsTrayInactiveTabsExpanded) }
+        assertTrue(TabsTrayMetrics.inactiveTabsExpanded.testHasValue())
+        assertFalse(TabsTrayMetrics.inactiveTabsCollapsed.testHasValue())
     }
 
     @Test
     fun `WHEN collapsed THEN track telemetry event`() {
         val store = TabsTrayStore()
         val controller = InactiveTabsController(
-            store, appStore, mockk(relaxed = true), metrics, settings
+            store, appStore, mockk(relaxed = true), settings
         )
 
+        assertFalse(TabsTrayMetrics.inactiveTabsExpanded.testHasValue())
+        assertFalse(TabsTrayMetrics.inactiveTabsCollapsed.testHasValue())
+
         controller.updateCardExpansion(false)
 
-        verify { metrics.track(Event.TabsTrayInactiveTabsCollapsed) }
+        assertFalse(TabsTrayMetrics.inactiveTabsExpanded.testHasValue())
+        assertTrue(TabsTrayMetrics.inactiveTabsCollapsed.testHasValue())
     }
 
     @Test
@@ -85,15 +104,17 @@ class InactiveTabsControllerTest {
         val store = TabsTrayStore()
         val controller = spyk(
             InactiveTabsController(
-                store, appStore, mockk(relaxed = true), metrics, settings
+                store, appStore, mockk(relaxed = true), settings
             )
         )
 
         every { controller.refreshInactiveTabsSection() } just Runs
 
+        assertFalse(TabsTrayMetrics.autoCloseDimissed.testHasValue())
+
         controller.close()
 
-        verify { metrics.track(Event.TabsTrayAutoCloseDialogDismissed) }
+        assertTrue(TabsTrayMetrics.autoCloseDimissed.testHasValue())
         verify { settings.hasInactiveTabsAutoCloseDialogBeenDismissed = true }
         verify { controller.refreshInactiveTabsSection() }
     }
@@ -104,13 +125,16 @@ class InactiveTabsControllerTest {
         val store = BrowserStore()
         val tray: TabsTray = mockk(relaxed = true)
         val controller =
-            spyk(InactiveTabsAutoCloseDialogController(store, settings, filter, tray, metrics))
+            spyk(InactiveTabsAutoCloseDialogController(store, settings, filter, tray))
 
         every { controller.refreshInactiveTabsSection() } just Runs
 
+        assertFalse(TabsTrayMetrics.autoCloseTurnOnClicked.testHasValue())
+
         controller.enableAutoClosed()
 
-        verify { metrics.track(Event.TabsTrayAutoCloseDialogTurnOnClicked) }
+        assertTrue(TabsTrayMetrics.autoCloseTurnOnClicked.testHasValue())
+
         verify { settings.closeTabsAfterOneMonth = true }
         verify { settings.closeTabsAfterOneWeek = false }
         verify { settings.closeTabsAfterOneDay = false }

app/src/test/java/org/mozilla/fenix/tabstray/browser/RemoveTabUseCaseWrapperTest.kt

@@ -5,27 +5,42 @@
 package org.mozilla.fenix.tabstray.browser
 
 import io.mockk.mockk
-import io.mockk.verify
+import mozilla.components.service.glean.testing.GleanTestRule
+import mozilla.components.support.test.robolectric.testContext
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
 import org.junit.Test
-import org.mozilla.fenix.components.metrics.Event
+import org.junit.runner.RunWith
+import org.mozilla.fenix.GleanMetrics.TabsTray
 import org.mozilla.fenix.components.metrics.MetricController
+import org.mozilla.fenix.helpers.FenixRobolectricTestRunner
 
+@RunWith(FenixRobolectricTestRunner::class) // for gleanTestRule
 class RemoveTabUseCaseWrapperTest {
 
     val metricController = mockk<MetricController>(relaxed = true)
 
+    @get:Rule
+    val gleanTestRule = GleanTestRule(testContext)
+
     @Test
     fun `WHEN invoked with no source name THEN metrics with unknown source, use case and callback are triggered`() {
         var actualTabId: String? = null
         val onRemove: (String) -> Unit = { tabId ->
             actualTabId = tabId
         }
-        val wrapper = RemoveTabUseCaseWrapper(metricController, onRemove)
+        val wrapper = RemoveTabUseCaseWrapper(onRemove)
+
+        assertFalse(TabsTray.closedExistingTab.testHasValue())
 
         wrapper("123")
 
-        verify { metricController.track(Event.ClosedExistingTab("unknown")) }
+        assertTrue(TabsTray.closedExistingTab.testHasValue())
+        val snapshot = TabsTray.closedExistingTab.testGetValue()
+        assertEquals(1, snapshot.size)
+        assertEquals("unknown", snapshot.single().extra?.getValue("source"))
         assertEquals("123", actualTabId)
     }
 
@@ -35,11 +50,16 @@ class RemoveTabUseCaseWrapperTest {
         val onRemove: (String) -> Unit = { tabId ->
             actualTabId = tabId
         }
-        val wrapper = RemoveTabUseCaseWrapper(metricController, onRemove)
+        val wrapper = RemoveTabUseCaseWrapper(onRemove)
+
+        assertFalse(TabsTray.closedExistingTab.testHasValue())
 
         wrapper("123", "Test")
 
-        verify { metricController.track(Event.ClosedExistingTab("Test")) }
+        assertTrue(TabsTray.closedExistingTab.testHasValue())
+        val snapshot = TabsTray.closedExistingTab.testGetValue()
+        assertEquals(1, snapshot.size)
+        assertEquals("Test", snapshot.single().extra?.getValue("source"))
         assertEquals("123", actualTabId)
     }
 }

app/src/test/java/org/mozilla/fenix/tabstray/browser/SelectTabUseCaseWrapperTest.kt

@@ -7,25 +7,42 @@ package org.mozilla.fenix.tabstray.browser
 import io.mockk.mockk
 import io.mockk.verify
 import mozilla.components.feature.tabs.TabsUseCases
+import mozilla.components.service.glean.testing.GleanTestRule
+import mozilla.components.support.test.robolectric.testContext
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
 import org.junit.Test
-import org.mozilla.fenix.components.metrics.Event
+import org.junit.runner.RunWith
+import org.mozilla.fenix.GleanMetrics.TabsTray
 import org.mozilla.fenix.components.metrics.MetricController
+import org.mozilla.fenix.helpers.FenixRobolectricTestRunner
 
+@RunWith(FenixRobolectricTestRunner::class) // for gleanTestRule
 class SelectTabUseCaseWrapperTest {
 
     val metricController = mockk<MetricController>(relaxed = true)
     val selectUseCase: TabsUseCases.SelectTabUseCase = mockk(relaxed = true)
 
+    @get:Rule
+    val gleanTestRule = GleanTestRule(testContext)
+
     @Test
     fun `WHEN invoked with no source name THEN metrics with unknown source, use case and callback are triggered`() {
         var invoked = ""
         val onSelect: (String) -> Unit = { invoked = it }
-        val wrapper = SelectTabUseCaseWrapper(metricController, selectUseCase, onSelect)
+        val wrapper = SelectTabUseCaseWrapper(selectUseCase, onSelect)
+
+        assertFalse(TabsTray.openedExistingTab.testHasValue())
 
         wrapper("123")
 
-        verify { metricController.track(Event.OpenedExistingTab("unknown")) }
+        assertTrue(TabsTray.openedExistingTab.testHasValue())
+        val snapshot = TabsTray.openedExistingTab.testGetValue()
+        assertEquals(1, snapshot.size)
+        assertEquals("unknown", snapshot.single().extra?.getValue("source"))
+
         verify { selectUseCase("123") }
         assertEquals("123", invoked)
     }
@@ -34,11 +51,17 @@ class SelectTabUseCaseWrapperTest {
     fun `WHEN invoked with a source name THEN metrics, use case and callback are triggered`() {
         var invoked = ""
         val onSelect: (String) -> Unit = { invoked = it }
-        val wrapper = SelectTabUseCaseWrapper(metricController, selectUseCase, onSelect)
+        val wrapper = SelectTabUseCaseWrapper(selectUseCase, onSelect)
+
+        assertFalse(TabsTray.openedExistingTab.testHasValue())
 
         wrapper("123", "Test")
 
-        verify { metricController.track(Event.OpenedExistingTab("Test")) }
+        assertTrue(TabsTray.openedExistingTab.testHasValue())
+        val snapshot = TabsTray.openedExistingTab.testGetValue()
+        assertEquals(1, snapshot.size)
+        assertEquals("Test", snapshot.single().extra?.getValue("source"))
+
         verify { selectUseCase("123") }
         assertEquals("123", invoked)
     }