@goliapkg/sentori-react-native 6.2.0 → 6.2.1

package/android/src/test/java-core/com/sentori/SentoriPushTest.kt

@@ -0,0 +1,151 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriPushTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import androidx.test.core.app.ApplicationProvider
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Push registration, as far as Robolectric can go.
+ *
+ * There is no FCM on the classpath here and no Google Play services,
+ * so the honest coverage is the shape of the failures and the shape of
+ * the request — not a real token. `scripts/android-live-ingest.sh`
+ * proves the ingest route against a real server; a device proves the
+ * rest, and nothing here pretends otherwise.
+ *
+ * Deliberately the same assertions as `SentoriPushTests.swift`.
+ */
+@RunWith(RobolectricTestRunner::class)
+class SentoriPushTest {
+
+    private val context get() = ApplicationProvider.getApplicationContext<android.content.Context>()
+
+    @Before
+    fun setUp() {
+        SentoriConfig.resetForTests()
+        SentoriScope.clear()
+        SentoriPush.resetForTests()
+    }
+
+    @After
+    fun tearDown() {
+        SentoriConfig.resetForTests()
+        SentoriPush.resetForTests()
+    }
+
+    private fun registerBlocking(timeoutMs: Long = 1_000): SentoriPush.Result {
+        val latch = CountDownLatch(1)
+        var result: SentoriPush.Result? = null
+        SentoriPush.register(context, activity = null, timeoutMs = timeoutMs) {
+            result = it
+            latch.countDown()
+        }
+        assertTrue("register never called back", latch.await(30, TimeUnit.SECONDS))
+        return result!!
+    }
+
+    @Test
+    fun registerBeforeStartReportsItRatherThanThrowing() {
+        val r = registerBlocking()
+        assertTrue("expected a failure before start, got $r", r is SentoriPush.Result.Failure)
+        assertEquals(
+            SentoriPush.Failure.NOT_INITIALISED,
+            (r as SentoriPush.Result.Failure).reason,
+        )
+        assertEquals("not-initialised", r.reason.reason)
+    }
+
+    @Test
+    fun everyFailureHasTheSameNameAsTheOtherTwoSdks() {
+        // Same strings as `PushRegisterFailure` in React Native and
+        // `SentoriPush.Failure` in Swift, so one set of integration
+        // notes covers all three.
+        assertEquals("not-initialised", SentoriPush.Failure.NOT_INITIALISED.reason)
+        assertEquals("permission-denied", SentoriPush.Failure.PERMISSION_DENIED.reason)
+        assertEquals("no-transport", SentoriPush.Failure.NO_TRANSPORT.reason)
+        assertEquals("token-timeout", SentoriPush.Failure.TOKEN_TIMEOUT.reason)
+        assertEquals("server-rejected", SentoriPush.Failure.SERVER_REJECTED.reason)
+    }
+
+    @Test
+    fun registerWithoutFcmFailsWithoutThrowing() {
+        Sentori.start(
+            SentoriConfig(
+                token = "st_test",
+                ingestUrl = "http://127.0.0.1:9",
+                release = "app@1.0.0",
+                environment = "test",
+            ),
+            context,
+        )
+
+        // No Firebase on the classpath, so this ends at permission or
+        // at the token wait. Either is fine; reaching the end without
+        // a throw and without a hang is the assertion.
+        val r = registerBlocking()
+        assertTrue("Robolectric cannot actually register, got $r", r is SentoriPush.Result.Failure)
+        val reason = (r as SentoriPush.Result.Failure).reason
+        assertTrue(
+            "unexpected reason ${reason.reason}: ${r.message}",
+            reason in
+                listOf(
+                    SentoriPush.Failure.PERMISSION_DENIED,
+                    SentoriPush.Failure.NO_TRANSPORT,
+                    SentoriPush.Failure.TOKEN_TIMEOUT,
+                ),
+        )
+        assertNull("a failure must cache nothing", SentoriPush.cachedDeviceHandle(context))
+    }
+
+    @Test
+    fun unregisterWithNothingRegisteredIsANoOp() {
+        val latch = CountDownLatch(1)
+        var ok: Boolean? = null
+        SentoriPush.unregister(context) {
+            ok = it
+            latch.countDown()
+        }
+        assertTrue(latch.await(10, TimeUnit.SECONDS))
+        assertEquals("nothing to revoke", false, ok)
+        assertNull(SentoriPush.cachedDeviceHandle(context))
+    }
+
+    @Test
+    fun theRegistrationBodyIsTheOneTheServerAccepts() {
+        // The field names are the whole reason push never worked for a
+        // year: the RN SDK sent `provider` where the server reads
+        // `kind`, and parsed an `ipt_*` handle no server has ever
+        // returned. Pinned here rather than left to a reviewer.
+        SentoriScope.setUser("usr_123", null)
+        val body =
+            mapOf(
+                "kind" to "fcm",
+                "nativeToken" to "abcd",
+                "userKey" to SentoriScope.userKey,
+            )
+        val json = org.json.JSONObject(SentoriTransport.toJson(body).toString())
+
+        assertEquals("fcm", json.getString("kind"))
+        assertTrue("the server has no such field", !json.has("provider"))
+        // FCM is one host; an `env` here would be a claim about a
+        // sandbox/production split that does not exist.
+        assertTrue("FCM has no environment split", !json.has("env"))
+        assertEquals(
+            SentoriIdentity.hash("id", "usr_123"),
+            json.getString("userKey"),
+        )
+        assertNotNull(json)
+    }
+}

package/android/src/test/{java → java-core}/com/sentori/SentoriScreenshotCaptureTest.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriScreenshotCaptureTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // Phase 42 sub-F.10 — Robolectric coverage for SentoriScreenshotCapture.
 //
 // Run via Gradle on the Android host:

package/android/src/test/java-core/com/sentori/SentoriVerbsTest.kt

@@ -0,0 +1,185 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriVerbsTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * The five verbs, and the contract an integrator is entitled to:
+ * synchronous, an id back every time, never a throw, and a no-op
+ * before [Sentori.start] rather than a crash.
+ *
+ * Deliberately the same assertions as `SentoriVerbsTests.swift`. The
+ * dashboard cannot tell which platform sent an event and should not
+ * have to, so the two suites disagreeing is itself the bug.
+ */
+@RunWith(RobolectricTestRunner::class)
+class SentoriVerbsTest {
+
+    @Before
+    fun setUp() {
+        SentoriTransport.resetForTests()
+        SentoriConfig.resetForTests()
+        SentoriScope.clear()
+        SentoriSignalRing.clear()
+        SentoriDevice.resetForTests()
+    }
+
+    @After
+    fun tearDown() {
+        SentoriTransport.resetForTests()
+        SentoriConfig.resetForTests()
+    }
+
+    private fun started() {
+        // Port 9 is discard: nothing listens, so a send fails without
+        // waiting on DNS.
+        Sentori.start(
+            SentoriConfig(
+                token = "st_test",
+                ingestUrl = "http://127.0.0.1:9",
+                release = "app@1.0.0",
+                environment = "test",
+            )
+        )
+    }
+
+    private fun queued() = SentoriTransport.peekQueue()
+
+    @Test
+    fun everyVerbBeforeStartIsASilentNoOpThatStillReturnsAnId() {
+        val ids =
+            listOf(
+                Sentori.error(IllegalStateException("boom")),
+                Sentori.warn("checkout.slow"),
+                Sentori.trace("cart.opened"),
+                Sentori.assert("total.positive", false),
+                Sentori.probe("SEN-482"),
+            )
+        ids.forEach { assertEquals("every verb returns an event id", 36, it.length) }
+        assertTrue("and nothing is queued before init", queued().isEmpty())
+    }
+
+    @Test
+    fun errorCarriesTypeMessageStackAndTheSignalRing() {
+        started()
+        Sentori.pushSignal("nav", mapOf("to" to "/checkout"))
+        Sentori.error(IllegalStateException("boom"), mapOf("cartId" to "c_1"))
+
+        val e = queued().last()
+        assertEquals("error", e["kind"])
+        assertEquals("android", e["platform"])
+        assertEquals("app@1.0.0", e["release"])
+
+        @Suppress("UNCHECKED_CAST") val payload = e["payload"] as Map<String, Any?>
+        @Suppress("UNCHECKED_CAST") val err = payload["error"] as Map<String, Any?>
+        assertEquals("java.lang.IllegalStateException", err["type"])
+        assertEquals("boom", err["message"])
+        assertTrue("a stack with no frames symbolicates nothing", (err["stack"] as List<*>).isNotEmpty())
+
+        @Suppress("UNCHECKED_CAST") val data = payload["data"] as Map<String, Any?>
+        assertEquals("c_1", data["cartId"])
+
+        val signals = payload["signals"] as List<*>
+        assertEquals(1, signals.size)
+    }
+
+    @Test
+    fun aPassingAssertIsNeverAnEvent() {
+        started()
+        Sentori.assert("total.positive", true)
+        Sentori.assert("total.positive", true)
+        assertTrue("passes aggregate; only failures are events", queued().isEmpty())
+        assertEquals(2, SentoriTransport.peekAssertStats().first()["passDelta"])
+
+        Sentori.assert("total.positive", false)
+        assertEquals(1, queued().size)
+        assertEquals("assert", queued().first()["kind"])
+    }
+
+    @Test
+    fun assertNeverStopsTheProgram() {
+        started()
+        Sentori.assert("impossible", false)
+        Sentori.assert("also impossible", false)
+        assertEquals("reached here, twice", 2, queued().size)
+    }
+
+    @Test
+    fun quietTraceReachesTheRingAndNotTheQueue() {
+        started()
+        Sentori.trace("tick", quiet = true)
+        assertTrue("a quiet trace must stay affordable", queued().isEmpty())
+        assertEquals("but it is still context", 1, SentoriSignalRing.snapshot().size)
+
+        Sentori.trace("cart.opened")
+        assertEquals(1, queued().size)
+        assertEquals("cart.opened", queued().first()["name"])
+    }
+
+    @Test
+    fun userKeyRidesEventsOnlyAfterUserIsCalled() {
+        started()
+        Sentori.warn("before")
+        assertNull("no identity, no key — not an empty one", queued().last()["userKey"])
+
+        Sentori.user("usr_123", null)
+        Sentori.warn("after")
+        assertEquals(SentoriIdentity.hash("id", "usr_123"), queued().last()["userKey"])
+    }
+
+    @Test
+    fun contextMergesAndRidesEveryEvent() {
+        started()
+        Sentori.context(mapOf("tenant" to "acme"))
+        Sentori.context(mapOf("plan" to "pro"))
+        Sentori.probe("SEN-1")
+
+        @Suppress("UNCHECKED_CAST")
+        val payload = queued().last()["payload"] as Map<String, Any?>
+        @Suppress("UNCHECKED_CAST") val ctx = payload["context"] as Map<String, Any?>
+        assertEquals("acme", ctx["tenant"])
+        assertEquals("pro", ctx["plan"])
+    }
+
+    @Test
+    fun eventIdsAreUuidV7AndSortByTime() {
+        val first = Sentori.newEventId()
+        Thread.sleep(10)
+        val second = Sentori.newEventId()
+        assertEquals(36, first.length)
+        assertEquals("version nibble", '7', first[14])
+        assertTrue("v7 ids sort by creation time as strings", first < second)
+    }
+
+    @Test
+    fun theQueueIsBoundedAndDropsOldestFirst() {
+        started()
+        // Not flushed: nothing drains to a dead port fast enough to
+        // race this, so it measures the cap rather than a timer.
+        repeat(2000) { Sentori.trace("t$it") }
+        assertTrue("an unbounded queue is a leak with a nicer name", queued().size <= 500)
+        assertEquals("t1999", queued().last()["name"])
+    }
+
+    @Test
+    fun garbageInDataDoesNotReachTheCaller() {
+        started()
+        val id =
+            Sentori.warn(
+                "bad",
+                mapOf("nan" to Double.NaN, "obj" to Any(), "nested" to mapOf("k" to Double.NaN)),
+            )
+        assertEquals(36, id.length)
+        assertNotNull(queued().last())
+    }
+}

package/ios/{SentoriCrashHandler.swift → core/SentoriCrashHandler.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriCrashHandler.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import MachO
 
@@ -64,6 +67,19 @@ import MachO
         return UserDefaults.standard.dictionary(forKey: configKey) ?? [:]
     }
 
+    /// Test-only seam onto `write`, which the real path reaches from
+    /// an `@convention(c)` handler an XCTest cannot raise safely.
+    ///
+    /// The test that calls this was written against this name and has
+    /// never compiled: the sources were loose files in an Expo module
+    /// with no module to import, so nothing ever built the test target
+    /// and nothing reported that the member was missing. Internal
+    /// rather than public — `@testable import` reaches it, an app
+    /// does not.
+    internal static func persistForTesting(exception: NSException) {
+        write(exception: exception)
+    }
+
     private static func write(exception: NSException) {
         let cfg = config()
         let release = (cfg["release"] as? String) ?? "unknown"

package/ios/{SentoriHangWatchdog.swift → core/SentoriHangWatchdog.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriHangWatchdog.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 
 /// iOS hang detector — mirrors the Android ANR watchdog (Phase 22 sub-D).

package/ios/{SentoriMobileVitals.swift → core/SentoriMobileVitals.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriMobileVitals.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import UIKit
 import QuartzCore

package/ios/{SentoriNativeExceptionBridge.swift → core/SentoriNativeExceptionBridge.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriNativeExceptionBridge.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 
 /// v0.9.5 #8 — partial-fix for the "TurboModule swallows NSException