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);
mock1.Setup(s => s.DisconnectedID).Returns(Guid.NewGuid());
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");
mock2.Setup(s => s.DisconnectedID).Returns(Guid.NewGuid());
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));
}
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 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);
state.Setup(s => s.DisconnectedID).Returns(Guid.NewGuid());
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);
state.Setup(s => s.DisconnectedID).Returns(Guid.NewGuid());
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_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);
mock1.Setup(m => m.DisconnectedID).Returns(Guid.NewGuid());
mock2.Setup(m => m.SessionID).Returns(vm.SessionID);
mock2.Setup(m => m.DisconnectedID).Returns(Guid.NewGuid());
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));
}
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);
}
[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);
}
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);
}
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);
}
}
void DispatchServerDebugMessage(ExecuteMessage message, IContextualResourceModel resource)
{
if (message != null && message.Message != null)
{
var debugstate = DebugStateFactory.Create(message.Message.ToString(), resource);
if (_debugOutputViewModel != null)
{
debugstate.SessionID = _debugOutputViewModel.SessionID;
_debugOutputViewModel.Append(debugstate);
}
}
}
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_AppendWhenDebugStateFinishedShouldNotWriteItems()
{
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(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object)
{
DebugStatus = DebugStatus.Finished
};
vm.Append(mock1.Object);
vm.Append(mock2.Object);
Assert.AreEqual(0, vm.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 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 DebugOutputViewModel_Append_TypeIsEsbServicesInvokerAndNotLastStep_NothingAppended()
{
var envRepo = GetEnvironmentRepository();
var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object);
var content = new DebugState {
Name = "EsbServiceInvoker", ExecutionOrigin = ExecutionOrigin.Unknown, ID = Guid.NewGuid(), ParentID = Guid.Empty, StateType = StateType.End, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID
};
//------------Execute Test---------------------------
viewModel.Append(content);
// Assert Nothing Appended
Assert.AreEqual(0, viewModel.RootItems.Count);
}
public void DebugOutputViewModel_Append_WhenDebugIsInStoppingState_ZeroItemsAddedToTree()
{
var envRepo = GetEnvironmentRepository();
var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object)
{
DebugStatus = DebugStatus.Stopping
};
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);
Assert.AreEqual(0, vm.RootItems.Count);
}
public void DebugOutputViewModel_AppendItemNotFinalStep_DebugStatusUnchanced()
{
//*********************Setup********************
var mock1 = new Mock <IDebugState>();
mock1.Setup(m => m.IsFinalStep()).Returns(false);
var vm = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, GetEnvironmentRepository(), new Mock <IDebugOutputFilterStrategy>().Object)
{
DebugStatus = DebugStatus.Ready
};
//*********************Test********************
vm.Append(mock1.Object);
//*********************Assert*******************
Assert.AreEqual(vm.DebugStatus, DebugStatus.Ready);
}
public void Given_GroupDebugOutputViewModel_Append_Adds_Assing_On_Label()
{
var inputs = new List <IDebugItem>
{
new DebugItem
{
ResultsList = new List <IDebugItemResult>
{
new DebugItemResult {
GroupIndex = 0, GroupName = "something", HasError = false, Label = "OutputLabel", MockSelected = false, MoreLink = null, Operator = "", TestStepHasError = false, Type = DebugItemResultType.Value, Value = "", Variable = null
},
new DebugItemResult {
GroupIndex = 0, GroupName = "something", HasError = false, Label = "Variable", MockSelected = false, MoreLink = null, Operator = "=", TestStepHasError = false, Type = DebugItemResultType.Variable, Value = "", Variable = "[[recordset().recordsetfield]]"
},
new DebugItemResult {
GroupIndex = 0, GroupName = "something", HasError = false, Label = "New Value", MockSelected = false, MoreLink = null, Operator = "", TestStepHasError = false, Type = DebugItemResultType.Variable, Value = "s", Variable = null
}
}
}
};
var envRepo = GetEnvironmentRepository();
var viewModel = new DebugOutputViewModel(new Mock <IEventPublisher>().Object, envRepo, new Mock <IDebugOutputFilterStrategy>().Object);
var mockedContent = new Mock <IDebugState>();
mockedContent.Setup(p => p.DisplayName).Returns("Content");
mockedContent.Setup(p => p.ID).Returns(Guid.NewGuid());
mockedContent.Setup(p => p.ParentID).Returns(Guid.Empty);
mockedContent.Setup(p => p.StateType).Returns(StateType.End);
mockedContent.Setup(p => p.SessionID).Returns(viewModel.SessionID);
mockedContent.Setup(p => p.Inputs).Returns(inputs);
//------------Execute Test---------------------------
viewModel.Append(mockedContent.Object);
// Assert Nothing Appended
var item = viewModel.RootItems[0];
var debugItem = item as DebugStateTreeViewItemViewModel;
var input = debugItem.Inputs[0];
var debugLine = input as DebugLine;
var lineItem = debugLine.LineItems[0];
var grp = lineItem as DebugLineGroup;
Assert.AreEqual("OutputLabel = ", grp.GroupLabel);
}
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_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);
}
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 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 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);
}
}
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 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 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));
}
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_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);
}
}
