public void OpenNullLineItemDoesntStartProcess() { ImportService.CurrentContext = _importServiceContext; var vm = new DebugOutputViewModel(); vm.OpenMoreLink(null); Assert.IsNull(vm.ProcessController); }
/// <summary> /// Child classes can override this method to perform /// clean-up logic, such as removing event handlers. /// </summary> protected override void OnDispose() { if (_environmentModel != null) { _environmentModel.IsConnectedChanged -= EnvironmentModelOnIsConnectedChanged(); if (_environmentModel.Connection != null) { // ReSharper disable DelegateSubtraction _environmentModel.Connection.ReceivedResourceAffectedMessage -= OnReceivedResourceAffectedMessage; } } if (DebugOutputViewModel != null) { DebugOutputViewModel.Dispose(); } var model = DataListViewModel as SimpleBaseViewModel; if (model != null) { DataListViewModel.Parent = null; model.Dispose(); DataListViewModel.Dispose(); } base.OnDispose(); }
/// <summary> /// Child classes can override this method to perform /// clean-up logic, such as removing event handlers. /// </summary> protected override void OnDispose() { if (_server != null) { _server.IsConnectedChanged -= EnvironmentModelOnIsConnectedChanged(); if (_server.Connection != null) { // ReSharper disable DelegateSubtraction _server.Connection.ReceivedResourceAffectedMessage -= OnReceivedResourceAffectedMessage; } } DebugOutputViewModel?.Dispose(); var model = DataListViewModel as SimpleBaseViewModel; if (model != null) { DataListViewModel.Parent = null; model.Dispose(); DataListViewModel.Dispose(); } var ws = (WorkSurfaceViewModel as IDisposable); ws?.Dispose(); base.OnDispose(); }
public void DebugOutputViewModel_AppendWhenDebugStateFinishedShouldNotWriteItems_ItemIsMessage() { var mock1 = new Mock <IDebugState>(); var mock2 = new Mock <IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.Message).Returns("Some message"); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock1.SetupGet(m => m.StateType).Returns(StateType.Message); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.Message).Returns("Some message"); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object); mock1.Setup(m => m.SessionID).Returns(vm.SessionID); mock2.Setup(m => m.SessionID).Returns(vm.SessionID); vm.DebugStatus = DebugStatus.Finished; vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.AreEqual(1, vm.RootItems.Count); var root = vm.RootItems[0] as DebugStringTreeViewItemViewModel; Assert.IsNotNull(root); }
public void DebugOutputViewModel_AppendNestedDebugstatesExpectNestedInRootItems() { var mock1 = new Mock <IDebugState>(); var mock2 = new Mock <IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ID).Returns(Guid.NewGuid()); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object); mock1.Setup(m => m.SessionID).Returns(vm.SessionID); mock2.Setup(m => m.SessionID).Returns(vm.SessionID); vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.AreEqual(1, vm.RootItems.Count); var root = vm.RootItems.First() as DebugStateTreeViewItemViewModel; Assert.IsNotNull(root); Assert.AreEqual(root.Content, mock1.Object, "Root item incorrectly appended"); var firstChild = root.Children.First() as DebugStateTreeViewItemViewModel; Assert.IsNotNull(firstChild); Assert.IsTrue(firstChild.Content.ParentID.Equals(_firstResourceID)); }
public void DebugOutputViewModel_Append_ItemRemoteHasNoPermission_ShouldNotAddAsNewItemIntoTree() { //------------Setup for test-------------------------- var id = Guid.NewGuid(); var envRepo = GetEnvironmentRepository(); var mockAuthorizationService = new Mock <IAuthorizationService>(); mockAuthorizationService.Setup(service => service.GetResourcePermissions(It.IsAny <Guid>())).Returns(Permissions.None); _environmentModel.Setup(model => model.AuthorizationService).Returns(mockAuthorizationService.Object); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; viewModel.Append(content); var content2 = new DebugState { DisplayName = "Content2", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID, EnvironmentID = Guid.NewGuid() }; //------------Execute Test--------------------------- viewModel.Append(content2); //------------Assert Results------------------------- Assert.AreEqual(1, viewModel.RootItems.Count); }
void DebugOutputViewModel_Append_ContentIsDebugStateErrors(bool parentContentHasErrors, bool childContentHasErrors) { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); var parentContent = new DebugState { HasError = parentContentHasErrors, DisplayName = "Content", ID = Guid.NewGuid(), ParentID = Guid.Empty, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; var childContent = new DebugState { HasError = childContentHasErrors, DisplayName = "Content", ID = Guid.NewGuid(), ParentID = parentContent.ID, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(parentContent); viewModel.Append(childContent); //------------Assert Results------------------------- Assert.AreEqual(2, viewModel.ContentItemCount); Assert.AreEqual(1, viewModel.RootItems.Count); var childItem = viewModel.RootItems[0].Children[0]; Assert.AreEqual(childContentHasErrors, childItem.HasError); Assert.AreEqual(parentContentHasErrors, childItem.Parent.HasError); }
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel, Task <IResourcePickerDialog> getResourcePicker = null) : base(eventPublisher) { SchedulerTaskManager = new SchedulerTaskManager(this, getResourcePicker); VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker); DirectoryObjectPickerDialog directoryObjectPicker1 = directoryObjectPicker; VerifyArgument.IsNotNull("popupController", popupController); _popupController = popupController; VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _asyncWorker = asyncWorker; _toEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel()); Errors = new ErrorResultTO(); IsLoading = false; directoryObjectPicker1.AllowedObjectTypes = ObjectTypes.Users; directoryObjectPicker1.DefaultObjectTypes = ObjectTypes.Users; directoryObjectPicker1.AllowedLocations = Locations.All; directoryObjectPicker1.DefaultLocations = Locations.JoinedDomain; directoryObjectPicker1.MultiSelect = false; directoryObjectPicker1.TargetComputer = string.Empty; directoryObjectPicker1.ShowAdvancedView = false; InitializeHelp(); DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), ServerRepository.Instance, new DebugOutputFilterStrategy()); Server = server; SetupServer(server); SetDisplayName(false); }
public void DebugOutputViewModelCantOpenNullMoreLinkLineItem() { ImportService.CurrentContext = _importServiceContext; var vm = new DebugOutputViewModel(); Assert.IsTrue(vm.CanOpenMoreLink(null).Equals(false)); }
public void DebugOutputViewModel_PendingQueueExpectedQueuesMessagesAndFlushesWhenFinishedProcessing() { var envRepo = GetEnvironmentRepository(); var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object) { DebugStatus = DebugStatus.Executing }; for (var i = 0; i < 10; i++) { var state = new Mock <IDebugState>(); var stateType = i % 2 == 0 ? StateType.Message : StateType.After; state.Setup(s => s.StateType).Returns(stateType); state.Setup(s => s.SessionID).Returns(vm.SessionID); vm.Append(state.Object); } Assert.AreEqual(5, vm.PendingItemCount); Assert.AreEqual(5, vm.ContentItemCount); vm.DebugStatus = DebugStatus.Finished; Assert.AreEqual(0, vm.PendingItemCount); Assert.AreEqual(10, vm.ContentItemCount); }
public void DebugOutputViewModel_OpenItemWithRemoteEnvironment_OpensResourceFromRemoteEnvironment() { const string ResourceName = "TestResource"; var environmentID = Guid.NewGuid(); var envList = new List <IEnvironmentModel>(); var envRepository = new Mock <IEnvironmentRepository>(); envRepository.Setup(e => e.All()).Returns(envList); var env = new Mock <IEnvironmentModel>(); env.Setup(e => e.ID).Returns(environmentID); env.Setup(e => e.IsConnected).Returns(true); // If we get here then we've found the environment based on the environment ID! env.Setup(e => e.ResourceRepository.FindSingle(It.IsAny <Expression <Func <IResourceModel, bool> > >(), false, false)).Verifiable(); envList.Add(env.Object); var model = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepository.Object, new Mock <IDebugOutputFilterStrategy>().Object); var debugState = new DebugState { ActivityType = ActivityType.Workflow, DisplayName = ResourceName, EnvironmentID = environmentID }; model.OpenItemCommand.Execute(debugState); env.Verify(e => e.ResourceRepository.FindSingle(It.IsAny <Expression <Func <IResourceModel, bool> > >(), false, false)); }
public void DebugOutputViewModel_IsProcessing_ReflectsDebugStatus() { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object) { DebugStatus = DebugStatus.Executing }; //------------Execute Test--------------------------- //------------Assert Results------------------------- Assert.IsTrue(viewModel.IsProcessing); viewModel.DebugStatus = DebugStatus.Configure; Assert.IsTrue(viewModel.IsProcessing); viewModel.DebugStatus = DebugStatus.Ready; Assert.IsFalse(viewModel.IsProcessing); viewModel.DebugStatus = DebugStatus.Finished; Assert.IsFalse(viewModel.IsProcessing); viewModel.DebugStatus = DebugStatus.Stopping; Assert.IsFalse(viewModel.IsProcessing); }
public void DebugOutputViewModel_Append_WhenDebugIsInFinishedState_MessageIsAddedBeforeAndAfterLastItem() { var envRepo = GetEnvironmentRepository(); var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object) { DebugStatus = DebugStatus.Finished }; var state = new Mock <IDebugState>(); state.Setup(s => s.StateType).Returns(StateType.After); state.Setup(s => s.SessionID).Returns(vm.SessionID); vm.Append(state.Object); state = new Mock <IDebugState>(); state.Setup(s => s.StateType).Returns(StateType.Message); state.Setup(s => s.Message).Returns("Some random message"); state.Setup(s => s.SessionID).Returns(vm.SessionID); vm.Append(state.Object); Assert.AreEqual(3, vm.RootItems.Count); Assert.IsInstanceOfType(vm.RootItems[0], typeof(DebugStringTreeViewItemViewModel)); Assert.IsInstanceOfType(vm.RootItems[1], typeof(DebugStateTreeViewItemViewModel)); Assert.IsInstanceOfType(vm.RootItems[2], typeof(DebugStringTreeViewItemViewModel)); }
public void DebugOutputViewModel_OpenNullLineItemDoesntStartProcess() { var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object); vm.OpenMoreLink(null); Assert.IsNull(vm.ProcessController); }
public void DebugOutputViewModel_DebugStatus_Executing_PublishesDebugSelectionChangedEventArgs() { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); var expectedProps = new[] { "IsStopping", "IsProcessing", "IsConfiguring", "DebugImage", "DebugText", "ProcessingText" }; var actualProps = new List <string>(); viewModel.PropertyChanged += (sender, args) => actualProps.Add(args.PropertyName); var events = new List <DebugSelectionChangedEventArgs>(); var selectionChangedEvents = EventPublishers.Studio.GetEvent <DebugSelectionChangedEventArgs>(); selectionChangedEvents.Subscribe(events.Add); //------------Execute Test--------------------------- viewModel.DebugStatus = DebugStatus.Executing; EventPublishers.Studio.RemoveEvent <DebugSelectionChangedEventArgs>(); //------------Assert Results------------------------- Assert.AreEqual(1, events.Count); Assert.AreEqual(ActivitySelectionType.None, events[0].SelectionType); Assert.IsNull(events[0].DebugState); CollectionAssert.AreEqual(expectedProps, actualProps); }
public void DebugOutputViewModel_SelectAll_Execute_AllDebugStateItemsSelected() { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); viewModel.RootItems.Add(CreateItemViewModel <DebugStringTreeViewItemViewModel>(envRepo, 0, false, null)); for (var i = 1; i < 6; i++) { var item = CreateItemViewModel <DebugStateTreeViewItemViewModel>(envRepo, i, false, null); for (var j = 0; j < 2; j++) { CreateItemViewModel <DebugStateTreeViewItemViewModel>(envRepo, j, false, item); } viewModel.RootItems.Add(item); } //------------Execute Test--------------------------- viewModel.SelectAllCommand.Execute(null); //------------Assert Results------------------------- // Items are selected only if they are DebugStateTreeViewItemViewModel's foreach (var item in viewModel.RootItems) { Assert.AreEqual(item is DebugStateTreeViewItemViewModel, item.IsSelected); foreach (var child in item.Children) { Assert.AreEqual(child is DebugStateTreeViewItemViewModel, child.IsSelected); } } }
public void DebugOutputViewModel_AppendErrorExpectErrorMessageAppended() { var mock1 = new Mock <IDebugState>(); var mock2 = new Mock <IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); mock2.SetupGet(m => m.StateType).Returns(StateType.Append); mock2.SetupGet(m => m.HasError).Returns(true); mock2.SetupGet(m => m.ErrorMessage).Returns("Error Test"); mock1.SetupSet(s => s.ErrorMessage = It.IsAny <string>()).Callback <string>(s => Assert.IsTrue(s.Equals("Error Test"))); mock1.SetupSet(s => s.HasError = It.IsAny <bool>()).Callback <bool>(s => Assert.IsTrue(s.Equals(true))); var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object); mock1.Setup(m => m.SessionID).Returns(vm.SessionID); mock2.Setup(m => m.SessionID).Returns(vm.SessionID); vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.AreEqual(1, vm.RootItems.Count); var root = vm.RootItems.First() as DebugStateTreeViewItemViewModel; Assert.IsNotNull(root); Assert.IsTrue(root.HasError.GetValueOrDefault(false)); }
static void DebugOutputViewModel_Append_ContentStateType(StateType stateType, Type expectedType, bool isExpanded) { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = Guid.NewGuid(), StateType = stateType, ActivityType = ActivityType.Step, Message = "The message", SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content); //------------Assert Results------------------------- Assert.AreEqual(1, viewModel.ContentItemCount); Assert.AreEqual(1, viewModel.RootItems.Count); Assert.AreEqual(viewModel.RootItems[0].IsExpanded, isExpanded); Assert.IsInstanceOfType(viewModel.RootItems[0], expectedType); if (expectedType == typeof(DebugStringTreeViewItemViewModel)) { Assert.AreEqual(0, viewModel.RootItems[0].Depth); var viewContent = ((DebugStringTreeViewItemViewModel)viewModel.RootItems[0]).Content; Assert.AreEqual(content.Message, viewContent); } else { Assert.IsTrue(viewModel.RootItems[0].Depth >= 0); var viewContent = ((DebugStateTreeViewItemViewModel)viewModel.RootItems[0]).Content; Assert.AreSame(content, viewContent); } }
[Ignore] //Bad Mocking Needs to be fixed... See MainViewModel OnImportsStatisfied public void DebugOutputViewModelAppendErrorExpectErrorMessageAppende() { ImportService.CurrentContext = _importServiceContext; var mock1 = new Mock <IDebugState>(); var mock2 = new Mock <IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); mock2.SetupGet(m => m.StateType).Returns(StateType.Append); mock2.SetupGet(m => m.HasError).Returns(true); mock2.SetupGet(m => m.ErrorMessage).Returns("Error Test"); mock1.SetupSet(s => s.ErrorMessage).Callback(s => Assert.IsTrue(s.Equals("Error Test"))); mock1.SetupSet(s => s.HasError).Callback(s => Assert.IsTrue(s.Equals(true))); var vm = new DebugOutputViewModel(); vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.IsTrue(vm.RootItems.Count == 1); var root = vm.RootItems.First() as DebugStateTreeViewItemViewModel; Assert.IsTrue(root.HasError.Equals(true)); }
[Ignore] //Bad Mocking Needs to be fixed... See MainViewModel OnImportsStatisfied public void DebugOutputViewModelPendingQueueExpectedQueuesMessagesAndFlushesWhenFinishedProcessing() { ImportService.CurrentContext = _importServiceContext; var envRepo = new Mock <IEnvironmentRepository>(); envRepo.Setup(e => e.All()).Returns(new List <IEnvironmentModel>()); envRepo.Setup(e => e.IsLoaded).Returns(true); var vm = new DebugOutputViewModel(envRepo.Object) { DebugStatus = DebugStatus.Executing }; for (var i = 0; i < 10; i++) { var state = new Mock <IDebugState>(); var stateType = i % 2 == 0 ? StateType.Message : StateType.After; state.Setup(s => s.StateType).Returns(stateType); vm.Append(state.Object); } Assert.AreEqual(5, vm.PendingItemCount); Assert.AreEqual(5, vm.ContentItemCount); vm.DebugStatus = DebugStatus.Finished; Assert.AreEqual(0, vm.PendingItemCount); Assert.AreEqual(10, vm.ContentItemCount); }
[Ignore] //Bad Mocking Needs to be fixed... See MainViewModel OnImportsStatisfied public void DebugOutputViewModelAppendNestedDebugstatesExpectNestedInRootItems() { ImportService.CurrentContext = _importServiceContext; var mock1 = new Mock <IDebugState>(); var mock2 = new Mock <IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); var vm = new DebugOutputViewModel(); vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.IsTrue(vm.RootItems.Count == 1); var root = vm.RootItems.First() as DebugStateTreeViewItemViewModel; Assert.IsTrue(root.Content.Equals(mock1.Object)); var firstChild = root.Children.First() as DebugStateTreeViewItemViewModel; Assert.IsTrue(firstChild.Content.ParentID.Equals(_firstResourceID)); }
public void DebugOutputViewModel_CantOpenEmptyMoreLinkLineItem() { var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object); var lineItem = new Mock <IDebugLineItem>(); lineItem.SetupGet(l => l.MoreLink).Returns(""); Assert.IsTrue(vm.CanOpenMoreLink(lineItem.Object).Equals(false)); }
public void DebugOutputViewModelCantOpenEmptyMoreLinkLineItem() { ImportService.CurrentContext = _importServiceContext; var vm = new DebugOutputViewModel(); var lineItem = new Mock <IDebugLineItem>(); lineItem.SetupGet(l => l.MoreLink).Returns(""); Assert.IsTrue(vm.CanOpenMoreLink(lineItem.Object).Equals(false)); }
public void DebugOutputViewModel_OpenEmptyMoreLinkDoesntStartProcess() { var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object); var lineItem = new Mock <IDebugLineItem>(); lineItem.SetupGet(l => l.MoreLink).Returns(""); vm.OpenMoreLink(lineItem.Object); Assert.IsNull(vm.ProcessController); }
public void DebugOutputViewModel_Constructor_ViewModelSessionIDAndEnvironmentRepoProperlyInitialized() { var mockedEnvRepo = new Mock <IEnvironmentRepository>(); //------------Execute Test--------------------------- var debugOutputViewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, mockedEnvRepo.Object, new Mock <IDebugOutputFilterStrategy>().Object); // Assert View Model Session ID And Environment Repo Properly Initialized Assert.AreNotEqual(Guid.Empty, debugOutputViewModel.SessionID, "Session ID not properly initialized"); Assert.AreEqual(mockedEnvRepo.Object, debugOutputViewModel.EnvironmentRepository, "Environment Repo not initialized"); }
public void OpenEmptyMoreLinkDoesntStartProcess() { ImportService.CurrentContext = _importServiceContext; var vm = new DebugOutputViewModel(); var lineItem = new Mock<IDebugLineItem>(); lineItem.SetupGet(l => l.MoreLink).Returns(""); vm.OpenMoreLink(lineItem.Object); Assert.IsNull(vm.ProcessController); }
public void OpenEmptyMoreLinkDoesntStartProcess() { ImportService.CurrentContext = _importServiceContext; var vm = new DebugOutputViewModel(); var lineItem = new Mock <IDebugLineItem>(); lineItem.SetupGet(l => l.MoreLink).Returns(""); vm.OpenMoreLink(lineItem.Object); Assert.IsNull(vm.ProcessController); }
public void DebugOutputViewModel_Append_NullContent_NotAdded() { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); //------------Execute Test--------------------------- viewModel.Append(null); //------------Assert Results------------------------- Assert.AreEqual(0, viewModel.ContentItemCount); Assert.AreEqual(0, viewModel.RootItems.Count); }
public void DebugOutputViewModel_Append_NullContent_NotAdded() { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); //------------Execute Test--------------------------- viewModel.Append(null); //------------Assert Results------------------------- Assert.AreEqual(0, viewModel.ContentItemCount); Assert.AreEqual(0, viewModel.RootItems.Count); }
public void DebugOutputViewModel_Append_TypeIsStartAndNotFirstStep_NothingAppended() { var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = Guid.NewGuid(), ParentID = Guid.Empty, StateType = StateType.Start, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content); Assert.AreEqual(1, viewModel.RootItems.Count); }
public void SetDebugStatus(DebugStatus debugStatus) { if (debugStatus == DebugStatus.Finished) { CommandManager.InvalidateRequerySuggested(); } if (debugStatus == DebugStatus.Configure) { DebugOutputViewModel.Clear(); } DebugOutputViewModel.DebugStatus = debugStatus; }
public void DebugOutputViewModel_ProcessingText_ShouldReturnDescriptionOfDebugStatus() { //------------Setup for test-------------------------- var mockedEnvRepo = new Mock <IEnvironmentRepository>(); var debugOutputViewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, mockedEnvRepo.Object, new Mock <IDebugOutputFilterStrategy>().Object) { DebugStatus = DebugStatus.Finished }; //------------Execute Test--------------------------- string processingText = debugOutputViewModel.ProcessingText; //------------Assert Results------------------------- Assert.AreEqual("Ready", processingText); }
public void DebugOutputViewModel_Append_ItemRemoteHasNoPermission_ShouldNotAddAsNewItemIntoTree() { //------------Setup for test-------------------------- var id = Guid.NewGuid(); var envRepo = GetEnvironmentRepository(); var mockAuthorizationService = new Mock<IAuthorizationService>(); mockAuthorizationService.Setup(service => service.GetResourcePermissions(It.IsAny<Guid>())).Returns(Permissions.None); _environmentModel.Setup(model => model.AuthorizationService).Returns(mockAuthorizationService.Object); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; viewModel.Append(content); var content2 = new DebugState { DisplayName = "Content2", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID, EnvironmentID = Guid.NewGuid() }; //------------Execute Test--------------------------- viewModel.Append(content2); //------------Assert Results------------------------- Assert.AreEqual(1, viewModel.RootItems.Count); }
public void DebugOutputViewModelPendingQueueExpectedQueuesMessagesAndFlushesWhenFinishedProcessing() { ImportService.CurrentContext = _importServiceContext; var envRepo = new Mock<IEnvironmentRepository>(); envRepo.Setup(e => e.All()).Returns(new List<IEnvironmentModel>()); envRepo.Setup(e => e.IsLoaded).Returns(true); var vm = new DebugOutputViewModel(envRepo.Object) { DebugStatus = DebugStatus.Executing }; for(var i = 0; i < 10; i++) { var state = new Mock<IDebugState>(); var stateType = i % 2 == 0 ? StateType.Message : StateType.After; state.Setup(s => s.StateType).Returns(stateType); vm.Append(state.Object); } Assert.AreEqual(5, vm.PendingItemCount); Assert.AreEqual(5, vm.ContentItemCount); vm.DebugStatus = DebugStatus.Finished; Assert.AreEqual(0, vm.PendingItemCount); Assert.AreEqual(10, vm.ContentItemCount); }
public void DebugOutputViewModel_Append_TypeIsStartAndNotFirstStep_NothingAppended() { var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = Guid.NewGuid(), ParentID = Guid.Empty, StateType = StateType.Start, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content); // Assert Nothing Appended Assert.AreEqual(0, viewModel.RootItems.Count); }
static void DebugOutputViewModel_Append_ContentStateType(StateType stateType, Type expectedType, bool isExpanded) { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = Guid.NewGuid(), StateType = stateType, ActivityType = ActivityType.Step, Message = "The message", SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content); //------------Assert Results------------------------- Assert.AreEqual(1, viewModel.ContentItemCount); Assert.AreEqual(1, viewModel.RootItems.Count); Assert.AreEqual(viewModel.RootItems[0].IsExpanded, isExpanded); Assert.IsInstanceOfType(viewModel.RootItems[0], expectedType); if(expectedType == typeof(DebugStringTreeViewItemViewModel)) { Assert.AreEqual(0, viewModel.RootItems[0].Depth); var viewContent = ((DebugStringTreeViewItemViewModel)viewModel.RootItems[0]).Content; Assert.AreEqual(content.Message, viewContent); } else { Assert.IsTrue(viewModel.RootItems[0].Depth >= 0); var viewContent = ((DebugStateTreeViewItemViewModel)viewModel.RootItems[0]).Content; Assert.AreSame(content, viewContent); } }
static void DebugOutputViewModel_Append_SearchText(string searchText, string contentText, bool isAdded) { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var filterStrat = new Mock<IDebugOutputFilterStrategy>(); filterStrat.Setup(e => e.Filter(It.IsAny<Object>(), It.IsAny<String>())).Returns(searchText == contentText); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, filterStrat.Object) { SearchText = searchText }; var content = new DebugState { DisplayName = contentText, ID = Guid.NewGuid(), StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content); //------------Assert Results------------------------- Assert.AreEqual(1, viewModel.ContentItemCount); Assert.AreEqual(isAdded ? 1 : 0, viewModel.RootItems.Count); }
void DebugOutputViewModel_Append_ContentIsDebugStateErrors(bool parentContentHasErrors, bool childContentHasErrors) { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); var parentContent = new DebugState { HasError = parentContentHasErrors, DisplayName = "Content", ID = Guid.NewGuid(), ParentID = Guid.Empty, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; var childContent = new DebugState { HasError = childContentHasErrors, DisplayName = "Content", ID = Guid.NewGuid(), ParentID = parentContent.ID, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(parentContent); viewModel.Append(childContent); //------------Assert Results------------------------- Assert.AreEqual(2, viewModel.ContentItemCount); Assert.AreEqual(1, viewModel.RootItems.Count); var childItem = viewModel.RootItems[0].Children[0]; Assert.AreEqual(childContentHasErrors, childItem.HasError); Assert.AreEqual(parentContentHasErrors, childItem.Parent.HasError); }
public void DebugOutputViewModelAppendErrorExpectErrorMessageAppende() { ImportService.CurrentContext = _importServiceContext; var mock1 = new Mock<IDebugState>(); var mock2 = new Mock<IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); mock2.SetupGet(m => m.StateType).Returns(StateType.Append); mock2.SetupGet(m => m.HasError).Returns(true); mock2.SetupGet(m => m.ErrorMessage).Returns("Error Test"); mock1.SetupSet(s => s.ErrorMessage).Callback(s => Assert.IsTrue(s.Equals("Error Test"))); mock1.SetupSet(s => s.HasError).Callback(s => Assert.IsTrue(s.Equals(true))); var vm = new DebugOutputViewModel(); vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.IsTrue(vm.RootItems.Count == 1); var root = vm.RootItems.First() as DebugStateTreeViewItemViewModel; Assert.IsTrue(root.HasError.Equals(true)); }
public void DebugOutputViewModelAppendNestedDebugstatesExpectNestedInRootItems() { ImportService.CurrentContext = _importServiceContext; var mock1 = new Mock<IDebugState>(); var mock2 = new Mock<IDebugState>(); mock1.SetupGet(m => m.ID).Returns(_firstResourceID); mock1.SetupGet(m => m.ServerID).Returns(_serverID); mock1.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ServerID).Returns(_serverID); mock2.SetupGet(m => m.WorkspaceID).Returns(_workspaceID); mock2.SetupGet(m => m.ParentID).Returns(_firstResourceID); var vm = new DebugOutputViewModel(); vm.Append(mock1.Object); vm.Append(mock2.Object); Assert.IsTrue(vm.RootItems.Count == 1); var root = vm.RootItems.First() as DebugStateTreeViewItemViewModel; Assert.IsTrue(root.Content.Equals(mock1.Object)); var firstChild = root.Children.First() as DebugStateTreeViewItemViewModel; Assert.IsTrue(firstChild.Content.ParentID.Equals(_firstResourceID)); }
public WorkflowInputDataViewModelMock(IServiceDebugInfoModel serviceDebugInfoModel, DebugOutputViewModel debugOutputViewModel) : base(serviceDebugInfoModel, debugOutputViewModel.SessionID) { }
void DebugOutputViewModel_Append_ContentIsDebugState(Guid contentID, Guid contentParentID, string displayName) { //------------Setup for test-------------------------- var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = displayName, ID = contentID, ParentID = contentParentID, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content); //------------Assert Results------------------------- Assert.AreEqual(1, viewModel.ContentItemCount); Assert.AreEqual(1, viewModel.RootItems.Count); var child = viewModel.RootItems[0]; Assert.AreEqual(0, child.Depth); Assert.IsNull(child.Parent); Assert.IsFalse(child.IsExpanded); }
public void DebugOutputViewModel_Append_ItemHasSameID_ShouldAddAsNewItemIntoTree() { //------------Setup for test-------------------------- var id = Guid.NewGuid(); var envRepo = GetEnvironmentRepository(); var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object); var content = new DebugState { DisplayName = "Content", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; viewModel.Append(content); var content2 = new DebugState { DisplayName = "Content2", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID }; //------------Execute Test--------------------------- viewModel.Append(content2); //------------Assert Results------------------------- Assert.AreEqual(2, viewModel.RootItems.Count); var child = viewModel.RootItems[0] as DebugStateTreeViewItemViewModel; Assert.IsNotNull(child); // ReSharper disable ConditionIsAlwaysTrueOrFalse if(child != null) // ReSharper restore ConditionIsAlwaysTrueOrFalse { Assert.AreEqual("Content", child.Content.DisplayName); } var child2 = viewModel.RootItems[1] as DebugStateTreeViewItemViewModel; Assert.IsNotNull(child2); // ReSharper disable ConditionIsAlwaysTrueOrFalse if(child2 != null) // ReSharper restore ConditionIsAlwaysTrueOrFalse { Assert.AreEqual("Content2", child2.Content.DisplayName); } }
public void DebugOutputViewModelCantOpenEmptyMoreLinkLineItem() { ImportService.CurrentContext = _importServiceContext; var vm = new DebugOutputViewModel(); var lineItem = new Mock<IDebugLineItem>(); lineItem.SetupGet(l => l.MoreLink).Returns(""); Assert.IsTrue(vm.CanOpenMoreLink(lineItem.Object).Equals(false)); }