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 TheExecuteMethod()
{
var observable = Observable.Return(calendarsFromService);
CalendarService.GetUserCalendars().Returns(observable);
UserPreferences.EnabledCalendarIds().Returns(selectedCalendars);
}
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 OnlyRetunsCalendarItemsThatComeFromEnabledCalendars()
{
UserPreferences.EnabledCalendarIds().Returns("1".Yield().ToList());
var calendarItems = await interactor.Execute();
calendarItems.Count().Should().Be(calendarEvents.Count + calendarItemsFromTimeEntries.Count - 1);
}
public async Task GetsInitialisedToTheProperValue(bool permissionGranted)
{
UserPreferences.EnabledCalendarIds().Returns(new List <string>());
PermissionsChecker.CalendarPermissionGranted.Returns(Observable.Return(permissionGranted));
await ViewModel.Initialize(false);
ViewModel.PermissionGranted.Should().Be(permissionGranted);
}
public void SubtractsTheUserConfiguredTimeSpanFromTheEventsStartDate(long ticks)
{
if (ticks < 0)
{
return;
}
var timeSpan = TimeSpan.FromTicks(ticks);
var now = new DateTimeOffset(2020, 1, 1, 0, 0, 0, TimeSpan.Zero);
var endOfWeek = now.AddDays(7);
var eightHours = TimeSpan.FromHours(8);
var events = Enumerable
.Range(0, 14)
.Select(number => new CalendarItem(
id: number.ToString(),
source: CalendarItemSource.Calendar,
startTime: now.Add(eightHours * number),
duration: eightHours,
description: number.ToString(),
iconKind: CalendarIconKind.None,
calendarId: "1"
));
var expectedNotifications = events
.Where(calendarItem => calendarItem.StartTime >= now + timeSpan)
.Select(@event => new Notification(
@event.Id,
"Event reminder",
@event.Description,
@event.StartTime - timeSpan
));
UserPreferences
.TimeSpanBeforeCalendarNotifications
.Returns(Observable.Return(timeSpan));
UserPreferences
.EnabledCalendarIds()
.Returns(new List <string> {
"1"
});
CalendarService
.GetEventsInRange(now, endOfWeek)
.Returns(Observable.Return(events));
TimeService.CurrentDateTime.Returns(now);
NotificationService.ClearReceivedCalls();
interactor.Execute().Wait();
NotificationService
.Received()
.Schedule(Arg.Is <IImmutableList <Notification> >(
notifications => notifications.SequenceEqual(expectedNotifications))
);
}
public void DoesNotSetTheEnabledCalendarsToNullWhenCalendarPermissionsWereGranted()
{
PermissionsChecker.CalendarPermissionGranted.Returns(Observable.Return(true));
UserPreferences.EnabledCalendarIds().Returns(new List <string>());
var viewModel = CreateViewModel();
viewModel.Initialize(false).Wait();
UserPreferences.DidNotReceive().SetEnabledCalendars(Arg.Is <string[]>(strings => strings == null || strings.Length == 0));
}
public async Task SchedulesEventsOnlyFromEnabledCalendars()
{
const int eventsPerCalendar = 4;
var now = new DateTimeOffset(2020, 1, 2, 3, 4, 5, TimeSpan.Zero);
IEnumerable <CalendarItem> eventsForCalendar(UserCalendar calendar)
{
return(Enumerable
.Range(1, eventsPerCalendar)
.Select(id => new CalendarItem(
id.ToString(),
CalendarItemSource.Calendar,
now.AddHours(id),
TimeSpan.FromHours(1),
"description",
CalendarIconKind.None,
calendarId: calendar.Id
)));
}
var calendars = Enumerable
.Range(0, 3)
.Select(id => id.ToString())
.Select(id => new UserCalendar(
id,
id,
"Does not matter"
))
.ToArray();
CalendarService.GetUserCalendars().Returns(Observable.Return(calendars));
var events = calendars
.SelectMany(eventsForCalendar);
CalendarService
.GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>())
.Returns(Observable.Return(events));
UserPreferences.EnabledCalendarIds().Returns(new List <string> {
"1"
});
TimeService.CurrentDateTime.Returns(now);
await interactor.Execute();
await NotificationService.Received().Schedule(Arg.Is <ImmutableList <Notification> >(
notifications => notifications.Count == eventsPerCalendar
));
}
public async Task SchedulesNotificationsForAllUpcomingEventsInTheNextWeekThatBeginAfterTheCurrentDate()
{
var now = new DateTimeOffset(2020, 1, 1, 0, 0, 0, TimeSpan.Zero);
var endOfWeek = now.AddDays(7);
var eightHours = TimeSpan.FromHours(8);
var tenMinutes = TimeSpan.FromMinutes(10);
var events = Enumerable
.Range(0, 14)
.Select(number => new CalendarItem(
id: number.ToString(),
source: CalendarItemSource.Calendar,
startTime: now.Add(eightHours * number),
duration: eightHours,
description: number.ToString(),
iconKind: CalendarIconKind.None,
calendarId: "1"
));
var expectedNotifications = events
.Where(calendarItem => calendarItem.StartTime >= now + tenMinutes)
.Select(@event => new Notification(
@event.Id,
"Event reminder",
@event.Description,
@event.StartTime - tenMinutes
));
UserPreferences
.TimeSpanBeforeCalendarNotifications
.Returns(Observable.Return(tenMinutes));
CalendarService
.GetEventsInRange(now, endOfWeek)
.Returns(Observable.Return(events));
TimeService.CurrentDateTime.Returns(now);
UserPreferences.EnabledCalendarIds().Returns(new List <string> {
"1"
});
await interactor.Execute();
await NotificationService
.Received()
.Schedule(Arg.Is <IImmutableList <Notification> >(
notifications => notifications.SequenceEqual(expectedNotifications))
);
}
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 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 override async Task Initialize(bool forceItemSelection)
{
base.Initialize(forceItemSelection);
ForceItemSelection = forceItemSelection;
var calendarIds = UserPreferences.EnabledCalendarIds();
InitialSelectedCalendarIds.AddRange(calendarIds);
SelectedCalendarIds.AddRange(calendarIds);
await ReloadCalendars();
var enabledObservable = ForceItemSelection
? SelectCalendar.Elements
.Select(_ => SelectedCalendarIds.Any())
.DistinctUntilChanged()
: Observable.Return(true);
enabledObservable.Subscribe(doneEnabledSubject).DisposedBy(disposeBag);
}
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 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)));
}
protected SelectUserCalendarsViewModelBaseTest()
{
UserPreferences.EnabledCalendarIds().Returns(new List <string>());
}
public TheExecuteMethod()
{
calendarEvents = new List <CalendarItem>
{
new CalendarItem(
"id",
CalendarItemSource.Calendar,
new DateTimeOffset(2018, 08, 06, 10, 30, 00, TimeSpan.Zero),
TimeSpan.FromMinutes(30),
"Important meeting",
CalendarIconKind.Event,
color: "#0000ff",
calendarId: "1"),
new CalendarItem(
"id",
CalendarItemSource.Calendar,
new DateTimeOffset(2018, 08, 06, 10, 00, 00, TimeSpan.Zero),
TimeSpan.FromMinutes(90),
"F**** timesheets",
CalendarIconKind.Event,
color: "#0000ff",
calendarId: "1"),
new CalendarItem(
"id",
CalendarItemSource.Calendar,
new DateTimeOffset(2018, 08, 06, 09, 00, 00, TimeSpan.Zero),
TimeSpan.FromMinutes(15),
"Not so important meeting",
CalendarIconKind.Event,
color: "#0000ff",
calendarId: "2")
};
timeEntries = new List <IThreadSafeTimeEntry>
{
new MockTimeEntry()
{
Id = 1,
Description = "Something in project A",
Start = new DateTimeOffset(2018, 08, 06, 13, 00, 00, TimeSpan.Zero),
Duration = 45
},
new MockTimeEntry()
{
Id = 2,
Description = "Something in project B",
Start = new DateTimeOffset(2018, 08, 06, 11, 45, 00, TimeSpan.Zero),
Duration = 15
},
new MockTimeEntry()
{
Id = 3,
Description = "Something without project",
Start = new DateTimeOffset(2018, 08, 06, 09, 45, 00, TimeSpan.Zero),
Duration = 10
},
new MockTimeEntry()
{
Id = 4,
Description = "My deleted time entry",
Start = new DateTimeOffset(2018, 08, 06, 15, 45, 00, TimeSpan.Zero),
Duration = 10,
IsDeleted = true
}
};
calendarItemsFromTimeEntries = timeEntries
.Where(te => te.IsDeleted == false)
.Select(CalendarItem.From)
.ToList();
date = new DateTime(2018, 08, 06);
CalendarService
.GetEventsForDate(Arg.Is(date))
.Returns(Observable.Return(calendarEvents));
DataSource
.TimeEntries
.GetAll(Arg.Any <Func <IDatabaseTimeEntry, bool> >())
.Returns(callInfo =>
{
var filterFunc = callInfo.Arg <Func <IDatabaseTimeEntry, bool> >();
var filteredTimeEntries = timeEntries.Where(filterFunc).Cast <IThreadSafeTimeEntry>().ToList();
return(Observable.Return(filteredTimeEntries));
});
UserPreferences.EnabledCalendarIds().Returns(new[] { "1", "2" }.ToList());
interactor = new GetCalendarItemsForDateInteractor(DataSource.TimeEntries, CalendarService, UserPreferences, date);
}
