Ejemplo n.º 1
0
        public void OnCurrentPageChanged()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };
            var tabbedPageMock = new TabbedPageMock(eventRecoder);

            tabbedPageMock.Children.Add(contentPageMock1);
            tabbedPageMock.Children.Add(contentPageMock2);

            tabbedPageMock.Behaviors.Add(new MultiPageBehavior <Page>());

            tabbedPageMock.CurrentPage = contentPageMock2;

            Assert.Equal(2, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(contentPageMock2, eventRecoder[0].Sender);
            Assert.Equal("OnLoaded", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(contentPageMock1, eventRecoder[1].Sender);
            Assert.Equal("OnUnloaded", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);
        }
Ejemplo n.º 2
0
        public async Task PushModalAsync_WithParameter()
        {
            var eventRecorder        = new EventRecorder();
            var contentPageMock1     = new ContentPageMock(eventRecorder);
            var navigationMock       = new Mock <INavigation>();
            var navigator            = new Navigator(contentPageMock1, navigationMock.Object);
            var behaviorInjectorMock = new Mock <IBehaviorInjector>();

            navigator.BehaviorInjector = behaviorInjectorMock.Object;

            var contentPageMock2 = new ContentPageMock(eventRecorder);
            var parameter        = new object();
            await navigator.PushModalAsync(contentPageMock2, parameter);


            behaviorInjectorMock.Verify(x => x.Inject(contentPageMock2), Times.Once);
            navigationMock.Verify(x => x.PushModalAsync(contentPageMock2, true), Times.Once);

            Assert.Equal(3, eventRecorder.Count);

            Assert.Equal(contentPageMock2, eventRecorder[0].Sender);
            Assert.Equal("OnInitialize", eventRecorder[0].CallerMemberName);
            Assert.Equal(parameter, eventRecorder[0].Parameter);

            Assert.Equal(contentPageMock2, eventRecorder[1].Sender);
            Assert.Equal("OnLoaded", eventRecorder[1].CallerMemberName);
            Assert.Null(eventRecorder[1].Parameter);

            Assert.Equal(contentPageMock1, eventRecorder[2].Sender);
            Assert.Equal("OnUnloaded", eventRecorder[2].CallerMemberName);
            Assert.Null(eventRecorder[2].Parameter);
        }
Ejemplo n.º 3
0
        public async Task PopToRootAsync_WhenAnimatedIsFalse()
        {
            var eventRecorder    = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock2"
            };
            var contentPageMock3 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock3"
            };
            // ReSharper disable once UnusedVariable
            var navigationPage = new NavigationPageMock(contentPageMock1, eventRecorder);
            await contentPageMock1.Navigation.PushAsync(contentPageMock2);

            await contentPageMock2.Navigation.PushAsync(contentPageMock3);

            var navigationMock = new Mock <INavigation>();

            navigationMock
            .Setup(m => m.PopToRootAsync(false))
            .Returns(() => Task.FromResult(false))
            .Callback(() => contentPageMock3.Navigation.PopToRootAsync(false).Wait());

            var navigator = new Navigator(contentPageMock3, navigationMock.Object);
            await navigator.PopToRootAsync(false);

            navigationMock.Verify(x => x.PopToRootAsync(false), Times.Once);
        }
Ejemplo n.º 4
0
        public async Task PopToRootAsync_WhenParentIsNotNavigationPage()
        {
            var eventRecorder    = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock2"
            };
            var contentPageMock3 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock3"
            };
            var tabbedPage = new TabbedPage();

            tabbedPage.Children.Add(contentPageMock1);
            tabbedPage.Children.Add(contentPageMock2);
            tabbedPage.Children.Add(contentPageMock3);

            var navigationMock = new Mock <INavigation>();
            var navigator      = new Navigator(contentPageMock3, navigationMock.Object);
            await navigator.PopToRootAsync();

            Assert.Equal(0, eventRecorder.Count);
            navigationMock.Verify(m => m.PopToRootAsync(It.IsAny <bool>()), Times.Never);
        }
Ejemplo n.º 5
0
        public void OnResume_WithModalStackPages()
        {
            var eventRecorder    = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecorder);

            var application = new ApplicationMock {
                MainPage = contentPageMock1
            };

            var contentPageMock2 = new ContentPageMock(eventRecorder);

            contentPageMock1.Navigation.PushModalAsync(contentPageMock2);

            var contentPageMock3 = new ContentPageMock(eventRecorder);

            contentPageMock2.Navigation.PushModalAsync(contentPageMock3);

            LifecycleNoticeService.OnResume(application);

            Assert.Equal(3, eventRecorder.Count);

            Assert.Equal(contentPageMock1, eventRecorder[0].Sender);
            Assert.Equal("OnResume", eventRecorder[0].CallerMemberName);
            Assert.Null(eventRecorder[0].Parameter);

            Assert.Equal(contentPageMock2, eventRecorder[1].Sender);
            Assert.Equal("OnResume", eventRecorder[1].CallerMemberName);
            Assert.Null(eventRecorder[1].Parameter);

            Assert.Equal(contentPageMock3, eventRecorder[2].Sender);
            Assert.Equal("OnResume", eventRecorder[2].CallerMemberName);
            Assert.Null(eventRecorder[2].Parameter);
        }
Ejemplo n.º 6
0
        public void ContentPage()
        {
            var eventRecoder    = new EventRecorder();
            var viewModelMock   = new ViewModelMock(eventRecoder);
            var contentPageMock = new ContentPageMock(eventRecoder)
            {
                BindingContext = viewModelMock
            };

            LifecycleNoticeService.OnResume(new ApplicationMock {
                MainPage = contentPageMock
            });

            Assert.Equal(2, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(contentPageMock, eventRecoder[0].Sender);
            Assert.Equal("OnResume", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(viewModelMock, eventRecoder[1].Sender);
            Assert.Equal("OnResume", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);
        }
Ejemplo n.º 7
0
        public void OnCurrentPageChanged()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };
            var navigationPageMock = new NavigationPageMock(contentPageMock1, eventRecoder);

            contentPageMock1.Navigation.PushAsync(contentPageMock2);

            navigationPageMock.Behaviors.Add(new NavigationPageBehavior());

            contentPageMock2.Navigation.PopAsync();

            Assert.Equal(2, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(contentPageMock1, eventRecoder[0].Sender);
            Assert.Equal("OnLoaded", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(contentPageMock2, eventRecoder[1].Sender);
            Assert.Equal("OnClosed", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);
        }
Ejemplo n.º 8
0
        public async void NavigateAsync_ToContentPage_ThenGoBack()
        {
            var pageMock          = new ContentPageMock();
            var navigationService = new PageNavigationServiceMock(_container, _applicationProvider, _loggerFacade);

            ((IPageAware)navigationService).Page = pageMock;

            var rootPage = new NavigationPage(pageMock);

            Assert.IsType(typeof(ContentPageMock), rootPage.CurrentPage);

            await navigationService.NavigateAsync("TabbedPage");

            Assert.True(rootPage.Navigation.NavigationStack.Count == 2);
            Assert.IsType(typeof(TabbedPageMock), rootPage.CurrentPage);
            var tabbedPageMock = rootPage.CurrentPage as TabbedPageMock;

            Assert.NotNull(tabbedPageMock);
            var viewModel = (ViewModelBase)tabbedPageMock.BindingContext;

            await navigationService.GoBackAsync();

            Assert.True(rootPage.Navigation.NavigationStack.Count == 1);
            Assert.IsType(typeof(ContentPageMock), rootPage.CurrentPage);
            Assert.True(tabbedPageMock.DestroyCalled);
            Assert.Null(tabbedPageMock.BindingContext);
            Assert.True(viewModel.DestroyCalled);
        }
Ejemplo n.º 9
0
        public void NavigationPage()
        {
            var eventRecoder       = new EventRecorder();
            var contentPageMock1   = new ContentPageMock(eventRecoder);
            var contentPageMock2   = new ContentPageMock(eventRecoder);
            var viewModelMock      = new ViewModelMock(eventRecoder);
            var navigationPageMock = new NavigationPageMock(contentPageMock1, eventRecoder)
            {
                BindingContext = viewModelMock
            };

            contentPageMock1.Navigation.PushAsync(contentPageMock2);

            LifecycleNoticeService.OnUnloaded(navigationPageMock);

            Assert.Equal(3, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(contentPageMock2, eventRecoder[0].Sender);
            Assert.Equal("OnUnloaded", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(viewModelMock, eventRecoder[1].Sender);
            Assert.Equal("OnUnloaded", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);

            Assert.NotNull(eventRecoder[2]);
            Assert.Equal(navigationPageMock, eventRecoder[2].Sender);
            Assert.Equal("OnUnloaded", eventRecoder[2].CallerMemberName);
            Assert.Null(eventRecoder[2].Parameter);
        }
Ejemplo n.º 10
0
        public void SetMainPage_WithParameter()
        {
            var behaviorInjector = new Mock <IBehaviorInjector>();
            var eventRecorder    = new EventRecorder();
            var contentPageMock  = new ContentPageMock(eventRecorder);

            behaviorInjector.Setup(m => m.Inject(contentPageMock))
            .Callback(() => eventRecorder.Record(behaviorInjector));

            ApplicationService.BehaviorInjector = behaviorInjector.Object;

            var parameter = new object();

            ApplicationService.SetMainPage(contentPageMock, parameter);

            ApplicationMock.VerifySet(m => m.MainPage = contentPageMock);

            Assert.Equal(3, eventRecorder.Count);

            // BehaviorInjector
            Assert.NotNull(eventRecorder[0]);
            Assert.Equal(behaviorInjector, eventRecorder[0].Sender);

            // OnInitialize
            Assert.NotNull(eventRecorder[1]);
            Assert.Equal(contentPageMock, eventRecorder[1].Sender);
            Assert.Equal("OnInitialize", eventRecorder[1].CallerMemberName);
            Assert.Equal(parameter, eventRecorder[1].Parameter);

            // OnLoaded
            Assert.NotNull(eventRecorder[2]);
            Assert.Equal(contentPageMock, eventRecorder[2].Sender);
            Assert.Equal("OnLoaded", eventRecorder[2].CallerMemberName);
        }
Ejemplo n.º 11
0
        public void OnPagesChanged_WhenAddChild()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var tabbedPageMock = new TabbedPageMock(eventRecoder);

            tabbedPageMock.Children.Add(contentPageMock1);

            tabbedPageMock.Behaviors.Add(new MultiPageBehavior <Page>());

            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };

            tabbedPageMock.Children.Add(contentPageMock2);

            Assert.Equal(1, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(contentPageMock2, eventRecoder[0].Sender);
            Assert.Equal("OnInitialize", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);
        }
        public async Task GoBackToRootAsync_PopsToRoot()
        {
            var navigationService = new PageNavigationServiceMock(null, null, null);
            var rootPage          = new Xamarin.Forms.NavigationPage();

            ((IPageAware)navigationService).Page = rootPage;

            var page1 = new ContentPageMock()
            {
                Title = "Page 1"
            };
            await rootPage.Navigation.PushAsync(page1);

            await rootPage.Navigation.PushAsync(new ContentPageMock()
            {
                Title = "Page 2"
            });

            await rootPage.Navigation.PushAsync(new ContentPageMock()
            {
                Title = "Page 3"
            });

            await rootPage.Navigation.PushAsync(new ContentPageMock()
            {
                Title = "Page 4"
            });

            Assert.True(rootPage.Navigation.NavigationStack.Count == 4);

            await navigationService.GoBackToRootAsync();

            Assert.Equal(1, rootPage.Navigation.NavigationStack.Count);
            Assert.Equal(page1, rootPage.Navigation.NavigationStack[0]);
        }
Ejemplo n.º 13
0
        public void RemovePage_LastPage()
        {
            var eventRecorder    = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecorder);
            var navigationPage   = new NavigationPage(contentPageMock1);

            navigationPage.Behaviors.Add(new NavigationPageBehavior());
            var contentPageMock2 = new ContentPageMock(eventRecorder);

            contentPageMock1.Navigation.PushAsync(contentPageMock2);

            var navigator = new Navigator(contentPageMock2);

            navigator.RemovePage(contentPageMock2);

            Assert.Equal(contentPageMock1, navigationPage.CurrentPage);

            Assert.Equal(2, eventRecorder.Count);

            Assert.Equal(contentPageMock1, eventRecorder[0].Sender);
            Assert.Equal("OnLoaded", eventRecorder[0].CallerMemberName);
            Assert.Null(eventRecorder[0].Parameter);

            Assert.Equal(contentPageMock2, eventRecorder[1].Sender);
            Assert.Equal("OnClosed", eventRecorder[1].CallerMemberName);
            Assert.Null(eventRecorder[1].Parameter);
        }
        public void DestoryMasterDetailPage()
        {
            var recorder   = new PageNavigationEventRecorder();
            var masterPage = new ContentPageMock(recorder)
            {
                Title = "Master"
            };
            var masterPageViewModel = masterPage.BindingContext;
            var detailPage          = new ContentPageMock(recorder)
            {
                Title = "Detail"
            };
            var detailPageViewModel       = detailPage.BindingContext;
            var masterDetailPage          = new MasterDetailPageMock(recorder, masterPage, detailPage);
            var masterDetailPageViewModel = masterDetailPage.BindingContext;

            PageUtilities.DestroyPage(masterDetailPage);

            // MasterPage
            var record = recorder.TakeFirst();

            Assert.Equal(masterPage, record.Sender);
            Assert.Null(masterPage.BindingContext);
            Assert.Equal(0, masterPage.Behaviors.Count);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(masterPageViewModel, record.Sender);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            // DetailPage
            record = recorder.TakeFirst();
            Assert.Equal(detailPage, record.Sender);
            Assert.Null(detailPage.BindingContext);
            Assert.Equal(0, detailPage.Behaviors.Count);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(detailPageViewModel, record.Sender);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            // MasterDetailPage
            record = recorder.TakeFirst();
            Assert.Equal(masterDetailPage, record.Sender);
            Assert.Null(masterDetailPage.BindingContext);
            Assert.Equal(0, masterDetailPage.Behaviors.Count);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(masterDetailPageViewModel, record.Sender);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            Assert.True(recorder.IsEmpty);
        }
Ejemplo n.º 15
0
        public void OnClosed()
        {
            var eventRecorder   = new EventRecorder();
            var contentPageMock = new ContentPageMock(eventRecorder);

            LifecycleNoticeService.OnClosed(contentPageMock);

            Assert.Equal(1, eventRecorder.Count);
            Assert.Equal(contentPageMock, eventRecorder[0].Sender);
            Assert.Equal("OnClosed", eventRecorder[0].CallerMemberName);
            Assert.Null(eventRecorder[0].Parameter);
        }
Ejemplo n.º 16
0
        public void OnInitialize()
        {
            var eventRecorder   = new EventRecorder();
            var contentPageMock = new ContentPageMock(eventRecorder);
            var parameter       = new object();

            LifecycleNoticeService.OnInitialize(contentPageMock, parameter);

            Assert.Equal(1, eventRecorder.Count);
            Assert.Equal(contentPageMock, eventRecorder[0].Sender);
            Assert.Equal("OnInitialize", eventRecorder[0].CallerMemberName);
            Assert.Equal(parameter, eventRecorder[0].Parameter);
        }
Ejemplo n.º 17
0
        public async void Navigate_ToContentPage_ByAbsoluteUri()
        {
            // Set up top page.
            var recorder            = new PageNavigationEventRecorder();;
            var rootPage            = new ContentPageMock(recorder);
            var rootPageViewModel   = (ViewModelBase)rootPage.BindingContext;
            var applicationProvider = new ApplicationProviderMock(rootPage);
            var navigationService   = new PageNavigationServiceMock(_container, applicationProvider, _loggerFacade, recorder);

            await navigationService.NavigateAsync(new Uri("http://localhost/ContentPage", UriKind.Absolute));

            var navigatedPage = applicationProvider.MainPage;

            Assert.IsType(typeof(ContentPageMock), navigatedPage);
            Assert.NotEqual(rootPage, _applicationProvider.MainPage);

            var record = recorder.TakeFirst();

            Assert.Equal(navigatedPage, record.Sender);
            Assert.Equal(PageNavigationEvent.OnNavigatingTo, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(navigatedPage.BindingContext, record.Sender);
            Assert.Equal(PageNavigationEvent.OnNavigatingTo, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(rootPage, record.Sender);
            Assert.Equal(PageNavigationEvent.OnNavigatedFrom, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(rootPageViewModel, record.Sender);
            Assert.Equal(PageNavigationEvent.OnNavigatedFrom, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(navigatedPage, record.Sender);
            Assert.Equal(PageNavigationEvent.OnNavigatedTo, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(navigatedPage.BindingContext, record.Sender);
            Assert.Equal(PageNavigationEvent.OnNavigatedTo, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(rootPage, record.Sender);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            record = recorder.TakeFirst();
            Assert.Equal(rootPageViewModel, record.Sender);
            Assert.Equal(PageNavigationEvent.Destroy, record.Event);

            Assert.True(recorder.IsEmpty);
        }
        public async void Navigate_ToContentPage_PageHasIConfirmNavigation_True()
        {
            var navigationService = new PageNavigationServiceMock(_container);
            var rootPage          = new ContentPageMock();

            ((IPageAware)navigationService).Page = rootPage;

            Assert.False(rootPage.OnConfirmNavigationCalled);

            await navigationService.Navigate("ContentPage");

            Assert.True(rootPage.OnConfirmNavigationCalled);
            Assert.True(rootPage.Navigation.ModalStack.Count == 1);
        }
Ejemplo n.º 19
0
        public void NotNotifiedBindingContext()
        {
            var eventReporder = new EventRecorder();
            var contentPage   = new ContentPageMock(eventReporder)
            {
                BindingContext = new object()
            };

            LifecycleNoticeService.OnInitialize(contentPage);

            Assert.Equal(1, eventReporder.Count);
            Assert.Equal(contentPage, eventReporder[0].Sender);
            Assert.Equal("OnInitialize", eventReporder[0].CallerMemberName);
            Assert.Null(eventReporder[0].Parameter);
        }
Ejemplo n.º 20
0
        public void CanNotPop()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var navigationPageMock = new NavigationPageMock(contentPageMock1, eventRecoder);

            navigationPageMock.Behaviors.Add(new NavigationPageBehavior());

            contentPageMock1.Navigation.PopAsync();

            Assert.Equal(0, eventRecoder.Count);
        }
Ejemplo n.º 21
0
        public void OnResume()
        {
            var eventRecorder   = new EventRecorder();
            var contentPageMock = new ContentPageMock(eventRecorder);

            var application = new ApplicationMock {
                MainPage = contentPageMock
            };

            LifecycleNoticeService.OnResume(application);

            Assert.Equal(1, eventRecorder.Count);
            Assert.Equal(contentPageMock, eventRecorder[0].Sender);
            Assert.Equal("OnResume", eventRecorder[0].CallerMemberName);
            Assert.Null(eventRecorder[0].Parameter);
        }
Ejemplo n.º 22
0
        public void NavigationPage()
        {
            var eventRecoder              = new EventRecorder();
            var contentPageMock1          = new ContentPageMock(eventRecoder);
            var contentPageMock2ViewModel = new ViewModelMock(eventRecoder);
            var contentPageMock2          = new ContentPageMock(eventRecoder)
            {
                BindingContext = contentPageMock2ViewModel
            };
            var viewModelMock      = new ViewModelMock(eventRecoder);
            var navigationPageMock = new NavigationPageMock(contentPageMock1, eventRecoder)
            {
                BindingContext = viewModelMock
            };

            contentPageMock1.Navigation.PushAsync(contentPageMock2);
            var parameter = "Hello, Parameter!";

            LifecycleNoticeService.OnInitialize(navigationPageMock, parameter);

            Assert.Equal(5, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(navigationPageMock, eventRecoder[0].Sender);
            Assert.Equal("OnInitialize", eventRecoder[0].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(viewModelMock, eventRecoder[1].Sender);
            Assert.Equal("OnInitialize", eventRecoder[1].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[1].Parameter);

            Assert.NotNull(eventRecoder[2]);
            Assert.Equal(contentPageMock1, eventRecoder[2].Sender);
            Assert.Equal("OnInitialize", eventRecoder[2].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[2].Parameter);

            Assert.NotNull(eventRecoder[3]);
            Assert.Equal(contentPageMock2, eventRecoder[3].Sender);
            Assert.Equal("OnInitialize", eventRecoder[3].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[3].Parameter);

            Assert.NotNull(eventRecoder[4]);
            Assert.Equal(contentPageMock2ViewModel, eventRecoder[4].Sender);
            Assert.Equal("OnInitialize", eventRecoder[4].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[4].Parameter);
        }
Ejemplo n.º 23
0
        public async Task PopToRootAsync()
        {
            var eventRecorder    = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock2"
            };
            var contentPageMock3 = new ContentPageMock(eventRecorder)
            {
                Title = "contentPageMock3"
            };
            // ReSharper disable once UnusedVariable
            var navigationPage = new NavigationPageMock(contentPageMock1, eventRecorder);
            await contentPageMock1.Navigation.PushAsync(contentPageMock2);

            await contentPageMock2.Navigation.PushAsync(contentPageMock3);

            var navigationMock = new Mock <INavigation>();

            navigationMock
            .Setup(m => m.PopToRootAsync(true))
            .Returns(() => Task.FromResult(true))
            .Callback(() => contentPageMock3.Navigation.PopToRootAsync(true).Wait());

            var navigator = new Navigator(contentPageMock3, navigationMock.Object);
            await navigator.PopToRootAsync();

            navigationMock.Verify(x => x.PopToRootAsync(true), Times.Once);

            Assert.Equal(3, eventRecorder.Count);

            Assert.Equal(contentPageMock1, eventRecorder[0].Sender);
            Assert.Equal("OnLoaded", eventRecorder[0].CallerMemberName);
            Assert.Null(eventRecorder[0].Parameter);

            Assert.Equal(contentPageMock3, eventRecorder[1].Sender);
            Assert.Equal("OnClosed", eventRecorder[1].CallerMemberName);
            Assert.Null(eventRecorder[1].Parameter);

            Assert.Equal(contentPageMock2, eventRecorder[2].Sender);
            Assert.Equal("OnClosed", eventRecorder[2].CallerMemberName);
            Assert.Null(eventRecorder[2].Parameter);
        }
Ejemplo n.º 24
0
        public async Task PushModalAsync_WhenAnimatedIsFalse()
        {
            var eventRecorder        = new EventRecorder();
            var contentPageMock1     = new ContentPageMock(eventRecorder);
            var navigationMock       = new Mock <INavigation>();
            var navigator            = new Navigator(contentPageMock1, navigationMock.Object);
            var behaviorInjectorMock = new Mock <IBehaviorInjector>();

            navigator.BehaviorInjector = behaviorInjectorMock.Object;

            var contentPageMock2 = new ContentPageMock(eventRecorder);
            await navigator.PushModalAsync(contentPageMock2, false);


            behaviorInjectorMock.Verify(x => x.Inject(contentPageMock2), Times.Once);
            navigationMock.Verify(x => x.PushModalAsync(contentPageMock2, false), Times.Once);
        }
Ejemplo n.º 25
0
        public void CarouselPage()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };
            var viewModelMock    = new ViewModelMock(eventRecoder);
            var carouselPageMock = new CarouselPageMock(eventRecoder)
            {
                BindingContext = viewModelMock
            };

            carouselPageMock.Children.Add(contentPageMock1);
            carouselPageMock.Children.Add(contentPageMock2);

            LifecycleNoticeService.OnResume(new ApplicationMock {
                MainPage = carouselPageMock
            });

            Assert.Equal(4, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(carouselPageMock, eventRecoder[0].Sender);
            Assert.Equal("OnResume", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(viewModelMock, eventRecoder[1].Sender);
            Assert.Equal("OnResume", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);

            Assert.NotNull(eventRecoder[2]);
            Assert.Equal(contentPageMock1, eventRecoder[2].Sender);
            Assert.Equal("OnResume", eventRecoder[2].CallerMemberName);
            Assert.Null(eventRecoder[2].Parameter);

            Assert.NotNull(eventRecoder[3]);
            Assert.Equal(contentPageMock2, eventRecoder[3].Sender);
            Assert.Equal("OnResume", eventRecoder[3].CallerMemberName);
            Assert.Null(eventRecoder[3].Parameter);
        }
Ejemplo n.º 26
0
        public void CarouselPage()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };
            var viewModelMock    = new ViewModelMock(eventRecoder);
            var carouselPageMock = new CarouselPageMock(eventRecoder)
            {
                BindingContext = viewModelMock
            };

            carouselPageMock.Children.Add(contentPageMock1);
            carouselPageMock.Children.Add(contentPageMock2);
            var parameter = "Hello, Parameter!";

            LifecycleNoticeService.OnInitialize(carouselPageMock, parameter);

            Assert.Equal(4, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(carouselPageMock, eventRecoder[0].Sender);
            Assert.Equal("OnInitialize", eventRecoder[0].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(viewModelMock, eventRecoder[1].Sender);
            Assert.Equal("OnInitialize", eventRecoder[1].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[1].Parameter);

            Assert.NotNull(eventRecoder[2]);
            Assert.Equal(contentPageMock1, eventRecoder[2].Sender);
            Assert.Equal("OnInitialize", eventRecoder[2].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[2].Parameter);

            Assert.NotNull(eventRecoder[3]);
            Assert.Equal(contentPageMock2, eventRecoder[3].Sender);
            Assert.Equal("OnInitialize", eventRecoder[3].CallerMemberName);
            Assert.Equal(parameter, eventRecoder[3].Parameter);
        }
Ejemplo n.º 27
0
        public void MasterDetailPage()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };
            var viewModelMock        = new ViewModelMock(eventRecoder);
            var masterDetailPageMock = new MasterDetailPageMock(eventRecoder)
            {
                Master         = contentPageMock1,
                Detail         = contentPageMock2,
                BindingContext = viewModelMock
            };

            LifecycleNoticeService.OnResume(new ApplicationMock {
                MainPage = masterDetailPageMock
            });

            Assert.Equal(4, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(masterDetailPageMock, eventRecoder[0].Sender);
            Assert.Equal("OnResume", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(viewModelMock, eventRecoder[1].Sender);
            Assert.Equal("OnResume", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);

            Assert.NotNull(eventRecoder[2]);
            Assert.Equal(contentPageMock1, eventRecoder[2].Sender);
            Assert.Equal("OnResume", eventRecoder[2].CallerMemberName);
            Assert.Null(eventRecoder[2].Parameter);

            Assert.NotNull(eventRecoder[3]);
            Assert.Equal(contentPageMock2, eventRecoder[3].Sender);
            Assert.Equal("OnResume", eventRecoder[3].CallerMemberName);
            Assert.Null(eventRecoder[3].Parameter);
        }
        public async void Navigate_ToContentPage_PageHasIConfirmNavigation_False()
        {
            var navigationService = new PageNavigationServiceMock(_container);
            var rootPage          = new ContentPageMock();

            ((IPageAware)navigationService).Page = rootPage;

            Assert.False(rootPage.OnConfirmNavigationCalled);

            var navParams = new NavigationParameters();

            navParams.Add("canNavigate", false);

            await navigationService.Navigate("ContentPage", navParams);

            Assert.True(rootPage.OnConfirmNavigationCalled);
            Assert.True(rootPage.Navigation.ModalStack.Count == 0);
        }
Ejemplo n.º 29
0
        public void DestroyContentPage()
        {
            var recorder  = new PageNavigationEventRecorder();
            var page      = new ContentPageMock(recorder);
            var viewModel = (ViewModelBase)page.BindingContext;

            PageUtilities.DestroyPage(page);

            Assert.Equal(2, recorder.Records.Count);

            Assert.Equal(page, recorder.Records[0].Sender);
            Assert.Null(page.BindingContext);
            Assert.Equal(0, page.Behaviors.Count);
            Assert.Equal(PageNavigationEvent.Destroy, recorder.Records[0].Event);

            Assert.Equal(viewModel, recorder.Records[1].Sender);
            Assert.Equal(PageNavigationEvent.Destroy, recorder.Records[1].Event);
        }
Ejemplo n.º 30
0
        public void TabbedPage()
        {
            var eventRecoder     = new EventRecorder();
            var contentPageMock1 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock1"
            };
            var contentPageMock2 = new ContentPageMock(eventRecoder)
            {
                Title = "contentPageMock2"
            };
            var viewModelMock  = new ViewModelMock(eventRecoder);
            var tabbedPageMock = new TabbedPageMock(eventRecoder)
            {
                BindingContext = viewModelMock
            };

            tabbedPageMock.Children.Add(contentPageMock1);
            tabbedPageMock.Children.Add(contentPageMock2);

            LifecycleNoticeService.OnClosed(tabbedPageMock);

            Assert.Equal(4, eventRecoder.Count);

            Assert.NotNull(eventRecoder[0]);
            Assert.Equal(contentPageMock2, eventRecoder[0].Sender);
            Assert.Equal("OnClosed", eventRecoder[0].CallerMemberName);
            Assert.Null(eventRecoder[0].Parameter);

            Assert.NotNull(eventRecoder[1]);
            Assert.Equal(contentPageMock1, eventRecoder[1].Sender);
            Assert.Equal("OnClosed", eventRecoder[1].CallerMemberName);
            Assert.Null(eventRecoder[1].Parameter);

            Assert.NotNull(eventRecoder[2]);
            Assert.Equal(viewModelMock, eventRecoder[2].Sender);
            Assert.Equal("OnClosed", eventRecoder[2].CallerMemberName);
            Assert.Null(eventRecoder[2].Parameter);

            Assert.NotNull(eventRecoder[3]);
            Assert.Equal(tabbedPageMock, eventRecoder[3].Sender);
            Assert.Equal("OnClosed", eventRecoder[3].CallerMemberName);
            Assert.Null(eventRecoder[3].Parameter);
        }