Adds index on _Role name property (#3586)

* Adds index on _Role name property

In order to avoid having different _Role objects with the same name, adding an index on the name property of _Role is necessary.

Fixes #3579

* Uses throw instead of Promise.reject when enforcing unique indexes

* Fixes wrong sorting of results in schemas tests

Author: natanrolnik

spec/ParseRole.spec.js

@@ -192,6 +192,24 @@ describe('Parse Role testing', () => {
     });
   });
 
+  it("Different _Role objects cannot have the same name.", (done) => {
+    const roleName = "MyRole";
+    let aUser;
+    createTestUser().then((user) => {
+      aUser = user;
+      return createRole(roleName, null, aUser);
+    }).then((firstRole) => {
+      expect(firstRole.getName()).toEqual(roleName);
+      return createRole(roleName, null, aUser);
+    }).then(() => {
+      fail("_Role cannot have the same name as another role");
+      done();
+    }, (error) => {
+      expect(error.code).toEqual(137);
+      done();
+    });
+  });
+
   it("Should properly resolve roles", (done) => {
     const admin = new Parse.Role("Admin", new Parse.ACL());
     const moderator = new Parse.Role("Moderator", new Parse.ACL());

spec/Schema.spec.js

@@ -494,7 +494,8 @@ describe('SchemaController', () => {
 
   it('creates non-custom classes which include relation field', done => {
     config.database.loadSchema()
-    .then(schema => schema.addClassIfNotExists('_Role', {}))
+    //as `_Role` is always created by default, we only get it here
+    .then(schema => schema.getOneSchema('_Role'))
     .then(actualSchema => {
       const expectedSchema = {
         className: '_Role',

spec/schemas.spec.js

@@ -102,6 +102,20 @@ const userSchema = {
   "classLevelPermissions": defaultClassLevelPermissions,
 }
 
+const roleSchema = {
+  "className": "_Role",
+  "fields": {
+    "objectId": {"type": "String"},
+    "createdAt": {"type": "Date"},
+    "updatedAt": {"type": "Date"},
+    "ACL": {"type": "ACL"},
+    "name":  {"type":"String"},
+    "users": {"type":"Relation", "targetClass":"_User"},
+    "roles": {"type":"Relation", "targetClass":"_Role"}
+  },
+  "classLevelPermissions": defaultClassLevelPermissions,
+}
+
 var noAuthHeaders = {
   'X-Parse-Application-Id': 'test',
 };
@@ -166,7 +180,10 @@ describe('schemas', () => {
       json: true,
       headers: masterKeyHeaders,
     }, (error, response, body) => {
-      expect(dd(body.results, [userSchema])).toEqual();
+      var expected = {
+        results: [userSchema,roleSchema]
+      };
+      expect(dd(body.results.sort((s1, s2) => s1.className > s2.className), expected.results.sort((s1, s2) => s1.className > s2.className))).toEqual(undefined);
       done();
     });
   });
@@ -186,9 +203,9 @@ describe('schemas', () => {
         headers: masterKeyHeaders,
       }, (error, response, body) => {
         var expected = {
-          results: [userSchema,plainOldDataSchema,pointersAndRelationsSchema]
+          results: [userSchema,roleSchema,plainOldDataSchema,pointersAndRelationsSchema]
         };
-        expect(dd(body, expected)).toEqual(undefined);
+        expect(dd(body.results.sort((s1, s2) => s1.className > s2.className), expected.results.sort((s1, s2) => s1.className > s2.className))).toEqual(undefined);
         done();
       })
     });

src/Controllers/DatabaseController.js

@@ -909,27 +909,37 @@ DatabaseController.prototype.addPointerPermissions = function(schema, className,
 // have a Parse app without it having a _User collection.
 DatabaseController.prototype.performInitialization = function() {
   const requiredUserFields = { fields: { ...SchemaController.defaultColumns._Default, ...SchemaController.defaultColumns._User } };
+  const requiredRoleFields = { fields: { ...SchemaController.defaultColumns._Default, ...SchemaController.defaultColumns._Role } };
 
   const userClassPromise = this.loadSchema()
     .then(schema => schema.enforceClassExists('_User'))
+  const roleClassPromise = this.loadSchema()
+    .then(schema => schema.enforceClassExists('_Role'))
 
   const usernameUniqueness = userClassPromise
     .then(() => this.adapter.ensureUniqueness('_User', requiredUserFields, ['username']))
     .catch(error => {
       logger.warn('Unable to ensure uniqueness for usernames: ', error);
-      return Promise.reject(error);
+      throw error;
     });
 
   const emailUniqueness = userClassPromise
     .then(() => this.adapter.ensureUniqueness('_User', requiredUserFields, ['email']))
     .catch(error => {
       logger.warn('Unable to ensure uniqueness for user email addresses: ', error);
-      return Promise.reject(error);
+      throw error;
+    });
+
+  const roleUniqueness = roleClassPromise
+    .then(() => this.adapter.ensureUniqueness('_Role', requiredRoleFields, ['name']))
+    .catch(error => {
+      logger.warn('Unable to ensure uniqueness for role name: ', error);
+      throw error;
     });
 
   // Create tables for volatile classes
   const adapterInit = this.adapter.performInitialization({ VolatileClassesSchemas: SchemaController.VolatileClassesSchemas });
-  return Promise.all([usernameUniqueness, emailUniqueness, adapterInit]);
+  return Promise.all([usernameUniqueness, emailUniqueness, roleUniqueness, adapterInit]);
 }
 
 function joinTableName(className, key) {