kami-parse-server/spec/ParseRole.spec.js

"use strict";

// Roles are not accessible without the master key, so they are not intended
// for use by clients.  We can manually test them using the master key.
var Auth = require("../src/Auth").Auth;
var Config = require("../src/Config");

describe('Parse Role testing', () => {

  it('Do a bunch of basic role testing', (done) => {

    var user;
    var role;

    createTestUser().then((x) => {
      user = x;
      role = new Parse.Object('_Role');
      role.set('name', 'Foos');
      var users = role.relation('users');
      users.add(user);
      return role.save({}, { useMasterKey: true });
    }).then((x) => {
      var query = new Parse.Query('_Role');
      return query.find({ useMasterKey: true });
    }).then((x) => {
      expect(x.length).toEqual(1);
      var relation = x[0].relation('users').query();
      return relation.first({ useMasterKey: true });
    }).then((x) => {
      expect(x.id).toEqual(user.id);
      // Here we've got a valid role and a user assigned.
      // Lets create an object only the role can read/write and test
      // the different scenarios.
      var obj = new Parse.Object('TestObject');
      var acl = new Parse.ACL();
      acl.setPublicReadAccess(false);
      acl.setPublicWriteAccess(false);
      acl.setRoleReadAccess('Foos', true);
      acl.setRoleWriteAccess('Foos', true);
      obj.setACL(acl);
      return obj.save();
    }).then((x) => {
      var query = new Parse.Query('TestObject');
      return query.find({ sessionToken: user.getSessionToken() });
    }).then((x) => {
      expect(x.length).toEqual(1);
      var objAgain = x[0];
      objAgain.set('foo', 'bar');
      // This should succeed:
      return objAgain.save({}, {sessionToken: user.getSessionToken()});
    }).then((x) => {
      x.set('foo', 'baz');
      // This should fail:
      return x.save({},{sessionToken: ""});
    }).then((x) => {
      fail('Should not have been able to save.');
    }, (e) => {
      done();
    });

  });

  it("should recursively load roles", (done) => {

    var rolesNames = ["FooRole", "BarRole", "BazRole"];

    var createRole = function(name, sibling, user) {
      var role = new Parse.Role(name, new Parse.ACL());
      if (user) {
        var users = role.relation('users');
        users.add(user);
      }
      if (sibling) {
        role.relation('roles').add(sibling);
      }
      return role.save({}, { useMasterKey: true });
    }
    var roleIds = {};
     createTestUser().then( (user) => {
       // Put the user on the 1st role
       return createRole(rolesNames[0], null, user).then( (aRole) => {
         roleIds[aRole.get("name")] = aRole.id;
         // set the 1st role as a sibling of the second
         // user will should have 2 role now
          return createRole(rolesNames[1], aRole, null);
       }).then( (anotherRole) => {
         roleIds[anotherRole.get("name")] = anotherRole.id;
         // set this role as a sibling of the last
         // the user should now have 3 roles
         return createRole(rolesNames[2], anotherRole, null);
       }).then( (lastRole) => {
         roleIds[lastRole.get("name")] = lastRole.id;
         var auth = new Auth({ config: new Config("test"), isMaster: true, user: user });
         return auth._loadRoles();
       })
     }).then( (roles) => {
       expect(roles.length).toEqual(3);
       rolesNames.forEach( (name) => {
        expect(roles.indexOf('role:'+name)).not.toBe(-1);
       })
       done();
     }, function(err){
       fail("should succeed")
       done();
     });
  });

  it("_Role object should not save without name.", (done) => {
    var role = new Parse.Role();
    role.save(null,{useMasterKey:true})
    .then((r) => {
      fail("_Role object should not save without name.");
    }, (error) => {
      expect(error.code).toEqual(111);
      role.set('name','testRole');
      role.save(null,{useMasterKey:true})
      .then((r2)=>{
        fail("_Role object should not save without ACL.");
      }, (error2) =>{
        expect(error2.code).toEqual(111);
        done();
      });
    });
  });
  
  it("Should properly resolve roles", (done) => {
    let admin = new Parse.Role("Admin", new Parse.ACL());
    let moderator = new Parse.Role("Moderator", new Parse.ACL());
    let superModerator = new Parse.Role("SuperModerator", new Parse.ACL());
    let contentManager = new Parse.Role('ContentManager', new Parse.ACL());
    let superContentManager = new Parse.Role('SuperContentManager', new Parse.ACL());
    Parse.Object.saveAll([admin, moderator, contentManager, superModerator, superContentManager], {useMasterKey: true}).then(() => {
      contentManager.getRoles().add([moderator, superContentManager]);
      moderator.getRoles().add([admin, superModerator]);
      superContentManager.getRoles().add(superModerator);
      return Parse.Object.saveAll([admin, moderator, contentManager, superModerator, superContentManager], {useMasterKey: true});
    }).then(() => { 
      var auth = new Auth({ config: new Config("test"), isMaster: true });
      // For each role, fetch their sibling, what they inherit
      // return with result and roleId for later comparison
      let promises = [admin, moderator, contentManager, superModerator].map((role) => {
        return auth._getAllRoleNamesForId(role.id).then((result) => {
          return Parse.Promise.as({
            id: role.id,
            name: role.get('name'),
            roleIds: result
          });
        })
      });
      
      return Parse.Promise.when(promises);
    }).then((results) => {
      results.forEach((result) => {
        let id = result.id;
        let roleIds = result.roleIds;
        if (id == admin.id) {
          expect(roleIds.length).toBe(2);
          expect(roleIds.indexOf(moderator.id)).not.toBe(-1);
          expect(roleIds.indexOf(contentManager.id)).not.toBe(-1);
        } else if (id == moderator.id) {
          expect(roleIds.length).toBe(1);
          expect(roleIds.indexOf(contentManager.id)).toBe(0);
        } else if (id == contentManager.id) {
          expect(roleIds.length).toBe(0);
        } else if (id == superModerator.id) {
          expect(roleIds.length).toBe(3);
          expect(roleIds.indexOf(moderator.id)).not.toBe(-1);
          expect(roleIds.indexOf(contentManager.id)).not.toBe(-1);
          expect(roleIds.indexOf(superContentManager.id)).not.toBe(-1);
        }
      });
      done();
    }).fail((err) => {
      console.error(err);
      done();
    })
    
  });

  it('can create role and query empty users', (done)=> {
    var roleACL = new Parse.ACL();
    roleACL.setPublicReadAccess(true);
    var role = new Parse.Role('subscribers', roleACL);
    role.save({}, {useMasterKey : true})
      .then((x)=>{
        var query = role.relation('users').query();
        query.find({useMasterKey : true})
          .then((users)=>{
            done();
          }, (e)=>{
            fail('should not have errors');
            done();
          });
      }, (e) => {
        console.log(e);
        fail('should not have errored');
      });
  });

});