@react-native-firebase/app 26.4.0 → 27.1.0

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

@@ -0,0 +1,296 @@
+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.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import io.invertase.firebase.BuildConfig
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito.inOrder
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.mockStatic
+import org.mockito.Mockito.verify
+import org.mockito.Mockito.verifyNoInteractions
+import org.mockito.Mockito.`when`
+import java.lang.reflect.Modifier
+import java.util.ArrayList
+
+/**
+ * Plain JUnit4 + Mockito (AndroidTest-AD-1). JSONObject and JSONArray are mocked where Android's
+ * host-side stubs would otherwise be involved.
+ */
+class ReactNativeFirebaseJSONTest {
+  private lateinit var json: ReactNativeFirebaseJSON
+  private lateinit var jsonObjectField: java.lang.reflect.Field
+  private var originalJsonObject: Any? = null
+
+  @Before
+  fun setUp() {
+    json = ReactNativeFirebaseJSON.getSharedInstance()
+    jsonObjectField = ReactNativeFirebaseJSON::class.java.getDeclaredField("jsonObject")
+    jsonObjectField.isAccessible = true
+    originalJsonObject = jsonObjectField.get(json)
+  }
+
+  @After
+  fun tearDown() {
+    jsonObjectField.set(json, originalJsonObject)
+  }
+
+  @Test
+  fun javaVisibleApi_preservesSingletonAndExactMethodTypes() {
+    val jsonClass = ReactNativeFirebaseJSON::class.java
+    val sharedInstanceMethod = jsonClass.getMethod("getSharedInstance")
+
+    assertTrue(Modifier.isStatic(sharedInstanceMethod.modifiers))
+    assertEquals(jsonClass, sharedInstanceMethod.returnType)
+    assertSame(json, ReactNativeFirebaseJSON.getSharedInstance())
+    assertEquals(Boolean::class.javaPrimitiveType, jsonClass.getMethod("contains", String::class.java).returnType)
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      jsonClass
+        .getMethod("getBooleanValue", String::class.java, Boolean::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Int::class.javaPrimitiveType,
+      jsonClass.getMethod("getIntValue", String::class.java, Int::class.javaPrimitiveType).returnType,
+    )
+    assertEquals(
+      Long::class.javaPrimitiveType,
+      jsonClass
+        .getMethod("getLongValue", String::class.java, Long::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      String::class.java,
+      jsonClass.getMethod("getStringValue", String::class.java, String::class.java).returnType,
+    )
+    assertEquals(ArrayList::class.java, jsonClass.getMethod("getArrayValue", String::class.java).returnType)
+    assertEquals(String::class.java, jsonClass.getMethod("getRawJSON").returnType)
+    assertEquals(WritableMap::class.java, jsonClass.getMethod("getAll").returnType)
+  }
+
+  @Test
+  fun scalarAccessors_returnDefaultsWhenJsonObjectIsNull() {
+    jsonObjectField.set(json, null)
+
+    assertFalse(json.contains("missing"))
+    assertTrue(json.getBooleanValue("missing", true))
+    assertEquals(17, json.getIntValue("missing", 17))
+    assertEquals(23L, json.getLongValue("missing", 23L))
+    assertEquals("fallback", json.getStringValue("missing", "fallback"))
+  }
+
+  @Test
+  fun scalarAccessors_delegateToJsonObject() {
+    val jsonObject = mock(JSONObject::class.java)
+    `when`(jsonObject.has("present")).thenReturn(true)
+    `when`(jsonObject.optBoolean("boolean", false)).thenReturn(true)
+    `when`(jsonObject.optInt("integer", 0)).thenReturn(42)
+    `when`(jsonObject.optLong("long", 0L)).thenReturn(4_294_967_296L)
+    `when`(jsonObject.optString("string", "fallback")).thenReturn("value")
+    jsonObjectField.set(json, jsonObject)
+
+    assertTrue(json.contains("present"))
+    assertTrue(json.getBooleanValue("boolean", false))
+    assertEquals(42, json.getIntValue("integer", 0))
+    assertEquals(4_294_967_296L, json.getLongValue("long", 0L))
+    assertEquals("value", json.getStringValue("string", "fallback"))
+  }
+
+  @Test
+  fun getArrayValue_returnsMutableEmptyArrayListWhenJsonObjectIsNull() {
+    jsonObjectField.set(json, null)
+
+    val result = json.getArrayValue("missing")
+    result.add("later")
+
+    assertEquals(arrayListOf("later"), result)
+  }
+
+  @Test
+  fun getArrayValue_returnsMutableEmptyArrayListWhenValueIsNotAnArray() {
+    val jsonObject = mock(JSONObject::class.java)
+    `when`(jsonObject.optJSONArray("missing")).thenReturn(null)
+    jsonObjectField.set(json, jsonObject)
+
+    val result = json.getArrayValue("missing")
+    result.add("later")
+
+    assertEquals(arrayListOf("later"), result)
+  }
+
+  @Test
+  fun getArrayValue_preservesElementOrder() {
+    val jsonObject = mock(JSONObject::class.java)
+    val jsonArray = mock(JSONArray::class.java)
+    `when`(jsonObject.optJSONArray("items")).thenReturn(jsonArray)
+    `when`(jsonArray.length()).thenReturn(3)
+    `when`(jsonArray.getString(0)).thenReturn("first")
+    `when`(jsonArray.getString(1)).thenReturn("second")
+    `when`(jsonArray.getString(2)).thenReturn("third")
+    jsonObjectField.set(json, jsonObject)
+
+    assertEquals(arrayListOf("first", "second", "third"), json.getArrayValue("items"))
+  }
+
+  @Test
+  fun getArrayValue_returnsValuesCollectedBeforeJsonException() {
+    val jsonObject = mock(JSONObject::class.java)
+    val jsonArray = mock(JSONArray::class.java)
+    `when`(jsonObject.optJSONArray("items")).thenReturn(jsonArray)
+    `when`(jsonArray.length()).thenReturn(3)
+    `when`(jsonArray.getString(0)).thenReturn("first")
+    `when`(jsonArray.getString(1)).thenThrow(JSONException("malformed"))
+    jsonObjectField.set(json, jsonObject)
+
+    assertEquals(arrayListOf("first"), json.getArrayValue("items"))
+  }
+
+  @Test
+  fun getRawJson_returnsGeneratedBuildConfigValue() {
+    assertEquals(BuildConfig.FIREBASE_JSON_RAW, json.getRawJSON())
+  }
+
+  @Test
+  fun getAllReturnsEmptyMapWhenJsonObjectIsNull() {
+    val emptyMap = mock(WritableMap::class.java)
+    jsonObjectField.set(json, null)
+
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(emptyMap)
+
+      assertSame(emptyMap, json.getAll())
+      verifyNoInteractions(emptyMap)
+    }
+  }
+
+  @Test
+  fun getAllReturnsEmptyMapForEmptyJsonObject() {
+    val emptyMap = mock(WritableMap::class.java)
+    val jsonObject = mock(JSONObject::class.java)
+    `when`(jsonObject.keys()).thenReturn(emptyList<String>().iterator())
+    jsonObjectField.set(json, jsonObject)
+
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(emptyMap)
+
+      assertSame(emptyMap, json.getAll())
+      verifyNoInteractions(emptyMap)
+    }
+  }
+
+  @Test
+  fun getAllConvertsSupportedPreferenceValueShapesAndNestedCollections() {
+    val writableMap = mock(WritableMap::class.java)
+    val nestedWritableArray = mock(WritableArray::class.java)
+    val nestedWritableMap = mock(WritableMap::class.java)
+    val jsonObject = mock(JSONObject::class.java)
+    val nestedObject = mock(JSONObject::class.java)
+    val nestedJsonArray = mock(JSONArray::class.java)
+    val values =
+      linkedMapOf<String, Any>(
+        "boolean" to true,
+        "integer" to 42,
+        "long" to 4_294_967_296L,
+        "float" to 1.5F,
+        "double" to 2.5,
+        "string" to "value",
+        "jsonNull" to JSONObject.NULL,
+        "jsonObject" to nestedObject,
+        "jsonArray" to nestedJsonArray,
+        "list" to listOf("nested"),
+        "map" to linkedMapOf("nested" to true),
+      )
+    `when`(jsonObject.keys()).thenReturn(values.keys.iterator())
+    values.forEach { (key, value) -> `when`(jsonObject.get(key)).thenReturn(value) }
+    jsonObjectField.set(json, jsonObject)
+
+    mockStatic(Log::class.java).use {
+      mockStatic(Arguments::class.java).use { arguments ->
+        arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(writableMap, nestedWritableMap)
+        arguments.`when`<WritableArray>(Arguments::createArray).thenReturn(nestedWritableArray)
+
+        assertSame(writableMap, json.getAll())
+
+        verify(writableMap).putBoolean("boolean", true)
+        verify(writableMap).putInt("integer", 42)
+        verify(writableMap).putDouble("long", 4_294_967_296.0)
+        verify(writableMap).putDouble("float", 1.5)
+        verify(writableMap).putDouble("double", 2.5)
+        verify(writableMap).putString("string", "value")
+        verify(writableMap).putNull("jsonNull")
+        verify(writableMap).putNull("jsonObject")
+        verify(writableMap).putNull("jsonArray")
+        verify(writableMap).putArray("list", nestedWritableArray)
+        verify(writableMap).putMap("map", nestedWritableMap)
+        verify(nestedWritableArray).pushString("nested")
+        verify(nestedWritableMap).putBoolean("nested", true)
+      }
+    }
+  }
+
+  @Test
+  fun getAllPreservesKeyOrder() {
+    val writableMap = mock(WritableMap::class.java)
+    val jsonObject = mock(JSONObject::class.java)
+    `when`(jsonObject.keys()).thenReturn(listOf("first", "second").iterator())
+    `when`(jsonObject.get("first")).thenReturn(1)
+    `when`(jsonObject.get("second")).thenReturn(2)
+    jsonObjectField.set(json, jsonObject)
+
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(writableMap)
+
+      json.getAll()
+
+      val order = inOrder(jsonObject)
+      order.verify(jsonObject).get("first")
+      order.verify(jsonObject).get("second")
+    }
+  }
+
+  @Test
+  fun getAllSkipsJsonExceptionAndContinuesWithRemainingEntries() {
+    val writableMap = mock(WritableMap::class.java)
+    val jsonObject = mock(JSONObject::class.java)
+    `when`(jsonObject.keys()).thenReturn(listOf("bad", "good").iterator())
+    `when`(jsonObject.get("bad")).thenThrow(JSONException("malformed"))
+    `when`(jsonObject.get("good")).thenReturn(false)
+    jsonObjectField.set(json, jsonObject)
+
+    mockStatic(Arguments::class.java).use { arguments ->
+      arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(writableMap)
+
+      assertSame(writableMap, json.getAll())
+
+      verify(writableMap).putBoolean("good", false)
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+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.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+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.Test;
+import org.mockito.MockedStatic;
+
+/** Compiles and exercises the Kotlin implementation through its Java ABI, including null calls. */
+public class ReactNativeFirebaseMetaJavaCompatibilityTest {
+  @Test
+  public void javaCallersCanConstructOverrideAndPassNull() {
+    Context context = mock(Context.class);
+    WritableMap writableMap = mock(WritableMap.class);
+    when(context.getPackageManager()).thenReturn(null);
+    Context previous = ReactNativeFirebaseApp.getApplicationContext();
+
+    try (MockedStatic<Log> ignored = mockStatic(Log.class);
+        MockedStatic<Arguments> arguments = mockStatic(Arguments.class)) {
+      ReactNativeFirebaseApp.setApplicationContext(context);
+      arguments.when(Arguments::createMap).thenReturn(writableMap);
+
+      ReactNativeFirebaseMeta meta =
+          new ReactNativeFirebaseMeta() {
+            @Override
+            public boolean contains(String key) {
+              return super.contains(key);
+            }
+          };
+
+      assertFalse(meta.contains(null));
+      assertFalse(meta.getBooleanValue(null, false));
+      assertEquals(7, meta.getIntValue(null, 7));
+      assertNull(meta.getStringValue(null, null));
+      assertEquals(writableMap, meta.getAll());
+    } finally {
+      try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+        ReactNativeFirebaseApp.setApplicationContext(previous);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,246 @@
+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.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.os.Bundle
+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.never
+import org.mockito.Mockito.verify
+import org.mockito.Mockito.verifyNoInteractions
+import org.mockito.Mockito.verifyNoMoreInteractions
+import org.mockito.Mockito.`when`
+import java.lang.reflect.Modifier
+
+/** Plain JUnit4 + Mockito coverage for manifest metadata lookup (AndroidTest-AD-1). */
+class ReactNativeFirebaseMetaTest {
+  @Test
+  fun javaVisibleApiPreservesConstructorSingletonAndExactMethodTypes() {
+    val metaClass = ReactNativeFirebaseMeta::class.java
+    val constructor = metaClass.getConstructor()
+    val sharedInstanceMethod = metaClass.getMethod("getSharedInstance")
+
+    assertTrue(Modifier.isPublic(constructor.modifiers))
+    assertFalse(Modifier.isFinal(metaClass.modifiers))
+    assertTrue(Modifier.isStatic(sharedInstanceMethod.modifiers))
+    assertEquals(metaClass, sharedInstanceMethod.returnType)
+    assertSame(
+      ReactNativeFirebaseMeta.getSharedInstance(),
+      ReactNativeFirebaseMeta.getSharedInstance(),
+    )
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      metaClass.getMethod("contains", String::class.java).returnType,
+    )
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      metaClass
+        .getMethod("getBooleanValue", String::class.java, Boolean::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      String::class.java,
+      metaClass.getMethod("getStringValue", String::class.java, String::class.java).returnType,
+    )
+    assertEquals(
+      Int::class.javaPrimitiveType,
+      metaClass
+        .getMethod("getIntValue", String::class.java, Int::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(WritableMap::class.java, metaClass.getMethod("getAll").returnType)
+    metaClass.declaredMethods
+      .filterNot { Modifier.isStatic(it.modifiers) || Modifier.isPrivate(it.modifiers) }
+      .forEach { method ->
+        assertFalse("${method.name} must remain overridable", Modifier.isFinal(method.modifiers))
+      }
+  }
+
+  @Test
+  fun scalarAccessorsReturnDefaultsWhenPackageManagerIsNull() {
+    val context = mock(Context::class.java)
+    `when`(context.packageManager).thenReturn(null)
+
+    withApplicationContext(context) {
+      val subject = ReactNativeFirebaseMeta()
+
+      assertFalse(subject.contains("missing"))
+      assertTrue(subject.getBooleanValue("missing", true))
+      assertEquals("fallback", subject.getStringValue("missing", "fallback"))
+      assertEquals(17, subject.getIntValue("missing", 17))
+    }
+  }
+
+  @Test
+  fun scalarAccessorsUsePrefixedKeysIncludingNullAndDelegateDefaults() {
+    val metaData = mock(Bundle::class.java)
+    val context = contextWithMetaData(metaData)
+    `when`(metaData.containsKey("rnfirebase_present")).thenReturn(true)
+    `when`(metaData.getBoolean("rnfirebase_boolean", false)).thenReturn(true)
+    `when`(metaData.getString("rnfirebase_string", null)).thenReturn("value")
+    `when`(metaData.getInt("rnfirebase_integer", 0)).thenReturn(42)
+    `when`(metaData.containsKey("rnfirebase_null")).thenReturn(true)
+
+    withApplicationContext(context) {
+      val subject = ReactNativeFirebaseMeta()
+
+      assertTrue(subject.contains("present"))
+      assertTrue(subject.getBooleanValue("boolean", false))
+      assertEquals("value", subject.getStringValue("string", null))
+      assertEquals(42, subject.getIntValue("integer", 0))
+      assertTrue(subject.contains(null))
+    }
+  }
+
+  @Test
+  fun metadataLookupUsesPackageNameAndGetMetaDataFlag() {
+    val context = mock(Context::class.java)
+    val packageManager = mock(PackageManager::class.java)
+    val applicationInfo = mock(ApplicationInfo::class.java)
+    val metaData = mock(Bundle::class.java)
+    applicationInfo.metaData = metaData
+    `when`(context.packageManager).thenReturn(packageManager)
+    `when`(context.packageName).thenReturn("com.example.test")
+    `when`(
+      packageManager.getApplicationInfo("com.example.test", PackageManager.GET_META_DATA),
+    ).thenReturn(applicationInfo)
+    `when`(metaData.containsKey("rnfirebase_present")).thenReturn(true)
+
+    withApplicationContext(context) {
+      assertTrue(ReactNativeFirebaseMeta().contains("present"))
+    }
+
+    verify(packageManager)
+      .getApplicationInfo("com.example.test", PackageManager.GET_META_DATA)
+  }
+
+  @Test
+  fun metadataLookupFallsBackForNullApplicationInfoNullMetadataAndMissingPackage() {
+    val context = mock(Context::class.java)
+    val packageManager = mock(PackageManager::class.java)
+    val applicationInfo = mock(ApplicationInfo::class.java)
+    `when`(context.packageManager).thenReturn(packageManager)
+    `when`(context.packageName).thenReturn("com.example.test")
+    `when`(
+      packageManager.getApplicationInfo("com.example.test", PackageManager.GET_META_DATA),
+    ).thenReturn(null, applicationInfo)
+      .thenThrow(PackageManager.NameNotFoundException("missing"))
+
+    withApplicationContext(context) {
+      val subject = ReactNativeFirebaseMeta()
+
+      assertFalse(subject.contains("first"))
+      assertFalse(subject.contains("second"))
+      assertFalse(subject.contains("third"))
+    }
+  }
+
+  @Test
+  fun getAllCreatesAndReturnsEmptyMapWhenMetadataIsUnavailable() {
+    val context = mock(Context::class.java)
+    val emptyMap = mock(WritableMap::class.java)
+    `when`(context.packageManager).thenReturn(null)
+
+    withApplicationContext(context) {
+      mockStatic(Arguments::class.java).use { arguments ->
+        arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(emptyMap)
+
+        assertSame(emptyMap, ReactNativeFirebaseMeta().getAll())
+        verifyNoInteractions(emptyMap)
+      }
+    }
+  }
+
+  @Test
+  fun getAllKeepsPrefixedSupportedValuesAndIgnoresEverythingElse() {
+    val metaData = mock(Bundle::class.java)
+    val writableMap = mock(WritableMap::class.java)
+    val context = contextWithMetaData(metaData)
+    val keys =
+      linkedSetOf(
+        "unrelated",
+        "rnfirebase_null",
+        "rnfirebase_string",
+        "rnfirebase_boolean",
+        "rnfirebase_integer",
+        "rnfirebase_unsupported",
+      )
+    `when`(metaData.keySet()).thenReturn(keys)
+    `when`(metaData.get("rnfirebase_null")).thenReturn(null)
+    `when`(metaData.get("rnfirebase_string")).thenReturn("value")
+    `when`(metaData.get("rnfirebase_boolean")).thenReturn(true)
+    `when`(metaData.get("rnfirebase_integer")).thenReturn(42)
+    `when`(metaData.get("rnfirebase_unsupported")).thenReturn(42L)
+
+    withApplicationContext(context) {
+      mockStatic(Arguments::class.java).use { arguments ->
+        arguments.`when`<WritableMap>(Arguments::createMap).thenReturn(writableMap)
+
+        assertSame(writableMap, ReactNativeFirebaseMeta().getAll())
+      }
+    }
+
+    verify(metaData, never()).get("unrelated")
+    verify(writableMap).putNull("rnfirebase_null")
+    verify(writableMap).putString("rnfirebase_string", "value")
+    verify(writableMap).putBoolean("rnfirebase_boolean", true)
+    verify(writableMap).putInt("rnfirebase_integer", 42)
+    verifyNoMoreInteractions(writableMap)
+  }
+
+  private fun contextWithMetaData(metaData: Bundle): Context {
+    val context = mock(Context::class.java)
+    val packageManager = mock(PackageManager::class.java)
+    val applicationInfo = mock(ApplicationInfo::class.java)
+    applicationInfo.metaData = metaData
+    `when`(context.packageManager).thenReturn(packageManager)
+    `when`(context.packageName).thenReturn("com.example.test")
+    `when`(
+      packageManager.getApplicationInfo("com.example.test", PackageManager.GET_META_DATA),
+    ).thenReturn(applicationInfo)
+    return context
+  }
+
+  private fun withApplicationContext(
+    context: Context,
+    block: () -> Unit,
+  ) {
+    val previous: Context? = ReactNativeFirebaseApp.getApplicationContext()
+    mockStatic(Log::class.java).use {
+      ReactNativeFirebaseApp.setApplicationContext(context)
+    }
+    try {
+      block()
+    } finally {
+      mockStatic(Log::class.java).use {
+        ReactNativeFirebaseApp.setApplicationContext(previous)
+      }
+    }
+  }
+}