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 OpenNullLineItemDoesntStartProcess()
{
ImportService.CurrentContext = _importServiceContext;
var vm = new DebugOutputViewModel();
vm.OpenMoreLink(null);
Assert.IsNull(vm.ProcessController);
}
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);
}
public void DebugOutputViewModelCantOpenNullMoreLinkLineItem()
{
ImportService.CurrentContext = _importServiceContext;
var vm = new DebugOutputViewModel();
Assert.IsTrue(vm.CanOpenMoreLink(null).Equals(false));
}
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));
}
