@react-native-firebase/app 26.4.0 → 27.1.0

package/android/src/test/java/io/invertase/firebase/app/ReactNativeFirebaseAppJavaCompatibilityTest.java

@@ -0,0 +1,60 @@
+package io.invertase.firebase.app;
+
+/*
+ * 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.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.times;
+
+import android.util.Log;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.MockedStatic;
+
+/** Proves Java callers retain nullable calls and the public no-argument constructor. */
+public class ReactNativeFirebaseAppJavaCompatibilityTest {
+  @After
+  public void resetApplicationContext() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      ReactNativeFirebaseApp.setApplicationContext(null);
+    }
+  }
+
+  @Test
+  public void javaCanConstructAndCallEveryStaticMethodWithNull() {
+    new ReactNativeFirebaseApp();
+    FirebaseOptions options = mock(FirebaseOptions.class);
+
+    try (MockedStatic<Log> log = mockStatic(Log.class);
+        MockedStatic<FirebaseOptions> firebaseOptions = mockStatic(FirebaseOptions.class);
+        MockedStatic<FirebaseApp> firebaseApps = mockStatic(FirebaseApp.class)) {
+      firebaseOptions.when(() -> FirebaseOptions.fromResource(null)).thenReturn(options);
+
+      ReactNativeFirebaseApp.setApplicationContext(null);
+      assertNull(ReactNativeFirebaseApp.getApplicationContext());
+      ReactNativeFirebaseApp.initializeSecondaryApp(null);
+      ReactNativeFirebaseApp.initializeSecondaryApp(null, null);
+
+      log.verify(() -> Log.d("ReactNativeFirebaseApp", "received application context."), times(1));
+      firebaseOptions.verify(() -> FirebaseOptions.fromResource(null), times(2));
+      firebaseApps.verify(() -> FirebaseApp.initializeApp(null, options, null), times(2));
+    }
+  }
+}

package/android/src/test/java/io/invertase/firebase/app/ReactNativeFirebaseAppPackageTest.java

@@ -0,0 +1,165 @@
+package io.invertase.firebase.app;
+
+/*
+ * 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.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.util.Log;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import io.invertase.firebase.utils.NativeRNFBTurboUtils;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.MockedStatic;
+
+/**
+ * Verifies behavior and Java ABI remain stable while the package implementation moves to Kotlin.
+ */
+public class ReactNativeFirebaseAppPackageTest {
+  private Field applicationContextField;
+  private Context originalApplicationContext;
+  private MockedStatic<Log> log;
+
+  @Before
+  public void setUp() throws Exception {
+    applicationContextField = ReactNativeFirebaseApp.class.getDeclaredField("applicationContext");
+    applicationContextField.setAccessible(true);
+    originalApplicationContext = (Context) applicationContextField.get(null);
+    applicationContextField.set(null, null);
+    log = org.mockito.Mockito.mockStatic(Log.class);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    applicationContextField.set(null, originalApplicationContext);
+    log.close();
+  }
+
+  @Test
+  public void createNativeModules_setsMissingApplicationContextAndReturnsMutableOrderedArrayList() {
+    ReactApplicationContext reactContext = mock(ReactApplicationContext.class);
+    Context applicationContext = mock(Context.class);
+    when(reactContext.getApplicationContext()).thenReturn(applicationContext);
+
+    List<NativeModule> modules =
+        new ReactNativeFirebaseAppPackage().createNativeModules(reactContext);
+
+    assertSame(applicationContext, ReactNativeFirebaseApp.getApplicationContext());
+    assertTrue(modules instanceof ArrayList);
+    assertEquals(2, modules.size());
+    assertEquals(NativeRNFBTurboApp.class, modules.get(0).getClass());
+    assertEquals(NativeRNFBTurboUtils.class, modules.get(1).getClass());
+    modules.clear();
+    assertTrue(modules.isEmpty());
+  }
+
+  @Test
+  public void createNativeModules_preservesExistingApplicationContext() throws Exception {
+    Context existingApplicationContext = mock(Context.class);
+    applicationContextField.set(null, existingApplicationContext);
+    ReactApplicationContext reactContext = mock(ReactApplicationContext.class);
+
+    List<NativeModule> modules =
+        new ReactNativeFirebaseAppPackage().createNativeModules(reactContext);
+
+    assertSame(existingApplicationContext, ReactNativeFirebaseApp.getApplicationContext());
+    verify(reactContext, never()).getApplicationContext();
+    assertEquals(NativeRNFBTurboApp.class, modules.get(0).getClass());
+    assertEquals(NativeRNFBTurboUtils.class, modules.get(1).getClass());
+  }
+
+  @Test
+  public void createViewManagers_returnsEmptyList() {
+    ReactNativeFirebaseAppPackage subject = new ReactNativeFirebaseAppPackage();
+    ReactApplicationContext reactContext = mock(ReactApplicationContext.class);
+
+    List<ViewManager> viewManagers = subject.createViewManagers(reactContext);
+
+    assertTrue(viewManagers.isEmpty());
+  }
+
+  @Test
+  public void preservesPublicOpenNoArgJavaAbiAndNonnullGenericContracts() throws Exception {
+    Class<ReactNativeFirebaseAppPackage> type = ReactNativeFirebaseAppPackage.class;
+    Constructor<ReactNativeFirebaseAppPackage> constructor = type.getConstructor();
+
+    assertTrue(Modifier.isPublic(type.getModifiers()));
+    assertFalse(Modifier.isFinal(type.getModifiers()));
+    assertTrue(Modifier.isPublic(constructor.getModifiers()));
+
+    assertPackageMethodAbi(
+        type.getDeclaredMethod("createNativeModules", ReactApplicationContext.class),
+        NativeModule.class);
+    assertPackageMethodAbi(
+        type.getDeclaredMethod("createViewManagers", ReactApplicationContext.class),
+        ViewManager.class);
+
+    ReactNativeFirebaseAppPackage subclass =
+        new ReactNativeFirebaseAppPackage() {
+          @Override
+          public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+            return new ArrayList<>();
+          }
+
+          @Override
+          public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+            return new ArrayList<>();
+          }
+        };
+    assertTrue(subclass.createNativeModules(mock(ReactApplicationContext.class)).isEmpty());
+    assertTrue(subclass.createViewManagers(mock(ReactApplicationContext.class)).isEmpty());
+    assertNull(subclass.getModule("missing", mock(ReactApplicationContext.class)));
+  }
+
+  private static void assertPackageMethodAbi(Method method, Class<?> genericElementType) {
+    assertTrue(Modifier.isPublic(method.getModifiers()));
+    assertFalse(Modifier.isFinal(method.getModifiers()));
+    assertEquals(List.class, method.getReturnType());
+    assertTrue(method.isAnnotationPresent(Nonnull.class));
+    assertTrue(method.getParameters()[0].isAnnotationPresent(Nonnull.class));
+
+    ParameterizedType genericReturnType = (ParameterizedType) method.getGenericReturnType();
+    assertEquals(List.class, genericReturnType.getRawType());
+    Type[] arguments = genericReturnType.getActualTypeArguments();
+    assertEquals(1, arguments.length);
+    Type elementType = arguments[0];
+    if (elementType instanceof ParameterizedType) {
+      elementType = ((ParameterizedType) elementType).getRawType();
+    }
+    assertEquals(genericElementType, elementType);
+  }
+}

package/android/src/test/java/io/invertase/firebase/app/ReactNativeFirebaseAppTest.kt

@@ -0,0 +1,167 @@
+package io.invertase.firebase.app
+
+/*
+ * 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.util.Log
+import com.google.firebase.FirebaseApp
+import com.google.firebase.FirebaseOptions
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+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 java.lang.reflect.Modifier
+
+class ReactNativeFirebaseAppTest {
+  @After
+  fun resetApplicationContext() {
+    mockStatic(Log::class.java).use {
+      ReactNativeFirebaseApp.setApplicationContext(null)
+    }
+  }
+
+  @Test
+  fun javaVisibleApiPreservesClassConstructorAndStaticDescriptors() {
+    val appClass = ReactNativeFirebaseApp::class.java
+    val constructor = appClass.getConstructor()
+
+    assertTrue(Modifier.isPublic(constructor.modifiers))
+    assertFalse(Modifier.isFinal(appClass.modifiers))
+    assertEquals(
+      4,
+      appClass.declaredMethods.count {
+        Modifier.isPublic(it.modifiers) &&
+          Modifier.isStatic(it.modifiers) &&
+          !it.isSynthetic
+      },
+    )
+    assertStaticMethod(appClass, "getApplicationContext", Context::class.java)
+    assertStaticMethod(
+      appClass,
+      "setApplicationContext",
+      Void.TYPE,
+      Context::class.java,
+    )
+    assertStaticMethod(
+      appClass,
+      "initializeSecondaryApp",
+      Void.TYPE,
+      String::class.java,
+    )
+    assertStaticMethod(
+      appClass,
+      "initializeSecondaryApp",
+      Void.TYPE,
+      String::class.java,
+      Context::class.java,
+    )
+  }
+
+  @Test
+  fun applicationContextStoresExactValueIncludingNullAndLogsExactly() {
+    val context = mock(Context::class.java)
+
+    mockStatic(Log::class.java).use { log ->
+      ReactNativeFirebaseApp.setApplicationContext(context)
+      assertSame(context, ReactNativeFirebaseApp.getApplicationContext())
+
+      ReactNativeFirebaseApp.setApplicationContext(null)
+      assertNull(ReactNativeFirebaseApp.getApplicationContext())
+
+      log.verify(
+        { Log.d("ReactNativeFirebaseApp", "received application context.") },
+        times(2),
+      )
+      log.verifyNoMoreInteractions()
+    }
+  }
+
+  @Test
+  fun initializeSecondaryAppUsesStoredNullableContextAndName() {
+    val context = mock(Context::class.java)
+    val options = mock(FirebaseOptions::class.java)
+    val initializedApp = mock(FirebaseApp::class.java)
+
+    mockStatic(Log::class.java).use {
+      ReactNativeFirebaseApp.setApplicationContext(context)
+    }
+    mockStatic(FirebaseOptions::class.java).use { firebaseOptions ->
+      mockStatic(FirebaseApp::class.java).use { firebaseApps ->
+        firebaseOptions
+          .`when`<FirebaseOptions> { FirebaseOptions.fromResource(context) }
+          .thenReturn(options)
+        firebaseApps
+          .`when`<FirebaseApp> {
+            FirebaseApp.initializeApp(context, options, nullAsPlatformType())
+          }.thenReturn(initializedApp)
+
+        ReactNativeFirebaseApp.initializeSecondaryApp(null)
+
+        firebaseOptions.verify { FirebaseOptions.fromResource(context) }
+        firebaseApps.verify {
+          FirebaseApp.initializeApp(context, options, nullAsPlatformType())
+        }
+      }
+    }
+  }
+
+  @Test
+  fun explicitContextOverloadIgnoresStoredContextAndAcceptsNull() {
+    val storedContext = mock(Context::class.java)
+    val options = mock(FirebaseOptions::class.java)
+
+    mockStatic(Log::class.java).use {
+      ReactNativeFirebaseApp.setApplicationContext(storedContext)
+    }
+    mockStatic(FirebaseOptions::class.java).use { firebaseOptions ->
+      mockStatic(FirebaseApp::class.java).use { firebaseApps ->
+        firebaseOptions
+          .`when`<FirebaseOptions> { FirebaseOptions.fromResource(nullAsPlatformType()) }
+          .thenReturn(options)
+
+        ReactNativeFirebaseApp.initializeSecondaryApp("secondary", null)
+
+        firebaseOptions.verify { FirebaseOptions.fromResource(nullAsPlatformType()) }
+        firebaseApps.verify {
+          FirebaseApp.initializeApp(nullAsPlatformType(), options, "secondary")
+        }
+        assertSame(storedContext, ReactNativeFirebaseApp.getApplicationContext())
+      }
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun <T> nullAsPlatformType(): T = null as T
+
+  private fun assertStaticMethod(
+    owner: Class<*>,
+    name: String,
+    returnType: Class<*>,
+    vararg parameterTypes: Class<*>,
+  ) {
+    val method = owner.getMethod(name, *parameterTypes)
+    assertTrue("$name must remain static", Modifier.isStatic(method.modifiers))
+    assertTrue("$name must remain public", Modifier.isPublic(method.modifiers))
+    assertEquals(returnType, method.returnType)
+  }
+}

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

@@ -0,0 +1,112 @@
+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.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.google.firebase.FirebaseApp;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+
+/** Compile-time and reflection checks for callers that consume the Kotlin port from Java. */
+public class RCTConvertFirebaseJavaCompatibilityTest {
+  @Test
+  public void preservesPublicOpenNoArgClassAndExactStaticMethodTypes() throws Exception {
+    Class<RCTConvertFirebase> type = RCTConvertFirebase.class;
+
+    assertTrue(Modifier.isPublic(type.getModifiers()));
+    assertFalse(Modifier.isFinal(type.getModifiers()));
+    assertTrue(Modifier.isPublic(type.getConstructor().getModifiers()));
+    assertEquals(type, new RCTConvertFirebase().getClass());
+
+    assertStaticMethod(
+        type.getMethod("firebaseAppToMap", FirebaseApp.class),
+        Map.class,
+        String.class,
+        Object.class);
+    assertStaticMethod(
+        type.getMethod("firebaseAppToWritableMap", FirebaseApp.class), WritableMap.class);
+    assertStaticMethod(
+        type.getMethod(
+            "readableMapToFirebaseApp", ReadableMap.class, ReadableMap.class, Context.class),
+        FirebaseApp.class);
+    assertStaticMethod(
+        type.getMethod("mapPutValue", String.class, Object.class, WritableMap.class),
+        WritableMap.class);
+    assertStaticMethod(
+        type.getMethod("readableMapToWritableMap", ReadableMap.class), WritableMap.class);
+    assertStaticMethod(
+        type.getMethod("toHashMap", ReadableMap.class), Map.class, String.class, Object.class);
+    assertStaticMethod(
+        type.getMethod("toArrayList", ReadableArray.class), List.class, Object.class);
+  }
+
+  @Test
+  public void staticCallAcceptsNullableValueWithoutKotlinEntryChecks() {
+    WritableMap map = mock(WritableMap.class);
+
+    assertSame(map, RCTConvertFirebase.mapPutValue("null", null, map));
+
+    verify(map).putNull("null");
+  }
+
+  @Test
+  public void javaStaticCollectionDelegatesPreserveMutableReturnIdentity() {
+    ReadableMap readableMap = mock(ReadableMap.class);
+    HashMap<String, Object> hashMap = new HashMap<>();
+    when(readableMap.toHashMap()).thenReturn(hashMap);
+    ReadableArray readableArray = mock(ReadableArray.class);
+    ArrayList<Object> arrayList = new ArrayList<>();
+    when(readableArray.toArrayList()).thenReturn(arrayList);
+
+    assertSame(hashMap, RCTConvertFirebase.toHashMap(readableMap));
+    assertSame(arrayList, RCTConvertFirebase.toArrayList(readableArray));
+  }
+
+  private static void assertStaticMethod(
+      Method method, Class<?> returnType, Type... genericArguments) {
+    assertTrue(Modifier.isPublic(method.getModifiers()));
+    assertTrue(Modifier.isStatic(method.getModifiers()));
+    assertEquals(returnType, method.getReturnType());
+
+    if (genericArguments.length == 0) {
+      assertEquals(returnType, method.getGenericReturnType());
+      return;
+    }
+
+    ParameterizedType genericReturnType = (ParameterizedType) method.getGenericReturnType();
+    assertEquals(returnType, genericReturnType.getRawType());
+    assertEquals(List.of(genericArguments), List.of(genericReturnType.getActualTypeArguments()));
+  }
+}