WIP: add info.test.ts

Author: jshcrowthe

tests/database/event.test.ts

@@ -31,7 +31,7 @@ function rawPath(firebaseRef) {
  * @param {string=} opt_helperName
  * @return {{waiter: waiter, watchesInitializedWaiter: watchesInitializedWaiter, unregister: unregister, addExpectedEvents: addExpectedEvents}}
  */
-export function eventTestHelper(pathAndEvents, helperName?, eventAccumulator?: EventAccumulator) {
+export function eventTestHelper(pathAndEvents, helperName?, eventAccumulator?: EventAccumulator | EventAccumulator[]) {
   var expectedPathAndEvents = [];
   var actualPathAndEvents = [];
   var pathEventListeners = {};
@@ -43,10 +43,19 @@ export function eventTestHelper(pathAndEvents, helperName?, eventAccumulator?: E
   // appends to actualPathAndEvents.
   var make_eventCallback = function(type) {
     return function(snap) {
-      console.log('evt', type);
       // Get the ref of where the snapshot came from.
       var ref = type === 'value' ? snap.ref : snap.ref.parent;
-      eventAccumulator && eventAccumulator.addEvent && eventAccumulator.addEvent();
+
+      if (eventAccumulator) {
+        if (Array.isArray(eventAccumulator)) {
+          eventAccumulator.forEach(ea => {
+            ea.addEvent();
+          })
+        } else {
+          eventAccumulator.addEvent();
+        }
+      }
+
       actualPathAndEvents.push([rawPath(ref), [type, snap.key]]);
 
       if (!pathEventListeners[ref].initialized) {

tests/database/helpers/events.ts

@@ -170,7 +170,7 @@ export function testAuthTokenProvider(app) {
 let freshRepoId = 1;
 const activeFreshApps = [];
 
-export function getFreshRepo(url, path) {
+export function getFreshRepo(url, path?) {
   var app = firebase.initializeApp({databaseURL: url}, 'ISOLATED_REPO_' + freshRepoId++);
   patchFakeAuthFunctions(app);
   activeFreshApps.push(app);
@@ -210,4 +210,4 @@ export function buildObjFromKey(key) {
     parent = parent[key];
   }
   return obj;
-};
+};

tests/database/helpers/util.ts

@@ -0,0 +1,162 @@
+import { expect } from "chai";
+import { 
+  getFreshRepo,
+  getRootNode,
+  getRandomNode,
+  getPath
+} from "./helpers/util";
+import { Reference } from "../../src/database/api/Reference";
+import { EventAccumulator } from "./helpers/EventAccumulator";
+
+describe.only(".info Tests", function () {
+  it("Can get a reference to .info nodes.", function() {
+    var f = (getRootNode() as Reference);
+    expect(getPath(f.child('.info'))).to.equal('/.info');
+    expect(getPath(f.child('.info/foo'))).to.equal('/.info/foo');
+  });
+
+  it("Can't write to .info", function() {
+    var f = (getRootNode() as Reference).child('.info');
+    expect(function() {f.set('hi');}).to.throw;
+    expect(function() {f.setWithPriority('hi', 5);}).to.throw;
+    expect(function() {f.setPriority('hi');}).to.throw;
+    expect(function() {f.transaction(function() { });}).to.throw;
+    expect(function() {f.push();}).to.throw;
+    expect(function() {f.remove();}).to.throw;
+
+    expect(function() {f.child('test').set('hi');}).to.throw;
+    var f2 = f.child('foo/baz');
+    expect(function() {f2.set('hi');}).to.throw;
+  });
+
+  it("Can watch .info/connected.", function (done) {
+    var f = (getRandomNode() as Reference).root;
+    f.child('.info/connected').on('value', function(snap) {
+      if (snap.val() === true) done();
+    });
+  });
+
+
+  it('.info/connected correctly goes to false when disconnected.', async function() {
+    var f = (getRandomNode() as Reference).root;
+    var everConnected = false;
+    var connectHistory = '';
+
+    const ea = new EventAccumulator(() => everConnected);
+    f.child('.info/connected').on('value', function(snap) {
+      if (snap.val() === true)
+        everConnected = true;
+
+      if (everConnected)
+        connectHistory += snap.val() + ',';
+      ea.addEvent();
+    });
+
+    await ea.promise;
+
+    ea.reset(() => connectHistory);
+    f.database.goOffline();
+    f.database.goOnline();
+
+    return ea.promise;
+  });
+
+  it(".info/serverTimeOffset", async function() {
+    var ref = (getRootNode() as Reference);
+
+    // make sure push works
+    var child = ref.push();
+
+    var offsets = [];
+
+    const ea = new EventAccumulator(() => offsets.length === 1);
+
+    ref.child('.info/serverTimeOffset').on('value', function(snap) {
+      offsets.push(snap.val());
+      ea.addEvent();
+    });
+
+    await ea.promise;
+
+    expect(typeof offsets[0]).to.equal('number');
+    expect(offsets[0]).not.to.be.greaterThan(0);
+
+    // Make sure push still works
+    ref.push();
+    ref.child('.info/serverTimeOffset').off();
+  });
+
+  it.skip("database.goOffline() / database.goOnline() connection management", function() {
+    var ref = getFreshRepo(TEST_NAMESPACE);
+    var refAlt = getFreshRepo(TEST_ALT_NAMESPACE);
+    var ready;
+
+    // Wait until we're connected to both Firebases
+    runs(function() {
+      ready = 0;
+      var eventHandler = function(snap) {
+        if (snap.val() === true) {
+          snap.ref.off();
+          ready += 1;
+        }
+      };
+      ref.child(".info/connected").on("value", eventHandler);
+      refAlt.child(".info/connected").on("value", eventHandler);
+    });
+    waitsFor(function() { return (ready == 2); });
+
+    runs(function() {
+      ref.database.goOffline();
+      refAlt.database.goOffline();
+    });
+
+    // Ensure we're disconnected from both Firebases
+    runs(function() {
+      ready = 0;
+      var eventHandler = function(snap) {
+        expect(snap.val() === false);
+        ready += 1;
+      }
+      ref.child(".info/connected").once("value", eventHandler);
+      refAlt.child(".info/connected").once("value", eventHandler);
+    });
+    waitsFor(function() { return (ready == 2); });
+
+    // Ensure that we don't automatically reconnect upon Reference creation
+    runs(function() {
+      ready = 0;
+      var refDup = ref.database.ref();
+      refDup.child(".info/connected").on("value", function(snap) {
+        ready = (snap.val() === true) || ready;
+      });
+      setTimeout(function() {
+        expect(ready).to.equal(0);
+        refDup.child(".info/connected").off();
+        ready = -1;
+      }, 500);
+    });
+    waitsFor(function() { return ready == -1; });
+
+    runs(function() {
+      ref.database.goOnline();
+      refAlt.database.goOnline();
+    });
+
+    // Ensure we're connected to both Firebases
+    runs(function() {
+      ready = 0;
+      var eventHandler = function(snap) {
+        if (snap.val() === true) {
+          snap.ref.off();
+          ready += 1;
+        }
+      };
+      ref.child(".info/connected").on("value", eventHandler);
+      refAlt.child(".info/connected").on("value", eventHandler);
+    });
+
+    waitsFor(function() {
+      return (ready == 2);
+    });
+  });
+});