@react-native-firebase/database 26.3.3 → 27.0.0

package/android/src/test/java/io/invertase/firebase/database/RNFBDatabaseKeepSyncedRegistryTest.java

@@ -0,0 +1,174 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+
+public class RNFBDatabaseKeepSyncedRegistryTest {
+  private static final String LOCATION = "[DEFAULT]|https://db.example.com/users/1";
+  private static final String OTHER_LOCATION = "[DEFAULT]|https://db.example.com/users/2";
+
+  private final RNFBDatabaseKeepSyncedRegistry registry = new RNFBDatabaseKeepSyncedRegistry();
+  private final List<String> applied = new ArrayList<>();
+
+  private void keepSynced(String location, String queryKey, boolean enabled) {
+    registry.keepSynced(location, queryKey, enabled, () -> applied.add(queryKey + "=" + enabled));
+  }
+
+  @Test
+  public void beginNativeGet_nothingKeptSynced_returnsTrue() {
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_locationKeptSynced_returnsFalse() {
+    keepSynced(LOCATION, "plain", true);
+    assertFalse(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_queryAtLocationKeptSynced_returnsFalse() {
+    keepSynced(LOCATION, "limitToLast(1)", true);
+    assertFalse(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_otherLocationKeptSynced_returnsTrue() {
+    keepSynced(OTHER_LOCATION, "plain", true);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_afterKeepSyncedFalse_returnsTrue() {
+    keepSynced(LOCATION, "plain", true);
+    keepSynced(LOCATION, "plain", false);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_untilEveryQueryAtLocationIsCleared_returnsFalse() {
+    keepSynced(LOCATION, "plain", true);
+    keepSynced(LOCATION, "limitToLast(1)", true);
+    keepSynced(LOCATION, "plain", false);
+    assertFalse(registry.beginNativeGet(LOCATION));
+    keepSynced(LOCATION, "limitToLast(1)", false);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void keepSynced_noNativeGetInFlight_appliesNow() {
+    keepSynced(LOCATION, "plain", true);
+    assertEquals(Collections.singletonList("plain=true"), applied);
+  }
+
+  @Test
+  public void keepSynced_disableWhenNothingKept_stillApplies() {
+    keepSynced(LOCATION, "plain", false);
+    assertEquals(Collections.singletonList("plain=false"), applied);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void keepSynced_noNativeGetInFlight_runsApplyBeforeCallerCompletion() {
+    List<String> order = new ArrayList<>();
+    registry.keepSynced(
+        LOCATION,
+        "plain",
+        true,
+        () -> {
+          order.add("sdk");
+          order.add("promise");
+        });
+    assertEquals(Arrays.asList("sdk", "promise"), order);
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlight_waitsForItInCallOrder() {
+    registry.beginNativeGet(LOCATION);
+    keepSynced(LOCATION, "plain", true);
+    keepSynced(LOCATION, "limitToLast(1)", true);
+    keepSynced(LOCATION, "plain", false);
+    assertTrue(applied.isEmpty());
+
+    registry.endNativeGet(LOCATION);
+    assertEquals(Arrays.asList("plain=true", "limitToLast(1)=true", "plain=false"), applied);
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlight_runsEachApplyBeforeItsCallerCompletion() {
+    List<String> order = new ArrayList<>();
+    registry.beginNativeGet(LOCATION);
+    registry.keepSynced(
+        LOCATION,
+        "plain",
+        true,
+        () -> {
+          order.add("sdk-true");
+          order.add("promise-true");
+        });
+    registry.keepSynced(
+        LOCATION,
+        "plain",
+        false,
+        () -> {
+          order.add("sdk-false");
+          order.add("promise-false");
+        });
+    assertTrue(order.isEmpty());
+
+    registry.endNativeGet(LOCATION);
+    assertEquals(Arrays.asList("sdk-true", "promise-true", "sdk-false", "promise-false"), order);
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlight_makesLaterGetsUseOnce() {
+    registry.beginNativeGet(LOCATION);
+    keepSynced(LOCATION, "plain", true);
+    assertFalse(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlightAtOtherLocation_appliesNow() {
+    registry.beginNativeGet(OTHER_LOCATION);
+    keepSynced(LOCATION, "plain", true);
+    assertEquals(Collections.singletonList("plain=true"), applied);
+  }
+
+  @Test
+  public void endNativeGet_waitsForTheLastGetAtLocation() {
+    registry.beginNativeGet(LOCATION);
+    registry.beginNativeGet(LOCATION);
+    keepSynced(LOCATION, "plain", true);
+
+    registry.endNativeGet(LOCATION);
+    assertTrue(applied.isEmpty());
+    registry.endNativeGet(LOCATION);
+    assertEquals(Collections.singletonList("plain=true"), applied);
+
+    keepSynced(LOCATION, "plain", false);
+    assertEquals(Arrays.asList("plain=true", "plain=false"), applied);
+  }
+}

package/android/src/test/java/io/invertase/firebase/database/RNFBDatabaseListenerRegistryTest.java

@@ -0,0 +1,191 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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.junit.Assert.fail;
+
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import org.junit.Test;
+
+public class RNFBDatabaseListenerRegistryTest {
+
+  @Test
+  public void putValueGetTake_happyPath() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    Object listener = new Object();
+    registry.putValue("k", listener);
+    assertSame(listener, registry.getValue("k"));
+    assertSame(listener, registry.takeValue("k"));
+    assertNull(registry.getValue("k"));
+    assertFalse(registry.hasListeners());
+  }
+
+  @Test
+  public void putChildGetTake_happyPath() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    Object listener = new Object();
+    registry.putChild("k", listener);
+    assertSame(listener, registry.getChild("k"));
+    assertSame(listener, registry.takeChild("k"));
+    assertNull(registry.getChild("k"));
+    assertFalse(registry.hasListeners());
+  }
+
+  @Test
+  public void putValue_occupiedId_throwsCollision() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    Object first = new Object();
+    registry.putValue("k", first);
+    try {
+      registry.putValue("k", new Object());
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("k"));
+      assertSame(first, registry.getValue("k"));
+    }
+  }
+
+  @Test
+  public void putChild_occupiedId_throwsCollision() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    Object first = new Object();
+    registry.putChild("k", first);
+    try {
+      registry.putChild("k", new Object());
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("k"));
+      assertSame(first, registry.getChild("k"));
+    }
+  }
+
+  @Test
+  public void putValue_nullListener_throws() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    try {
+      registry.putValue("k", null);
+      fail("expected NullPointerException");
+    } catch (NullPointerException e) {
+      assertEquals("listener", e.getMessage());
+      assertFalse(registry.hasListeners());
+    }
+  }
+
+  @Test
+  public void putChild_nullListener_throws() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    try {
+      registry.putChild("k", null);
+      fail("expected NullPointerException");
+    } catch (NullPointerException e) {
+      assertEquals("listener", e.getMessage());
+    }
+  }
+
+  @Test
+  public void takeValue_missingKey_isNoOp() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.takeValue("missing"));
+    assertFalse(registry.hasListeners());
+  }
+
+  @Test
+  public void getValue_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.getValue(null));
+  }
+
+  @Test
+  public void getChild_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.getChild(null));
+  }
+
+  @Test
+  public void takeValue_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.takeValue(null));
+    assertFalse(registry.hasListeners());
+  }
+
+  @Test
+  public void takeChild_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.takeChild(null));
+  }
+
+  @Test
+  public void hasEventListener_nullKey_returnsFalse_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertFalse(registry.hasEventListener(null));
+  }
+
+  @Test
+  public void takeChild_missingKey_isNoOp() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.takeChild("missing"));
+  }
+
+  @Test
+  public void takeAllValuesAndChildren_empty_isNoOp() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertTrue(registry.takeAllValues().isEmpty());
+    assertTrue(registry.takeAllChildren().isEmpty());
+  }
+
+  @Test
+  public void hasEventListener_valueOrChild() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertFalse(registry.hasEventListener("k"));
+    registry.putValue("k", new Object());
+    assertTrue(registry.hasEventListener("k"));
+    registry.takeValue("k");
+    registry.putChild("k", new Object());
+    assertTrue(registry.hasEventListener("k"));
+  }
+
+  @Test
+  public void hasListeners_tracksOccupancyAcrossMaps() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    registry.putValue("v", new Object());
+    registry.putChild("c", new Object());
+    assertTrue(registry.hasListeners());
+    registry.takeAllValues();
+    assertTrue(registry.hasListeners());
+    registry.takeAllChildren();
+    assertFalse(registry.hasListeners());
+  }
+
+  @Test
+  public void takeAll_combinesValueAndChildMaps() throws Exception {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    Object value = new Object();
+    Object child = new Object();
+    registry.putValue("v", value);
+    registry.putChild("c", child);
+    assertEquals(2, registry.takeAll().size());
+    assertFalse(registry.hasListeners());
+    assertNull(registry.getValue("v"));
+    assertNull(registry.getChild("c"));
+  }
+}