public void YearlyPatternMonthsName()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
var list = new List<string>
{
Month.January.ToString(),
Month.February.ToString(),
Month.March.ToString(),
Month.April.ToString(),
Month.May.ToString(),
Month.June.ToString(),
Month.July.ToString(),
Month.August.ToString(),
Month.September.ToString(),
Month.October.ToString(),
Month.November.ToString(),
Month.December.ToString()
};
// act
var yearlyPatternMonthsNameList = vm.YearlyPatternMonthsName;
// assert
CollectionAssert.AreEqual(list, (ICollection) yearlyPatternMonthsNameList);
}
public void Ctor()
{
var vm = new FrequencyPatternDetailsViewModel();
Assert.IsFalse(vm.CanScrollHorizontal);
Assert.IsTrue(vm.CanScrollVertical);
Assert.AreEqual(LanguageService.Translate("Cmd_CreateFrequency"), vm.ToolbarItemList.First().Caption);
Assert.AreEqual(LanguageService.Translate("Cmd_RemoveFrequency"), vm.ToolbarItemList.Last().Caption);
Assert.AreEqual(LanguageService.Translate("Cmd_Save"), vm.WindowCommandItemList.First().Caption);
Assert.AreEqual(LanguageService.Translate("Cmd_Cancel"), vm.WindowCommandItemList.Last().Caption);
}
public void DaysOfWeek()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
var list = new List<string>
{
DayofWeek.Sunday.ToString(),
DayofWeek.Monday.ToString(),
DayofWeek.Tuesday.ToString(),
DayofWeek.Wednesday.ToString(),
DayofWeek.Thursday.ToString(),
DayofWeek.Friday.ToString(),
DayofWeek.Saturday.ToString()
};
// act
var daysOfWeekList = vm.DaysOfWeek;
// assert
CollectionAssert.AreEqual(list, (ICollection)daysOfWeekList);
}
public void IsSaveable()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
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 OnRefreshed()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
var unitOfWork = Mock.Create<IUnitOfWork<IFrequencyPattern>>(Behavior.Loose);
var model = Mock.Create<IFrequencyPattern>(Behavior.Loose);
Mock.Arrange(() => model.IsNew).Returns(true);
Mock.Arrange(() => unitOfWork.Model).Returns(model);
var dataportalResult = new DataPortalResult<IUnitOfWork<IFrequencyPattern>>(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(model, vm.Model);
Assert.AreEqual(FrequencyPatternType.Daily.ToString(), model.PatternType);
// daily
Assert.AreEqual(DailyPatternVariant.NumberOfDays.ToString(), model.DailyPatternOption);
Assert.AreEqual(1, model.DailyPatternDaysToRecur);
// weekly
Assert.AreEqual(1, model.WeeklyPatternWeeksToRecur);
Assert.AreEqual(false, model.IsSundaySelected);
Assert.AreEqual(false, model.IsMondaySelected);
Assert.AreEqual(false, model.IsTuesdaySelected);
Assert.AreEqual(false, model.IsWednesdaySelected);
Assert.AreEqual(false, model.IsThursdaySelected);
Assert.AreEqual(false, model.IsFridaySelected);
Assert.AreEqual(false, model.IsSaturdaySelected);
// monthly
Assert.AreEqual(MonthlyPatternVariant.DayByDate.ToString(), model.MonPatOption);
Assert.AreEqual(1, model.MonPatRecurDate);
Assert.AreEqual(1, model.MonPatByDateOptionMonthsToRec);
Assert.AreEqual(TimeIntervalPosition.First.ToString(), model.MonPatTimeIntervalPosition);
Assert.AreEqual(1, model.MonPatByPositionOptionMonToRec);
Assert.AreEqual(1, model.MonPatMonthsToRec);
Assert.AreEqual(DayofWeek.Saturday.ToString(), model.MonPatDayOfWeek);
// yearly
Assert.AreEqual(1, model.YearPatYearsToRec);
Assert.AreEqual(YearlyPatternVariant.DayByDate.ToString(), model.YearPatOption);
Assert.AreEqual(Month.January.ToString(), model.YearPatByDateOptionSelectMon);
Assert.AreEqual(1, model.YearPatDayOfSelectMon);
Assert.AreEqual(TimeIntervalPosition.First.ToString(), model.YearPatTimeIntervalPosition);
Assert.AreEqual(DayofWeek.Saturday.ToString(), model.YearPatDayOfWeek);
Assert.AreEqual(Month.January.ToString(), model.YearPatByNameOptionSelectMon);
Assert.IsTrue(baseMethodWasCalled);
// arrange
baseMethodWasCalled = false;
dataportalResult = new DataPortalResult<IUnitOfWork<IFrequencyPattern>>(null, new Exception(), null);
var loggerWasCalled = false;
var logger = new ClientLogger();
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FrequencyPatternDetailsViewModel).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 Refresh()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
var called = false;
Mock.Arrange(() => dynamicTypeManager.BeginGetRetriever(Constants.FrequencyPatternProcessName, 1, Arg.IsAny<Action<object, IDataPortalResult>>(), false, false, default(Guid?), null)).DoInstead(() => called = true);
vm.TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dynamicTypeManager);
// act
vm.LoadEditableRoot(1);
// assert
Assert.IsTrue(called);
}
public void AddNewFrequencyPattern_CheckCurrentIfSaved_Accept()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
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.FrequencyPatternProcessName, 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 IconUrl()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
// act
var result = vm.IconURL;
// assert
Assert.AreEqual(ImageHelper.GetIconPath("frequency.png"), result);
}
public void GetTitle()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
// act
var privateAccessor = new PrivateAccessor(vm);
var result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Loading...", result);
// arrange
var fp = Mock.Create<IFrequencyPattern>(Behavior.CallOriginal);
Mock.Arrange(() => fp.ProcessDisplayName).Returns("Frequency Pattern");
Mock.Arrange(() => fp.IsNew).Returns(true);
Mock.Arrange(() => vm.Model).Returns(fp);
// act
result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Details: Frequency Pattern (new)", result);
// arrange
Mock.Arrange(() => fp.Id).Returns(1);
Mock.Arrange(() => fp.IsNew).Returns(false);
// act
result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Details: Frequency Pattern (1)", result);
}
public void OnSaved()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
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);
var eventAggregator = Mock.Create<IEventAggregator>();
Mock.Arrange(() => eventAggregator.Publish(Arg.IsAny<FrequencyPatternSaveEvent>())).MustBeCalled();
vm.EventAggregator = eventAggregator;
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("OnSaved", new object[] { false });
// assert
Mock.Assert(shell);
Mock.Assert(vm);
Mock.Assert(popupFactory);
Mock.Assert(eventAggregator);
// arrange
Mock.Arrange(() => popupFactory.NotifySuccess("Frequency Pattern 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 AddNewFrequencyPatternCommand()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
var called = false;
Mock.Arrange(() => vm.NewEditableRoot()).DoInstead(() => called = true);
Mock.Arrange(() => vm.CanAddItem).Returns(true);
// act
vm.AddNewFrequencyPatternCommand.Execute(null);
// assert
Assert.IsTrue(called);
}
