public void OnPaneClosing(object sender, PaneClosingEventArgs e)
{
ContentPane contentPane = sender as ContentPane;
if (contentPane != null)
{
var pane = contentPane;
WorkSurfaceContextViewModel model = pane.DataContext as WorkSurfaceContextViewModel;
if (model != null)
{
var workflowVm = model.WorkSurfaceViewModel as IWorkflowDesignerViewModel;
IContextualResourceModel resource = workflowVm?.ResourceModel;
if (resource != null && !resource.IsWorkflowSaved)
{
CloseCurrent(e, model);
}
else
{
var sourceView = model.WorkSurfaceViewModel as IStudioTab;
if (sourceView != null)
{
CloseCurrent(e, model);
}
}
}
}
}
private void ViewModelDeactivated(object sender, DeactivationEventArgs e)
{
if (e.WasClosed)
{
var container = _target as TabGroupPane;
if (container != null)
{
WorkSurfaceContextViewModel model = sender as WorkSurfaceContextViewModel;
if (model != null)
{
var toRemove = container.Items.Cast <ContentPane>().ToList()
.FirstOrDefault(p => p.Content != null && p.Content == model.WorkSurfaceViewModel);
if (toRemove != null)
{
RemovePane(toRemove);
}
if (toRemove != null &&
Application.Current != null &&
!Application.Current.Dispatcher.HasShutdownStarted)
{
container.Items.Remove(toRemove);
}
}
}
}
}
public void OnPaneClosing(object sender, PaneClosingEventArgs e)
{
ContentPane contentPane = sender as ContentPane;
if (contentPane != null)
{
var pane = contentPane;
WorkSurfaceContextViewModel model = pane.DataContext as WorkSurfaceContextViewModel;
if (model != null)
{
var vm = model;
vm.TryClose();
var mainVm = vm.Parent as MainViewModel;
if (mainVm != null)
{
if (mainVm.CloseCurrent)
{
vm.Dispose();
}
else
{
e.Cancel = true;
}
}
}
}
}
void ActiveItemChanged(WorkSurfaceContextViewModel workSurfaceContextViewModel)
{
if (_tabGroupPanes == null || _tabGroupPanes.Count <= 0)
{
_tabGroupPanes = GetAllTabGroupPanes();
}
SetActivePane(workSurfaceContextViewModel);
}
static void CloseCurrent(PaneClosingEventArgs e, WorkSurfaceContextViewModel model)
{
var vm = model;
vm.TryClose();
if (vm.Parent is ShellViewModel mainVm && !mainVm.CloseCurrent)
{
e.Cancel = true;
}
}
public void BringItemIntoView(WorkSurfaceContextViewModel item)
{
if (NavigationViewModel != null)
{
if (item != null && item.ContextualResourceModel != null)
{
NavigationViewModel.BringItemIntoView(item.ContextualResourceModel);
}
}
}
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);
}
static ContentPaneFactory SetupPane(out WorkSurfaceContextViewModel workSurfaceContextViewModel, out ContentPane userControl, MessageBoxResult messageBoxResult)
{
var pane = new ContentPaneFactory();
var eventAggregator = new Mock <IEventAggregator>();
var workSurfaceViewModel = new Mock <ITestWorkSurfaceViewModel>();
workSurfaceViewModel.SetupGet(w => w.WorkSurfaceContext).Returns(WorkSurfaceContext.Workflow);
workSurfaceViewModel.SetupGet(w => w.ResourceModel).Returns(new TestResourceModel {
Authorized = true
});
var localhost = new Mock <IEnvironmentModel>();
localhost.Setup(e => e.ID).Returns(Guid.Empty);
localhost.Setup(e => e.IsConnected).Returns(true);
var environmentRepository = new Mock <IEnvironmentRepository>();
environmentRepository.Setup(c => c.All()).Returns(new[] { localhost.Object });
environmentRepository.Setup(c => c.Source).Returns(localhost.Object);
var eventPublisher = new Mock <IEventAggregator>();
var asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var versionChecker = new Mock <IVersionChecker>();
var browserPopupController = new Mock <IBrowserPopupController>();
var savePopup = new Mock <IPopupController>();
savePopup.Setup(s => s.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), It.IsAny <MessageBoxImage>(), It.IsAny <string>())).Returns(messageBoxResult);
var mainViewModel = new MainViewModelMock(eventPublisher.Object, asyncWorker.Object, environmentRepository.Object, versionChecker.Object, new Mock <IStudioResourceRepository>().Object, new Mock <IConnectControlSingleton>().Object, new Mock <IConnectControlViewModel>().Object, false, browserPopupController.Object)
{
IsBusyDownloadingInstaller = () => false, PopupProvider = savePopup.Object
};
workSurfaceContextViewModel = new WorkSurfaceContextViewModel(eventAggregator.Object, new WorkSurfaceKey
{
EnvironmentID = Guid.NewGuid(),
ResourceID = Guid.NewGuid(),
ServerID = Guid.NewGuid(),
WorkSurfaceContext = WorkSurfaceContext.Workflow
}, workSurfaceViewModel.Object, new Mock <IPopupController>().Object, (a, b) => { })
{
Parent = mainViewModel
};
pane.ItemsSource = new List <WorkSurfaceContextViewModel>
{
workSurfaceContextViewModel
};
userControl = new ContentPane {
DataContext = workSurfaceContextViewModel
};
return(pane);
}
public static WorkSurfaceContextViewModel CreateResourceViewModel(IContextualResourceModel resourceModel, bool createDesigner = true)
{
var key = WorkSurfaceKeyFactory.CreateKey(resourceModel);
var workSurfaceVm = new WorkflowDesignerViewModel(resourceModel, createDesigner);
var contextVm = new WorkSurfaceContextViewModel(key, workSurfaceVm)
{
DataListViewModel = DataListViewModelFactory.CreateDataListViewModel(resourceModel)
};
return(contextVm);
}
public static WorkSurfaceContextViewModel CreateResourceViewModel(IContextualResourceModel resourceModel, bool createDesigner, IPopupController popupController, IAsyncWorker asyncWorker)
{
var key = WorkSurfaceKeyFactory.CreateKey(resourceModel);
var workSurfaceVm = new WorkflowDesignerViewModel(EventPublishers.Aggregator, resourceModel, new WorkflowHelper(), popupController, asyncWorker, createDesigner);
var contextVm = new WorkSurfaceContextViewModel(key, workSurfaceVm)
{
DataListViewModel = DataListViewModelFactory.CreateDataListViewModel(resourceModel)
};
return(contextVm);
}
private 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);
}
//Juries TODO improve (remove typing tied to contentfactory)
private void SetTabName(ContentPane pane, object item)
{
WorkSurfaceContextViewModel model = item as WorkSurfaceContextViewModel;
if (model != null)
{
var vm = model;
pane.Name = vm.WorkSurfaceKey.ToString();
}
else
{
pane.Name = item.ToString();
}
}
/// <summary>
/// Used to initialize a container for a given item.
/// </summary>
/// <param name="container">The container element </param>
/// <param name="item">The item from the source collection</param>
protected override void PrepareContainerForItem(DependencyObject container, object item)
{
BindingHelper.BindPath(container, item, HeaderPath, HeaderedContentControl.HeaderProperty);
BindingHelper.BindPath(container, item, ContentPath, ContentControl.ContentProperty);
BindingHelper.BindPath(container, item, TabHeaderPath, ContentPane.TabHeaderProperty);
base.PrepareContainerForItem(container, item);
ContentPane pane = container as ContentPane;
SetTabName(pane, item);
//Aded to prevent tab from stealing focus from adorners
//FocusManager.SetIsFocusScope(pane, false);
if (pane != null)
{
pane.PreviewLostKeyboardFocus += pane_PreviewLostKeyboardFocus;
pane.PreviewGotKeyboardFocus += pane_PreviewLostKeyboardFocus;
pane.PreviewMouseDown += PaneOnPreviewMouseDown;
// always hook the closed
pane.Closed += OnPaneClosed;
pane.Closing += OnPaneClosing;
//Juries attach to events when viewmodel is closed/deactivated to close view.
WorkSurfaceContextViewModel model = item as WorkSurfaceContextViewModel;
if (model != null)
{
var vm = model;
vm.Deactivated += ViewModelDeactivated;
}
if (RemoveItemOnClose)
{
IEditableCollectionView cv = CollectionViewSource.GetDefaultView(ItemsSource) as IEditableCollectionView;
// set the pane to be removed from the dockmanager
pane.CloseAction = PaneCloseAction.RemovePane;
if (null == cv || !cv.CanRemove)
{
pane.AllowClose = false;
}
}
}
}
private static void CloseCurrent(PaneClosingEventArgs e, WorkSurfaceContextViewModel model)
{
var vm = model;
vm.TryClose();
var mainVm = vm.Parent as ShellViewModel;
if (mainVm != null)
{
if (mainVm.CloseCurrent)
{
//vm.Dispose();
}
else
{
e.Cancel = true;
}
}
}
static void SetActivePane(WorkSurfaceContextViewModel newValue)
{
if (_tabGroupPanes != null && _tabGroupPanes.Count > 0)
{
var tabGroupPane = _tabGroupPanes[0];
foreach (var item in from object item in tabGroupPane.Items
let frameworkElement = item as FrameworkElement
where frameworkElement != null && frameworkElement.DataContext == newValue
select item)
{
if (tabGroupPane.SelectedItem != item)
{
tabGroupPane.SelectedItem = item;
break;
}
}
FocusManager.AddGotFocusHandler(tabGroupPane, GotFocusHandler);
}
}
static ContentPaneFactory SetupPane(out WorkSurfaceContextViewModel workSurfaceContextViewModel, out ContentPane userControl, MessageBoxResult messageBoxResult)
{
var pane = new ContentPaneFactory();
var eventAggregator = new Mock<IEventAggregator>();
var workSurfaceViewModel = new Mock<ITestWorkSurfaceViewModel>();
workSurfaceViewModel.SetupGet(w => w.WorkSurfaceContext).Returns(WorkSurfaceContext.Workflow);
workSurfaceViewModel.SetupGet(w => w.ResourceModel).Returns(new TestResourceModel { Authorized = true });
var localhost = new Mock<IEnvironmentModel>();
localhost.Setup(e => e.ID).Returns(Guid.Empty);
localhost.Setup(e => e.IsConnected).Returns(true);
var environmentRepository = new Mock<IEnvironmentRepository>();
environmentRepository.Setup(c => c.All()).Returns(new[] { localhost.Object });
environmentRepository.Setup(c => c.Source).Returns(localhost.Object);
var eventPublisher = new Mock<IEventAggregator>();
var asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var versionChecker = new Mock<IVersionChecker>();
var browserPopupController = new Mock<IBrowserPopupController>();
var savePopup = new Mock<IPopupController>();
savePopup.Setup(s => s.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButton>(), It.IsAny<MessageBoxImage>(), It.IsAny<string>())).Returns(messageBoxResult);
var mainViewModel = new MainViewModelMock(eventPublisher.Object, asyncWorker.Object, environmentRepository.Object, versionChecker.Object,new Mock<IStudioResourceRepository>().Object, new Mock<IConnectControlSingleton>().Object, new Mock<IConnectControlViewModel>().Object, false, browserPopupController.Object) { IsBusyDownloadingInstaller = () => false, PopupProvider = savePopup.Object };
workSurfaceContextViewModel = new WorkSurfaceContextViewModel(eventAggregator.Object, new WorkSurfaceKey
{
EnvironmentID = Guid.NewGuid(),
ResourceID = Guid.NewGuid(),
ServerID = Guid.NewGuid(),
WorkSurfaceContext = WorkSurfaceContext.Workflow
}, workSurfaceViewModel.Object, new Mock<IPopupController>().Object, (a, b) => { })
{
Parent = mainViewModel
};
pane.ItemsSource = new List<WorkSurfaceContextViewModel>
{
workSurfaceContextViewModel
};
userControl = new ContentPane { DataContext = workSurfaceContextViewModel };
return pane;
}
public void CallDeactivate(WorkSurfaceContextViewModel item)
{
base.DeactivateItem(item, true);
}
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 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));
}
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());
}
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"));
}
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 void MainViewModel_OnStudioClosing_CallsSchedulerOnClosingClosesSuccessfully()
{
//Barney, commented out when I removed the feedback stuff from the studio
//SetupDefaultMef();
var eventPublisher = new Mock<IEventAggregator>();
var environmentRepository = new Mock<IEnvironmentRepository>();
environmentRepository.Setup(repo => repo.Source).Returns(new Mock<IEnvironmentModel>().Object);
var versionChecker = new Mock<IVersionChecker>();
var asyncWorker = new Mock<IAsyncWorker>();
asyncWorker.Setup(w => w.Start(It.IsAny<System.Action>(), It.IsAny<System.Action>())).Verifiable();
var connected1 = new Mock<IEnvironmentModel>();
var connected2 = new Mock<IEnvironmentModel>();
var notConnected = new Mock<IEnvironmentModel>();
connected1.Setup(a => a.IsConnected).Returns(true).Verifiable();
connected1.Setup(a => a.Disconnect()).Verifiable();
connected2.Setup(a => a.IsConnected).Returns(true).Verifiable();
connected2.Setup(a => a.Disconnect()).Verifiable();
IList<IEnvironmentModel> lst = new List<IEnvironmentModel> { connected1.Object, connected2.Object, notConnected.Object };
environmentRepository.Setup(repo => repo.All()).Returns(lst);
var mvm = new MainViewModel(eventPublisher.Object, asyncWorker.Object, environmentRepository.Object, versionChecker.Object, false);
var popup = new Mock<IPopupController>();
popup.Setup(a => a.ShowSchedulerCloseConfirmation()).Returns(MessageBoxResult.Yes).Verifiable();
var scheduler = new SchedulerViewModelForTesting(EventPublishers.Aggregator, new DirectoryObjectPickerDialog(), popup.Object, new TestAsyncWorker()) { RetValue = true, WorkSurfaceContext = WorkSurfaceContext.Scheduler };
var task = new Mock<IScheduledResource>();
task.Setup(a => a.IsDirty).Returns(true);
scheduler.SelectedTask = task.Object;
var vm = new WorkSurfaceContextViewModel(new EventAggregator(), new WorkSurfaceKey(), scheduler, new Mock<IPopupController>().Object, (a, b) => { });
environmentRepository.Setup(repo => repo.All()).Returns(new List<IEnvironmentModel>());
mvm.Items.Add(vm);
Assert.IsTrue(mvm.OnStudioClosing());
}
static void CloseCurrentWorkSurfaceWorkflowDesignerViewModel(PaneClosingEventArgs e, WorkSurfaceContextViewModel model)
{
var workflowVm = model.WorkSurfaceViewModel as IWorkflowDesignerViewModel;
var resource = workflowVm?.ResourceModel;
if (resource != null && !resource.IsWorkflowSaved)
{
CloseCurrent(e, model);
}
else
{
if (model.WorkSurfaceViewModel is IStudioTab sourceView)
{
CloseCurrent(e, model);
}
}
}
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;
}
public void MainViewModel_TryRemoveContext_Removes()
{
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(() => new List<IWorkspaceItem>());
wsiRepo.Setup(r => r.Write()).Verifiable();
#region Setup ImportService - GRRR!
SetupImportServiceForPersistenceTests(wsiRepo);
#endregion
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Save(It.IsAny<IResourceModel>())).Verifiable();
var envRepo = new Mock<IEnvironmentRepository>();
var envConn = new Mock<IEnvironmentConnection>();
envConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.Connection).Returns(envConn.Object);
envRepo.Setup(r => r.All()).Returns(new List<IEnvironmentModel>(new[] { env.Object }));
envRepo.Setup(r => r.Source).Returns(env.Object);
Mock<IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var mockMainViewModel = new MainViewModelPersistenceMock(envRepo.Object, asyncWorker.Object);
var resourceID = Guid.NewGuid();
#region Setup WorkSurfaceContextViewModel1
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment).Returns(env.Object);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.IsNewWorkflow).Returns(true);
resourceModel.Setup(m => m.IsWorkflowSaved).Returns(true);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 2");
var workflowHelper = new Mock<IWorkflowHelper>();
var designerViewModel = new WorkflowDesignerViewModel(resourceModel.Object, workflowHelper.Object, false);
var contextViewModel1 = new WorkSurfaceContextViewModel(
new WorkSurfaceKey { ResourceID = resourceID, ServerID = Guid.Empty, WorkSurfaceContext = designerViewModel.WorkSurfaceContext },
designerViewModel);
#endregion
mockMainViewModel.Items.Add(contextViewModel1);
Mock<IPopupController> mockPopUp = Dev2MockFactory.CreateIPopup(MessageBoxResult.No);
mockPopUp.Setup(m => m.Show()).Verifiable();
mockMainViewModel.PopupProvider = mockPopUp.Object;
mockMainViewModel.ActivateItem(mockMainViewModel.Items[0]);
mockMainViewModel.ActivateItem(mockMainViewModel.Items[1]);
mockMainViewModel.TryRemoveContext(mockMainViewModel.Items[1].ContextualResourceModel);
Assert.AreEqual(mockMainViewModel.Items[0], mockMainViewModel.ActiveItem);
mockPopUp.Verify(m => m.Show(), Times.Never());
}
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);
}
public void CallDeactivate(WorkSurfaceContextViewModel item)
{
DeactivateItem(item, true);
}
public void MainViewModelDeactivateItemWithPreviousItemOpenExpectedActiveItemToBePreviousItem()
{
lock (syncroot)
{
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(() => new List<IWorkspaceItem>());
wsiRepo.Setup(r => r.Write()).Verifiable();
#region Setup ImportService - GRRR!
var importServiceContext = new ImportServiceContext();
ImportService.CurrentContext = importServiceContext;
ImportService.Initialize(new List<ComposablePartCatalog>
{
new FullTestAggregateCatalog()
});
ImportService.AddExportedValueToContainer(wsiRepo.Object);
ImportService.AddExportedValueToContainer(new Mock<IEventAggregator>().Object);
#endregion
var envRepo = new Mock<IEnvironmentRepository>();
var mockMainViewModel = new MainViewModelPersistenceMock(envRepo.Object, false);
mockMainViewModel.EventAggregator = ImportService.GetExportValue<IEventAggregator>();
var resourceID = Guid.NewGuid();
var serverID = Guid.NewGuid();
#region Setup WorkSurfaceContextViewModel1
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Save(It.IsAny<IResourceModel>())).Verifiable();
var envConn = new Mock<IEnvironmentConnection>();
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.Connection).Returns(envConn.Object);
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment).Returns(env.Object);
resourceModel.Setup(m => m.ID).Returns(resourceID);
var workflowHelper = new Mock<IWorkflowHelper>();
var designerViewModel = new WorkflowDesignerViewModel(resourceModel.Object, workflowHelper.Object, false);
var contextViewModel1 = new WorkSurfaceContextViewModel(
new WorkSurfaceKey { ResourceID = resourceID, ServerID = serverID, WorkSurfaceContext = designerViewModel.WorkSurfaceContext },
designerViewModel);
#endregion
mockMainViewModel.Items.Add(contextViewModel1);
serverID = Guid.NewGuid();
resourceID = Guid.NewGuid();
mockMainViewModel.PopupProvider = Dev2MockFactory.CreateIPopup(MessageBoxResult.No).Object;
mockMainViewModel.ActivateItem(mockMainViewModel.Items[0]);
mockMainViewModel.ActivateItem(mockMainViewModel.Items[1]);
mockMainViewModel.CallDeactivate(mockMainViewModel.Items[1]);
Assert.AreEqual(mockMainViewModel.Items[0], mockMainViewModel.ActiveItem);
}
}
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());
}
static WorkSurfaceContextViewModel CreateWorkSurfaceContextViewModel(Permissions userPermissions)
{
var mockedConn = new Mock<IEnvironmentConnection>();
mockedConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var authService = new Mock<IAuthorizationService>();
authService.Setup(s => s.IsAuthorized(It.IsAny<AuthorizationContext>(), It.IsAny<string>())).Returns(true);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockedConn.Object);
mockEnvironmentModel.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel.Setup(model => model.AuthorizationService).Returns(authService.Object);
var environmentModel = mockEnvironmentModel.Object;
var resourceModel = new ResourceModel(environmentModel)
{
ID = Guid.NewGuid(),
ResourceName = "TestResource" + Guid.NewGuid(),
UserPermissions = userPermissions
};
var mockWorkSurfaceViewModel = new Mock<IWorkflowDesignerViewModel>();
mockWorkSurfaceViewModel.Setup(model => model.EnvironmentModel).Returns(environmentModel);
mockWorkSurfaceViewModel.Setup(model => model.ResourceModel).Returns(resourceModel);
var workSurfaceViewModel = mockWorkSurfaceViewModel.As<IWorkSurfaceViewModel>().Object;
var workSurfaceContextViewModel = new WorkSurfaceContextViewModel(new WorkSurfaceKey(), workSurfaceViewModel)
{
DebugOutputViewModel = { DebugStatus = DebugStatus.Ready }
};
workSurfaceContextViewModel.DebugCommand.UpdateContext(environmentModel, resourceModel);
workSurfaceContextViewModel.QuickDebugCommand.UpdateContext(environmentModel, resourceModel);
return workSurfaceContextViewModel;
}
public void MainViewModel_UnsavedWorkflowDialog_WhenXPressed_WorkflowRemainsOpen()
{
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(() => new List<IWorkspaceItem>());
wsiRepo.Setup(r => r.Write()).Verifiable();
#region Setup ImportService - GRRR!
SetupImportServiceForPersistenceTests(wsiRepo);
#endregion
var envRepo = new Mock<IEnvironmentRepository>();
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Save(It.IsAny<IResourceModel>())).Verifiable();
var envConn = new Mock<IEnvironmentConnection>();
var env = new Mock<IEnvironmentModel>();
envConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.Connection).Returns(envConn.Object);
envRepo.Setup(r => r.All()).Returns(new[] { env.Object });
envRepo.Setup(e => e.Source).Returns(env.Object);
envRepo.Setup(r => r.ReadSession()).Returns(new[] { env.Object.ID });
Mock<IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var mockMainViewModel = new MainViewModelPersistenceMock(envRepo.Object, asyncWorker.Object, false);
var resourceID = Guid.NewGuid();
var serverID = Guid.NewGuid();
#region Setup WorkSurfaceContextViewModel1
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment).Returns(env.Object);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(r => r.IsAuthorized(AuthorizationContext.Contribute)).Returns(true);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 3");
Mock<IPopupController> mockPopUp = Dev2MockFactory.CreateIPopup(MessageBoxResult.No);
mockPopUp.Setup(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButton>(), It.IsAny<MessageBoxImage>(), It.IsAny<string>())).Verifiable();
var workflowHelper = new Mock<IWorkflowHelper>();
var designerViewModel = new WorkflowDesignerViewModel(new Mock<IEventAggregator>().Object, resourceModel.Object, workflowHelper.Object, mockPopUp.Object, new TestAsyncWorker(), false);
var contextViewModel1 = new WorkSurfaceContextViewModel(
new WorkSurfaceKey { ResourceID = resourceID, ServerID = serverID, WorkSurfaceContext = designerViewModel.WorkSurfaceContext },
designerViewModel);
#endregion
mockMainViewModel.Items.Add(contextViewModel1);
mockMainViewModel.PopupProvider = mockPopUp.Object;
mockMainViewModel.ActivateItem(mockMainViewModel.Items[0]);
mockMainViewModel.ActivateItem(mockMainViewModel.Items[1]);
mockMainViewModel.CallDeactivate(mockMainViewModel.Items[1]);
Assert.AreEqual(mockMainViewModel.Items[1], mockMainViewModel.ActiveItem);
mockPopUp.Verify(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxButton>(), It.IsAny<MessageBoxImage>(), It.IsAny<string>()), Times.Once());
}
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 MainViewModelOnDeactivateWithTrueExpectedSavesResourceModels_WhenEnvironmentNotConnectedDoesNotCallSave()
{
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(() => new List<IWorkspaceItem>());
wsiRepo.Setup(r => r.UpdateWorkspaceItem(It.IsAny<IContextualResourceModel>(), It.Is<bool>(b => b))).Verifiable();
SetupImportServiceForPersistenceTests(wsiRepo);
var resourceID = Guid.NewGuid();
var serverID = Guid.NewGuid();
#region Setup resourceModel
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Save(It.IsAny<IResourceModel>())).Verifiable();
var envConn = new Mock<IEnvironmentConnection>();
var env = new Mock<IEnvironmentModel>();
envConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.Connection).Returns(envConn.Object);
env.Setup(e => e.IsConnected).Returns(false);
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment).Returns(env.Object);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 5");
#endregion
Mock<IPopupController> mockPopUp = Dev2MockFactory.CreateIPopup(MessageBoxResult.No);
var workflowHelper = new Mock<IWorkflowHelper>();
var designerViewModel = new WorkflowDesignerViewModel(new Mock<IEventAggregator>().Object, resourceModel.Object, workflowHelper.Object, mockPopUp.Object, new TestAsyncWorker(), false);
var contextViewModel = new WorkSurfaceContextViewModel(
new WorkSurfaceKey { ResourceID = resourceID, ServerID = serverID, WorkSurfaceContext = designerViewModel.WorkSurfaceContext },
designerViewModel);
var envRepo = new Mock<IEnvironmentRepository>();
envRepo.Setup(r => r.All()).Returns(new[] { env.Object });
envRepo.Setup(e => e.Source).Returns(env.Object);
envRepo.Setup(r => r.ReadSession()).Returns(new[] { env.Object.ID });
var viewModel = new MainViewModelPersistenceMock(envRepo.Object, false);
viewModel.Items.Add(contextViewModel);
viewModel.TestClose();
wsiRepo.Verify(r => r.UpdateWorkspaceItem(It.IsAny<IContextualResourceModel>(), It.Is<bool>(b => b)), Times.Never());
resourceRepo.Verify(r => r.Save(It.IsAny<IResourceModel>()), Times.Never());
}
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);
}
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());
}
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());
}
public void MainViewModelOnDeactivateWithTrueExpectedSavesResourceModels()
{
lock (syncroot)
{
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(() => new List<IWorkspaceItem>());
wsiRepo.Setup(r => r.UpdateWorkspaceItem(It.IsAny<IContextualResourceModel>(), It.Is<bool>(b => b))).Verifiable();
SetupImportServiceForPersistenceTests(wsiRepo);
var resourceID = Guid.NewGuid();
var serverID = Guid.NewGuid();
#region Setup resourceModel
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.Save(It.IsAny<IResourceModel>())).Verifiable();
var envConn = new Mock<IEnvironmentConnection>();
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.Connection).Returns(envConn.Object);
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment).Returns(env.Object);
resourceModel.Setup(m => m.ID).Returns(resourceID);
#endregion
var workflowHelper = new Mock<IWorkflowHelper>();
var designerViewModel = new WorkflowDesignerViewModel(resourceModel.Object, workflowHelper.Object, false);
var contextViewModel = new WorkSurfaceContextViewModel(
new WorkSurfaceKey { ResourceID = resourceID, ServerID = serverID, WorkSurfaceContext = designerViewModel.WorkSurfaceContext },
designerViewModel);
var envRepo = new Mock<IEnvironmentRepository>();
var viewModel = new MainViewModelPersistenceMock(envRepo.Object, false);
viewModel.Items.Add(contextViewModel);
viewModel.TestClose();
wsiRepo.Verify(r => r.UpdateWorkspaceItem(It.IsAny<IContextualResourceModel>(), It.Is<bool>(b => b)));
resourceRepo.Verify(r => r.Save(It.IsAny<IResourceModel>()));
}
}
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());
}
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 MainViewModel_OnStudioClosing_CallsSettingsOnClosingDirty()
{
//Barney, commented out when I removed the feedback stuff from the studio
//SetupDefaultMef();
var eventPublisher = new Mock<IEventAggregator>();
var environmentRepository = new Mock<IEnvironmentRepository>();
environmentRepository.Setup(repo => repo.Source).Returns(new Mock<IEnvironmentModel>().Object);
var versionChecker = new Mock<IVersionChecker>();
var asyncWorker = new Mock<IAsyncWorker>();
asyncWorker.Setup(w => w.Start(It.IsAny<System.Action>(), It.IsAny<System.Action>())).Verifiable();
var connected1 = new Mock<IEnvironmentModel>();
var connected2 = new Mock<IEnvironmentModel>();
var notConnected = new Mock<IEnvironmentModel>();
connected1.Setup(a => a.IsConnected).Returns(true).Verifiable();
connected1.Setup(a => a.Disconnect()).Verifiable();
connected2.Setup(a => a.IsConnected).Returns(true).Verifiable();
connected2.Setup(a => a.Disconnect()).Verifiable();
IList<IEnvironmentModel> lst = new List<IEnvironmentModel> { connected1.Object, connected2.Object, notConnected.Object };
environmentRepository.Setup(repo => repo.All()).Returns(lst);
var mvm = new MainViewModel(eventPublisher.Object, asyncWorker.Object, environmentRepository.Object, versionChecker.Object, false);
var popup = new Mock<IPopupController>();
var settings = new SettingsViewModelForTest(EventPublishers.Aggregator, popup.Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new NativeWindow()) { RetValue = true, WorkSurfaceContext = WorkSurfaceContext.Settings };
var task = new Mock<IScheduledResource>();
task.Setup(a => a.IsDirty).Returns(true);
settings.IsDirty = true;
var vm = new WorkSurfaceContextViewModel(new EventAggregator(), new WorkSurfaceKey(), settings, new Mock<IPopupController>().Object, (a, b) => { });
environmentRepository.Setup(repo => repo.All()).Returns(new List<IEnvironmentModel>());
mvm.Items.Add(vm);
Assert.IsTrue(mvm.OnStudioClosing());
}
