public async Task Test_NavigateBackWhile_Disposes_Of_Presenters_For_ViewModel()
{
Navigator = new Navigator();
Router = new Router(Navigator);
var testViewModel = new TestViewModel();
var middleViewModel = new MiddleViewModel();
var otherViewModel = new OtherViewModel();
var middlePresenter = Substitute.For <IPresenter>();
var disposable = new BooleanDisposable();
Resolver.RegisterConstant(testViewModel, typeof(TestViewModel));
Resolver.RegisterConstant(middleViewModel, typeof(MiddleViewModel));
Resolver.RegisterConstant(otherViewModel, typeof(OtherViewModel));
Resolver.RegisterConstant(middlePresenter, typeof(IPresenter));
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.When <MiddleViewModel>(r => r.Navigate().Present <IPresenter>())
.When <OtherViewModel>(r => r.NavigateFrom <TestViewModel>())
.Build();
middlePresenter.PresentAsync(middleViewModel, null).Returns(disposable);
await Router.InitAsync(routerParams);
await Router.ShowAsync <TestViewModel, TestParams>();
await Router.ShowAsync <MiddleViewModel, TestParams>();
disposable.IsDisposed.Should().BeFalse();
await Router.ShowAsync <OtherViewModel, TestParams>();
disposable.IsDisposed.Should().BeTrue();
}
public async Task Test_ResumeAsync_Resumes_Stored_ViewModel_State()
{
Resolver.Register(() => new TestReActivatableViewModel(), typeof(TestReActivatableViewModel));
Navigator = new Navigator();
Router = new Router(Navigator);
var routerParams = new RouterBuilder()
.When <TestReActivatableViewModel>(r => r.Navigate())
.Build();
var viewModelState = new TestState();
var savedState = new RouterState()
{
Actions = new[]
{
new Router.StoredRouterAction()
{
Action = RouterActions.ShowViewModel(typeof(TestReActivatableViewModel), new TestParams()),
ViewModelState = viewModelState
},
}
};
await Router.InitAsync(routerParams);
await Router.ResumeAsync(savedState);
Assert.Collection(Navigator.TransitionStack,
t =>
{
t.ViewModel.Should().BeAssignableTo <TestReActivatableViewModel>();
t.ViewModel.As <TestReActivatableViewModel>().State.Should().Be(viewModelState);
});
}
public void TestMethod7()
{
RouterBuilder builder = new RouterBuilder("../Inputs/input5.txt");
var townsFrom = builder.Build();
var sumDistanceResult = new List <Tuple <int, string> >()
{
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'B', 'C' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'D' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'D', 'C' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'E', 'B', 'C', 'D' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'E', 'D' }, townsFrom)
};
var sumRoutesToTown = new List <int>()
{
RoutesVisitor.CountMaxStopRoutes(townsFrom, 'C', 'C', false, 3),
RoutesVisitor.CountMaxStopRoutes(townsFrom, 'A', 'C', true, 4)
};
var shortestRouteDistance = new List <int>()
{
RoutesVisitor.GetShortestRouteDistance(townsFrom, 'A', 'C'),
RoutesVisitor.GetShortestRouteDistance(townsFrom, 'B', 'B')
};
var sumRoutesToTownMaxDistance = new List <int>()
{
RoutesVisitor.CountMaxDistanceRoutes(townsFrom, 'C', 'C', 30)
};
}
public async Task Test_SuspendAsync_Returns_RouterState()
{
Resolver.Register(() => new TestViewModel(), typeof(TestViewModel));
Navigator = new Navigator();
Router = new Router(Navigator);
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.Build();
await Router.InitAsync(routerParams);
await Router.ShowAsync <TestViewModel, TestParams>();
var state = await Router.GetStateAsync();
Assert.Collection(state.Actions,
a =>
{
a.Action.Should().BeAssignableTo <ShowViewModelAction>();
var action = a.Action.As <ShowViewModelAction>();
action.ActivationParams.Params.Should().BeAssignableTo <TestParams>();
action.ActivationParams.Type.Should().Be <TestViewModel>();
a.ViewModelState.Should().BeNull();
});
}
public async Task Test_SuspendAsync_Returns_RouterState_With_ViewModel_Params()
{
var viewModel = new TestReActivatableViewModel();
Resolver.RegisterConstant(viewModel, typeof(TestReActivatableViewModel));
Navigator = new Navigator();
Router = new Router(Navigator);
var routerParams = new RouterBuilder()
.When <TestReActivatableViewModel>(r => r.Navigate())
.Build();
await Router.InitAsync(routerParams);
await Router.ShowAsync <TestReActivatableViewModel, TestParams>(new TestParams()
{
Value = "Hello, Params!"
});
var state = await Router.GetStateAsync();
Assert.Collection(state.Actions,
a =>
{
a.Action.Should().BeAssignableTo <ShowViewModelAction>();
var action = a.Action.As <ShowViewModelAction>();
action.ActivationParams.Params.Should().BeAssignableTo <TestParams>();
action.ActivationParams.Params.As <TestParams>().Value.Should().Be("Hello, Params!");
});
}
public async Task Test_NavigateBackWhileAction_Closes_App_If_Navigating_Past_The_Last_ViewModel_Without_Navigating_To_Another_ViewModel()
{
Resolver.Register(() => new TestViewModel(), typeof(TestViewModel));
Resolver.Register(() => new OtherViewModel(), typeof(OtherViewModel));
var initParams = new RouterBuilder()
.When <OtherViewModel>(r => r.Navigate())
.When <TestViewModel>(r => r.NavigateBackWhile(t => true))
.Build();
var closeAppEvents = new List <Unit>();
Navigator = new Navigator();
Router = new Router(Navigator);
using (Router.CloseApp.Subscribe(u => closeAppEvents.Add(u)))
{
await Router.InitAsync(initParams);
await Router.ShowAsync <OtherViewModel, TestParams>();
await Router.ShowAsync <TestViewModel, TestParams>();
closeAppEvents.Should()
.NotBeEmpty(
"the router should close the app when navigating past the last view model without pushing a new view model");
}
}
public async Task Test_NavigateAsRoot_Acts_Like_NavigateBackWhile_True_And_Navigate()
{
Resolver.Register(() => new TestViewModel(), typeof(TestViewModel));
Resolver.Register(() => new OtherViewModel(), typeof(OtherViewModel));
var initParams = new RouterBuilder()
.When <OtherViewModel>(r => r.Navigate())
.When <TestViewModel>(r => r.NavigateAsRoot())
.Build();
var closeAppEvents = new List <Unit>();
Navigator = new Navigator();
Router = new Router(Navigator);
using (Router.CloseApp.Subscribe(u => closeAppEvents.Add(u)))
{
await Router.InitAsync(initParams);
await Router.ShowAsync <OtherViewModel, TestParams>();
await Router.ShowAsync <TestViewModel, TestParams>();
closeAppEvents.Should()
.BeEmpty("the router should not attempt to close app when navigating back past the last view model.");
Navigator.TransitionStack.Single().ViewModel.Should().BeOfType <TestViewModel>();
}
}
public async Task Test_Calls_CloseApp_On_RoutedAppConfig_When_Router_Notifies_CloseApp()
{
var navigator = new Navigator();
var router = new Router(navigator);
var stateStore = Substitute.For <IObjectStateStore>();
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.Build();
Register(() => new TestViewModel());
Register(routerParams);
Register(stateStore);
Register <IRouter>(router);
await AppHost.StartAsync();
await router.ShowAsync <TestViewModel, TestParams>();
await router.ShowAsync <TestViewModel, TestParams>();
await router.BackAsync();
await router.BackAsync();
Config.Received(1).CloseApp();
}
public async Task Test_CloseApp_Resolves_When_Navigating_Back_From_Root_ViewModel()
{
Navigator = new Navigator();
Router = new Router(Navigator);
Resolver.Register(() => new TestViewModel(), typeof(TestViewModel));
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.Build();
await Router.InitAsync(routerParams);
await Router.ShowAsync <TestViewModel, TestParams>();
await Router.ShowAsync <TestViewModel, TestParams>();
List <Unit> closeNotifications = new List <Unit>();
Router.CloseApp.Subscribe(u => closeNotifications.Add(u));
await Router.BackAsync();
closeNotifications.Should().BeEmpty();
await Router.BackAsync();
Assert.Collection(closeNotifications,
u => u.Should().NotBeNull());
}
Test_InvalidOperationException_Is_Thrown_If_Attempting_To_Navigate_To_ViewModel_That_Is_Not_In_RouterParams()
{
Navigator = new Navigator();
Router = new Router(Navigator);
var routerParams = new RouterBuilder()
.Build();
await Router.InitAsync(routerParams);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await Router.ShowAsync <TestViewModel, TestParams>();
});
}
public async Task Test_InvalidOperationException_Is_Thrown_If_ViewModel_Cannot_Be_Located()
{
Navigator = new Navigator();
Router = new Router(Navigator);
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate().Present())
.Build();
await Router.InitAsync(routerParams);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await Router.ShowAsync <TestViewModel, TestParams>();
});
}
public void RegisterDependencies(IMutableDependencyResolver resolver)
{
var routerConfig = new RouterBuilder()
.Default <PhotoListViewModel>()
.When <PhotoListViewModel>(route => route.Navigate().PresentPage())
.When <ShareViewModel>(route => route.Navigate().PresentPage())
.When <PhotoViewModel>(route => route.NavigateFrom <PhotoListViewModel>().PresentPage())
.Build();
resolver.RegisterConstant(routerConfig, typeof(RouterConfig));
resolver.Register(() => new PhotoListViewModel(), typeof(PhotoListViewModel));
resolver.Register(() => new PhotoViewModel(), typeof(PhotoViewModel));
resolver.Register(() => new ShareViewModel(), typeof(ShareViewModel));
resolver.Register(() => new PhotosService(), typeof(IPhotosService));
}
public void RegisterDependencies(IMutableDependencyResolver resolver)
{
var routerConfig = new RouterBuilder()
.Default <LoginViewModel>()
.When <LoginViewModel>(r => r.Navigate().PresentPage())
.When <TodoListViewModel>(r => r.NavigateAsRoot().PresentPage())
.When <SettingsViewModel>(r => r.Navigate().PresentPage())
.Build();
resolver.RegisterConstant(routerConfig, typeof(RouterConfig));
resolver.Register(() => new SettingsService(), typeof(ISettingsService));
resolver.Register(() => new TodoListViewModel(), typeof(TodoListViewModel));
resolver.Register(() => new SettingsViewModel(), typeof(SettingsViewModel));
resolver.Register(() => new LoginViewModel(), typeof(LoginViewModel));
resolver.Register(() => new TodoListPage(), typeof(TodoListPage));
resolver.Register(() => new SettingsPage(), typeof(SettingsPage));
resolver.Register(() => new LoginPage(), typeof(LoginPage));
}
public async Task Test_Only_Registers_Dependencies_On_The_First_Start()
{
var router = Substitute.For <IRouter>();
var stateStore = Substitute.For <IObjectStateStore>();
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.Build();
Register(() => new TestViewModel());
Register(routerParams);
Register(stateStore);
Register(router);
Config.Received(0).RegisterDependencies(Resolver);
await AppHost.StartAsync();
Config.Received(1).RegisterDependencies(Resolver);
await AppHost.StartAsync();
Config.Received(1).RegisterDependencies(Resolver);
}
public async Task Test_NavigateBackAction_Destroys_ViewModel()
{
Navigator = new Navigator();
Router = new Router(Navigator);
var viewModel = new TestViewModel();
Resolver.RegisterConstant(viewModel, typeof(TestViewModel));
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.Build();
await Router.InitAsync(routerParams);
await Router.ShowAsync <TestViewModel, TestParams>();
viewModel.Destroyed.Should().BeFalse();
await Router.BackAsync();
viewModel.Destroyed.Should().BeTrue();
}
public async Task Test_NavigateBackAction_Presents_Previous_ViewModel()
{
Navigator = new Navigator();
Router = new Router(Navigator);
var presenter = Substitute.For <IPresenter>();
Resolver.Register(() => new TestViewModel(), typeof(TestViewModel));
Resolver.RegisterConstant(presenter, typeof(IPresenter));
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate().Present())
.Build();
await Router.InitAsync(routerParams);
await Router.ShowAsync <TestViewModel, TestParams>();
await Router.ShowAsync <TestViewModel, TestParams>();
await Router.BackAsync();
presenter.Received(3).PresentAsync(Arg.Any <object>(), Arg.Any <object>());
}
public async Task Test_Does_Not_Save_State_When_Router_Notifies_CloseApp()
{
var closeApp = new Subject <Unit>();
var router = Substitute.For <IRouter>();
var stateStore = Substitute.For <IObjectStateStore>();
var routerParams = new RouterBuilder()
.When <TestViewModel>(r => r.Navigate())
.Build();
var routerState = new RouterState();
router.CloseApp.Returns(closeApp);
((IReActivatable)router).GetStateAsync().Returns(routerState);
Register(() => new TestViewModel());
Register(routerParams);
Register(stateStore);
Register(router);
await AppHost.StartAsync();
closeApp.OnNext(Unit.Default);
stateStore.DidNotReceive().SaveStateAsync(Arg.Is <ObjectState>(os => os.State == routerState));
}
public async Task Test_ShowAsync_With_NavigateBackWhile_Preserves_Current_ShowViewAction()
{
Locator.CurrentMutable.Register(() => new TestViewModel(), typeof(TestViewModel));
Locator.CurrentMutable.Register(() => new OtherViewModel(), typeof(OtherViewModel));
Router = new Router(new Navigator());
var initParams = new RouterBuilder()
.When <TestViewModel>(r => r.NavigateAsRoot())
.When <OtherViewModel>(r => r.Navigate())
.Build();
await Router.InitAsync(initParams);
await Router.ShowAsync(typeof(OtherViewModel), new TestParams());
await Router.ShowAsync(typeof(TestViewModel), new TestParams());
var state = (RouterState)(await ActivationHelpers.GetObjectStateAsync(Router)).State;
Assert.Collection(state.Actions,
a => a.Action.As <ShowViewModelAction>().ActivationParams.Type.Should().Be <TestViewModel>());
}
public void TestMethod6()
{
RouterBuilder builder = new RouterBuilder("../Inputs/input5.txt");
var townsFrom = builder.Build();
#region TestsResult
var sumDistanceResultTest = new List <Tuple <int, string> >()
{
Tuple.Create <int, string>(9, "NO SUCH ROUTE"),
Tuple.Create <int, string>(5, "NO SUCH ROUTE"),
Tuple.Create <int, string>(13, "NO SUCH ROUTE"),
Tuple.Create <int, string>(22, "NO SUCH ROUTE"),
Tuple.Create <int, string>(0, "NO SUCH ROUTE")
};
var sumRoutesToTownTest = new List <int>()
{
0, 0
};
var shortestRouteDistanceTest = new List <int> {
0, 0
};
var sumRoutesToTownMaxDistanceTest = new List <int>()
{
0
};
#endregion
var sumDistanceResult = new List <Tuple <int, string> >()
{
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'B', 'C' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'D' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'D', 'C' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'E', 'B', 'C', 'D' }, townsFrom),
RoutesVisitor.SumRouteDistance(new char[] { 'A', 'E', 'D' }, townsFrom)
};
var sumRoutesToTown = new List <int>()
{
RoutesVisitor.CountMaxStopRoutes(townsFrom, 'C', 'C', false, 3),
RoutesVisitor.CountMaxStopRoutes(townsFrom, 'A', 'C', true, 4)
};
var shortestRouteDistance = new List <int>()
{
RoutesVisitor.GetShortestRouteDistance(townsFrom, 'A', 'C'),
RoutesVisitor.GetShortestRouteDistance(townsFrom, 'B', 'B')
};
var sumRoutesToTownMaxDistance = new List <int>()
{
RoutesVisitor.CountMaxDistanceRoutes(townsFrom, 'C', 'C', 30)
};
#region Asserts
for (int i = 0; i < sumDistanceResult.Count; i++)
{
if (sumDistanceResultTest[i].Item2 != string.Empty)
{
if (sumDistanceResult[i].Item2 != sumDistanceResultTest[i].Item2)
{
Assert.Fail();
}
}
else if (sumDistanceResult[i].Item1 != sumDistanceResultTest[i].Item1)
{
Assert.Fail();
}
}
for (int i = 0; i < sumRoutesToTown.Count; i++)
{
if (sumRoutesToTownTest[i] != sumRoutesToTown[i])
{
Assert.Fail();
}
}
for (int i = 0; i < shortestRouteDistance.Count; i++)
{
if (shortestRouteDistanceTest[i] != shortestRouteDistance[i])
{
Assert.Fail();
}
}
for (int i = 0; i < sumRoutesToTownMaxDistance.Count; i++)
{
if (sumRoutesToTownMaxDistanceTest[i] != sumRoutesToTownMaxDistance[i])
{
Assert.Fail();
}
}
#endregion
}
