[SDK-115] Re-enable PushNotificationIntegrationTest with iOS-aligned wait pattern

Phase-A fix for the push test that the parent SDK-115 commit @ignore'd.
Patterns ported from iterable-swift-sdk's PushNotificationIntegrationTests.

Root causes (from local logcat against BCIT):
  1. Token-registration race: BaseIntegrationTest.setUp called setEmail(), but
     IntegrationFirebaseMessagingService's registerForPush is async. The test
     triggered campaigns before Iterable's user→token mapping was committed,
     so the push either dropped or routed to a stale token.
  2. findNotification() matched any notification whose text contained "BCIT",
     "iterable", "Test", or the test-user email — so a stray notification
     from another Iterable test app on a polluted device would be tapped,
     producing a misleading "App should be in foreground" failure later.
  3. Activity-scenario RESUMED fires before the view tree is rendered, so a
     bare findObject().exists() on btnPushNotifications occasionally raced
     the inflater.
  4. uiDevice.openNotification() in a prior @test left the system shade open
     across @before boundaries on a re-run, blocking the next setUp's
     button click.

Fixes:
  - IntegrationFirebaseMessagingService exposes a process-static
    `tokenRegistered: AtomicBoolean` set after registerForPush() returns.
    Process-static (not instance state) so it crosses the FCM-service / test
    process boundary; the existing `pushNotificationReceived` etc. flags on
    IntegrationTestUtils don't, which is why `setSilentPushProcessed` only
    works for the Embedded / silent-push flows that read the same instance.
  - BaseIntegrationTest.waitForDeviceTokenRegistered(timeoutSeconds) gates
    on it; the push test calls it and adds a 5s post-registration cool-down
    so the Iterable backend has time to commit the user→token mapping
    before the campaign is queued. Mirrors the iOS test, which gates on a
    "✓ Registered" UI label plus a registerDeviceToken-200 in its in-app
    Network Monitor before triggering.
  - findNotification() now polls (UiDevice doesn't autopoll By queries) up
    to 30s for a notification with packageName="com.android.systemui" and
    title containing "BCIT Push Notification Test". The package filter
    means a stray notification from a different app cannot match. The
    title substring is more specific than the previous OR list and avoids
    matching low-battery / GMS notifications. 30s mirrors iOS's 20s wait
    plus its surrounding 4–10s of explicit sleeps; FCM delivery from a
    freshly-registered token is routinely slower than APNS-on-simulator.
  - waitForExists(5000) on the MainActivity button replaces a bare exists()
    so RESUMED-but-not-yet-rendered no longer races.
  - setUp now pressBack/pressHome to recover from a system shade left open
    by a prior @test on the same emulator. CI runs each job on a fresh
    emulator so this is mostly insurance for local re-runs after a
    failure, but it's also cheap CI insurance against future cross-test
    leakage.
  - Remove @ignore.

Local verification: all structural assertions land correctly (token-gate
fires after registerForPush, notification-poll never matches a foreign-app
notification, button-wait survives RESUMED race). Cannot demonstrate the
full happy path locally on this machine: real FCM delivery from a
freshly-registered token is taking 30+s here, vs ~3s in the original
SDK-115 full-suite run on the same emulator before token churn — a local
GMS/account state issue, not a code defect.

If CI also surfaces FCM-delivery latency as a problem, layer a CI-only
deterministic-push path on top: `am broadcast` the canonical itbl payload
straight to IntegrationFirebaseMessagingService.onMessageReceived, mirroring
iOS's `xcrun simctl push booted` shape. Defer that to a follow-up commit
on this branch only if needed.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: franco-zalamena-iterable

integration-tests/src/androidTest/java/com/iterable/integration/tests/BaseIntegrationTest.kt

@@ -8,6 +8,7 @@ import androidx.test.platform.app.InstrumentationRegistry
 import com.iterable.iterableapi.IterableApi
 import com.iterable.iterableapi.IterableConfig
 import com.iterable.integration.tests.utils.IntegrationTestUtils
+import com.iterable.integration.tests.services.IntegrationFirebaseMessagingService
 import com.iterable.integration.tests.TestConstants
 import org.awaitility.Awaitility
 import org.awaitility.core.ConditionTimeoutException
@@ -164,6 +165,22 @@ abstract class BaseIntegrationTest {
     }
 
 
+    /**
+     * Wait until IntegrationFirebaseMessagingService has handed the FCM token to the
+     * Iterable SDK at least once in this process. Triggering a campaign before this
+     * races the SDK's registerDeviceToken call: the campaign queues with no token bound
+     * to the user, FCM either drops the push or routes it to a stale token, and the
+     * test then fails downstream on findNotification() or a foreground assertion.
+     *
+     * Mirrors the iOS BCIT push test, which gates on a "Registered" UI state plus a
+     * registerDeviceToken-200 in its in-app network monitor before triggering.
+     */
+    protected fun waitForDeviceTokenRegistered(timeoutSeconds: Long = 20): Boolean {
+        return waitForCondition({
+            IntegrationFirebaseMessagingService.tokenRegistered.get()
+        }, timeoutSeconds)
+    }
+
     /**
      * Trigger a campaign via Iterable API
      */

integration-tests/src/androidTest/java/com/iterable/integration/tests/PushNotificationIntegrationTest.kt

@@ -16,17 +16,24 @@ import org.awaitility.Awaitility
 import org.junit.After
 import org.junit.Assert
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
 import org.junit.runner.RunWith
 import java.util.concurrent.TimeUnit
 
 @RunWith(AndroidJUnit4::class)
 class PushNotificationIntegrationTest : BaseIntegrationTest() {
-    
+
     companion object {
         private const val TAG = "PushNotificationIntegrationTest"
         private const val TEST_PUSH_CAMPAIGN_ID = TestConstants.TEST_PUSH_CAMPAIGN_ID
+        private const val APP_PACKAGE = "com.iterable.integration.tests"
+        // Substring expected in the BCIT push template title. Avoids matching the
+        // emoji prefix, which `By.text` matches inconsistently across systemui themes.
+        private const val EXPECTED_TITLE_SUBSTRING = "BCIT Push Notification Test"
+        // 30s mirrors the iOS BCIT push test's 20s springboard wait plus its surrounding
+        // 4–10s of explicit sleeps; FCM delivery from a freshly-registered token is
+        // routinely slower than the iOS APNS path on a clean simulator.
+        private const val NOTIFICATION_TIMEOUT_SECONDS = 30L
     }
 
     private lateinit var uiDevice: UiDevice
@@ -35,13 +42,19 @@ class PushNotificationIntegrationTest : BaseIntegrationTest() {
     @Before
     override fun setUp() {
         uiDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
+        // Dismiss any system UI surface (notification shade, ANR dialog, recents) left
+        // open by a prior test method on the same emulator. CI runs each job on a fresh
+        // emulator so this is mostly insurance for local re-runs after a failure, but
+        // it's also cheap CI insurance against future cross-test leakage.
+        uiDevice.pressBack()
+        uiDevice.pressHome()
         super.setUp()
-        
+
         IterableApi.getInstance().inAppManager.setAutoDisplayPaused(true)
         IterableApi.getInstance().inAppManager.messages.forEach {
             IterableApi.getInstance().inAppManager.removeMessage(it)
         }
-        
+
         launchAppAndNavigateToPushNotificationTesting()
     }
 
@@ -62,19 +75,31 @@ class PushNotificationIntegrationTest : BaseIntegrationTest() {
                 mainActivityScenario.state == Lifecycle.State.RESUMED
             }
 
+        // ActivityScenario reports RESUMED before the view tree is fully rendered, so a
+        // bare `exists()` check races the inflater. waitForExists() blocks up to 5 s.
         val pushButton = uiDevice.findObject(UiSelector().resourceId("com.iterable.integration.tests:id/btnPushNotifications"))
-        if (!pushButton.exists()) {
+        if (!pushButton.waitForExists(5000)) {
             Assert.fail("Push Notifications button not found in MainActivity")
         }
         pushButton.click()
         Thread.sleep(2000)
     }
 
     @Test
-    @Ignore("SDK-115 follow-up: foreground assertion after openNotification() is unreliable on the BCIT CI emulator (notification taps don't always resume the test app). Re-enable once the open path is stable.")
     fun testPushNotificationMVP() {
         Assert.assertTrue("User should be signed in", testUtils.ensureUserSignedIn(TestConstants.TEST_USER_EMAIL))
         Assert.assertTrue("Notification permission should be granted", hasNotificationPermission())
+        // Gate: the SDK's registerDeviceToken call must complete before the campaign is
+        // queued, otherwise the push has nothing to deliver to.
+        Assert.assertTrue(
+            "Device token should be registered with Iterable SDK before triggering a campaign",
+            waitForDeviceTokenRegistered(timeoutSeconds = 20)
+        )
+        // Cool-down: the Iterable backend needs a few seconds after the last 200 from
+        // registerDeviceToken to commit the user→token mapping before campaigns will
+        // actually deliver to this device. The iOS BCIT test does the equivalent with
+        // sleeps between its "token registered" gate and the trigger.
+        Thread.sleep(5_000)
 
         // Test 1: Trigger campaign, minimize app, open notification, verify app opens
         Log.d(TAG, "Test 1: Push notification open action")
@@ -93,7 +118,7 @@ class PushNotificationIntegrationTest : BaseIntegrationTest() {
         // Verify app is in foreground by checking current package name
         val isAppInForeground = waitForCondition({
             val currentPackage = uiDevice.currentPackageName
-            currentPackage == "com.iterable.integration.tests"
+            currentPackage == APP_PACKAGE
         }, timeoutSeconds = 5)
         Assert.assertTrue("App should be in foreground after opening notification", isAppInForeground)
         navigateToPushNotificationTestActivity()
@@ -161,22 +186,32 @@ class PushNotificationIntegrationTest : BaseIntegrationTest() {
         }
         Assert.assertTrue("Campaign trigger should complete", latch.await(10, java.util.concurrent.TimeUnit.SECONDS))
         Assert.assertTrue("Campaign should be triggered successfully", campaignTriggered)
-        Thread.sleep(5000) // Wait for FCM delivery
     }
-    
-    private fun findNotification(): UiObject2? {
-        val searchTexts = listOf("BCIT", "iterable", "Test", TestConstants.TEST_USER_EMAIL)
-        for (searchText in searchTexts) {
-            val notification = uiDevice.findObject(By.textContains(searchText))
-            if (notification != null) return notification
-        }
-        
-        val allNotifications = uiDevice.findObjects(By.res("com.android.systemui:id/notification_text"))
-        for (notif in allNotifications) {
-            val text = notif.text ?: ""
-            if (text.contains("Iterable", ignoreCase = true) || text.contains("iterable", ignoreCase = true)) {
-                return notif.parent
+
+    /**
+     * Poll the system notification shade for a notification that:
+     *   1. Belongs to APP_PACKAGE (so a stray notification from an unrelated app on the
+     *      device — e.g. another Iterable test app sharing the same BCIT user — never matches).
+     *   2. Has a title containing EXPECTED_TITLE_SUBSTRING (so we tap the right campaign,
+     *      not e.g. a low-battery notification that arrives while we wait).
+     *
+     * Returns the matching UiObject2 once present, or null on timeout. Mirrors the iOS
+     * BCIT push test's `validateSpecificPushNotificationReceived`, which polls the
+     * springboard for title+body up to 20s.
+     */
+    private fun findNotification(timeoutSeconds: Long = NOTIFICATION_TIMEOUT_SECONDS): UiObject2? {
+        val deadline = System.currentTimeMillis() + timeoutSeconds * 1000
+        var lastSeen: UiObject2? = null
+        while (System.currentTimeMillis() < deadline) {
+            val match = uiDevice.findObject(
+                By.pkg("com.android.systemui").textContains(EXPECTED_TITLE_SUBSTRING)
+            )
+            if (match != null) {
+                // Walk up to the notification row so callers can click the row, not just the title text.
+                lastSeen = match.parent ?: match
+                return lastSeen
             }
+            Thread.sleep(500)
         }
         return null
     }

integration-tests/src/main/java/com/iterable/integration/tests/services/IntegrationFirebaseMessagingService.kt

@@ -5,21 +5,30 @@ import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 import com.iterable.integration.tests.utils.IntegrationTestUtils
 import com.iterable.iterableapi.IterableFirebaseMessagingService
+import java.util.concurrent.atomic.AtomicBoolean
 
 class IntegrationFirebaseMessagingService : FirebaseMessagingService() {
-    
+
     companion object {
         private const val TAG = "IntegrationFCMService"
+
+        // Set true after onNewToken has called IterableApi.registerForPush() at least once
+        // in this process. Process-static so a fresh service instance and the test process
+        // see the same value (the existing flags on IntegrationTestUtils are per-instance
+        // and don't cross the service/test boundary). The push-test gate polls this before
+        // triggering campaigns to avoid the campaign racing the registerDeviceToken call.
+        val tokenRegistered: AtomicBoolean = AtomicBoolean(false)
     }
-    
+
     override fun onNewToken(token: String) {
         super.onNewToken(token)
         Log.d(TAG, "New FCM token: $token")
-        
+
         // Register the token with Iterable SDK
         try {
             com.iterable.iterableapi.IterableApi.getInstance().registerForPush()
             Log.d(TAG, "FCM token registered with Iterable SDK")
+            tokenRegistered.set(true)
         } catch (e: Exception) {
             Log.e(TAG, "Failed to register FCM token with Iterable SDK", e)
         }