diff --git a/tests/js/admin-user-helper.js b/tests/js/admin-user-helper.js
index 85718b0f..e9eaa813 100644
--- a/tests/js/admin-user-helper.js
+++ b/tests/js/admin-user-helper.js
@@ -3,27 +3,20 @@ function node_require(module) {
     return require(module);
 }
 
-var Realm = node_require('realm');
+const Realm = node_require('realm');
 
 const adminName = "realm-admin"
 const password = '';
 
 exports.createAdminUser = function () {
-    return new Promise((resolve, reject) => {
-        Realm.Sync.User.login('http://localhost:9080', adminName, password, (error, user) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            
-            if (!user.isAdmin) {
-                reject(adminName + " user is not an admin user on this server");
-            }
+    return Realm.Sync.User.login('http://localhost:9080', adminName, password).then((user) => {
+        if (!user.isAdmin) {
+            throw new Error(`${adminName} user is not an admin user on this server`);
+        }
 
-            resolve({
-                username: adminName,
-                password
-            });
-        });
+        return {
+            username: adminName,
+            password
+        };
     });
 }
diff --git a/tests/js/download-api-helper.js b/tests/js/download-api-helper.js
index fd899431..81893a05 100644
--- a/tests/js/download-api-helper.js
+++ b/tests/js/download-api-helper.js
@@ -1,50 +1,55 @@
-/*
-This script creates 3 new objects into a new realm. These are objects are validated to exists by the download api tests.
-*/
-'use strict';
-console.log("download-api-helper started");
-const username = process.argv[2];
-const realmName = process.argv[3];
-const realmModule = process.argv[4];
-
-var Realm = require(realmModule);
-
-function createObjects(user) {
-    const config = {
-        sync: { user,
-            url: `realm://localhost:9080/~/${realmName}`,
-            error: err => console.log(err)
-        },
-        schema: [{ name: 'Dog', properties: { name: 'string' } }]
-    };
-
-    var realm = new Realm(config);
-
-    realm.write(() => {
-        for (let i = 1; i <= 3; i++) {
-            realm.create('Dog', { name: `Lassy ${i}` });
-        }
-    });
-
-    console.log("Dogs count " + realm.objects('Dog').length);
-    setTimeout(() => process.exit(0), 3000);
-}
-
-Realm.Sync.User.register('http://localhost:9080', username, 'password', (error, registeredUser) => {
-    if (error) {
-        const registrationError = JSON.stringify(error);
-        Realm.Sync.User.login('http://localhost:9080', username, 'password', (err, loggedUser) => {
-            if (err) {
-                const loginError = JSON.stringify(err);
-                console.error("download-api-helper failed:\n User.register() error:\n" + err + "\n" + registrationError + "\n User.login() error:\n" + loginError);
-                process.exit(-2);
-            }
-            else {
-                createObjects(loggedUser);
-            }
-        });
-    }
-    else {
-        createObjects(registeredUser);
-    }
-});
+/*
+This script creates 3 new objects into a new realm. These are objects are validated to exists by the download api tests.
+*/
+'use strict';
+console.log("download-api-helper started");
+const username = process.argv[2];
+const realmName = process.argv[3];
+const realmModule = process.argv[4];
+
+const Realm = require(realmModule);
+
+function createObjects(user) {
+    const config = {
+        sync: { user,
+            url: `realm://localhost:9080/~/${realmName}`,
+            error: err => console.log(err)
+        },
+        schema: [{ name: 'Dog', properties: { name: 'string' } }]
+    };
+
+    const realm = new Realm(config);
+
+    realm.write(() => {
+        for (let i = 1; i <= 3; i++) {
+            realm.create('Dog', { name: `Lassy ${i}` });
+        }
+    });
+
+    console.log("Dogs count " + realm.objects('Dog').length);
+
+    let session = realm.syncSession;
+    return new Promise((resolve, reject) => {
+        let callback = (transferred, total) => {
+            if (transferred === total) {
+                session.removeProgressNotification(callback);
+                resolve(realm);
+            }
+        }
+        session.addProgressNotification('upload', 'forCurrentlyOutstandingWork', callback);
+    });
+}
+
+let registrationError;
+Realm.Sync.User.register('http://localhost:9080', username, 'password')
+  .catch((error) => {
+      registrationError = JSON.stringify(error);
+      return Realm.Sync.User.login('http://localhost:9080', username, 'password')
+    })
+    .catch((error) => {
+        const loginError = JSON.stringify(err);
+        console.error(`download-api-helper failed:\n User.register() error:\n${registrationError}\n User.login() error:\n${registrationError}`);
+        process.exit(-2);
+    })
+    .then((user) => createObjects(user))
+    .then(() => process.exit(0));
diff --git a/tests/js/permission-tests.js b/tests/js/permission-tests.js
index e8a15571..bc894a0f 100644
--- a/tests/js/permission-tests.js
+++ b/tests/js/permission-tests.js
@@ -30,24 +30,15 @@ function uuid() {
 }
 
 function createUsersWithTestRealms(count) {
-  const createUserWithTestRealm = username => new Promise((resolve, reject) => {
-    Realm.Sync.User.register('http://localhost:9080', username, 'password', (error, user) => {
-      if (error) {
-        reject(error);
-      }
-      else {
-        new Realm({ sync: { user, url: 'realm://localhost:9080/~/test'}}).close();
-        resolve(user);
-      }
-    })
-  });
+  const createUserWithTestRealm = () => {
+    return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password')
+      .then(user => {
+        new Realm({sync: {user, url: 'realm://localhost:9080/~/test'}}).close();
+        return user;
+      });
+  };
 
-  // Generate some usernames
-  const usernames = new Array(count).fill(undefined).map(uuid);
-
-  // And turn them into users and realms
-  const userPromises = usernames.map(createUserWithTestRealm);
-  return Promise.all(userPromises);
+  return Promise.all(Array.from({length: count}, createUserWithTestRealm));
 }
 
 function wait(t) {
@@ -103,28 +94,29 @@ module.exports = {
     },
 
     testInvalidatePermissionOffer() {
+      let user1, user2, token;
       return createUsersWithTestRealms(2)
-        .then(([user1, user2]) => {
-            user1.offerPermissions(`/${user1.identity}/test`, 'read')
-              .then((token) => {
-                return user1.invalidatePermissionOffer(token)
-                    // Since we don't yet support notification when the invalidation has gone through,
-                    // wait for a bit and hope the server is done processing.
-                  .then(wait(100))
-                  .then(user2.acceptPermissionOffer(token))
-                  // We want the call to fail, i.e. the catch() below should be called.
-                  .then(() => { throw new Error("User was able to accept an invalid permission offer token"); })
-                  .catch(error => {
-                    try {
-                      TestCase.assertEqual(error.message, 'The permission offer is expired.');
-                      TestCase.assertEqual(error.statusCode, 701);
-                    }
-                    catch (e) {
-                      throw new Error(e);
-                    }
-                  });
-              });
-          });
+        .then(users => {
+            user1 = users[0];
+            user2 = users[1];
+            return user1.offerPermissions(`/${user1.identity}/test`, 'read');
+        })
+        .then(t => { token = t; return user1.invalidatePermissionOffer(token); })
+        // Since we don't yet support notification when the invalidation has gone through,
+        // wait for a bit and hope the server is done processing.
+        .then(wait(100))
+        .then(() => user2.acceptPermissionOffer(token))
+        // We want the call to fail, i.e. the catch() below should be called.
+        .then(() => { throw new Error("User was able to accept an invalid permission offer token"); })
+        .catch(error => {
+          try {
+            TestCase.assertEqual(error.message, 'The permission offer is expired.');
+            TestCase.assertEqual(error.statusCode, 701);
+          }
+          catch (e) {
+            throw new Error(e);
+          }
+        });
     },
 }
 
diff --git a/tests/js/session-tests.js b/tests/js/session-tests.js
index 8957b886..aab58bfb 100644
--- a/tests/js/session-tests.js
+++ b/tests/js/session-tests.js
@@ -44,7 +44,6 @@ if (isNodeProccess) {
     path = node_require("path");
 }
 
-
 function uuid() {
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
         var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
@@ -52,32 +51,6 @@ function uuid() {
     });
 }
 
-function promisifiedRegister(server, username, password) {
-    return new Promise((resolve, reject) => {
-        Realm.Sync.User.register(server, username, password, (error, user) => {
-            if (error) {
-                console.log(`promisifiedRegister ${error}`);
-                reject(error);
-            } else {
-                resolve(user);
-            }
-        });
-    });
-}
-
-function promisifiedLogin(server, username, password) {
-    return new Promise((resolve, reject) => {
-        Realm.Sync.User.login(server, username, password, (error, user) => {
-            if (error) {
-                console.log(`promisifiedLogin ${error}`);
-                reject(error);
-            } else {
-                resolve(user);
-            }
-        });
-    });
-}
-
 function copyFileToTempDir(filename) {
     let tmpDir = tmp.dirSync();
     let content = fs.readFileSync(filename);
@@ -120,9 +93,8 @@ module.exports = {
     },
 
     testProperties() {
-        return promisifiedRegister('http://localhost:9080', uuid(), 'password').then(user => {
+        return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password').then(user => {
             return new Promise((resolve, reject) => {
-
                 const accessTokenRefreshed = this;
                 let successCounter = 0;
                 function checkSuccess() {
@@ -162,43 +134,43 @@ module.exports = {
 
     testRealmOpen() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
         const realmName = uuid();
         const expectedObjectsCount = 3;
 
+        let user, config;
         return runOutOfProcess(__dirname + '/download-api-helper.js', username, realmName, REALM_MODULE_PATH)
-            .then(() => {
-                return promisifiedLogin('http://localhost:9080', username, 'password').then(user => {
-                    const accessTokenRefreshed = this;
-                    let successCounter = 0;
+            .then(() => Realm.Sync.User.login('http://localhost:9080', username, 'password'))
+            .then(u => {
+                user = u;
+                const accessTokenRefreshed = this;
+                let successCounter = 0;
 
-                    let config = {
-                        sync: { user, url: `realm://localhost:9080/~/${realmName}` },
-                        schema: [{ name: 'Dog', properties: { name: 'string' } }],
-                    };
+                config = {
+                    sync: { user, url: `realm://localhost:9080/~/${realmName}` },
+                    schema: [{ name: 'Dog', properties: { name: 'string' } }],
+                };
 
-                    return Realm.open(config)
-                        .then(realm => {
-                            let actualObjectsCount = realm.objects('Dog').length;
-                            TestCase.assertEqual(actualObjectsCount, expectedObjectsCount, "Synced realm does not contain the expected objects count");
-                            return realm.syncSession;
-                        }).then(session => {
-                            TestCase.assertInstanceOf(session, Realm.Sync.Session);
-                            TestCase.assertEqual(session.user.identity, user.identity);
-                            TestCase.assertEqual(session.config.url, config.sync.url);
-                            TestCase.assertEqual(session.config.user.identity, config.sync.user.identity);
-                            TestCase.assertEqual(session.state, 'active');
-                        });
-                });
+                return Realm.open(config)
+            }).then(realm => {
+                let actualObjectsCount = realm.objects('Dog').length;
+                TestCase.assertEqual(actualObjectsCount, expectedObjectsCount, "Synced realm does not contain the expected objects count");
+
+                const session = realm.syncSession;
+                TestCase.assertInstanceOf(session, Realm.Sync.Session);
+                TestCase.assertEqual(session.user.identity, user.identity);
+                TestCase.assertEqual(session.config.url, config.sync.url);
+                TestCase.assertEqual(session.config.user.identity, config.sync.user.identity);
+                TestCase.assertEqual(session.state, 'active');
             });
     },
 
     testRealmOpenAsync() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
@@ -206,44 +178,42 @@ module.exports = {
         const expectedObjectsCount = 3;
 
         return runOutOfProcess(__dirname + '/download-api-helper.js', username, realmName, REALM_MODULE_PATH)
-            .then(() => {
-                return Realm.Sync.User.login('http://localhost:9080', username, 'password').then(user => {
-                    return new Promise((resolve, reject) => {
-                        const accessTokenRefreshed = this;
-                        let successCounter = 0;
+            .then(() => Realm.Sync.User.login('http://localhost:9080', username, 'password'))
+            .then(user => {
+                const accessTokenRefreshed = this;
+                let successCounter = 0;
 
-                        let config = {
-                            sync: { user, url: `realm://localhost:9080/~/${realmName}` },
-                            schema: [{ name: 'Dog', properties: { name: 'string' } }],
-                        };
+                let config = {
+                    sync: { user, url: `realm://localhost:9080/~/${realmName}` },
+                    schema: [{ name: 'Dog', properties: { name: 'string' } }],
+                };
+                return new Promise((resolve, reject) => {
+                    Realm.openAsync(config, (error, realm) => {
+                        try {
+                            if (error) {
+                                reject(error);
+                            }
 
-                        Realm.openAsync(config, (error, realm) => {
-                            try {
-                                if (error) {
-                                    reject(error);
+                            let actualObjectsCount = realm.objects('Dog').length;
+                            TestCase.assertEqual(actualObjectsCount, expectedObjectsCount, "Synced realm does not contain the expected objects count");
+
+                            setTimeout(() => {
+                                try {
+                                    const session = realm.syncSession;
+                                    TestCase.assertInstanceOf(session, Realm.Sync.Session);
+                                    TestCase.assertEqual(session.user.identity, user.identity);
+                                    TestCase.assertEqual(session.config.url, config.sync.url);
+                                    TestCase.assertEqual(session.config.user.identity, config.sync.user.identity);
+                                    TestCase.assertEqual(session.state, 'active');
+                                    resolve();
+                                } catch (e) {
+                                    reject(e);
                                 }
-
-                                let actualObjectsCount = realm.objects('Dog').length;
-                                TestCase.assertEqual(actualObjectsCount, expectedObjectsCount, "Synced realm does not contain the expected objects count");
-
-                                setTimeout(() => {
-                                    try {
-                                        const session = realm.syncSession;
-                                        TestCase.assertInstanceOf(session, Realm.Sync.Session);
-                                        TestCase.assertEqual(session.user.identity, user.identity);
-                                        TestCase.assertEqual(session.config.url, config.sync.url);
-                                        TestCase.assertEqual(session.config.user.identity, config.sync.user.identity);
-                                        TestCase.assertEqual(session.state, 'active');
-                                        resolve();
-                                    } catch (e) {
-                                        reject(e);
-                                    }
-                                }, 50);
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                        });
+                            }, 50);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
                     });
                 });
             });
@@ -251,7 +221,7 @@ module.exports = {
 
     testRealmOpenAsyncNoSchema() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
@@ -397,8 +367,8 @@ module.exports = {
             Realm.copyBundledRealmFiles();
         }
 
-        return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password').then(user => {
-            return new Promise((resolve, _reject) => {
+        return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password')
+            .then(user => {
                 const config = {
                     path: realm,
                     sync: {
@@ -407,30 +377,26 @@ module.exports = {
                         url: 'realm://localhost:9080/~/sync-v1'
                     }
                 };
+                return Realm.open(config)
+            })
+            .then(realm => { throw new Error("Should fail with IncompatibleSyncedRealmError") })
+            .catch(e => {
+                if (e.name == "IncompatibleSyncedRealmError") {
+                    const backupRealm = new Realm(e.configuration);
+                    TestCase.assertEqual(backupRealm.objects('Dog').length, 3);
+                    return;
+                }
 
-                Realm.open(config)
-                    .then(realm =>
-                        _reject("Should fail with IncompatibleSyncedRealmError"))
-                    .catch(e => {
-                        if (e.name == "IncompatibleSyncedRealmError") {
-                            const backupRealm = new Realm(e.configuration);
-                            TestCase.assertEqual(backupRealm.objects('Dog').length, 3);
-                            resolve();
-                            return;
-                        }
+                function printObject(o) {
+                    var out = '';
+                    for (var p in o) {
+                      out += p + ': ' + o[p] + '\n';
+                    }
+                    return out;
+                  }
 
-                        function printObject(o) {
-                            var out = '';
-                            for (var p in o) {
-                              out += p + ': ' + o[p] + '\n';
-                            }
-                            return out;
-                          }
-
-                        _reject("Failed with unexpected error " + printObject(e));
-                    });
+                throw new Error("Failed with unexpected error " + printObject(e));
             });
-        });
     },
 
     testIncompatibleSyncedRealmOpenAsync() {
@@ -514,42 +480,36 @@ module.exports = {
 
     testProgressNotificationsForRealmConstructor() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
         const realmName = uuid();
 
         return runOutOfProcess(__dirname + '/download-api-helper.js', username, realmName, REALM_MODULE_PATH)
-            .then(() => {
-                return Realm.Sync.User.login('http://localhost:9080', username, 'password').then(user => {
-                    return new Promise((resolve, reject) => {
-                        let config = {
-                            sync: {
-                                user,
-                                url: `realm://localhost:9080/~/${realmName}`
-                            },
-                            schema: [{ name: 'Dog', properties: { name: 'string' } }],
-                        };
+            .then(() => Realm.Sync.User.login('http://localhost:9080', username, 'password'))
+            .then(user => {
+                let config = {
+                    sync: {
+                        user,
+                        url: `realm://localhost:9080/~/${realmName}`
+                    },
+                    schema: [{ name: 'Dog', properties: { name: 'string' } }],
+                };
 
-                        let realm = new Realm(config);
-                        const progressCallback = (transferred, total) => {
-                            resolve();
-                        };
-
-                        realm.syncSession.addProgressNotification('download', 'reportIndefinitely', progressCallback);
-
-                        setTimeout(function() {
-                            reject("Progress Notifications API failed to call progress callback for Realm constructor");
-                        }, 5000);
-                    });
+                const realm = new Realm(config);
+                return new Promise((resolve, reject) => {
+                    realm.syncSession.addProgressNotification('download', 'reportIndefinitely', resolve);
+                    setTimeout(function() {
+                        reject("Progress Notifications API failed to call progress callback for Realm constructor");
+                    }, 5000);
                 });
             });
     },
 
     testProgressNotificationsUnregisterForRealmConstructor() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
@@ -616,7 +576,7 @@ module.exports = {
 
     testProgressNotificationsForRealmOpen() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
@@ -655,7 +615,7 @@ module.exports = {
 
     testProgressNotificationsForRealmOpenAsync() {
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
@@ -700,7 +660,7 @@ module.exports = {
     testPartialSync() {
         // FIXME: try to enable for React Native
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         const username = uuid();
@@ -733,7 +693,7 @@ module.exports = {
     testClientReset() {
         // FIXME: try to enable for React Native
         if (!isNodeProccess) {
-            return Promise.resolve();
+            return;
         }
 
         return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password').then(user => {
diff --git a/tests/js/user-tests.js b/tests/js/user-tests.js
index 6c7727d8..b1c02b3a 100644
--- a/tests/js/user-tests.js
+++ b/tests/js/user-tests.js
@@ -26,7 +26,7 @@ const isNodeProcess = typeof process === 'object' && process + '' === '[object p
 
 function uuid() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-    var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+    const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
     return v.toString(16);
   });
 }
@@ -65,35 +65,11 @@ function assertIsAuthError(error, code, title) {
   }
 }
 
-function failOnError(error) {
-  if (error) {
-    throw new Error(`Unexpected error in test: ${error}\n${error.stack}`);
-  }
-}
-
-// Test the given requestFunc, passing it the given callback after it's been wrapped appropriately.
-// This function makes sure that errors thrown in the async callback rejects the promise (making tests actually run).
-function callbackTest(requestFunc, callback) {
-  return new Promise((resolve, reject) => {
-    function callbackWrapper() {
-      try {
-        callback.apply(this, Array.from(arguments));
-        resolve();
-      }
-      catch (e) {
-        reject(e);
-      }
-    }
-    requestFunc(callbackWrapper);
-  });
-}
-
 module.exports = {
 
   testLogout() {
-    var username = uuid();
-    return callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', username, 'password', callback), (error, user) => {
-      failOnError(error);
+    const username = uuid();
+    return Realm.Sync.User.register('http://localhost:9080', username, 'password').then((user) => {
       assertIsUser(user);
 
       assertIsSameUser(user, Realm.Sync.User.current);
@@ -103,272 +79,188 @@ module.exports = {
       TestCase.assertUndefined(Realm.Sync.User.current);
 
       // Can we open a realm with the registered user?
-      TestCase.assertThrows(function() {
-        var _realm = new Realm({sync: {user: user, url: 'realm://localhost:9080/~/test'}});
-      });
-    })
+      TestCase.assertThrows(() => new Realm({sync: {user: user, url: 'realm://localhost:9080/~/test'}}));
+    });
   },
 
   testRegisterUser() {
-    var username = uuid();
-    return callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', username, 'password', callback), (error, user) => {
-      failOnError(error);
-      assertIsUser(user);
-
+    const username = uuid();
+    return Realm.Sync.User.register('http://localhost:9080', username, 'password').then((user) => {
       // Can we open a realm with the registered user?
-      var realm = new Realm({sync: {user: user, url: 'realm://localhost:9080/~/test'}});
+      const realm = new Realm({sync: {user: user, url: 'realm://localhost:9080/~/test'}});
       TestCase.assertInstanceOf(realm, Realm);
     });
   },
 
   testRegisterExistingUser() {
-    var username = uuid();
-    return new Promise((resolve, reject) => {
-      Realm.Sync.User.register('http://localhost:9080', username, 'password', (error, user) => {
-        failOnError(error);
-        assertIsUser(user);
-
-        Realm.Sync.User.register('http://localhost:9080', username, 'password', (error, user) => {
-         try { 
-            assertIsAuthError(error, 611, "The provided credentials are invalid or the user does not exist.");
-            TestCase.assertUndefined(user);
-            resolve();
-          } catch(e) { 
-           reject(e);
-          }
-        });
-      });
+    const username = uuid();
+    return Realm.Sync.User.register('http://localhost:9080', username, 'password').then((user) => {
+      assertIsUser(user);
+      return Realm.Sync.User.register('http://localhost:9080', username, 'password')
+        .then((user) => { throw new Error(user); })
+        .catch((e) => {
+            assertIsAuthError(e, 611, "The provided credentials are invalid or the user does not exist.");
+        })
     });
   },
 
   testRegisterMissingUsername() {
-    return new Promise((resolve, _reject) => {
-        TestCase.assertThrows(() => {
-            Realm.Sync.User.register('http://localhost:9080', undefined, 'password', () => {});
-        });
-        resolve();
-    });
+    TestCase.assertThrows(() => Realm.Sync.User.register('http://localhost:9080', undefined, 'password'));
   },
 
   testRegisterMissingPassword() {
-    var username = uuid();
-    return new Promise((resolve, _reject) => {
-        TestCase.assertThrows(() => {
-            Realm.Sync.User.register('http://localhost:9080', username, undefined, () => {});
-        });
-        resolve();
-    });
+    const username = uuid();
+    TestCase.assertThrows(() => Realm.Sync.User.register('http://localhost:9080', username, undefined));
   },
 
   testRegisterServerOffline() {
-    var username = uuid();
+    const username = uuid();
     // Because it waits for answer this takes some time..
-    return callbackTest((callback) => Realm.Sync.User.register('http://fake_host.local', username, 'password', callback), (error, user) => {
-      assertIsError(error);
-      TestCase.assertUndefined(user);
-    });
+    return Realm.Sync.User.register('http://fake_host.local', username, 'password')
+      .catch((e) => {})
+      .then((user) => { if (user) { throw new Error('should not have been able to register'); }})
   },
 
   testLogin() {
-      var username = uuid();
+      const username = uuid();
       // Create user, logout the new user, then login
-      return callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', username, 'password', callback), (error, user) => {
-        failOnError(error);
+      return Realm.Sync.User.register('http://localhost:9080', username, 'password').then((user) => {
         user.logout();
-
-        Realm.Sync.User.login('http://localhost:9080', username, 'password', (error, user) => {
-          failOnError(error);
+        return Realm.Sync.User.login('http://localhost:9080', username, 'password');
+      }).then((user => {
           assertIsUser(user);
-
           // Can we open a realm with the logged-in user?
-          var realm = new Realm({ sync: { user: user, url: 'realm://localhost:9080/~/test' } });
+          const realm = new Realm({ sync: { user: user, url: 'realm://localhost:9080/~/test' } });
           TestCase.assertInstanceOf(realm, Realm);
           realm.close();
-        });
-      });
+      }))
   },
 
   testLoginMissingUsername() {
-    return new Promise((resolve, _reject) => {
-        TestCase.assertThrows(() => {
-            Realm.Sync.User.login('http://localhost:9080', undefined, 'password', () => {});
-        });
-        resolve();
-    });
+    TestCase.assertThrows(() => Realm.Sync.User.login('http://localhost:9080', undefined, 'password'));
   },
 
   testLoginMissingPassword() {
-    var username = uuid();
-    return new Promise((resolve, _reject) => {
-        TestCase.assertThrows(() => {
-            Realm.Sync.User.login('http://localhost:9080', username, undefined, () => {});
-        });
-        resolve();
-    });
+    const username = uuid();
+    TestCase.assertThrows(() => Realm.Sync.User.login('http://localhost:9080', username, undefined));
   },
 
   testLoginNonExistingUser() {
-    return callbackTest((callback) => Realm.Sync.User.login('http://localhost:9080', 'does_not', 'exist', callback), (error, user) => {
-      assertIsAuthError(error, 611, "The provided credentials are invalid or the user does not exist.");
-      TestCase.assertUndefined(user);
-    });
+    return Realm.Sync.User.login('http://localhost:9080', 'does_not', 'exist')
+      .then((user) => { throw new Error(user); })
+      .catch((e) => assertIsAuthError(e, 611, "The provided credentials are invalid or the user does not exist."))
   },
 
   testLoginServerOffline() {
-    var username = uuid();
+    const username = uuid();
 
     // Because it waits for answer this takes some time..
-    return new Promise((resolve, reject) => {
-      Realm.Sync.User.register('http://fake_host.local', username, 'password', (error, user) => {
-        try {
-          assertIsError(error);
-          TestCase.assertUndefined(user);
-          resolve();
-        }
-        catch (e) { reject(e) }
-      });
-    });
+    return Realm.Sync.User.register('http://fake_host.local', username, 'password')
+      .then((user) => { throw new Error(user); })
+      .catch((e) => assertIsError(e));
   },
 
   testAll() {
-    return new Promise((resolve, reject) => {
-      let all;
-      all = Realm.Sync.User.all;
-      TestCase.assertArrayLength(Object.keys(all), 0);
+    const all = Realm.Sync.User.all;
+    TestCase.assertArrayLength(Object.keys(all), 0);
 
-      callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', uuid(), 'password', callback), (error, user1) => {
-        failOnError(error);
+    let user1;
+    return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password').then((user) => {
+      const all = Realm.Sync.User.all;
+      TestCase.assertArrayLength(Object.keys(all), 1);
+      assertIsSameUser(all[user.identity], user);
+      user1 = user;
 
+      return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password');
+    }).then((user2) => {
+        let all = Realm.Sync.User.all;
+        TestCase.assertArrayLength(Object.keys(all), 2);
+        // NOTE: the list of users is in latest-first order.
+        assertIsSameUser(all[user2.identity], user2);
+        assertIsSameUser(all[user1.identity], user1);
+
+        user2.logout();
         all = Realm.Sync.User.all;
         TestCase.assertArrayLength(Object.keys(all), 1);
         assertIsSameUser(all[user1.identity], user1);
 
-        Realm.Sync.User.register('http://localhost:9080', uuid(), 'password', (error, user2) => {
-          failOnError(error);
-
-          all = Realm.Sync.User.all;
-          TestCase.assertArrayLength(Object.keys(all), 2);
-          // NOTE: the list of users is in latest-first order.
-          assertIsSameUser(all[user2.identity], user2);
-          assertIsSameUser(all[user1.identity], user1);
-
-          user2.logout();
-          all = Realm.Sync.User.all;
-          TestCase.assertArrayLength(Object.keys(all), 1);
-          assertIsSameUser(all[user1.identity], user1);
-
-          user1.logout();
-          all = Realm.Sync.User.all;
-          TestCase.assertArrayLength(Object.keys(all), 0);
-          resolve();
-        });
-      }).catch(e => reject(e));
-    });
-  },
-
-  testCurrent() {
-      return new Promise((resolve, reject) => {
-        TestCase.assertUndefined(Realm.Sync.User.current);
-
-        callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', uuid(), 'password', callback), (error, user1) => {
-          failOnError(error);
-          assertIsSameUser(Realm.Sync.User.current, user1);
-
-          Realm.Sync.User.register('http://localhost:9080', uuid(), 'password', (error, user2) => {
-            failOnError(error);
-            TestCase.assertThrows(() => Realm.Sync.User.current, 'We expect Realm.Sync.User.current to throw if > 1 user.');
-            user2.logout();
-
-            assertIsSameUser(Realm.Sync.User.current, user1);
-
-            user1.logout();
-            TestCase.assertUndefined(Realm.Sync.User.current);
-
-            resolve();
-
-          });
-        }).catch(e => reject(e));
+        user1.logout();
+        all = Realm.Sync.User.all;
+        TestCase.assertArrayLength(Object.keys(all), 0);
       });
   },
 
-  testManagementRealm() {
-    return callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', uuid(), 'password', callback), (error, user) => {
-      failOnError(error);
+  testCurrent() {
+    TestCase.assertUndefined(Realm.Sync.User.current);
 
+    let user1;
+    return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password').then((user) => {
+      user1 = user;
+      assertIsSameUser(Realm.Sync.User.current, user1);
+
+      return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password');
+    }).then((user2) => {
+      TestCase.assertThrows(() => Realm.Sync.User.current, 'We expect Realm.Sync.User.current to throw if > 1 user.');
+      user2.logout();
+
+      assertIsSameUser(Realm.Sync.User.current, user1);
+
+      user1.logout();
+      TestCase.assertUndefined(Realm.Sync.User.current);
+    });
+  },
+
+  testManagementRealm() {
+    return Realm.Sync.User.register('http://localhost:9080', uuid(), 'password').then((user) => {
       let realm = user.openManagementRealm();
       TestCase.assertInstanceOf(realm, Realm);
 
-      let objectSchemaNames = realm.schema.map(o => o.name);
-      TestCase.assertArraysEqual(objectSchemaNames, [ 'PermissionChange', 'PermissionOffer', 'PermissionOfferResponse' ]);
+      TestCase.assertArraysEqual(realm.schema.map(o => o.name),
+                                 ['PermissionChange', 'PermissionOffer', 'PermissionOfferResponse']);
     });
   },
 
   testRetrieveAccount() {
-    return new Promise((resolve, reject) => {
-      if (!isNodeProcess) {
-        resolve();
-      }
+    if (!isNodeProcess) {
+      return;
+    }
 
-      if (!global.testAdminUserInfo) {
-        reject("Test requires an admin user");
-      }
+    if (!global.testAdminUserInfo) {
+      throw new Error("Test requires an admin user");
+    }
 
-      Realm.Sync.User.login('http://localhost:9080', global.testAdminUserInfo.username, global.testAdminUserInfo.password, (error, user) => {
-        if (error) {
-          reject(error);
-        }
+    return Realm.Sync.User.login('http://localhost:9080', global.testAdminUserInfo.username, global.testAdminUserInfo.password).then((user) => {
+      TestCase.assertTrue(user.isAdmin, "Test requires an admin user");
 
-        TestCase.assertTrue(user.isAdmin, "Test requires an admin user");
-
-        user.retrieveAccount('password', global.testAdminUserInfo.username)
-          .then(account => {
-            TestCase.assertEqual(account.accounts[0].provider_id, global.testAdminUserInfo.username);
-            TestCase.assertEqual(account.accounts[0].provider, 'password');
-            TestCase.assertTrue(account.is_admin);
-            TestCase.assertTrue(account.user_id);
-            resolve();
-          })
-          .catch(e => reject(e));
-      })
+      return user.retrieveAccount('password', global.testAdminUserInfo.username)
+    }).then((account) => {
+      TestCase.assertEqual(account.accounts[0].provider_id, global.testAdminUserInfo.username);
+      TestCase.assertEqual(account.accounts[0].provider, 'password');
+      TestCase.assertTrue(account.is_admin);
+      TestCase.assertTrue(account.user_id);
     });
   },
 
   testRetrieveNotExistingAccount() {
-    return new Promise((resolve, reject) => {
-      if (!isNodeProcess) {
-        resolve();
-      }
+    if (!isNodeProcess) {
+      return;
+    }
 
-      if (!global.testAdminUserInfo) {
-        reject("Test requires an admin user");
-      }
+    if (!global.testAdminUserInfo) {
+      throw new Error("Test requires an admin user");
+    }
 
-      Realm.Sync.User.login('http://localhost:9080', global.testAdminUserInfo.username, global.testAdminUserInfo.password, (error, user) => {
-        if (error) {
-          reject(error);
-        }
+    return Realm.Sync.User.login('http://localhost:9080', global.testAdminUserInfo.username, global.testAdminUserInfo.password).then((user) => {
+      TestCase.assertTrue(user.isAdmin, "Test requires an admin user");
 
-        TestCase.assertTrue(user.isAdmin, "Test requires an admin user");
-
-        let notExistingUsername = uuid();
-        user.retrieveAccount('password', notExistingUsername)
-          .then(account => {
-            reject("Retrieving not existing account should fail");
-          })
-          .catch(e => {
-            try {
-              TestCase.assertEqual(e.status, 404);
-              TestCase.assertEqual(e.code, 612);
-              TestCase.assertEqual(e.message, "The account does not exist.");
-              TestCase.assertEqual(e.type, "https://realm.io/docs/object-server/problems/unknown-account");
-            }
-            catch (e) {
-              reject(e);
-            }
-            resolve()
-          });
-      })
-    });
+      let notExistingUsername = uuid();
+      return user.retrieveAccount('password', notExistingUsername)
+    }).catch(e => {
+      TestCase.assertEqual(e.status, 404);
+      TestCase.assertEqual(e.code, 612);
+      TestCase.assertEqual(e.message, "The account does not exist.");
+      TestCase.assertEqual(e.type, "https://realm.io/docs/object-server/problems/unknown-account");
+    }).then(account => { if (account) { throw new Error("Retrieving nonexistent account should fail"); }});
   },
 
   /* This test fails because of realm-object-store #243 . We should use 2 users.