Repository: wordpress-mobile/WordPress-Android (language: kotlin)

Issue:
Add indicator to the conflict resolution overlay track events so post can be distinguished from page
Add property "source=page|post" to the overlay tracking events


Discussion hints:
Thanks for reporting! 👍 <!-- generated_by_dangermattic -->


Pull request: Conflict Resolution: Tracking source
Fixes #20655 

This PR adds a source property to the Post Conflict Resolution tracking events
"source=page|post" 


Merge Instructions
- Ensure PR #20635 has been merged
- Remove Not Ready for merge label
- Merge as normal
-----

## To Test:
Prereq
- Install and launch the app from this PR
- Set up some posts with version conflicts and autosave changes (2 of each)
- Set up some pages with version conflicts and autosave changes (2 of each)

### Test posts
- Tap on a "version conflict" post to launch the resolution dialog
- Tap around on the overlay to capture the following tracking events
- ✅ Validate the following events are shown
🔵 Tracked: resolve_conflict_screen_shown, Properties: {"source":"post"}
🔵 Tracked: resolve_conflict_cancel_tapped, Properties: {"source":"post"}
🔵 Tracked: resolve_conflict_close_tapped, Properties: {"source":"post"}
🔵 Tracked: resolve_conflict_confirm_tapped, Properties: {"confirm_type":"remote_version","source":"post"}
🔵 Tracked: resolve_conflict_dismissed, Properties: {"source":"post"}

- Repeat the test with "autosave" post
- ✅ Validate the following events are shown
🔵 Tracked: resolve_autosave_conflict_screen_shown, Properties: {"source":"post"}
🔵 Tracked: resolve_autosave_conflict_cancel_tapped, Properties: {"source":"post"}
🔵 Tracked: resolve_autosave_conflict_close_tapped, Properties: {"source":"post"}
🔵 Tracked: resolve_autosave_conflict_confirm_tapped, Properties: {"confirm_type":"remote_version","source":"post"}
🔵 Tracked: resolve_autosave_conflict_dismissed, Properties: {"source":"post"}

### Test pages
- Tap on a "version conflict" page to launch the resolution dialog
- Tap around on the overlay to capture the following tracking events
- ✅ Validate the following events are shown
🔵 Tracked: resolve_conflict_screen_shown, Properties: {"source":"page"}
🔵 Tracked: resolve_conflict_cancel_tapped, Properties: {"source":"page"}
🔵 Tracked: resolve_conflict_close_tapped, Properties: {"source":"page"}
🔵 Tracked: resolve_conflict_confirm_tapped, Properties: {"confirm_type":"remote_version","source":"page"}
🔵 Tracked: resolve_conflict_dismissed, Properties: {"source":"page"}

- Repeat the test with "autosave" page
🔵 Tracked: resolve_autosave_conflict_screen_shown, Properties: {"source":"page"}
🔵 Tracked: resolve_autosave_conflict_cancel_tapped, Properties: {"source":"page"}
🔵 Tracked: resolve_autosave_conflict_close_tapped, Properties: {"source":"page"}
🔵 Tracked: resolve_autosave_conflict_confirm_tapped, Properties: {"confirm_type":"remote_version","source":"page"}
🔵 Tracked: resolve_autosave_conflict_dismissed, Properties: {"source":"page"}

-----

## Regression Notes

1. Potential unintended areas of impact
The resolution overlay events are not tracked with a source property

2. What I did to test those areas of impact (or what existing automated tests I relied on)
Updated unit tests

3. What automated tests I added (or what prevented me from doing so)
N/A

-----

## PR Submission Checklist:
- [X] I have completed the Regression Notes.
- [X] I have considered adding accessibility improvements for my changes.
- [X] I have considered if this change warrants user-facing release notes and have added them to `RELEASE-NOTES.txt` if necessary.

-----

## Testing Checklist (strike-out the not-applying and unnecessary ones): N/A



Test command: ./gradlew :WordPress:testWordpressVanillaDebugUnitTest --tests "org.wordpress.android.ui.posts.PostResolutionOverlayViewModelTest" --tests "org.wordpress.android.ui.posts.PostResolutionOverlayAnalyticsTrackerTest"

Fix patch:
diff --git a/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTracker.kt b/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTracker.kt
index 009fa4247147..dd22ea67f638 100644
--- a/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTracker.kt
+++ b/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTracker.kt
@@ -7,51 +7,73 @@ import javax.inject.Inject
 class PostResolutionOverlayAnalyticsTracker @Inject constructor(
     private val tracker: AnalyticsTrackerWrapper
 ) {
-    fun trackShown(postResolutionType: PostResolutionType) {
+    fun trackShown(postResolutionType: PostResolutionType, isPage: Boolean = false) {
         val stat = when (postResolutionType) {
             PostResolutionType.SYNC_CONFLICT -> AnalyticsTracker.Stat.RESOLVE_CONFLICT_SCREEN_SHOWN
             PostResolutionType.AUTOSAVE_REVISION_CONFLICT ->
                 AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_SCREEN_SHOWN
         }
-        tracker.track(stat)
+
+        tracker.track(stat, mapOf(
+            PROPERTY_SOURCE to if (isPage) PROPERTY_SOURCE_PAGE else PROPERTY_SOURCE_POST)
+        )
     }
 
-    fun trackCancel(postResolutionType: PostResolutionType) {
+    fun trackCancel(postResolutionType: PostResolutionType, isPage: Boolean = false) {
         val stat = when (postResolutionType) {
             PostResolutionType.SYNC_CONFLICT -> AnalyticsTracker.Stat.RESOLVE_CONFLICT_CANCEL_TAPPED
             PostResolutionType.AUTOSAVE_REVISION_CONFLICT ->
                 AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CANCEL_TAPPED
         }
-        tracker.track(stat)
+        tracker.track(stat, mapOf(
+            PROPERTY_SOURCE to if (isPage) PROPERTY_SOURCE_PAGE else PROPERTY_SOURCE_POST)
+        )
     }
 
-    fun trackClose(postResolutionType: PostResolutionType) {
+    fun trackClose(postResolutionType: PostResolutionType, isPage: Boolean = false) {
         val stat = when (postResolutionType) {
             PostResolutionType.SYNC_CONFLICT -> AnalyticsTracker.Stat.RESOLVE_CONFLICT_CLOSE_TAPPED
             PostResolutionType.AUTOSAVE_REVISION_CONFLICT ->
                 AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CLOSE_TAPPED
         }
-        tracker.track(stat)
+        tracker.track(stat, mapOf(
+            PROPERTY_SOURCE to if (isPage) PROPERTY_SOURCE_PAGE else PROPERTY_SOURCE_POST)
+        )
     }
 
-    fun trackDismissed(postResolutionType: PostResolutionType) {
+    fun trackDismissed(postResolutionType: PostResolutionType, isPage: Boolean = false) {
         val stat = when (postResolutionType) {
             PostResolutionType.SYNC_CONFLICT -> AnalyticsTracker.Stat.RESOLVE_CONFLICT_DISMISSED
             PostResolutionType.AUTOSAVE_REVISION_CONFLICT -> AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_DISMISSED
         }
-        tracker.track(stat)
+        tracker.track(stat, mapOf(
+            PROPERTY_SOURCE to if (isPage) PROPERTY_SOURCE_PAGE else PROPERTY_SOURCE_POST)
+        )
     }
 
-    fun trackConfirm(postResolutionType: PostResolutionType, confirmationType: PostResolutionConfirmationType) {
+    fun trackConfirm(
+        postResolutionType: PostResolutionType,
+        confirmationType: PostResolutionConfirmationType,
+        isPage: Boolean = false
+    ) {
         val stat = when (postResolutionType) {
             PostResolutionType.SYNC_CONFLICT -> AnalyticsTracker.Stat.RESOLVE_CONFLICT_CONFIRM_TAPPED
             PostResolutionType.AUTOSAVE_REVISION_CONFLICT ->
                 AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CONFIRM_TAPPED
         }
-        tracker.track(stat, mapOf(PROPERTY_CONFIRM_TYPE to confirmationType.analyticsLabel))
+
+        tracker.track(
+            stat, mapOf(
+                PROPERTY_CONFIRM_TYPE to confirmationType.analyticsLabel,
+                PROPERTY_SOURCE to if (isPage) PROPERTY_SOURCE_PAGE else PROPERTY_SOURCE_POST
+            )
+        )
     }
 
     companion object {
         const val PROPERTY_CONFIRM_TYPE = "confirm_type"
+        const val PROPERTY_SOURCE = "source"
+        const val PROPERTY_SOURCE_PAGE = "page"
+        const val PROPERTY_SOURCE_POST = "post"
     }
 }
diff --git a/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModel.kt b/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModel.kt
index 70732b6ae4e5..d3ac8cfc6164 100644
--- a/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModel.kt
+++ b/WordPress/src/main/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModel.kt
@@ -138,7 +138,7 @@ class PostResolutionOverlayViewModel @Inject constructor(
     private fun onConfirmClick() {
         _uiState.value?.selectedContentItem?.let {
             val confirmationType = it.id.toPostResolutionConfirmationType()
-            tracker.trackConfirm(resolutionType, confirmationType)
+            tracker.trackConfirm(resolutionType, confirmationType, post.isPage)
             _triggerListeners.value = PostResolutionOverlayActionEvent.PostResolutionConfirmationEvent(resolutionType,
                 confirmationType)
         }
@@ -146,21 +146,21 @@ class PostResolutionOverlayViewModel @Inject constructor(
     }
 
     private fun onCloseClick() {
-        tracker.trackClose(resolutionType)
+        tracker.trackClose(resolutionType, post.isPage)
         _dismissDialog.value = true
     }
 
     private fun onCancelClick() {
-        tracker.trackCancel(resolutionType)
+        tracker.trackCancel(resolutionType, post.isPage)
         _dismissDialog.value = true
     }
 
     fun onDialogDismissed() {
-        tracker.trackDismissed(resolutionType)
+        tracker.trackDismissed(resolutionType, post.isPage)
     }
 
     private fun onDialogShown() {
-        tracker.trackShown(resolutionType)
+        tracker.trackShown(resolutionType, post.isPage)
     }
 
     private fun onItemSelected(selectedItem: ContentItem) {


Test patch:
diff --git a/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTrackerTest.kt b/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTrackerTest.kt
index 54b47bd72f08..651577665d20 100644
--- a/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTrackerTest.kt
+++ b/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayAnalyticsTrackerTest.kt
@@ -13,59 +13,182 @@ import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.wordpress.android.analytics.AnalyticsTracker
 import org.wordpress.android.ui.posts.PostResolutionOverlayAnalyticsTracker.Companion.PROPERTY_CONFIRM_TYPE
+import org.wordpress.android.ui.posts.PostResolutionOverlayAnalyticsTracker.Companion.PROPERTY_SOURCE
+import org.wordpress.android.ui.posts.PostResolutionOverlayAnalyticsTracker.Companion.PROPERTY_SOURCE_PAGE
+import org.wordpress.android.ui.posts.PostResolutionOverlayAnalyticsTracker.Companion.PROPERTY_SOURCE_POST
 
 @RunWith(MockitoJUnitRunner::class)
 class PostResolutionOverlayAnalyticsTrackerTest {
     private val analyticsTracker: AnalyticsTrackerWrapper = mock()
     lateinit var tracker: PostResolutionOverlayAnalyticsTracker
 
+    private val pageProps = mapOf(PROPERTY_SOURCE to PROPERTY_SOURCE_PAGE)
+    private val postProps = mapOf(PROPERTY_SOURCE to PROPERTY_SOURCE_POST)
+
     @Before
     fun setUp() {
         tracker = PostResolutionOverlayAnalyticsTracker(analyticsTracker)
     }
 
     @Test
-    fun `tracksScreenShown tracks correct event`() {
+    fun `given page, tracksScreenShown tracks correct event`() {
+        tracker.trackShown(PostResolutionType.AUTOSAVE_REVISION_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_SCREEN_SHOWN,
+            expectedProps = pageProps,
+        )
+
+        tracker.trackShown(PostResolutionType.SYNC_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_SCREEN_SHOWN,
+            expectedProps = pageProps,
+        )
+    }
+    @Test
+    fun `given post, tracksScreenShown tracks correct event`() {
         tracker.trackShown(PostResolutionType.AUTOSAVE_REVISION_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_SCREEN_SHOWN))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_SCREEN_SHOWN,
+            expectedProps = postProps,
+        )
+
         tracker.trackShown(PostResolutionType.SYNC_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_CONFLICT_SCREEN_SHOWN))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_SCREEN_SHOWN,
+            expectedProps = postProps,
+        )
     }
 
     @Test
-    fun `tracksCancel tracks correct event`() {
+    fun `given page, tracksCancel tracks correct event`() {
+        tracker.trackCancel(PostResolutionType.AUTOSAVE_REVISION_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CANCEL_TAPPED,
+            expectedProps = pageProps,
+        )
+
+        tracker.trackCancel(PostResolutionType.SYNC_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_CANCEL_TAPPED,
+            expectedProps = pageProps,
+        )
+    }
+
+    @Test
+    fun `given post, tracksCancel tracks correct event`() {
         tracker.trackCancel(PostResolutionType.AUTOSAVE_REVISION_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CANCEL_TAPPED))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CANCEL_TAPPED,
+            expectedProps = postProps,
+        )
+
         tracker.trackCancel(PostResolutionType.SYNC_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_CONFLICT_CANCEL_TAPPED))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_CANCEL_TAPPED,
+            expectedProps = postProps,
+        )
     }
 
     @Test
-    fun `tracksClose tracks correct event`() {
+    fun `given page, tracksClose tracks correct event`() {
+        tracker.trackClose(PostResolutionType.AUTOSAVE_REVISION_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CLOSE_TAPPED,
+            expectedProps = pageProps,
+        )
+
+        tracker.trackClose(PostResolutionType.SYNC_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_CLOSE_TAPPED,
+            expectedProps = pageProps,
+        )
+    }
+
+    @Test
+    fun `given post, tracksClose tracks correct event`() {
         tracker.trackClose(PostResolutionType.AUTOSAVE_REVISION_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CLOSE_TAPPED))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CLOSE_TAPPED,
+            expectedProps = postProps,
+        )
+
         tracker.trackClose(PostResolutionType.SYNC_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_CONFLICT_CLOSE_TAPPED))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_CLOSE_TAPPED,
+            expectedProps = postProps,
+        )
+    }
+
+
+    @Test
+    fun `given page, tracksDismiss tracks correct event`() {
+        tracker.trackDismissed(PostResolutionType.AUTOSAVE_REVISION_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_DISMISSED,
+            expectedProps = pageProps,
+        )
+        tracker.trackDismissed(PostResolutionType.SYNC_CONFLICT, true)
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_DISMISSED,
+            expectedProps = pageProps,
+        )
     }
 
     @Test
-    fun `tracksDismiss tracks correct event`() {
+    fun `given post, tracksDismiss tracks correct event`() {
         tracker.trackDismissed(PostResolutionType.AUTOSAVE_REVISION_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_DISMISSED))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_DISMISSED,
+            expectedProps = postProps,
+        )
         tracker.trackDismissed(PostResolutionType.SYNC_CONFLICT)
-        verify(analyticsTracker, times(1)).track(
-            eq(AnalyticsTracker.Stat.RESOLVE_CONFLICT_DISMISSED))
+        verifyCorrectEventTracking(
+            expectedEvent = AnalyticsTracker.Stat.RESOLVE_CONFLICT_DISMISSED,
+            expectedProps = postProps,
+        )
+    }
+
+    @Test
+    fun `given page, tracksConfirm tracks correct event and properties`() {
+        tracker.trackConfirm(
+            PostResolutionType.AUTOSAVE_REVISION_CONFLICT,
+            PostResolutionConfirmationType.CONFIRM_OTHER,
+            true
+        )
+        tracker.trackConfirm(
+            PostResolutionType.AUTOSAVE_REVISION_CONFLICT,
+            PostResolutionConfirmationType.CONFIRM_LOCAL,
+            true
+        )
+        mapCaptor().apply {
+            verify(analyticsTracker, times(2)).track(
+                eq(AnalyticsTracker.Stat.RESOLVE_AUTOSAVE_CONFLICT_CONFIRM_TAPPED),
+                capture()
+            )
+
+            Assertions.assertThat(firstValue).containsEntry(PROPERTY_CONFIRM_TYPE, "remote_version")
+            Assertions.assertThat(secondValue).containsEntry(PROPERTY_CONFIRM_TYPE, "local_version")
+            Assertions.assertThat(firstValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_PAGE)
+            Assertions.assertThat(secondValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_PAGE)
+        }
+
+        tracker.trackConfirm(PostResolutionType.SYNC_CONFLICT, PostResolutionConfirmationType.CONFIRM_OTHER, true)
+        tracker.trackConfirm(PostResolutionType.SYNC_CONFLICT, PostResolutionConfirmationType.CONFIRM_LOCAL, true)
+        mapCaptor().apply {
+            verify(analyticsTracker, times(2)).track(
+                eq(AnalyticsTracker.Stat.RESOLVE_CONFLICT_CONFIRM_TAPPED),
+                capture()
+            )
+
+            Assertions.assertThat(firstValue).containsEntry(PROPERTY_CONFIRM_TYPE, "remote_version")
+            Assertions.assertThat(secondValue).containsEntry(PROPERTY_CONFIRM_TYPE, "local_version")
+            Assertions.assertThat(firstValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_PAGE)
+            Assertions.assertThat(secondValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_PAGE)
+        }
     }
 
     @Test
-    fun `tracksConfirm tracks correct event and properties`() {
+    fun `given post, tracksConfirm tracks correct event and properties`() {
         tracker.trackConfirm(
             PostResolutionType.AUTOSAVE_REVISION_CONFLICT,
             PostResolutionConfirmationType.CONFIRM_OTHER
@@ -82,6 +205,8 @@ class PostResolutionOverlayAnalyticsTrackerTest {
 
             Assertions.assertThat(firstValue).containsEntry(PROPERTY_CONFIRM_TYPE, "remote_version")
             Assertions.assertThat(secondValue).containsEntry(PROPERTY_CONFIRM_TYPE, "local_version")
+            Assertions.assertThat(firstValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_POST)
+            Assertions.assertThat(secondValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_POST)
         }
 
         tracker.trackConfirm(PostResolutionType.SYNC_CONFLICT, PostResolutionConfirmationType.CONFIRM_OTHER)
@@ -94,8 +219,23 @@ class PostResolutionOverlayAnalyticsTrackerTest {
 
             Assertions.assertThat(firstValue).containsEntry(PROPERTY_CONFIRM_TYPE, "remote_version")
             Assertions.assertThat(secondValue).containsEntry(PROPERTY_CONFIRM_TYPE, "local_version")
+            Assertions.assertThat(firstValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_POST)
+            Assertions.assertThat(secondValue).containsEntry(PROPERTY_SOURCE, PROPERTY_SOURCE_POST)
         }
     }
 
     private fun mapCaptor() = argumentCaptor<Map<String, Any?>>()
+    private fun verifyCorrectEventTracking(
+        expectedEvent: AnalyticsTracker.Stat,
+        expectedProps: Map<String, String>,
+        expectedTimes: Int = 1
+    ) {
+        mapCaptor().apply {
+            verify(analyticsTracker, times(expectedTimes)).track(
+                eq(expectedEvent),
+                capture()
+            )
+            Assertions.assertThat(firstValue).isEqualTo(expectedProps)
+        }
+    }
 }
diff --git a/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModelTest.kt b/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModelTest.kt
index 7ac8150bd338..2d230056294b 100644
--- a/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModelTest.kt
+++ b/WordPress/src/test/java/org/wordpress/android/ui/posts/PostResolutionOverlayViewModelTest.kt
@@ -134,7 +134,7 @@ class PostResolutionOverlayViewModelTest : BaseUnitTest() {
         val uiState = uiStates.last()
         uiState.closeClick.invoke()
 
-        verify(tracker, times(1)).trackClose(any())
+        verify(tracker, times(1)).trackClose(any(), any())
     }
 
     @Test
@@ -154,7 +154,7 @@ class PostResolutionOverlayViewModelTest : BaseUnitTest() {
         val uiState = uiStates.last()
         uiState.cancelClick.invoke()
 
-        verify(tracker, times(1)).trackCancel(any())
+        verify(tracker, times(1)).trackCancel(any(), any())
     }
 
     @Test
@@ -163,7 +163,7 @@ class PostResolutionOverlayViewModelTest : BaseUnitTest() {
 
         viewModel.onDialogDismissed()
 
-        verify(tracker, times(1)).trackDismissed(any())
+        verify(tracker, times(1)).trackDismissed(any(), any())
     }
 
     @Test
@@ -184,7 +184,7 @@ class PostResolutionOverlayViewModelTest : BaseUnitTest() {
         uiState.onSelected.invoke(selectedContentItem)
         uiState.confirmClick.invoke()
 
-        verify(tracker, times(1)).trackConfirm(any(), any())
+        verify(tracker, times(1)).trackConfirm(any(), any(), any())
     }
 
     @Test