Merge pull request #1319 from realm/blagoev/fix-2.0-tests

Blagoev/fix 2.0 tests

tests/js/admin-user-helper.js

@@ -2,92 +2,28 @@
 function node_require(module) {
     return require(module);
 }
-let fs = node_require("fs");
+
-let path = node_require("path");
 var Realm = node_require('realm');
 
-const DEFAULT_ADMIN_TOKEN_PATH = path.join(__dirname, "..", "..", "object-server-for-testing", "admin_token.base64");
+const adminName = "realm-admin"
-const ADMIN_TOKEN_PATH = process.env.ADMIN_TOKEN_PATH || DEFAULT_ADMIN_TOKEN_PATH;
+const password = '';
 
-function getAdminToken() {
-    if (fs.existsSync(ADMIN_TOKEN_PATH)) {
-        return fs.readFileSync(ADMIN_TOKEN_PATH, 'utf-8');
-    } else {
-        throw new Error("Missing the file with an admin token: " + ADMIN_TOKEN_PATH);
-    }
-}
-
-function random(min, max) {
-    min = Math.ceil(min);
-    max = Math.floor(max);
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-const newAdminName = 'admin' + random(1, 100000);
-const password = '123';
 exports.createAdminUser = function () {
-    let nonTokenUser, userIdentity, admin_token_user
     return new Promise((resolve, reject) => {
-        Realm.Sync.User.register('http://localhost:9080', newAdminName, password, (error, user) => {
+        Realm.Sync.User.login('http://localhost:9080', adminName, password, (error, user) => {
             if (error) {
                 reject(error);
                 return;
             }
-            nonTokenUser = user
+            
-            userIdentity = user.identity;
+            if (!user.isAdmin) {
-            user.logout();
+                reject(adminName + " user is not an admin user on this server");
-
-            admin_token_user = Realm.Sync.User.adminUser(getAdminToken(), 'http://localhost:9080');
-
-            const config = {
-                sync: {
-                    user: admin_token_user,
-                    url: 'realm://localhost:9080/__admin',
-                    error: err => {
-                        reject(new Error('Error opening __admin realm error:' + err.user  + ' url:' + err.url + ' state:' + err.state));
-                    }
-                }
-            };
-
-            resolve(Realm.open(config));
-        });
-    }).then(realm => {
-        let pendingAdminUser = realm.objectForPrimaryKey('User', userIdentity);
-        realm.write(() => {
-            pendingAdminUser.isAdmin = true;
-        });
-
-        admin_token_user.logout();
-    }).then(() => {
-        return new Promise((resolve, reject) => {
-            let isAdminRetryCounter = 0;
-            let waitForServerToUpdateAdminUser = function () {
-                isAdminRetryCounter++;
-                if (isAdminRetryCounter > 10) {
-                    reject("admin-user-helper: Create admin user timeout");
-                    return;
-                }
-
-                Realm.Sync.User.login('http://localhost:9080', newAdminName, password, (error, newAdminUser) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-
-                    let isAdmin = newAdminUser.isAdmin;
-                    nonTokenUser.logout();
-                    if (!isAdmin) {
-                        setTimeout(waitForServerToUpdateAdminUser, 500);
-                        return;
-                    }
-
-                    resolve({
-                        username: newAdminName,
-                        password
-                    });
-                });
             }
-            waitForServerToUpdateAdminUser();
+
+            resolve({
+                username: adminName,
+                password
+            });
         });
     });
 }

tests/js/user-tests.js

@@ -55,13 +55,13 @@ function assertIsError(error, message) {
   }
 }
 
-function assertIsAuthError(error, code, type) {
+function assertIsAuthError(error, code, title) {
   TestCase.assertInstanceOf(error, Realm.Sync.AuthError, 'The API should return an AuthError');
   if (code) {
     TestCase.assertEqual(error.code, code);
   }
-  if (type) {
+  if (title) {
-    TestCase.assertEqual(error.type, type);
+    TestCase.assertEqual(error.title, title);
   }
 }
 
@@ -123,13 +123,20 @@ module.exports = {
 
   testRegisterExistingUser() {
     var username = uuid();
-    return callbackTest((callback) => Realm.Sync.User.register('http://localhost:9080', username, 'password', callback), (error, user) => {
+    return new Promise((resolve, reject) => {
-      failOnError(error);
-      assertIsUser(user);
-
       Realm.Sync.User.register('http://localhost:9080', username, 'password', (error, user) => {
-        assertIsAuthError(error, 611, 'https://realm.io/docs/object-server/problems/invalid-credentials');
+        failOnError(error);
-        TestCase.assertUndefined(user);
+        assertIsUser(user);
+
+        Realm.Sync.User.register('http://localhost:9080', username, 'password', (error, user) => {
+         try { 
+            assertIsAuthError(error, 613, "The account cannot be registered as it exists already.");
+            TestCase.assertUndefined(user);
+            resolve();
+          } catch(e) { 
+           reject(e);
+          }
+        });
       });
     });
   },
@@ -202,7 +209,7 @@ module.exports = {
 
   testLoginNonExistingUser() {
     return callbackTest((callback) => Realm.Sync.User.login('http://localhost:9080', 'does_not', 'exist', callback), (error, user) => {
-      assertIsAuthError(error, 611, 'https://realm.io/docs/object-server/problems/invalid-credentials');
+      assertIsAuthError(error, 611, "The provided credentials are invalid.");
       TestCase.assertUndefined(user);
     });
   },
@@ -359,7 +366,12 @@ module.exports = {
             reject("Retrieving not existing account should fail");
           })
           .catch(e => {
-            TestCase.assertEqual(e.code, 404);
+            try {
+              TestCase.assertEqual(e.code, 404);
+            }
+            catch (e) {
+              reject(e);
+            }
             resolve()
           });
       })