public void UserChangesAndWorkspaceItemsChange()
        {
            // Arrange
            var vm          = viewModelFactory.GetViewModel <LocalUserViewModel>();
            var workspaceVm = viewModelFactory.GetViewModel <WorkspaceViewModel>();
            var user1       = DesignTimeHelper.GetGuestUser();
            var user2       = DesignTimeHelper.GetRegisteredUser();

            Assert.IsNull(vm.UserSharedFileCollectionVm);
            vm.Model = user1;
            Assert.IsNotNull(vm.UserSharedFileCollectionVm);
            var sharedFileVms = vm.UserSharedFileCollectionVm.ViewModels;

            workspaceVm.WorkspaceItems.RegisterObservedCollection(sharedFileVms);
            foreach (var sharedFile in user1.SharedFiles)
            {
                Assert.IsTrue(vm.UserSharedFileCollectionVm.ViewModels.Any(sfvm => sfvm.Model == sharedFile));
                Assert.IsTrue(workspaceVm.WorkspaceItems.Any(item => (item as SharedFileViewModel).Model == sharedFile));
            }

            // Act
            vm.Model = user2;

            // Assert
            Assert.AreEqual(sharedFileVms, vm.UserSharedFileCollectionVm.ViewModels);
            foreach (var sharedFile in user2.SharedFiles)
            {
                Assert.IsTrue(vm.UserSharedFileCollectionVm.ViewModels.Any(sfvm => sfvm.Model == sharedFile));
                Assert.IsTrue(workspaceVm.WorkspaceItems.Any(item => (item as SharedFileViewModel).Model == sharedFile));
            }
        }
        public void ApproveModerationTest_Invitation()
        {
            // Arrange dependencies
            var requests = viewModelFactory.GetViewModel <ModerationRequestCollectionViewModel>();

            requests.Models = DesignTimeHelper.GetModerationRequests(DesignTimeHelper.GetGuestUser());
            var grantsVm  = viewModelFactory.GetViewModel <RoomPermissionGrantCollectionViewModel>();
            var requestVm = requests.ViewModels[0];
            var roomVm    = viewModelFactory.GetViewModel <RoomViewModel>();

            roomVm.Model = room;
            var localUserVm = viewModelFactory.GetViewModel <LocalUserViewModel>();

            localUserVm.Model = user;

            // Configure mock RoomServiceAdapter.
            mockRoomService.Setup(rs => rs.CreateInvitation(It.IsAny <LoginSession>(), It.IsAny <Guid>(), It.IsAny <Invitation>(), It.IsAny <OperationCallback>()))
            .Callback((LoginSession loginSessionId, Guid roomId, Invitation invitation, OperationCallback callback) =>
            {
                Assert.IsNotNull(invitation);
                Assert.AreEqual(user.UserId, invitation.UserId);
                Assert.AreEqual(room.RoomId, invitation.RoomId);
                callback(null);
            });
            mockRoomService.Setup(rs => rs.UpdateRoomPermissionsForInvitation(It.IsAny <LoginSession>(), It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <ObservableCollection <RoomPermissionGrant> >(), It.IsAny <OperationCallback>()))
            .Callback((LoginSession loginSessionId, Guid moderationRequestId, Guid securityPrincipalId, ObservableCollection <RoomPermissionGrant> grants, OperationCallback callback) =>
            {
                Assert.AreEqual(2, grants.Count);
                Assert.AreEqual(1, grants.Count(g => g.RoomPermissionTag == "Share"));
                Assert.AreEqual(1, grants.Count(g => g.RoomPermissionTag == "Join"));
                callback(null);
            });

            // Affirm
            Assert.IsTrue(requestVm.Model.ModerationRequestedRoomPermissions.Count > 0);
            Assert.IsTrue(requestVm.Model.ModerationRequestedRoomPermissions.All(p => !string.IsNullOrEmpty(p.RoomPermissionTag)));

            // Act
            grantsVm.ApproveModerationRequest(requestVm);

            // Assert
            mockRoomService.VerifyAll();
            Assert.AreEqual(1, grantsVm.SecurityPrincipals.OfType <InvitationViewModel>().Count());
            var invitationVm = grantsVm.SecurityPrincipals.OfType <InvitationViewModel>().First();

            Assert.AreEqual(requestVm.Model.ModerationRequestedRoomPermissions.Count, invitationVm.RoomPermissionGrants.ViewModelCount);
            foreach (var grantvm in invitationVm.RoomPermissionGrants.ViewModels)
            {
                string roomPermissionTag = grantvm.Model.RoomPermissionTag;
                Assert.AreEqual(RoomPermissionScopeValues.Invitation, grantvm.Model.RoomPermissionScopeTag);
                Assert.AreEqual(1, requestVm.Model.ModerationRequestedRoomPermissions.Count(p => p.RoomPermissionTag == roomPermissionTag));
            }
        }
        public virtual void TestInit()
        {
            DesignTimeHelper.Reset();
            mockMessageService = GetMockMessageService();
            messageService     = mockMessageService.Object;
            viewLocator        = new ViewLocator();
            mockRoomService    = GetMockRoomService();
            roomService        = mockRoomService.Object;
            viewModelFactory   = new ViewModelFactory(roomService, messageService, viewLocator);

            user      = DesignTimeHelper.GetRegisteredUser();
            room      = DesignTimeHelper.GetRoom();
            guestUser = DesignTimeHelper.GetGuestUser();

            // Wait to kick off any of the actual tests until the basic test initialization has completed.
            EnqueueConditional(() => TestGlobals.Initialized);
            EnqueueTestComplete();
        }
        public void UserChangesAndClosedWorkspaceItemsChange()
        {
            // Arrange
            var localUserVm = viewModelFactory.GetViewModel <LocalUserViewModel>();
            var workspaceVm = viewModelFactory.GetViewModel <WorkspaceViewModel>();
            var user1       = DesignTimeHelper.GetGuestUser();
            var user2       = DesignTimeHelper.GetRegisteredUser();
            var wb1         = new Data.RoomService.Whiteboard()
            {
                WhiteboardId = Guid.NewGuid(), User = user2, IsClosed = true
            };
            var wbVm1 = viewModelFactory.GetViewModel <WhiteboardViewModel>(w => w.WorkspaceItemId == wb1.WhiteboardId);

            wbVm1.Model = wb1;
            var wb2 = new Data.RoomService.Whiteboard()
            {
                WhiteboardId = Guid.NewGuid(), User = user2, IsClosed = true
            };
            var wbVm2 = viewModelFactory.GetViewModel <WhiteboardViewModel>(w => w.WorkspaceItemId == wb2.WhiteboardId);

            wbVm2.Model = wb2;
            workspaceVm.ClosedWorkspaceItems.Triggers.Add(localUserVm);
            workspaceVm.WorkspaceItems.Add(wbVm1);
            workspaceVm.WorkspaceItems.Add(wbVm2);
            localUserVm.Model = user1;
            Assert.IsTrue(wbVm1.IsReady && !wbVm1.IsShareAvailable && !wbVm1.IsShared);
            Assert.IsTrue(wbVm2.IsReady && !wbVm2.IsShareAvailable && !wbVm2.IsShared);

            // The whiteboards shouldn't initially show up in the closed workspace items because
            // they aren't owned by the current local user.
            Assert.IsFalse(workspaceVm.ClosedWorkspaceItems.Contains(wbVm1));
            Assert.IsFalse(workspaceVm.ClosedWorkspaceItems.Contains(wbVm2));

            // Act
            localUserVm.Model = user2;

            // Assert
            // The whiteboards should now show up in the closed workspace items because
            // they're owned by the new local user.
            Assert.IsTrue(wbVm1.IsReady && wbVm1.IsShareAvailable && !wbVm1.IsShared);
            Assert.IsTrue(wbVm2.IsReady && wbVm2.IsShareAvailable && !wbVm2.IsShared);
            Assert.IsTrue(workspaceVm.ClosedWorkspaceItems.Contains(wbVm1));
            Assert.IsTrue(workspaceVm.ClosedWorkspaceItems.Contains(wbVm2));
        }