@firebase/database-compat 0.1.1-2021823172527 → 0.1.2-canary.0b3ca78eb

package/test/helpers/events.ts

@@ -1,258 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file 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 { pathParent } from '../../../database/src/core/util/Path';
-import { Reference } from '../../src/api/Reference';
-
-import { TEST_PROJECT } from './util';
-
-/**
- * A set of functions to clean up event handlers.
- */
-export let eventCleanupHandlers = [];
-
-/** Clean up outstanding event handlers */
-export function eventCleanup() {
-  for (let i = 0; i < eventCleanupHandlers.length; ++i) {
-    eventCleanupHandlers[i]();
-  }
-  eventCleanupHandlers = [];
-}
-
-/**
- * The path component of the firebaseRef url
- */
-function rawPath(firebaseRef: Reference) {
-  return firebaseRef.toString().replace(TEST_PROJECT.databaseURL, '');
-}
-
-/**
- * Creates a struct which waits for many events.
- * @param pathAndEvents - an array of tuples of [Firebase, [event type strings]]
- */
-export function eventTestHelper(pathAndEvents, helperName?) {
-  let resolve, reject;
-  let promise = new Promise((pResolve, pReject) => {
-    resolve = pResolve;
-    reject = pReject;
-  });
-  let resolveInit, rejectInit;
-  const initPromise = new Promise((pResolve, pReject) => {
-    resolveInit = pResolve;
-    rejectInit = pReject;
-  });
-  const expectedPathAndEvents = [];
-  const actualPathAndEvents = [];
-  const pathEventListeners = {};
-  let initializationEvents = 0;
-
-  helperName = helperName ? helperName + ': ' : '';
-
-  // Listen on all of the required paths, with a callback function that just
-  // appends to actualPathAndEvents.
-  const makeEventCallback = function (type) {
-    return function (snap) {
-      // Get the ref of where the snapshot came from.
-      const ref = type === 'value' ? snap.ref : pathParent(this);
-
-      actualPathAndEvents.push([rawPath(ref), [type, snap.key]]);
-
-      if (!pathEventListeners[ref].initialized) {
-        initializationEvents++;
-        if (type === 'value') {
-          pathEventListeners[ref].initialized = true;
-        }
-      } else {
-        // Call waiter here to trigger exceptions when the event is fired, rather than later when the
-        // test framework is calling the waiter...  makes for easier debugging.
-        waiter();
-      }
-
-      // We want to trigger the promise resolution if valid, so try to call waiter as events
-      // are coming back.
-      try {
-        if (waiter()) {
-          resolve();
-        }
-      } catch (e) {}
-    };
-  };
-
-  // returns a function which indicates whether the events have been received
-  // in the correct order.  If anything is wrong (too many events or
-  // incorrect events, we throw).  Else we return false, indicating we should
-  // keep waiting.
-  const waiter = function () {
-    const pathAndEventToString = function (pathAndEvent) {
-      return (
-        '{path: ' +
-        pathAndEvent[0] +
-        ', event:[' +
-        pathAndEvent[1][0] +
-        ', ' +
-        pathAndEvent[1][1] +
-        ']}'
-      );
-    };
-
-    let i = 0;
-    while (i < expectedPathAndEvents.length && i < actualPathAndEvents.length) {
-      const expected = expectedPathAndEvents[i];
-      const actual = actualPathAndEvents[i];
-
-      if (
-        expected[0] !== actual[0] ||
-        expected[1][0] !== actual[1][0] ||
-        expected[1][1] !== actual[1][1]
-      ) {
-        throw (
-          helperName +
-          'Event ' +
-          i +
-          ' incorrect. Expected: ' +
-          pathAndEventToString(expected) +
-          ' Actual: ' +
-          pathAndEventToString(actual)
-        );
-      }
-      i++;
-    }
-
-    if (expectedPathAndEvents.length < actualPathAndEvents.length) {
-      throw (
-        helperName +
-        "Extra event detected '" +
-        pathAndEventToString(actualPathAndEvents[i]) +
-        "'."
-      );
-    }
-
-    // If we haven't thrown and both arrays are the same length, then we're
-    // done.
-    return expectedPathAndEvents.length === actualPathAndEvents.length;
-  };
-
-  const listenOnPath = function (path) {
-    const valueCB = makeEventCallback('value');
-    const addedCB = makeEventCallback('child_added');
-    const removedCB = makeEventCallback('child_removed');
-    const movedCB = makeEventCallback('child_moved');
-    const changedCB = makeEventCallback('child_changed');
-    path.on('child_removed', removedCB);
-    path.on('child_added', addedCB);
-    path.on('child_moved', movedCB);
-    path.on('child_changed', changedCB);
-    path.on('value', valueCB);
-    return function () {
-      path.off('child_removed', removedCB);
-      path.off('child_added', addedCB);
-      path.off('child_moved', movedCB);
-      path.off('child_changed', changedCB);
-      path.off('value', valueCB);
-    };
-  };
-
-  const addExpectedEvents = function (pathAndEvents) {
-    const pathsToListenOn = [];
-    for (let i = 0; i < pathAndEvents.length; i++) {
-      const pathAndEvent = pathAndEvents[i];
-
-      const path = pathAndEvent[0];
-      //var event = pathAndEvent[1];
-
-      pathsToListenOn.push(path);
-
-      pathAndEvent[0] = rawPath(path);
-
-      if (pathAndEvent[1][0] === 'value') {
-        pathAndEvent[1][1] = path.key;
-      }
-
-      expectedPathAndEvents.push(pathAndEvent);
-    }
-
-    // There's some trickiness with event order depending on the order you attach event callbacks:
-    //
-    // When you listen on a/b/c, a/b, and a, we dedupe that to just listening on a.  But if you do it in that
-    // order, we'll send "listen a/b/c, listen a/b, unlisten a/b/c, listen a, unlisten a/b" which will result in you
-    // getting events something like "a/b/c: value, a/b: child_added c, a: child_added b, a/b: value, a: value"
-    //
-    // BUT, if all of the listens happen before you are connected to firebase (e.g. this is the first test you're
-    // running), the dedupe will have taken affect and we'll just send "listen a", which results in:
-    // "a/b/c: value, a/b: child_added c, a/b: value, a: child_added b, a: value"
-    // Notice the 3rd and 4th events are swapped.
-    // To mitigate this, we re-ordeer your event registrations and do them in order of shortest path to longest.
-
-    pathsToListenOn.sort((a, b) => {
-      return a.toString().length - b.toString().length;
-    });
-    for (let i = 0; i < pathsToListenOn.length; i++) {
-      const path = pathsToListenOn[i];
-      if (!pathEventListeners[path.toString()]) {
-        pathEventListeners[path.toString()] = {};
-        pathEventListeners[path.toString()].initialized = false;
-        pathEventListeners[path.toString()].unlisten = listenOnPath(path);
-      }
-    }
-
-    promise = new Promise((pResolve, pReject) => {
-      resolve = pResolve;
-      reject = pReject;
-    });
-  };
-
-  addExpectedEvents(pathAndEvents);
-
-  const watchesInitializedWaiter = function () {
-    for (const path in pathEventListeners) {
-      if (!pathEventListeners[path].initialized) {
-        return false;
-      }
-    }
-
-    // Remove any initialization events.
-    actualPathAndEvents.splice(
-      actualPathAndEvents.length - initializationEvents,
-      initializationEvents
-    );
-    initializationEvents = 0;
-
-    resolveInit();
-    return true;
-  };
-
-  const unregister = function () {
-    for (const path in pathEventListeners) {
-      if (pathEventListeners.hasOwnProperty(path)) {
-        pathEventListeners[path].unlisten();
-      }
-    }
-  };
-
-  eventCleanupHandlers.push(unregister);
-  return {
-    promise,
-    initPromise,
-    waiter,
-    watchesInitializedWaiter,
-    unregister,
-
-    addExpectedEvents(moreEvents) {
-      addExpectedEvents(moreEvents);
-    }
-  };
-}

package/test/helpers/util.ts

@@ -1,177 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file 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.
- */
-
-declare let MozWebSocket: WebSocket;
-
-import '../../src/index';
-
-import firebase from '@firebase/app-compat';
-import { _FirebaseNamespace } from '@firebase/app-types/private';
-import { Component, ComponentType } from '@firebase/component';
-
-import { Path } from '../../../database/src/core/util/Path';
-import { Query, Reference } from '../../src/api/Reference';
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-export const TEST_PROJECT = require('../../../../config/project.json');
-
-const EMULATOR_PORT = process.env.RTDB_EMULATOR_PORT;
-const EMULATOR_NAMESPACE = process.env.RTDB_EMULATOR_NAMESPACE;
-
-const USE_EMULATOR = !!EMULATOR_PORT;
-
-/*
- * When running against the emulator, the hostname will be "localhost" rather
- * than "<namespace>.firebaseio.com", and so we need to append the namespace
- * as a query param.
- *
- * Some tests look for hostname only while others need full url (with the
- * namespace provided as a query param), hence below declarations.
- */
-export const DATABASE_ADDRESS = USE_EMULATOR
-  ? `http://localhost:${EMULATOR_PORT}`
-  : TEST_PROJECT.databaseURL;
-
-export const DATABASE_URL = USE_EMULATOR
-  ? `${DATABASE_ADDRESS}?ns=${EMULATOR_NAMESPACE}`
-  : TEST_PROJECT.databaseURL;
-
-console.log(`USE_EMULATOR: ${USE_EMULATOR}. DATABASE_URL: ${DATABASE_URL}.`);
-
-let numDatabases = 0;
-
-// mock authentication functions for testing
-(firebase as unknown as _FirebaseNamespace).INTERNAL.registerComponent(
-  new Component(
-    'auth-internal',
-    () => ({
-      getToken: async () => null,
-      addAuthTokenListener: () => {},
-      removeAuthTokenListener: () => {},
-      getUid: () => null
-    }),
-    ComponentType.PRIVATE
-  )
-);
-
-export function createTestApp() {
-  const app = firebase.initializeApp({ databaseURL: DATABASE_URL });
-  return app;
-}
-
-/**
- * Gets or creates a root node to the test namespace. All calls sharing the
- * value of opt_i will share an app context.
- */
-export function getRootNode(i = 0, ref?: string) {
-  if (i + 1 > numDatabases) {
-    numDatabases = i + 1;
-  }
-  let app;
-  try {
-    app = firebase.app('TEST-' + i);
-  } catch (e) {
-    app = firebase.initializeApp({ databaseURL: DATABASE_URL }, 'TEST-' + i);
-  }
-  const db = app.database();
-  return db.ref(ref);
-}
-
-/**
- * Create multiple refs to the same top level
- * push key - each on it's own Firebase.Context.
- */
-export function getRandomNode(numNodes?): Reference | Reference[] {
-  if (numNodes === undefined) {
-    return getRandomNode(1)[0] as Reference;
-  }
-
-  let child;
-  const nodeList = [];
-  for (let i = 0; i < numNodes; i++) {
-    const ref = getRootNode(i);
-    if (child === undefined) {
-      child = ref.push().key;
-    }
-
-    nodeList[i] = ref.child(child);
-  }
-
-  return nodeList as Reference[];
-}
-
-export function getQueryValue(query: Query) {
-  return query.once('value').then(snap => snap.val());
-}
-
-export function pause(milliseconds: number) {
-  return new Promise<void>(resolve => {
-    setTimeout(() => resolve(), milliseconds);
-  });
-}
-
-export function getPath(query: Query) {
-  return query.toString().replace(DATABASE_ADDRESS, '');
-}
-
-export function shuffle(arr, randFn = Math.random) {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(randFn() * (i + 1));
-    const tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
-  }
-}
-
-let freshRepoId = 1;
-const activeFreshApps = [];
-
-export function getFreshRepo(path: Path) {
-  const app = firebase.initializeApp(
-    { databaseURL: DATABASE_URL },
-    'ISOLATED_REPO_' + freshRepoId++
-  );
-  activeFreshApps.push(app);
-  return (app as any).database().ref(path.toString());
-}
-
-export function getFreshRepoFromReference(ref) {
-  const host = ref.root.toString();
-  const path = ref.toString().replace(host, '');
-  return getFreshRepo(path);
-}
-
-// Little helpers to get the currently cached snapshot / value.
-export function getSnap(path) {
-  let snap;
-  const callback = function (snapshot) {
-    snap = snapshot;
-  };
-  path.once('value', callback);
-  return snap;
-}
-
-export function getVal(path) {
-  const snap = getSnap(path);
-  return snap ? snap.val() : undefined;
-}
-
-export function canCreateExtraConnections() {
-  return (
-    typeof MozWebSocket !== 'undefined' || typeof WebSocket !== 'undefined'
-  );
-}

package/test/info.test.ts

@@ -1,222 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file 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 { expect } from 'chai';
-
-import { EventAccumulator } from '../../database/test/helpers/EventAccumulator';
-import { Reference } from '../src/api/Reference';
-
-import {
-  getFreshRepo,
-  getRootNode,
-  getRandomNode,
-  getPath
-} from './helpers/util';
-
-/**
- * We have a test that depends on leveraging two properly
- * configured Firebase instances. we are skiping the test
- * but I want to leave the test here for when we can refactor
- * to remove the prod firebase dependency.
- */
-declare const runs;
-declare const waitsFor;
-declare const TEST_ALT_NAMESPACE;
-declare const TEST_NAMESPACE;
-
-describe('.info Tests', function () {
-  this.timeout(3000);
-  it('Can get a reference to .info nodes.', () => {
-    const 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", () => {
-    const f = (getRootNode() as Reference).child('.info');
-    expect(() => {
-      f.set('hi');
-    }).to.throw;
-    expect(() => {
-      f.setWithPriority('hi', 5);
-    }).to.throw;
-    expect(() => {
-      f.setPriority('hi');
-    }).to.throw;
-    expect(() => {
-      f.transaction(() => {});
-    }).to.throw;
-    expect(() => {
-      f.push();
-    }).to.throw;
-    expect(() => {
-      f.remove();
-    }).to.throw;
-
-    expect(() => {
-      f.child('test').set('hi');
-    }).to.throw;
-    const f2 = f.child('foo/baz');
-    expect(() => {
-      f2.set('hi');
-    }).to.throw;
-  });
-
-  it('Can watch .info/connected.', () => {
-    return new Promise<void>(resolve => {
-      const f = (getRandomNode() as Reference).root;
-      f.child('.info/connected').on('value', snap => {
-        if (snap.val() === true) {
-          resolve();
-        }
-      });
-    });
-  });
-
-  it('.info/connected correctly goes to false when disconnected.', async () => {
-    const f = (getRandomNode() as Reference).root;
-    let everConnected = false;
-    let connectHistory = '';
-
-    const ea = new EventAccumulator(() => everConnected);
-    f.child('.info/connected').on('value', 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 () => {
-    const ref = getRootNode() as Reference;
-
-    // make sure push works
-    const child = ref.push();
-
-    const offsets = [];
-
-    const ea = new EventAccumulator(() => offsets.length === 1);
-
-    ref.child('.info/serverTimeOffset').on('value', 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', () => {
-    // NOTE: getFreshRepo() no longer takes a hostname, so this test needs to be reworked.
-    // Need to figure out how to re-enable this test.
-    const ref = getFreshRepo(TEST_NAMESPACE);
-    const refAlt = getFreshRepo(TEST_ALT_NAMESPACE);
-    let ready;
-
-    // Wait until we're connected to both Firebases
-    runs(() => {
-      ready = 0;
-      const 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(() => {
-      return ready === 2;
-    });
-
-    runs(() => {
-      ref.database.goOffline();
-      refAlt.database.goOffline();
-    });
-
-    // Ensure we're disconnected from both Firebases
-    runs(() => {
-      ready = 0;
-      const eventHandler = function (snap) {
-        expect(snap.val() === false);
-        ready += 1;
-      };
-      ref.child('.info/connected').once('value', eventHandler);
-      refAlt.child('.info/connected').once('value', eventHandler);
-    });
-    waitsFor(() => {
-      return ready === 2;
-    });
-
-    // Ensure that we don't automatically reconnect upon Reference creation
-    runs(() => {
-      ready = 0;
-      const refDup = ref.database.ref();
-      refDup.child('.info/connected').on('value', snap => {
-        ready = snap.val() === true || ready;
-      });
-      setTimeout(() => {
-        expect(ready).to.equal(0);
-        refDup.child('.info/connected').off();
-        ready = -1;
-      }, 500);
-    });
-    waitsFor(() => {
-      return ready === -1;
-    });
-
-    runs(() => {
-      ref.database.goOnline();
-      refAlt.database.goOnline();
-    });
-
-    // Ensure we're connected to both Firebases
-    runs(() => {
-      ready = 0;
-      const 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(() => {
-      return ready === 2;
-    });
-  });
-});