Archives
/
iceraven-browser
mirror of https://github.com/fork-maintainers/iceraven-browser
2
0
Fork 0
Code Issues Releases Wiki Activity

For #24098: Update tests for tabs tray metrics.

Browse Source
upstream-sync
mcarare 2 years ago committed by mergify[bot]
parent 1f18f62a5a
commit cb14837bc6
11 changed files with 165 additions and 124 deletions
Show Stats Download Patch File Download Diff File

4
app/src/main/java/org/mozilla/fenix/tabstray/browser/InactiveTabsAutoCloseDialogController.kt
Unescape Escape View File

@ -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())
}

68
app/src/test/java/org/mozilla/fenix/components/metrics/GleanMetricsServiceTest.kt
Unescape Escape View File

@ -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())

27
app/src/test/java/org/mozilla/fenix/tabstray/DefaultTabsTrayControllerTest.kt
Unescape Escape View File

@ -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")
}

13
app/src/test/java/org/mozilla/fenix/tabstray/NavigationInteractorTest.kt
Unescape Escape View File

@ -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 {
metrics.track(Event.TabsTrayClosed)
}
assertTrue(TabsTray.closed.testHasValue())
}
@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")
}

10
app/src/test/java/org/mozilla/fenix/tabstray/TabLayoutMediatorTest.kt
Unescape Escape View File

@ -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 }

34
app/src/test/java/org/mozilla/fenix/tabstray/TabLayoutObserverTest.kt
Unescape Escape View File

@ -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.mozilla.fenix.components.metrics.MetricController
import org.junit.runner.RunWith
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())
}
}

11
app/src/test/java/org/mozilla/fenix/tabstray/TabsTrayFragmentTest.kt
Unescape Escape View File

@ -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 {

13
app/src/test/java/org/mozilla/fenix/tabstray/TabsTrayMiddlewareTest.kt
Unescape Escape View File

@ -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)) }
verify { metrics.track(Event.InactiveTabsCountUpdate(0)) }
assertTrue(TabsTray.hasInactiveTabs.testHasValue())
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()

44
app/src/test/java/org/mozilla/fenix/tabstray/browser/InactiveTabsControllerTest.kt
Unescape Escape View File

@ -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 }

32
app/src/test/java/org/mozilla/fenix/tabstray/browser/RemoveTabUseCaseWrapperTest.kt
Unescape Escape View File

@ -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)
}
}

33
app/src/test/java/org/mozilla/fenix/tabstray/browser/SelectTabUseCaseWrapperTest.kt
Unescape Escape View File

@ -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)
}

Write Preview
Loading…
Cancel
Save