public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread()
{
var serviceLocator = ServiceLocator.Default;
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock <IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny <Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock <IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock <IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] {});
serviceLocator.RegisterInstance <IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance <IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
var @event = new AutoResetEvent(false);
serviceLocator.ResolveType <IUIVisualizerService>().Show(fooViewModel, () => @event.Set());
@event.WaitOne(20000);
visualizerServiceMock.Verify(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
}
public void TheOpenedActionIsCalledWhenViewManagerHaveRegisteredAViewForTheViewModel()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock <IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny <Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock <IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock <IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { new FooViewModelView(fooViewModel) });
serviceLocator.RegisterInstance <IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance <IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType <IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
public FooViewModel CreateFooViewModel(Foo foo)
{
var vm = new FooViewModel(foo);
Container.BuildUp(vm);
return(vm);
}
public void NotCallsAddOrActivateMethodsOfViewThatsBelongToTheViewModelIsAlreadyActive()
{
_activeViewCollection.Setup(collection => collection.Contains(It.IsAny <FooViewModelView>())).Returns(true);
_mainRegionMock.SetupGet(region => region.ActiveViews).Returns(_activeViewCollection.Object);
_mainRegionMock.SetupGet(region => region.Views).Returns(_viewCollection.Object);
_regionCollectionMock.Setup(collection => collection.ContainsRegionWithName(MainRegionName)).Returns(true);
_regionCollectionMock.SetupGet(collection => collection[MainRegionName]).Returns(_mainRegionMock.Object);
_regionManagerMock.SetupGet(manager => manager.Regions).Returns(_regionCollectionMock.Object);
_serviceLocator.RegisterInstance <IRegionManager>(_regionManagerMock.Object);
var fooViewModel = new FooViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = _serviceLocator.ResolveType <IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
_regionManagerMock.VerifyGet(collection => collection.Regions, Times.AtLeast(1));
_regionCollectionMock.Verify(collection => collection.ContainsRegionWithName(MainRegionName), Times.Once());
_regionCollectionMock.Verify(collection => collection[MainRegionName], Times.Once());
_mainRegionMock.Verify(region => region.Add(It.IsAny <FooViewModelView>()), Times.Never());
_mainRegionMock.Verify(region => region.Activate(It.IsAny <FooViewModelView>()), Times.Never());
}
public void AllowsTheReactivationOfADeactivatedViewModel()
{
SetupDefaultRegionManager();
var fooViewModel = new FooViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = _serviceLocator.ResolveType <IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
uiVisualizerService.Deactivate(fooViewModel);
uiVisualizerService.Activate(fooViewModel);
_regionManagerMock.VerifyGet(collection => collection.Regions, Times.AtLeast(1));
_regionCollectionMock.Verify(collection => collection.ContainsRegionWithName(MainRegionName), Times.Once());
_regionCollectionMock.Verify(collection => collection[MainRegionName], Times.Once());
_mainRegionMock.Verify(region => region.Add(It.IsAny <FooViewModelView>()), Times.Once());
_mainRegionMock.Verify(region => region.Deactivate(It.IsAny <FooViewModelView>()), Times.Once());
_mainRegionMock.Verify(region => region.Activate(It.IsAny <FooViewModelView>()), Times.Exactly(2));
}
public void SetsTheExistingRegionManagerAndCreatesAParentChildRelationshipBetweenTheViewModelWithTheRegionAndTheInjectedOne()
{
this.SetupDefaultRegionManager();
var fooViewModel = new FooViewModel(this.serviceLocator);
var fooParentViewModel = new FooParentViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var viewManagerMock = new Mock <IViewManager>();
var fooParentViewModelView = new FooParentViewModelView(fooParentViewModel);
fooParentViewModelView.SetRegionManager(this.regionManagerMock.Object);
RegionManager.SetRegionName(fooParentViewModelView, MainRegionName);
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooParentViewModel)).Returns(new IView[] { fooParentViewModelView });
this.serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
this.serviceLocator.ResolveType <IUIVisualizerService>().Activate(fooViewModel, fooParentViewModel, MainRegionName);
this.VerifyDefaultRegionManagerBehavior();
Assert.AreEqual(fooParentViewModel, fooViewModel.GetParentViewModel());
Assert.IsTrue(fooParentViewModel.GetChildViewModelsWrapper().Contains(fooViewModel));
}
public void MakeACallToResolveTheRegionManagerIfNotFoundInTheVisualTreeAndCreatesAParentChildRelationshipBetweenTheViewModelWithTheRegionAndTheInjectedOne()
{
SetupDefaultRegionManager();
_regionManagerMock.Setup(manager => manager.CreateRegionManager()).Returns(_regionManagerMock.Object);
var fooViewModel = new FooViewModel(_serviceLocator);
var fooParentViewModel = new FooParentViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var viewManagerMock = new Mock <IViewManager>();
var fooParentViewModelView = new FooParentViewModelView(fooParentViewModel);
RegionManager.SetRegionName(fooParentViewModelView, MainRegionName);
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooParentViewModel)).Returns(new IView[] { fooParentViewModelView });
_serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
_serviceLocator.ResolveType <IUIVisualizerService>().Activate(fooViewModel, fooParentViewModel, MainRegionName);
VerifyDefaultRegionManagerBehavior();
Assert.AreEqual(fooParentViewModel, fooViewModel.GetParentViewModel());
Assert.IsTrue(fooParentViewModel.GetChildViewModelsWrapper().Contains(fooViewModel));
_regionManagerMock.Verify(manager => manager.CreateRegionManager(), Times.Once());
}
public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock <IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny <Action>(), true)).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock <IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(new Task <bool>(() => true));
var viewManagerMock = new Mock <IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { });
serviceLocator.RegisterInstance <IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance <IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType <IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
public void ThrowsInvalidOperationExceptionIfViewModelAndParentViewModelAreReferenceEquals()
{
var uiVisualizerService = _serviceLocator.ResolveType <IUIVisualizerService>();
var fooViewModel = new FooViewModel(_serviceLocator);
ExceptionTester.CallMethodAndExpectException <InvalidOperationException>(() => uiVisualizerService.Activate(fooViewModel, fooViewModel, MainRegionName));
}
protected override void Because_of()
{
var foo3 = new Foo {
IsFooBarred = null
};
_result = Mapper.Map <Foo, FooViewModel>(foo3);
}
public ActionResult Excel()
{
FooViewModel model = new FooViewModel()
{
Foos = new List <Foo>()
};
return(View(model));
}
public ActionResult Edit()
{
var viewModel = new FooViewModel
{
Bars = new List <BarViewModel> {
new BarViewModel()
}
};
return(View(viewModel));
}
public Package <int> Save([FromBody] FooViewModel model)
{
try
{
var id = _manager.Save(model);
return(new Package <int>(id, "The call filter was successfully saved."));
}
catch (Exception ex)
{
return(new Package <int>(ex));
}
}
public void ThrowsNotSupportedExceptionIfTheRegionManagerIsNotAvaliable()
{
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType <IUIVisualizerService>();
ExceptionTester.CallMethodAndExpectException <NotSupportedException>(() => uiVisualizerService.Activate(fooViewModel, MainRegionName));
}
public void ThrowsInvalidOperationIfIsTheFirstActivationOfAViewModelIsRequestedWithOutRegion()
{
_serviceLocator.RegisterInstance(_regionManagerMock.Object);
var fooViewModel = new FooViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = _serviceLocator.ResolveType <IUIVisualizerService>();
ExceptionTester.CallMethodAndExpectException <InvalidOperationException>(() => uiVisualizerService.Activate(fooViewModel));
}
public void NoErrorIsRaisedIfAServiceCannotBeFound()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.Null(result);
}
}
public void TriesToResolveTheViewsOfTheParentViewModelUsingTheViewManager()
{
var fooViewModel = new FooViewModel(_serviceLocator);
var fooParentViewModel = new FooParentViewModel(_serviceLocator);
var viewManagerMock = new Mock <IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooParentViewModel)).Returns(new IView[] {});
_serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
_serviceLocator.ResolveType <IUIVisualizerService>().Activate(fooViewModel, fooParentViewModel, MainRegionName);
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooParentViewModel), Times.Once());
}
public void CanResolveViewFromViewModelClassUsingInterfaceRegistration()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooView(), typeof(IFooView));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
FooViewModel vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.IsType <FooView>(result);
}
}
public void ByDefaultViewModelIsReplacedWithViewWhenDeterminingTheServiceName()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooView(), typeof(IViewFor <FooViewModel>));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
FooViewModel vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.True(result is FooView);
}
}
public void AnErrorIsRaisedIfTheCreationOfTheViewFails()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooThatThrowsView(), typeof(IViewFor <IFooViewModel>));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new FooViewModel();
var ex = Assert.Throws <InvalidOperationException>(() => fixture.ResolveView(vm));
Assert.Equal("This is a test failure.", ex.Message);
}
}
public void NoErrorIsRaisedIfTheServiceDoesNotImplementIViewFor()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => "this string does not implement IViewFor", typeof(IViewFor <IFooViewModel>));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.Null(result);
}
}
public void CanResolveViewFromViewModelInterfaceUsingIViewForRegistration()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooView(), typeof(IViewFor <IFooViewModel>));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
IFooViewModel vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.True(result is FooView);
}
}
public void TheRuntimeTypeOfTheViewModelIsUsedToResolveTheView()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooView(), typeof(FooView));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
object vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.True(result is FooView);
}
}
public void NoErrorIsRaisedIfATypeCannotBeFound()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
using (resolver.WithResolver())
{
var fixture = new DefaultViewLocator();
fixture.ViewModelToViewFunc = viewModelName => "DoesNotExist, " + typeof(DefaultViewLocatorTests).Assembly.FullName;
var vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.Null(result);
}
}
public void ViewModelToViewNamingConventionCanBeCustomized()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooWithWeirdConvention(), typeof(FooWithWeirdConvention));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
fixture.ViewModelToViewFunc = viewModelName => viewModelName.Replace("ViewModel", "WithWeirdConvention");
FooViewModel vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.True(result is FooWithWeirdConvention);
}
}
public void CallsAddAndActivateMethodsOfAnExistingRegionWithTheViewThatsBelongToTheViewModel()
{
SetupDefaultRegionManager();
var fooViewModel = new FooViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = _serviceLocator.ResolveType <IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
VerifyDefaultRegionManagerBehavior();
}
public async Task <IActionResult> PostFoo([FromBody] FooViewModel foo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Foo nfoo = new Foo()
{
FooId = 1,
DateJoined = DateTime.Now,
Name = foo.Name,
Bars = new List <Bar>()
};
_context.Foos.Add(nfoo);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetFoo", new { id = nfoo.FooId }, foo));
}
public void IsCalledIsTheMethodIsCloseAndRemoveMethodOfTheRegionIsCalled()
{
SetupRegionManagerBehaviorRelatedWithMainRegion();
var fooViewModel = new FooViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType <IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType <IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = _serviceLocator.ResolveType <IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
fooViewModel.CloseViewModel(true);
_mainRegionMock.Verify(region => region.Remove(It.IsAny <FooViewModelView>()), Times.Once());
}
/// <summary>
/// Page_Load hadler.
/// </summary>
protected void Page_Load(object sender, EventArgs e)
{
try // try to handle Page_Load
{
_ajaxManager = null;
if ((_ajaxManager = RadAjaxManager.GetCurrent(Page)) == null)
{
_ajaxManager = new RadAjaxManager()
{
ID = "amMain", EnableAJAX = true
};
{
phAjaxManager.Controls.Add(_ajaxManager);
}
}
var apMainSetting = new AjaxSetting("apMain");
{
apMainSetting.UpdatedControls.Add(new AjaxUpdatedControl("apMain", "alpMain"));
{
_ajaxManager.AjaxSettings.Add(apMainSetting);
}
}
if (IsPostBack)
{
return;
}
{
_model = new FooViewModel()
{
Foos = UnitOfWork.Foos.GetAll()
};
}
}
catch (Exception ex) // catch exceptions
{
Exceptions.ProcessModuleLoadException(this, ex);
}
}
public void ContractIsUsedWhenResolvingView()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooView(), typeof(IViewFor <IFooViewModel>), "first");
resolver.Register(() => new FooWithWeirdConvention(), typeof(IViewFor <IFooViewModel>), "second");
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new FooViewModel();
var result = fixture.ResolveView(vm);
Assert.Null(result);
result = fixture.ResolveView(vm, "first");
Assert.True(result is FooView);
result = fixture.ResolveView(vm, "second");
Assert.True(result is FooWithWeirdConvention);
}
}
public void IsCalledIsTheMethodIsCloseAndRemoveMethodOfTheRegionIsCalled()
{
this.SetupRegionManagerBehaviorRelatedWithMainRegion();
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
fooViewModel.CloseViewModel(true);
this.mainRegionMock.Verify(region => region.Remove(It.IsAny<FooViewModelView>()), Times.Once());
}
public void ThrowsInvalidOperationExceptionIfViewModelAndParentViewModelAreReferenceEquals()
{
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
var fooViewModel = new FooViewModel(this.serviceLocator);
ExceptionTester.CallMethodAndExpectException<InvalidOperationException>(() => uiVisualizerService.Activate(fooViewModel, fooViewModel, MainRegionName));
}
public void MakeACallToResolveTheRegionManagerIfNotFoundInTheVisualTreeAndCreatesAParentChildRelationshipBetweenTheViewModelWithTheRegionAndTheInjectedOne()
{
this.SetupDefaultRegionManager();
this.regionManagerMock.Setup(manager => manager.CreateRegionManager()).Returns(this.regionManagerMock.Object);
var fooViewModel = new FooViewModel(this.serviceLocator);
var fooParentViewModel = new FooParentViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var viewManagerMock = new Mock<IViewManager>();
var fooParentViewModelView = new FooParentViewModelView(fooParentViewModel);
RegionManager.SetRegionName(fooParentViewModelView, MainRegionName);
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooParentViewModel)).Returns(new IView[] { fooParentViewModelView });
this.serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
this.serviceLocator.ResolveType<IUIVisualizerService>().Activate(fooViewModel, fooParentViewModel, MainRegionName);
this.VerifyDefaultRegionManagerBehavior();
Assert.AreEqual(fooParentViewModel, fooViewModel.GetParentViewModel());
Assert.IsTrue(fooParentViewModel.GetChildViewModelsWrapper().Contains(fooViewModel));
this.regionManagerMock.Verify(manager => manager.CreateRegionManager(), Times.Once());
}
public void TriesToResolveTheViewsOfTheParentViewModelUsingTheViewManager()
{
var fooViewModel = new FooViewModel(this.serviceLocator);
var fooParentViewModel = new FooParentViewModel(this.serviceLocator);
var viewManagerMock = new Mock<IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooParentViewModel)).Returns(new IView[] { });
this.serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
this.serviceLocator.ResolveType<IUIVisualizerService>().Activate(fooViewModel, fooParentViewModel, MainRegionName);
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooParentViewModel), Times.Once());
}
public void NotCallsAddOrActivateMethodsOfViewThatsBelongToTheViewModelIsAlreadyActive()
{
this.activeViewCollection.Setup(collection => collection.Contains(It.IsAny<FooViewModelView>())).Returns(true);
this.mainRegionMock.SetupGet(region => region.ActiveViews).Returns(this.activeViewCollection.Object);
this.mainRegionMock.SetupGet(region => region.Views).Returns(this.viewCollection.Object);
this.regionCollectionMock.Setup(collection => collection.ContainsRegionWithName(MainRegionName)).Returns(true);
this.regionCollectionMock.SetupGet(collection => collection[MainRegionName]).Returns(this.mainRegionMock.Object);
this.regionManagerMock.SetupGet(manager => manager.Regions).Returns(this.regionCollectionMock.Object);
this.serviceLocator.RegisterInstance<IRegionManager>(this.regionManagerMock.Object);
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
this.regionManagerMock.VerifyGet(collection => collection.Regions, Times.AtLeast(1));
this.regionCollectionMock.Verify(collection => collection.ContainsRegionWithName(MainRegionName), Times.Once());
this.regionCollectionMock.Verify(collection => collection[MainRegionName], Times.Once());
this.mainRegionMock.Verify(region => region.Add(It.IsAny<FooViewModelView>()), Times.Never());
this.mainRegionMock.Verify(region => region.Activate(It.IsAny<FooViewModelView>()), Times.Never());
}
public void AllowsTheReactivationOfADeactivatedViewModel()
{
this.SetupDefaultRegionManager();
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
uiVisualizerService.Deactivate(fooViewModel);
uiVisualizerService.Activate(fooViewModel);
this.regionManagerMock.VerifyGet(collection => collection.Regions, Times.AtLeast(1));
this.regionCollectionMock.Verify(collection => collection.ContainsRegionWithName(MainRegionName), Times.Once());
this.regionCollectionMock.Verify(collection => collection[MainRegionName], Times.Once());
this.mainRegionMock.Verify(region => region.Add(It.IsAny<FooViewModelView>()), Times.Once());
this.mainRegionMock.Verify(region => region.Deactivate(It.IsAny<FooViewModelView>()), Times.Once());
this.mainRegionMock.Verify(region => region.Activate(It.IsAny<FooViewModelView>()), Times.Exactly(2));
}
public void ThrowsInvalidOperationIfIsTheFirstActivationOfAViewModelIsRequestedWithOutRegion()
{
this.serviceLocator.RegisterInstance(this.regionManagerMock.Object);
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
ExceptionTester.CallMethodAndExpectException<InvalidOperationException>(() => uiVisualizerService.Activate(fooViewModel));
}
public void ThrowsNotSupportedExceptionIfTheRegionManagerIsNotAvaliable()
{
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
ExceptionTester.CallMethodAndExpectException<NotSupportedException>(() => uiVisualizerService.Activate(fooViewModel, MainRegionName));
}
public FooView(FooViewModel viewModel)
{
DataContext = viewModel;
InitializeComponent();
}
public async Task IsCalledIsTheMethodIsCloseAndRemoveMethodOfTheRegionIsCalled()
{
SetupRegionManagerBehaviorRelatedWithMainRegion();
var fooViewModel = new FooViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof (FooViewModelView), typeof (FooViewModel));
viewLocator.Register(typeof (FooViewModel), typeof (FooViewModelView));
var uiCompositionService = _serviceLocator.ResolveType<IUICompositionService>();
uiCompositionService.Activate(fooViewModel, MainRegionName);
await fooViewModel.CloseViewModelAsync(true);
_mainRegionMock.Verify(region => region.Remove(It.IsAny<FooViewModelView>()), Times.Once());
}
public void SetsTheExistingRegionManagerAndCreatesAParentChildRelationshipBetweenTheViewModelWithTheRegionAndTheInjectedOne()
{
SetupDefaultRegionManager();
var fooViewModel = new FooViewModel(_serviceLocator);
var fooParentViewModel = new FooParentViewModel(_serviceLocator);
var viewLocator = _serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = _serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof (FooViewModelView), typeof (FooViewModel));
viewLocator.Register(typeof (FooViewModel), typeof (FooViewModelView));
var viewManagerMock = new Mock<IViewManager>();
var fooParentViewModelView = new FooParentViewModelView(fooParentViewModel);
fooParentViewModelView.SetRegionManager(_regionManagerMock.Object);
RegionManager.SetRegionName(fooParentViewModelView, MainRegionName);
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooParentViewModel)).Returns(new IView[] {fooParentViewModelView});
_serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
_serviceLocator.ResolveType<IUIVisualizerService>().Activate(fooViewModel, fooParentViewModel, MainRegionName);
VerifyDefaultRegionManagerBehavior();
Assert.AreEqual(fooParentViewModel, fooViewModel.GetParentViewModel());
Assert.IsTrue(fooParentViewModel.GetChildViewModelsWrapper().Contains(fooViewModel));
}
public void TheOpenedActionIsCalledWhenViewManagerHaveRegisteredAViewForTheViewModel()
{
var serviceLocator = new ServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock<IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock<IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock<IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { new FooViewModelView(fooViewModel) });
serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
public void CallsAddAndActivateMethodsOfAnExistingRegionWithTheViewThatsBelongToTheViewModel()
{
this.SetupDefaultRegionManager();
var fooViewModel = new FooViewModel(this.serviceLocator);
var viewLocator = this.serviceLocator.ResolveType<IViewLocator>();
var viewModelLocator = this.serviceLocator.ResolveType<IViewModelLocator>();
viewModelLocator.Register(typeof(FooViewModelView), typeof(FooViewModel));
viewLocator.Register(typeof(FooViewModel), typeof(FooViewModelView));
var uiVisualizerService = this.serviceLocator.ResolveType<IUIVisualizerService>();
uiVisualizerService.Activate(fooViewModel, MainRegionName);
this.VerifyDefaultRegionManagerBehavior();
}
public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread()
{
var serviceLocator = new ServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock<IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock<IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock<IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { });
serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
var @event = new AutoResetEvent(false);
serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () => @event.Set());
@event.WaitOne(20000);
visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
}
public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock<IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock<IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(new Task<bool>(() => true));
var viewManagerMock = new Mock<IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { });
serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
