Пример #1
0
        public void TestInternalGroupRemovedeventsNotPublished()
        {
            int roleSomethingUnassignedCount = 0;
            int groupSomethingRemovedCount = 0;
            DomainEventPublisher.Instance.Subscribe<GroupUnassignedFromRole>(e => roleSomethingUnassignedCount++);
            DomainEventPublisher.Instance.Subscribe<GroupGroupRemoved>(e => groupSomethingRemovedCount++);
            DomainEventPublisher.Instance.Subscribe<UserUnassignedFromRole>(e => roleSomethingUnassignedCount++);
            DomainEventPublisher.Instance.Subscribe<GroupUserRemoved>(e => groupSomethingRemovedCount++);

            Tenant tenant = this.CreateTenant();
            User user = this.CreateUser(tenant);
            Role managerRole = tenant.ProvisionRole("Manager", "A manager role.", true);
            Group group = new Group(user.TenantId, "Managers", "A group of managers.");

            Mock<IGroupRepository> groupRepository = new Mock<IGroupRepository>();
            groupRepository.Setup(r => r.GroupNamed(group.TenantId, group.Name)).Returns(group);
            Mock<IUserRepository> userRepository = new Mock<IUserRepository>();
            userRepository.Setup(r => r.UserWithUserName(user.TenantId, user.UserName)).Returns(user);

            GroupMemberService groupMemberService = new GroupMemberService(userRepository.Object, groupRepository.Object);

            managerRole.AssignGroup(group, groupMemberService);
            managerRole.AssignUser(user);

            managerRole.UnassignUser(user);
            managerRole.UnassignGroup(group);

            Assert.AreEqual(2, roleSomethingUnassignedCount);
            Assert.AreEqual(0, groupSomethingRemovedCount);
        }
Пример #2
0
        public virtual void AssignGroup(Group group, GroupMemberService groupMemberService)
        {
            AssertionConcern.True(this.SupportsNesting, "This role does not support group nestiong.");
            AssertionConcern.NotNull(group, "Group must not be null.");
            AssertionConcern.Equals(this.TenantId, group.TenantId, "Wrong tenant for this group.");

            this.Group.AddGroup(group, groupMemberService);

            DomainEventPublisher.Instance.Publish(new GroupAssignedToRole(this.TenantId, this.Name, group.Name));
        }
 public IdentityApplicationService(AuthenticationService authenticationService,
     GroupMemberService groupMemberService, TenantProvisioningService tenantProvisioningService,
     ITenantRepository tenantRepository, IGroupRepository groupRepository, IUserRepository userRepository)
 {
     this._authenticationService = authenticationService;
     this._groupMemberService = groupMemberService;
     this._groupRepository = groupRepository;
     this._tenantProvisioningService = tenantProvisioningService;
     this._tenantRepository = tenantRepository;
     this._userRepository = userRepository;
 }
Пример #4
0
        public virtual void AddGroup(Group group, GroupMemberService groupMemberService)
        {
            AssertionConcern.NotNull(group, "Group must not be null.");
            AssertionConcern.Equals(this.TenantId, group.TenantId, "Wrong tenant for this group.");
            AssertionConcern.False(groupMemberService.IsMemberGroup(group, this.ToGroupMember()), "Group recurrsion.");

            /*if (this.GroupMembers.Add(group.ToGroupMember()) && !this.IsInternalGroup) {
                DomainEventPublisher.Instance.Publish(new GroupGroupAdded(this.TenantId, this.Name, group.Name));
            }*/
            this.GroupMembers.Add(group.ToGroupMember());
            if(!this.IsInternalGroup) {
                DomainEventPublisher.Instance.Publish(new GroupGroupAdded(this.TenantId, this.Name, group.Name));
            }
        }
Пример #5
0
        public void TestNoRecursiveGroupings()
        {
            User user = this.CreateUser(this.CreateTenant());

            Group groupA = new Group(user.TenantId, "GroupA", "A group named GroupA.");
            Group groupB = new Group(user.TenantId, "GroupB", "A group named GroupB.");
            Group groupC = new Group(user.TenantId, "GroupC", "A group named GroupC.");

            Mock<IGroupRepository> groupRepository = new Mock<IGroupRepository>();
            groupRepository.Setup(r => r.GroupNamed(groupA.TenantId, groupA.Name)).Returns(groupA);
            groupRepository.Setup(r => r.GroupNamed(groupB.TenantId, groupB.Name)).Returns(groupB);
            groupRepository.Setup(r => r.GroupNamed(groupC.TenantId, groupC.Name)).Returns(groupC);
            Mock<IUserRepository> userRepository = new Mock<IUserRepository>();

            GroupMemberService groupMemberService = new GroupMemberService(userRepository.Object, groupRepository.Object);
            groupA.AddGroup(groupB, groupMemberService);
            groupB.AddGroup(groupC, groupMemberService);

            groupC.AddGroup(groupA, groupMemberService);
        }
        public void TestRemoveGroupReferencedUser()
        {
            Tenant tenant = this.CreateTenant();
            Group groupA = tenant.ProvisionGroup("GroupA", "A group named GroupA.");
            User user = this.CreateUser(tenant);
            this.UserRepository.Add(user);
            groupA.AddUser(user);
            this.GroupRepository.Add(groupA);

            GroupMemberService groupMemberService = new GroupMemberService(this.UserRepository, this.GroupRepository);

            Assert.AreEqual(1, groupA.GroupMembers.Count);
            Assert.IsTrue(groupA.IsMember(user, groupMemberService));

            this.UserRepository.Remove(user);

            Group reGroup = this.GroupRepository.GroupNamed(tenant.TenantId, "GroupA");

            Assert.AreEqual(1, reGroup.GroupMembers.Count);
            Assert.IsFalse(groupA.IsMember(user, groupMemberService));
        }
Пример #7
0
        public void TestUserIsNotMember()
        {
            User user = this.CreateUser(this.CreateTenant());

            Group groupA = new Group(user.TenantId, "GroupA", "A group named GroupA.");
            Group groupB = new Group(user.TenantId, "GroupB", "A group named GroupB.");

            Mock<IGroupRepository> groupRepository = new Mock<IGroupRepository>();
            groupRepository.Setup(r => r.GroupNamed(groupA.TenantId, groupA.Name)).Returns(groupA);
            groupRepository.Setup(r => r.GroupNamed(groupB.TenantId, groupB.Name)).Returns(groupB);
            Mock<IUserRepository> userRepository = new Mock<IUserRepository>();
            userRepository.Setup(r => r.UserWithUserName(user.TenantId, user.UserName)).Returns(user);

            GroupMemberService groupMemberService = new GroupMemberService(userRepository.Object, groupRepository.Object);

            Assert.IsFalse(groupB.IsMember(user, groupMemberService));
            Assert.IsFalse(groupA.IsMember(user, groupMemberService));
        }
Пример #8
0
        public void TestUserIsMemberOfNestedGroup()
        {
            int groupGroupAddedCount = 0;
            DomainEventPublisher.Instance.Subscribe<GroupGroupAdded>(e => groupGroupAddedCount++);

            Tenant tenant = this.CreateTenant();
            User user = this.CreateUser(tenant);

            Group groupA = tenant.ProvisionGroup("GroupA", "A group named GroupA.");
            Group groupB = tenant.ProvisionGroup("GroupB", "A group named GroupB.");

            Mock<IGroupRepository> groupRepository = new Mock<IGroupRepository>();
            groupRepository.Setup(r => r.GroupNamed(groupA.TenantId, groupA.Name)).Returns(groupA);
            groupRepository.Setup(r => r.GroupNamed(groupB.TenantId, groupB.Name)).Returns(groupB);
            Mock<IUserRepository> userRepository = new Mock<IUserRepository>();
            userRepository.Setup(r => r.UserWithUserName(user.TenantId, user.UserName)).Returns(user);

            GroupMemberService groupMemberService = new GroupMemberService(userRepository.Object, groupRepository.Object);

            groupA.AddGroup(groupB, groupMemberService);

            groupB.AddUser(user);

            Assert.IsTrue(groupB.IsMember(user, groupMemberService));
            Assert.IsTrue(groupA.IsMember(user, groupMemberService));

            Assert.AreEqual(1, groupGroupAddedCount);
        }
        protected override void SetUp()
        {
            this._tenantRepository = new Mock<ITenantRepository>();
            this._groupRepository = new Mock<IGroupRepository>();
            this._userRepository = new Mock<IUserRepository>();
            this._roleRepository = new Mock<IRoleRepository>();

            this._groupMemberService = new GroupMemberService(this._userRepository.Object, this._groupRepository.Object);

            this._accessApplicationService = new AccessApplicationService(
                this._tenantRepository.Object, this._groupRepository.Object, this._userRepository.Object, this._roleRepository.Object);

            base.SetUp();
        }
        protected override void SetUp()
        {
            base.SetUp();

            this._tenantRepository = new Mock<ITenantRepository>();
            this._groupRepository = new Mock<IGroupRepository>();
            this._userRepository = new Mock<IUserRepository>();
            this._roleRepository = new Mock<IRoleRepository>();

            this._authenticationService = new AuthenticationService(_tenantRepository.Object, _userRepository.Object,
                ServiceLocator.GetService<IEncryptionService>());
            this._groupMemberService = new GroupMemberService(this._userRepository.Object, this._groupRepository.Object);
            this._tenantProvisioningService = new TenantProvisioningService(_tenantRepository.Object,
                _userRepository.Object, _roleRepository.Object);

            this._identityApplicationService = new IdentityApplicationService(this._authenticationService,
                this._groupMemberService, this._tenantProvisioningService, this._tenantRepository.Object,
                this._groupRepository.Object, this._userRepository.Object);
        }
Пример #11
0
        public void TestUserIsInRole()
        {
            Tenant tenant = this.CreateTenant();
            User user = this.CreateUser(tenant);
            Role managerRole = tenant.ProvisionRole("Manager", "A manager role.", true);
            Group group = new Group(user.TenantId, "Managers", "A group of managers.");

            Mock<IGroupRepository> groupRepository = new Mock<IGroupRepository>();
            groupRepository.Setup(r => r.GroupNamed(group.TenantId, group.Name)).Returns(group);
            Mock<IUserRepository> userRepository = new Mock<IUserRepository>();
            userRepository.Setup(r => r.UserWithUserName(user.TenantId, user.UserName)).Returns(user);

            GroupMemberService groupMemberService = new GroupMemberService(userRepository.Object, groupRepository.Object);

            managerRole.AssignGroup(group, groupMemberService);
            group.AddUser(user);

            Assert.IsTrue(group.IsMember(user, groupMemberService));
            Assert.IsTrue(managerRole.IsInRole(user, groupMemberService));
        }
Пример #12
0
 public virtual bool IsInRole(User user, GroupMemberService groupMemberService)
 {
     return this.Group.IsMember(user, groupMemberService);
 }
Пример #13
0
        public virtual bool IsMember(User.User user, GroupMemberService groupMemberService)
        {
            AssertionConcern.NotNull(user, "User must not be null.");
            AssertionConcern.Equals(this.TenantId, user.TenantId, "Wrong tenant for this group.");
            AssertionConcern.True(user.IsEnabled, "User is not enabled.");

            bool isMember = this.GroupMembers.Contains(user.ToGroupMember());

            if(isMember) {
                isMember = groupMemberService.ConfirmUser(this, user);
            }
            else {
                isMember = groupMemberService.IsUserInNestedGroup(this, user);
            }

            return isMember;
        }