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()); }