public void GivenValidStudentAssignedOffering_WhenCopyFrom_ThenViewModelHasModelData()
{
StudentServiceOfferingScheduleModel target = new StudentServiceOfferingScheduleModel();
StudentAssignedOffering offering = new StudentAssignedOffering
{
Id = 1,
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(1),
Notes = "blah",
ServiceOffering = new ServiceOffering
{
Provider = new Provider(),
ServiceType = new ServiceType(),
Program = new Program()
},
CreatingUser = new User()
};
target.CopyFrom(offering);
Assert.AreEqual(target.Id, offering.Id);
Assert.AreEqual(target.StartDate, offering.StartDate);
Assert.AreEqual(target.EndDate, offering.EndDate);
Assert.AreEqual(target.Notes, offering.Notes);
}
public void GivenModelNotModified_AndViewModelAuditDataAlreadySet_WhenCopyFrom_ThenModelStatelastModifyValuesNull()
{
StudentAssignedOffering expectedState = new StudentAssignedOffering
{
ServiceOffering = new ServiceOffering
{
Provider = new Provider {
Name = "provider name"
},
ServiceType = new ServiceType {
Name = "service type name"
},
Program = new Program {
Name = "program name"
}
},
CreateTime = new DateTime(2005, 4, 30),
CreatingUser = new User {
DisplayName = "fredBob"
}
};
StudentServiceOfferingScheduleModel target = new StudentServiceOfferingScheduleModel();
target.Audit = new AuditModel {
LastModifiedBy = "bob", LastModifyTime = DateTime.Now
};
target.CopyFrom(expectedState);
Assert.IsNull(target.Audit.LastModifiedBy);
Assert.IsFalse(target.Audit.LastModifyTime.HasValue);
}
private static void AssertModelState(StudentAssignedOffering expectedState, int expectedStudentId, StudentServiceOfferingScheduleModel actual)
{
Assert.AreEqual(expectedState.Id, actual.Id);
Assert.AreEqual(expectedState.EndDate, actual.EndDate);
Assert.AreEqual(expectedState.Notes, actual.Notes);
Assert.AreEqual(expectedState.StartDate, actual.StartDate);
}
public void Create(EducationSecurityPrincipal user, ServiceOfferingScheduleModel viewModel)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (viewModel == null)
{
throw new ArgumentNullException("viewModel");
}
if (!ServiceOfferingRepository.Items.Any(s => s.Id == viewModel.ServiceOfferingId && s.IsActive))
{
throw new EntityNotFoundException("Selected Service Offering was not found.");
}
ServiceOffering offering = ServiceOfferingRepository.Items.Single(s => s.Id == viewModel.ServiceOfferingId && s.IsActive);
IEnumerable <Student> students = StudentRepository.Items.Include(s => s.School).Where(s => viewModel.SelectedStudents.Contains(s.Id));
IPermission permission = PermissionFactory.Current.Create("ScheduleOffering", students, offering);
permission.GrantAccess(user);
User userEntity = user.Identity.User;
List <int> studentIds = viewModel.SelectedStudents.ToList();
foreach (int studentId in studentIds)
{
var studentAssignedOffering = new StudentAssignedOffering
{
StudentId = studentId,
CreatingUserId = userEntity.Id,
IsActive = true
};
viewModel.CopyTo(studentAssignedOffering);
StudentAssignedOfferingRepository.Add(studentAssignedOffering);
}
RepositoryContainer.Save();
}
public ManageServiceAttendancePermission(StudentAssignedOffering studentAssignedOffering)
{
if (studentAssignedOffering == null)
{
throw new ArgumentNullException("assignedOffering");
}
StudentAssignedOffering = studentAssignedOffering;
}
public void GivenAnAssignedOffering_WhenRemove_ThenThrowNotSupportedException()
{
var item = new StudentAssignedOffering {
Id = 1
};
Target.ExpectException <NotSupportedException>(() => Target.Remove(item));
}
public void Remove(StudentAssignedOffering item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
throw new NotSupportedException(string.Format("{0} entities cannot be removed. Only \"soft\" deletes are supported via IsActive.", item.GetType().Name));
}
private static bool MatchProperties(ServiceAttendance actualState, StudentAssignedOffering expectedStudentAssignedOffering, DateTime expectedDateAttended, Subject expectedSubject, decimal expectedDuration, string expectedNotes)
{
Assert.AreEqual(expectedStudentAssignedOffering, actualState.StudentAssignedOffering);
Assert.AreEqual(expectedDateAttended, actualState.DateAttended);
Assert.AreEqual(expectedSubject.Id, actualState.Subject.Id);
Assert.AreEqual(expectedDuration, actualState.Duration);
Assert.AreEqual(expectedNotes, actualState.Notes);
return(true);
}
public void WhenDelete_ThenAssignedOfferingSetInactive()
{
Target.Delete(User, 3);
using (EducationDataContext verificationContext = new EducationDataContext())
{
StudentAssignedOffering actual = verificationContext.StudentAssignedOfferings.Find(3);
Assert.IsFalse(actual.IsActive);
}
}
public void GivenValidAssignedOfferingId_WhenGenerateCreateViewModel_ThenModelIsReturned()
{
StudentAssignedOffering addTo = Data.StudentAssignedOfferings.Single(a => a.Id == 1);
PermissionFactory.Current.Expect(m => m.Create("CreateServiceAttendance", addTo)).Return(MockRepository.GenerateMock <IPermission>());
var actual = Target.GenerateCreateViewModel(User, 1) as ServiceAttendanceModel;
Assert.IsNotNull(actual);
}
public void GivenValidAssignedServiceOfferingId_WhenGenerateDeleteViewModel_ThenViewModelReturned()
{
StudentAssignedOffering expectedState = Data.StudentAssignedOfferings[0];
PermissionFactory.Current.Expect(m => m.Create("DeleteScheduledOffering", expectedState)).Return(MockRepository.GenerateMock <IPermission>());
DeleteServiceOfferingScheduleModel actual = Target.GenerateDeleteViewModel(User, expectedState.Id);
Assert.IsNotNull(actual);
}
public void GivenValidAssignedServiceOfferingId_AndAssignedOfferingIsForMultipleStudents_WhenDelete_ThenStudentAssignedOfferingSetInactive()
{
StudentAssignedOffering toRemove = Data.StudentAssignedOfferings[0];
PermissionFactory.Current.Expect(m => m.Create("DeleteScheduledOffering", toRemove)).Return(MockRepository.GenerateMock <IPermission>());
Target.Delete(User, toRemove.Id);
Assert.IsFalse(toRemove.IsActive);
}
public void GivenAStudentAssignedOffering_WhenUpdated_ThenContextSetsModified()
{
var expected = new StudentAssignedOffering {
Id = 1
};
Target.Update(expected);
MockContext.AssertWasCalled(m => m.SetModified(expected));
}
public void GivenAStudentAssignedOffering_WhenAdd_ThenAddToContext()
{
var expected = new StudentAssignedOffering {
Id = 1
};
Target.Add(expected);
MockDbSet.AssertWasCalled(m => m.Add(expected));
}
public void GivenValidAssignedServiceOfferingId__WhenGenerateEditViewModel_ThenAttemptGrantAccess()
{
StudentAssignedOffering expectedState = Data.StudentAssignedOfferings[0];
IPermission permission = MockRepository.GenerateMock <IPermission>();
PermissionFactory.Current.Expect(m => m.Create("EditScheduledOffering", expectedState)).Return(permission);
Target.GenerateEditViewModel(User, 1);
permission.AssertWasCalled(p => p.GrantAccess(User));
}
public void GivenValidAssignedServiceOfferingId_WhenDelete_ThenStudentAssignedOfferingIsUpdated_AndSaved()
{
StudentAssignedOffering toRemove = Data.StudentAssignedOfferings[0];
PermissionFactory.Current.Expect(m => m.Create("DeleteScheduledOffering", toRemove)).Return(MockRepository.GenerateMock <IPermission>());
Target.Delete(User, toRemove.Id);
Repositories.MockStudentAssignedOfferingRepository.AssertWasCalled(m => m.Update(toRemove));
Repositories.MockRepositoryContainer.AssertWasCalled(m => m.Save());
}
public void GivenValidAssignedServiceOfferingId_WhenDelete_ThenAttemptGrantAccess()
{
StudentAssignedOffering toRemove = Data.StudentAssignedOfferings[0];
IPermission permission = MockRepository.GenerateMock <IPermission>();
PermissionFactory.Current.Expect(m => m.Create("DeleteScheduledOffering", toRemove)).Return(permission);
Target.Delete(User, toRemove.Id);
permission.AssertWasCalled(p => p.GrantAccess(User));
}
public void GivenValidAssignedServiceOfferingId_WhenGenerateEditViewModel_ThenViewModelReturnedWithAssignedOfferingState()
{
StudentAssignedOffering expectedState = Data.StudentAssignedOfferings[0];
int expectedStudentId = expectedState.StudentId;
PermissionFactory.Current.Expect(m => m.Create("EditScheduledOffering", expectedState)).Return(MockRepository.GenerateMock <IPermission>());
StudentServiceOfferingScheduleModel actual = Target.GenerateEditViewModel(User, expectedState.Id);
AssertModelState(expectedState, expectedStudentId, actual);
}
public void GivenValidAssignedOfferingId_WhenGenerateCreateViewModel_ThenAttemptGrantAccess()
{
StudentAssignedOffering addTo = Data.StudentAssignedOfferings.Single(a => a.Id == 1);
IPermission permission = MockRepository.GenerateMock <IPermission>();
PermissionFactory.Current.Expect(m => m.Create("CreateServiceAttendance", addTo)).Return(permission);
Target.GenerateCreateViewModel(User, 1);
permission.AssertWasCalled(p => p.GrantAccess(User));
}
private void Create(StudentAssignedOffering studentAssignedOffering, DateTime dateAttended, Subject subject, decimal duration, string notes, EducationSecurityPrincipal user)
{
var newAttendance = new ServiceAttendance();
newAttendance.StudentAssignedOffering = studentAssignedOffering;
newAttendance.DateAttended = dateAttended;
newAttendance.Subject = subject;
newAttendance.Duration = duration;
newAttendance.Notes = notes;
newAttendance.CreatingUser = user.Identity.User;
ServiceAttendanceRepository.Add(newAttendance);
}
public void GivenOnlyInactiveStudentAssignedOffering_WhenCheckStudentOfferings_ThenSucceed()
{
Data.StudentAssignedOfferings.Clear();
StudentAssignedOffering offering = new StudentAssignedOffering {
ServiceOfferingId = 1, IsActive = false
};
Data.ServiceOfferings[0].StudentAssignedOfferings.Add(offering);
Data.StudentAssignedOfferings.Add(offering);
Target.CheckStudentAssignedOfferings(1);
}
public void GivenValidStudentAssignedOffering_WhenCopyTo_ThenModelHasViewModelData()
{
StudentServiceOfferingScheduleModel target = new StudentServiceOfferingScheduleModel {
Id = 1, StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(1), Notes = "blah"
};
StudentAssignedOffering actual = new StudentAssignedOffering();
target.CopyTo(actual);
Assert.AreEqual(target.StartDate, actual.StartDate);
Assert.AreEqual(target.EndDate, actual.EndDate);
Assert.AreEqual(target.Notes, actual.Notes);
}
public void GivenValidAssignedServiceOfferingId_WhenGenerateDeleteViewModel_ThenViewModelStateMatches()
{
StudentAssignedOffering expectedState = Data.StudentAssignedOfferings[0];
int expectedStudentId = expectedState.StudentId;
PermissionFactory.Current.Expect(m => m.Create("DeleteScheduledOffering", expectedState)).Return(MockRepository.GenerateMock <IPermission>());
DeleteServiceOfferingScheduleModel actual = Target.GenerateDeleteViewModel(User, expectedState.Id);
Assert.AreEqual(expectedState.Id, actual.Id);
Assert.AreEqual(expectedStudentId, actual.StudentId);
Assert.AreEqual(expectedState.ServiceOffering.Name, actual.Name);
}
private StudentAssignedOffering CreateNewStudentAssignedOffering(Student student, ServiceUploadModel model, EducationSecurityPrincipal user)
{
var newOffering = new StudentAssignedOffering();
newOffering.Student = student;
newOffering.StudentId = student.Id;
newOffering.CreatingUser = user.Identity.User;
newOffering.ServiceOfferingId = model.ServiceOfferingId;
newOffering.StartDate = DateTime.Now;
newOffering.CreateTime = DateTime.Now;
newOffering.IsActive = true;
StudentAssignedOfferingRepository.Add(newOffering);
return(newOffering);
}
public void WhenICopyFromADomainEntity_ThenViewModelContainsState()
{
StudentAssignedOffering source = new StudentAssignedOffering {
Id = 12, EndDate = new DateTime(2004, 4, 5), Notes = "swkldfjwoi", ServiceOfferingId = 3483, StartDate = new DateTime(2001, 6, 21)
};
Target.CopyFrom(source);
Assert.AreEqual(source.Id, Target.Id);
Assert.AreEqual(source.EndDate, Target.EndDate);
Assert.AreEqual(source.Notes, Target.Notes);
Assert.AreEqual(source.ServiceOfferingId, Target.ServiceOfferingId);
Assert.AreEqual(source.StartDate, Target.StartDate);
}
private void CreateNewStudentAssignedOffering(Student student, ServiceUploadModel model, DateTime?startDate, DateTime?endDate, string notes, EducationSecurityPrincipal user)
{
var newOffering = new StudentAssignedOffering()
{
StudentId = student.Id,
CreatingUser = user.Identity.User,
ServiceOfferingId = model.ServiceOfferingId,
StartDate = startDate,
EndDate = endDate,
Notes = notes,
IsActive = true
};
StudentAssignedOfferingRepository.Add(newOffering);
}
public void GivenValidViewModel_WhenEdit_ThenAttemptGrantAccess()
{
StudentAssignedOffering toEdit = Data.StudentAssignedOfferings[0];
StudentServiceOfferingScheduleModel viewModel = new StudentServiceOfferingScheduleModel
{
Id = toEdit.Id
};
PermissionFactory.Current.Expect(m => m.Create("EditScheduledOffering", toEdit)).Return(MockRepository.GenerateMock <IPermission>());
Target.Edit(User, viewModel);
Assert.IsTrue(toEdit.LastModifyTime.Value.WithinTimeSpanOf(TimeSpan.FromSeconds(1), DateTime.Now));
Assert.AreEqual(User.Identity.User, toEdit.LastModifyingUser);
}
public void GivenValidUser_WhenEdit_ThenAttemptGrantAccess()
{
StudentAssignedOffering toEdit = Data.StudentAssignedOfferings[0];
StudentServiceOfferingScheduleModel viewModel = new StudentServiceOfferingScheduleModel
{
Id = toEdit.Id
};
IPermission permission = MockRepository.GenerateMock <IPermission>();
PermissionFactory.Current.Expect(m => m.Create("EditScheduledOffering", toEdit)).Return(permission);
Target.Edit(User, viewModel);
permission.AssertWasCalled(p => p.GrantAccess(User));
}
public void GivenOnlyHaveOneStudentAssignedOffering_WhenEdit_ThenItIsUpdated()
{
StudentAssignedOffering toEdit = Data.StudentAssignedOfferings[4];
StudentServiceOfferingScheduleModel viewModel = new StudentServiceOfferingScheduleModel
{
Id = toEdit.Id,
EndDate = DateTime.Now
};
PermissionFactory.Current.Expect(m => m.Create("EditScheduledOffering", toEdit)).Return(MockRepository.GenerateMock <IPermission>());
Target.Edit(User, viewModel);
Repositories.MockStudentAssignedOfferingRepository.AssertWasCalled(a => a.Update(toEdit));
Repositories.MockRepositoryContainer.AssertWasCalled(a => a.Save());
}
public void WhenICopyToDomainEntity_ThenDomainEntityContainsState()
{
StudentAssignedOffering destination = new StudentAssignedOffering();
Target.Id = 12;
Target.EndDate = new DateTime(2004, 4, 5);
Target.Notes = "swkldfjwoi";
Target.ServiceOfferingId = 3483;
Target.StartDate = new DateTime(2001, 6, 21);
Target.CopyTo(destination);
//Assert.AreEqual(Target.Id, destination.Id);
Assert.AreEqual(Target.EndDate, destination.EndDate);
Assert.AreEqual(Target.Notes, destination.Notes);
Assert.AreEqual(Target.ServiceOfferingId, destination.ServiceOfferingId);
Assert.AreEqual(Target.StartDate, destination.StartDate);
}
