@react-native-firebase/app 26.3.3 → 27.0.0

package/android/src/test/java/io/invertase/firebase/common/ReactNativeFirebaseModuleTest.kt

@@ -0,0 +1,254 @@
+package io.invertase.firebase.common
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.app.Activity
+import android.content.Context
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotSame
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.mockito.ArgumentMatchers.anyInt
+import org.mockito.ArgumentMatchers.anyString
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.mockStatic
+import org.mockito.Mockito.never
+import org.mockito.Mockito.verify
+import org.mockito.Mockito.`when`
+
+/** Plain JUnit4 + Mockito coverage for the module's bridge and lifecycle contracts. */
+class ReactNativeFirebaseModuleTest {
+  private lateinit var jsonObjectField: java.lang.reflect.Field
+  private var originalJsonObject: Any? = null
+
+  @Before
+  fun setUp() {
+    val jsonObject = mock(JSONObject::class.java)
+    `when`(jsonObject.optInt(anyString(), anyInt())).thenAnswer { it.getArgument(1) }
+    val json = ReactNativeFirebaseJSON.getSharedInstance()
+    jsonObjectField = ReactNativeFirebaseJSON::class.java.getDeclaredField("jsonObject")
+    jsonObjectField.isAccessible = true
+    originalJsonObject = jsonObjectField.get(json)
+    jsonObjectField.set(json, jsonObject)
+  }
+
+  @After
+  fun tearDown() {
+    jsonObjectField.set(ReactNativeFirebaseJSON.getSharedInstance(), originalJsonObject)
+  }
+
+  @Test
+  fun constructorUsesVirtualNameAfterAssigningModuleName() {
+    val subject = VirtualNameModule(mock(ReactApplicationContext::class.java))
+    val field = ReactNativeFirebaseModule::class.java.getDeclaredField("executorService")
+    field.isAccessible = true
+    val service = field.get(subject) as TaskExecutorService
+
+    assertEquals("ExternalChildExecutor", service.getExecutorName(false, ""))
+    assertEquals("ExternalChild", subject.name)
+  }
+
+  @Test
+  fun namePreservesJavaNullConcatenation() {
+    val subject = ReactNativeFirebaseModule(mock(ReactApplicationContext::class.java), null)
+
+    assertEquals("RNFBnullModule", subject.name)
+  }
+
+  @Test
+  fun contextActivityAndApplicationContextDelegateToReactContext() {
+    val reactContext = mock(ReactApplicationContext::class.java)
+    val applicationContext = mock(Context::class.java)
+    val activity = mock(Activity::class.java)
+    `when`(reactContext.applicationContext).thenReturn(applicationContext)
+    `when`(reactContext.currentActivity).thenReturn(activity)
+    val subject = ReactNativeFirebaseModule(reactContext, "App")
+
+    assertSame(reactContext, subject.getContext())
+    assertSame(applicationContext, subject.getApplicationContext())
+    assertSame(activity, subject.getActivity())
+    subject.initialize()
+  }
+
+  @Test
+  fun nullCurrentActivityAndApplicationContextAreReturned() {
+    val reactContext = mock(ReactApplicationContext::class.java)
+    `when`(reactContext.applicationContext).thenReturn(null)
+    `when`(reactContext.currentActivity).thenReturn(null)
+    val subject = ReactNativeFirebaseModule(reactContext, "App")
+
+    assertNull(subject.getApplicationContext())
+    assertNull(subject.getActivity())
+  }
+
+  @Test
+  fun executorAccessorsAndRemovalPreserveTransactionalBehavior() {
+    val subject = ReactNativeFirebaseModule(mock(ReactApplicationContext::class.java), "App")
+    val defaultExecutor = subject.getExecutor()
+    val transactionalExecutor = subject.getTransactionalExecutor()
+    val identifiedExecutor = subject.getTransactionalExecutor("listener")
+
+    assertSame(defaultExecutor, transactionalExecutor)
+    assertNotSame(transactionalExecutor, identifiedExecutor)
+    assertSame(identifiedExecutor, subject.getTransactionalExecutor("listener"))
+
+    subject.removeEventListeningExecutor("listener")
+
+    assertTrue(identifiedExecutor.isShutdown)
+    assertNotSame(identifiedExecutor, subject.getTransactionalExecutor("listener"))
+    subject.invalidate()
+    assertTrue(defaultExecutor.isShutdown)
+  }
+
+  @Suppress("DEPRECATION")
+  @Test
+  fun catalystDestroyDynamicallyInvokesChildInvalidate() {
+    val subject = LifecycleModule(mock(ReactApplicationContext::class.java))
+    val executor = subject.getTransactionalExecutor()
+
+    subject.onCatalystInstanceDestroy()
+
+    assertEquals(1, subject.invalidations)
+    assertTrue(executor.isShutdown)
+  }
+
+  @Test
+  fun constantsAreFreshMutableHashMaps() {
+    val subject = ReactNativeFirebaseModule(mock(ReactApplicationContext::class.java), "App")
+    val first = subject.constants
+    val second = subject.constants
+
+    first["value"] = 1
+    assertTrue(first is HashMap<*, *>)
+    assertTrue(second is HashMap<*, *>)
+    assertNotSame(first, second)
+    assertTrue(second.isEmpty())
+  }
+
+  @Test
+  fun rejectionHelpersPreserveMapsAndPromiseOverloads() {
+    val promise = mock(Promise::class.java)
+    val map = mock(WritableMap::class.java)
+    val resolver = mock(ReadableMap::class.java)
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap> { Arguments.createMap() }.thenReturn(map)
+
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+        promise,
+        "code",
+        "message",
+        resolver,
+      )
+      verify(map).putString("code", "code")
+      verify(map).putString("message", "message")
+      verify(map).putMap("resolver", resolver)
+      verify(promise).reject("code", "message", map)
+
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+        promise,
+        "without-resolver",
+        "message",
+        null as ReadableMap?,
+      )
+      verify(promise).reject("without-resolver", "message", map)
+
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, null, null)
+      verify(map).putString("code", null)
+      verify(map).putString("message", null)
+      verify(promise).reject(null as String?, null as String?, map)
+
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+        promise,
+        "native-code",
+        "native-message",
+        null as String?,
+      )
+      verify(map).putString("nativeErrorMessage", null)
+      verify(map, never()).putMap("resolver", null)
+      verify(promise).reject("native-code", "native-message", map)
+
+      assertThrows(NullPointerException::class.java) {
+        ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(null, "code", "message")
+      }
+      assertThrows(NullPointerException::class.java) {
+        ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+          null,
+          "code",
+          "message",
+          resolver,
+        )
+      }
+      assertThrows(NullPointerException::class.java) {
+        ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+          null,
+          "code",
+          "message",
+          "native",
+        )
+      }
+    }
+  }
+
+  @Test
+  fun exceptionRejectionUsesSharedExceptionMapAndExactOverload() {
+    val promise = mock(Promise::class.java)
+    val exception = Exception("failure")
+    val map = mock(WritableMap::class.java)
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(map)
+
+      ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, exception)
+
+      verify(promise).reject(exception, map)
+      verify(map).putString("code", "unknown")
+      verify(map).putString("nativeErrorCode", "unknown")
+      verify(map).putString("message", "failure")
+      verify(map).putString("nativeErrorMessage", "failure")
+      assertThrows(NullPointerException::class.java) {
+        ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(null, exception)
+      }
+    }
+  }
+
+  private class VirtualNameModule(
+    reactContext: ReactApplicationContext?,
+  ) : ReactNativeFirebaseModule(reactContext, "Ignored") {
+    override fun getName(): String = "ExternalChild"
+  }
+
+  private class LifecycleModule(
+    reactContext: ReactApplicationContext?,
+  ) : ReactNativeFirebaseModule(reactContext, "Lifecycle") {
+    var invalidations = 0
+
+    override fun invalidate() {
+      invalidations += 1
+      super.invalidate()
+    }
+  }
+}

package/android/src/test/java/io/invertase/firebase/common/ReactNativeFirebasePreferencesJavaCompatibilityTest.java

@@ -0,0 +1,87 @@
+package io.invertase.firebase.common;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.SharedPreferences;
+import java.lang.reflect.Field;
+import org.junit.Before;
+import org.junit.Test;
+
+/** Proves the Kotlin port preserves calls that Java permits with null reference arguments. */
+public class ReactNativeFirebasePreferencesJavaCompatibilityTest {
+  private SharedPreferences preferences;
+  private SharedPreferences.Editor editor;
+  private ReactNativeFirebasePreferences subject;
+
+  @Before
+  public void setUp() throws Exception {
+    preferences = mock(SharedPreferences.class);
+    editor = mock(SharedPreferences.Editor.class);
+    when(preferences.edit()).thenReturn(editor);
+    when(editor.putBoolean(null, true)).thenReturn(editor);
+    when(editor.putInt(null, 42)).thenReturn(editor);
+    when(editor.putLong(null, 4294967296L)).thenReturn(editor);
+    when(editor.putString(null, null)).thenReturn(editor);
+    when(preferences.contains(null)).thenReturn(false);
+    when(preferences.getBoolean(null, true)).thenReturn(false);
+    when(preferences.getInt(null, 42)).thenReturn(42);
+    when(preferences.getLong(null, 4294967296L)).thenReturn(4294967296L);
+    when(preferences.getString(null, null)).thenReturn(null);
+
+    subject = new ReactNativeFirebasePreferences();
+    Field field = ReactNativeFirebasePreferences.class.getDeclaredField("preferences");
+    field.setAccessible(true);
+    field.set(subject, preferences);
+  }
+
+  @Test
+  public void publicAccessorsAcceptNullKeysFromJava() {
+    assertFalse(subject.contains(null));
+    subject.setBooleanValue(null, true);
+    assertFalse(subject.getBooleanValue(null, true));
+    subject.setIntValue(null, 42);
+    subject.getIntValue(null, 42);
+    subject.setLongValue(null, 4294967296L);
+    subject.getLongValue(null, 4294967296L);
+
+    verify(preferences).contains(null);
+    verify(editor).putBoolean(null, true);
+    verify(preferences).getBoolean(null, true);
+    verify(editor).putInt(null, 42);
+    verify(preferences).getInt(null, 42);
+    verify(editor).putLong(null, 4294967296L);
+    verify(preferences).getLong(null, 4294967296L);
+    verify(editor, times(3)).apply();
+  }
+
+  @Test
+  public void stringAccessorsAcceptNullKeyValueAndDefaultAndReturnNullToJava() {
+    subject.setStringValue(null, null);
+
+    assertNull(subject.getStringValue(null, null));
+    verify(editor).putString(null, null);
+    verify(editor).apply();
+    verify(preferences).getString(null, null);
+  }
+}

package/android/src/test/java/io/invertase/firebase/common/ReactNativeFirebasePreferencesTest.kt

@@ -0,0 +1,260 @@
+package io.invertase.firebase.common
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import io.invertase.firebase.app.ReactNativeFirebaseApp
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.mockStatic
+import org.mockito.Mockito.times
+import org.mockito.Mockito.verify
+import org.mockito.Mockito.verifyNoMoreInteractions
+import org.mockito.Mockito.`when`
+import java.lang.reflect.Modifier
+import java.util.LinkedHashMap
+
+/** Plain JUnit4 + Mockito coverage for the preferences bridge (AndroidTest-AD-1). */
+class ReactNativeFirebasePreferencesTest {
+  @Test
+  fun javaVisibleApiPreservesConstructorSingletonAndExactMethodTypes() {
+    val preferencesClass = ReactNativeFirebasePreferences::class.java
+    val constructor = preferencesClass.getConstructor()
+    val sharedInstanceMethod = preferencesClass.getMethod("getSharedInstance")
+
+    assertTrue(Modifier.isPublic(constructor.modifiers))
+    assertFalse(Modifier.isFinal(preferencesClass.modifiers))
+    assertTrue(Modifier.isStatic(sharedInstanceMethod.modifiers))
+    assertEquals(preferencesClass, sharedInstanceMethod.returnType)
+    assertSame(
+      ReactNativeFirebasePreferences.getSharedInstance(),
+      ReactNativeFirebasePreferences.getSharedInstance(),
+    )
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      preferencesClass.getMethod("contains", String::class.java).returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setBooleanValue", String::class.java, Boolean::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      preferencesClass
+        .getMethod("getBooleanValue", String::class.java, Boolean::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setIntValue", String::class.java, Int::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Int::class.javaPrimitiveType,
+      preferencesClass
+        .getMethod("getIntValue", String::class.java, Int::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setLongValue", String::class.java, Long::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Long::class.javaPrimitiveType,
+      preferencesClass
+        .getMethod("getLongValue", String::class.java, Long::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setStringValue", String::class.java, String::class.java)
+        .returnType,
+    )
+    assertEquals(
+      String::class.java,
+      preferencesClass
+        .getMethod("getStringValue", String::class.java, String::class.java)
+        .returnType,
+    )
+    assertEquals(WritableMap::class.java, preferencesClass.getMethod("getAll").returnType)
+    assertEquals(Void.TYPE, preferencesClass.getMethod("clearAll").returnType)
+    preferencesClass.declaredMethods
+      .filterNot { Modifier.isStatic(it.modifiers) || Modifier.isPrivate(it.modifiers) }
+      .forEach { method -> assertFalse("${method.name} must remain overridable", Modifier.isFinal(method.modifiers)) }
+  }
+
+  @Test
+  fun lazyPreferencesUseApplicationContextFileAndModeOnce() {
+    val preferences = mock(SharedPreferences::class.java)
+    val applicationContext = mock(Context::class.java)
+    `when`(
+      applicationContext.getSharedPreferences("io.invertase.firebase", Context.MODE_PRIVATE),
+    ).thenReturn(preferences)
+    `when`(preferences.contains("present")).thenReturn(true)
+
+    val previous: Context? = ReactNativeFirebaseApp.getApplicationContext()
+    mockStatic(Log::class.java).use {
+      ReactNativeFirebaseApp.setApplicationContext(applicationContext)
+    }
+    try {
+      val subject = ReactNativeFirebasePreferences()
+
+      assertTrue(subject.contains("present"))
+      assertTrue(subject.contains("present"))
+
+      verify(applicationContext, times(1))
+        .getSharedPreferences("io.invertase.firebase", Context.MODE_PRIVATE)
+      verify(preferences, times(2)).contains("present")
+    } finally {
+      mockStatic(Log::class.java).use {
+        ReactNativeFirebaseApp.setApplicationContext(previous)
+      }
+    }
+  }
+
+  @Test
+  fun scalarGettersDelegateAndReturnStoredValues() {
+    val preferences = mock(SharedPreferences::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.contains("present")).thenReturn(true)
+    `when`(preferences.getBoolean("boolean", false)).thenReturn(true)
+    `when`(preferences.getInt("integer", 0)).thenReturn(42)
+    `when`(preferences.getLong("long", 0L)).thenReturn(4_294_967_296L)
+    `when`(preferences.getString("string", "fallback")).thenReturn("value")
+
+    assertTrue(subject.contains("present"))
+    assertTrue(subject.getBooleanValue("boolean", false))
+    assertEquals(42, subject.getIntValue("integer", 0))
+    assertEquals(4_294_967_296L, subject.getLongValue("long", 0L))
+    assertEquals("value", subject.getStringValue("string", "fallback"))
+  }
+
+  @Test
+  fun scalarSettersApplyAsynchronously() {
+    val preferences = mock(SharedPreferences::class.java)
+    val editor = mock(SharedPreferences.Editor::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.edit()).thenReturn(editor)
+    `when`(editor.putBoolean("boolean", true)).thenReturn(editor)
+    `when`(editor.putInt("integer", 42)).thenReturn(editor)
+    `when`(editor.putLong("long", 4_294_967_296L)).thenReturn(editor)
+    `when`(editor.putString("string", "value")).thenReturn(editor)
+
+    subject.setBooleanValue("boolean", true)
+    subject.setIntValue("integer", 42)
+    subject.setLongValue("long", 4_294_967_296L)
+    subject.setStringValue("string", "value")
+
+    verify(editor).putBoolean("boolean", true)
+    verify(editor).putInt("integer", 42)
+    verify(editor).putLong("long", 4_294_967_296L)
+    verify(editor).putString("string", "value")
+    verify(editor, times(4)).apply()
+    verifyNoMoreInteractions(editor)
+  }
+
+  @Test
+  fun getAllConvertsEveryEntryThroughSharedUtils() {
+    val preferences = mock(SharedPreferences::class.java)
+    val writableMap = mock(WritableMap::class.java)
+    val values =
+      LinkedHashMap<String, Any?>().apply {
+        put("boolean", true)
+        put("integer", 42)
+        put("long", 4_294_967_296L)
+        put("string", "value")
+        put("null", null)
+      }
+    val subject = subjectWith(preferences)
+    `when`(preferences.all).thenReturn(values)
+
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(writableMap)
+
+      assertSame(writableMap, subject.getAll())
+
+      verify(writableMap).putBoolean("boolean", true)
+      verify(writableMap).putInt("integer", 42)
+      verify(writableMap).putDouble("long", 4_294_967_296.0)
+      verify(writableMap).putString("string", "value")
+      verify(writableMap).putNull("null")
+    }
+  }
+
+  @Test
+  fun getAllReturnsCreatedMapWhenPreferencesAreEmpty() {
+    val preferences = mock(SharedPreferences::class.java)
+    val writableMap = mock(WritableMap::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.all).thenReturn(emptyMap())
+
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(writableMap)
+
+      assertSame(writableMap, subject.getAll())
+
+      verifyNoMoreInteractions(writableMap)
+    }
+  }
+
+  @Test
+  fun clearAllClearsAndAppliesAsynchronously() {
+    val preferences = mock(SharedPreferences::class.java)
+    val editor = mock(SharedPreferences.Editor::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.edit()).thenReturn(editor)
+    `when`(editor.clear()).thenReturn(editor)
+
+    subject.clearAll()
+
+    verify(editor).clear()
+    verify(editor).apply()
+    verifyNoMoreInteractions(editor)
+    verify(preferences).edit()
+  }
+
+  @Test
+  fun containsReturnsUnderlyingFalseValue() {
+    val preferences = mock(SharedPreferences::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.contains("missing")).thenReturn(false)
+
+    assertFalse(subject.contains("missing"))
+  }
+
+  private fun subjectWith(preferences: SharedPreferences): ReactNativeFirebasePreferences {
+    val subject = ReactNativeFirebasePreferences()
+    val field = ReactNativeFirebasePreferences::class.java.getDeclaredField("preferences")
+    field.isAccessible = true
+    field.set(subject, preferences)
+    return subject
+  }
+}