Merge remote-tracking branch 'upstream/master'

# Conflicts: # ios/RNFirebase/RNFirebase.h # ios/RNFirebase/RNFirebaseAnalytics.h # ios/RNFirebase/RNFirebaseAuth.h # ios/RNFirebase/RNFirebaseCrash.h # ios/RNFirebase/RNFirebaseDatabase.h # ios/RNFirebase/RNFirebaseErrors.h # ios/RNFirebase/RNFirebaseMessaging.h # ios/RNFirebase/RNFirebaseStorage.h
2017-05-14 14:30:10 +02:00 · 2017-05-14 14:30:10 +02:00 · db792b8857
parent c35ed6f49d 019ce793a9
commit db792b8857
50 changed files with 1905 additions and 512 deletions
--- a/README.md
+++ b/README.md
@ -4,6 +4,7 @@
 [![Gitter](https://badges.gitter.im/invertase/react-native-firebase.svg)](https://gitter.im/invertase/react-native-firebase?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 [![npm version](https://img.shields.io/npm/v/react-native-firebase.svg)](https://www.npmjs.com/package/react-native-firebase)
 [![License](https://img.shields.io/npm/l/react-native-firebase.svg)](/LICENSE)
+[![Donate](https://img.shields.io/badge/Donate-Patreon-green.svg)](https://www.patreon.com/invertase)

 **RNFirebase** makes using [Firebase](http://firebase.com) with React Native simple.

--- a/android/src/main/java/io/invertase/firebase/RNFirebaseModule.java
+++ b/android/src/main/java/io/invertase/firebase/RNFirebaseModule.java
@ -1,5 +1,7 @@
 package io.invertase.firebase;

+import android.app.Activity;
+
 import java.util.Map;
 import java.util.HashMap;

@ -34,7 +36,10 @@ public class RNFirebaseModule extends ReactContextBaseJavaModule implements Life
    int status = gapi.isGooglePlayServicesAvailable(getReactApplicationContext());

    if (status != ConnectionResult.SUCCESS && gapi.isUserResolvableError(status)) {
-      gapi.getErrorDialog(getCurrentActivity(), status, 2404).show();
+      Activity activity = getCurrentActivity();
+      if (activity != null) {
+        gapi.getErrorDialog(activity, status, 2404).show();
+      }
    }
  }

--- a/android/src/main/java/io/invertase/firebase/Utils.java
+++ b/android/src/main/java/io/invertase/firebase/Utils.java
@ -216,12 +216,12 @@ public class Utils {
   * @return
   */
  private static boolean isArray(DataSnapshot snapshot) {
-    long expectedKey = 0;
+    long expectedKey = -1;
    for (DataSnapshot child : snapshot.getChildren()) {
      try {
        long key = Long.parseLong(child.getKey());
-        if (key == expectedKey) {
-          expectedKey++;
+        if (key > expectedKey) {
+          expectedKey = key;
        } else {
          return false;
        }
@ -238,11 +238,11 @@ public class Utils {
   * @return
   */
  private static boolean isArray(MutableData mutableData) {
-    long expectedKey = 0;
+    long expectedKey = -1;
    for (MutableData child : mutableData.getChildren()) {
      try {
        long key = Long.parseLong(child.getKey());
-        if (key == expectedKey) {
+        if (key > expectedKey) {
          expectedKey++;
        } else {
          return false;
@ -261,8 +261,16 @@ public class Utils {
   * @return
   */
  private static <Any> WritableArray buildArray(DataSnapshot snapshot) {
+    long expectedKey = 0;
    WritableArray array = Arguments.createArray();
    for (DataSnapshot child : snapshot.getChildren()) {
+      long key = Long.parseLong(child.getKey());
+      if (key > expectedKey) {
+        for (long i = expectedKey; i < key; i++) {
+          array.pushNull();
+        }
+        expectedKey = key;
+      }
      Any castedChild = castValue(child);
      switch (castedChild.getClass().getName()) {
        case "java.lang.Boolean":
@ -288,6 +296,7 @@ public class Utils {
          Log.w(TAG, "Invalid type: " + castedChild.getClass().getName());
          break;
      }
+      expectedKey++;
    }
    return array;
  }
@ -299,8 +308,16 @@ public class Utils {
   * @return
   */
  private static <Any> WritableArray buildArray(MutableData mutableData) {
+    long expectedKey = 0;
    WritableArray array = Arguments.createArray();
    for (MutableData child : mutableData.getChildren()) {
+      long key = Long.parseLong(child.getKey());
+      if (key > expectedKey) {
+        for (long i = expectedKey; i < key; i++) {
+          array.pushNull();
+        }
+        expectedKey = key;
+      }
      Any castedChild = castValue(child);
      switch (castedChild.getClass().getName()) {
        case "java.lang.Boolean":
@ -326,6 +343,7 @@ public class Utils {
          Log.w(TAG, "Invalid type: " + castedChild.getClass().getName());
          break;
      }
+      expectedKey++;
    }
    return array;
  }
--- a/android/src/main/java/io/invertase/firebase/auth/RNFirebaseAuth.java
+++ b/android/src/main/java/io/invertase/firebase/auth/RNFirebaseAuth.java
@ -4,6 +4,7 @@ import android.util.Log;
 import android.net.Uri;
 import android.support.annotation.NonNull;

+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

@ -12,6 +13,7 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReactContext;
@ -25,6 +27,7 @@ import com.google.firebase.auth.AuthCredential;
 import com.google.firebase.auth.AuthResult;
 import com.google.firebase.auth.GithubAuthProvider;
 import com.google.firebase.auth.TwitterAuthProvider;
+import com.google.firebase.auth.UserInfo;
 import com.google.firebase.auth.UserProfileChangeRequest;
 import com.google.firebase.auth.FacebookAuthProvider;
 import com.google.firebase.auth.FirebaseAuth;
@ -739,6 +742,35 @@ public class RNFirebaseAuth extends ReactContextBaseJavaModule {
  }


+  /**
+   * Converts a List of UserInfo instances into the correct format to match the web sdk
+   * @param providerData List<UserInfo> user.getProviderData()
+   * @return WritableArray array
+   */
+  private WritableArray convertProviderData(List<? extends UserInfo> providerData) {
+    WritableArray output = Arguments.createArray();
+    for (UserInfo userInfo : providerData) {
+      WritableMap userInfoMap = Arguments.createMap();
+      userInfoMap.putString("providerId", userInfo.getProviderId());
+      userInfoMap.putString("uid", userInfo.getUid());
+      userInfoMap.putString("displayName", userInfo.getDisplayName());
+
+      final Uri photoUrl = userInfo.getPhotoUrl();
+
+      if (photoUrl != null) {
+        userInfoMap.putString("photoURL", photoUrl.toString());
+      } else {
+        userInfoMap.putNull("photoURL");
+      }
+
+      userInfoMap.putString("email", userInfo.getEmail());
+
+      output.pushMap(userInfoMap);
+    }
+
+    return output;
+  }
+
  /**
   * firebaseUserToMap
   *
@ -778,7 +810,7 @@ public class RNFirebaseAuth extends ReactContextBaseJavaModule {
      userMap.putNull("photoURL");
    }

-    // todo providerData
+    userMap.putArray("providerData", convertProviderData(user.getProviderData()));

    return userMap;
  }
--- a/android/src/main/java/io/invertase/firebase/database/RNFirebaseDatabase.java
+++ b/android/src/main/java/io/invertase/firebase/database/RNFirebaseDatabase.java
@ -28,6 +28,7 @@ import com.google.firebase.database.OnDisconnect;
 import com.google.firebase.database.DatabaseError;
 import com.google.firebase.database.DatabaseReference;
 import com.google.firebase.database.FirebaseDatabase;
+import com.google.firebase.database.DatabaseException;
 import com.google.firebase.database.Transaction;

 import io.invertase.firebase.Utils;
@ -55,8 +56,8 @@ public class RNFirebaseDatabase extends ReactContextBaseJavaModule {
    final Callback callback) {
    try {
      mFirebaseDatabase.setPersistenceEnabled(enable);
-    } catch (Throwable t) {
-      Log.e(TAG, "FirebaseDatabase setPersistenceEnabled exception", t);
+    } catch (DatabaseException t) {
+
    }

    WritableMap res = Arguments.createMap();
--- a/docs/README.md
+++ b/docs/README.md
@ -10,6 +10,7 @@
 [![Gitter](https://badges.gitter.im/invertase/react-native-firebase.svg)](https://gitter.im/invertase/react-native-firebase?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 [![npm version](https://img.shields.io/npm/v/react-native-firebase.svg)](https://www.npmjs.com/package/react-native-firebase)
 [![License](https://img.shields.io/npm/l/react-native-firebase.svg)](/LICENSE)
+[![Donate](https://img.shields.io/badge/Donate-Patreon-green.svg)](https://www.patreon.com/invertase)
 <br />
 A well tested Firebase implementation for React Native, supporting both iOS & Android apps.
 </div>
--- a/docs/installation-android.md
+++ b/docs/installation-android.md
@ -73,9 +73,9 @@ Add permissions:
  <uses-permission android:name="android.permission.VIBRATE" />
 ```

-Set app [launch mode](https://inthecheesefactory.com/blog/understand-android-activity-launchmode/en) inside application props:
+Set app [launch mode](https://inthecheesefactory.com/blog/understand-android-activity-launchmode/en) inside activity props:
 ```xml
-<application
+<activity
  ...
  android:launchMode="singleTop"
 >
--- a/docs/installation-ios.md
+++ b/docs/installation-ios.md
@ -112,7 +112,7 @@ Follow the instructions at https://firebase.google.com/docs/cloud-messaging/ios/
 In Xcode, enable the following capabilities:

 1) Push Notifications
-2) Background modes > Remove notifications
+2) Background modes > Remote notifications

 ### 3.3) Update `AppDelegate.h`

--- a/index.d.ts
+++ b/index.d.ts
@ -0,0 +1,667 @@
+// Type definitions for React Native Firebase  v1.0.0-alpha7
+// Project: https://github.com/invertase/react-native-firebase
+// Definitions by: Tal <https://github.com/taljacobson>
+// TypeScript Version: 2.1
+
+declare module "react-native-firebase" {
+
+  export default class FireBase {
+    constructor(config?: RNFirebase.configurationOptions)
+    log: any
+    analytics(): RNFirebase.Analytics;
+    auth(): RNFirebase.auth.Auth;
+    on(type: string, handler: (msg: any) => void): any;
+    /** mimics firebase Web SDK */
+    database(): RNFirebase.database.Database;
+    /**RNFirebase mimics the Web Firebase SDK Storage, 
+     * whilst providing some iOS and Android specific functionality. 
+     */
+    storage(): RNFirebase.storage.Storage;
+    /**
+     * Firebase Cloud Messaging (FCM) allows you to send push messages at no cost to both Android & iOS platforms.
+     * Assuming the installation instructions have been followed, FCM is ready to go.
+     * As the Firebase Web SDK has limited messaging functionality, 
+     * the following methods within react-native-firebase have been created to handle FCM in the React Native environment.
+     */
+    messaging(): RNFirebase.messaging.Messaging;
+    /**
+     * RNFirebase provides crash reporting for your app out of the box.
+     * Please note crashes do not appear in real-time on the console,
+     * they tend to take a number of hours to appear
+     * If you want to manually report a crash,
+     * such as a pre-caught exception this is possible by using the report method.
+     */
+    crash(): RNFirebase.crash.Crash;
+    apps: Array<string>;
+    googleApiAvailability: RNFirebase.GoogleApiAvailabilityType;
+    static initializeApp(options?: any | RNFirebase.configurationOptions, name?: string): FireBase;
+    [key: string]: any;
+  }
+
+  namespace RNFirebase {
+    interface RnError extends Error {
+      code?: string;
+    }
+
+    type GoogleApiAvailabilityType = {
+      status: number,
+      isAvailable: boolean,
+      isUserResolvableError?: boolean,
+      error?: string
+    };
+
+    /**
+ * pass custom options by passing an object with configuration options. 
+ * The configuration object will be generated first by the native configuration object, if set and then will be overridden if passed in JS. 
+ * That is, all of the following key/value pairs are optional if the native configuration is set.
+ */
+    interface configurationOptions {
+      /**
+       *  default false	
+       *  When set to true, RNFirebase will log messages to the console and fire debug events we can listen to in js
+       * @usage 
+       * firebase.on('debug', msg => console.log('Received debug message', msg))
+       */
+      debug?: boolean;
+      /**
+       * default false	
+       * When set to true, database persistence will be enabled.
+       */
+      persistence?: boolean;
+      /**
+       * Default from app [NSBundle mainBundle]	The bundle ID for the app to be bundled with
+       */
+      bundleID?: string;
+      /**
+       * defualt ""	
+       * The Google App ID that is used to uniquely identify an instance of an app.
+       */
+      googleAppID?: string;
+      /**
+       * deufalt ""	
+       * The database root (i.e. https://my-app.firebaseio.com)
+       */
+      databaseURL?: string;
+      /**
+       * defualt ""	
+       * URL scheme to set up durable deep link service
+       */
+      deepLinkURLScheme?: string;
+      /**
+       * defualt "" 
+       * The Google Cloud storage bucket name
+       */
+      storageBucket?: string;
+      /**
+       * default ""	
+       * The Android client ID used in Google AppInvite when an iOS app has it's android version
+       */
+      androidClientID?: string;
+      /**
+       * default	""	
+       * The Project number from the Google Developer's console used to configure Google Cloud Messaging
+       */
+      GCMSenderID?: string;
+      /**
+       * default ""	
+       * The tracking ID for Google Analytics
+       */
+      trackingID?: string;
+      /**
+       * default ""	
+       * The OAuth2 client ID for iOS application used to authenticate Google Users for signing in with Google
+       */
+      clientID?: string;
+      /**
+       * defualt ""	
+       * The secret iOS API key used for authenticating requests from our app
+       */
+      APIKey?: string
+    }
+
+    namespace storage {
+
+      interface StorageTask<T> extends Promise<T> {
+        on(
+          event: TaskEvent,
+          nextOrObserver: (snapshot: any) => any,
+          error: (error: RnError) => any,
+          complete: (complete: any) => any
+        ): any
+        /**
+         * is not currently supported by react-native-firebase
+         */
+        pause(): void
+        /**
+         * is not currently supported by react-native-firebase
+         */
+        resume(): void
+        /**
+         * is not currently supported by react-native-firebase
+         */
+        cancel(): void
+
+      }
+
+      interface RNStorage extends Reference {
+        /**
+         *  Downloads a reference to the device
+         *  @param {String} filePath Where to store the file
+         *  @return {Promise}
+         * */
+        downloadFile(filePath: string): StorageTask<any>;
+        /**
+         * Upload a file path
+         * @returns {Promise}
+         */
+        putFile(filePath: string, metadata?: any): StorageTask<any>;
+        setMaxDownloadRetryTime(time: number): void
+        [key: string]: any;
+      }
+
+      interface Storage {
+        maxOperationRetryTime: number;
+        maxUploadRetryTime: number;
+        ref(path?: string): storage.RNStorage;
+        refFromURL(url: string): storage.RNStorage;
+        setMaxOperationRetryTime(time: number): any;
+        setMaxUploadRetryTime(time: number): any;
+      }
+
+      interface Reference {
+        bucket: string;
+        child(path: string): storage.Reference;
+        delete(): Promise<any>;
+        fullPath: string;
+        getDownloadURL(): Promise<any>;
+        getMetadata(): Promise<any>;
+        name: string;
+        parent: storage.Reference | null;
+        put(data: any | Uint8Array | ArrayBuffer,
+          metadata?: storage.UploadMetadata):
+          storage.UploadTask;
+        putString(
+          data: string, format?: storage.StringFormat,
+          metadata?: storage.UploadMetadata):
+          storage.UploadTask;
+        root: storage.Reference;
+        storage: storage.Storage;
+        toString(): string;
+        updateMetadata(metadata: storage.SettableMetadata):
+          Promise<any>;
+      }
+      interface UploadMetadata extends storage.SettableMetadata {
+        md5Hash?: string | null;
+      }
+      interface SettableMetadata {
+        cacheControl?: string | null;
+        contentDisposition?: string | null;
+        contentEncoding?: string | null;
+        contentLanguage?: string | null;
+        contentType?: string | null;
+        customMetadata?: { [/* warning: coerced from ? */ key: string]: string } | null;
+      }
+
+      type StringFormat = string;
+      var StringFormat: {
+        BASE64: StringFormat,
+        BASE64URL: StringFormat,
+        DATA_URL: StringFormat,
+        RAW: StringFormat,
+      }
+
+      interface UploadTask {
+        cancel(): boolean;
+        catch(onRejected: (a: RnError) => any): Promise<any>;
+        on(event: storage.TaskEvent, nextOrObserver?: null | Object,
+          error?: ((a: RnError) => any) | null, complete?: (() => any) | null): Function;
+        pause(): boolean;
+        resume(): boolean;
+        snapshot: storage.UploadTaskSnapshot;
+        then(
+          onFulfilled?: ((a: storage.UploadTaskSnapshot) => any) | null,
+          onRejected?: ((a: RnError) => any) | null): Promise<any>;
+      }
+
+      interface UploadTaskSnapshot {
+        bytesTransferred: number;
+        downloadURL: string | null;
+        metadata: storage.FullMetadata;
+        ref: storage.Reference;
+        state: storage.TaskState;
+        task: storage.UploadTask;
+        totalBytes: number;
+      }
+
+      interface FullMetadata extends storage.UploadMetadata {
+        bucket: string;
+        downloadURLs: string[];
+        fullPath: string;
+        generation: string;
+        metageneration: string;
+        name: string;
+        size: number;
+        timeCreated: string;
+        updated: string;
+      }
+
+      type TaskEvent = string;
+      var TaskEvent: {
+        STATE_CHANGED: TaskEvent,
+      };
+
+      type TaskState = string;
+      var TaskState: {
+        CANCELED: TaskState,
+        ERROR: TaskState,
+        PAUSED: TaskState,
+        RUNNING: TaskState,
+        SUCCESS: TaskState,
+      };
+    }
+
+
+    namespace database {
+
+
+      interface Database {
+        /**
+         * Returns a new firebase reference instance
+         * */
+        ref(path: string): RnReference
+        /**
+         * register listener 
+         */
+        on(path: string, modifiersString: string, modifiers: Array<string>, eventName: string, cb: () => void, errorCb: () => void): any
+        /**
+         * unregister listener 
+         */
+        off(path: string, modifiersString: string, eventName?: string, origCB?: () => void): any
+        /**
+         * Removes all event handlers and their native subscriptions
+         */
+        cleanup(): Promise<any>
+        /**
+         * connect to firebase backend
+         */
+        goOnline(): void
+        /**
+         * disconnect to firebase backend
+         */
+        goOffline(): void
+        [key: string]: any;
+      }
+
+      interface RnReference extends Reference {
+        keepSynced(bool: boolean): any
+        filter(name: string, value: any, key?: string): any;
+        [key: string]: any;
+      }
+
+      interface Query {
+        endAt(value: number | string | boolean | null, key?: string): database.Query;
+        equalTo(value: number | string | boolean | null, key?: string): database.Query;
+        isEqual(other: database.Query | null): boolean;
+        limitToFirst(limit: number): database.Query;
+        limitToLast(limit: number): database.Query;
+        off(eventType?: string,
+          callback?: (a: database.DataSnapshot, b?: string | null) => any,
+          context?: Object | null): any;
+        on(eventType: string,
+          callback: (a: database.DataSnapshot | null, b?: string) => any,
+          cancelCallbackOrContext?: Object | null, context?: Object | null):
+          (a: database.DataSnapshot | null, b?: string) => any;
+        once(
+          eventType: string,
+          successCallback?:
+            (a: database.DataSnapshot, b?: string) => any,
+          failureCallbackOrContext?: Object | null,
+          context?: Object | null): Promise<any>;
+        orderByChild(path: string): database.Query;
+        orderByKey(): database.Query;
+        orderByPriority(): database.Query;
+        orderByValue(): database.Query;
+        ref: database.Reference;
+        startAt(value: number | string | boolean | null, key?: string): database.Query;
+        toJSON(): Object;
+        toString(): string;
+      }
+
+      interface DataSnapshot {
+        child(path: string): database.DataSnapshot;
+        exists(): boolean;
+        exportVal(): any;
+        forEach(action: (a: database.DataSnapshot) => boolean): boolean;
+        getPriority(): string | number | null;
+        hasChild(path: string): boolean;
+        hasChildren(): boolean;
+        key: string | null;
+        numChildren(): number;
+        ref: database.Reference;
+        toJSON(): Object | null;
+        val(): any;
+      }
+
+      interface Reference extends database.Query {
+        child(path: string): database.Reference;
+        key: string | null;
+        onDisconnect(): any;
+        parent: database.Reference | null;
+        push(value?: any, onComplete?: (a: RnError | null) => any): any
+        remove(onComplete?: (a: RnError | null) => any): Promise<any>;
+        root: database.Reference;
+        set(value: any, onComplete?: (a: RnError | null) => any): Promise<any>;
+        setPriority(
+          priority: string | number | null,
+          onComplete: (a: RnError | null) => any): Promise<any>;
+        setWithPriority(
+          newVal: any, newPriority: string | number | null,
+          onComplete?: (a: RnError | null) => any): Promise<any>;
+        transaction(
+          transactionUpdate: (a: any) => any,
+          onComplete?:
+            (a: RnError | null, b: boolean,
+              c: database.DataSnapshot | null) => any,
+          applyLocally?: boolean): Promise<any>;
+        update(values: Object, onComplete?: (a: RnError | null) => any): Promise<any>;
+      }
+    }
+    /**
+     * firebase Analytics
+     */
+    interface Analytics {
+      /**Log a custom event with optional params. */
+      logEvent(event: string, params?: Object): void
+      /** Sets whether analytics collection is enabled for this app on this device. */
+      setAnalyticsCollectionEnabled(enabled: boolean): void
+      /**
+       * Sets the current screen name, which specifies the current visual context in your app.
+       * Whilst screenClassOverride is optional, 
+       * it is recommended it is always sent as your current class name, 
+       * for example on Android it will always show as 'MainActivity' if not specified.
+       */
+      setCurrentScreen(screenName: string, screenClassOverride?: string): void
+      /**
+       * Sets the minimum engagement time required before starting a session. 
+       * The default value is 10000 (10 seconds)
+       */
+      setMinimumSessionDuration(miliseconds: number): void
+      /**
+       * Sets the duration of inactivity that terminates the current session.
+       * The default value is 1800000 (30 minutes).
+       */
+      setSessionTimeoutDuration(miliseconds: number): void
+      /**
+       * Gives a user a uniqiue identificaition.
+       * @example 
+       * const id = firebase.auth().currentUser.uid;
+       * 
+       * firebase.analytics().setUserId(id);
+       */
+      setUserId(id: string): void
+      /**
+       * Sets a key/value pair of data on the current user.
+       */
+      setUserProperty(name: string, value: string): void;
+      [key: string]: any;
+    }
+
+    interface User {
+      /**
+       * The user's display name (if available).
+       */
+      displayName: string | null
+      /**
+       * - The user's email address (if available).
+       */
+      email: string | null
+      /**
+       * - True if the user's email address has been verified.
+       */
+      emailVerified: boolean
+      /**
+       * 
+       */
+      isAnonymous: boolean
+      /**
+       * - The URL of the user's profile picture (if available).
+       */
+      photoURL: string | null
+      /**
+       * - Additional provider-specific information about the user.
+       */
+      providerData: any | null
+      /**
+       *  - The authentication provider ID for the current user.
+       *  For example, 'facebook.com', or 'google.com'.
+       */
+      providerId: string | null
+      /**
+       *  - The user's unique ID.
+       */
+      uid: string
+      /**
+       * Delete the current user.
+       */
+      delete(): Promise<void>
+      /**
+       * Returns the users authentication token.
+       */
+      getToken(): Promise<string>
+      /**
+       * Reauthenticate the current user with credentials:
+       */
+      reauthenticate(credential: Credential): Promise<void>
+      /**
+       * Refreshes the current user.
+       */
+      reload(): Promise<void>
+      /**
+       * Sends a verification email to a user. 
+       * This will Promise reject is the user is anonymous.
+       */
+      sendEmailVerification(): Promise<void>
+      /**
+       * Updates the user's email address.
+       * See Firebase docs for more information on security & email validation. 
+       * This will Promise reject is the user is anonymous.
+       */
+      updateEmail(email: string): Promise<void>
+      /**
+       * Important: this is a security sensitive operation that requires the user to have recently signed in. 
+       * If this requirement isn't met, ask the user to authenticate again and then call firebase.User#reauthenticate. 
+       * This will Promise reject is the user is anonymous.
+       */
+      updatePassword(password: string): Promise<void>
+      /**
+       * Updates a user's profile data.
+       * Profile data should be an object of fields to update:
+       */
+      updateProfile(profile: Object): Promise<void>
+    }
+
+    /** 3rd party provider Credentials */
+    interface Credential {
+      provider: string,
+      token: string,
+      secret: string
+    }
+    namespace auth {
+
+      interface Auth {
+        /**
+         * Returns the current Firebase authentication state.
+         */
+        authenticated: boolean;
+        /**
+         * Returns the currently signed-in user (or null). See the User class documentation for further usage.
+         */
+        currentUser: User | null
+        /**
+         * Listen for changes in the users auth state (logging in and out). 
+         * This method returns a unsubscribe function to stop listening to events. 
+         * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use.
+         */
+        onAuthStateChanged(
+          nextOrObserver: Object, error?: (a: RnError) => any,
+          completed?: () => any): () => any;
+        /**
+         * We can create a user by calling the createUserWithEmailAndPassword() function. 
+         * The method accepts two parameters, an email and a password.
+         */
+        createUserWithEmailAndPassword(email: string, password: string): Promise<User>
+        /**
+         * To sign a user in with their email and password, use the signInWithEmailAndPassword() function. 
+         * It accepts two parameters, the user's email and password:
+         */
+        signInWithEmailAndPassword(email: string, password: string): Promise<User>
+        /**
+         * Sign an anonymous user. 
+         * If the user has already signed in, that user will be returned
+         */
+        signInAnonymously(): Promise<User>
+        /**
+         * Sign in the user with a 3rd party credential provider. 
+         * credential requires the following properties:
+         */
+        signInWithCredential(credential: Credential): Promise<User>
+        /**
+         * Sign a user in with a self-signed JWT token. 
+         * To sign a user using a self-signed custom token, 
+         * use the signInWithCustomToken() function. 
+         * It accepts one parameter, the custom token:
+         */
+        signInWithCustomToken(token: string): Promise<User>
+        /**
+         * Sends a password reset email to the given email address. 
+         * Unlike the web SDK, 
+         * the email will contain a password reset link rather than a code.
+         */
+        sendPasswordResetEmail(email: string): Promise<void>
+        /**
+         * Completes the password reset process, 
+         * given a confirmation code and new password.
+         */
+        signOut(): Promise<void>
+        [key: string]: any;
+      }
+    }
+
+    namespace messaging {
+
+      interface Messaging {
+        /**
+         * Subscribes the device to a topic.
+         */
+        subscribeToTopic(topic: string): void
+        /**
+         * Unsubscribes the device from a topic.
+         */
+        unsubscribeFromTopic(topic: string): void
+        /**
+         * When the application has been opened from a notification 
+         * getInitialNotification is called and the notification payload is returned. 
+         * Use onMessage for notifications when the app is running.
+         */
+        getInitialNotification(): Promise<any>
+        /**
+         * Returns the devices FCM token. 
+         * This token can be used in the Firebase console to send messages to directly.
+         */
+        getToken(forceRefresh?: Boolean): Promise<string>
+        /**
+         * On the event a devices FCM token is refreshed by Google,
+         *  the new token is returned in a callback listener.
+         */
+        onTokenRefresh(listener: (token: string) => any): void
+        /**
+         * On a new message, 
+         * the payload object is passed to the listener callback. 
+         * This method is only triggered when the app is running.
+         * Use getInitialNotification for notifications which cause the app to open.
+         */
+        onMessage(listener: (message: any) => any): void
+        /**
+         * Create a local notification from the device itself.
+         */
+        createLocalNotification(notification: any): any
+        /**
+         * Schedule a local notification to be shown on the device.
+         */
+        scheduleLocalNotification(notification: any): any
+        /**
+         * Returns an array of all currently scheduled notifications.
+         * ```
+         * firebase.messaging().getScheduledLocalNotifications()
+         *   .then((notifications) => {
+         *       console.log('Current scheduled notifications: ', notifications);
+         *   });
+         * ```
+         */
+        getScheduledLocalNotifications(): Promise<any[]>
+        /**
+         * Cancels a location notification by ID, 
+         * or all notifications by *.
+         */
+        cancelLocalNotification(id: string): void
+        /**
+         * Removes all delivered notifications from device by ID, 
+         * or all notifications by *.
+         */
+        removeDeliveredNotification(id: string): void
+        /**
+         * IOS 
+         * Requests app notification permissions in an Alert dialog.
+         */
+        requestPermissions(): void
+        /**
+         * IOS
+         * Sets the badge number on the iOS app icon.
+         */
+        setBadgeNumber(value: number): void
+        /**
+         * IOS
+         * Returns the current badge number on the app icon.
+         */
+        getBadgeNumber(): number
+        /**
+         * Send an upstream message
+         * @param senderId
+         * @param payload
+         */
+        send(senderId: string, payload: RemoteMessage): any
+        NOTIFICATION_TYPE: Object
+        REMOTE_NOTIFICATION_RESULT: Object
+        WILL_PRESENT_RESULT: Object
+        EVENT_TYPE: Object
+      }
+
+      interface RemoteMessage {
+        id: string,
+        type: string,
+        ttl?: number,
+        sender: string,
+        collapseKey?: string,
+        data: Object,
+      }
+    }
+    namespace crash {
+
+      interface Crash {
+        /** Logs a message that will appear in a subsequent crash report. */
+        log(message: string): void
+        /**
+         * Android: Logs a message that will appear in a subsequent crash report as well as in logcat.
+         * iOS: Logs the message in the subsequest crash report only (same as log).
+         */
+        logcat(level: number, tag: string, message: string): void
+        /**
+         * Files a crash report, along with any previous logs to Firebase. 
+         * An Error object must be passed into the report method.
+         */
+        report(error: RnError, maxStackSize: Number): void
+        [key: string]: any;
+      }
+    }
+  }
+}
--- a/ios/RNFirebase/RNFirebase.h
+++ b/ios/RNFirebase/RNFirebase.h
@ -2,9 +2,21 @@
 #define RNFirebase_h

 #import <UIKit/UIKit.h>
-#import <React/RCTBridgeModule.h>
+#if __has_include(<React/RCTEventDispatcher.h>)
 #import <React/RCTEventDispatcher.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventDispatcher.h"
+#endif
+#if __has_include(<React/RCTEventEmitter.h>)
 #import <React/RCTEventEmitter.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventEmitter.h"
+#endif
+#if __has_include(<React/RCTBridgeModule.h>)
+#import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif

@interface RNFirebase : RCTEventEmitter <RCTBridgeModule> {
 }
--- a/ios/RNFirebase/RNFirebaseAnalytics.h
+++ b/ios/RNFirebase/RNFirebaseAnalytics.h
@ -1,7 +1,11 @@
 #ifndef RNFirebaseAnalytics_h
 #define RNFirebaseAnalytics_h

+#if __has_include(<React/RCTBridgeModule.h>)
 #import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif

@interface RNFirebaseAnalytics : NSObject <RCTBridgeModule> {

--- a/ios/RNFirebase/RNFirebaseAuth.h
+++ b/ios/RNFirebase/RNFirebaseAuth.h
@ -2,8 +2,16 @@
 #define RNFirebaseAuth_h

 #import "Firebase.h"
+#if __has_include(<React/RCTEventEmitter.h>)
 #import <React/RCTEventEmitter.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventEmitter.h"
+#endif
+#if __has_include(<React/RCTBridgeModule.h>)
 #import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif

@interface RNFirebaseAuth : RCTEventEmitter <RCTBridgeModule> {
    FIRAuthStateDidChangeListenerHandle authListenerHandle;
--- a/ios/RNFirebase/RNFirebaseAuth.m
+++ b/ios/RNFirebase/RNFirebaseAuth.m
@ -636,6 +636,44 @@ RCT_EXPORT_METHOD(reauthenticate:(NSString *)provider authToken:(NSString *)auth
 }


+/**
+ Converts an array of FIRUserInfo instances into the correct format to match the web sdk
+ 
+ @param providerData FIRUser.providerData
+ @return NSArray
+ */
+- (NSArray <NSObject *> *) convertProviderData:(NSArray <id<FIRUserInfo>> *) providerData {
+    NSMutableArray *output = [NSMutableArray array];
+    
+    for (id<FIRUserInfo> userInfo in providerData) {
+        NSMutableDictionary *pData = [NSMutableDictionary dictionary];
+        
+        if (userInfo.providerID != nil) {
+            [pData setValue: userInfo.providerID forKey:@"providerId"];
+        }
+        
+        if (userInfo.uid != nil) {
+            [pData setValue: userInfo.uid forKey:@"uid"];
+        }
+        
+        if (userInfo.displayName != nil) {
+            [pData setValue: userInfo.displayName forKey:@"displayName"];
+        }
+        
+        if (userInfo.photoURL != nil) {
+            [pData setValue: [userInfo.photoURL absoluteString] forKey:@"photoURL"];
+        }
+        
+        if (userInfo.email != nil) {
+            [pData setValue: userInfo.email forKey:@"email"];
+        }
+        
+        [output addObject:pData];
+    }
+    
+    return output;
+}
+
 /**
 Converts a FIRUser instance into a dictionary to send via RNBridge
 
@ -650,15 +688,13 @@ RCT_EXPORT_METHOD(reauthenticate:(NSString *)provider authToken:(NSString *)auth
                                        @"isAnonymous": @(user.anonymous),
                                        @"displayName": user.displayName ? user.displayName : [NSNull null],
                                        @"refreshToken": user.refreshToken,
-                                        @"providerId": [user.providerID lowercaseString]
-                                        }
-                                     mutableCopy
-                                     ];
-    
-    // todo providerData
+                                        @"providerId": [user.providerID lowercaseString],
+                                        @"providerData": [self convertProviderData: user.providerData]
+                                     } mutableCopy
+                                 ];
    
    if ([user valueForKey:@"photoURL"] != nil) {
-        [userDict setValue: [NSString stringWithFormat:@"%@", user.photoURL] forKey:@"photoURL"];
+        [userDict setValue: [user.photoURL absoluteString] forKey:@"photoURL"];
    }
    
    return userDict;
--- a/ios/RNFirebase/RNFirebaseCrash.h
+++ b/ios/RNFirebase/RNFirebaseCrash.h
@ -1,7 +1,11 @@
 #ifndef RNFirebaseCrash_h
 #define RNFirebaseCrash_h

+#if __has_include(<React/RCTBridgeModule.h>)
 #import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif

@interface RNFirebaseCrash : NSObject <RCTBridgeModule> {

--- a/ios/RNFirebase/RNFirebaseDatabase.h
+++ b/ios/RNFirebase/RNFirebaseDatabase.h
@ -2,8 +2,16 @@
 #define RNFirebaseDatabase_h

 #import "Firebase.h"
+#if __has_include(<React/RCTEventEmitter.h>)
 #import <React/RCTEventEmitter.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventEmitter.h"
+#endif
+#if __has_include(<React/RCTBridgeModule.h>)
 #import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif

@interface RNFirebaseDatabase : RCTEventEmitter <RCTBridgeModule> {

--- a/ios/RNFirebase/RNFirebaseDatabase.m
+++ b/ios/RNFirebase/RNFirebaseDatabase.m
@ -219,7 +219,7 @@
             type:(NSString *) type
 {
    if ([type isEqualToString:@"number"]) {
-        return [NSNumber numberWithInteger:value.integerValue];
+        return [NSNumber numberWithDouble:value.doubleValue];
    } else if ([type isEqualToString:@"boolean"]) {
        return [NSNumber numberWithBool:value.boolValue];
    } else {
@ -361,7 +361,11 @@ RCT_EXPORT_METHOD(enablePersistence:(BOOL) enable

    BOOL isEnabled = [FIRDatabase database].persistenceEnabled;
    if ( isEnabled != enable) {
-        [FIRDatabase database].persistenceEnabled = enable;
+        @try {
+           [FIRDatabase database].persistenceEnabled = enable;
+        } @catch (NSException *exception) {
+            // do nothing - for RN packager reloads
+        }
    }
    callback(@[[NSNull null], @{
                   @"result": @"success"
--- a/ios/RNFirebase/RNFirebaseErrors.h
+++ b/ios/RNFirebase/RNFirebaseErrors.h
@ -1,7 +1,11 @@
 #ifndef RNFirebaseErrors_h
 #define RNFirebaseErrors_h

+#if __has_include(<React/RCTBridgeModule.h>)
 #import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif
 #import "Firebase.h"

@interface RNFirebaseErrors : NSObject <RCTBridgeModule> {
--- a/ios/RNFirebase/RNFirebaseMessaging.h
+++ b/ios/RNFirebase/RNFirebaseMessaging.h
@ -5,9 +5,22 @@
 #import <UIKit/UIKit.h>

 #import "Firebase.h"
+
+#if __has_include(<React/RCTEventEmitter.h>)
 #import <React/RCTEventEmitter.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventEmitter.h"
+#endif
+#if __has_include(<React/RCTBridgeModule.h>)
 #import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif
+#if __has_include(<React/RCTUtils.h>)
 #import <React/RCTUtils.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTUtils.h"
+#endif

@import UserNotifications;

--- a/ios/RNFirebase/RNFirebaseMessaging.m
+++ b/ios/RNFirebase/RNFirebaseMessaging.m
@ -1,8 +1,20 @@
 #import "RNFirebaseMessaging.h"

-#import <React/RCTConvert.h>
+#if __has_include(<React/RCTEventDispatcher.h>)
 #import <React/RCTEventDispatcher.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventDispatcher.h"
+#endif
+#if __has_include(<React/RCTConvert.h>)
+#import <React/RCTConvert.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTConvert.h"
+#endif
+#if __has_include(<React/RCTUtils.h>)
 #import <React/RCTUtils.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTUtils.h"
+#endif

@import UserNotifications;
 #import <FirebaseMessaging/FirebaseMessaging.h>
--- a/ios/RNFirebase/RNFirebaseStorage.h
+++ b/ios/RNFirebase/RNFirebaseStorage.h
@ -2,8 +2,16 @@
 #define RNFirebaseStorage_h

 #import "Firebase.h"
-#import <React/RCTBridgeModule.h>
+#if __has_include(<React/RCTEventEmitter.h>)
 #import <React/RCTEventEmitter.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTEventEmitter.h"
+#endif
+#if __has_include(<React/RCTBridgeModule.h>)
+#import <React/RCTBridgeModule.h>
+#else // Compatibility for RN version < 0.40
+#import "RCTBridgeModule.h"
+#endif

@interface RNFirebaseStorage : RCTEventEmitter <RCTBridgeModule> {

--- a/lib/modules/auth/user.js
+++ b/lib/modules/auth/user.js
@ -1,9 +1,7 @@
 import { NativeModules } from 'react-native';
-import { promisify } from './../../utils';

 const FirebaseAuth = NativeModules.RNFirebaseAuth;

-// TODO refreshToken property

 /**
 * @url https://firebase.google.com/docs/reference/js/firebase.User
@ -144,10 +142,13 @@ export default class User {
    return FirebaseAuth.getToken(forceRefresh);
  }

-  // TODO return from native
-  // get providerData() {
-  //   return this._valueOrNull('providerData');
-  // }
+  /**
+   *
+   * @returns {Array}
+   */
+  get providerData(): Array {
+    return this._valueOrNull('providerData') || [];
+  }

  /**
   * Update the current user's email
--- a/lib/modules/base.js
+++ b/lib/modules/base.js
@ -76,6 +76,12 @@ export class ReferenceBase extends Base {
    this.path = path || '/';
  }

+  /**
+   * The last part of a Reference's path (after the last '/')
+   * The key of a root Reference is null.
+   * @type {String}
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#key}
+   */
  get key(): string|null {
    return this.path === '/' ? null : this.path.substring(this.path.lastIndexOf('/') + 1);
  }
--- a/lib/modules/database/reference.js
+++ b/lib/modules/database/reference.js
@ -14,8 +14,44 @@ const FirebaseDatabase = NativeModules.RNFirebaseDatabase;
 let refId = 1;

 /**
+ * Enum for event types
+ * @readonly
+ * @enum {String}
+ */
+const ReferenceEventTypes = {
+  value: 'value',
+  child_added: 'child_added',
+  child_removed: 'child_removed',
+  child_changed: 'child_changed',
+  child_moved: 'child_moved',
+};
+
+/**
+ * @typedef {String} ReferenceLocation - Path to location in the database, relative
+ * to the root reference. Consists of a path where segments are separated by a
+ * forward slash (/) and ends in a ReferenceKey - except the root location, which
+ * has no ReferenceKey.
+ *
+ * @example
+ * // root reference location: '/'
+ * // non-root reference: '/path/to/referenceKey'
+ */
+
+/**
+ * @typedef {String} ReferenceKey - Identifier for each location that is unique to that
+ * location, within the scope of its parent. The last part of a ReferenceLocation.
+ */
+
+/**
+ * Represents a specific location in your Database that can be used for
+ * reading or writing data.
+ *
+ * You can reference the root using firebase.database().ref() or a child location
+ * by calling firebase.database().ref("child/path").
+ *
 * @link https://firebase.google.com/docs/reference/js/firebase.database.Reference
 * @class Reference
+ * @extends ReferenceBase
 */
 export default class Reference extends ReferenceBase {

@ -99,23 +135,157 @@ export default class Reference extends ReferenceBase {
  }

  /**
+   * iOS: Called once with the initial data at the specified location and then once each
+   * time the data changes. It won't trigger until the entire contents have been
+   * synchronized.
   *
-   * @param eventName
-   * @param successCallback
-   * @param failureCallback
-   * @param context TODO
-   * @returns {*}
+   * Android: (@link https://github.com/invertase/react-native-firebase/issues/92)
+   * - Array & number values: Called once with the initial data at the specified
+   * location and then twice each time the value changes.
+   * - Other data types: Called once with the initial data at the specified location
+   * and once each time the data type changes.
+   *
+   * @callback onValueCallback
+   * @param {!DataSnapshot} dataSnapshot - Snapshot representing data at the location
+   * specified by the current ref.  If location has no data, .val() will return null.
   */
-  on(eventName: string, successCallback: () => any, failureCallback: () => any) {
-    if (!isFunction(successCallback)) throw new Error('The specified callback must be a function');
-    if (failureCallback && !isFunction(failureCallback)) throw new Error('The specified error callback must be a function');
-    this.log.debug('adding reference.on', this.refId, eventName);
+
+  /**
+   * Called once for each initial child at the specified location and then again
+   * every time a new child is added.
+   *
+   * @callback onChildAddedCallback
+   * @param {!DataSnapshot} dataSnapshot - Snapshot reflecting the data for the
+   * relevant child.
+   * @param {?ReferenceKey} previousChildKey - For ordering purposes, the key
+   * of the previous sibling child by sort order, or null if it is the first child.
+   */
+
+  /**
+   * Called once every time a child is removed.
+   *
+   * A child will get removed when either:
+   * - remove() is explicitly called on a child or one of its ancestors
+   * - set(null) is called on that child or one of its ancestors
+   * - a child has all of its children removed
+   * - there is a query in effect which now filters out the child (because it's sort
+   * order changed or the max limit was hit)
+   *
+   * @callback onChildRemovedCallback
+   * @param {!DataSnapshot} dataSnapshot - Snapshot reflecting the old data for
+   * the child that was removed.
+   */
+
+  /**
+   * Called when a child (or any of its descendants) changes.
+   *
+   * A single child_changed event may represent multiple changes to the child.
+   *
+   * @callback onChildChangedCallback
+   * @param {!DataSnapshot} dataSnapshot - Snapshot reflecting new child contents.
+   * @param {?ReferenceKey} previousChildKey - For ordering purposes, the key
+   * of the previous sibling child by sort order, or null if it is the first child.
+   */
+
+  /**
+   * Called when a child's sort order changes, i.e. its position relative to its
+   * siblings changes.
+   *
+   * @callback onChildMovedCallback
+   * @param {!DataSnapshot} dataSnapshot - Snapshot reflecting the data of the moved
+   * child.
+   * @param {?ReferenceKey} previousChildKey - For ordering purposes, the key
+   * of the previous sibling child by sort order, or null if it is the first child.
+   */
+
+  /**
+   * @typedef (onValueCallback|onChildAddedCallback|onChildRemovedCallback|onChildChangedCallback|onChildMovedCallback) ReferenceEventCallback
+   */
+
+  /**
+   * Called if the event subscription is cancelled because the client does
+   * not have permission to read this data (or has lost the permission to do so).
+   *
+   * @callback onFailureCallback
+   * @param {Error} error - Object indicating why the failure occurred
+   */
+
+  /**
+   * Binds callback handlers to when data changes at the current ref's location.
+   * The primary method of reading data from a Database.
+   *
+   * Callbacks can be unbound using {@link off}.
+   *
+   * Event Types:
+   *
+   * - value: {@link onValueCallback}.
+   * - child_added: {@link onChildAddedCallback}
+   * - child_removed: {@link onChildRemovedCallback}
+   * - child_changed: {@link onChildChangedCallback}
+   * - child_moved: {@link onChildMovedCallback}
+   *
+   * @param {ReferenceEventType} eventType - Type of event to attach a callback for.
+   * @param {ReferenceEventCallback} successCallback - Function that will be called
+   * when the event occurs with the new data.
+   * @param {onFailureCallback=} failureCallbackOrContext - Optional callback that is called
+   * if the event subscription fails. {@link onFailureCallback}
+   * @param {*=} context - Optional object to bind the callbacks to when calling them.
+   * @returns {ReferenceEventCallback} callback function, unmodified (unbound), for
+   * convenience if you want to pass an inline function to on() and store it later for
+   * removing using off().
+   *
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#on}
+   */
+  on(eventType: string, successCallback: () => any, failureCallbackOrContext: () => any, context: any) {
+    if (!eventType) throw new Error('Error: Query on failed: Was called with 0 arguments. Expects at least 2');
+    if (!ReferenceEventTypes[eventType]) throw new Error('Query.on failed: First argument must be a valid event type: "value", "child_added", "child_removed", "child_changed", or "child_moved".');
+    if (!successCallback) throw new Error('Query.on failed: Was called with 1 argument. Expects at least 2.');
+    if (!isFunction(successCallback)) throw new Error('Query.on failed: Second argument must be a valid function.');
+    if (arguments.length > 2 && !failureCallbackOrContext) throw new Error('Query.on failed: third argument  must either be a cancel callback or a context object.');
+
+    this.log.debug('adding reference.on', this.refId, eventType);
+
+    let _failureCallback;
+    let _context;
+
+    if (context) {
+      _context = context;
+      _failureCallback = failureCallbackOrContext;
+    } else {
+      if (isFunction(failureCallbackOrContext)) {
+        _failureCallback = failureCallbackOrContext;
+      } else {
+        _context = failureCallbackOrContext;
+      }
+    }
+
+    if (_failureCallback) {
+      _failureCallback = (error) => {
+        if (error.message.startsWith('FirebaseError: permission_denied')) {
+
+          error.message = `permission_denied at /${this.path}: Client doesn\'t have permission to access the desired data.`
+        }
+
+        failureCallbackOrContext(error);
+
+      }
+    }
+
+    let _successCallback;
+
+    if (_context) {
+      _successCallback = successCallback.bind(_context);
+    } else {
+      _successCallback = successCallback;
+    }
+
    const listener = {
      listenerId: Object.keys(this.listeners).length + 1,
-      eventName,
-      successCallback,
-      failureCallback,
+      eventName: eventType,
+      successCallback: _successCallback,
+      failureCallback: _failureCallback,
    };
+
    this.listeners[listener.listenerId] = listener;
    this.database.on(this, listener);
    return successCallback;
@ -144,29 +314,49 @@ export default class Reference extends ReferenceBase {
  }

  /**
+   * Detaches a callback attached with on().
   *
-   * @param eventName
-   * @param origCB
-   * @returns {*}
+   * Calling off() on a parent listener will not automatically remove listeners
+   * registered on child nodes.
+   *
+   * If on() was called multiple times with the same eventType off() must be
+   * called multiple times to completely remove it.
+   *
+   * If a callback is not specified, all callbacks for the specified eventType
+   * will be removed. If no eventType or callback is specified, all callbacks
+   * for the Reference will be removed.
+   *
+   * If a context is specified, it too is used as a filter parameter: a callback
+   * will only be detached if, when it was attached with on(), the same event type,
+   * callback function and context were provided.
+   *
+   * If no callbacks matching the parameters provided are found, no callbacks are
+   * detached.
+   *
+   * @param {('value'|'child_added'|'child_changed'|'child_removed'|'child_moved')=} eventType - Type of event to detach callback for.
+   * @param {Function=} originalCallback - Original callback passed to on()
+   * @param {*=} context - The context passed to on() when the callback was bound
+   *
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#off}
   */
-  off(eventName?: string = '', origCB?: () => any) {
-    this.log.debug('ref.off(): ', this.refId, eventName);
+  off(eventType?: string = '', originalCallback?: () => any) {
+    this.log.debug('ref.off(): ', this.refId, eventType);
    // $FlowFixMe
    const listeners: Array<DatabaseListener> = Object.values(this.listeners);
    let listenersToRemove;
-    if (eventName && origCB) {
+    if (eventType && originalCallback) {
      listenersToRemove = listeners.filter((listener) => {
-        return listener.eventName === eventName && listener.successCallback === origCB;
+        return listener.eventName === eventType && listener.successCallback === originalCallback;
      });
      // Only remove a single listener as per the web spec
      if (listenersToRemove.length > 1) listenersToRemove = [listenersToRemove[0]];
-    } else if (eventName) {
+    } else if (eventType) {
      listenersToRemove = listeners.filter((listener) => {
-        return listener.eventName === eventName;
+        return listener.eventName === eventType;
      });
-    } else if (origCB) {
+    } else if (originalCallback) {
      listenersToRemove = listeners.filter((listener) => {
-        return listener.successCallback === origCB;
+        return listener.successCallback === originalCallback;
      });
    } else {
      listenersToRemove = listeners;
@ -185,8 +375,16 @@ export default class Reference extends ReferenceBase {
   * @param onComplete
   * @param applyLocally
   */
-  transaction(transactionUpdate: Function, onComplete: (?Error, boolean, ?Snapshot) => *, applyLocally: boolean = false) {
-    if (!isFunction(transactionUpdate)) return Promise.reject(new Error('Missing transactionUpdate function argument.'));
+  transaction(
+    transactionUpdate: Function,
+    onComplete: (error: ?Error, committed: boolean, snapshot: ?Snapshot) => *,
+    applyLocally: boolean = false
+  ) {
+    if (!isFunction(transactionUpdate)) {
+      return Promise.reject(
+        new Error('Missing transactionUpdate function argument.')
+      );
+    }

    return new Promise((resolve, reject) => {
      const onCompleteWrapper = (error, committed, snapshotData) => {
@ -349,9 +547,12 @@ export default class Reference extends ReferenceBase {
  }

  /**
-   * Get a specified child
-   * @param path
-   * @returns {Reference}
+   * Creates a Reference to a child of the current Reference, using a relative path.
+   * No validation is performed on the path to ensure it has a valid format.
+   * @param {String} path relative to current ref's location
+   * @returns {!Reference} A new Reference to the path provided, relative to the current
+   * Reference
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#child}
   */
  child(path: string) {
    return new Reference(this.database, `${this.path}/${path}`);
@ -370,6 +571,7 @@ export default class Reference extends ReferenceBase {
   * same instance of firebase.app.App - multiple firebase apps not currently supported.
   * @param {Reference} otherRef - Other reference to compare to this one
   * @return {Boolean} Whether otherReference is equal to this one
+   *
   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#isEqual}
   */
  isEqual(otherRef: Reference): boolean {
@ -381,8 +583,10 @@ export default class Reference extends ReferenceBase {
   */

  /**
-   * Returns the parent ref of the current ref i.e. a ref of /foo/bar would return a new ref to '/foo'
-   * @returns {*}
+   * The parent location of a Reference, or null for the root Reference.
+   * @type {Reference}
+   *
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#parent}
   */
  get parent(): Reference|null {
    if (this.path === '/') return null;
@ -392,6 +596,7 @@ export default class Reference extends ReferenceBase {
  /**
   * A reference to itself
   * @type {!Reference}
+   *
   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#ref}
   */
  get ref(): Reference {
@ -399,8 +604,10 @@ export default class Reference extends ReferenceBase {
  }

  /**
-   * Returns a ref to the root of db - '/'
-   * @returns {Reference}
+   * Reference to the root of the database: '/'
+   * @type {!Reference}
+   *
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#root}
   */
  get root(): Reference {
    return new Reference(this.database, '/');
--- a/lib/modules/database/snapshot.js
+++ b/lib/modules/database/snapshot.js
@ -5,6 +5,7 @@ import Reference from './reference.js';
 import { isObject, deepGet, deepExists } from './../../utils';

 /**
+ * @class DataSnapshot
 * @link https://firebase.google.com/docs/reference/js/firebase.database.DataSnapshot
 */
 export default class Snapshot {
--- a/lib/utils/index.js
+++ b/lib/utils/index.js
@ -165,7 +165,7 @@ export function promisify(
  fn: Function | string,
  NativeModule: Object,
  errorPrefix?: string
-): (any) => Promise<> {
+): (args: any) => Promise<> {
  return (...args) => {
    return new Promise((resolve, reject) => {
      const _fn = typeof fn === 'function' ? fn : NativeModule[fn];
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "react-native-firebase",
-  "version": "1.0.1",
+  "version": "1.0.10",
  "author": "Invertase <contact@invertase.io> (http://invertase.io)",
  "description": "A react native firebase library supporting both android and ios native firebase SDK's",
  "main": "index",
@ -48,7 +48,7 @@
  ],
  "peerDependencies": {
    "react": "*",
-    "react-native": "*"
+    "react-native": ">= 0.38.0"
  },
  "rnpm": {
    "commands": {
@ -77,7 +77,7 @@
    "flow-bin": "^0.40.0",
    "react": "^15.3.0",
    "react-dom": "^15.3.0",
-    "react-native": "^0.42.0",
+    "react-native": "^0.44.0",
    "wml": "0.0.82"
  },
  "dependencies": {
--- a/tests/.babelrc
+++ b/tests/.babelrc
@ -1,9 +1,5 @@
 {
  "presets": [
    "react-native"
-  ],
-  "ignore": [
-    "node_modules/diff/lib/**/*.js",
-    "node_modules/diff/node_modules/**/*.js"
  ]
 }
--- a/tests/.gitignore
+++ b/tests/.gitignore
@ -0,0 +1,2 @@
+__tests__/build/
+ios/build/
--- a/tests/README.md
+++ b/tests/README.md
@ -68,7 +68,7 @@ Tests are bootstrapped and ran when the app is booted. The status of each test s

 Tests can be run by pressing the play button in the toolbar of the app. Test can be run individually, by suite, or all at once.

-![Test suite Android](/docs/assets/test-suite-screenshot-android.png?raw=true)
+![Test suite Android](/tests/docs/assets/test-suite-screenshot-android.png?raw=true)


 ### Adding test
--- a/tests/tests/src/tests/pendingTestTests.js
+++ b/tests/tests/src/tests/pendingTestTests.js
@ -103,6 +103,84 @@ function pendingTestTests({ it: _it, describe: _describe }) {
      otherTest.should.be.called();
    });
  });
+
+  _describe('when an outer context is focused', () => {
+    _it('a pending test will still not run', async () => {
+      const pendingTest = sinon.spy();
+      const otherTest = sinon.spy();
+      const unfocusedTest = sinon.spy();
+
+      const testSuite = new TestSuite('', '', {});
+
+      testSuite.addTests(({ fdescribe, it, xit }) => {
+        fdescribe('', () => {
+          xit('', pendingTest);
+
+          it('', otherTest);
+        });
+
+        it('', unfocusedTest);
+      });
+
+      testSuite.setStore({
+        getState: () => { return {}; },
+      });
+
+      const testIdsToRun = Object.keys(testSuite.testDefinitions.focusedTestIds).reduce((memo, testId) => {
+        if (!testSuite.testDefinitions.pendingTestIds[testId]) {
+          memo.push(testId);
+        }
+
+        return memo;
+      }, []);
+
+      await testSuite.run(testIdsToRun);
+
+      pendingTest.should.not.be.called();
+      otherTest.should.be.called();
+      unfocusedTest.should.not.be.called();
+    });
+  });
+
+  _describe('when an outer context is focused', () => {
+    _it('a pending context will still not run', async () => {
+      const pendingTest = sinon.spy();
+      const otherTest = sinon.spy();
+      const unfocusedTest = sinon.spy();
+
+      const testSuite = new TestSuite('', '', {});
+
+      testSuite.addTests(({ fdescribe, it, xdescribe }) => {
+        fdescribe('', () => {
+          xdescribe('', () => {
+            it('', pendingTest);
+          });
+
+          it('', otherTest);
+        });
+
+        it('', unfocusedTest);
+      });
+
+      testSuite.setStore({
+        getState: () => { return {}; },
+      });
+
+      const testIdsToRun = Object.keys(testSuite.testDefinitions.focusedTestIds).reduce((memo, testId) => {
+        if (!testSuite.testDefinitions.pendingTestIds[testId]) {
+          memo.push(testId);
+        }
+
+        return memo;
+      }, []);
+
+      await testSuite.run(testIdsToRun);
+
+      pendingTest.should.not.be.called();
+      otherTest.should.be.called();
+      unfocusedTest.should.not.be.called();
+    });
+  });
 }

 export default pendingTestTests;
--- a/tests/android/app/src/main/java/com/reactnativefirebasedemo/MainApplication.java
+++ b/tests/android/app/src/main/java/com/reactnativefirebasedemo/MainApplication.java
@ -17,7 +17,7 @@ public class MainApplication extends Application implements ReactApplication {

  private final ReactNativeHost mReactNativeHost = new ReactNativeHost(this) {
    @Override
-    protected boolean getUseDeveloperSupport() {
+    public boolean getUseDeveloperSupport() {
      return BuildConfig.DEBUG;
    }

--- a/tests/android/build.gradle
+++ b/tests/android/build.gradle
@ -5,7 +5,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:2.3.0'
+        classpath 'com.android.tools.build:gradle:2.3.1'
        classpath 'com.google.gms:google-services:3.0.0'

        // NOTE: Do not place your application dependencies here; they belong
--- a/tests/android/gradle.properties
+++ b/tests/android/gradle.properties
@ -18,3 +18,4 @@
 # org.gradle.parallel=true

 android.useDeprecatedNdk=true
+org.gradle.jvmargs=-Xmx1536M
--- a/tests/index.ios.js
+++ b/tests/index.ios.js
@ -2,3 +2,4 @@ import { AppRegistry } from 'react-native';
 import bootstrap from './src/main';

 AppRegistry.registerComponent('ReactNativeFirebaseDemo', () => bootstrap);
+
--- a/tests/ios/Podfile
+++ b/tests/ios/Podfile
@ -7,23 +7,11 @@ target 'ReactNativeFirebaseDemo' do
  # Uncomment this line if you're using Swift or would like to use dynamic frameworks
  # use_frameworks!

+  react_native_path = "../node_modules/react-native"
+  pod "Yoga", :path => "#{react_native_path}/ReactCommon/yoga"
+
  # Pods for ReactNativeFirebaseDemo
-  pod 'React', :path => '../node_modules/react-native', :subspecs => [
-    'Core',
-    'RCTActionSheet',
-    'RCTAnimation',
-    'RCTCameraRoll',
-    'RCTGeolocation',
-    'RCTImage',
-    'RCTLinkingIOS',
-    'RCTNetwork',
-    'RCTPushNotification',
-    'RCTSettings',
-    'RCTText',
-    'RCTVibration',
-    'RCTWebSocket'
-    # Add any other subspecs you want to use in your project
-  ]
+  pod 'React', :path => '../node_modules/react-native'

  pod 'Firebase/Auth'
  pod 'Firebase/Analytics'
--- a/tests/ios/Podfile.lock
+++ b/tests/ios/Podfile.lock
@ -1,168 +0,0 @@
-PODS:
-  - Firebase/Analytics (3.14.0):
-    - Firebase/Core
-  - Firebase/AppIndexing (3.14.0):
-    - Firebase/Core
-    - FirebaseAppIndexing (= 1.2.0)
-  - Firebase/Auth (3.14.0):
-    - Firebase/Core
-    - FirebaseAuth (= 3.1.1)
-  - Firebase/Core (3.14.0):
-    - FirebaseAnalytics (= 3.7.0)
-    - FirebaseCore (= 3.5.1)
-  - Firebase/Crash (3.14.0):
-    - Firebase/Core
-    - FirebaseCrash (= 1.1.6)
-  - Firebase/Database (3.14.0):
-    - Firebase/Core
-    - FirebaseDatabase (= 3.1.2)
-  - Firebase/DynamicLinks (3.14.0):
-    - Firebase/Core
-    - FirebaseDynamicLinks (= 1.3.3)
-  - Firebase/Messaging (3.14.0):
-    - Firebase/Core
-    - FirebaseMessaging (= 1.2.2)
-  - Firebase/RemoteConfig (3.14.0):
-    - Firebase/Core
-    - FirebaseRemoteConfig (= 1.3.4)
-  - Firebase/Storage (3.14.0):
-    - Firebase/Core
-    - FirebaseStorage (= 1.1.0)
-  - FirebaseAnalytics (3.7.0):
-    - FirebaseCore (~> 3.5)
-    - FirebaseInstanceID (~> 1.0)
-    - GoogleToolboxForMac/NSData+zlib (~> 2.1)
-  - FirebaseAppIndexing (1.2.0)
-  - FirebaseAuth (3.1.1):
-    - FirebaseAnalytics (~> 3.7)
-    - GoogleToolboxForMac/NSDictionary+URLArguments (~> 2.1)
-    - GTMSessionFetcher/Core (~> 1.1)
-  - FirebaseCore (3.5.1):
-    - GoogleToolboxForMac/NSData+zlib (~> 2.1)
-  - FirebaseCrash (1.1.6):
-    - FirebaseAnalytics (~> 3.7)
-    - FirebaseInstanceID (~> 1.0)
-    - GoogleToolboxForMac/Logger (~> 2.1)
-    - GoogleToolboxForMac/NSData+zlib (~> 2.1)
-    - Protobuf (~> 3.1)
-  - FirebaseDatabase (3.1.2):
-    - FirebaseAnalytics (~> 3.7)
-  - FirebaseDynamicLinks (1.3.3):
-    - FirebaseAnalytics (~> 3.7)
-  - FirebaseInstanceID (1.0.9)
-  - FirebaseMessaging (1.2.2):
-    - FirebaseAnalytics (~> 3.7)
-    - FirebaseInstanceID (~> 1.0)
-    - GoogleToolboxForMac/Logger (~> 2.1)
-    - Protobuf (~> 3.1)
-  - FirebaseRemoteConfig (1.3.4):
-    - FirebaseAnalytics (~> 3.7)
-    - FirebaseInstanceID (~> 1.0)
-    - GoogleToolboxForMac/NSData+zlib (~> 2.1)
-    - Protobuf (~> 3.1)
-  - FirebaseStorage (1.1.0):
-    - FirebaseAnalytics (~> 3.7)
-    - GTMSessionFetcher/Core (~> 1.1)
-  - GoogleToolboxForMac/DebugUtils (2.1.1):
-    - GoogleToolboxForMac/Defines (= 2.1.1)
-  - GoogleToolboxForMac/Defines (2.1.1)
-  - GoogleToolboxForMac/Logger (2.1.1):
-    - GoogleToolboxForMac/Defines (= 2.1.1)
-  - GoogleToolboxForMac/NSData+zlib (2.1.1):
-    - GoogleToolboxForMac/Defines (= 2.1.1)
-  - GoogleToolboxForMac/NSDictionary+URLArguments (2.1.1):
-    - GoogleToolboxForMac/DebugUtils (= 2.1.1)
-    - GoogleToolboxForMac/Defines (= 2.1.1)
-    - GoogleToolboxForMac/NSString+URLArguments (= 2.1.1)
-  - GoogleToolboxForMac/NSString+URLArguments (2.1.1)
-  - GTMSessionFetcher/Core (1.1.8)
-  - Protobuf (3.2.0)
-  - React/Core (0.40.0):
-    - React/cxxreact
-    - React/yoga
-  - React/cxxreact (0.40.0):
-    - React/jschelpers
-  - React/jschelpers (0.40.0)
-  - React/RCTActionSheet (0.40.0):
-    - React/Core
-  - React/RCTAnimation (0.40.0):
-    - React/Core
-  - React/RCTCameraRoll (0.40.0):
-    - React/Core
-    - React/RCTImage
-  - React/RCTGeolocation (0.40.0):
-    - React/Core
-  - React/RCTImage (0.40.0):
-    - React/Core
-    - React/RCTNetwork
-  - React/RCTLinkingIOS (0.40.0):
-    - React/Core
-  - React/RCTNetwork (0.40.0):
-    - React/Core
-  - React/RCTPushNotification (0.40.0):
-    - React/Core
-  - React/RCTSettings (0.40.0):
-    - React/Core
-  - React/RCTText (0.40.0):
-    - React/Core
-  - React/RCTVibration (0.40.0):
-    - React/Core
-  - React/RCTWebSocket (0.40.0):
-    - React/Core
-  - React/yoga (0.40.0)
-  - RNFirebase (1.0.0-alpha13)
-
-DEPENDENCIES:
-  - Firebase/Analytics
-  - Firebase/AppIndexing
-  - Firebase/Auth
-  - Firebase/Core
-  - Firebase/Crash
-  - Firebase/Database
-  - Firebase/DynamicLinks
-  - Firebase/Messaging
-  - Firebase/RemoteConfig
-  - Firebase/Storage
-  - React/Core (from `../node_modules/react-native`)
-  - React/RCTActionSheet (from `../node_modules/react-native`)
-  - React/RCTAnimation (from `../node_modules/react-native`)
-  - React/RCTCameraRoll (from `../node_modules/react-native`)
-  - React/RCTGeolocation (from `../node_modules/react-native`)
-  - React/RCTImage (from `../node_modules/react-native`)
-  - React/RCTLinkingIOS (from `../node_modules/react-native`)
-  - React/RCTNetwork (from `../node_modules/react-native`)
-  - React/RCTPushNotification (from `../node_modules/react-native`)
-  - React/RCTSettings (from `../node_modules/react-native`)
-  - React/RCTText (from `../node_modules/react-native`)
-  - React/RCTVibration (from `../node_modules/react-native`)
-  - React/RCTWebSocket (from `../node_modules/react-native`)
-  - RNFirebase (from `./../../`)
-
-EXTERNAL SOURCES:
-  React:
-    :path: ../node_modules/react-native
-  RNFirebase:
-    :path: ./../../
-
-SPEC CHECKSUMS:
-  Firebase: 85a581fb04e44f63ae9f4fbc8d6dabf4a4c18653
-  FirebaseAnalytics: 0d1b7d81d5021155be37702a94ba1ec16d45365d
-  FirebaseAppIndexing: d0fa52ce0ad13f4b5b2f09e4b47fb0dc2213f4e9
-  FirebaseAuth: cc8a1824170adbd351edb7f994490a3fb5c18be6
-  FirebaseCore: 225d40532489835a034b8f4e2c9c87fbf4f615a2
-  FirebaseCrash: db4c05d9c75baa050744d31b36357c8f1efba481
-  FirebaseDatabase: 05c96d7b43a7368dc91c07791adb49683e1738d1
-  FirebaseDynamicLinks: f0d025dd29a1d70418c003344813b67ab748ffb9
-  FirebaseInstanceID: 2d0518b1378fe9d685ef40cbdd63d2fdc1125339
-  FirebaseMessaging: df8267f378580a24174ce7861233aa11d5c90109
-  FirebaseRemoteConfig: af3003f4e8daa2bd1d5cf90d3cccc1fe224f8ed9
-  FirebaseStorage: a5c55b23741a49a72af8f30f95b3bb5ddbeda12d
-  GoogleToolboxForMac: 8e329f1b599f2512c6b10676d45736bcc2cbbeb0
-  GTMSessionFetcher: 6f8d8b28b7e345549ac471071608170b31cb4977
-  Protobuf: 745f59e122e5de98d4d7ef291e264a0eef80f58e
-  React: 6dfb2f72edb1d74a800127ae157af038646673ce
-  RNFirebase: 46bfe1099349ac6fac8c5e57cf4f0b0f4b7938ac
-
-PODFILE CHECKSUM: f8bc5de55afd159ec2faf523f1b8e0d861d0832b
-
-COCOAPODS: 1.2.0
--- a/tests/lib/TestRun.js
+++ b/tests/lib/TestRun.js
@ -286,8 +286,7 @@ class TestRun {
        suiteId: this.testSuite.id,
        status: RunStatus.ERR,
        time: Date.now() - this.runStartTime,
-        message: `Test suite failed: ${error.message}`,
-        stackTrace: error.stack,
+        message: `Test suite failed: ${error.message}`
      });
    });
  }
@ -306,7 +305,7 @@ class TestRun {
  }

  async _safelyRunFunction(func, timeOutDuration, description) {
-    const syncResultOrPromise = tryCatcher(func);
+    const syncResultOrPromise = captureThrownErrors(func);

    if (syncResultOrPromise.error) {
      // Synchronous Error
@ -314,49 +313,59 @@ class TestRun {
    }

    // Asynchronous Error
-    return promiseToCallBack(syncResultOrPromise.value, timeOutDuration, description);
+    return capturePromiseErrors(syncResultOrPromise.result, timeOutDuration, description);
  }

 }

 /**
- * Try catch to object
- * @returns {{}}
+ * Call a function and capture any errors that are immediately thrown.
+ * @returns {Object} Object containing result of executing the function, or the error
+ * message that was captured
 * @private
 */

-function tryCatcher(func) {
+function captureThrownErrors(func) {
  const result = {};

  try {
-    result.value = func();
-  } catch (e) {
-    result.error = e;
+    result.result = func();
+  } catch (error) {
+    result.error = error;
  }

  return result;
 }

 /**
- * Make a promise callback-able to trap errors
- * @param promise
+ * Wraps a promise so that if it's rejected or an error is thrown while it's being
+ * evaluated, it's captured and thrown no further
+ * @param {*} target - Target to wrap. If a thenable object, it's wrapped so if it's
+ * rejected or an error is thrown, it will be captured. If a non-thenable object,
+ * wrapped in resolved promise and returned.
+ * @param {Number} timeoutDuration - Number of milliseconds the promise is allowed
+ * to pend before it's considered timed out
+ * @param {String} description - Description of the context the promises is defined
+ * in, used for reporting where a timeout occurred in the resulting error message.
 * @private
 */

-function promiseToCallBack(promise, timeoutDuration, description) {
+function capturePromiseErrors(target, timeoutDuration, description) {
  let returnValue = null;

  try {
-    returnValue = Promise.resolve(promise)
+    returnValue = Promise.resolve(target)
      .then(() => {
        return null;
      }, (error) => {
        return Promise.resolve(error);
      })
-      .timeout(timeoutDuration, `${description} took longer than ${timeoutDuration}ms. This can be extended with the timeout option.`)
      .catch((error) => {
        return Promise.resolve(error);
-      });
+      })
+      .timeout(timeoutDuration,
+        `${description} took longer than ${timeoutDuration}ms. This can be extended with the timeout option.`
+      );
  } catch (error) {
    returnValue = Promise.resolve(error);
  }
--- a/tests/lib/TestSuite.js
+++ b/tests/lib/TestSuite.js
@ -111,19 +111,19 @@ class TestSuite {
   */
  async run(testIds = undefined) {
    const testsToRun = (() => {
-      if (testIds) {
-        return testIds.map((id) => {
-          const test = this.testDefinitions.tests[id];
+      return (testIds || Object.keys(this.testDefinitions.tests)).reduce((memo, id) => {
+        const test = this.testDefinitions.tests[id];

-          if (!test) {
-            throw new RangeError(`ReactNativeFirebaseTests.TestRunError: Test with id ${id} not found in test suite ${this.name}`);
-          }
+        if (!test) {
+          throw new RangeError(`ReactNativeFirebaseTests.TestRunError: Test with id ${id} not found in test suite ${this.name}`);
+        }

-          return test;
-        });
-      }
+        if (!this.testDefinitions.pendingTestIds[id]) {
+          memo.push(test);
+        }

-      return Object.values(this.testDefinitions.tests);
+        return memo;
+      }, []);
    })();

    const testRun = new TestRun(this, testsToRun.reverse(), this.testDefinitions);
--- a/tests/package.json
+++ b/tests/package.json
@ -32,12 +32,12 @@
    "js-beautify": "^1.6.11",
    "lodash.groupby": "^4.6.0",
    "lodash.some": "^4.6.0",
-    "react": "~15.4.1",
-    "react-native": "0.40.0",
+    "react": "16.0.0-alpha.6",
+    "react-native": "^0.44.0",
    "react-native-firebase": "file:..",
    "react-native-simple-toast": "0.0.5",
    "react-native-vector-icons": "^4.0.0",
-    "react-navigation": "^1.0.0-beta.7",
+    "react-navigation": "^1.0.0-beta.9",
    "react-redux": "^5.0.3",
    "redux": "^3.6.0",
    "redux-logger": "^2.8.2",
--- a/tests/src/actions/TestActions.js
+++ b/tests/src/actions/TestActions.js
@ -14,13 +14,14 @@ export function setSuiteStatus({ suiteId, status, time, message, progress }) {
  };
 }

-export function setTestStatus({ testId, status, time = 0, message = null }) {
+export function setTestStatus({ testId, status, stackTrace, time = 0, message = null }) {
  return {
    type: TEST_SET_STATUS,
    testId,

    status,
    message,
+    stackTrace,
    time,
  };
 }
--- a/tests/src/reducers/testsReducers.js
+++ b/tests/src/reducers/testsReducers.js
@ -12,6 +12,7 @@ function testsReducers(state = initState.tests, action: Object): State {
    flattened[`${action.testId}.status`] = action.status;
    flattened[`${action.testId}.message`] = action.message;
    flattened[`${action.testId}.time`] = action.time;
+    flattened[`${action.testId}.stackTrace`] = action.stackTrace;

    return unflatten(flattened);
  }
--- a/tests/src/screens/Overview.js
+++ b/tests/src/screens/Overview.js
@ -13,17 +13,11 @@ class Overview extends React.Component {
  // noinspection JSUnusedGlobalSymbols
  static navigationOptions = {
    title: 'Test Suites',
-    header: () => {
-      return {
-        style: { backgroundColor: '#0288d1' },
-        tintColor: '#ffffff',
-        right: (
-          <View style={{ marginRight: 8 }}>
-            <OverviewControlButton />
-          </View>
-        ),
-      };
-    },
+    headerTintColor: '#ffffff',
+    headerStyle: { backgroundColor: '#0288d1' },
+    headerRight: <View style={{ marginRight: 8 }}>
+      <OverviewControlButton />
+    </View>
  };

  /**
--- a/tests/src/screens/Suite.js
+++ b/tests/src/screens/Suite.js
@ -11,25 +11,19 @@ import TestSuiteControlButton from '../components/TestSuiteControlButton';

 class Suite extends React.Component {

-  static navigationOptions = {
-    title: ({ state: { params: { title } } }) => {
-      return title;
-    },
-    header: ({ state: { params: { testSuiteId, onlyShowFailingTests } }, setParams }) => {
-      return {
-        style: { backgroundColor: '#0288d1' },
-        tintColor: '#ffffff',
-        right: (
-          <View style={{ flexDirection: 'row', marginRight: 8 }}>
-            <TestSuiteControlButton
-              testSuiteId={testSuiteId}
-              onlyShowFailingTests={onlyShowFailingTests}
-              onFilterChange={setParams}
-            />
-          </View>
-        ),
-      };
-    },
+  static navigationOptions = ({ navigation: { state: { params: { title, testSuiteId, onlyShowFailingTests } }, setParams } }) => {
+    return {
+      title,
+      headerTintColor: '#ffffff',
+      headerStyle: { backgroundColor: '#0288d1' },
+      headerRight: <View style={{ flexDirection: 'row', marginRight: 8 }}>
+        <TestSuiteControlButton
+          testSuiteId={testSuiteId}
+          onlyShowFailingTests={onlyShowFailingTests}
+          onFilterChange={setParams}
+        />
+      </View>,
+    };
  };

  /**
--- a/tests/src/screens/Test.js
+++ b/tests/src/screens/Test.js
@ -9,21 +9,15 @@ import TestControlButton from '../components/TestControlButton';

 class Test extends React.Component {

-  static navigationOptions = {
-    title: ({ state: { params: { title } } }) => {
-      return title;
-    },
-    header: ({ state: { params: { testId } } }) => {
-      return {
-        style: { backgroundColor: '#0288d1' },
-        tintColor: '#ffffff',
-        right: (
-          <View style={{ marginRight: 8 }}>
-            <TestControlButton testId={testId} />
-          </View>
-        ),
-      };
-    },
+  static navigationOptions = ({ navigation: { state: { params: { title, testId } } } }) => {
+    return {
+      title,
+      headerTintColor: '#ffffff',
+      headerStyle: { backgroundColor: '#0288d1' },
+      headerRight: <View style={{ marginRight: 8 }}>
+        <TestControlButton testId={testId} />
+      </View>,
+    };
  };

  static renderBanner({ status, time }) {
@ -57,35 +51,28 @@ class Test extends React.Component {
    setParams({ test });
  }

-  renderError() {
-    const { test: { message } } = this.props;
-
-    if (message) {
-      return (
-        <ScrollView>
-          <Text style={styles.codeHeader}>Test Error</Text>
-          <Text style={styles.code}>
-            <Text>{message}</Text>
-          </Text>
-        </ScrollView>
-      );
-    }
-
-    return null;
-  }
-
-
  render() {
-    const { test: { func, status, time } } = this.props;
+    const { test: { stackTrace, description, func, status, time }, testContextName } = this.props;

    return (
      <View style={styles.container}>
        {Test.renderBanner({ status, time })}
-        <View style={styles.content}>
-          {this.renderError()}
-          <Text style={styles.codeHeader}>Test Code Preview</Text>
-          <ScrollView>
-            <Text style={styles.code}>
+        <View >
+          <ScrollView style={styles.sectionContainer}>
+            <Text style={styles.heading}>{testContextName}</Text>
+            <Text style={styles.description}>{description}</Text>
+          </ScrollView>
+          <ScrollView style={styles.sectionContainer}>
+            <Text style={styles.heading}>Test Error</Text>
+            <Text style={styles.description}>
+              <Text>{stackTrace || 'None.'}</Text>
+            </Text>
+          </ScrollView>
+          <Text style={styles.heading}>
+            Test Code Preview
+          </Text>
+          <ScrollView style={styles.sectionContainer}>
+            <Text style={styles.description}>
              {beautify(removeLastLine(removeFirstLine(func.toString())), { indent_size: 4, break_chained_methods: true })}
            </Text>
          </ScrollView>
@ -99,10 +86,13 @@ Test.propTypes = {
  test: PropTypes.shape({
    status: PropTypes.string,
    time: PropTypes.number,
-    message: PropTypes.string,
    func: PropTypes.function,
+    stackTrace: PropTypes.function,
+    description: PropTypes.string,
  }).isRequired,

+  testContextName: PropTypes.string,
+
  navigation: PropTypes.shape({
    setParams: PropTypes.func.isRequired,
  }).isRequired,
@ -113,27 +103,32 @@ const styles = StyleSheet.create({
    flex: 1,
    backgroundColor: '#ffffff',
  },
-  content: {},
-  code: {
-    backgroundColor: '#3F373A',
-    color: '#c3c3c3',
-    padding: 5,
-    fontSize: 12,
+  sectionContainer: {
+    minHeight: 100,
  },
-  codeHeader: {
-    fontWeight: '600',
-    fontSize: 18,
-    backgroundColor: '#000',
-    color: '#fff',
+  heading: {
    padding: 5,
+    backgroundColor: '#0288d1',
+    fontWeight: '600',
+    color: '#ffffff',
+    fontSize: 16,
+  },
+  description: {
+    padding: 5,
+    fontSize: 14,
  },
 });

-function select({ tests }, { navigation: { state: { params: { testId } } } }) {
+function select({ tests, testContexts }, { navigation: { state: { params: { testId } } } }) {
  const test = tests[testId];
+  let testContext = testContexts[test.testContextId];

+  while(testContext.parentContextId && testContexts[testContext.parentContextId].parentContextId) {
+    testContext = testContexts[testContext.parentContextId];
+  }
  return {
    test,
+    testContextName: testContext.name,
  };
 }

--- a/tests/src/tests/database/ref/index.js
+++ b/tests/src/tests/database/ref/index.js
@ -1,4 +1,5 @@
-import onTests from './onTests';
+import onTests from './on/onTests';
+import onValueTests from './on/onValueTests';
 import offTests from './offTests';
 import onceTests from './onceTests';
 import setTests from './setTests';
@ -14,13 +15,14 @@ import refTests from './refTests';
 import rootTests from './rootTests';
 import transactionTests from './transactionTests';
 import queryTests from './queryTests';
+import issueSpecificTests from './issueSpecificTests';

 import DatabaseContents from '../../support/DatabaseContents';

 const testGroups = [
-  factoryTests, keyTests, parentTests, childTests, rootTests,
-  pushTests, onTests, offTests, onceTests, updateTests, removeTests, setTests,
-  transactionTests, queryTests, refTests, isEqualTests,
+  issueSpecificTests, factoryTests, keyTests, parentTests, childTests, rootTests,
+  pushTests, onTests, onValueTests, offTests, onceTests, updateTests,
+  removeTests, setTests, transactionTests, queryTests, refTests, isEqualTests,
 ];

 function registerTestSuite(testSuite) {
@ -28,10 +30,12 @@ function registerTestSuite(testSuite) {
    this._databaseRef = testSuite.firebase.native.database().ref('tests/types');

    await this._databaseRef.set(DatabaseContents.DEFAULT);
+    await this._databaseRef.parent.child('issues').set(DatabaseContents.ISSUES);
  });

  testSuite.afterEach(async function () {
    await this._databaseRef.set(DatabaseContents.DEFAULT);
+    await this._databaseRef.parent.child('issues').set(DatabaseContents.ISSUES);
  });

  testGroups.forEach((testGroup) => {
--- a/tests/src/tests/database/ref/issueSpecificTests.js
+++ b/tests/src/tests/database/ref/issueSpecificTests.js
@ -0,0 +1,74 @@
+import should from 'should';
+import DatabaseContents from '../../support/DatabaseContents';
+
+function issueTests({ fdescribe, describe, it, context, firebase }) {
+  describe('issue_100', () => {
+    context('array-like values should', () => {
+      it('return null in returned array at positions where a key is missing', async() => {
+        // Setup
+
+        const ref = firebase.native.database().ref('tests/issues/100');
+
+        // Test
+
+        return ref.once('value').then((snapshot) => {
+          // Assertion
+          // console.warn(JSON.stringify(snapshot.val()));
+
+          snapshot.val().should.eql([null, DatabaseContents.ISSUES[100][1], DatabaseContents.ISSUES[100][2], DatabaseContents.ISSUES[100][3]]);
+        });
+      });
+    });
+  });
+
+  describe('issue_108', () => {
+    context('filters using floats', () => {
+      it('return correct results', async() => {
+        // Setup
+
+        const ref = firebase.native.database().ref('tests/issues/108');
+
+        // Test
+
+        return ref
+          .orderByChild('latitude')
+          .startAt(34.00867000999119)
+          .endAt(34.17462960866099)
+          .once('value')
+          .then((snapshot) => {
+            const val = snapshot.val();
+            // Assertion
+            val.foobar.should.eql(DatabaseContents.ISSUES[108].foobar);
+            should.equal(Object.keys(val).length, 1);
+
+            return Promise.resolve();
+          });
+      });
+
+      it('return correct results when not using float values', async() => {
+        // Setup
+
+        const ref = firebase.native.database().ref('tests/issues/108');
+
+        // Test
+
+        return ref
+          .orderByChild('latitude')
+          .equalTo(37)
+          .once('value')
+          .then((snapshot) => {
+            const val = snapshot.val();
+
+            // Assertion
+
+            val.notAFloat.should.eql(DatabaseContents.ISSUES[108].notAFloat);
+            should.equal(Object.keys(val).length, 1);
+
+            return Promise.resolve();
+          });
+      });
+    });
+  });
+}
+
+export default issueTests;
--- a/tests/src/tests/database/ref/on/onTests.js
+++ b/tests/src/tests/database/ref/on/onTests.js
@ -0,0 +1,52 @@
+import 'should-sinon';
+
+function onTests({ describe, it, firebase, context }) {
+  describe('ref().on()', () => {
+    // Observed Web API Behaviour
+    context('when no eventName is provided', () => {
+      it('then raises an error', () => {
+        const ref = firebase.native.database().ref('tests/types/number');
+
+        (() => { ref.on(); }).should.throw('Error: Query on failed: Was called with 0 arguments. Expects at least 2');
+      });
+    });
+
+    // Observed Web API Behaviour
+    context('when no callback function is provided', () => {
+      it('then raises an error', () => {
+        const ref = firebase.native.database().ref('tests/types/number');
+
+        (() => { ref.on('value'); }).should.throw('Query.on failed: Was called with 1 argument. Expects at least 2.');
+      });
+    });
+
+    // Observed Web API Behaviour
+    context('when an invalid eventName is provided', () => {
+      it('then raises an error', () => {
+        const ref = firebase.native.database().ref('tests/types/number');
+
+        (() => { ref.on('invalid', () => {}); }).should.throw('Query.on failed: First argument must be a valid event type: "value", "child_added", "child_removed", "child_changed", or "child_moved".');
+      });
+    });
+
+    // Observed Web API Behaviour
+    context('when an invalid success callback function is provided', () => {
+      it('then raises an error', () => {
+        const ref = firebase.native.database().ref('tests/types/number');
+
+        (() => { ref.on('value', 1); }).should.throw('Query.on failed: Second argument must be a valid function.');
+      });
+    });
+
+    // Observed Web API Behaviour
+    context('when an invalid failure callback function is provided', () => {
+      it('then raises an error', () => {
+        const ref = firebase.native.database().ref('tests/types/number');
+
+        (() => { ref.on('value', () => {}, null); }).should.throw('Query.on failed: third argument  must either be a cancel callback or a context object.');
+      });
+    });
+  });
+}
+
+export default onTests;
--- a/tests/src/tests/database/ref/on/onValueTests.js
+++ b/tests/src/tests/database/ref/on/onValueTests.js
@ -0,0 +1,409 @@
+import { Platform } from 'react-native';
+
+import sinon from 'sinon';
+import 'should-sinon';
+import Promise from 'bluebird';
+
+import DatabaseContents from '../../../support/DatabaseContents';
+
+/**
+ * On Android, some data types result in callbacks that get called twice every time
+ * they are updated. This appears to be behaviour coming from the Android Firebase
+ * library itself.
+ *
+ * See https://github.com/invertase/react-native-firebase/issues/92 for details
+ */
+const DATATYPES_WITH_DUPLICATE_CALLBACK_CALLS = [
+  'array',
+  'number',
+];
+
+function onTests({ describe, context, it, firebase, tryCatch }) {
+  describe('ref().on(\'value\')', () => {
+    // Documented Web API Behaviour
+    it('returns the success callback', () => {
+      // Setup
+
+      const successCallback = sinon.spy();
+      const ref = firebase.native.database().ref('tests/types/array');
+
+      // Assertions
+
+      ref.on('value', successCallback).should.eql(successCallback);
+
+      // Tear down
+
+      ref.off();
+    });
+
+    // Documented Web API Behaviour
+    it('calls callback with null if there is no data at ref', async () => {
+      // Setup
+      const ref = firebase.native.database().ref('tests/types/invalid');
+
+      const callback = sinon.spy();
+
+      // Test
+
+      await new Promise((resolve) => {
+        ref.on('value', (snapshot) => {
+          callback(snapshot.val());
+          resolve();
+        });
+      });
+
+      // Assertions
+
+      callback.should.be.calledWith(null);
+
+      await ref.set(1);
+
+      callback.should.be.calledWith(1);
+
+      // Teardown
+      ref.off();
+      await ref.set(null);
+    });
+
+    // Documented Web API Behaviour
+    it('calls callback with the initial data and then when value changes', () => {
+      return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => {
+        // Setup
+
+        const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
+        const currentDataValue = DatabaseContents.DEFAULT[dataRef];
+
+        const callback = sinon.spy();
+
+        // Test
+
+        await new Promise((resolve) => {
+          ref.on('value', (snapshot) => {
+            callback(snapshot.val());
+            resolve();
+          });
+        });
+
+        callback.should.be.calledWith(currentDataValue);
+
+        const newDataValue = DatabaseContents.NEW[dataRef];
+        await ref.set(newDataValue);
+
+        // Assertions
+
+        callback.should.be.calledWith(newDataValue);
+
+        if (Platform.OS === 'android' && DATATYPES_WITH_DUPLICATE_CALLBACK_CALLS.includes(dataRef)) {
+          callback.should.be.calledThrice();
+        } else {
+          callback.should.be.calledTwice();
+        }
+
+        // Tear down
+
+        ref.off();
+        await ref.set(currentDataValue);
+      });
+    });
+
+    it('calls callback when children of the ref change', async () => {
+      const ref = firebase.native.database().ref('tests/types/object');
+      const currentDataValue = DatabaseContents.DEFAULT.object;
+
+      const callback = sinon.spy();
+
+      // Test
+
+      await new Promise((resolve) => {
+        ref.on('value', (snapshot) => {
+          callback(snapshot.val());
+          resolve();
+        });
+      });
+
+      callback.should.be.calledWith(currentDataValue);
+
+      const newDataValue = DatabaseContents.NEW.string;
+      const childRef = firebase.native.database().ref('tests/types/object/foo2');
+      await childRef.set(newDataValue);
+
+      // Assertions
+
+      callback.should.be.calledWith({
+        ...currentDataValue,
+        foo2: newDataValue,
+      });
+
+      callback.should.be.calledTwice();
+
+      // Tear down
+
+      ref.off();
+      await ref.set(currentDataValue);
+    });
+
+    it('calls callback when child of the ref is added', async () => {
+      const ref = firebase.native.database().ref('tests/types/array');
+      const currentDataValue = DatabaseContents.DEFAULT.array;
+
+      const callback = sinon.spy();
+
+      // Test
+
+      await new Promise((resolve) => {
+        ref.on('value', (snapshot) => {
+          callback(snapshot.val());
+          resolve();
+        });
+      });
+
+      callback.should.be.calledWith(currentDataValue);
+
+      const newElementRef = await ref.push(37);
+
+      const arrayAsObject = currentDataValue.reduce((memo, element, index) => {
+        memo[index] = element;
+        return memo;
+      }, {});
+
+      // Assertions
+      callback.should.be.calledWith({
+        ...arrayAsObject,
+        [newElementRef.key]: 37,
+      });
+
+      if (Platform.OS === 'android') {
+        callback.should.be.calledThrice();
+      } else {
+        callback.should.be.calledTwice();
+      }
+
+      // Tear down
+
+      ref.off();
+      await ref.set(currentDataValue);
+    });
+
+    it('doesn\'t call callback when the ref is updated with the same value', async () => {
+      const ref = firebase.native.database().ref('tests/types/object');
+      const currentDataValue = DatabaseContents.DEFAULT.object;
+
+      const callback = sinon.spy();
+
+      // Test
+
+      await new Promise((resolve) => {
+        ref.on('value', (snapshot) => {
+          callback(snapshot.val());
+          resolve();
+        });
+      });
+
+      callback.should.be.calledWith(currentDataValue);
+
+      await ref.set(currentDataValue);
+
+      // Assertions
+
+      callback.should.be.calledOnce(); // Callback is not called again
+
+      // Tear down
+
+      ref.off();
+    });
+
+    // Documented Web API Behaviour
+    it('allows binding multiple callbacks to the same ref', () => {
+      return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => {
+        // Setup
+
+        const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
+        const currentDataValue = DatabaseContents.DEFAULT[dataRef];
+
+        const callbackA = sinon.spy();
+        const callbackB = sinon.spy();
+
+        // Test
+
+        await new Promise((resolve) => {
+          ref.on('value', (snapshot) => {
+            callbackA(snapshot.val());
+            resolve();
+          });
+        });
+
+        await new Promise((resolve) => {
+          ref.on('value', (snapshot) => {
+            callbackB(snapshot.val());
+            resolve();
+          });
+        });
+
+        callbackA.should.be.calledWith(currentDataValue);
+        callbackA.should.be.calledOnce();
+
+        callbackB.should.be.calledWith(currentDataValue);
+        callbackB.should.be.calledOnce();
+
+        const newDataValue = DatabaseContents.NEW[dataRef];
+        await ref.set(newDataValue);
+
+        callbackA.should.be.calledWith(newDataValue);
+        callbackB.should.be.calledWith(newDataValue);
+
+        if (Platform.OS === 'android' && DATATYPES_WITH_DUPLICATE_CALLBACK_CALLS.includes(dataRef)) {
+          callbackA.should.be.calledThrice();
+          callbackB.should.be.calledThrice();
+        } else {
+          callbackA.should.be.calledTwice();
+          callbackB.should.be.calledTwice();
+        }
+
+        // Tear down
+
+        ref.off();
+      });
+    });
+
+    context('when no failure callback is provided', () => {
+      it('then does not call the callback for a ref to un-permitted location', () => {
+        const invalidRef = firebase.native.database().ref('nope');
+
+        const callback = sinon.spy();
+
+        invalidRef.on('value', callback);
+
+        /**
+         * As we are testing that a callback is "never" called, we just wait for
+         * a reasonable time before giving up.
+         */
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            callback.should.not.be.called();
+            invalidRef.off();
+            resolve();
+          }, 1000);
+        });
+      });
+
+      // Documented Web API Behaviour
+      it('then calls callback bound to the specified context with the initial data and then when value changes', () => {
+        return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => {
+          // Setup
+
+          const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
+          const currentDataValue = DatabaseContents.DEFAULT[dataRef];
+
+          const context = {
+            callCount: 0,
+          };
+
+          // Test
+
+          await new Promise((resolve) => {
+            ref.on('value', function(snapshot) {
+              this.value = snapshot.val();
+              this.callCount += 1;
+              resolve();
+            }, context);
+          });
+
+          context.value.should.eql(currentDataValue);
+          context.callCount.should.eql(1);
+
+          const newDataValue = DatabaseContents.NEW[dataRef];
+          await ref.set(newDataValue);
+
+          // Assertions
+
+          context.value.should.eql(newDataValue);
+
+          if (Platform.OS === 'android' && DATATYPES_WITH_DUPLICATE_CALLBACK_CALLS.includes(dataRef)) {
+            context.callCount.should.eql(3);
+          } else {
+            context.callCount.should.eql(2);
+          }
+
+          // Tear down
+
+          ref.off();
+          await ref.set(currentDataValue);
+        });
+      });
+
+    });
+
+    // Observed Web API Behaviour
+    context('when a failure callback is provided', () => {
+      it('then calls only the failure callback for a ref to un-permitted location', () => {
+        const invalidRef = firebase.native.database().ref('nope');
+
+        const callback = sinon.spy();
+
+        return new Promise((resolve, reject) => {
+          invalidRef.on('value', callback, tryCatch((error) => {
+            error.message.should.eql(
+              'permission_denied at /nope: Client doesn\'t have permission to access the desired data.'
+            );
+            error.name.should.eql('Error');
+
+            callback.should.not.be.called();
+
+            invalidRef.off();
+            resolve();
+          }, reject));
+        });
+      });
+
+      // Documented Web API Behaviour
+      it('then calls callback bound to the specified context with the initial data and then when value changes', () => {
+        return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => {
+          // Setup
+
+          const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
+          const currentDataValue = DatabaseContents.DEFAULT[dataRef];
+
+          const context = {
+            callCount: 0,
+          };
+
+          const failureCallback = sinon.spy();
+
+          // Test
+
+          await new Promise((resolve) => {
+            ref.on('value', function(snapshot) {
+              this.value = snapshot.val();
+              this.callCount += 1;
+              resolve();
+            }, failureCallback, context);
+          });
+
+          failureCallback.should.not.be.called();
+          context.value.should.eql(currentDataValue);
+          context.callCount.should.eql(1);
+
+          const newDataValue = DatabaseContents.NEW[dataRef];
+          await ref.set(newDataValue);
+
+          // Assertions
+
+          context.value.should.eql(newDataValue);
+
+          if (Platform.OS === 'android' && DATATYPES_WITH_DUPLICATE_CALLBACK_CALLS.includes(dataRef)) {
+            context.callCount.should.eql(3);
+          } else {
+            context.callCount.should.eql(2);
+          }
+
+          // Tear down
+
+          ref.off();
+          await ref.set(currentDataValue);
+        });
+      })
+    });
+  });
+}
+
+export default onTests;
--- a/tests/src/tests/database/ref/onTests.js
+++ b/tests/src/tests/database/ref/onTests.js
@ -1,125 +0,0 @@
-import sinon from 'sinon';
-import 'should-sinon';
-import Promise from 'bluebird';
-
-import DatabaseContents from '../../support/DatabaseContents';
-
-function onTests({ describe, it, firebase, tryCatch }) {
-  describe('ref().on()', () => {
-    it('calls callback when value changes', () => {
-      return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => {
-        // Setup
-
-        const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
-        const currentDataValue = DatabaseContents.DEFAULT[dataRef];
-
-        const callback = sinon.spy();
-
-        // Test
-
-        await new Promise((resolve) => {
-          ref.on('value', (snapshot) => {
-            callback(snapshot.val());
-            resolve();
-          });
-        });
-
-        callback.should.be.calledWith(currentDataValue);
-
-        const newDataValue = DatabaseContents.NEW[dataRef];
-        await ref.set(newDataValue);
-
-        // Assertions
-
-        callback.should.be.calledWith(newDataValue);
-
-        // Tear down
-
-        ref.off();
-      });
-    });
-
-    it('allows binding multiple callbacks to the same ref', () => {
-      return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => {
-        // Setup
-
-        const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
-        const currentDataValue = DatabaseContents.DEFAULT[dataRef];
-
-        const callbackA = sinon.spy();
-        const callbackB = sinon.spy();
-
-        // Test
-
-        await new Promise((resolve) => {
-          ref.on('value', (snapshot) => {
-            callbackA(snapshot.val());
-            resolve();
-          });
-        });
-
-        await new Promise((resolve) => {
-          ref.on('value', (snapshot) => {
-            callbackB(snapshot.val());
-            resolve();
-          });
-        });
-
-        callbackA.should.be.calledWith(currentDataValue);
-        callbackB.should.be.calledWith(currentDataValue);
-
-        // Tear down
-
-        ref.off();
-      });
-    });
-
-    it('calls callback with current values', () => {
-      return Promise.each(Object.keys(DatabaseContents.DEFAULT), (dataRef) => {
-        // Setup
-
-        const dataTypeValue = DatabaseContents.DEFAULT[dataRef];
-        const ref = firebase.native.database().ref(`tests/types/${dataRef}`);
-
-        // Test
-
-        return ref.on('value', (snapshot) => {
-          // Assertion
-
-          snapshot.val().should.eql(dataTypeValue);
-
-          // Tear down
-
-          ref.off();
-        });
-      });
-    });
-
-    it('errors if permission denied', () => {
-      return new Promise((resolve, reject) => {
-        const successCb = tryCatch(() => {
-          // Assertion
-
-          reject(new Error('No permission denied error'));
-        }, reject);
-
-        const failureCb = tryCatch((error) => {
-          // Assertion
-
-          error.message.includes('permission_denied').should.be.true();
-          resolve();
-        }, reject);
-
-        // Setup
-
-        const invalidRef = firebase.native.database().ref('nope');
-
-        // Test
-
-        invalidRef.on('value', successCb, failureCb);
-      });
-    });
-  });
-}
-
-export default onTests;
--- a/tests/src/tests/support/DatabaseContents.js
+++ b/tests/src/tests/support/DatabaseContents.js
@ -22,4 +22,38 @@ export default {
      foo: 'baz',
    },
  },
+
+  ISSUES: {
+    // https://github.com/invertase/react-native-firebase/issues/100
+    100: {
+      1: {
+        someKey: 'someValue',
+        someOtherKey: 'someOtherValue',
+      },
+      2: {
+        someKey: 'someValue',
+        someOtherKey: 'someOtherValue',
+      },
+      3: {
+        someKey: 'someValue',
+        someOtherKey: 'someOtherValue',
+      },
+    },
+
+    // https://github.com/invertase/react-native-firebase/issues/108
+    108: {
+      foobar: {
+        name: 'Foobar Pizzas',
+        latitude: 34.1013717,
+      },
+      notTheFoobar: {
+        name: 'Not the pizza you\'re looking for',
+        latitude: 34.456787,
+      },
+      notAFloat: {
+        name: 'Not a float',
+        latitude: 37,
+      },
+    },
+  },
 };