For #24498 - Remove Event.wrapper for History metrics

pull/543/head
Alexandru2909 2 years ago committed by mergify[bot]
parent dbfd5ffca0
commit e571f0bb3a

@ -3061,6 +3061,7 @@ history:
User has tapped on an item in the "Recently visited" section on home.
extra_keys:
page_number:
type: string
description: |
The page number in the homescreen carousel that the recently visited
item was on.

@ -11,7 +11,6 @@ import org.mozilla.fenix.GleanMetrics.AppTheme
import org.mozilla.fenix.GleanMetrics.Autoplay
import org.mozilla.fenix.GleanMetrics.ContextMenu
import org.mozilla.fenix.GleanMetrics.Events
import org.mozilla.fenix.GleanMetrics.History
import org.mozilla.fenix.GleanMetrics.Logins
import org.mozilla.fenix.GleanMetrics.Pocket
import org.mozilla.fenix.GleanMetrics.SearchTerms
@ -30,26 +29,8 @@ sealed class Event {
object CustomTabsClosed : Event()
object CustomTabsActionTapped : Event()
object CustomTabsMenuOpened : Event()
object HistoryOpened : Event()
object HistoryItemShared : Event()
object HistoryItemOpened : Event()
object HistoryOpenedInNewTab : Event()
object HistoryOpenedInNewTabs : Event()
object HistoryOpenedInPrivateTab : Event()
object HistoryOpenedInPrivateTabs : Event()
object HistoryItemRemoved : Event()
object HistoryAllItemsRemoved : Event()
data class HistoryRecentSearchesTapped(val source: String) : Event() {
override val extras = mapOf(History.recentSearchesTappedKeys.pageNumber to source)
}
object HistoryHighlightOpened : Event()
object HistorySearchGroupOpened : Event()
object HistorySearchTermGroupTapped : Event()
object HistorySearchTermGroupOpenTab : Event()
object HistorySearchTermGroupRemoveTab : Event()
object HistorySearchTermGroupRemoveAll : Event()
object HistorySearchIconTapped : Event()
object HistorySearchResultTapped : Event()
object ReaderModeAvailable : Event()
object ReaderModeOpened : Event()
object ReaderModeClosed : Event()

@ -20,7 +20,6 @@ import org.mozilla.fenix.GleanMetrics.CreditCards
import org.mozilla.fenix.GleanMetrics.CustomTab
import org.mozilla.fenix.GleanMetrics.Events
import org.mozilla.fenix.GleanMetrics.ExperimentsDefaultBrowser
import org.mozilla.fenix.GleanMetrics.History
import org.mozilla.fenix.GleanMetrics.HomeMenu
import org.mozilla.fenix.GleanMetrics.HomeScreen
import org.mozilla.fenix.GleanMetrics.Logins
@ -129,55 +128,6 @@ private val Event.wrapper: EventWrapper<*>?
is Event.CustomTabsClosed -> EventWrapper<NoExtraKeys>(
{ CustomTab.closed.record(it) }
)
is Event.HistoryOpened -> EventWrapper<NoExtraKeys>(
{ History.opened.record(it) }
)
is Event.HistoryItemShared -> EventWrapper<NoExtraKeys>(
{ History.shared.record(it) }
)
is Event.HistoryItemOpened -> EventWrapper<NoExtraKeys>(
{ History.openedItem.record(it) }
)
is Event.HistoryOpenedInNewTab -> EventWrapper<NoExtraKeys>(
{ History.openedItemInNewTab.record(it) }
)
is Event.HistoryOpenedInNewTabs -> EventWrapper<NoExtraKeys>(
{ History.openedItemsInNewTabs.record(it) }
)
is Event.HistoryOpenedInPrivateTab -> EventWrapper<NoExtraKeys>(
{ History.openedItemInPrivateTab.record(it) }
)
is Event.HistoryOpenedInPrivateTabs -> EventWrapper<NoExtraKeys>(
{ History.openedItemsInPrivateTabs.record(it) }
)
is Event.HistoryItemRemoved -> EventWrapper<NoExtraKeys>(
{ History.removed.record(it) }
)
is Event.HistoryAllItemsRemoved -> EventWrapper<NoExtraKeys>(
{ History.removedAll.record(it) }
)
is Event.HistoryRecentSearchesTapped -> EventWrapper(
{ History.recentSearchesTapped.record(it) },
{ History.recentSearchesTappedKeys.valueOf(it) }
)
is Event.HistorySearchTermGroupTapped -> EventWrapper<NoExtraKeys>(
{ History.searchTermGroupTapped.record(it) }
)
is Event.HistorySearchTermGroupOpenTab -> EventWrapper<NoExtraKeys>(
{ History.searchTermGroupOpenTab.record(it) }
)
is Event.HistorySearchTermGroupRemoveTab -> EventWrapper<NoExtraKeys>(
{ History.searchTermGroupRemoveTab.record(it) }
)
is Event.HistorySearchTermGroupRemoveAll -> EventWrapper<NoExtraKeys>(
{ History.searchTermGroupRemoveAll.record(it) }
)
is Event.HistorySearchIconTapped -> EventWrapper<NoExtraKeys>(
{ History.searchIconTapped.record(it) }
)
is Event.HistorySearchResultTapped -> EventWrapper<NoExtraKeys>(
{ History.searchResultTapped.record(it) }
)
is Event.ReaderModeAvailable -> EventWrapper<NoExtraKeys>(
{ ReaderMode.available.record(it) }
)

@ -10,6 +10,7 @@ import androidx.compose.ui.platform.ComposeView
import androidx.compose.ui.res.stringResource
import androidx.lifecycle.LifecycleOwner
import mozilla.components.lib.state.ext.observeAsComposableState
import org.mozilla.fenix.GleanMetrics.History
import org.mozilla.fenix.R
import org.mozilla.fenix.components.components
import org.mozilla.fenix.components.metrics.Event
@ -68,7 +69,11 @@ class RecentlyVisitedViewHolder(
}
is RecentHistoryGroup -> {
metrics.track(Event.HistorySearchGroupOpened)
metrics.track(Event.HistoryRecentSearchesTapped(pageNumber.toString()))
History.recentSearchesTapped.record(
History.RecentSearchesTappedExtra(
pageNumber.toString()
)
)
interactor.onRecentHistoryGroupClicked(recentlyVisitedItem)
}
}

@ -8,12 +8,12 @@ import androidx.navigation.NavController
import androidx.navigation.NavOptions
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import mozilla.components.service.glean.private.NoExtras
import mozilla.telemetry.glean.private.NoExtras
import org.mozilla.fenix.GleanMetrics.Events
import org.mozilla.fenix.R
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.components.metrics.MetricController
import org.mozilla.fenix.ext.navigateSafe
import org.mozilla.fenix.GleanMetrics.History as GleanHistory
@Suppress("TooManyFunctions")
interface HistoryController {
@ -46,7 +46,7 @@ class DefaultHistoryController(
when (item) {
is History.Regular -> openToBrowser(item)
is History.Group -> {
metrics.track(Event.HistorySearchTermGroupTapped)
GleanHistory.searchTermGroupTapped.record(NoExtras())
navController.navigate(
HistoryFragmentDirections.actionGlobalHistoryMetadataGroup(
title = item.title,

@ -35,6 +35,7 @@ import mozilla.components.concept.engine.prompt.ShareData
import mozilla.components.lib.state.ext.consumeFrom
import mozilla.components.service.fxa.sync.SyncReason
import mozilla.components.support.base.feature.UserInteractionHandler
import mozilla.telemetry.glean.private.NoExtras
import org.mozilla.fenix.BrowserDirection
import org.mozilla.fenix.FeatureFlags
import org.mozilla.fenix.HomeActivity
@ -44,7 +45,6 @@ import org.mozilla.fenix.addons.showSnackBar
import org.mozilla.fenix.browser.browsingmode.BrowsingMode
import org.mozilla.fenix.components.StoreProvider
import org.mozilla.fenix.components.history.DefaultPagedHistoryProvider
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.databinding.FragmentHistoryBinding
import org.mozilla.fenix.ext.components
import org.mozilla.fenix.ext.nav
@ -53,6 +53,7 @@ import org.mozilla.fenix.ext.setTextColor
import org.mozilla.fenix.ext.toShortUrl
import org.mozilla.fenix.library.LibraryPageFragment
import org.mozilla.fenix.utils.allowUndo
import org.mozilla.fenix.GleanMetrics.History as GleanHistory
@SuppressWarnings("TooManyFunctions", "LargeClass")
class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
@ -140,7 +141,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
historyProvider = DefaultPagedHistoryProvider(requireComponents.core.historyStorage)
requireComponents.analytics.metrics.track(Event.HistoryOpened)
GleanHistory.opened.record(NoExtras())
setHasOptionsMenu(true)
}
@ -235,7 +236,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
}
R.id.open_history_in_new_tabs_multi_select -> {
openItemsInNewTab { selectedItem ->
requireComponents.analytics.metrics.track(Event.HistoryOpenedInNewTabs)
GleanHistory.openedItemsInNewTabs.record(NoExtras())
(selectedItem as? History.Regular)?.url ?: (selectedItem as? History.Metadata)?.url
}
@ -244,7 +245,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
}
R.id.open_history_in_private_tabs_multi_select -> {
openItemsInNewTab(private = true) { selectedItem ->
requireComponents.analytics.metrics.track(Event.HistoryOpenedInPrivateTabs)
GleanHistory.openedItemsInNewTabs.record(NoExtras())
(selectedItem as? History.Regular)?.url ?: (selectedItem as? History.Metadata)?.url
}
@ -257,7 +258,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
true
}
R.id.history_search -> {
requireComponents.analytics.metrics.track(Event.HistorySearchIconTapped)
GleanHistory.searchIconTapped.record(NoExtras())
historyInteractor.onSearch()
true
}
@ -310,7 +311,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
}
private fun openItem(item: History.Regular) {
requireComponents.analytics.metrics.track(Event.HistoryItemOpened)
GleanHistory.openedItem.record(NoExtras())
(activity as HomeActivity).openToBrowserAndLoad(
searchTermOrURL = item.url,
@ -330,7 +331,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
historyStore.dispatch(HistoryFragmentAction.EnterDeletionMode)
// Use fragment's lifecycle; the view may be gone by the time dialog is interacted with.
lifecycleScope.launch(IO) {
requireComponents.analytics.metrics.track(Event.HistoryAllItemsRemoved)
GleanHistory.removedAll.record(NoExtras())
requireComponents.core.store.dispatch(RecentlyClosedAction.RemoveAllClosedTabAction)
requireComponents.core.historyStorage.deleteEverything()
deleteOpenTabsEngineHistory(requireComponents.core.store)
@ -356,7 +357,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
}
private fun share(data: List<ShareData>) {
requireComponents.analytics.metrics.track(Event.HistoryItemShared)
GleanHistory.shared.record(NoExtras())
val directions = HistoryFragmentDirections.actionGlobalShareFragment(
data = data.toTypedArray()
)
@ -377,7 +378,7 @@ class HistoryFragment : LibraryPageFragment<History>(), UserInteractionHandler {
historyStore.dispatch(HistoryFragmentAction.EnterDeletionMode)
context?.components?.run {
for (item in items) {
analytics.metrics.track(Event.HistoryItemRemoved)
GleanHistory.removed.record(NoExtras())
when (item) {
is History.Regular -> core.historyStorage.deleteVisitsFor(item.url)

@ -5,10 +5,10 @@
package org.mozilla.fenix.library.history
import mozilla.components.concept.engine.EngineSession.LoadUrlFlags
import mozilla.components.service.glean.private.NoExtras
import org.mozilla.fenix.BrowserDirection
import org.mozilla.fenix.GleanMetrics.History
import org.mozilla.fenix.HomeActivity
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.components.metrics.MetricController
/**
* An interface that handles the view manipulation of the History Search, triggered by the Interactor
@ -21,7 +21,6 @@ interface HistorySearchController {
class HistorySearchDialogController(
private val activity: HomeActivity,
private val metrics: MetricController,
private val fragmentStore: HistorySearchFragmentStore,
private val clearToolbarFocus: () -> Unit,
) : HistorySearchController {
@ -35,7 +34,7 @@ class HistorySearchDialogController(
}
override fun handleUrlTapped(url: String, flags: LoadUrlFlags) {
metrics.track(Event.HistorySearchResultTapped)
History.searchResultTapped.record(NoExtras())
clearToolbarFocus()
activity.openToBrowserAndLoad(

@ -44,7 +44,6 @@ import org.mozilla.fenix.R
import org.mozilla.fenix.components.toolbar.ToolbarPosition
import org.mozilla.fenix.databinding.FragmentHistorySearchDialogBinding
import org.mozilla.fenix.databinding.SearchSuggestionsHintBinding
import org.mozilla.fenix.ext.components
import org.mozilla.fenix.ext.settings
import org.mozilla.fenix.library.history.awesomebar.AwesomeBarView
import org.mozilla.fenix.library.history.toolbar.ToolbarView
@ -92,7 +91,6 @@ class HistorySearchDialogFragment : AppCompatDialogFragment(), UserInteractionHa
interactor = HistorySearchDialogInteractor(
HistorySearchDialogController(
activity = activity,
metrics = activity.components.analytics.metrics,
fragmentStore = store,
clearToolbarFocus = {
dialogHandledAction = true

@ -77,7 +77,6 @@ class HistoryMetadataGroupFragment :
browserStore = (activity as HomeActivity).components.core.store,
store = historyMetadataGroupStore,
selectOrAddUseCase = requireComponents.useCases.tabsUseCases.selectOrAddTab,
metrics = requireComponents.analytics.metrics,
navController = findNavController(),
scope = lifecycleScope,
searchTerm = args.title

@ -12,13 +12,13 @@ import mozilla.components.browser.state.store.BrowserStore
import mozilla.components.browser.storage.sync.PlacesHistoryStorage
import mozilla.components.concept.engine.prompt.ShareData
import mozilla.components.feature.tabs.TabsUseCases
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.components.metrics.MetricController
import mozilla.components.service.glean.private.NoExtras
import org.mozilla.fenix.R
import org.mozilla.fenix.library.history.History
import org.mozilla.fenix.library.historymetadata.HistoryMetadataGroupFragmentAction
import org.mozilla.fenix.library.historymetadata.HistoryMetadataGroupFragmentDirections
import org.mozilla.fenix.library.historymetadata.HistoryMetadataGroupFragmentStore
import org.mozilla.fenix.GleanMetrics.History as GleanHistory
/**
* An interface that handles the view manipulation of the history metadata group in the History
@ -75,12 +75,12 @@ interface HistoryMetadataGroupController {
/**
* The default implementation of [HistoryMetadataGroupController].
*/
@Suppress("LongParameterList")
class DefaultHistoryMetadataGroupController(
private val historyStorage: PlacesHistoryStorage,
private val browserStore: BrowserStore,
private val store: HistoryMetadataGroupFragmentStore,
private val selectOrAddUseCase: TabsUseCases.SelectOrAddUseCase,
private val metrics: MetricController,
private val navController: NavController,
private val scope: CoroutineScope,
private val searchTerm: String,
@ -89,7 +89,7 @@ class DefaultHistoryMetadataGroupController(
override fun handleOpen(item: History.Metadata) {
selectOrAddUseCase.invoke(item.url, item.historyMetadataKey)
navController.navigate(R.id.browserFragment)
metrics.track(Event.HistorySearchTermGroupOpenTab)
GleanHistory.searchTermGroupOpenTab.record(NoExtras())
}
override fun handleSelect(item: History.Metadata) {
@ -123,7 +123,7 @@ class DefaultHistoryMetadataGroupController(
items.forEach {
store.dispatch(HistoryMetadataGroupFragmentAction.Delete(it))
historyStorage.deleteVisitsFor(it.url)
metrics.track(Event.HistorySearchTermGroupRemoveTab)
GleanHistory.searchTermGroupRemoveTab.record(NoExtras())
}
// The method is called for both single and multiple items.
// In case all items have been deleted, we have to disband the search group.
@ -144,7 +144,7 @@ class DefaultHistoryMetadataGroupController(
browserStore.dispatch(
HistoryMetadataAction.DisbandSearchGroupAction(searchTerm = searchTerm)
)
metrics.track(Event.HistorySearchTermGroupRemoveAll)
GleanHistory.searchTermGroupRemoveAll.record(NoExtras())
}
}
}

@ -16,7 +16,6 @@ import org.junit.runner.RunWith
import org.mozilla.fenix.GleanMetrics.Addons
import org.mozilla.fenix.GleanMetrics.Awesomebar
import org.mozilla.fenix.GleanMetrics.CreditCards
import org.mozilla.fenix.GleanMetrics.History
import org.mozilla.fenix.GleanMetrics.RecentBookmarks
import org.mozilla.fenix.GleanMetrics.RecentlyVisitedHomepage
import org.mozilla.fenix.GleanMetrics.SyncedTabs
@ -69,56 +68,6 @@ class GleanMetricsServiceTest {
assertTrue(Awesomebar.openedTabSuggestionClicked.testHasValue())
}
@Test
fun `History events are correctly recorded`() {
assertFalse(History.openedItemInNewTab.testHasValue())
gleanService.track(Event.HistoryOpenedInNewTab)
assertTrue(History.openedItemInNewTab.testHasValue())
assertFalse(History.openedItemsInNewTabs.testHasValue())
gleanService.track(Event.HistoryOpenedInNewTabs)
assertTrue(History.openedItemsInNewTabs.testHasValue())
assertFalse(History.openedItemInPrivateTab.testHasValue())
gleanService.track(Event.HistoryOpenedInPrivateTab)
assertTrue(History.openedItemInPrivateTab.testHasValue())
assertFalse(History.openedItemsInPrivateTabs.testHasValue())
gleanService.track(Event.HistoryOpenedInPrivateTabs)
assertTrue(History.openedItemsInPrivateTabs.testHasValue())
assertFalse(History.recentSearchesTapped.testHasValue())
gleanService.track(Event.HistoryRecentSearchesTapped("5"))
assertTrue(History.recentSearchesTapped.testHasValue())
val events = History.recentSearchesTapped.testGetValue()
assertEquals(1, events[0].extra!!.size)
assertEquals("5", events[0].extra!!["page_number"])
assertFalse(History.searchTermGroupTapped.testHasValue())
gleanService.track(Event.HistorySearchTermGroupTapped)
assertTrue(History.searchTermGroupTapped.testHasValue())
assertFalse(History.searchTermGroupOpenTab.testHasValue())
gleanService.track(Event.HistorySearchTermGroupOpenTab)
assertTrue(History.searchTermGroupOpenTab.testHasValue())
assertFalse(History.searchTermGroupRemoveTab.testHasValue())
gleanService.track(Event.HistorySearchTermGroupRemoveTab)
assertTrue(History.searchTermGroupRemoveTab.testHasValue())
assertFalse(History.searchTermGroupRemoveAll.testHasValue())
gleanService.track(Event.HistorySearchTermGroupRemoveAll)
assertTrue(History.searchTermGroupRemoveAll.testHasValue())
assertFalse(History.searchIconTapped.testHasValue())
gleanService.track(Event.HistorySearchIconTapped)
assertTrue(History.searchIconTapped.testHasValue())
assertFalse(History.searchResultTapped.testHasValue())
gleanService.track(Event.HistorySearchResultTapped)
assertTrue(History.searchResultTapped.testHasValue())
}
@Test
fun `Addon events are correctly recorded`() {
assertFalse(Addons.openAddonsInSettings.testHasValue())

@ -270,59 +270,6 @@ class MetricControllerTest {
verify { marketingService1.track(Event.OpenedTabSuggestionClicked) }
}
@Test
fun `history events should be sent to enabled service`() {
val controller = ReleaseMetricController(
listOf(marketingService1),
isDataTelemetryEnabled = { true },
isMarketingDataTelemetryEnabled = { true },
mockk()
)
every { marketingService1.shouldTrack(Event.HistoryOpenedInNewTab) } returns true
every { marketingService1.shouldTrack(Event.HistoryOpenedInNewTabs) } returns true
every { marketingService1.shouldTrack(Event.HistoryOpenedInPrivateTab) } returns true
every { marketingService1.shouldTrack(Event.HistoryOpenedInPrivateTabs) } returns true
every { marketingService1.shouldTrack(Event.HistoryItemRemoved) } returns true
every { marketingService1.shouldTrack(Event.HistoryAllItemsRemoved) } returns true
every { marketingService1.shouldTrack(Event.HistoryRecentSearchesTapped("2")) } returns true
every { marketingService1.shouldTrack(Event.HistorySearchTermGroupTapped) } returns true
every { marketingService1.shouldTrack(Event.HistorySearchTermGroupOpenTab) } returns true
every { marketingService1.shouldTrack(Event.HistorySearchTermGroupRemoveTab) } returns true
every { marketingService1.shouldTrack(Event.HistorySearchTermGroupRemoveAll) } returns true
every { marketingService1.shouldTrack(Event.HistorySearchIconTapped) } returns true
every { marketingService1.shouldTrack(Event.HistorySearchResultTapped) } returns true
controller.start(MetricServiceType.Marketing)
controller.track(Event.HistoryOpenedInNewTab)
controller.track(Event.HistoryOpenedInNewTabs)
controller.track(Event.HistoryOpenedInPrivateTab)
controller.track(Event.HistoryOpenedInPrivateTabs)
controller.track(Event.HistoryItemRemoved)
controller.track(Event.HistoryAllItemsRemoved)
controller.track(Event.HistoryRecentSearchesTapped("2"))
controller.track(Event.HistorySearchTermGroupTapped)
controller.track(Event.HistorySearchTermGroupOpenTab)
controller.track(Event.HistorySearchTermGroupRemoveTab)
controller.track(Event.HistorySearchTermGroupRemoveAll)
controller.track(Event.HistorySearchIconTapped)
controller.track(Event.HistorySearchResultTapped)
verify { marketingService1.track(Event.HistoryOpenedInNewTab) }
verify { marketingService1.track(Event.HistoryOpenedInNewTabs) }
verify { marketingService1.track(Event.HistoryOpenedInPrivateTab) }
verify { marketingService1.track(Event.HistoryOpenedInPrivateTabs) }
verify { marketingService1.track(Event.HistoryItemRemoved) }
verify { marketingService1.track(Event.HistoryAllItemsRemoved) }
verify { marketingService1.track(Event.HistoryRecentSearchesTapped("2")) }
verify { marketingService1.track(Event.HistorySearchTermGroupTapped) }
verify { marketingService1.track(Event.HistorySearchTermGroupOpenTab) }
verify { marketingService1.track(Event.HistorySearchTermGroupRemoveTab) }
verify { marketingService1.track(Event.HistorySearchTermGroupRemoveAll) }
verify { marketingService1.track(Event.HistorySearchIconTapped) }
verify { marketingService1.track(Event.HistorySearchResultTapped) }
}
@Test
fun `web extension fact should set value in SharedPreference`() {
val enabled = true

@ -9,16 +9,27 @@ import io.mockk.impl.annotations.MockK
import io.mockk.verify
import kotlinx.coroutines.test.runBlockingTest
import mozilla.components.concept.engine.EngineSession
import mozilla.components.support.test.robolectric.testContext
import mozilla.telemetry.glean.testing.GleanTestRule
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.BrowserDirection
import org.mozilla.fenix.GleanMetrics.History
import org.mozilla.fenix.HomeActivity
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.components.metrics.MetricController
import org.mozilla.fenix.helpers.FenixRobolectricTestRunner
@RunWith(FenixRobolectricTestRunner::class)
class HistorySearchControllerTest {
@get:Rule
val gleanTestRule = GleanTestRule(testContext)
@MockK(relaxed = true) private lateinit var activity: HomeActivity
@MockK(relaxed = true) private lateinit var store: HistorySearchFragmentStore
@MockK(relaxed = true) private lateinit var metrics: MetricController
@ -62,12 +73,14 @@ class HistorySearchControllerTest {
fun `WHEN url is tapped THEN openToBrowserAndLoad is called`() {
val url = "https://www.google.com/"
val flags = EngineSession.LoadUrlFlags.none()
assertFalse(History.searchResultTapped.testHasValue())
createController().handleUrlTapped(url, flags)
createController().handleUrlTapped(url)
assertTrue(History.searchResultTapped.testHasValue())
assertNull(History.searchResultTapped.testGetValue().last().extra)
verify {
metrics.track(Event.HistorySearchResultTapped)
activity.openToBrowserAndLoad(
searchTermOrURL = url,
newTab = true,
@ -82,7 +95,6 @@ class HistorySearchControllerTest {
): HistorySearchDialogController {
return HistorySearchDialogController(
activity = activity,
metrics = metrics,
fragmentStore = store,
clearToolbarFocus = clearToolbarFocus,
)

@ -17,17 +17,19 @@ import mozilla.components.browser.storage.sync.PlacesHistoryStorage
import mozilla.components.concept.engine.prompt.ShareData
import mozilla.components.concept.storage.HistoryMetadataKey
import mozilla.components.feature.tabs.TabsUseCases
import mozilla.components.service.glean.testing.GleanTestRule
import mozilla.components.support.test.robolectric.testContext
import mozilla.components.support.test.rule.MainCoroutineRule
import org.junit.After
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.HomeActivity
import org.mozilla.fenix.components.metrics.Event
import org.mozilla.fenix.components.metrics.MetricController
import org.mozilla.fenix.R
import org.mozilla.fenix.ext.components
import org.mozilla.fenix.ext.directionsEq
@ -37,10 +39,13 @@ import org.mozilla.fenix.library.history.HistoryItemTimeGroup
import org.mozilla.fenix.library.historymetadata.HistoryMetadataGroupFragmentAction
import org.mozilla.fenix.library.historymetadata.HistoryMetadataGroupFragmentDirections
import org.mozilla.fenix.library.historymetadata.HistoryMetadataGroupFragmentStore
import org.mozilla.fenix.GleanMetrics.History as GleanHistory
@RunWith(FenixRobolectricTestRunner::class)
class HistoryMetadataGroupControllerTest {
@get:Rule
val gleanTestRule = GleanTestRule(testContext)
@get:Rule
val coroutinesTestRule = MainCoroutineRule()
private val testDispatcher = coroutinesTestRule.testDispatcher
@ -50,7 +55,6 @@ class HistoryMetadataGroupControllerTest {
private val store: HistoryMetadataGroupFragmentStore = mockk(relaxed = true)
private val browserStore: BrowserStore = mockk(relaxed = true)
private val selectOrAddUseCase: TabsUseCases.SelectOrAddUseCase = mockk(relaxed = true)
private val metrics: MetricController = mockk(relaxed = true)
private val navController: NavController = mockk(relaxed = true)
private val historyStorage: PlacesHistoryStorage = mockk(relaxed = true)
@ -87,7 +91,6 @@ class HistoryMetadataGroupControllerTest {
browserStore = browserStore,
store = store,
selectOrAddUseCase = selectOrAddUseCase,
metrics = metrics,
navController = navController,
scope = scope,
searchTerm = "mozilla"
@ -104,6 +107,8 @@ class HistoryMetadataGroupControllerTest {
@Test
fun handleOpen() {
assertFalse(GleanHistory.searchTermGroupOpenTab.testHasValue())
controller.handleOpen(mozillaHistoryMetadataItem)
verify {
@ -112,8 +117,16 @@ class HistoryMetadataGroupControllerTest {
mozillaHistoryMetadataItem.historyMetadataKey
)
navController.navigate(R.id.browserFragment)
metrics.track(Event.HistorySearchTermGroupOpenTab)
}
assertTrue(GleanHistory.searchTermGroupOpenTab.testHasValue())
assertEquals(
1,
GleanHistory.searchTermGroupOpenTab.testGetValue().size
)
assertNull(
GleanHistory.searchTermGroupOpenTab.testGetValue()
.single().extra
)
}
@Test
@ -169,13 +182,23 @@ class HistoryMetadataGroupControllerTest {
@Test
fun handleDeleteSingle() = testDispatcher.runBlockingTest {
assertFalse(GleanHistory.searchTermGroupRemoveTab.testHasValue())
controller.handleDelete(setOf(mozillaHistoryMetadataItem))
coVerify {
store.dispatch(HistoryMetadataGroupFragmentAction.Delete(mozillaHistoryMetadataItem))
historyStorage.deleteVisitsFor(mozillaHistoryMetadataItem.url)
metrics.track(Event.HistorySearchTermGroupRemoveTab)
}
assertTrue(GleanHistory.searchTermGroupRemoveTab.testHasValue())
assertEquals(
1,
GleanHistory.searchTermGroupRemoveTab.testGetValue().size
)
assertNull(
GleanHistory.searchTermGroupRemoveTab.testGetValue()
.single().extra
)
// Here we don't expect the action to be dispatched, because items inside the store
// we provided by getMetadataItemsList(), but only one item has been removed
verify(exactly = 0) {
@ -187,6 +210,7 @@ class HistoryMetadataGroupControllerTest {
@Test
fun handleDeleteMultiple() = testDispatcher.runBlockingTest {
assertFalse(GleanHistory.searchTermGroupRemoveTab.testHasValue())
controller.handleDelete(getMetadataItemsList().toSet())
coVerify {
@ -194,8 +218,12 @@ class HistoryMetadataGroupControllerTest {
store.dispatch(HistoryMetadataGroupFragmentAction.Delete(it))
historyStorage.deleteVisitsFor(it.url)
}
metrics.track(Event.HistorySearchTermGroupRemoveTab)
}
assertTrue(GleanHistory.searchTermGroupRemoveTab.testHasValue())
assertNull(
GleanHistory.searchTermGroupRemoveTab.testGetValue()
.last().extra
)
// Here we expect the action to be dispatched, because both deleted items and items inside
// the store were provided by the same method getMetadataItemsList()
verify {
@ -214,21 +242,31 @@ class HistoryMetadataGroupControllerTest {
mozillaHistoryMetadataItem.copy(title = "BBC", url = "https://www.bbc.com/"),
mozillaHistoryMetadataItem.copy(title = "Stackoverflow", url = "https://stackoverflow.com/")
)
assertFalse(GleanHistory.searchTermGroupRemoveTab.testHasValue())
controller.handleDelete(abnormalList.toSet())
coVerify {
getMetadataItemsList().forEach {
store.dispatch(HistoryMetadataGroupFragmentAction.Delete(it))
historyStorage.deleteVisitsFor(it.url)
}
metrics.track(Event.HistorySearchTermGroupRemoveTab)
}
assertTrue(GleanHistory.searchTermGroupRemoveTab.testHasValue())
assertNull(
GleanHistory.searchTermGroupRemoveTab.testGetValue()
.last().extra
)
coVerify {
abnormalList.forEach {
store.dispatch(HistoryMetadataGroupFragmentAction.Delete(it))
historyStorage.deleteVisitsFor(it.url)
}
metrics.track(Event.HistorySearchTermGroupRemoveTab)
}
assertTrue(GleanHistory.searchTermGroupRemoveTab.testHasValue())
assertNull(
GleanHistory.searchTermGroupRemoveTab.testGetValue()
.last().extra
)
// Here we expect the action to be dispatched, because deleted items include the items
// provided by getMetadataItemsList(), so that the store becomes empty and the event
// should be sent
@ -241,6 +279,8 @@ class HistoryMetadataGroupControllerTest {
@Test
fun handleDeleteAll() = testDispatcher.runBlockingTest {
assertFalse(GleanHistory.searchTermGroupRemoveAll.testHasValue())
controller.handleDeleteAll()
coVerify {
@ -251,7 +291,15 @@ class HistoryMetadataGroupControllerTest {
browserStore.dispatch(
HistoryMetadataAction.DisbandSearchGroupAction(searchTerm = searchTerm)
)
metrics.track(Event.HistorySearchTermGroupRemoveAll)
}
assertTrue(GleanHistory.searchTermGroupRemoveAll.testHasValue())
assertEquals(
1,
GleanHistory.searchTermGroupRemoveAll.testGetValue().size
)
assertNull(
GleanHistory.searchTermGroupRemoveAll.testGetValue()
.single().extra
)
}
}

Loading…
Cancel
Save