test: update test suites to reflect modernization cleanup changes

wpinho-branch · wpinho-branch · commit d0c7c5e0e0b9 · 2025-07-08T15:08:39.000-03:00
- Update BranchApiPreservationManagerTest to remove tests for deprecated API registrations
- Remove logout callback adapter tests from CallbackAdapterRegistryTest
- Update LegacyBranchWrapperTest to reflect simplified wrapper implementation
- Clean up PreservedBranchApiTest by removing tests for deprecated methods
- Adjust ModernStrategyDemoTest to align with updated modernization components

These test updates correspond to the production code cleanup in the
modernization layer and ensure test coverage remains accurate.
diff --git a/Branch-SDK/src/test/java/io/branch/referral/modernization/BranchApiPreservationManagerTest.kt b/Branch-SDK/src/test/java/io/branch/referral/modernization/BranchApiPreservationManagerTest.kt
@@ -171,14 +171,7 @@ class BranchApiPreservationManagerTest {
         assertNotNull("Should return result for getInstance", result)
     }
     
-    @Test
-    fun `test handleLegacyApiCall with getAutoInstance method`() {
-        val manager = BranchApiPreservationManager.getInstance(mockContext)
-        
-        val result = manager.handleLegacyApiCall("getAutoInstance", arrayOf(mockContext))
-        
-        assertNotNull("Should return result for getAutoInstance", result)
-    }
+
     
     @Test
     fun `test handleLegacyApiCall with setIdentity method`() {
@@ -189,14 +182,7 @@ class BranchApiPreservationManagerTest {
         assertNotNull("Should return result for setIdentity", result)
     }
     
-    @Test
-    fun `test handleLegacyApiCall with resetUserSession method`() {
-        val manager = BranchApiPreservationManager.getInstance(mockContext)
-        
-        val result = manager.handleLegacyApiCall("resetUserSession", emptyArray())
-        
-        assertNotNull("Should return result for resetUserSession", result)
-    }
+
     
     @Test
     fun `test handleLegacyApiCall with enableTestMode method`() {
@@ -255,7 +241,7 @@ class BranchApiPreservationManagerTest {
         // Call multiple methods
         manager.handleLegacyApiCall("getInstance", emptyArray())
         manager.handleLegacyApiCall("setIdentity", arrayOf("user1"))
-        manager.handleLegacyApiCall("resetUserSession", emptyArray())
+        manager.handleLegacyApiCall("enableTestMode", emptyArray())
         
         // Verify analytics are being tracked
         val analytics = manager.getUsageAnalytics()
diff --git a/Branch-SDK/src/test/java/io/branch/referral/modernization/ModernStrategyDemoTest.kt b/Branch-SDK/src/test/java/io/branch/referral/modernization/ModernStrategyDemoTest.kt
@@ -111,17 +111,15 @@ class ModernStrategyDemoTest {
             println("⚠️ Static enableTestMode not available: ${e.message}")
         }
         
-        // Test auto instance
-        val autoInstance = PreservedBranchApi.getAutoInstance(mockContext)
-        assertNotNull("Auto instance should return wrapper", autoInstance)
-        println("✅ Static Branch.getAutoInstance() preserved")
+        // Test regular instance
+        val instance = PreservedBranchApi.getInstance()
+        assertNotNull("Instance should return wrapper", instance)
+        println("✅ Static Branch.getInstance() preserved")
         
         // Verify analytics captured the calls
         val usageData = analytics.getUsageData()
         assertTrue("Analytics should track getInstance calls", 
                    usageData.containsKey("getInstance"))
-        assertTrue("Analytics should track getAutoInstance calls", 
-                   usageData.containsKey("getAutoInstance"))
         
         println("📈 Static API calls tracked in analytics")
     }
diff --git a/Branch-SDK/src/test/java/io/branch/referral/modernization/adapters/CallbackAdapterRegistryTest.kt b/Branch-SDK/src/test/java/io/branch/referral/modernization/adapters/CallbackAdapterRegistryTest.kt
@@ -187,95 +187,19 @@ class CallbackAdapterRegistryTest {
         assertTrue("Should handle null callback gracefully", true)
     }
     
-    @Test
-    fun `test adaptLogoutCallback with success result`() {
-        var callbackExecuted = false
-        var stateChanged = false
-        var receivedError: BranchError? = null
-        
-        val callback = object : Branch.BranchReferralStateChangedListener {
-            override fun onStateChanged(changed: Boolean, error: BranchError?) {
-                callbackExecuted = true
-                stateChanged = changed
-                receivedError = error
-            }
-        }
-        
-        registry.adaptLogoutCallback(callback, true, null)
-        
-        // Wait a bit for async callback
-        Thread.sleep(100)
-        
-        assertTrue("Callback should have been executed", callbackExecuted)
-        assertTrue("Should indicate state changed", stateChanged)
-        assertNull("Should have no error", receivedError)
-    }
+
     
-    @Test
-    fun `test adaptLogoutCallback with error`() {
-        var callbackExecuted = false
-        var stateChanged = false
-        var receivedError: BranchError? = null
-        
-        val callback = object : Branch.BranchReferralStateChangedListener {
-            override fun onStateChanged(changed: Boolean, error: BranchError?) {
-                callbackExecuted = true
-                stateChanged = changed
-                receivedError = error
-            }
-        }
-        
-        val testError = mock(BranchError::class.java)
-        
-        registry.adaptLogoutCallback(callback, false, testError)
-        
-        // Wait a bit for async callback
-        Thread.sleep(100)
-        
-        assertTrue("Callback should have been executed", callbackExecuted)
-        assertFalse("Should indicate state not changed", stateChanged)
-        assertNotNull("Should receive error", receivedError)
-        assertSame("Should have correct error", testError, receivedError)
-    }
+
     
-    @Test
-    fun `test adaptLogoutCallback with null callback`() {
-        // Should not throw exception with null callback
-        registry.adaptLogoutCallback(null, true, null)
-        
-        assertTrue("Should handle null callback gracefully", true)
-    }
+
     
-    @Test
-    fun `test adaptLogoutCallback with null result`() {
-        var callbackExecuted = false
-        var stateChanged = false
-        var receivedError: BranchError? = null
-        
-        val callback = object : Branch.BranchReferralStateChangedListener {
-            override fun onStateChanged(changed: Boolean, error: BranchError?) {
-                callbackExecuted = true
-                stateChanged = changed
-                receivedError = error
-            }
-        }
-        
-        registry.adaptLogoutCallback(callback, null, null)
-        
-        // Wait a bit for async callback
-        Thread.sleep(100)
-        
-        assertTrue("Callback should have been executed", callbackExecuted)
-        assertFalse("Should indicate state not changed when result is null", stateChanged)
-        assertNull("Should have no error", receivedError)
-    }
+
     
     @Test
     fun `test concurrent callback execution`() {
-        val latch = CountDownLatch(3)
+        val latch = CountDownLatch(2)
         var callback1Executed = false
         var callback2Executed = false
-        var callback3Executed = false
         
         val callback1 = object : Branch.BranchReferralInitListener {
             override fun onInitFinished(referringParams: JSONObject?, error: BranchError?) {
@@ -291,23 +215,14 @@ class CallbackAdapterRegistryTest {
             }
         }
         
-        val callback3 = object : Branch.BranchReferralStateChangedListener {
-            override fun onStateChanged(changed: Boolean, error: BranchError?) {
-                callback3Executed = true
-                latch.countDown()
-            }
-        }
-        
         // Execute callbacks concurrently
         registry.adaptInitSessionCallback(callback1, JSONObject(), null)
         registry.adaptIdentityCallback(callback2, JSONObject(), null)
-        registry.adaptLogoutCallback(callback3, true, null)
         
         latch.await(5, TimeUnit.SECONDS)
         
         assertTrue("Callback 1 should have been executed", callback1Executed)
         assertTrue("Callback 2 should have been executed", callback2Executed)
-        assertTrue("Callback 3 should have been executed", callback3Executed)
     }
     
     @Test
@@ -326,24 +241,15 @@ class CallbackAdapterRegistryTest {
             }
         }
         
-        val callback3 = object : Branch.BranchReferralStateChangedListener {
-            override fun onStateChanged(changed: Boolean, error: BranchError?) {
-                executionOrder.add("callback3")
-            }
-        }
-        
         // Execute callbacks in sequence
         registry.adaptInitSessionCallback(callback1, JSONObject(), null)
         Thread.sleep(50)
         registry.adaptIdentityCallback(callback2, JSONObject(), null)
         Thread.sleep(50)
-        registry.adaptLogoutCallback(callback3, true, null)
-        Thread.sleep(50)
         
-        assertTrue("Should have executed all callbacks", executionOrder.size >= 3)
+        assertTrue("Should have executed all callbacks", executionOrder.size >= 2)
         assertTrue("Should contain callback1", executionOrder.contains("callback1"))
         assertTrue("Should contain callback2", executionOrder.contains("callback2"))
-        assertTrue("Should contain callback3", executionOrder.contains("callback3"))
     }
     
     @Test
@@ -489,7 +395,6 @@ class CallbackAdapterRegistryTest {
     fun `test callback with different result types`() {
         var initCallbackExecuted = false
         var identityCallbackExecuted = false
-        var logoutCallbackExecuted = false
         
         val initCallback = object : Branch.BranchReferralInitListener {
             override fun onInitFinished(referringParams: JSONObject?, error: BranchError?) {
@@ -503,22 +408,14 @@ class CallbackAdapterRegistryTest {
             }
         }
         
-        val logoutCallback = object : Branch.BranchReferralStateChangedListener {
-            override fun onStateChanged(changed: Boolean, error: BranchError?) {
-                logoutCallbackExecuted = true
-            }
-        }
-        
         // Test with different result types
         registry.adaptInitSessionCallback(initCallback, JSONObject(), null)
         registry.adaptIdentityCallback(identityCallback, "string_result", null)
-        registry.adaptLogoutCallback(logoutCallback, 123, null)
         
         Thread.sleep(100)
         
         assertTrue("Init callback should have been executed", initCallbackExecuted)
         assertTrue("Identity callback should have been executed", identityCallbackExecuted)
-        assertTrue("Logout callback should have been executed", logoutCallbackExecuted)
     }
     
     @Test
diff --git a/Branch-SDK/src/test/java/io/branch/referral/modernization/wrappers/LegacyBranchWrapperTest.kt b/Branch-SDK/src/test/java/io/branch/referral/modernization/wrappers/LegacyBranchWrapperTest.kt
@@ -103,13 +103,7 @@ class LegacyBranchWrapperTest {
         assertTrue("Should execute without exception", true)
     }
     
-    @Test
-    fun `test resetUserSession`() {
-        wrapper.resetUserSession()
-        
-        // Should not throw exception
-        assertTrue("Should execute without exception", true)
-    }
+
     
     @Test
     fun `test getFirstReferringParams`() {
diff --git a/Branch-SDK/src/test/java/io/branch/referral/modernization/wrappers/PreservedBranchApiTest.kt b/Branch-SDK/src/test/java/io/branch/referral/modernization/wrappers/PreservedBranchApiTest.kt
