[tests][database] start of database tests

bridge/e2e/database/snapshot.e2e.js

@@ -0,0 +1,131 @@
+const { setDatabaseContents } = TestHelpers.database;
+
+describe('database()', () => {
+  describe('Snapshot', () => {
+    before(() => setDatabaseContents());
+
+    it('should provide a functioning val() method', async () => {
+      const { Array } = bridge.context.window;
+      const snapshot = await firebase
+        .database()
+        .ref('tests/types/array')
+        .once('value');
+
+      snapshot.val.should.be.a.Function();
+      // eslint-disable-next-line
+      snapshot.val().should.eql(new Array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
+    });
+
+    it('should provide a functioning child() method', async () => {
+      const snapshot = await firebase
+        .database()
+        .ref('tests/types/array')
+        .once('value');
+
+      snapshot.child('0').val.should.be.a.Function();
+      snapshot
+        .child('0')
+        .val()
+        .should.equal(0);
+      snapshot.child('0').key.should.be.a.String();
+      snapshot.child('0').key.should.equal('0');
+    });
+
+    // TODO refactor
+    // it('should provide a functioning hasChild() method', () =>
+    //   new Promise((resolve, reject) => {
+    //     const successCb = tryCatch(snapshot => {
+    //       snapshot.hasChild.should.be.a.Function();
+    //       snapshot.hasChild('foo').should.equal(true);
+    //       snapshot.hasChild('baz').should.equal(false);
+    //       resolve();
+    //     }, reject);
+
+    //     firebase
+    //       .database()
+    //       .ref('tests/types/object')
+    //       .once('value', successCb, reject);
+    //   }));
+
+    // it('should provide a functioning hasChildren() method', () =>
+    //   new Promise((resolve, reject) => {
+    //     const successCb = tryCatch(snapshot => {
+    //       snapshot.hasChildren.should.be.a.Function();
+    //       snapshot.hasChildren().should.equal(true);
+    //       snapshot
+    //         .child('foo')
+    //         .hasChildren()
+    //         .should.equal(false);
+    //       resolve();
+    //     }, reject);
+
+    //     firebase
+    //       .database()
+    //       .ref('tests/types/object')
+    //       .once('value', successCb, reject);
+    //   }));
+
+    // it('should provide a functioning exists() method', () =>
+    //   new Promise((resolve, reject) => {
+    //     const successCb = tryCatch(snapshot => {
+    //       snapshot.exists.should.be.a.Function();
+    //       snapshot.exists().should.equal(false);
+    //       resolve();
+    //     }, reject);
+
+    //     firebase
+    //       .database()
+    //       .ref('tests/types/object/baz/daz')
+    //       .once('value', successCb, reject);
+    //   }));
+
+    // it('should provide a functioning getPriority() method', () =>
+    //   new Promise((resolve, reject) => {
+    //     const successCb = tryCatch(snapshot => {
+    //       snapshot.getPriority.should.be.a.Function();
+    //       snapshot.getPriority().should.equal(666);
+    //       snapshot.val().should.eql({ foo: 'bar' });
+    //       resolve();
+    //     }, reject);
+
+    //     const ref = firebase.database().ref('tests/priority');
+    //     ref.once('value', successCb, reject);
+    //   }));
+
+    // it('should provide a functioning forEach() method', () =>
+    //   // TODO this doesn't really test that the key order returned is in correct order
+    //   new Promise((resolve, reject) => {
+    //     const successCb = tryCatch(snapshot => {
+    //       let total = 0;
+    //       snapshot.forEach.should.be.a.Function();
+    //       snapshot.forEach(childSnapshot => {
+    //         const val = childSnapshot.val();
+    //         total += val;
+    //         return val === 3; // stop iteration after key 3
+    //       });
+
+    //       total.should.equal(6); // 0 + 1 + 2 + 3 = 6
+    //       resolve();
+    //     }, reject);
+
+    //     firebase
+    //       .database()
+    //       .ref('tests/types/array')
+    //       .once('value', successCb, reject);
+    //   }));
+
+    // it('should provide a key property', () =>
+    //   new Promise((resolve, reject) => {
+    //     const successCb = tryCatch(snapshot => {
+    //       snapshot.key.should.be.a.String();
+    //       snapshot.key.should.equal('array');
+    //       resolve();
+    //     }, reject);
+
+    //     firebase
+    //       .database()
+    //       .ref('tests/types/array')
+    //       .once('value', successCb, reject);
+    //   }));
+  });
+});

bridge/e2e/database/transactions.e2e.js

@@ -0,0 +1,34 @@
+const { setDatabaseContents } = TestHelpers.database;
+
+describe('database()', () => {
+  before(() => setDatabaseContents());
+  // TODO use testRunId in refs to prevent multiple test instances interfering with each other
+  describe('ref.transaction()', () => {
+    it('increments a value', async () => {
+      let valueBefore = 1;
+      const ref = firebase.database().ref('tests/transaction');
+
+      const { committed, snapshot } = await ref.transaction(currentData => {
+        if (currentData === null) {
+          return valueBefore + 10;
+        }
+        valueBefore = currentData;
+        return valueBefore + 10;
+      }, true);
+
+      should.equal(committed, true, 'Transaction did not commit.');
+      snapshot.val().should.equal(valueBefore + 10);
+    });
+
+    it('aborts if undefined returned', async () => {
+      const ref = firebase.database().ref('tests/transaction');
+
+      const { committed } = await ref.transaction(() => undefined, true);
+      should.equal(
+        committed,
+        false,
+        'Transaction committed and did not abort.'
+      );
+    });
+  });
+});