public void GivenIsActiveIsFalse_WhenIExecuteFilterPredicate_ThenReturnFalse()
{
ServiceOffering argument = new ServiceOffering { IsActive = false };
ServiceOfferingClientDataTable target = new ServiceOfferingClientDataTable(MockRequest, CurrentUser);
Assert.IsFalse(target.FilterPredicate.Compile().Invoke(argument));
}
public void GivenAServiceOffering_WhenAdd_ThenAddToContext()
{
var expected = new ServiceOffering { Id = 1 };
Target.Add(expected);
MockDbSet.AssertWasCalled(m => m.Add(expected));
}
public ImportOfferingDataPermission(ServiceOffering offering)
{
if (offering == null)
{
throw new ArgumentNullException("offering");
}
Offering = offering;
}
public void GivenAServiceOffering_WhenUpdate_ThenContextSetsModified()
{
var expected = new ServiceOffering { Id = 1 };
Target.Update(expected);
MockContext.AssertWasCalled(m => m.SetModified(expected));
}
public void GivenAnAssociatedServiceOfferingAndUser_WhenAddLink_ThenTheyAreAssociated()
{
ServiceOffering serviceOffering = new ServiceOffering();
User user = new User();
Target.AddLink(serviceOffering, user);
CollectionAssert.Contains(serviceOffering.UsersLinkingAsFavorite.ToList(), user);
CollectionAssert.Contains(user.FavoriteServiceOfferings.ToList(), serviceOffering);
}
public WorksheetWriter(ServiceOffering offering, string sheetName)
{
if (offering == null)
{
throw new ArgumentNullException("offering");
}
ServiceOffering = offering;
SheetName = sheetName;
ErrorRows = new List<FileRowModel>();
}
public void GivenProviderSet_AndServiceTypeSet_AndProgramSet_WhenGetName_ThenProgramIsAlsoConcatenated()
{
ServiceOffering target = new ServiceOffering
{
Provider = new Provider { Name = "Bob" },
ServiceType = new ServiceType { Name = "Tutoring" },
Program = new Program { Name = "Test Program"}
};
Assert.AreEqual("Bob Tutoring/Test Program", target.Name);
}
public void GivenAnAssociatedUserAndServiceOffering_WhenDeleteLink_ThenTheyAreNoLongerAssociated()
{
ServiceOffering serviceOffering = new ServiceOffering();
User user = new User { FavoriteServiceOfferings = new List<ServiceOffering> { serviceOffering } };
serviceOffering.UsersLinkingAsFavorite.Add(user);
Target.DeleteLink(serviceOffering, user);
CollectionAssert.DoesNotContain(serviceOffering.UsersLinkingAsFavorite.ToList(), user);
CollectionAssert.DoesNotContain(user.FavoriteServiceOfferings.ToList(), serviceOffering);
}
public void DeleteLink(ServiceOffering serviceOffering, User user)
{
if (serviceOffering == null)
{
throw new ArgumentNullException("serviceOffering");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
serviceOffering.UsersLinkingAsFavorite.Remove(user);
user.FavoriteServiceOfferings.Remove(serviceOffering);
}
public void GivenServiceOffering_AndUserIsDataAdmin_WhenInvokeDataSelector_ThenDataCanInteract()
{
ServiceOffering offering = new ServiceOffering
{
Provider = new Provider(),
ServiceType = new ServiceType(),
Program = new Program()
};
CurrentUser.Identity.User.UserRoles.Add(new UserRole { Role = new Role { Name = SecurityRoles.DataAdmin } });
ServiceOfferingClientDataTable target = new ServiceOfferingClientDataTable(MockRequest, CurrentUser);
dynamic actual = target.DataSelector.Compile().Invoke(offering);
Assert.AreEqual(true, actual.CanInteract);
}
public ScheduleOfferingPermission(IEnumerable<Student> students, ServiceOffering offering)
{
if (students == null)
{
throw new ArgumentNullException("students");
}
if (offering == null)
{
throw new ArgumentNullException("offering");
}
if (!students.Any())
{
throw new ArgumentException("List cannot be empty.", "students");
}
Students = students;
Offering = offering;
}
public void GivenProviderSet_AndServiceTypeSet_AndProgramSet_WhenGetName_ThenProgramIsAlsoConcatenated()
{
ServiceOffering target = new ServiceOffering
{
Provider = new Provider {
Name = "Bob"
},
ServiceType = new ServiceType {
Name = "Tutoring"
},
Program = new Program {
Name = "Test Program"
}
};
Assert.AreEqual("Bob Tutoring/Test Program", target.Name);
}
public void Add(ServiceOffering item)
{
Context.ServiceOfferings.Add(item);
}
protected bool IsProviderAssociatedToOffering(EducationSecurityPrincipal user, ServiceOffering offering)
{
return IsProvider(user) && user.Identity.User.UserRoles.SelectMany(u => u.Providers).Contains(offering.Provider);
}
public void WhenConstruct_ThenUsersLinkingAsFavoriteNotNull()
{
ServiceOffering target = new ServiceOffering();
Assert.IsNotNull(target.UsersLinkingAsFavorite);
}
public void GivenServiceTypeProviderProgramAlreadyExists_AndOfferingIsInactive_AndServiceTypeAddedToProgram_WhenEdit_ThenServiceOfferingIsActive()
{
int id = 2;
ServiceOffering newOffering = new ServiceOffering { ProviderId = 1, ServiceTypeId = 1, ProgramId = id, IsActive = false };
Data.ServiceOfferings.Add(newOffering);
ProgramModel viewModel = new ProgramModel { Id = id, SelectedServiceTypes = new int[] { 1, 4 }, SelectedProviders = new int[] { 1 } };
Target.Edit(viewModel);
Assert.IsTrue(newOffering.IsActive);
}
private IWorksheetWriter CreateWorksheetWriter(ServiceOffering offering)
{
return new WorksheetWriter(offering, ServiceOfferingSheetName);
}
public void WhenConstruct_ThenAssignedOfferingsNotNull()
{
ServiceOffering target = new ServiceOffering();
Assert.IsNotNull(target.StudentAssignedOfferings);
}
private void ProcessErrorFile(EducationSecurityPrincipal user, ServiceOffering offering, ServiceUploadModel model, string templatePath)
{
var fileName = string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", offering.Name.GetSafeFileName(), DateTime.Now.Ticks, ".xlsx");
var blobAddress = string.Format("{0}-{1}-{2}", user.Identity.User.DisplayName, user.Identity.User.Id, fileName);
model.ErrorDownloadFile = new DownloadFileModel
{
FileName = fileName,
BlobAddress = blobAddress
};
var worksheetWriter = CreateWorksheetWriter(offering);
ExcelWriter writer = new ExcelWriter();
writer.InitializeFrom(templatePath, worksheetWriter);
foreach (var error in model.RowErrorValues)
{
worksheetWriter.ErrorRows.Add(error);
}
writer.AppendErrorRows(ServiceOfferingSheetName, worksheetWriter);
writer.Write(BlobClient.CreateContainer(ServiceFileContainerName), model.ErrorDownloadFile.BlobAddress);
}
private bool GrantUserAccessToUploadOffering(EducationSecurityPrincipal user, ServiceOffering offering)
{
IPermission permission = PermissionFactory.Current.Create("ImportOfferingData", offering);
return permission.TryGrantAccess(user);
}
public void GivenServiceOffering_WhenInvokeDataSelector_ThenDataContainsExpectedProperties()
{
bool expectedIsFavorite = true;
bool expectedIsProviate = true;
string expectedServiceTypeName = "jw29fij2";
string expectedProviderName = "slkdjfsdkljfs";
string expectedProgramName = "wjovjwiojw";
int expectedServiceOfferingId = 382;
ServiceOffering offering = new ServiceOffering
{
UsersLinkingAsFavorite = new List<User> { CurrentUser.Identity.User },
ServiceType = new ServiceType { Name = expectedServiceTypeName, IsPrivate = expectedIsProviate },
Provider = new Provider { Name = expectedProviderName },
Program = new Program { Name = expectedProgramName },
Id = expectedServiceOfferingId
};
ServiceOfferingClientDataTable target = new ServiceOfferingClientDataTable(MockRequest, CurrentUser);
dynamic actual = target.DataSelector.Compile().Invoke(offering);
Assert.AreEqual(expectedIsFavorite, actual.IsFavorite);
Assert.AreEqual(expectedIsProviate, actual.IsPrivate);
Assert.AreEqual(expectedServiceTypeName, actual.ServiceType);
Assert.AreEqual(expectedProviderName, actual.Provider);
Assert.AreEqual(expectedProgramName, actual.Program);
Assert.AreEqual(expectedServiceOfferingId, actual.Id);
}
public void GivenServiceTypeFiltersExistInRequest_AndServiceOfferingMatchesFilter_WhenIExecuteFilterPredicate_ThenServiceOfferingIsSelected()
{
ServiceOffering argument = new ServiceOffering { ServiceType = new ServiceType { Name = "Apples" }, IsActive = true };
MockRequest.Expect(m => m["ServiceTypeFilters"]).Return("Apples|Oranges|Grapes");
ServiceOfferingClientDataTable target = new ServiceOfferingClientDataTable(MockRequest, CurrentUser);
Assert.IsTrue(target.FilterPredicate.Compile().Invoke(argument));
}
public void WhenConstruct_ThenUsersLinkingAsFavoriteNotNull()
{
ServiceOffering target = new ServiceOffering();
Assert.IsNotNull(target.UsersLinkingAsFavorite);
}
private void CreateServiceOfferings(Program program, ServiceType serviceType)
{
foreach (int providerId in program.ServiceOfferings.Select(s => s.ProviderId).Distinct().ToArray())
{
if (!serviceType.ServiceOfferings.Any(o => o.Program == program && o.ProviderId == providerId))
{
ServiceOffering newOffering = new ServiceOffering
{
IsActive = true,
ServiceType = serviceType,
Program = program,
ProgramId = program.Id,
ProviderId = providerId
};
serviceType.ServiceOfferings.Add(newOffering);
ServiceOfferingRepository.Add(newOffering);
}
else if (serviceType.ServiceOfferings.Any(o => o.Program == program && o.ProviderId == providerId && !o.IsActive))
{
serviceType.ServiceOfferings.Single(o => o.Program == program && o.ProviderId == providerId && !o.IsActive).IsActive = true;
}
}
}
public void GivenNullUser_WhenDeleteLink_ThenThrowException()
{
ServiceOffering serviceOffering = new ServiceOffering();
Target.ExpectException<ArgumentNullException>(() => Target.DeleteLink(serviceOffering, null));
}
public void Remove(ServiceOffering item)
{
throw new NotSupportedException(string.Format("{0} entities cannot be removed. Only \"soft\" deletes are supported via IsActive.", item.GetType().Name));
}
public void GivenAServiceOffering_WhenRemove_ThenThrowException()
{
var item = new ServiceOffering { Id = 1 };
Target.ExpectException<NotSupportedException>(() => Target.Remove(item));
}
public void Update(ServiceOffering item)
{
Context.SetModified(item);
}
public void WhenConstruct_ThenAssignedOfferingsNotNull()
{
ServiceOffering target = new ServiceOffering();
Assert.IsNotNull(target.StudentAssignedOfferings);
}
private List<ServiceOffering> GenerateServiceOfferingMappings(ProgramModel viewModel, Program item)
{
List<ServiceOffering> newMappings = new List<ServiceOffering>();
if (viewModel.SelectedServiceTypes != null && viewModel.SelectedProviders != null)
{
foreach (var serviceTypeId in viewModel.SelectedServiceTypes)
{
foreach (var providerId in viewModel.SelectedProviders)
{
ServiceOffering newOffering = ServiceOfferingRepository.Items.SingleOrDefault(s => s.ServiceTypeId == serviceTypeId && s.ProviderId == providerId && s.ProgramId == item.Id && !s.IsActive);
if (newOffering == null)
{
newOffering = new ServiceOffering { ProviderId = providerId, ServiceTypeId = serviceTypeId, Program = item, ProgramId = item.Id, IsActive = true };
}
else
{
newOffering.IsActive = true;
}
newMappings.Add(newOffering);
}
}
}
return newMappings;
}
public void InitializeTest()
{
TestData = new TestData();
ServiceOffering = new ServiceOffering() { Id = 1, Provider = TestData.Providers[0], ServiceType = TestData.ServiceTypes[0], Program = TestData.Programs[0] };
Target = new WorksheetWriter(ServiceOffering, "Assign Service Offering");
}
