public void SwitchingViewModelShouldDeactivateIt()
{
var locator = new ModernDependencyResolver();
locator.InitializeResolver();
locator.Register(() => new ActivatingViewFetcher(), typeof(IActivationForViewFetcher));
using (locator.WithResolver())
{
var vm = new ActivatingViewModel();
var fixture = new ActivatingView();
fixture.ViewModel = vm;
Assert.Equal(0, vm.IsActiveCount);
Assert.Equal(0, fixture.IsActiveCount);
fixture.Loaded.OnNext(Unit.Default);
Assert.Equal(1, vm.IsActiveCount);
Assert.Equal(1, fixture.IsActiveCount);
var newVm = new ActivatingViewModel();
Assert.Equal(0, newVm.IsActiveCount);
fixture.ViewModel = newVm;
Assert.Equal(0, vm.IsActiveCount);
Assert.Equal(1, newVm.IsActiveCount);
}
}
public void CanUnloadAndLoadViewAgain()
{
var locator = new ModernDependencyResolver();
locator.InitializeSplat();
locator.InitializeReactiveUI();
locator.Register(() => new ActivatingViewFetcher(), typeof(IActivationForViewFetcher));
using (locator.WithResolver())
{
var vm = new ActivatingViewModel();
var fixture = new ActivatingView();
fixture.ViewModel = vm;
Assert.Equal(0, vm.IsActiveCount);
Assert.Equal(0, fixture.IsActiveCount);
fixture.Loaded.OnNext(Unit.Default);
Assert.Equal(1, vm.IsActiveCount);
Assert.Equal(1, fixture.IsActiveCount);
fixture.Unloaded.OnNext(Unit.Default);
Assert.Equal(0, vm.IsActiveCount);
Assert.Equal(0, fixture.IsActiveCount);
fixture.Loaded.OnNext(Unit.Default);
Assert.Equal(1, vm.IsActiveCount);
Assert.Equal(1, fixture.IsActiveCount);
}
}
public void ModernDependencyResolver_UnregisterCurrent_WithValuesWorks()
{
var dummy1 = new DummyObjectClass1();
var dummy2 = new DummyObjectClass2();
var dummy3 = new DummyObjectClass3();
var currentMutable = new ModernDependencyResolver();
var testContracts = new[] { string.Empty, "test" };
foreach (var testContract in testContracts)
{
currentMutable.RegisterConstant <IDummyInterface>(dummy1, testContract);
currentMutable.RegisterConstant <IDummyInterface>(dummy2, testContract);
currentMutable.RegisterConstant <IDummyInterface>(dummy3, testContract);
}
foreach (var testContract in testContracts)
{
var items = currentMutable.GetServices <IDummyInterface>(testContract);
items.ShouldBe(new IDummyInterface[] { dummy1, dummy2, dummy3 });
currentMutable.UnregisterCurrent <IDummyInterface>(testContract);
items = currentMutable.GetServices <IDummyInterface>(testContract);
items.ShouldBe(new IDummyInterface[] { dummy1, dummy2 });
}
}
private static ModernDependencyResolver GenerateResolver()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
return(resolver);
}
public void RegisterLazySingleton_ByInterfaceWithoutDependencies_ResolvedByInterface()
{
var sut = new ModernDependencyResolver();
sut.RegisterLazySingleton <ClassWithoutDependencies, IService>();
var result = sut.GetService <IService>();
Assert.IsType <ClassWithoutDependencies>(result);
}
public void CanRegisterViewTypeForViewModelTypeTest()
{
ModernDependencyResolver locator = new ModernDependencyResolver();
locator.RegisterView <ActivatingView, ActivatingViewModel>();
Type type = locator.GetService(typeof(IViewFor <ActivatingViewModel>)) as Type;
Assert.AreEqual(typeof(ActivatingView), type);
}
public void Register_ClassWithMissingDependencies_ExceptionThrown()
{
var sut = new ModernDependencyResolver();
sut.Register <ClassWithDependencies>();
Assert.Throws <ResolveException>(() =>
{
var result = sut.GetService <ClassWithDependencies>();
});
}
public void Register_ClassWithoutDependencies_ResolvedByClass()
{
var sut = new ModernDependencyResolver();
sut.Register <ClassWithoutDependencies>();
var result = sut.GetService <ClassWithoutDependencies>();
Assert.IsType <ClassWithoutDependencies>(result);
}
public void RegisterLazySingleton_ByInterfaceWithMissingDependencies_ExceptionThrown()
{
var sut = new ModernDependencyResolver();
sut.RegisterLazySingleton <ClassWithDependencies, IService>();
Assert.Throws <ResolveException>(() =>
{
var result = sut.GetService <IService>();
});
}
public void ModernDependencyResolver_UnregisterCurrent_NoValuesWorks()
{
var currentMutable = new ModernDependencyResolver();
var items = currentMutable.GetServices <IDummyInterface>();
items.ShouldBeEmpty();
currentMutable.UnregisterCurrent <IDummyInterface>();
items = currentMutable.GetServices <IDummyInterface>();
items.ShouldBeEmpty();
}
public Startup(IDependencyResolver dependencyResolver = null)
{
if (dependencyResolver == null)
{
dependencyResolver = new ModernDependencyResolver();
}
RxApp.DefaultExceptionHandler = new TemplateExceptionHandler();
RegisterServices(dependencyResolver);
RegisterViewModels(dependencyResolver);
RegisterViews(dependencyResolver);
Build(dependencyResolver);
}
public void Register_ClassWithoutDependencies_DistinctInstancesPerResolve()
{
var sut = new ModernDependencyResolver();
sut.Register <ClassWithoutDependencies>();
var result1 = sut.GetService <ClassWithoutDependencies>();
var result2 = sut.GetService <ClassWithoutDependencies>();
Assert.IsType <ClassWithoutDependencies>(result1);
Assert.IsType <ClassWithoutDependencies>(result2);
Assert.NotEqual(result1, result2);
}
public void RegisterViewForViewModel_ViewAndViewModel_ViewAndViewModelResolved()
{
var sut = new ModernDependencyResolver();
sut.RegisterViewForViewModel <View, RoutableViewModel>();
var result1 = sut.GetService <RoutableViewModel>();
Assert.IsType <RoutableViewModel>(result1);
var result2 = sut.GetService <IViewFor <RoutableViewModel> >();
Assert.IsType <View>(result2);
}
public void RegisterLazySingleton_ClassWithoutDependencies_SameInstancesPerResolve()
{
var sut = new ModernDependencyResolver();
sut.RegisterLazySingleton <ClassWithoutDependencies>();
var result1 = sut.GetService <ClassWithoutDependencies>();
var result2 = sut.GetService <ClassWithoutDependencies>();
Assert.IsType <ClassWithoutDependencies>(result1);
Assert.IsType <ClassWithoutDependencies>(result2);
Assert.Equal(result1, result2);
}
public void WithOddInterfaceNameDoesntThrowException()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new StrangeClassNotFollowingConvention();
fixture.ResolveView((StrangeInterfaceNotFollowingConvention)vm);
}
}
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 CanResolveViewFromViewModelWithIRoutableViewModelType()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new RoutableFooView(), typeof(IViewFor <IRoutableFooViewModel>));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new RoutableFooViewModel();
var result = fixture.ResolveView <IRoutableViewModel>(vm);
Assert.IsType <RoutableFooView>(result);
}
}
public void ResolveExplicitViewType()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeResolver();
resolver.Register(() => new BazView(), typeof(IBazView));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new BazViewModel(null);
var result = fixture.ResolveView(vm);
this.Log().Info(result.GetType().FullName);
Assert.True(result is BazView);
}
}
public void CanResolveViewFromViewModelInterfaceUsingClassRegistration()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new FooView(), typeof(FooView));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
IFooViewModel vm = new FooViewModelWithWeirdName();
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 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 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 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 ResolveByConcreteViewFor()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new QuxView(), typeof(IViewFor <QuxViewModel>));
using (resolver.WithResolver()) {
var fixture = new DefaultViewLocator();
var vm = new QuxViewModel(null);
var result = fixture.ResolveView(vm);
this.Log().Info(result.GetType().FullName);
Assert.IsType <QuxView>(result);
}
}
public void CanOverrideNameResolutionFunc()
{
var resolver = new ModernDependencyResolver();
resolver.InitializeSplat();
resolver.InitializeReactiveUI();
resolver.Register(() => new RoutableFooCustomView());
using (resolver.WithResolver())
{
var fixture = new DefaultViewLocator();
fixture.ViewModelToViewFunc = x => x.Replace("ViewModel", "CustomView");
var vm = new RoutableFooViewModel();
var result = fixture.ResolveView <IRoutableViewModel>(vm);
Assert.IsType <RoutableFooCustomView>(result);
}
}
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 TestEnvironment(ILogger logger = null)
{
_locator = new ModernDependencyResolver();
var abracadabra = Menu.Games[0];
var mm = Menu.Games[1];
//--------------------------------------------------------------------------
// Fixtures
//--------------------------------------------------------------------------
// IMarshallManager
MarshallManager.Setup(m => m.ParseIni(PinballXIniPath)).Returns(GetPinballXIni(_ini));
MarshallManager.Setup(m => m.UnmarshallPlatformDatabase(VisualPinballDatabaseJsonPath)).Returns(new PlatformDatabase());
MarshallManager.Setup(m => m.UnmarshallPlatformDatabase(FuturePinballDatabaseJsonPath)).Returns(new PlatformDatabase());
MarshallManager.Setup(m => m.UnmarshallXml(Path.GetFileName(VisualPinballDatabaseXmlPath))).Returns(Menu);
_locator.RegisterLazySingleton(() => MarshallManager.Object, typeof(IMarshallManager));
// IFileSystemWatcher
FileSystemWatcher.Setup(f => f.FileWatcher(PinballXIniPath)).Returns(PinballXIniWatcher);
//FileSystemWatcher.Setup(f => f.DatabaseWatcher(It.IsAny<string>(), It.IsAny<IList<PinballXSystem>>())).Returns(DatabaseWatcher);
//FileSystemWatcher.Setup(f => f.TablesWatcher(It.IsAny<IList<PinballXSystem>>())).Returns(TableWatcher);
_locator.RegisterLazySingleton(() => FileSystemWatcher.Object, typeof(IFileSystemWatcher));
// ISettingsManager
SettingsManager.Setup(s => s.Settings).Returns(Settings);
SettingsManager.Setup(s => s.ApiAuthenticated).Returns(ApiAuthenticated);
_locator.RegisterLazySingleton(() => SettingsManager.Object, typeof(ISettingsManager));
// IDatabaseManager
_locator.RegisterLazySingleton(() => DatabaseManager.Object, typeof(IDatabaseManager));
// VPDB API
VpdbApi.Setup(api => api.GetReleasesBySize(TestVpdbApi.AbraCaDabraV20FileSize, GameItemViewModel.MatchThreshold)).Returns(TestVpdbApi.GetAbraCaDabraIdentify());
VpdbApi.Setup(api => api.GetRelease(TestVpdbApi.AbraCaDabraReleaseId)).Returns(TestVpdbApi.GetAbraCaDabraDetails());
// IVpdbClient
VpdbClient.Setup(v => v.UserChannel).Returns(UserChannel);
VpdbClient.Setup(v => v.Api).Returns(VpdbApi.Object);
_locator.RegisterLazySingleton(() => VpdbClient.Object, typeof(IVpdbClient));
// IVisualPinballManager
_locator.RegisterLazySingleton(() => VisualPinballManager.Object, typeof(IVisualPinballManager));
// IFile, IDirectory
Directory.Setup(d => d.Exists(VisualPinballDatabasePath)).Returns(true);
Directory.Setup(d => d.GetFiles(VisualPinballDatabasePath)).Returns(new[] { Path.GetFileName(VisualPinballDatabaseXmlPath) });
File.Setup(f => f.Exists(Path.Combine(VisualPinballTablePath, abracadabra.Filename + ".vpt"))).Returns(true);
File.Setup(f => f.FileSize(Path.Combine(VisualPinballTablePath, abracadabra.Filename + ".vpt"))).Returns(TestVpdbApi.AbraCaDabraV20FileSize);
File.Setup(f => f.Exists(Path.Combine(VisualPinballTablePath, mm.Filename + ".vpx"))).Returns(true);
File.Setup(f => f.FileSize(Path.Combine(VisualPinballTablePath, mm.Filename + ".vpx"))).Returns(10002);
_locator.RegisterLazySingleton(() => File.Object, typeof(IFile));
_locator.RegisterLazySingleton(() => Directory.Object, typeof(IDirectory));
// Logging
_locator.RegisterLazySingleton(() => logger ?? LogManager.GetCurrentClassLogger(), typeof(ILogger));
_locator.RegisterLazySingleton(() => new Mock <CrashManager>(_locator.GetService <ILogger>()).Object, typeof(CrashManager));
// IThreadManager
_locator.RegisterLazySingleton(() => new TestThreadManager(), typeof(IThreadManager));
//--------------------------------------------------------------------------
// Real (non-mocked) services start here. Those are the tested ones.
//--------------------------------------------------------------------------
// IVersionManager
_locator.RegisterLazySingleton(() => new VersionManager(
_locator.GetService <CrashManager>(),
_locator.GetService <ILogger>()
), typeof(IVersionManager));
// IMessageManager
_locator.RegisterLazySingleton(() => new MessageManager(
_locator.GetService <IDatabaseManager>(),
_locator.GetService <CrashManager>()
), typeof(IMessageManager));
// IRealtimeManager
_locator.RegisterLazySingleton(() => new RealtimeManager(
_locator.GetService <IVpdbClient>(),
_locator.GetService <ILogger>()
), typeof(IRealtimeManager));
// IJobManager
_locator.RegisterLazySingleton(() => new JobManager(
_locator.GetService <IDatabaseManager>(),
_locator.GetService <IMessageManager>(),
_locator.GetService <ILogger>(),
_locator.GetService <CrashManager>()
), typeof(IJobManager));
// IMenuManager
_locator.RegisterLazySingleton(() => new PinballX.MenuManager(
_locator.GetService <IFileSystemWatcher>(),
_locator.GetService <ISettingsManager>(),
_locator.GetService <IMarshallManager>(),
_locator.GetService <IThreadManager>(),
_locator.GetService <IFile>(),
_locator.GetService <IDirectory>(),
_locator.GetService <ILogger>()), typeof(IMenuManager));
// IPlatformManager
_locator.RegisterLazySingleton(() => new Application.PlatformManager(
_locator.GetService <IMenuManager>(),
_locator.GetService <IThreadManager>(),
_locator.GetService <ILogger>(),
_locator
), typeof(IPlatformManager));
// IDownloadManager
_locator.RegisterLazySingleton(() => new DownloadManager(
_locator.GetService <IPlatformManager>(),
_locator.GetService <IJobManager>(),
_locator.GetService <IVpdbClient>(),
_locator.GetService <ISettingsManager>(),
_locator.GetService <IMessageManager>(),
_locator.GetService <IDatabaseManager>(),
_locator.GetService <ILogger>(),
_locator.GetService <CrashManager>()
), typeof(IDownloadManager));
// IGameManager
_locator.RegisterLazySingleton(() => new Application.GameManager(
_locator.GetService <IMenuManager>(),
_locator.GetService <IVpdbClient>(),
_locator.GetService <ISettingsManager>(),
_locator.GetService <IDownloadManager>(),
_locator.GetService <IDatabaseManager>(),
_locator.GetService <IVersionManager>(),
_locator.GetService <IPlatformManager>(),
_locator.GetService <IMessageManager>(),
_locator.GetService <IRealtimeManager>(),
_locator.GetService <IVisualPinballManager>(),
_locator.GetService <IThreadManager>(),
_locator.GetService <IFile>(),
_locator.GetService <ILogger>()
), typeof(IGameManager));
}
