Exemplo n.º 1
0
            public async ThreadingTask ReturnsTheCountOfInteractorResult()
            {
                var syncables = new IDatabaseSyncable[]
                {
                    new MockTag {
                        Name = "Tag", SyncStatus = SyncStatus.SyncFailed, LastSyncErrorMessage = "Error1"
                    },
                    new MockTag {
                        Name = "Tag2", SyncStatus = SyncStatus.SyncFailed, LastSyncErrorMessage = "Error1"
                    },
                    new MockProject {
                        Name = "Project", SyncStatus = SyncStatus.SyncFailed, LastSyncErrorMessage = "Error2"
                    }
                };

                var items = syncables.Select(i => new SyncFailureItem(i));

                var interactor = Substitute.For <IInteractor <IObservable <IEnumerable <SyncFailureItem> > > >();

                interactor.Execute().Returns(Observable.Return(items));
                InteractorFactory.GetItemsThatFailedToSync().Returns(interactor);

                await ViewModel.Initialize();

                ViewModel.NumberOfSyncFailures.Should().Be(3);
            }
Exemplo n.º 2
0
            public async ThreadingTask ReturnsTheCountOfInteractorResult()
            {
                var syncables = new IDatabaseSyncable[]
                {
                    new MockTag {
                        Name = "Tag", SyncStatus = SyncStatus.SyncFailed, LastSyncErrorMessage = "Error1"
                    },
                    new MockTag {
                        Name = "Tag2", SyncStatus = SyncStatus.SyncFailed, LastSyncErrorMessage = "Error1"
                    },
                    new MockProject {
                        Name = "Project", SyncStatus = SyncStatus.SyncFailed, LastSyncErrorMessage = "Error2"
                    }
                };
                var items      = syncables.Select(i => new SyncFailureItem(i));
                var interactor = Substitute.For <IInteractor <IObservable <IEnumerable <SyncFailureItem> > > >();

                interactor.Execute().Returns(Observable.Return(items));
                InteractorFactory.GetItemsThatFailedToSync().Returns(interactor);
                await ViewModel.Initialize();

                var observer = TestScheduler.CreateObserver <int>();

                ViewModel.NumberOfSyncFailures.Subscribe(observer);
                TestScheduler.AdvanceBy(50);

                observer.Messages
                .Last(m => m.Value.Kind == System.Reactive.NotificationKind.OnNext).Value.Value
                .Should()
                .Be(syncables.Length);
            }
Exemplo n.º 3
0
            public void ReturnsTheInteractorResultAsAList()
            {
                var mockedInteractor = Substitute.For <IInteractor <IObservable <IEnumerable <SyncFailureItem> > > >();

                InteractorFactory.GetItemsThatFailedToSync().Returns(mockedInteractor);

                SyncFailureItem[] result =
                {
                    new SyncFailureItem(new MockProject {
                        Name = "MyProject"
                    }),
                    new SyncFailureItem(new MockProject {
                        Name = "MyProject 2"
                    }),
                    new SyncFailureItem(new MockTag     {
                        Name = "MyTag"
                    })
                };

                mockedInteractor.Execute().Returns(Observable.Return(result));

                ViewModel.Initialize();

                ViewModel.SyncFailures.Should().BeEquivalentTo(result);
            }
            public void ExecutesGetItemsThatFailedInteractor()
            {
                var mockedInteractor = Substitute.For<IInteractor<IObservable<IEnumerable<SyncFailureItem>>>>();
                InteractorFactory.GetItemsThatFailedToSync().Returns(mockedInteractor);

                ViewModel.Initialize();

                mockedInteractor.Received().Execute();
            }
Exemplo n.º 5
0
            public async Task ReturnsOnlyItemsThatFailedToSync()
            {
                MockClient[] clients =
                {
                    new MockClient {
                        Id = 0, SyncStatus = SyncStatus.SyncFailed
                    },
                    new MockClient {
                        Id = 1, SyncStatus = SyncStatus.InSync
                    },
                    new MockClient {
                        Id = 2, SyncStatus = SyncStatus.SyncFailed
                    },
                    new MockClient {
                        Id = 3, SyncStatus = SyncStatus.SyncNeeded
                    },
                    new MockClient {
                        Id = 4, SyncStatus = SyncStatus.InSync
                    },
                    new MockClient {
                        Id = 5, SyncStatus = SyncStatus.SyncFailed
                    }
                };

                DataSource.Clients
                .GetAll(Arg.Any <Func <IDatabaseClient, bool> >())
                .Returns(callInfo =>
                {
                    var filteredClients = clients.Where(callInfo.Arg <Func <IDatabaseClient, bool> >());
                    return(Observable.Return(filteredClients.Cast <IThreadSafeClient>()));
                });

                MockProject[] projects =
                {
                    new MockProject {
                        Id = 0, SyncStatus = SyncStatus.SyncFailed
                    },
                    new MockProject {
                        Id = 1, SyncStatus = SyncStatus.InSync
                    },
                    new MockProject {
                        Id = 2, SyncStatus = SyncStatus.SyncFailed
                    },
                };

                DataSource.Projects
                .GetAll(Arg.Any <Func <IDatabaseProject, bool> >())
                .Returns(callInfo =>
                {
                    var filteredProjects = projects.Where(callInfo.Arg <Func <IDatabaseProject, bool> >());
                    return(Observable.Return(filteredProjects.Cast <IThreadSafeProject>()));
                });

                MockTag[] tags = { };

                DataSource.Tags
                .GetAll(Arg.Any <Func <IDatabaseTag, bool> >())
                .Returns(callInfo =>
                {
                    var fiteredTags = tags.Where(callInfo.Arg <Func <IDatabaseTag, bool> >());
                    return(Observable.Return(fiteredTags.Cast <IThreadSafeTag>()));
                });

                int syncFailedCount = clients.Count(p => p.SyncStatus == SyncStatus.SyncFailed) +
                                      projects.Count(p => p.SyncStatus == SyncStatus.SyncFailed) +
                                      tags.Count(p => p.SyncStatus == SyncStatus.SyncFailed);

                var returnedClients = await InteractorFactory.GetItemsThatFailedToSync().Execute();

                returnedClients.Count().Should().Be(syncFailedCount);
            }