private void prepareWorkspace(bool isProEnabled) { var workspace = new MockWorkspace { Id = 123 }; var workspaceFeatures = new MockWorkspaceFeatureCollection { Features = new[] { new MockWorkspaceFeature { FeatureId = WorkspaceFeatureId.Pro, Enabled = isProEnabled } } }; var workspaceFeaturesObservable = Observable.Return(workspaceFeatures); var workspaceObservable = Observable.Return(workspace); InteractorFactory.GetWorkspaceFeaturesById(workspace.Id) .Execute() .Returns(workspaceFeaturesObservable); View.Select(Arg.Any <string>(), Arg.Any <IEnumerable <SelectOption <IThreadSafeWorkspace> > >(), Arg.Any <int>()) .Returns(workspaceObservable); }
public async Task ReturnsTheWorkspaceWithSmallestIdWhenUsersDefaultWorkspaceIsNull() { const long workspaceId = 11; var workspaces = new[] { new MockWorkspace { Id = workspaceId + 2 }, new MockWorkspace { Id = workspaceId }, new MockWorkspace { Id = workspaceId + 1 } }; var user = new MockUser { DefaultWorkspaceId = null }; DataSource.User.Get().Returns(Observable.Return(user)); DataSource.Workspaces.GetAll(Arg.Any <Func <IDatabaseWorkspace, bool> >()) .Returns(Observable.Return(workspaces)); var defaultWorkspace = await InteractorFactory.GetDefaultWorkspace().Execute(); defaultWorkspace.Id.Should().Be(workspaceId); }
public async Task CanBeExecutedForTheSecondTimeIfStartingTheFirstOneFinishesSuccessfully() { var suggestion = createSuggestion(); var timeEntry = Substitute.For <IThreadSafeTimeEntry>(); var mockedInteractor = Substitute.For <IInteractor <IObservable <IThreadSafeTimeEntry> > >(); InteractorFactory.StartSuggestion(Arg.Any <Suggestion>()).Returns(mockedInteractor); mockedInteractor.Execute() .Returns(Observable.Return(timeEntry)); await ViewModel.Initialize(); var auxObservable = TestScheduler.CreateObserver <Unit>(); Observable.Concat( Observable.Defer(() => ViewModel.StartTimeEntry.Execute(suggestion)), Observable.Defer(() => ViewModel.StartTimeEntry.Execute(suggestion)) ) .Subscribe(auxObservable); TestScheduler.Start(); InteractorFactory.Received(2).StartSuggestion(suggestion); }
public async Task ShouldNotTriggerReloadAfterDisappearingAndAppearingImmediately(int numberOfAppearances) { TimeService.CurrentDateTime.Returns(DateTimeOffset.Now); Interactor.Execute() .ReturnsForAnyArgs(Observable.Empty <ProjectSummaryReport>(SchedulerProvider.TestScheduler)); await ViewModel.Initialize(); ViewModel.CalendarViewModel.ViewAppeared(); InteractorFactory.ClearReceivedCalls(); for (int i = 0; i < numberOfAppearances; ++i) { ViewModel.ViewDisappeared(); ViewModel.ViewAppeared(); } TestScheduler.Start(); InteractorFactory .DidNotReceive() .GetProjectSummary(Arg.Any <long>(), Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>()); }
public void PassesTheCurrentWorkspaceToTheViewModel() { InteractorFactory .GetDefaultWorkspace() .Execute() .Returns(Observable.Return(Workspace)); Workspace.Id.Returns(DefaultWorkspaceId); var viewModel = CreateViewModel(); viewModel.Initialize("Some name"); viewModel.AttachView(View); TestScheduler.Start(); viewModel.PickClient.Execute(); TestScheduler.Start(); NavigationService.Received() .Navigate <SelectClientViewModel, SelectClientParameters, long?>( Arg.Is <SelectClientParameters>(parameter => parameter.WorkspaceId == DefaultWorkspaceId), viewModel.View ); }
public async Task ShouldTriggerAReportReload() { TimeService.CurrentDateTime.Returns(DateTimeOffset.Now); await ViewModel.Initialize(); ViewModel.CalendarViewModel.ViewAppeared(); TestScheduler.Start(); var mockWorkspace = new MockWorkspace { Id = WorkspaceId + 1 }; View.Select(Arg.Any <string>(), Arg.Any <IEnumerable <SelectOption <IThreadSafeWorkspace> > >(), Arg.Any <int>()) .Returns(Observable.Return(mockWorkspace)); ViewModel.SelectWorkspace.Execute(); TestScheduler.Start(); InteractorFactory.Received().GetProjectSummary( Arg.Is(mockWorkspace.Id), Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>()); }
public async Task TracksTheTimeEntryContinuedEvent(ContinueTimeEntryMode continueMode, ContinueTimeEntryOrigin expectedOrigin) { InteractorFactory .ContinueTimeEntry(Arg.Any <ITimeEntryPrototype>(), Arg.Any <ContinueTimeEntryMode>()) .Execute() .Returns(Observable.Return(createdTimeEntry)); var interactor = new ContinueTimeEntryFromMainLogInteractor( InteractorFactory, AnalyticsService, timeEntryPrototype, continueMode, IndexInLog, DayInLog, DaysInPast); await interactor.Execute(); AnalyticsService .Received() .TimeEntryContinued .Track(expectedOrigin, IndexInLog, DayInLog, DaysInPast); }
public async Task SetsTheReturnedClientAsTheClientNameProperty() { const string expectedName = "Some client"; long? expectedId = 10; var client = Substitute.For <IThreadSafeClient>(); client.Id.Returns(expectedId.Value); client.Name.Returns(expectedName); NavigationService .Navigate <SelectClientViewModel, SelectClientParameters, long?>(Arg.Any <SelectClientParameters>()) .Returns(Task.FromResult(expectedId)); InteractorFactory .GetDefaultWorkspace() .Execute() .Returns(Observable.Return(Workspace)); DataSource.Clients.GetById(expectedId.Value).Returns(Observable.Return(client)); Workspace.Id.Returns(WorkspaceId); ViewModel.Prepare("Some name"); await ViewModel.PickClientCommand.ExecuteAsync(); ViewModel.ClientName.Should().Be(expectedName); }
public async Task MarksTheCalendarAsSelectedIfItIsNotSelected() { var userCalendars = Enumerable .Range(0, 9) .Select(id => new UserCalendar( id.ToString(), $"Calendar #{id}", $"Source #{id % 3}", false)); var userCalendarsObservable = Observable.Return(userCalendars); InteractorFactory.GetUserCalendars().Execute().Returns(userCalendarsObservable); await ViewModel.Initialize(); var viewModelCalendars = await ViewModel.Calendars.FirstAsync(); var calendarToBeSelected = viewModelCalendars.First().Items.First(); ViewModel.SelectCalendar.Execute(calendarToBeSelected); TestScheduler.Start(); calendarToBeSelected.Selected.Should().BeTrue(); }
public void EmitsAnEventWhenATimeEntryIsCreated() { var createSubject = new Subject <IThreadSafeWorkspace>(); DataSource.Workspaces.Created.Returns(createSubject); DataSource.Workspaces.Updated.Returns(Observable.Never <EntityUpdate <IThreadSafeWorkspace> >()); DataSource.Workspaces.Deleted.Returns(Observable.Never <long>()); var testScheduler = new TestScheduler(); var observer = testScheduler.CreateObserver <IEnumerable <IThreadSafeTimeEntry> >(); InteractorFactory.ObserveAllTimeEntriesVisibleToTheUser() .Execute() .Subscribe(observer); var mockWorkspace = new MockWorkspace { Id = 42 }; createSubject.OnNext(mockWorkspace); observer.Messages.Should().HaveCount(1); }
public async Task GetsAnEventWhenAChangeToTimeEntriesHappens() { var createSubject = new Subject <IThreadSafeTimeEntry>(); DataSource.TimeEntries.Created.Returns(createSubject.AsObservable()); DataSource.TimeEntries.Updated.Returns(Observable.Never <EntityUpdate <IThreadSafeTimeEntry> >()); DataSource.TimeEntries.Deleted.Returns(Observable.Never <long>()); var testScheduler = new TestScheduler(); var observer = testScheduler.CreateObserver <Unit>(); InteractorFactory.ObserveWorkspaceOrTimeEntriesChanges().Execute() .Subscribe(observer); var mockTimeEntry = new MockTimeEntry { Id = 42 }; createSubject.OnNext(mockTimeEntry); createSubject.OnNext(mockTimeEntry); observer.Messages.Should().HaveCount(2); }
public async Task UpdatesTheStoredPreferences() { var oldBeginningOfWeek = BeginningOfWeek.Tuesday; var newBeginningOfWeek = BeginningOfWeek.Sunday; var user = Substitute.For <IThreadSafeUser>(); user.BeginningOfWeek.Returns(oldBeginningOfWeek); UserSubject.OnNext(user); View.Select( Arg.Any <string>(), Arg.Any <IEnumerable <SelectOption <BeginningOfWeek> > >(), Arg.Any <int>()) .Returns(Observable.Return(newBeginningOfWeek)); ViewModel.SelectBeginningOfWeek.Execute(); TestScheduler.Start(); await InteractorFactory .Received() .UpdateUser(Arg.Is <EditUserDTO>(dto => dto.BeginningOfWeek == newBeginningOfWeek)) .Execute(); }
public async Task UpdatesTheStoredPreferences() { var oldDurationFormat = DurationFormat.Decimal; var newDurationFormat = DurationFormat.Improved; var preferences = new MockPreferences { DurationFormat = oldDurationFormat }; PreferencesSubject.OnNext(preferences); View.Select( Arg.Any <string>(), Arg.Any <IEnumerable <SelectOption <DurationFormat> > >(), Arg.Any <int>()) .Returns(Observable.Return(newDurationFormat)); ViewModel.SelectDurationFormat.Execute(); TestScheduler.Start(); await InteractorFactory .Received() .UpdatePreferences(Arg.Is <EditPreferencesDTO>(dto => dto.DurationFormat.Equals(New <DurationFormat> .Value(newDurationFormat)))) .Execute(); }
public async Task UpdatesTheStoredPreferences() { var oldDateFormat = DateFormat.FromLocalizedDateFormat("MM-DD-YYYY"); var newDateFormat = DateFormat.FromLocalizedDateFormat("DD.MM.YYYY"); var preferences = new MockPreferences { DateFormat = oldDateFormat }; PreferencesSubject.OnNext(preferences); View.Select( Arg.Any <string>(), Arg.Any <IEnumerable <SelectOption <DateFormat> > >(), Arg.Any <int>()) .Returns(Observable.Return(newDateFormat)); ViewModel.SelectDateFormat.Execute(); TestScheduler.Start(); await InteractorFactory .Received() .UpdatePreferences(Arg.Is <EditPreferencesDTO>(dto => dto.DateFormat.Equals(New <DateFormat> .Value(newDateFormat)))) .Execute(); }
public void SetsTheEnabledCalendarsWhenThereAreCalendars(NonEmptyString[] nonEmptyStrings) { if (nonEmptyStrings == null) { return; } InteractorFactory.ClearReceivedCalls(); var viewModel = CreateViewModel(); var calendarIds = nonEmptyStrings.Select(str => str.Get).ToArray(); NavigationService.Navigate <SelectUserCalendarsViewModel, bool, string[]>(Arg.Any <bool>()).Returns(calendarIds); PermissionsService.RequestCalendarAuthorization().Returns(Observable.Return(true)); InteractorFactory.GetUserCalendars().Execute().Returns( Observable.Return(new UserCalendar[] { new UserCalendar() }) ); viewModel.GetStarted.Execute(Unit.Default); TestScheduler.Start(); InteractorFactory.Received().SetEnabledCalendars(calendarIds).Execute(); }
protected CalendarViewModelTest() { CalendarInteractor = Substitute.For <IInteractor <IObservable <IEnumerable <CalendarItem> > > >(); var workspace = new MockWorkspace { Id = DefaultWorkspaceId }; var timeEntry = new MockTimeEntry { Id = TimeEntryId }; TimeService.CurrentDateTime.Returns(Now); InteractorFactory .GetCalendarItemsForDate(Arg.Any <DateTime>()) .Returns(CalendarInteractor); InteractorFactory .GetDefaultWorkspace() .Execute() .Returns(Observable.Return(workspace)); InteractorFactory .CreateTimeEntry(Arg.Any <ITimeEntryPrototype>(), TimeEntryStartOrigin.CalendarEvent) .Execute() .Returns(Observable.Return(timeEntry)); InteractorFactory .CreateTimeEntry(Arg.Any <ITimeEntryPrototype>(), TimeEntryStartOrigin.CalendarTapAndDrag) .Execute() .Returns(Observable.Return(timeEntry)); InteractorFactory .UpdateTimeEntry(Arg.Any <EditTimeEntryDto>()) .Execute() .Returns(Observable.Return(timeEntry)); }
public async Task ReturnsSuggestionsFromEventsOneHourInThePastAndOneHourInTheFuture() { var now = new DateTimeOffset(2020, 1, 2, 3, 4, 5, TimeSpan.Zero); TimeService.CurrentDateTime.Returns(now); var tenMinutes = TimeSpan.FromMinutes(10); var events = Enumerable.Range(1, 5) .Select(id => new CalendarItem( id.ToString(), CalendarItemSource.Calendar, now - tenMinutes * id, tenMinutes, id.ToString(), CalendarIconKind.None)); CalendarService .GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>()) .Returns(Observable.Return(events)); var userCalendar = new UserCalendar( "", "", "", true); InteractorFactory.GetUserCalendars().Execute() .Returns(Observable.Return(new List <UserCalendar> { userCalendar })); var suggestions = await Provider.GetSuggestions().ToList(); await CalendarService.Received().GetEventsInRange(now.AddHours(-1), now.AddHours(1)); suggestions.Should().HaveCount(1) .And.OnlyContain(suggestion => events.Any(@event => @event.Description == suggestion.Description)); }
public async Task IsSortedBySelectedStatusThenByName() { var workspace = createWorkspace(13, "Some workspace"); var tagSuggestions = getTagSuggestions(4, workspace).ToArray(); var shuffledTags = new[] { tagSuggestions[3], tagSuggestions[1], tagSuggestions[2], tagSuggestions[0] }; var selectedTagIds = new[] { tagSuggestions[0].TagId, tagSuggestions[2].TagId }; InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >()) .Execute() .Returns(Observable.Return(shuffledTags)); InteractorFactory.GetWorkspaceById(workspace.Id).Execute() .Returns(Observable.Return(workspace)); ViewModel.Prepare((selectedTagIds, workspace.Id)); await ViewModel.Initialize(); var observer = TestScheduler.CreateObserver <IEnumerable <SelectableTagBaseViewModel> >(); ViewModel.Tags.Subscribe(observer); TestScheduler.Start(); var tags = observer.LastEmittedValue().ToArray(); tags.Should().HaveCount(4); tags[0].Name.Should().Be("Tag0"); tags[1].Name.Should().Be("Tag2"); tags[2].Name.Should().Be("Tag1"); tags[3].Name.Should().Be("Tag3"); tags[0].Selected.Should().BeTrue(); tags[1].Selected.Should().BeTrue(); tags[2].Selected.Should().BeFalse(); tags[3].Selected.Should().BeFalse(); }
public void SetsProperCalendarsAsSelected( NonEmptySet <NonEmptyString> strings0, NonEmptySet <NonEmptyString> strings1) { var enabledCalendarIds = strings0.Get.Select(str => str.Get).ToList(); var unenabledCalendarIds = strings1.Get.Select(str => str.Get).ToList(); var allCalendarIds = enabledCalendarIds.Concat(unenabledCalendarIds).ToList(); UserPreferences.EnabledCalendarIds().Returns(enabledCalendarIds); var userCalendars = allCalendarIds .Select(id => new UserCalendar( id, "Does not matter", "Does not matter, pt.2" )); InteractorFactory .GetUserCalendars() .Execute() .Returns(Observable.Return(userCalendars)); var viewModel = CreateViewModel(); viewModel.Initialize(false).Wait(); var calendars = viewModel.Calendars.FirstAsync().Wait(); foreach (var calendarGroup in calendars) { foreach (var calendar in calendarGroup.Items) { if (enabledCalendarIds.Contains(calendar.Id)) { calendar.Selected.Should().BeTrue(); } } } }
public async Task SavesThePreviouslySelectedCalendarIds() { var initialSelectedIds = new List <string> { "0", "1", "2", "3" }; UserPreferences.EnabledCalendarIds().Returns(initialSelectedIds); PermissionsService.CalendarPermissionGranted.Returns(Observable.Return(true)); var userCalendars = Enumerable .Range(0, 9) .Select(id => new UserCalendar( id.ToString(), $"Calendar #{id}", $"Source #{id % 3}", false)); InteractorFactory .GetUserCalendars() .Execute() .Returns(Observable.Return(userCalendars)); await ViewModel.Initialize(); var selectedIds = new[] { "0", "2", "4", "7" }; var calendars = userCalendars .Where(calendar => selectedIds.Contains(calendar.Id)) .Select(calendar => new SelectableUserCalendarViewModel(calendar, false)); ViewModel.SelectCalendar.ExecuteSequentally(calendars) .PrependAction(ViewModel.Close) .Subscribe(); TestScheduler.Start(); UserPreferences.Received().SetEnabledCalendars(initialSelectedIds.ToArray()); }
public async Task ReloadsSuggestionsWhenTimeEntriesUpdate() { var changesSubject = new Subject <Unit>(); InteractorFactory.ObserveWorkspaceOrTimeEntriesChanges().Execute().Returns(changesSubject); var provider = suggestionProvider(); SetProviders(SuggestionProviderContainer, provider); var observer = TestScheduler.CreateObserver <Suggestion[]>(); await ViewModel.Initialize(); ViewModel.Suggestions.Subscribe(observer); changesSubject.OnNext(Unit.Default); TestScheduler.Start(); observer.Messages.Should().HaveCount(2); observer.Messages.First().Value.Value.Should().HaveCount(0); observer.LastEmittedValue().Should().HaveCount(0); await provider.Received(2).GetSuggestions(); }
public void IsSetToTheFirstEligibleForProjectCreationIfDefaultIsNotEligible() { var observer = TestScheduler.CreateObserver <string>(); var defaultWorkspace = Substitute.For <IThreadSafeWorkspace>(); defaultWorkspace.Name.Returns(DefaultWorkspaceName); defaultWorkspace.Admin.Returns(false); defaultWorkspace.OnlyAdminsMayCreateProjects.Returns(true); var eligibleWorkspace = Substitute.For <IThreadSafeWorkspace>(); eligibleWorkspace.Name.Returns("Eligible workspace for project creation"); eligibleWorkspace.Admin.Returns(true); InteractorFactory.GetDefaultWorkspace().Execute() .Returns(Observable.Return(defaultWorkspace)); InteractorFactory.GetAllWorkspaces().Execute() .Returns(Observable.Return(new[] { defaultWorkspace, eligibleWorkspace })); var viewModel = CreateViewModel(); viewModel.WorkspaceName.Subscribe(observer); TestScheduler.Start(); observer.LastEmittedValue().Should().Be(eligibleWorkspace.Name); }
public void PropagatesErrorIfUpdateFails() { var failingTimeEntry = Models.TimeEntry.Builder.Create(12) .SetStart(now) .SetSyncStatus(SyncStatus.InSync) .SetDescription("") .SetUserId(11) .SetWorkspaceId(10) .SetAt(now) .Build(); var timeEntryObservable = Observable.Return(failingTimeEntry); var errorObservable = Observable.Throw <IThreadSafeTimeEntry>(new DatabaseOperationException <IDatabaseTimeEntry>(new Exception())); InteractorFactory.GetTimeEntryById(Arg.Is(timeEntry.Id)) .Execute() .Returns(timeEntryObservable); DataSource.TimeEntries.Update(Arg.Any <IThreadSafeTimeEntry>()).Returns(errorObservable); var observer = Substitute.For <IObserver <Unit> >(); interactor.Execute().Subscribe(observer); observer.Received().OnError(Arg.Any <DatabaseOperationException <IDatabaseTimeEntry> >()); }
public void EmitsFalseAfterAllTheCalendarsHaveBeenDeselected() { var observer = Substitute.For <IObserver <bool> >(); ViewModel.Done.Enabled.Subscribe(observer); var userCalendars = Enumerable .Range(0, 3) .Select(id => new UserCalendar(id.ToString(), id.ToString(), "Doesn't matter")); var selectedableUserCalendars = userCalendars .Select(userCalendar => new SelectableUserCalendarViewModel(userCalendar, false)); InteractorFactory .GetUserCalendars() .Execute() .Returns(Observable.Return(userCalendars)); var auxObserver = TestScheduler.CreateObserver <Unit>(); ViewModel.SelectCalendar.ExecuteSequentally( selectedableUserCalendars .Concat(selectedableUserCalendars) ) .Subscribe(auxObserver); TestScheduler.Start(); Received.InOrder(() => { observer.OnNext(false); observer.OnNext(true); observer.OnNext(false); }); }
public async Task ClosesTheViewModelAndReturnsTheInitialCalendarIds() { var initialSelectedIds = new List <string> { "0", "1", "2", "3" }; UserPreferences.EnabledCalendarIds().Returns(initialSelectedIds); var userCalendars = Enumerable .Range(0, 9) .Select(id => new UserCalendar( id.ToString(), $"Calendar #{id}", $"Source #{id % 3}", false)); InteractorFactory .GetUserCalendars() .Execute() .Returns(Observable.Return(userCalendars)); await ViewModel.Initialize(); var selectedIds = new[] { "0", "2", "4", "7" }; var calendars = userCalendars .Where(calendar => selectedIds.Contains(calendar.Id)) .Select(calendar => new SelectableUserCalendarViewModel(calendar, false)); ViewModel.SelectCalendar.ExecuteSequentally(calendars) .PrependAction(ViewModel.Close) .Subscribe(); TestScheduler.Start(); await NavigationService.Received().Close(ViewModel, Arg.Is <string[]>(ids => ids.SequenceEqual(initialSelectedIds))); }
public async Task OnlyContainsTagsFromTheSameWorkspaceAsTimeEntry() { var tags = new List <TagSuggestion>(); var workspaces = Enumerable.Range(0, 5) .Select(i => createWorkspace(i, $"Workspace{i}")).ToArray(); workspaces.ForEach(workspace => tags.AddRange(getTagSuggestions(5, workspace))); InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >()) .Execute() .Returns(Observable.Return(tags)); var targetWorkspace = workspaces[1]; InteractorFactory.GetWorkspaceById(targetWorkspace.Id).Execute() .Returns(Observable.Return(targetWorkspace)); var tagIds = tags.Select(tag => tag.TagId).ToArray(); ViewModel.Prepare((tagIds, targetWorkspace.Id)); await ViewModel.Initialize(); ViewModel.Tags.Should().HaveCount(5); ViewModel.Tags.Should() .OnlyContain(tag => tag.Workspace == targetWorkspace.Name); }
public async Task DoesNotIncludeProjectCreationRowWhenTheTextIsEmpty() { var workspaceId = 0; setupWorkspace(workspaceId, isEligibleForProjectCreation: true); var projectSuggestions = getProjectSuggestions(10, workspaceId: workspaceId); var suggestionsObservable = Observable.Return(projectSuggestions); InteractorFactory .GetProjectsAutocompleteSuggestions(Arg.Any <IList <string> >()) .Execute() .Returns(suggestionsObservable); var observer = TestScheduler.CreateObserver <IEnumerable <SectionModel <string, AutocompleteSuggestion> > >(); ViewModel.Suggestions.Subscribe(observer); await ViewModel.Initialize(); TestScheduler.Start(); var latestSuggestions = observer.Messages.Last().Value.Value; latestSuggestions.Should().HaveCount(1); }
public async Task GroupsProjectsByWorkspace() { var suggestions = new List <ProjectSuggestion>(); var workspaceIds = new[] { 0, 1, 10, 54 }; suggestions.AddRange(getProjectSuggestions(3, workspaceId: workspaceIds[0])); suggestions.AddRange(getProjectSuggestions(4, workspaceId: workspaceIds[1])); suggestions.AddRange(getProjectSuggestions(1, workspaceId: workspaceIds[2])); suggestions.AddRange(getProjectSuggestions(10, workspaceId: workspaceIds[3])); var suggestionsObservable = Observable.Return(suggestions); InteractorFactory .GetProjectsAutocompleteSuggestions(Arg.Any <IList <string> >()) .Execute() .Returns(suggestionsObservable); var observer = TestScheduler.CreateObserver <IEnumerable <SectionModel <string, AutocompleteSuggestion> > >(); ViewModel.Suggestions.Subscribe(observer); await ViewModel.Initialize(); TestScheduler.Start(); var latestSuggestions = observer.Messages.Last().Value.Value.ToArray(); latestSuggestions.Should().HaveCount(4); for (int i = 0; i < latestSuggestions.Length; i++) { foreach (var suggestion in latestSuggestions[i].Items) { suggestion.WorkspaceName.Should().Be(latestSuggestions[i].Header); suggestion.WorkspaceId.Should().Be(workspaceIds[i]); } } }
public async Task UpdatesTheCollapseTimeEntriesProperty() { var oldValue = false; var newValue = true; var oldPreferences = new MockPreferences { CollapseTimeEntries = oldValue }; var newPreferences = new MockPreferences { CollapseTimeEntries = newValue }; PreferencesSubject.OnNext(oldPreferences); InteractorFactory.UpdatePreferences(Arg.Any <EditPreferencesDTO>()) .Execute() .Returns(Observable.Return(newPreferences)); ViewModel.ToggleTimeEntriesGrouping.Execute(); TestScheduler.Start(); await InteractorFactory .Received() .UpdatePreferences(Arg.Is <EditPreferencesDTO>(dto => dto.CollapseTimeEntries.ValueOr(oldValue) == newValue)) .Execute(); }
public void PicksADefaultColorIfTheSelectedColorIsCustomAndTheWorkspaceIsNotPro() { var someColor = new Color(23, 45, 125); NavigationService .Navigate <SelectColorViewModel, ColorParameters, Color>(Arg.Any <ColorParameters>(), ViewModel.View) .Returns(Task.FromResult(someColor)); View.Select( Arg.Any <string>(), Arg.Any <IEnumerable <SelectOption <IThreadSafeWorkspace> > >(), Arg.Any <int>()) .Returns(Observable.Return(new MockWorkspace { Id = workspaceId })); InteractorFactory.AreCustomColorsEnabledForWorkspace(workspaceId).Execute() .Returns(Observable.Return(false)); ViewModel.PickColor.Execute(); TestScheduler.Start(); ViewModel.PickWorkspace.Execute(); TestScheduler.Start(); ViewModel.Color.Should().NotBe(someColor); }