public void Ctor()
{
var vm = new CalendarDetailsViewModel();
Assert.IsFalse(vm.CanScrollHorizontal);
Assert.IsTrue(vm.CanScrollVertical);
Assert.AreEqual(LanguageService.Translate("Cmd_CreateCalendar"), vm.ToolbarItemList.First().Caption);
Assert.AreEqual(LanguageService.Translate("Cmd_RemoveCalendar"), vm.ToolbarItemList.Last().Caption);
Assert.AreEqual(LanguageService.Translate("Cmd_Save"), vm.WindowCommandItemList.First().Caption);
Assert.AreEqual(LanguageService.Translate("Cmd_Cancel"), vm.WindowCommandItemList.Last().Caption);
var daysOfWeek = new ObservableCollection<DayOfWeek>(new[]
{
DayOfWeek.Sunday,
DayOfWeek.Monday,
DayOfWeek.Tuesday,
DayOfWeek.Wednesday,
DayOfWeek.Thursday,
DayOfWeek.Friday,
DayOfWeek.Saturday
});
CollectionAssert.AreEqual(daysOfWeek, vm.DaysOfWeek);
var workingIntervals = new CollectionViewSource();
workingIntervals.SortDescriptions.Add(new SortDescription("StartDate", ListSortDirection.Ascending));
workingIntervals.SortDescriptions.Add(new SortDescription("FinishDate", ListSortDirection.Ascending));
CollectionAssert.AreEqual(workingIntervals.SortDescriptions, vm.WorkingIntervals.SortDescriptions);
}
public async Task <ActionResult> Details(string d)
{
var model = new CalendarDetailsViewModel();
var date = DateTime.Parse(d, CultureInfo.InvariantCulture);
var events = await GraphHelper.GetEventsByDay(date);
model.Events = events.Select(_ =>
{
var m = new EventViewModel();
m.Subject = _.Subject;
m.Organizer = _.Organizer.EmailAddress.Name;
m.Attendees = _.Attendees;
m.Start = DateTime.Parse(_.Start.DateTime).ToShortTimeString();
m.End = DateTime.Parse(_.End.DateTime).ToShortTimeString();
return(m);
});
return(View(model));
}
public void OnRefreshed()
{
// arrange
var vm = new CalendarDetailsViewModel();
var unitOfWork = Mock.Create<IUnitOfWork<ICalendar>>(Behavior.Loose);
var calendar = Mock.Create<ICalendar>(Behavior.Loose);
var interval = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
interval.Weekday = DayOfWeek.Friday.ToString();
var intervalList = new List<ICalendarWorkingInterval> { interval };
Mock.Arrange(() => calendar.WorkingIntervals).Returns(intervalList);
Mock.Arrange(() => unitOfWork.Model).Returns(calendar);
var dataportalResult = new DataPortalResult<IUnitOfWork<ICalendar>>(unitOfWork, null, null);
var shell = Mock.Create<IShell>(Behavior.CallOriginal);
var baseMethodWasCalled = false;
Mock.Arrange(() => shell.ShowStatus(Arg.IsAny<Status>(), false)).DoInstead(() => baseMethodWasCalled = true);
vm.WindowManager = new Lazy<IShell>(() => shell);
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.AreEqual(DayOfWeek.Friday, vm.SelectedDayOfWeek);
CollectionAssert.AreEqual(intervalList, (List<ICalendarWorkingInterval>)vm.WorkingIntervals.Source);
Assert.IsTrue(baseMethodWasCalled);
// arrange
baseMethodWasCalled = false;
Mock.Arrange(() => calendar.IsNew).Returns(true);
((IList<ICalendarWorkingInterval>)vm.WorkingIntervals.Source).Clear();
// act
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.AreEqual(DayOfWeek.Sunday, vm.SelectedDayOfWeek);
CollectionAssert.AreEqual(intervalList, (List<ICalendarWorkingInterval>)vm.WorkingIntervals.Source);
Assert.IsTrue(baseMethodWasCalled);
// arrange
baseMethodWasCalled = false;
dataportalResult = new DataPortalResult<IUnitOfWork<ICalendar>>(null, new Exception(), null);
var loggerWasCalled = false;
var logger = new ClientLogger();
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(CalendarDetailsViewModel).ToString(), Arg.IsAny<Exception>())).DoInstead(() => loggerWasCalled = true);
vm.Logger = logger;
var popupMock = PopupMock.Create().NotifyFailureMustBeCalled(Arg.IsAny<Exception>());
vm.ThePopupFactory = popupMock.TheLazyPopupFactory;
// act
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.IsTrue(loggerWasCalled);
popupMock.AssertNotifyFailureCalled();
Assert.IsTrue(baseMethodWasCalled);
}
public void LoadEditableRoot()
{
// arrange
var vm = new CalendarDetailsViewModel();
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
Mock.Arrange(() => dynamicTypeManager.BeginGetRetriever(Constants.CalendarProcessName, 1, Arg.IsAny<Action<object, IDataPortalResult>>(), false, false, default(Guid?), null)).MustBeCalled();
vm.TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dynamicTypeManager);
// act
vm.LoadEditableRoot(1);
// assert
Mock.Assert(dynamicTypeManager);
}
public void AddNewCalendar_CheckCurrentIfSaved_Accept()
{
// arrange
var vm = new CalendarDetailsViewModel();
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
var popupFactory = Mock.Create<PopupFactory>(Behavior.Loose);
Mock.Arrange(() => vm.IsSaveable).Returns(true);
var called = false;
var confirmMessageShown = false;
Mock.Arrange(() => popupFactory.Confirm(Arg.AnyString, Arg.IsAny<Action>())).DoInstead<string, Action>((s, a) => { confirmMessageShown = true; a(); });
Mock.Arrange(() => dynamicTypeManager.BeginNewRetriever(Constants.CalendarProcessName, Arg.IsAny<Action<object, IDataPortalResult>>())).DoInstead(() => called = true);
vm.TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dynamicTypeManager);
vm.ThePopupFactory = new Lazy<PopupFactory>(() => popupFactory);
// act
vm.NewEditableRoot();
// assert
Assert.IsTrue(called);
Assert.IsTrue(confirmMessageShown);
}
public void AddNewCalendar()
{
// arrange
var vm = new CalendarDetailsViewModel();
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
var called = false;
Mock.Arrange(() => dynamicTypeManager.BeginNewRetriever(Constants.CalendarProcessName, Arg.IsAny<Action<object, IDataPortalResult>>())).DoInstead(() => called = true);
vm.TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dynamicTypeManager);
// act
vm.NewEditableRoot();
// assert
Assert.IsTrue(called);
}
public void OnFilterEventHandler()
{
// arrange
var vm = new CalendarDetailsViewModel();
var interval = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
Mock.Arrange(() => interval.Weekday).Returns(DayOfWeek.Monday.ToString());
Mock.Arrange(() => vm.SelectedDayOfWeek).Returns(DayOfWeek.Monday);
var e = Mock.Create<FilterEventArgs>(Behavior.Loose);
Mock.Arrange(() => e.Item).Returns(interval);
// act
new PrivateAccessor(vm).CallMethod("OnFilterEventHandler", new object[] { null, e });
// assert
Assert.IsTrue(e.Accepted);
}
public void WorkingIntervals()
{
// arrange
var vm = new CalendarDetailsViewModel();
var workingIntervals = new CollectionViewSource { Source = new List<object>() };
var raises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", ArgExpr.IsAny<Expression<Func<CollectionViewSource>>>()).DoInstead(() => raises = true);
// act
vm.WorkingIntervals = workingIntervals;
// assert
Assert.AreEqual(workingIntervals, vm.WorkingIntervals);
Assert.IsTrue(raises);
}
public void DeleteWorkingIntervalCommand()
{
// arrange
var vm = new CalendarDetailsViewModel();
var interval = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
var model = Mock.Create<ICalendar>(Behavior.Loose);
Mock.Arrange(() => model.WorkingIntervals).Returns(new List<ICalendarWorkingInterval> { interval });
Mock.Arrange(() => vm.Model).Returns(model);
// act
vm.DeleteWorkingIntervalCommand.Execute(interval);
// assert
Assert.AreEqual(0, model.WorkingIntervals.Count());
}
public void AddWorkingExceptionCommand()
{
// arrange
var vm = new CalendarDetailsViewModel();
var exception = Mock.Create<ICalendarWorkingException>(Behavior.Loose);
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
Mock.Arrange(() => dynamicTypeManager.GetNewEditableChild<ICalendarWorkingException>(Constants.CalendarWorkingExceptionProcessName)).Returns(exception);
vm.TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dynamicTypeManager);
var model = Mock.Create<ICalendar>(Behavior.Loose);
Mock.Arrange(() => model.WorkingExceptions).Returns(new List<ICalendarWorkingException>());
Mock.Arrange(() => vm.WorkingExceptionsIsEnabled).Returns(true);
Mock.Arrange(() => vm.Model).Returns(model);
// act
vm.AddExceptionCommand.Execute(null);
// assert
Assert.AreEqual(exception, model.WorkingExceptions.First());
Assert.AreEqual(DateTime.Today, model.WorkingExceptions.First().StartDate);
Assert.AreEqual(DateTime.Today, model.WorkingExceptions.First().FinishDate);
}
public void AddIntervalCommand()
{
// arrange
var vm = new CalendarDetailsViewModel();
var interval = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
Mock.Arrange(() => dynamicTypeManager.GetNewEditableChild<ICalendarWorkingInterval>((Constants.CalendarWorkingIntervalProcessName))).Returns(interval);
vm.TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dynamicTypeManager);
var model = Mock.Create<ICalendar>(Behavior.Loose);
Mock.Arrange(() => vm.SelectedDayOfWeek).Returns(DayOfWeek.Friday);
var calendarWorkingIntervalItem1 = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
calendarWorkingIntervalItem1.Weekday = DayOfWeek.Friday.ToString();
calendarWorkingIntervalItem1.FinishDate = new DateTime(1970, 1, 1, 10, 0, 0);
var calendarWorkingIntervalItem2 = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
calendarWorkingIntervalItem2.Weekday = DayOfWeek.Friday.ToString();
calendarWorkingIntervalItem2.FinishDate = new DateTime(1970, 1, 1, 11, 0, 0);
var calendarWorkingIntervalList = new List<ICalendarWorkingInterval>
{
calendarWorkingIntervalItem1, calendarWorkingIntervalItem2
};
Mock.Arrange(() => model.WorkingIntervals).Returns(calendarWorkingIntervalList);
Mock.Arrange(() => vm.Model).Returns(model);
Mock.Arrange(() => vm.WorkingIntervalsIsEnabled).Returns(true);
// act
vm.AddIntervalCommand.Execute(null);
// assert
Assert.AreEqual(3, model.WorkingIntervals.Count());
Assert.AreEqual(DayOfWeek.Friday.ToString(), model.WorkingIntervals.Last().Weekday);
Assert.AreEqual(new DateTime(1970, 1, 1, 11, 0, 0), model.WorkingIntervals.Last().FinishDate);
Assert.AreEqual(new DateTime(1970, 1, 1, 11, 0, 0), model.WorkingIntervals.Last().StartDate);
// arrange
((IList)model.WorkingIntervals).Clear();
// act
vm.AddIntervalCommand.Execute(null);
// assert
Assert.AreEqual(new DateTime(1970, 1, 1, 8, 0, 0), model.WorkingIntervals.First().FinishDate);
Assert.AreEqual(new DateTime(1970, 1, 1, 8, 0, 0), model.WorkingIntervals.First().StartDate);
}
public void AddNewCalendarCommand()
{
// arrange
var vm = new CalendarDetailsViewModel();
var called = false;
Mock.Arrange(() => vm.NewEditableRoot()).DoInstead(() => called = true);
Mock.Arrange(() => vm.CanAddItem).Returns(true);
// act
vm.AddNewCalendarCommand.Execute(null);
// assert
Assert.IsTrue(called);
}
public void IconUrl()
{
// arrange
var vm = new CalendarDetailsViewModel();
// act
var result = vm.IconURL;
// assert
Assert.AreEqual(ImageHelper.GetIconPath("calendar.png"), result);
}
public void GetTitle()
{
// arrange
var vm = new CalendarDetailsViewModel();
// act
var privateAccessor = new PrivateAccessor(vm);
var result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Loading...", result);
// arrange
var calendar = Mock.Create<ICalendar>(Behavior.CallOriginal);
Mock.Arrange(() => calendar.ProcessDisplayName).Returns("Calendar");
Mock.Arrange(() => calendar.IsNew).Returns(true);
Mock.Arrange(() => vm.Model).Returns(calendar);
// act
result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Details: Calendar (new)", result);
// arrange
Mock.Arrange(() => calendar.Id).Returns(1);
Mock.Arrange(() => calendar.IsNew).Returns(false);
// act
result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Details: Calendar (1)", result);
}
public void OnSaved()
{
// arrange
var vm = new CalendarDetailsViewModel();
var model = Mock.Create<ICalendar>(Behavior.CallOriginal);
var calendarWorkingInterval = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
Mock.Arrange(() => model.WorkingIntervals).Returns(new List<ICalendarWorkingInterval> { calendarWorkingInterval });
Mock.Arrange(() => vm.Model).Returns(model);
var shell = Mock.Create<IShell>(Behavior.CallOriginal);
Mock.Arrange(() => shell.ShowStatus(Arg.IsAny<Status>(), false)).MustBeCalled();
vm.WindowManager = new Lazy<IShell>(() => shell);
Mock.NonPublic.Arrange(vm, "RefreshTitle").MustBeCalled();
var popupFactory = Mock.Create<PopupFactory>();
Mock.Arrange(() => popupFactory.NotifySuccess("Successfully saved.", "Popup_Success")).MustBeCalled();
vm.ThePopupFactory = new Lazy<PopupFactory>(() => popupFactory);
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("OnSaved", new object[] { false });
// assert
Assert.AreEqual(1, ((IList)vm.WorkingIntervals.Source).Count); // important assert
Mock.Assert(shell);
Mock.Assert(vm);
Mock.Assert(popupFactory);
// arrange
Mock.Arrange(() => popupFactory.NotifySuccess("Calendar was removed", "Popup_Success")).MustBeCalled();
// act
privateAccessor.CallMethod("OnSaved", new object[] { true });
// assert
Mock.Assert(popupFactory);
// arrange
Mock.Reset();
Mock.Arrange(() => shell.ShowStatus(Arg.IsAny<Status>(), false)).MustBeCalled();
Mock.Arrange(() => vm.Error).Returns(new Exception());
// act
privateAccessor.CallMethod("OnSaved", new object[] { false });
// assert
Mock.Assert(shell);
Mock.NonPublic.Assert(vm, "RefreshTitle", Occurs.Never());
Mock.Assert(() => popupFactory.NotifySuccess(Arg.AnyString, Arg.AnyString), Occurs.Never());
}
public void IsSaveable()
{
// arrange
var vm = new CalendarDetailsViewModel();
Mock.Arrange(() => vm.HasBrokenRules).Returns(true);
// act
var result = vm.IsSaveable;
// assert
Assert.IsTrue(result);
// arrange
Mock.Arrange(() => vm.HasBrokenRules).Returns(false);
Mock.Arrange(() => vm.CanSave).Returns(true);
// act
result = vm.IsSaveable;
// assert
Assert.IsTrue(result);
}
public void SelectedDayOfWeek()
{
// arrange
var vm = new CalendarDetailsViewModel();
var refreshWasCalled = false;
Mock.Arrange(() => vm.WorkingIntervals.View.Refresh()).DoInstead(() => refreshWasCalled = true);
var moveCurrentToFirstCalled = false;
Mock.Arrange(() => vm.WorkingIntervals.View.MoveCurrentToFirst()).DoInstead(() => moveCurrentToFirstCalled = true);
var selectedDayOfWeekRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", ArgExpr.IsAny<Expression<Func<DayOfWeek>>>()).DoInstead(() => selectedDayOfWeekRaises = true);
// act
vm.SelectedDayOfWeek = DayOfWeek.Monday;
// assert
Assert.AreEqual(DayOfWeek.Monday, vm.SelectedDayOfWeek);
Assert.IsTrue(refreshWasCalled);
Assert.IsTrue(moveCurrentToFirstCalled);
Assert.IsTrue(selectedDayOfWeekRaises);
}
public void DeleteWorkingExceptionCommand()
{
// arrange
var vm = new CalendarDetailsViewModel();
var exception = Mock.Create<ICalendarWorkingException>(Behavior.Loose);
var model = Mock.Create<ICalendar>(Behavior.Loose);
Mock.Arrange(() => model.WorkingExceptions).Returns(new List<ICalendarWorkingException> { exception });
Mock.Arrange(() => vm.Model).Returns(model);
// act
vm.DeleteWorkingExceptionCommand.Execute(exception);
// assert
Assert.AreEqual(0, model.WorkingExceptions.Count());
}
