public void CreateShowDependencyKeysExpectedKeysCreated()
{
var resId = Guid.NewGuid();
var serverId = Guid.NewGuid();
var enviroId = Guid.NewGuid();
WorkSurfaceKey key1 = WorkSurfaceKeyFactory.CreateKey(WorkSurfaceContext.DependencyVisualiser) as WorkSurfaceKey;
Assert.IsNotNull(key1);
key1.EnvironmentID = enviroId;
key1.ResourceID = resId;
key1.ServerID = serverId;
var resource2 = Dev2MockFactory.SetupResourceModelMock();
resource2.Setup(c => c.ID).Returns(resId);
resource2.Setup(c => c.ServerID).Returns(serverId);
resource2.Setup(c => c.Environment.EnvironmentID).Returns(enviroId);
var key2 = WorkSurfaceKeyFactory.CreateKey(resource2.Object);
if (WorkSurfaceKeyEqualityComparerWithContextKey.Current.Equals(key1, key2))
{
Assert.Fail("The WorkSurfaceContext should not be the same.");
}
}
public WorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel, IPopupController popupController, Action <IContextualResourceModel, bool, System.Action> saveDialogAction)
: base(eventPublisher)
{
if (workSurfaceKey == null)
{
throw new ArgumentNullException(nameof(workSurfaceKey));
}
if (workSurfaceViewModel == null)
{
throw new ArgumentNullException(nameof(workSurfaceViewModel));
}
VerifyArgument.IsNotNull("popupController", popupController);
WorkSurfaceKey = workSurfaceKey;
WorkSurfaceViewModel = workSurfaceViewModel;
_windowManager = CustomContainer.Get <IWindowManager>();
var model = WorkSurfaceViewModel as IWorkflowDesignerViewModel;
if (model != null)
{
model.WorkflowChanged += UpdateForWorkflowChange;
_server = model.Server;
if (_server != null)
{
_server.IsConnectedChanged += EnvironmentModelOnIsConnectedChanged();
_server.Connection.ReceivedResourceAffectedMessage += OnReceivedResourceAffectedMessage;
}
}
_popupController = popupController;
_saveDialogAction = saveDialogAction;
}
/// <summary>
/// Determines whether [is waiting for fist focus loss] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsWaitingForFistFocusLoss(WorkSurfaceKey workSurfaceKey)
{
if (_resourcesCurrentlyWaitingForFirstFocusLoss.ContainsKey(workSurfaceKey.ToString()))
{
return(_resourcesCurrentlyWaitingForFirstFocusLoss[workSurfaceKey.ToString()]);
}
return(false);
}
public static WorkSurfaceContextViewModel Create <T>(WorkSurfaceKey key, Tuple <string, object>[] initParms)
where T : IWorkSurfaceViewModel
{
var vm = Activator.CreateInstance <T>();
PropertyHelper.SetValues(vm, initParms);
var context = CreateWorkSurfaceContextViewModel(vm, key.WorkSurfaceContext, key);
return(context);
}
static WorkSurfaceContextViewModel CreateWorkSurfaceContextViewModel <T>(T vm,
WorkSurfaceContext workSurfaceContext,
WorkSurfaceKey key)
where T : IWorkSurfaceViewModel
{
var context = new WorkSurfaceContextViewModel(key, vm);
if (!(vm is SchedulerViewModel) && !(vm is SettingsViewModel))
{
vm.DisplayName = workSurfaceContext.GetDescription();
}
vm.WorkSurfaceContext = workSurfaceContext;
return(context);
}
public WorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel, IPopupController popupController, Action <IContextualResourceModel, bool> saveDialogAction)
: base(eventPublisher)
{
if (workSurfaceKey == null)
{
throw new ArgumentNullException("workSurfaceKey");
}
if (workSurfaceViewModel == null)
{
throw new ArgumentNullException("workSurfaceViewModel");
}
VerifyArgument.IsNotNull("popupController", popupController);
WorkSurfaceKey = workSurfaceKey;
WorkSurfaceViewModel = workSurfaceViewModel;
_windowManager = CustomContainer.Get <IWindowManager>();
_workspaceItemRepository = WorkspaceItemRepository.Instance;
var model = WorkSurfaceViewModel as IWorkflowDesignerViewModel;
if (model != null)
{
_environmentModel = model.EnvironmentModel;
if (_environmentModel != null)
{
// MUST use connection server event publisher - debug events are published from the server!
DebugOutputViewModel = new DebugOutputViewModel(_environmentModel.Connection.ServerEvents, EnvironmentRepository.Instance, new DebugOutputFilterStrategy());
_environmentModel.IsConnectedChanged += EnvironmentModelOnIsConnectedChanged();
_environmentModel.Connection.ReceivedResourceAffectedMessage += OnReceivedResourceAffectedMessage;
}
}
if (WorkSurfaceKey.WorkSurfaceContext == WorkSurfaceContext.Scheduler)
{
if (DebugOutputViewModel == null)
{
DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), EnvironmentRepository.Instance, new DebugOutputFilterStrategy());
}
}
_popupController = popupController;
_saveDialogAction = saveDialogAction;
}
/// <summary>
/// Prunes the workflow from caches.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void PruneWorkflowFromCaches(WorkSurfaceKey workSurfaceKey)
{
if (_resourcesCurrentlyWaitingForFirstFocusLoss.ContainsKey(workSurfaceKey.ToString()))
{
_resourcesCurrentlyWaitingForFirstFocusLoss.Remove(workSurfaceKey.ToString());
}
if (_resourcesCurrentlyInOpeningState.Contains(workSurfaceKey))
{
_resourcesCurrentlyInOpeningState.Remove(workSurfaceKey);
}
if (_resourcesCurrentlyInOpeningStateWaitingForLoad.Contains(workSurfaceKey))
{
_resourcesCurrentlyInOpeningStateWaitingForLoad.Remove(workSurfaceKey);
}
if (_resourceCurrentlyWaitingForWaterMarkUpdates.Contains(workSurfaceKey))
{
_resourceCurrentlyWaitingForWaterMarkUpdates.Remove(workSurfaceKey);
}
}
/// <summary>
/// Removes the workflow waiting for first focus loss.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflowWaitingForFirstFocusLoss(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyWaitingForFirstFocusLoss[workSurfaceKey.ToString()] = false;
}
public TestWorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel)
: base(eventPublisher, workSurfaceKey, workSurfaceViewModel, new Mock<IPopupController>().Object, (a, b) => { })
{
}
/// <summary>
/// Removes the workflow.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflow(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyInOpeningState.Remove(workSurfaceKey);
}
public void WorkSurfaceContextViewModel_Handle_Save_WhenContextualResourceModelIsNotNull()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.SetupGet(p => p.IsConnected).Returns(true);
var mockRepository = new Mock<IResourceRepository>();
mockRepository.Setup(c => c.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
mockRepository.Setup(m => m.Save(It.IsAny<IResourceModel>())).Verifiable();
mockRepository.Setup(c => c.SaveToServer(It.IsAny<IResourceModel>())).Returns(new ExecuteMessage());
mockEnvironmentModel.SetupGet(p => p.ResourceRepository).Returns(mockRepository.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
var popup = new Mock<IPopupController>();
bool called = false;
var mockResourceModel = new Mock<IContextualResourceModel>();
mockResourceModel.SetupGet(p => p.Environment).Returns(environmentModel);
mockResourceModel.Setup(m => m.UserPermissions).Returns(Permissions.Contribute);
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(new Mock<IEventAggregator>().Object, workSurfaceKey, workSurfaceViewModel.Object, popup.Object, (a, b) => { called = true; });
mockWorkSurfaceViewModel.Setup(a => a.ResourceModel).Returns(mockResourceModel.Object);
workSurfaceContextViewModel.WorkSurfaceViewModel = new WorkSurfaceViewModelTest();
var dlvm = new Mock<IDataListViewModel>();
dlvm.Setup(a => a.HasErrors).Returns(false);
workSurfaceContextViewModel.DataListViewModel = dlvm.Object;
mockResourceModel.Setup(a => a.IsNewWorkflow).Returns(true);
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new SaveResourceMessage(mockResourceModel.Object, false, false));
//------------Assert---------------------------------
Assert.IsTrue(called);
}
public TestWorkSurfaceContextViewModel(WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel)
: base(workSurfaceKey, workSurfaceViewModel)
{
}
public void WorkSurfaceContextViewModel_DebugOutputMessage_DebugStateHasNoData_RootItemsIsZero()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey { WorkSurfaceContext = WorkSurfaceContext.Scheduler };
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>().Object;
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel) { DebugOutputViewModel = { DebugStatus = DebugStatus.Executing } };
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new DebugOutputMessage(new List<IDebugState>()));
//------------Assert Results-------------------------
Assert.AreEqual(0, workSurfaceContextViewModel.DebugOutputViewModel.RootItems.Count);
}
public void WorkSurfaceContextViewModel_Handle_ExecuteResourceMessage_CallsBindModelAndSave()
{
//------------Setup for test--------------------------
CustomContainer.Register(new Mock<IWindowManager>().Object);
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.SetupGet(p => p.IsConnected).Returns(true);
var mockRepository = new Mock<IResourceRepository>();
mockRepository.Setup(m => m.Save(It.IsAny<IResourceModel>())).Verifiable();
mockEnvironmentModel.SetupGet(p => p.ResourceRepository).Returns(mockRepository.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel.Object);
var mockResourceModel = new Mock<IContextualResourceModel>();
mockResourceModel.SetupGet(p => p.Environment).Returns(environmentModel);
mockResourceModel.Setup(m => m.UserPermissions).Returns(Permissions.Contribute);
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new ExecuteResourceMessage(mockResourceModel.Object));
//------------Assert---------------------------------
mockWorkSurfaceViewModel.Verify(m => m.BindToModel(), Times.Once());
mockRepository.Verify(m => m.Save(It.IsAny<IResourceModel>()), Times.Once());
}
/// <summary>
/// Determines whether [is loaded information focus loss catalog] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsLoadedInFocusLossCatalog(WorkSurfaceKey workSurfaceKey)
{
return(_resourcesCurrentlyWaitingForFirstFocusLoss.ContainsKey(workSurfaceKey.ToString()));
}
/// <summary>
/// Removes the workflow waiting for water mark updates.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflowWaitingForWaterMarkUpdates(WorkSurfaceKey workSurfaceKey)
{
_resourceCurrentlyWaitingForWaterMarkUpdates.Remove(workSurfaceKey);
}
/// <summary>
/// Prunes the workflow from caches.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void PruneWorkflowFromCaches(WorkSurfaceKey workSurfaceKey)
{
if(_resourcesCurrentlyWaitingForFirstFocusLoss.ContainsKey(workSurfaceKey.ToString()))
{
_resourcesCurrentlyWaitingForFirstFocusLoss.Remove(workSurfaceKey.ToString());
}
if(_resourcesCurrentlyInOpeningState.Contains(workSurfaceKey))
{
_resourcesCurrentlyInOpeningState.Remove(workSurfaceKey);
}
if(_resourcesCurrentlyInOpeningStateWaitingForLoad.Contains(workSurfaceKey))
{
_resourcesCurrentlyInOpeningStateWaitingForLoad.Remove(workSurfaceKey);
}
if(_resourceCurrentlyWaitingForWaterMarkUpdates.Contains(workSurfaceKey))
{
_resourceCurrentlyWaitingForWaterMarkUpdates.Remove(workSurfaceKey);
}
}
/// <summary>
/// Determines whether [is waiting for fist focus loss] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsWaitingForFistFocusLoss(WorkSurfaceKey workSurfaceKey)
{
if(_resourcesCurrentlyWaitingForFirstFocusLoss.ContainsKey(workSurfaceKey.ToString()))
{
return _resourcesCurrentlyWaitingForFirstFocusLoss[workSurfaceKey.ToString()];
}
return false;
}
/// <summary>
/// Removes the workflow waiting for first focus loss.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflowWaitingForFirstFocusLoss(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyWaitingForFirstFocusLoss[workSurfaceKey.ToString()] = false;
}
/// <summary>
/// Determines whether [is workflow waitingfor designer load] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsWorkflowWaitingforDesignerLoad(WorkSurfaceKey workSurfaceKey)
{
return _resourcesCurrentlyInOpeningStateWaitingForLoad.Contains(workSurfaceKey);
}
/// <summary>
/// Removes the workflow waiting for designer load.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflowWaitingForDesignerLoad(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyInOpeningStateWaitingForLoad.Remove(workSurfaceKey);
}
/// <summary>
/// Removes the workflow waiting for water mark updates.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflowWaitingForWaterMarkUpdates(WorkSurfaceKey workSurfaceKey)
{
_resourceCurrentlyWaitingForWaterMarkUpdates.Remove(workSurfaceKey);
}
/// <summary>
/// Determines whether [is workflow waiting for water mark updates] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsWorkflowWaitingForWaterMarkUpdates(WorkSurfaceKey workSurfaceKey)
{
return(_resourceCurrentlyWaitingForWaterMarkUpdates.Contains(workSurfaceKey));
}
public void WorkSurfaceContextViewModel_Constructor_ValidArguments_DebugOutputViewModelNotNull()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>().Object;
//------------Execute Test---------------------------
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel);
//------------Assert Results-------------------------
Assert.IsNotNull(workSurfaceContextViewModel);
Assert.IsNotNull(workSurfaceContextViewModel.DebugOutputViewModel);
}
public WorkSurfaceContextViewModel(WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel)
: this(EventPublishers.Aggregator, workSurfaceKey, workSurfaceViewModel, new PopupController(), (a, b) => RootWebSite.ShowNewWorkflowSaveDialog(a, null, b))
{
}
public void WorkSurfaceContextViewModel_EnvironmentModelIsConnectedChanged_False_DebugStatusFinished()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>().Object;
var connectedEventArgs = new ConnectedEventArgs { IsConnected = false };
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel) { DebugOutputViewModel = { DebugStatus = DebugStatus.Executing } };
//------------Execute Test---------------------------
mockEnvironmentModel.Raise(model => model.IsConnectedChanged += null, connectedEventArgs);
//------------Assert Results-------------------------
Assert.AreEqual(DebugStatus.Finished, workSurfaceContextViewModel.DebugOutputViewModel.DebugStatus);
}
/// <summary>
/// Determines whether [is workflow waiting for water mark updates] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsWorkflowWaitingForWaterMarkUpdates(WorkSurfaceKey workSurfaceKey)
{
return _resourceCurrentlyWaitingForWaterMarkUpdates.Contains(workSurfaceKey);
}
public void WorkSurfaceContextViewModel_Handle_Save_InvalidXml_CausesPopup()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.SetupGet(p => p.IsConnected).Returns(true);
var mockRepository = new Mock<IResourceRepository>();
mockRepository.Setup(c => c.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
mockRepository.Setup(m => m.Save(It.IsAny<IResourceModel>())).Verifiable();
mockRepository.Setup(c => c.SaveToServer(It.IsAny<IResourceModel>())).Returns(new ExecuteMessage());
mockEnvironmentModel.SetupGet(p => p.ResourceRepository).Returns(mockRepository.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
var popup = new Mock<IPopupController>();
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(new Mock<IEventAggregator>().Object, workSurfaceKey, workSurfaceViewModel.Object, popup.Object, (a, b) => { });
var mockResourceModel = new Mock<IContextualResourceModel>();
mockResourceModel.SetupGet(p => p.Environment).Returns(environmentModel);
mockResourceModel.Setup(m => m.UserPermissions).Returns(Permissions.Contribute);
var dlvm = new Mock<IDataListViewModel>();
dlvm.Setup(a => a.HasErrors).Returns(true);
workSurfaceContextViewModel.DataListViewModel = dlvm.Object;
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new SaveResourceMessage(mockResourceModel.Object, false, false));
//------------Assert---------------------------------
popup.Verify(a => a.Show(It.IsAny<string>(), "Error Saving", MessageBoxButton.OK, MessageBoxImage.Error, "true"));
}
private static WorkSurfaceContextViewModel CreateWorkSurfaceContextViewModel <T>(T vm,
WorkSurfaceContext workSurfaceContext,
WorkSurfaceKey key)
where T : IWorkSurfaceViewModel
{
var context = new WorkSurfaceContextViewModel(key, vm);
vm.DisplayName = workSurfaceContext.GetDescription();
vm.IconPath = workSurfaceContext.GetIconLocation();
vm.WorkSurfaceContext = workSurfaceContext;
return(context);
}
public void WorkSurfaceContextViewModel_SaveCallsCheckForServerMessages()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.SetupGet(p => p.IsConnected).Returns(true);
var mockRepository = new Mock<IResourceRepository>();
mockRepository.Setup(c => c.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
mockRepository.Setup(m => m.Save(It.IsAny<IResourceModel>())).Verifiable();
mockRepository.Setup(c => c.SaveToServer(It.IsAny<IResourceModel>())).Returns(new ExecuteMessage());
mockEnvironmentModel.SetupGet(p => p.ResourceRepository).Returns(mockRepository.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel.Object);
var mockResourceModel = new Mock<IContextualResourceModel>();
mockResourceModel.SetupGet(p => p.Environment).Returns(environmentModel);
mockResourceModel.Setup(m => m.UserPermissions).Returns(Permissions.Contribute);
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new SaveResourceMessage(mockResourceModel.Object, false, false));
}
/// <summary>
/// Adds the workflow.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void AddWorkflow(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyInOpeningState.Add(workSurfaceKey);
_resourcesCurrentlyInOpeningStateWaitingForLoad.Add(workSurfaceKey);
}
public void WorkSurfaceContextViewModel_SaveCallsCheckForServerMessages_NoMessagesAvailable_NothingHappen()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.SetupGet(p => p.IsConnected).Returns(true);
var mockRepository = new Mock<IResourceRepository>();
mockRepository.Setup(c => c.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
mockRepository.Setup(m => m.Save(It.IsAny<IResourceModel>())).Verifiable();
mockRepository.Setup(c => c.SaveToServer(It.IsAny<IResourceModel>())).Returns(new ExecuteMessage());
mockEnvironmentModel.SetupGet(p => p.ResourceRepository).Returns(mockRepository.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
// object to work on
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel.Object);
var st = new Mock<IStudioCompileMessageRepoFactory>();
var mr = new Mock<IStudioCompileMessageRepo>();
workSurfaceContextViewModel.StudioCompileMessageRepoFactory = st.Object;
st.Setup(x => x.Create()).Returns(mr.Object);
mr.Setup(a => a.GetCompileMessagesFromServer(It.IsAny<IContextualResourceModel>())).Returns(new CompileMessageList());
var resourceChangedFactory = new Mock<IResourceChangeHandlerFactory>();
var rsHandler = new Mock<IResourceChangeHandler>();
resourceChangedFactory.Setup(a => a.Create(new Mock<IEventAggregator>().Object)).Returns(rsHandler.Object);
workSurfaceContextViewModel.ResourceChangeHandlerFactory = resourceChangedFactory.Object;
var mockResourceModel = new Mock<IContextualResourceModel>();
mockResourceModel.SetupGet(p => p.Environment).Returns(environmentModel);
mockResourceModel.Setup(m => m.UserPermissions).Returns(Permissions.Contribute);
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new SaveResourceMessage(mockResourceModel.Object, false, false));
rsHandler.Verify(a => a.ShowResourceChanged(It.IsAny<IContextualResourceModel>(), It.IsAny<IList<string>>(), null), Times.Never());
}
/// <summary>
/// Removes the workflow waiting for designer load.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflowWaitingForDesignerLoad(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyInOpeningStateWaitingForLoad.Remove(workSurfaceKey);
}
static WorkSurfaceContextViewModel CreateWorkSurfaceContextViewModel(IEnvironmentModel environmentModel, Mock<IContextualResourceModel> ResourceModel = null)
{
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockResourceModel = ResourceModel ?? new Mock<IContextualResourceModel>();
mockResourceModel.Setup(model => model.Environment).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(mockResourceModel.Object);
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>().Object;
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel);
return workSurfaceContextViewModel;
}
/// <summary>
/// Adds the workflow.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void AddWorkflow(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyInOpeningState.Add(workSurfaceKey);
_resourcesCurrentlyInOpeningStateWaitingForLoad.Add(workSurfaceKey);
}
public void WorkSurfaceContextViewModel_BindToModel_CallsBindToModelOnWorkSurfaceViewModel()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel.Object);
//------------Execute Test---------------------------
workSurfaceContextViewModel.BindToModel();
//------------Assert---------------------------------
mockWorkSurfaceViewModel.Verify(m => m.BindToModel(), Times.Once());
}
public void WorkSurfaceContextViewModel_DebugOutputMessage_DebugStateHasData_OnlyOneRootItemIsDisplayed()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey { WorkSurfaceContext = WorkSurfaceContext.Scheduler };
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>().Object;
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel) { DebugOutputViewModel = { DebugStatus = DebugStatus.Executing } };
const string msg = "[{\"$type\":\"Dev2.Diagnostics.Debug.DebugState, Dev2.Diagnostics\",\"ID\":\"cd902be2-a202-4d54-8c07-c5f56bae97fe\",\"ParentID\":\"00000000-0000-0000-0000-000000000000\",\"ServerID\":\"00000000-0000-0000-0000-000000000000\",\"EnvironmentID\":\"00000000-0000-0000-0000-000000000000\",\"ClientID\":\"00000000-0000-0000-0000-000000000000\",\"StateType\":64,\"DisplayName\":\"dave\",\"HasError\":true,\"ErrorMessage\":\"Service [ dave ] not found.\",\"Version\":\"\",\"Name\":\"DynamicServicesInvoker\",\"ActivityType\":0,\"Duration\":\"00:00:00\",\"DurationString\":\"PT0S\",\"StartTime\":\"2014-03-20T17:23:14.0224329+02:00\",\"EndTime\":\"2014-03-20T17:23:14.0224329+02:00\",\"Inputs\":[],\"Outputs\":[],\"Server\":\"\",\"WorkspaceID\":\"00000000-0000-0000-0000-000000000000\",\"OriginalInstanceID\":\"00000000-0000-0000-0000-000000000000\",\"OriginatingResourceID\":\"00000000-0000-0000-0000-000000000000\",\"IsSimulation\":false,\"Message\":null,\"NumberOfSteps\":0,\"Origin\":\"\",\"ExecutionOrigin\":0,\"ExecutionOriginDescription\":null,\"ExecutingUser\":null,\"SessionID\":\"00000000-0000-0000-0000-000000000000\"}]";
var serializer = new Dev2JsonSerializer();
var tmp = serializer.Deserialize<List<IDebugState>>(msg);
//------------Execute Test---------------------------
workSurfaceContextViewModel.Handle(new DebugOutputMessage(tmp));
//------------Assert Results-------------------------
Assert.AreEqual(1, workSurfaceContextViewModel.DebugOutputViewModel.RootItems.Count);
}
/// <summary>
/// Removes the workflow.
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
public static void RemoveWorkflow(WorkSurfaceKey workSurfaceKey)
{
_resourcesCurrentlyInOpeningState.Remove(workSurfaceKey);
}
public void WorkSurfaceContextViewModel_CanViewInBrowser_ExpectTrue()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel.Object) { WorkSurfaceViewModel = new WorkSurfaceViewModelTest() };
//------------Execute Test---------------------------
Assert.IsTrue(workSurfaceContextViewModel.CanViewInBrowser());
}
/// <summary>
/// Determines whether [is workflow waitingfor designer load] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsWorkflowWaitingforDesignerLoad(WorkSurfaceKey workSurfaceKey)
{
return(_resourcesCurrentlyInOpeningStateWaitingForLoad.Contains(workSurfaceKey));
}
public void WorkSurfaceContextViewModel_Constructor_SchedularWorksurfaceContext_DebugOutputViewModelNotNull()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey { WorkSurfaceContext = WorkSurfaceContext.Scheduler };
var mockWorkSurfaceViewModel = new SchedulerViewModel();
//------------Execute Test---------------------------
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, mockWorkSurfaceViewModel);
//------------Assert Results-------------------------
Assert.IsNotNull(workSurfaceContextViewModel);
Assert.IsNotNull(workSurfaceContextViewModel.DebugOutputViewModel);
}
public void WorkSurfaceContextViewModel_CanSave_ExpectTrue()
{
//------------Setup for test--------------------------
var workSurfaceKey = new WorkSurfaceKey();
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
var environmentModel = mockEnvironmentModel.Object;
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(m => m.BindToModel()).Verifiable();
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>();
// ReSharper disable UseObjectOrCollectionInitializer
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(workSurfaceKey, workSurfaceViewModel.Object);
// ReSharper restore UseObjectOrCollectionInitializer
workSurfaceContextViewModel.WorkSurfaceViewModel = new WorkSurfaceViewModelTest();
//------------Execute Test---------------------------
Assert.IsTrue(workSurfaceContextViewModel.CanSave());
}
/// <summary>
/// Determines whether [is loaded information focus loss catalog] [the specified work surface key].
/// </summary>
/// <param name="workSurfaceKey">The work surface key.</param>
/// <returns></returns>
public static bool IsLoadedInFocusLossCatalog(WorkSurfaceKey workSurfaceKey)
{
return _resourcesCurrentlyWaitingForFirstFocusLoss.ContainsKey(workSurfaceKey.ToString());
}
