public void NotifyPropertyChanged_Test()
        {
            var model = new NavigationItemEditMock(123);
            var parentMock = Mock.Create<INavigationGroupViewModel>();
            var target = new NavigationItemViewModel();

            target.Initialize(model, parentMock);
            target.SelectedRoleId = 45;

            TestsHelper.TestPropertyWithNotifyPropertyChanged(target, () => target.CanMoveDown);
            TestsHelper.TestPropertyWithNotifyPropertyChanged(target, () => target.CanMoveUp);
            TestsHelper.TestPropertyWithNotifyPropertyChanged(target, () => target.IsVisible);
            TestsHelper.TestPropertyWithNotifyPropertyChanged(target, () => target.SelectedRoleId);
        }
        public void Initialize_Test()
        {
            var model = new NavigationItemEditMock(123);
            var parentMock = Mock.Create<INavigationGroupViewModel>();
            var target = new NavigationItemViewModel();
            var propertiesChanged = new List<string>();

            target.PropertyChanged += (o, e) => propertiesChanged.Add(e.PropertyName);

            target.Initialize(model, parentMock);

            Assert.AreSame(model, target.Model);
            Assert.AreSame(parentMock, target.Parent);
            Assert.IsTrue(propertiesChanged.Any(p => p == "IsVisible"));
            Assert.IsTrue(propertiesChanged.Any(p => p == "Model"));
            Assert.IsTrue(propertiesChanged.Any(p => p == "Parent"));
        }
        public void IsVisible_Test()
        {
            const int roleId = 123;

            var model = new NavigationItemEditMock(123);
            var parentMock = Mock.Create<INavigationGroupViewModel>();
            var target = new NavigationItemViewModel();

            target.Initialize(model, parentMock);
            target.SelectedRoleId = null;

            Assert.IsFalse(target.IsVisible);

            target.IsVisible = true;

            Assert.IsFalse(target.IsVisible);

            target.SelectedRoleId = roleId;

            Assert.IsFalse(target.IsVisible);

            target.IsVisible = true;

            Assert.IsTrue(target.IsVisible);
            Assert.IsTrue(model.GetCanView(roleId));

            target.SelectedRoleId = null;
            
            Assert.IsFalse(target.IsVisible);

            target.SelectedRoleId = roleId;
            target.IsVisible = false;

            Assert.IsFalse(target.IsVisible);
            Assert.IsFalse(model.GetCanView(roleId));
        }
        public void TurnOnItemVisibilityTurnsOnItsGroupVisibility()
        {
            var ng = new NavigationGroupViewModel { SelectedRoleId = 1 };
            Mock.NonPublic.Arrange(ng, "PopulateNavigationItems").DoNothing();

            var groupEdit = new NavigationGroupEdit();
            var groupConfig = new NavigationGroupSecurityConfigurationEdit { RoleId = 1, CanView = false };
            Mock.Arrange(() => groupConfig.IsChild).Returns(true);
            var groupConfigurations = new NavigationGroupSecurityConfigurationList { groupConfig };

            Mock.Arrange(() => groupConfigurations.IsChild).Returns(true);

            Mock.Arrange(() => groupEdit.SecurityConfigurations).Returns(groupConfigurations);
            ng.Initialize(groupEdit, new NavigationBuilderViewModel());

            var items = new ObservableCollection<INavigationItemViewModel>();

            var itemEdit = new NavigationItemEdit();
            var itemConfig = new NavigationItemSecurityConfigurationEdit { RoleId = 1, CanView = true };
            Mock.Arrange(() => itemConfig.IsChild).Returns(true);
            var itemConfigurations = new NavigationItemSecurityConfigurationList { itemConfig };

            Mock.Arrange(() => itemEdit.SecurityConfigurations).Returns(itemConfigurations);

            for (var i = 0; i < 3; i++)
            {
                var item = new NavigationItemViewModel { SelectedRoleId = 1 };
                item.Initialize(itemEdit, ng);
                item.IsVisible = false;
                items.Add(item);
            }

            ng.NavigationItems.AddRange(items);
            ng.IsVisible = false;

            ng.NavigationItems[0].IsVisible = true;

            Assert.IsTrue(ng.IsVisible);
        }
 public void PropertiesTest()
 {
     var item = new NavigationItemViewModel();
     TestsHelper.TestPublicPropertiesGetSet(item, x => item.IsVisible);
 }
        public void Initialize_Updates_IsReadOnly()
        {
            var parentMock = Mock.Create<INavigationGroupViewModel>();

            var target = new NavigationItemViewModel();

            var readOnlyPropertyHasChanged = false;

            var identityMock = Mock.Create<IMQ1Identity>();
            Mock.Arrange(() => identityMock.LicenseType).Returns(LicenseTypes.Concurrent);
            var principalMock = Mock.Create<IPrincipal>();
            Mock.Arrange(() => principalMock.Identity).Returns(identityMock);
            ApplicationContext.User = principalMock;

            Assert.IsFalse(target.IsReadOnly);

            Mock.Arrange(() => identityMock.LicenseType).Returns(LicenseTypes.Viewonly);

            target.PropertyChanged += (sender, args) =>
                {
                    if (args.PropertyName.Equals("IsReadOnly")) readOnlyPropertyHasChanged = true;
                };

            Assert.IsFalse(readOnlyPropertyHasChanged);

            target.Initialize(DataPortal.CreateChild<NavigationItemEdit>(), parentMock);

            Assert.IsTrue(readOnlyPropertyHasChanged);
            Assert.IsTrue(target.IsReadOnly);
        }
        public void RemoveCommand_Test()
        {
            var identityMock = Mock.Create<IMQ1Identity>();
            Mock.Arrange(() => identityMock.LicenseType).Returns(LicenseTypes.Viewonly);
            var principalMock = Mock.Create<IPrincipal>();
            Mock.Arrange(() => principalMock.Identity).Returns(identityMock);
            ApplicationContext.User = principalMock;

            var systemItem = DataPortal.CreateChild<NavigationItemEdit>();
            var item = DataPortal.CreateChild<NavigationItemEdit>();
            item.PublishedProcessId = 1;
            systemItem.SystemName = "test";
            systemItem.PublishedProcessId = null;

            var parentMock = Mock.Create<INavigationGroupViewModel>();
            var target = new NavigationItemViewModel();

            // Can't remove system item.
            target.Initialize(systemItem, parentMock);
            Assert.IsFalse(target.RemoveCommand.CanExecute(null));

            // Can't remove non-system item.
            target.Initialize(item, parentMock);
            Assert.IsFalse(target.RemoveCommand.CanExecute(null));

            // Can remove non-system item.         
            Mock.Arrange(() => identityMock.LicenseType).Returns(LicenseTypes.Concurrent);
            target.Initialize(item, parentMock);
            Assert.IsTrue(target.RemoveCommand.CanExecute(null));

            target.RemoveCommand.Execute(null);

            Mock.Assert(() => parentMock.RemoveItem(target), Occurs.Once());
        }
        public void MoveDownCommand_Test()
        {
            var identityMock = Mock.Create<IMQ1Identity>();
            var principalMock = Mock.Create<IPrincipal>();
            Mock.Arrange(() => principalMock.Identity).Returns(identityMock);
            ApplicationContext.User = principalMock;

            var systemItem = new NavigationItemEditMock(2, "test");
            var item = new NavigationItemEditMock(1);
            var parentMock = Mock.Create<INavigationGroupViewModel>();
            var target = new NavigationItemViewModel();

            // Can't move down any items
            Mock.Arrange(() => identityMock.LicenseType).Returns(LicenseTypes.Viewonly);

            target.CanMoveDown = false;
            target.Initialize(systemItem, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));
            target.Initialize(item, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));
            target.CanMoveDown = true;
            target.Initialize(systemItem, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));
            target.Initialize(item, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));

            Mock.Arrange(() => identityMock.LicenseType).Returns(LicenseTypes.Concurrent);

            // When CanMoveDown is false, MoveDownCommand.CanExecute returns false.
            target.CanMoveDown = false;

            // Can't move down system item.
            target.Initialize(systemItem, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));

            // Can't move down simple item.            
            target.Initialize(item, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));

            // When CanMoveDown is true, can move down only non-system items.
            target.CanMoveDown = true;

            // Can't move down system item.            
            target.Initialize(systemItem, parentMock);
            Assert.IsFalse(target.MoveDownCommand.CanExecute(null));

            // Can move down simple item.
            target.Initialize(item, parentMock);
            Assert.IsTrue(target.MoveDownCommand.CanExecute(null));

            target.CanMoveDown = true;

            target.MoveDownCommand.Execute(null);

            Mock.Assert(() => parentMock.MoveItemDown(target), Occurs.Once());
        }