public void Maintenance_Reset_Test_Remove_Duplicate_Or_Not_Should_Pass()
{
var Maintenance = new CalendarMaintenance();
var calendarSet = DataSourceBackend.Instance.SchoolCalendarBackend.Index();
calendarSet.Clear();
var calendarModel1 = new SchoolCalendarModel();
calendarModel1.Date = new DateTime(2010, 6, 4);
var calendarModel2 = new SchoolCalendarModel();
calendarModel2.Date = new DateTime(2010, 6, 5);
var calendarModel3 = new SchoolCalendarModel();
calendarModel3.Date = new DateTime(2010, 6, 5);
calendarSet.Add(calendarModel1);
calendarSet.Add(calendarModel2);
calendarSet.Add(calendarModel3);
Assert.AreEqual(calendarSet.Count(), 3, TestContext.TestName);
var result = Maintenance.ResetCalendar();
// Assert
Assert.AreEqual(calendarSet.Count(), 2, TestContext.TestName);
// reset
DataSourceBackend.Instance.SchoolCalendarBackend.Reset();
}
public void Controller_Calendar_Update_Post_TimeEnd_Invalid_Should_Send_Back_For_Edit()
{
// Arrange
CalendarController controller = new CalendarController();
SchoolCalendarModel dataBelowMin = new SchoolCalendarModel
{
TimeEnd = TimeSpan.FromHours(0) // less than 1
};
SchoolCalendarModel dataAboveMax = new SchoolCalendarModel
{
TimeEnd = TimeSpan.FromHours(25) // greater than 24
};
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
ViewResult resultBelowMin = controller.Update(dataBelowMin) as ViewResult;
ViewResult resultAboveMax = controller.Update(dataAboveMax) as ViewResult;
// Assert
Assert.IsFalse(controller.ModelState.IsValid);
Assert.IsNotNull(resultBelowMin, TestContext.TestName);
Assert.IsNotNull(resultAboveMax, TestContext.TestName);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public SchoolCalendarModel Update(SchoolCalendarModel data)
{
if (data == null)
{
return(null);
}
// Set date as modified
data.Modified = true;
// See if the updates make it match default, if so, need to clear the modified flag...
var myDefault = new SchoolCalendarModel(data.Date);
myDefault = SchoolCalendarBackendHelper.SetDefault(myDefault);
if (myDefault.TimeEnd == data.TimeEnd && myDefault.TimeStart == data.TimeStart)
{
// It is back to defaults, so turn off the modified flag.
data.Modified = false;
}
if (myDefault.SchoolDay != data.SchoolDay)
{
data.Modified = true;
}
var myReturn = DataSource.Update(data);
return(myReturn);
}
public void Controller_Calendar_Update_Post_Id_Is_Null_Or_Empty_Should_Return_Error_Page()
{
// Arrange
CalendarController controller = new CalendarController();
SchoolCalendarModel dataNull = new SchoolCalendarModel();
SchoolCalendarModel dataEmpty = new SchoolCalendarModel();
// Make data.Id = null
dataNull.Id = null;
// Make data.Id empty
dataEmpty.Id = "";
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
var resultNull = (RedirectToRouteResult)controller.Update(dataNull);
var resultEmpty = (RedirectToRouteResult)controller.Update(dataEmpty);
// Assert
Assert.AreEqual("Error", resultNull.RouteValues["action"], TestContext.TestName);
Assert.AreEqual("Error", resultEmpty.RouteValues["action"], TestContext.TestName);
}
/// <summary>
/// Walks each existing date in the calendar, and resets the dates based on the defaults.
/// </summary>
public void ResetDefaults()
{
var startDate = DataSourceBackend.Instance.SchoolDismissalSettingsBackend.GetDefault().DayFirst; //school year start date
var endDate = DataSourceBackend.Instance.SchoolDismissalSettingsBackend.GetDefault().DayLast; //school year end date
var today = UTCConversionsBackend.UtcToKioskTime(DateTimeHelper.Instance.GetDateTimeNowUTC()).Date;
var currentDate = startDate; //loop variable
while (currentDate.CompareTo(endDate) <= 0)
{
var currentCalendarModel = ReadDate(currentDate);
//if the calendar model for that date does not exit yet, create a new one
if (currentCalendarModel == null)
{
currentCalendarModel = new SchoolCalendarModel(currentDate);
currentCalendarModel = SchoolCalendarBackendHelper.SetDefault(currentCalendarModel); //use current default settings
Create(currentCalendarModel);
}
//if the calendar model for that date is not modified, and is after today, reset to default
if (!currentCalendarModel.Modified && currentDate.CompareTo(today) > 0)
{
currentCalendarModel = SchoolCalendarBackendHelper.SetDefault(currentCalendarModel); //use current default settings
Update(currentCalendarModel);
}
currentDate = currentDate.AddDays(1);
}
}
public ActionResult Update([Bind(Include =
"Id," +
"TimeStart," +
"TimeEnd," +
"")] SchoolCalendarModel data)
{
if (!ModelState.IsValid)
{
// Send back for edit
return(View(data));
}
if (data == null)
{
// Send to error page
return(RedirectToAction("Error", new { route = "Home", action = "Error" }));
}
if (string.IsNullOrEmpty(data.Id))
{
// Send back for Edit
return(RedirectToAction("Error", new { route = "Home", action = "Error" }));
}
// Validate Date and Times
if (data.TimeStart.TotalHours < 1 || data.TimeStart.TotalHours > 24)
{
// Must be between 0 and 24
ModelState.AddModelError("TimeStart", "Enter Valid Start Time");
return(View(data));
}
// Validate Date and Times
if (data.TimeEnd.TotalHours < 1 || data.TimeEnd.TotalHours > 24)
{
// Must be between 0 and 24
ModelState.AddModelError("TimeEnd", "Enter Valid End Time");
return(View(data));
}
// Validate Date and Times
if (data.TimeEnd.Subtract(data.TimeStart).Ticks < 1)
{
// End is before Start
ModelState.AddModelError("TimeStart", "Start Time must be before End Time");
return(View(data));
}
// Load the actual record, and only update TimeStart and Time End
var myData = Backend.DataSourceBackend.Instance.SchoolCalendarBackend.Read(data.Id);
myData.TimeStart = data.TimeStart;
myData.TimeEnd = data.TimeEnd;
myData.SchoolDay = data.SchoolDay;
Backend.DataSourceBackend.Instance.SchoolCalendarBackend.Update(myData);
return(RedirectToAction("Index"));
}
public void Models_SchoolCalendarModel_Default_Instantiate_Should_Pass()
{
// Act
var result = new SchoolCalendarModel();
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
/// <summary>
/// Makes a new SchoolCalendar
/// </summary>
/// <param name="data"></param>
/// <returns>SchoolCalendar Passed In</returns>
public SchoolCalendarModel Create(SchoolCalendarModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
SchoolCalendarList.Add(data);
//sort by date
SchoolCalendarList = SchoolCalendarList.OrderBy(x => x.Date).ToList();
return(data);
}
public void Models_SchoolCalendarModel_Default_Instantiate_With_Invalid_Data_Should_Fail()
{
// Act
var result = new SchoolCalendarModel(null);
string expect = null;
// Assert
Assert.AreEqual(expect, result.Id, TestContext.TestName);
}
/// <summary>
/// Set start and end time for the given calendar model, then calculate duration
/// </summary>
/// <param name="calendar"></param>
public static SchoolCalendarModel SetSchoolTime(SchoolCalendarModel calendar)
{
if (calendar == null)
{
return(null);
}
var startType = calendar.DayStart;
var endType = calendar.DayEnd;
//if not a school day
if (startType == SchoolCalendarDismissalEnum.Unknown || endType == SchoolCalendarDismissalEnum.Unknown)
{
calendar.SchoolDay = false;
calendar.TimeStart = SchoolDismissalSettingsBackend.Instance.GetDefault().StartNormal;
calendar.TimeEnd = SchoolDismissalSettingsBackend.Instance.GetDefault().EndNormal;
calendar.TimeDuration = TimeSpan.Zero;
return(calendar);
}
calendar.SchoolDay = true;
switch (calendar.DayStart)
{
case SchoolCalendarDismissalEnum.Early:
calendar.TimeStart = SchoolDismissalSettingsBackend.Instance.GetDefault().StartEarly;
break;
case SchoolCalendarDismissalEnum.Late:
calendar.TimeStart = SchoolDismissalSettingsBackend.Instance.GetDefault().StartLate;
break;
default:
calendar.TimeStart = SchoolDismissalSettingsBackend.Instance.GetDefault().StartNormal;
break;
}
switch (calendar.DayEnd)
{
case SchoolCalendarDismissalEnum.Early:
calendar.TimeEnd = SchoolDismissalSettingsBackend.Instance.GetDefault().EndEarly;
break;
case SchoolCalendarDismissalEnum.Late:
calendar.TimeEnd = SchoolDismissalSettingsBackend.Instance.GetDefault().EndLate;
break;
default:
calendar.TimeEnd = SchoolDismissalSettingsBackend.Instance.GetDefault().EndNormal;
break;
}
calendar.TimeDuration = calendar.TimeEnd.Subtract(calendar.TimeStart);
return(calendar);
}
/// <summary>
/// Set start and end type using default dismissal settings
/// </summary>
/// <param name="date"></param>
public static SchoolCalendarModel SetDefaultTypes(SchoolCalendarModel calendar)
{
if (calendar == null)
{
return(null);
}
var dismissalSettings = SchoolDismissalSettingsBackend.Instance.GetDefault();
var myDate = calendar.Date.DayOfWeek;
switch (myDate)
{
case DayOfWeek.Monday:
calendar.DayStart = dismissalSettings.MonStartType;
calendar.DayEnd = dismissalSettings.MonEndType;
break;
case DayOfWeek.Tuesday:
calendar.DayStart = dismissalSettings.TueStartType;
calendar.DayEnd = dismissalSettings.TueEndType;
break;
case DayOfWeek.Wednesday:
calendar.DayStart = dismissalSettings.WedStartType;
calendar.DayEnd = dismissalSettings.WedEndType;
break;
case DayOfWeek.Thursday:
calendar.DayStart = dismissalSettings.ThuStartType;
calendar.DayEnd = dismissalSettings.ThuEndType;
break;
case DayOfWeek.Friday:
calendar.DayStart = dismissalSettings.FriStartType;
calendar.DayEnd = dismissalSettings.FriEndType;
break;
case DayOfWeek.Saturday:
calendar.DayStart = dismissalSettings.SatStartType;
calendar.DayEnd = dismissalSettings.SatEndType;
break;
case DayOfWeek.Sunday:
calendar.DayStart = dismissalSettings.SunStartType;
calendar.DayEnd = dismissalSettings.SunEndType;
break;
}
return(calendar);
}
public void Models_SchoolCalendarModel_Default_Instantiate_With_Data_Should_Pass()
{
var test = new SchoolCalendarModel
{
Modified = true
};
// Act
var result = new SchoolCalendarModel(test);
var expect = test.Modified;
// Assert
Assert.AreEqual(expect, result.Modified, TestContext.TestName);
}
public void Backend_SchoolCalendarDataSourceMock_Update_Invalid_Data_Calendar_Not_Found_Should_Fail()
{
// Arrange
var backend = SchoolCalendarDataSourceMock.Instance;
var expectSchoolCalendarModel = new SchoolCalendarModel();
// Act
var result = backend.Update(expectSchoolCalendarModel);
//reset
backend.Reset();
// Assert
Assert.IsNull(result, TestContext.TestName);
}
public void Backend_SchoolCalendarBackendHelper_SetDefaultTypes_Valid_Data_Should_Pass()
{
// Arrange
var data = new SchoolCalendarModel();
var expect = false;
// Act
var result = SchoolCalendarBackendHelper.SetDefaultTypes(data);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(expect, result.Modified, TestContext.TestName);
}
/// <summary>
/// Set the given calendar model to default
/// </summary>
/// <param name="calendar"></param>
public static SchoolCalendarModel SetDefault(SchoolCalendarModel calendar)
{
if (calendar == null)
{
return(null);
}
// Clear modified flag on date
calendar.Modified = false;
calendar = SetDefaultTypes(calendar);
calendar = SetSchoolTime(calendar);
return(calendar);
}
public void Models_SchoolCalendarModel_Update_Invalid_Null_Should_Fail()
{
// Arrange
var expect = DateTime.Now;
var data = new SchoolCalendarModel
{
Date = expect
};
// Act
data.Update((SchoolCalendarModel)null);
// Assert
Assert.AreEqual(expect, data.Date, TestContext.TestName);
}
public void Backend_SchoolCalendarBackend_Create_Valid_Data_Should_Pass()
{
//arrange
var test = SchoolCalendarBackend.Instance;
var data = new SchoolCalendarModel();
//act
var result = test.Create(data);
//reset
test.Reset();
//assert
Assert.IsNotNull(result, TestContext.TestName);
Assert.AreEqual(data.Id, result.Id, TestContext.TestName);
}
/// <summary>
/// Makes a new SchoolCalendar
/// </summary>
/// <param name="data"></param>
/// <returns>SchoolCalendar Passed In</returns>
public SchoolCalendarModel Create(SchoolCalendarModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
// If using the defaul data source, use it, else just do the table operation
if (dataSourceEnum == DataSourceEnum.Unknown)
{
DataList.Add(data);
}
// Add to Storage
var myResult = DataSourceBackendTable.Instance.Create <SchoolCalendarModel>(tableName, partitionKey, data.Id, data, dataSourceEnum);
//sort by date
DataList = DataList.OrderBy(x => x.Date).ToList();
return(data);
}
public void Controller_Calendar_Update_Post_Default_Should_Pass()
{
// Arrange
CalendarController controller = new CalendarController();
SchoolCalendarModel scm = DataSourceBackend.Instance.SchoolCalendarBackend.GetDefault();
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
var result = controller.Update(scm) as RedirectToRouteResult;
// Assert
Assert.AreEqual("Index", result.RouteValues["action"], TestContext.TestName);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public SchoolCalendarModel Update(SchoolCalendarModel data)
{
if (data == null)
{
return(null);
}
var myReturn = SchoolCalendarList.Find(n => n.Id == data.Id);
if (myReturn == null)
{
return(null);
}
myReturn.Update(data);
return(myReturn);
}
public void Backend_SchoolCalendarBackend_Delete_Valid_Data_Should_Pass()
{
//arrange
var test = SchoolCalendarBackend.Instance;
var data = new SchoolCalendarModel();
var createResult = test.Create(data);
var expect = true;
//act
var deleteResult = test.Delete(data.Id);
//reset
test.Reset();
//assert
Assert.AreEqual(expect, deleteResult, TestContext.TestName);
}
public void Backend_SchoolCalendarBackendHelper_SetDefaultTypes_Null_Data_Should_Fail()
{
// Arrange
var data = new SchoolCalendarModel();
data = null;
var expect = data;
// Act
var result = SchoolCalendarBackendHelper.SetDefaultTypes(data);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(expect, result, TestContext.TestName);
}
public void Backend_SchoolCalendarBackendHelper_SetDefaultTypes_Valid_Sun_Should_Pass()
{
// Arrange
var date = DateTime.Parse("10/7/2018");
var data = new SchoolCalendarModel(date);
var dismissalSettings = SchoolDismissalSettingsBackend.Instance.GetDefault();
// Act
var result = SchoolCalendarBackendHelper.SetDefaultTypes(data);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(dismissalSettings.SunStartType, result.DayStart, TestContext.TestName);
Assert.AreEqual(dismissalSettings.SunEndType, result.DayEnd, TestContext.TestName);
}
public void Models_SchoolCalendarModel_SetGet_Should_Pass()
{
// Arrange
var TempId = "123";
var TempDate = DateTime.UtcNow;
var TempTimeDuration = TimeSpan.FromHours(6);
var TempTimeStart = TimeSpan.FromHours(8);
var TempTimeEnd = TimeSpan.FromHours(14);
var TempDayStart = _5051.Models.Enums.SchoolCalendarDismissalEnum.Early;
var TempDayEnd = _5051.Models.Enums.SchoolCalendarDismissalEnum.Early;
var TempModified = true;
var TempSchoolDay = true;
var TempHasAttendance = true;
// Act
var result = new SchoolCalendarModel(null)
{
Id = TempId,
Date = TempDate,
TimeDuration = TempTimeDuration,
TimeStart = TempTimeStart,
TimeEnd = TempTimeEnd,
DayStart = TempDayStart,
DayEnd = TempDayEnd,
Modified = TempModified,
SchoolDay = TempSchoolDay,
HasAttendance = TempHasAttendance
};
// Assert
Assert.AreEqual(TempId, result.Id, TestContext.TestName);
Assert.AreEqual(TempDate, result.Date, TestContext.TestName);
Assert.AreEqual(TempTimeDuration, result.TimeDuration, TestContext.TestName);
Assert.AreEqual(TempTimeStart, result.TimeStart, TestContext.TestName);
Assert.AreEqual(TempTimeEnd, result.TimeEnd, TestContext.TestName);
Assert.AreEqual(TempDayStart, result.DayStart, TestContext.TestName);
Assert.AreEqual(TempDayEnd, result.DayEnd, TestContext.TestName);
Assert.AreEqual(TempModified, result.Modified, TestContext.TestName);
Assert.AreEqual(TempSchoolDay, result.SchoolDay, TestContext.TestName);
Assert.AreEqual(TempHasAttendance, result.HasAttendance, TestContext.TestName);
}
public void Backend_SchoolCalendarBackend_Update_Valid_Reset_Modified_Should_Pass()
{
//arrange
var test = SchoolCalendarBackend.Instance;
var data = new SchoolCalendarModel();
var createResult = test.Create(data);
data.Date = DateTime.Parse("01/23/2018");
var myDefault = new SchoolCalendarModel(data.Date);
data.TimeDuration = TimeSpan.Parse("04:13");
data.TimeStart = myDefault.TimeStart;
data.TimeEnd = myDefault.TimeEnd;
data.DayStart = SchoolCalendarDismissalEnum.Late;
data.DayEnd = SchoolCalendarDismissalEnum.Early;
data.Modified = true;
data.SchoolDay = false;
var expect = data;
//act
var updateResult = test.Update(data);
var result = test.Read(data.Id);
//reset
test.Reset();
//assert
Assert.IsNotNull(result, "Updated " + TestContext.TestName);
Assert.AreEqual(expect.Date, result.Date, "Date " + TestContext.TestName);
Assert.AreEqual(expect.TimeDuration, result.TimeDuration, "TimeDuration " + TestContext.TestName);
Assert.AreEqual(expect.TimeStart, result.TimeStart, "TimeStart " + TestContext.TestName);
Assert.AreEqual(expect.TimeEnd, result.TimeEnd, "TimeEnd " + TestContext.TestName);
Assert.AreEqual(expect.DayStart, result.DayStart, "DayStart " + TestContext.TestName);
Assert.AreEqual(expect.DayEnd, result.DayEnd, "DayEnd " + TestContext.TestName);
Assert.AreEqual(expect.Modified, result.Modified, "Modified " + TestContext.TestName);
Assert.AreEqual(expect.SchoolDay, result.SchoolDay, "SchoolDay " + TestContext.TestName);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public SchoolCalendarModel Update(SchoolCalendarModel data)
{
if (data == null)
{
return(null);
}
var myReturn = SchoolCalendarList.Find(n => n.Id == data.Id);
if (myReturn == null)
{
return(null);
}
myReturn.Update(data);
//sort by date
SchoolCalendarList = SchoolCalendarList.OrderBy(x => x.Date).ToList();
return(myReturn);
}
/// <summary>
/// Get the Default data set, and then add it to the current
/// </summary>
private void CreateDataSetDefault()
{
var startDate = SchoolDismissalSettingsBackend.Instance.GetDefault().DayFirst; //school year start date
var endDate = SchoolDismissalSettingsBackend.Instance.GetDefault().DayLast; //school year end date
var currentDate = startDate; //loop variable
while (currentDate.CompareTo(endDate) <= 0)
{
var newCalendarModel = new SchoolCalendarModel(currentDate);
Create(newCalendarModel);
SchoolCalendarBackendHelper.SetDefault(newCalendarModel); //use default settings
Update(newCalendarModel);
currentDate = currentDate.AddDays(1);
}
//sort by date
DataList = DataList.OrderBy(x => x.Date).ToList();
}
public void Controller_Calendar_Update_Post_Model_Is_Invalid_Should_Send_Back_For_Edit()
{
// Arrange
CalendarController controller = new CalendarController();
SchoolCalendarModel data = new SchoolCalendarModel();
// Make ModelState Invalid
controller.ModelState.AddModelError("test", "test");
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
ViewResult result = controller.Update(data) as ViewResult;
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
public void Backend_SchoolCalendarBackendHelper_SetSchoolTime_DayStart_DayEnd_Late_Should_Return_Default()
{
// Arrange
var data = new SchoolCalendarModel
{
DayStart = SchoolCalendarDismissalEnum.Late,
DayEnd = SchoolCalendarDismissalEnum.Late
};
var expect = data;
// Act
var result = SchoolCalendarBackendHelper.SetSchoolTime(data);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(SchoolDismissalSettingsBackend.Instance.GetDefault().EndLate, result.TimeEnd, TestContext.TestName);
Assert.AreEqual(SchoolDismissalSettingsBackend.Instance.GetDefault().StartLate, result.TimeStart, TestContext.TestName);
}
public void Backend_SchoolCalendarBackendHelper_SetSchoolTime_End_Unknown_Should_Return_Default()
{
// Arrange
var data = new SchoolCalendarModel
{
DayStart = SchoolCalendarDismissalEnum.Early,
DayEnd = SchoolCalendarDismissalEnum.Unknown
};
var expect = data;
// Act
var result = SchoolCalendarBackendHelper.SetSchoolTime(data);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(false, result.SchoolDay, TestContext.TestName);
Assert.AreEqual(SchoolDismissalSettingsBackend.Instance.GetDefault().StartNormal, result.TimeStart, TestContext.TestName);
Assert.AreEqual(SchoolDismissalSettingsBackend.Instance.GetDefault().EndNormal, result.TimeEnd, TestContext.TestName);
Assert.AreEqual(TimeSpan.Zero, result.TimeDuration, TestContext.TestName);
}
