public async Task ClosesTheViewModelAndReturnsSelectedCalendarIds()
{
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.Done)
.Subscribe();
TestScheduler.Start();
await NavigationService.Received().Close(ViewModel, Arg.Is <string[]>(ids => ids.SequenceEqual(selectedIds)));
}
public async Task MarksTheCalendarAsNotSelectedIfItIsSelected()
{
var userCalendars = Enumerable
.Range(0, 9)
.Select(id => new UserCalendar(
id.ToString(),
$"Calendar #{id}",
$"Source #{id % 3}",
true));
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); //Select the calendar
TestScheduler.Start();
ViewModel.SelectCalendar.Execute(calendarToBeSelected); //Deselect the calendar
TestScheduler.Start();
calendarToBeSelected.Selected.Should().BeFalse();
}
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(false);
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).Subscribe();
ViewModel.CloseWithDefaultResult();
TestScheduler.Start();
(await ViewModel.Result).Should().BeSequenceEquivalentTo(initialSelectedIds);
}
public async Task ReturnsSuggestionsFromUserSelectedCalendars()
{
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,
calendarId: id.ToString()));
var userCalendars = Enumerable.Range(2, 3)
.Select(id => new UserCalendar(
id.ToString(),
id.ToString(),
"",
true));
CalendarService
.GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>())
.Returns(Observable.Return(events));
InteractorFactory.GetUserCalendars().Execute().Returns(Observable.Return(userCalendars));
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 => userCalendars.Select(c => c.Id).Contains(@event.CalendarId)));
}
protected override void AdditionalSetup()
{
OnboardingStorage
.CompletedCalendarOnboarding()
.Returns(true);
PermissionsService
.CalendarPermissionGranted
.Returns(Observable.Return(true));
NavigationService
.Navigate <SelectUserCalendarsViewModel, bool, string[]>(Arg.Any <bool>())
.Returns(new string[0]);
InteractorFactory
.GetUserCalendars()
.Execute()
.Returns(Observable.Return(new UserCalendar().Yield()));
DialogService
.Alert(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>())
.Returns(Observable.Return(Unit.Default));
TestScheduler.AdvanceBy(1);
}
public async Task TracksNumberOfLinkedCalendarsChanged()
{
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(false);
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.Save)
.Subscribe();
TestScheduler.Start();
AnalyticsService.NumberOfLinkedCalendarsChanged.Received().Track(4);
AnalyticsService.NumberOfLinkedCalendarsNewUser.DidNotReceiveWithAnyArgs().Track(4);
}
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().Wait();
foreach (var calendarGroup in viewModel.Calendars)
{
foreach (var calendar in calendarGroup)
{
if (enabledCalendarIds.Contains(calendar.Id))
{
calendar.Selected.Should().BeTrue();
}
}
}
}
public async Task ShowsADialogWhenThereAreNoCalendars()
{
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[0])
);
await ViewModel.SelectCalendars.Execute(Unit.Default);
await NavigationService.DidNotReceive().Navigate <SelectUserCalendarsViewModel, string[]>();
}
public async Task DoesNotNavigateToTheSelectUserCalendarsViewModelWhenThereAreNoCalendars()
{
PermissionsService.RequestCalendarAuthorization().Returns(Observable.Return(true));
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[0])
);
await ViewModel.GetStartedAction.Execute(Unit.Default);
await NavigationService.DidNotReceive().Navigate <SelectUserCalendarsViewModel, string[]>();
}
public async Task HandlesNotAuthorizedException()
{
InteractorFactory
.GetUserCalendars()
.Execute()
.Returns(Observable.Throw <IEnumerable <UserCalendar> >(new NotAuthorizedException("")));
await ViewModel.Initialize();
ViewModel.Calendars.Should().HaveCount(0);
}
public async Task DoesNotNavigateToTheSelectUserCalendarsViewModelWhenThereAreNoCalendars()
{
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[0])
);
await ViewModel.SelectCalendars.Execute(Unit.Default);
await DialogService
.Received()
.Alert(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>());
}
public async Task DoesNotNavigateToTheSelectUserCalendarsViewModelWhenThereAreNoCalendars()
{
View.RequestCalendarAuthorization().Returns(Observable.Return(true));
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[0])
);
Action.Execute();
TestScheduler.Start();
await NavigationService.DidNotReceive().Navigate <SelectUserCalendarsViewModel, bool, string[]>(Arg.Any <bool>(), ViewModel.View);
}
public async Task ShowsADialogWhenThereAreNoCalendars()
{
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[0])
);
ViewModel.SelectCalendars.Execute();
TestScheduler.Start();
await NavigationService.DidNotReceive()
.Navigate <SelectUserCalendarsViewModel, bool, string[]>(Arg.Any <bool>(), ViewModel.View);
}
public async Task DoesNotNavigateToTheSelectUserCalendarsViewModelWhenThereAreNoCalendars()
{
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[0])
);
ViewModel.SelectCalendars.Execute();
TestScheduler.Start();
await View.Received()
.Alert(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>());
}
public async Task NavigatesToTheSelectUserCalendarsViewModelWhenThereAreCalendars()
{
PermissionsService.RequestCalendarAuthorization().Returns(Observable.Return(true));
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[] { new UserCalendar() })
);
await ViewModel.GetStartedAction.Execute(Unit.Default);
await NavigationService
.Received()
.Navigate <SelectUserCalendarsViewModel, bool, string[]>(Arg.Any <bool>());
}
public override async Task Initialize()
{
await base.Initialize();
SelectedCalendarIds.AddRange(userPreferences.EnabledCalendarIds());
await InteractorFactory
.GetUserCalendars()
.Execute()
.Catch((NotAuthorizedException _) => Observable.Return(new List <UserCalendar>()))
.Select(calendars => calendars.Select(toSelectable))
.Do(calendars => calendars.ForEach(calendar => Calendars.InsertItem(calendar)));
}
public async Task ReturnsSuggestionsSortedByABSOffsetFromNow()
{
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,
id % 2 == 0 ? now - tenMinutes * id : now + tenMinutes * id,
tenMinutes,
id.ToString(),
CalendarIconKind.None));
var expectedSuggestionIds = new List <string>
{
"1",
"2",
"3",
"4",
"5"
};
var userCalendar = new UserCalendar(
"",
"",
"",
true);
CalendarService
.GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>())
.Returns(Observable.Return(events));
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 => expectedSuggestionIds.Any(expectedId => expectedId == suggestion.Description));
}
public async Task DeselectsAllCalendarAfterDisablingIntegration()
{
var initialSelectedIds = new List <string> {
"0"
};
UserPreferences.EnabledCalendarIds().Returns(initialSelectedIds);
PermissionsChecker.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(false);
var selectedIds = new[] { "2", "4", "7" };
var calendars = userCalendars
.Where(calendar => selectedIds.Contains(calendar.Id))
.Select(calendar => new SelectableUserCalendarViewModel(calendar, false));
ViewModel.SelectCalendar.ExecuteSequentally(calendars)
.PrependAction(ViewModel.TogglCalendarIntegration)
.PrependAction(ViewModel.Save)
.Subscribe();
TestScheduler.Start();
Received.InOrder(() =>
{
UserPreferences.SetEnabledCalendars(new[] { "0", "2" });
UserPreferences.SetEnabledCalendars(new[] { "0", "2", "4" });
UserPreferences.SetEnabledCalendars(new[] { "0", "2", "4", "7" });
UserPreferences.SetEnabledCalendars();
});
}
public async Task FillsTheCalendarList()
{
var userCalendarsObservable = Enumerable
.Range(0, 9)
.Select(id => new UserCalendar(
id.ToString(),
$"Calendar #{id}",
$"Source #{id % 3}",
false))
.Apply(Observable.Return);
InteractorFactory.GetUserCalendars().Execute().Returns(userCalendarsObservable);
await ViewModel.Initialize();
ViewModel.Calendars.Should().HaveCount(3);
ViewModel.Calendars.ForEach(group => group.Should().HaveCount(3));
}
public async Task MarksAllCalendarsAsNotSelected()
{
var userCalendarsObservable = Enumerable
.Range(0, 9)
.Select(id => new UserCalendar(
id.ToString(),
$"Calendar #{id}",
$"Source #{id % 3}",
false))
.Apply(Observable.Return);
InteractorFactory.GetUserCalendars().Execute().Returns(userCalendarsObservable);
await ViewModel.Initialize();
foreach (var calendarGroup in ViewModel.Calendars)
{
calendarGroup.All(calendar => !calendar.Selected);
}
}
public async Task TracksNumberOfLinkedCalendarsNewUser()
{
var initialSelectedIds = new List <string> {
};
UserPreferences.EnabledCalendarIds().Returns(initialSelectedIds);
PermissionsChecker.CalendarPermissionGranted.Returns(Observable.Return(true));
OnboardingStorage.IsFirstTimeConnectingCalendars().Returns(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(false);
var selectedIds = new[] { "2", "4", "7" };
var calendars = userCalendars
.Where(calendar => selectedIds.Contains(calendar.Id))
.Select(calendar => new SelectableUserCalendarViewModel(calendar, false));
ViewModel.SelectCalendar.ExecuteSequentally(calendars)
.PrependAction(ViewModel.Save)
.Subscribe();
TestScheduler.Start();
ViewModel.ViewDisappeared();
AnalyticsService.NumberOfLinkedCalendarsNewUser.Received().Track(3);
AnalyticsService.NumberOfLinkedCalendarsChanged.DidNotReceiveWithAnyArgs().Track(3);
}
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.GetStartedAction.Execute(Unit.Default).Wait();
InteractorFactory.Received().SetEnabledCalendars(calendarIds).Execute();
}
public async Task FillsTheCalendarList()
{
var userCalendarsObservable = Enumerable
.Range(0, 9)
.Select(id => new UserCalendar(
id.ToString(),
$"Calendar #{id}",
$"Source #{id % 3}",
false))
.Apply(Observable.Return);
InteractorFactory.GetUserCalendars().Execute().Returns(userCalendarsObservable);
var viewModel = new MockSelectUserCalendarsViewModel(UserPreferences, InteractorFactory, NavigationService, RxActionFactory);
await viewModel.Initialize();
var calendars = await viewModel.Calendars.FirstAsync();
calendars.Should().HaveCount(3);
calendars.ForEach(group => group.Items.Should().HaveCount(3));
}
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 ReturnsSuggestionsForTheDefaultWorkspace()
{
var defaultWorkspace = new MockWorkspace(10);
var now = new DateTimeOffset(2020, 10, 9, 8, 7, 6, TimeSpan.Zero);
InteractorFactory.GetDefaultWorkspace().Execute().Returns(Observable.Return(defaultWorkspace));
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();
suggestions.Should().OnlyContain(suggestion => suggestion.WorkspaceId == defaultWorkspace.Id);
}
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 void SetsTheEnabledCalendarsWhenThereAreCalendars(NonEmptyString[] nonEmptyStrings)
{
if (nonEmptyStrings == null)
{
return;
}
InteractorFactory.ClearReceivedCalls();
var viewModel = CreateViewModel();
viewModel.AttachView(View);
var calendarIds = nonEmptyStrings.Select(str => str.Get).ToArray();
NavigationService.Navigate <SelectUserCalendarsViewModel, bool, string[]>(Arg.Any <bool>(), viewModel.View).Returns(calendarIds);
View.RequestCalendarAuthorization().Returns(Observable.Return(true));
InteractorFactory.GetUserCalendars().Execute().Returns(
Observable.Return(new UserCalendar[] { new UserCalendar() })
);
viewModel.SelectCalendars.Execute();
TestScheduler.Start();
InteractorFactory.Received().SetEnabledCalendars(calendarIds).Execute();
}
public async Task ReturnsAllCalendarsFromTheCalendarService()
{
var calendars = await InteractorFactory.GetUserCalendars().Execute();
calendars.Should().HaveCount(calendarsFromService.Count());
}
public async Task SetsTheCalendarsToSelectedWhenTheyWereSelectedByTheUser()
{
var calendars = await InteractorFactory.GetUserCalendars().Execute();
calendars.Where(c => c.IsSelected).Should().HaveCount(selectedCalendars.Count());
}
