@react-native-firebase/app 26.4.0 → 27.1.0

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

@@ -0,0 +1,176 @@
+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.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import io.invertase.firebase.interfaces.NativeEvent;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * Java ABI / nullability / descriptor checks for the Kotlin EventEmitter port.
+ *
+ * <p>Robolectric is required because companion initialization constructs a main-looper Handler.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseEventEmitterJavaCompatibilityTest {
+
+  @Test
+  public void classIsPublicOpenConstructibleWithOuterStaticSharedInstanceAccessor()
+      throws Exception {
+    Class<?> emitterClass = ReactNativeFirebaseEventEmitter.class;
+    assertTrue(Modifier.isPublic(emitterClass.getModifiers()));
+    assertFalse(Modifier.isFinal(emitterClass.getModifiers()));
+
+    Constructor<?> constructor = emitterClass.getDeclaredConstructor();
+    assertTrue(Modifier.isPublic(constructor.getModifiers()));
+    assertNotNull(constructor.newInstance());
+
+    Method getSharedInstance = emitterClass.getMethod("getSharedInstance");
+    assertTrue(Modifier.isPublic(getSharedInstance.getModifiers()));
+    assertTrue(Modifier.isStatic(getSharedInstance.getModifiers()));
+    assertEquals(emitterClass, getSharedInstance.getReturnType());
+    assertSame(
+        ReactNativeFirebaseEventEmitter.getSharedInstance(),
+        ReactNativeFirebaseEventEmitter.getSharedInstance());
+  }
+
+  @Test
+  public void publicMethodDescriptorsMatchJavaSurface() throws Exception {
+    Class<?> emitterClass = ReactNativeFirebaseEventEmitter.class;
+
+    assertPublicOpenInstance(
+        emitterClass.getMethod("attachReactContext", ReactContext.class), Void.TYPE);
+    assertPublicOpenInstance(
+        emitterClass.getMethod("detachReactContext", ReactContext.class), Void.TYPE);
+    assertPublicOpenInstance(emitterClass.getMethod("notifyJsReady", Boolean.class), Void.TYPE);
+    assertPublicOpenInstance(emitterClass.getMethod("sendEvent", NativeEvent.class), Void.TYPE);
+    assertPublicOpenInstance(emitterClass.getMethod("addListener", String.class), Void.TYPE);
+    assertPublicOpenInstance(
+        emitterClass.getMethod("removeListener", String.class, Boolean.class), Void.TYPE);
+    assertPublicOpenInstance(emitterClass.getMethod("getListenersMap"), WritableMap.class);
+  }
+
+  @Test
+  public void sharedInstanceRemainsPrivateStaticOuterField() throws Exception {
+    Field shared = ReactNativeFirebaseEventEmitter.class.getDeclaredField("sharedInstance");
+    assertTrue(Modifier.isPrivate(shared.getModifiers()));
+    assertTrue(Modifier.isStatic(shared.getModifiers()));
+    assertEquals(ReactNativeFirebaseEventEmitter.class, shared.getType());
+  }
+
+  @Test
+  public void privateFieldNamesRemainReflectable() throws Exception {
+    String[] names = {
+      "handler",
+      "queuedEvents",
+      "jsListeners",
+      "attachedReactContext",
+      "pendingReactContext",
+      "hostLagReactContext",
+      "attachedListenersSnapshot",
+      "attachedJsReadySnapshot",
+      "attachedJsListenerCountSnapshot",
+      "emitPrefersRestoredAttached",
+      "jsReady",
+      "jsListenerCount"
+    };
+    for (String name : names) {
+      Field field = ReactNativeFirebaseEventEmitter.class.getDeclaredField(name);
+      assertTrue(name, Modifier.isPrivate(field.getModifiers()));
+    }
+
+    // Java field type was List; Kotlin MutableList erases to List.
+    Field queued = ReactNativeFirebaseEventEmitter.class.getDeclaredField("queuedEvents");
+    assertEquals(List.class, queued.getType());
+    Field listeners = ReactNativeFirebaseEventEmitter.class.getDeclaredField("jsListeners");
+    assertEquals(HashMap.class, listeners.getType());
+  }
+
+  @Test
+  public void hostResolveAndEmitMethodsRetainJavaDescriptors() throws Exception {
+    Method resolve =
+        ReactNativeFirebaseEventEmitter.class.getDeclaredMethod(
+            "getCurrentReactContextFromHost", ReactContext.class);
+    assertTrue(Modifier.isStatic(resolve.getModifiers()));
+    assertTrue(Modifier.isPrivate(resolve.getModifiers()));
+    assertEquals(ReactContext.class, resolve.getReturnType());
+
+    Method emit =
+        ReactNativeFirebaseEventEmitter.class.getDeclaredMethod("emit", NativeEvent.class);
+    assertTrue(Modifier.isPrivate(emit.getModifiers()));
+    assertEquals(Boolean.TYPE, emit.getReturnType());
+
+    Method sendQueued = ReactNativeFirebaseEventEmitter.class.getDeclaredMethod("sendQueuedEvents");
+    assertTrue(Modifier.isPrivate(sendQueued.getModifiers()));
+    assertEquals(Void.TYPE, sendQueued.getReturnType());
+
+    // androidx @Nullable/@MainThread are CLASS retention (lint-visible, not runtime).
+    Field snapshot =
+        ReactNativeFirebaseEventEmitter.class.getDeclaredField("attachedListenersSnapshot");
+    assertTrue(Modifier.isPrivate(snapshot.getModifiers()));
+    assertEquals(HashMap.class, snapshot.getType());
+  }
+
+  @Test
+  public void notifyJsReadyNullUnboxesWithNpeAtAssignmentTiming() {
+    ReactNativeFirebaseEventEmitter emitter = new ReactNativeFirebaseEventEmitter();
+    try {
+      emitter.notifyJsReady(null);
+      fail("expected NullPointerException from Boolean unboxing");
+    } catch (NullPointerException expected) {
+      // Java assigned Boolean into primitive boolean inside the monitor.
+    }
+  }
+
+  @Test
+  public void removeListenerNullAllUnboxesOnlyWhenEventRegistered() {
+    ReactNativeFirebaseEventEmitter emitter = new ReactNativeFirebaseEventEmitter();
+    // No registration: null `all` must not unbox.
+    emitter.removeListener("missing", null);
+
+    emitter.addListener("present");
+    try {
+      emitter.removeListener("present", null);
+      fail("expected NullPointerException from Boolean unboxing");
+    } catch (NullPointerException expected) {
+      // With count == 1, `|| all` short-circuits; `all ? … : 1` then unboxes.
+    }
+  }
+
+  private static void assertPublicOpenInstance(Method method, Class<?> returnType) {
+    assertTrue(method.toString(), Modifier.isPublic(method.getModifiers()));
+    assertFalse(method.toString(), Modifier.isStatic(method.getModifiers()));
+    assertFalse(method.toString(), Modifier.isFinal(method.getModifiers()));
+    assertEquals(returnType, method.getReturnType());
+  }
+}

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

@@ -1418,21 +1418,28 @@ public class ReactNativeFirebaseEventEmitterTest {
   public void emit_returnsFalse_whenEmitContextNull() throws Exception {
     when(reactHost.getCurrentReactContext()).thenReturn(null);
     ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
-    emitter.notifyJsReady(true);
-    emitter.addListener(EVENT);
-    ShadowLooper.idleMainLooper();
+    Context previous = ReactNativeFirebaseApp.getApplicationContext();
+    try {
+      // Force brownfield null host resolution: no ReactApplication fallback.
+      ReactNativeFirebaseApp.setApplicationContext(null);
+      emitter.notifyJsReady(true);
+      emitter.addListener(EVENT);
+      ShadowLooper.idleMainLooper();
 
-    emitter.sendEvent(event(EVENT, eventBody));
-    ShadowLooper.idleMainLooper();
+      emitter.sendEvent(event(EVENT, eventBody));
+      ShadowLooper.idleMainLooper();
 
-    verify(liveJsEmitter, never()).emit(anyString(), eq(eventBody));
-    verify(staleJsEmitter, never()).emit(anyString(), eq(eventBody));
+      verify(liveJsEmitter, never()).emit(anyString(), eq(eventBody));
+      verify(staleJsEmitter, never()).emit(anyString(), eq(eventBody));
 
-    Field queued = ReactNativeFirebaseEventEmitter.class.getDeclaredField("queuedEvents");
-    queued.setAccessible(true);
-    @SuppressWarnings("unchecked")
-    java.util.List<NativeEvent> remaining = (java.util.List<NativeEvent>) queued.get(emitter);
-    assertEquals(1, remaining.size());
+      Field queued = ReactNativeFirebaseEventEmitter.class.getDeclaredField("queuedEvents");
+      queued.setAccessible(true);
+      @SuppressWarnings("unchecked")
+      java.util.List<NativeEvent> remaining = (java.util.List<NativeEvent>) queued.get(emitter);
+      assertEquals(1, remaining.size());
+    } finally {
+      ReactNativeFirebaseApp.setApplicationContext(previous);
+    }
   }
 
   /** With no pending and a null attached pointer, emit prefers the non-null host current. */
@@ -1711,6 +1718,130 @@ public class ReactNativeFirebaseEventEmitterTest {
     }
   }
 
+  /** getListenersMap reports currentContextHash 0 when the host cannot name a current context. */
+  @Test
+  public void getListenersMap_reportsZeroCurrentHash_whenHostCurrentNull() {
+    when(reactHost.getCurrentReactContext()).thenReturn(liveContext);
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.attachReactContext(liveContext);
+    ShadowLooper.idleMainLooper();
+    emitter.notifyJsReady(true);
+    emitter.addListener(EVENT);
+    ShadowLooper.idleMainLooper();
+
+    when(reactHost.getCurrentReactContext()).thenReturn(null);
+
+    WritableMap writableMap = mock(WritableMap.class);
+    WritableMap eventsMap = mock(WritableMap.class);
+    try (MockedStatic<Arguments> arguments = mockStatic(Arguments.class)) {
+      arguments.when(Arguments::createMap).thenReturn(writableMap, eventsMap);
+      emitter.getListenersMap();
+      verify(writableMap).putInt("currentContextHash", 0);
+      verify(writableMap).putInt("attachedContextHash", System.identityHashCode(liveContext));
+    }
+  }
+
+  /** The first NativeEvent dereference must occur while holding the exact jsListeners monitor. */
+  @Test
+  public void sendEvent_readsEventNameFirstInsideJsListenersMonitor() throws Exception {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    Field field = ReactNativeFirebaseEventEmitter.class.getDeclaredField("jsListeners");
+    field.setAccessible(true);
+    Object monitor = field.get(emitter);
+
+    NativeEvent nativeEvent = mock(NativeEvent.class);
+    when(nativeEvent.getEventName())
+        .thenAnswer(
+            invocation -> {
+              assertTrue("getEventName must execute under jsListeners", Thread.holdsLock(monitor));
+              return EVENT;
+            });
+
+    emitter.sendEvent(nativeEvent);
+    ShadowLooper.idleMainLooper();
+
+    verify(nativeEvent).getEventName();
+    assertEquals(1, queuedCount(emitter));
+  }
+
+  /**
+   * A null NativeEvent is accepted by the public call and fails only when the posted runnable first
+   * dereferences it under jsListeners. The erased generic helper proves there is no parameter cast.
+   */
+  @Test
+  public void sendEvent_nullFailsInsidePostedRunnable_withoutPreMonitorCheck() throws Exception {
+    Method platformHelper =
+        ReactNativeFirebaseEventEmitter.class.getDeclaredMethod(
+            "nullableAsPlatformType", Object.class);
+    assertEquals(Object.class, platformHelper.getReturnType());
+
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.sendEvent(null);
+    try {
+      ShadowLooper.idleMainLooper();
+      org.junit.Assert.fail("expected posted getEventName NullPointerException");
+    } catch (NullPointerException expected) {
+      // The public sendEvent call returned; failure occurred in the posted runnable.
+    }
+  }
+
+  /** Nullable Java listener keys flow unchanged into WritableMap.putInt. */
+  @Test
+  public void getListenersMap_passesNullListenerKeyToWritableMap() {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.addListener(null);
+    ShadowLooper.idleMainLooper();
+
+    WritableMap writableMap = mock(WritableMap.class);
+    WritableMap eventsMap = mock(WritableMap.class);
+    try (MockedStatic<Arguments> arguments = mockStatic(Arguments.class)) {
+      arguments.when(Arguments::createMap).thenReturn(writableMap, eventsMap);
+
+      emitter.getListenersMap();
+
+      verify(eventsMap).putInt(eq((String) null), eq(1));
+    }
+  }
+
+  /** ReactHost LinkageError is swallowed the same as RuntimeException. */
+  @Test
+  public void hostResolution_swallowsReactHostLinkageError() throws Exception {
+    Application reactApp =
+        mock(
+            Application.class,
+            org.mockito.Mockito.withSettings().extraInterfaces(ReactApplication.class));
+    ReactApplication asReactApplication = (ReactApplication) reactApp;
+    when(reactApp.getApplicationContext()).thenReturn(reactApp);
+    when(asReactApplication.getReactHost()).thenThrow(new LinkageError("reactHost linkage"));
+    when(asReactApplication.getReactNativeHost())
+        .thenThrow(new RuntimeException("bridgeless-only test host"));
+
+    ReactContext hint = mock(ReactContext.class);
+    when(hint.getApplicationContext()).thenReturn(reactApp);
+
+    Method resolve =
+        ReactNativeFirebaseEventEmitter.class.getDeclaredMethod(
+            "getCurrentReactContextFromHost", ReactContext.class);
+    resolve.setAccessible(true);
+    assertNull(resolve.invoke(null, hint));
+  }
+
+  /** ReactNativeHost LinkageError is swallowed when ReactHost is absent. */
+  @Test
+  public void hostResolution_swallowsReactNativeHostLinkageError_whenReactHostAbsent()
+      throws Exception {
+    application.reactHost = null;
+    ReactNativeHost rnHost = mock(ReactNativeHost.class);
+    application.reactNativeHost = rnHost;
+    when(rnHost.hasInstance()).thenThrow(new LinkageError("native host linkage"));
+
+    Method resolve =
+        ReactNativeFirebaseEventEmitter.class.getDeclaredMethod(
+            "getCurrentReactContextFromHost", ReactContext.class);
+    resolve.setAccessible(true);
+    assertNull(resolve.invoke(null, liveContext));
+  }
+
   private static NativeEvent event(String name, WritableMap body) {
     return new NativeEvent() {
       @Override

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

@@ -0,0 +1,61 @@
+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 com.facebook.react.bridge.WritableMap
+import io.invertase.firebase.interfaces.NativeEvent
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+import org.mockito.Mockito.mock
+
+class ReactNativeFirebaseEventTest {
+  @Test
+  fun twoArgumentConstructor_preservesValuesAndUsesNullAppName() {
+    val body = mock(WritableMap::class.java)
+
+    val event: NativeEvent = ReactNativeFirebaseEvent("event_name", body)
+
+    assertEquals("event_name", event.getEventName())
+    assertSame(body, event.getEventBody())
+    assertNull(event.getFirebaseAppName())
+  }
+
+  @Test
+  fun threeArgumentConstructor_preservesValues() {
+    val body = mock(WritableMap::class.java)
+
+    val event: NativeEvent = ReactNativeFirebaseEvent("event_name", body, "app_name")
+
+    assertEquals("event_name", event.getEventName())
+    assertSame(body, event.getEventBody())
+    assertEquals("app_name", event.getFirebaseAppName())
+  }
+
+  @Test
+  fun javaVisibleApi_hasBothConstructorShapesAndExactGetterTypes() {
+    val eventClass = ReactNativeFirebaseEvent::class.java
+
+    eventClass.getConstructor(String::class.java, WritableMap::class.java)
+    eventClass.getConstructor(String::class.java, WritableMap::class.java, String::class.java)
+    assertEquals(String::class.java, eventClass.getMethod("getEventName").returnType)
+    assertEquals(WritableMap::class.java, eventClass.getMethod("getEventBody").returnType)
+    assertEquals(String::class.java, eventClass.getMethod("getFirebaseAppName").returnType)
+  }
+}

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

@@ -0,0 +1,85 @@
+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.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONObject;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/** Proves the Kotlin port preserves calls that Java permits with null reference arguments. */
+public class ReactNativeFirebaseJSONJavaCompatibilityTest {
+  private ReactNativeFirebaseJSON json;
+  private Field jsonObjectField;
+  private Object originalJsonObject;
+
+  @Before
+  public void setUp() throws Exception {
+    json = ReactNativeFirebaseJSON.getSharedInstance();
+    jsonObjectField = ReactNativeFirebaseJSON.class.getDeclaredField("jsonObject");
+    jsonObjectField.setAccessible(true);
+    originalJsonObject = jsonObjectField.get(json);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    jsonObjectField.set(json, originalJsonObject);
+  }
+
+  @Test
+  public void publicAccessorsAcceptNullKeysFromJava() throws Exception {
+    JSONObject jsonObject = mock(JSONObject.class);
+    when(jsonObject.has(null)).thenReturn(true);
+    when(jsonObject.optBoolean(null, true)).thenReturn(false);
+    when(jsonObject.optInt(null, 17)).thenReturn(23);
+    when(jsonObject.optLong(null, 29L)).thenReturn(31L);
+    when(jsonObject.optString(null, "fallback")).thenReturn("value");
+    when(jsonObject.optJSONArray(null)).thenReturn(null);
+    jsonObjectField.set(json, jsonObject);
+
+    assertTrue(json.contains(null));
+    assertFalse(json.getBooleanValue(null, true));
+    assertEquals(23, json.getIntValue(null, 17));
+    assertEquals(31L, json.getLongValue(null, 29L));
+    assertEquals("value", json.getStringValue(null, "fallback"));
+
+    ArrayList<String> result = json.getArrayValue(null);
+    result.add("mutable");
+    assertEquals(List.of("mutable"), result);
+  }
+
+  @Test
+  public void getStringValueAcceptsAndReturnsNullDefaultFromJava() throws Exception {
+    jsonObjectField.set(json, null);
+    assertNull(json.getStringValue(null, null));
+
+    JSONObject jsonObject = mock(JSONObject.class);
+    when(jsonObject.optString(null, null)).thenReturn(null);
+    jsonObjectField.set(json, jsonObject);
+    assertNull(json.getStringValue(null, null));
+  }
+}