public async Task GetEnrollmentsForSite_ReturnsEnrollmentsWithSiteId_IncludesEntities(
string[] include,
bool includeFundings,
bool includeChildren,
bool includeFamilies,
bool includeDeterminations
)
{
int[] ids;
int siteId;
using (var context = new TestHedwigContextProvider().Context)
{
var site = SiteHelper.CreateSite(context);
var enrollments = EnrollmentHelper.CreateEnrollments(context, 3, site: site);
ids = enrollments.Select(e => e.Id).ToArray();
siteId = site.Id;
}
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context);
var res = await enrollmentRepo.GetEnrollmentsForSiteAsync(siteId, include : include);
Assert.Equal(ids.OrderBy(id => id), res.Select(e => e.Id).OrderBy(id => id));
Assert.Equal(includeFundings, res.TrueForAll(e => e.Fundings != null));
Assert.Equal(includeChildren, res.TrueForAll(e => e.Child != null));
Assert.Equal(includeFamilies, res.TrueForAll(e => e.Child != null && e.Child.Family != null));
Assert.Equal(includeDeterminations, res.TrueForAll(e => e.Child != null && e.Child.Family != null && e.Child.Family.Determinations != null));
}
}
public void Execute_DoesNotAddEnrollmentsToReport(bool reportHasEnrollmentsReference)
{
CdcReport report;
using (var context = new TestHedwigContextProvider().Context)
{
report = ReportHelper.CreateCdcReport(context) as CdcReport;
var site = SiteHelper.CreateSite(context, organization: report.Organization);
var enrollments = EnrollmentHelper.CreateEnrollments(context, 1, site: site);
report.Enrollments = enrollments;
}
if (!reportHasEnrollmentsReference)
{
report.Enrollments = null;
}
using (var context = new TestHedwigContextProvider().Context)
{
context.Attach(report);
var _serviceProvider = new Mock <IServiceProvider>();
_serviceProvider.Setup(sp => sp.GetService(typeof(IEnumerable <IValidationRule <Enrollment> >)))
.Returns(new List <IValidationRule <Enrollment> >());
var _validator = new NonBlockingValidator(_serviceProvider.Object);
var _reports = new ReportRepository(context);
// when
var rule = new EnrollmentsAreValid(_validator, _reports);
rule.Execute(report, new NonBlockingValidationContext());
// then
Assert.Equal(reportHasEnrollmentsReference, report.Enrollments != null);
}
}
public async Task Get_Report_For_Organization(bool submitted, string[] include)
{
using (var context = new TestHedwigContextProvider().Context)
{
// Set up test data
var organization = OrganizationHelper.CreateOrganization(context);
var reportingPeriod = ReportingPeriodHelper.CreateReportingPeriod(context);
var report = ReportHelper.CreateCdcReport(context, organization: organization, reportingPeriod: reportingPeriod);
var site = SiteHelper.CreateSite(context, organization: organization);
var enrollment = EnrollmentHelper.CreateEnrollment(context, site: site, ageGroup: Age.Preschool);
var funding = FundingHelper.CreateFunding(context, enrollment: enrollment, firstReportingPeriod: reportingPeriod);
if (submitted)
{
Thread.Sleep(1000);
report.SubmittedAt = DateTime.Now;
context.SaveChanges();
Thread.Sleep(1000);
}
enrollment.AgeGroup = Age.SchoolAge;
context.SaveChanges();
// When the repository is queried
var repo = new ReportRepository(context);
var result = await repo.GetReportForOrganizationAsync(report.Id, organization.Id, include) as CdcReport;
// It returns the Report
Assert.Equal(result.Id, report.Id);
// It includes the Organization
Assert.Equal(include.Contains("organizations"), result.Organization != null);
// It includes the Sites
Assert.Equal(include.Contains("sites"), result.Organization != null && result.Organization.Sites != null);
// It includes the Enrollments (and Fundings too)
Assert.Equal(
include.Contains("enrollments"),
result.Enrollments != null &&
result.Enrollments.FirstOrDefault().Fundings != null
);
// When it includes enrollments
if (include.Contains("enrollments"))
{
var enrollmentResult = result.Enrollments.FirstOrDefault();
var fundingResult = enrollmentResult.Fundings.FirstOrDefault();
// A submitted report should return the data as of when it was submitted
Assert.Equal(submitted ? Age.Preschool : Age.SchoolAge, enrollmentResult.AgeGroup);
}
}
}
public async Task ReportControllerOrganizationsReportsGet_ReturnsCorrectResponseShape()
{
User user;
Organization organization;
Site[] sites;
Report report;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var site1 = SiteHelper.CreateSite(context, organization: organization);
var site2 = SiteHelper.CreateSite(context, organization: organization);
report = ReportHelper.CreateCdcReport(context, organization: organization);
sites = new Site[] { site1, site2 };
EnrollmentHelper.CreateEnrollment(context, site: site1);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site1);
PermissionHelper.CreateSitePermission(context, user, site2);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.OrganizationReports(
user,
organization
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseReports = JsonConvert.DeserializeObject <List <CdcReport> >(responseString);
Assert.NotEmpty(responseReports);
var responseReport = responseReports.First();
Assert.NotNull(responseReport);
Assert.Equal(report.Id, responseReport.Id);
Assert.NotNull(responseReport.Organization);
Assert.Null(responseReport.Organization.FundingSpaces);
Assert.Null(responseReport.Organization.Sites);
Assert.NotNull(responseReport.ReportingPeriod);
Assert.Null(responseReport.Enrollments);
}
public void OrganizationController_ReturnsCorrectResult_WhenUserHasVariousSiteAccess(
bool hasAccessToSite2,
bool authSucceeds
)
{
using (var dbContext = new TestHedwigContextProvider().Context)
{
// If user exists with access to site
var user = UserHelper.CreateUser(dbContext);
var site1 = SiteHelper.CreateSite(dbContext, name: "Test 1");
var site2 = SiteHelper.CreateSite(dbContext, name: "Test 2");
PermissionHelper.CreateSitePermission(dbContext, user, site1);
if (hasAccessToSite2)
{
PermissionHelper.CreateSitePermission(dbContext, user, site2);
}
// When requirement is evaluated with:
// - claim for that user
var claim = new Claim("sub", $"{user.WingedKeysId}");
var userClaim = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { claim }));
// - httpContext for request to 'Sites' controller for that site
var httpContext = new Mock <HttpContext>();
var httpContextAccessor = new HttpContextAccessor
{
HttpContext = httpContext.Object
};
var siteIds = new StringValues(new string[] { site1.Id.ToString(), site2.Id.ToString() });
httpContext.Setup(hc => hc.Request.Query.TryGetValue(It.IsAny <string>(), out siteIds)).Returns(true);
// - permission repository
var permissions = new PermissionRepository(dbContext);
var reqHandler = new MultipleSiteAccessHandler(httpContextAccessor, permissions);
var req = new SiteAccessRequirement();
var authContext = new AuthorizationHandlerContext(new List <IAuthorizationRequirement> {
req
}, userClaim, new object());
// When requirement handler handles authorization context
reqHandler.HandleAsync(authContext);
// Then authorization context will have succeeded
Assert.Equal(authSucceeds, authContext.HasSucceeded);
}
}
public void UserCanAccessSite_No_Permission()
{
using (var context = new TestHedwigContextProvider().Context)
{
// If user exists without any permissions
var user = UserHelper.CreateUser(context);
var site = SiteHelper.CreateSite(context);
PermissionHelper.CreateSitePermission(context, user, site);
// When repository is queried for user access to some other site
var permissionRepo = new PermissionRepository(context);
var res = permissionRepo.UserCanAccessSite(user.WingedKeysId, 0);
// Then result is false
Assert.False(res);
}
}
public void UserCanAccessSite_OrganizationPermission()
{
using (var context = new TestHedwigContextProvider().Context)
{
// If user exists with organization permission that includes site
var user = UserHelper.CreateUser(context);
var site = SiteHelper.CreateSite(context);
var organization = OrganizationHelper.CreateOrganization(context, sites: new Site[] { site });
PermissionHelper.CreateOrganizationPermission(context, user, organization);
// When repository is queried for user access to site
var permissionRepo = new PermissionRepository(context);
var res = permissionRepo.UserCanAccessSite(user.WingedKeysId, site.Id);
// Then result is true
Assert.True(res);
}
}
public void Other_Controller_User_Has_Site_Access_Evaluate_Returns_True()
{
using (var dbContext = new TestHedwigContextProvider().Context)
{
// If user exists with access to site
var user = UserHelper.CreateUser(dbContext);
var site = SiteHelper.CreateSite(dbContext);
PermissionHelper.CreateSitePermission(dbContext, user, site);
// When requirement is evaluated with:
// - claim for that user
var claim = new Claim("sub", $"{user.WingedKeysId}");
var userClaim = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { claim }));
// - httpContext for request to other controller nested under that site
var httpContext = new Mock <HttpContext>();
var httpContextAccessor = new HttpContextAccessor
{
HttpContext = httpContext.Object
};
var routeValues = new RouteValueDictionary(new Dictionary <string, string> {
{ "controller", "Other" },
{ "siteId", $"{site.Id}" }
});
httpContext.Setup(hc => hc.Features.Get <IRoutingFeature>()).Returns(new Mock <IRoutingFeature>().Object);
httpContext.Setup(hc => hc.Request.RouteValues).Returns(routeValues);
// - permission repository
var permissions = new PermissionRepository(dbContext);
var reqHandler = new SingleSiteAccessHandler(httpContextAccessor, permissions);
var req = new SiteAccessRequirement();
var authContext = new AuthorizationHandlerContext(new List <IAuthorizationRequirement> {
req
}, userClaim, new object());
// When requirement handler handles authorization context
reqHandler.HandleAsync(authContext);
// Then authorization context will have succeeded
Assert.True(authContext.HasSucceeded);
}
}
public async Task GetSitesForOrganizationAsync_ReturnsSitesWithOrganizationId()
{
using (var context = new TestHedwigContextProvider().Context)
{
var organization = OrganizationHelper.CreateOrganization(context);
var anotherOrganization = OrganizationHelper.CreateOrganization(context);
var sites = SiteHelper.CreateSites(context, 3, organization: organization);
var otherSites = SiteHelper.CreateSite(context, organization: anotherOrganization);
var siteIds = sites.Select(site => site.Id);
var siteRepo = new SiteRepository(context);
var res = await siteRepo.GetSitesForOrganizationAsync(organization.Id);
var resIds = res.Select(rSite => rSite.Id);
// Assert all returned sites are in the created sites with correct org id
Assert.All(res, rSite => Assert.Contains(rSite.Id, siteIds));
// Assert all created sites with correct org id are in the created sites
Assert.All(siteIds, id => Assert.Contains(id, resIds));
// Assert all returned sites have the correct org id
Assert.All(res, rSite => Assert.Equal(rSite.OrganizationId, rSite.OrganizationId));
}
}
public async Task OrganizationControllerOrganizationsGet_ReturnsCorrectResponseShape(
string[] include,
bool isInclude
)
{
User user;
Organization organization;
Site[] sites;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var site1 = SiteHelper.CreateSite(context, organization: organization);
var site2 = SiteHelper.CreateSite(context, organization: organization);
sites = new Site[] { site1, site2 };
EnrollmentHelper.CreateEnrollment(context, site: site1);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site1);
PermissionHelper.CreateSitePermission(context, user, site2);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.Organizations(
user,
organization,
include
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseOrganization = JsonConvert.DeserializeObject <Organization>(responseString);
Assert.NotNull(responseOrganization);
Assert.Equal(organization.Id, responseOrganization.Id);
Assert.Equal(organization.Name, responseOrganization.Name);
Assert.Null(responseOrganization.Reports);
if (isInclude)
{
Assert.NotEmpty(responseOrganization.Sites);
Assert.All(
responseOrganization.Sites,
site =>
{
Assert.NotNull(site.Name);
Assert.Null(site.Organization);
Assert.Null(site.Enrollments);
}
);
Assert.Null(responseOrganization.Reports);
Assert.NotNull(responseOrganization.FundingSpaces);
Assert.All(
responseOrganization.FundingSpaces,
fundingSpace =>
{
Assert.NotNull(fundingSpace);
Assert.Equal(fundingSpace.Time == FundingTime.Split, fundingSpace.TimeSplit != null);
}
);
}
else
{
Assert.Null(responseOrganization.Sites);
Assert.Null(responseOrganization.FundingSpaces);
}
}
public async Task ReportControllerOrganizationsReportGet_ReturnsCorrectResponseShape()
{
User user;
Organization organization;
Site[] sites;
Report report;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var site1 = SiteHelper.CreateSite(context, organization: organization);
var site2 = SiteHelper.CreateSite(context, organization: organization);
report = ReportHelper.CreateCdcReport(context, organization: organization);
sites = new Site[] { site1, site2 };
EnrollmentHelper.CreateEnrollment(context, site: site1);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site1);
PermissionHelper.CreateSitePermission(context, user, site2);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.OrganizationReport(
user,
organization,
report
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseReport = JsonConvert.DeserializeObject <CdcReport>(responseString);
Assert.NotNull(responseReport);
Assert.Equal(report.Id, responseReport.Id);
Assert.NotNull(responseReport.Organization);
Assert.All(
responseReport.Organization.Sites,
site =>
{
Assert.NotNull(site.Name);
Assert.Null(site.Organization);
Assert.Null(site.Enrollments);
}
);
Assert.NotNull(responseReport.Organization.FundingSpaces);
Assert.All(
responseReport.Organization.FundingSpaces,
fundingSpace =>
{
Assert.NotNull(fundingSpace);
Assert.Equal(fundingSpace.Time == FundingTime.Split, fundingSpace.TimeSplit != null);
}
);
Assert.NotNull(responseReport.ReportingPeriod);
Assert.NotNull(responseReport.Enrollments);
Assert.All(
responseReport.Enrollments,
enrollment =>
{
Assert.NotNull(enrollment.Child);
Assert.Null(enrollment.Child.Family);
Assert.Null(enrollment.Child.Enrollments);
Assert.Null(enrollment.Child.Organization);
Assert.Null(enrollment.Site);
Assert.All(
enrollment.Fundings,
funding =>
{
Assert.NotNull(funding.FundingSpace);
Assert.Equal(funding.FundingSpace.Time == FundingTime.Split, funding.FundingSpace.TimeSplit != null);
Assert.NotNull(funding.Source);
Assert.NotNull(funding.FirstReportingPeriod);
Assert.NotNull(funding.LastReportingPeriod);
}
);
Assert.Null(enrollment.PastEnrollments);
}
);
}
public async Task ReportControllerOrganizationsReportPut_IsSuccessfull_OrReturnsValidationError(
int partTimeWeeksUsed,
bool shouldSucceed
)
{
User user;
Organization organization;
FundingSpace fundingSpace;
Site site;
CdcReport report;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var reportingPeriod = ReportingPeriodHelper.CreateReportingPeriod(context, period: "2010-01-01", periodStart: "2010-01-01", periodEnd: "2010-01-31");
fundingSpace = FundingSpaceHelper.CreateFundingSpace(context, organization.Id, time: FundingTime.Split);
site = SiteHelper.CreateSite(context, organization: organization);
report = ReportHelper.CreateCdcReport(context, organization: organization, reportingPeriod: reportingPeriod) as CdcReport;
EnrollmentHelper.CreateEnrollment(context, site: site);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var timeSplitUtilization = new FundingTimeSplitUtilization
{
ReportId = report.Id,
ReportingPeriodId = report.ReportingPeriodId,
FundingSpaceId = fundingSpace.Id,
PartTimeWeeksUsed = partTimeWeeksUsed,
FullTimeWeeksUsed = 0,
};
typeof(FundingTimeSplitUtilization).GetProperty(nameof(FundingTimeSplitUtilization.ReportingPeriod)).SetValue(timeSplitUtilization, report.ReportingPeriod);
var reportForPut = new CdcReport
{
Id = report.Id,
Accredited = report.Accredited,
Comment = report.Comment,
Enrollments = report.Enrollments,
C4KRevenue = 0,
FamilyFeesRevenue = 0,
OrganizationId = report.OrganizationId,
ReportingPeriodId = report.ReportingPeriodId,
TimeSplitUtilizations = new List <FundingTimeSplitUtilization> {
timeSplitUtilization
},
};
typeof(Report).GetProperty(nameof(Report.ReportingPeriod)).SetValue(reportForPut, report.ReportingPeriod);
var request = HedwigAPIRequests.OrganizationReportPut(
user,
organization,
reportForPut
);
var client = _factory.CreateClient();
var response = await client.SendAsync(request);
if (shouldSucceed)
{
response.EnsureSuccessStatusCode();
}
else
{
Assert.False(response.IsSuccessStatusCode);
}
}
public async Task EnrollmentControllerOrganizationSiteEnrollmentGet_ReturnsCorrectResponseShape()
{
Enrollment enrollment;
User user;
Organization organization;
Site site;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
site = SiteHelper.CreateSite(context, organization: organization);
enrollment = EnrollmentHelper.CreateEnrollment(context, site: site);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.OrganizationSiteEnrollmentDetail(
user,
enrollment,
organization,
site
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseEnrollment = JsonConvert.DeserializeObject <Enrollment>(responseString);
Assert.NotNull(responseEnrollment);
Assert.Equal(enrollment.Id, responseEnrollment.Id);
Assert.Equal(enrollment.ChildId, responseEnrollment.ChildId);
Assert.NotNull(responseEnrollment.Child);
Assert.Equal(enrollment.ChildId, responseEnrollment.Child.Id);
Assert.Equal(enrollment.Child.FirstName, responseEnrollment.Child.FirstName);
Assert.Equal(enrollment.Child.MiddleName, responseEnrollment.Child.MiddleName);
Assert.Equal(enrollment.Child.LastName, responseEnrollment.Child.LastName);
Assert.Empty(responseEnrollment.Child.Enrollments);
Assert.Equal(enrollment.SiteId, responseEnrollment.SiteId);
Assert.NotNull(responseEnrollment.Site);
Assert.NotNull(responseEnrollment.Site.Name);
Assert.Empty(responseEnrollment.Site.Enrollments);
Assert.Equal(enrollment.AgeGroup, responseEnrollment.AgeGroup);
Assert.Equal(enrollment.Entry, responseEnrollment.Entry);
Assert.Equal(enrollment.Exit, responseEnrollment.Exit);
Assert.Equal(enrollment.ExitReason, responseEnrollment.ExitReason);
Assert.All(
responseEnrollment.Fundings,
funding =>
{
Assert.NotNull(funding.FundingSpace);
Assert.Equal(funding.FundingSpace.Time == FundingTime.Split, funding.FundingSpace.TimeSplit != null);
Assert.NotNull(funding.Source);
Assert.NotNull(funding.FirstReportingPeriod);
Assert.NotNull(funding.LastReportingPeriod);
}
);
}
public async Task EnrollmentControllerOrganizationSiteEnrollmentPost_AddsEnrollment_And_ReturnsCorrectResponseShape(
string firstName,
string lastName,
bool isSuccess
)
{
User user;
Organization organization;
Site site;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
site = SiteHelper.CreateSite(context, organization: organization);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
Child child = new Child
{
FirstName = firstName,
LastName = lastName,
OrganizationId = organization.Id
};
Enrollment enrollment = new Enrollment
{
Child = child,
SiteId = site.Id
};
var client = _factory.CreateClient();
var request = HedwigAPIRequests.EnrollmentPost(
user,
enrollment,
organization,
site
);
var response = await client.SendAsync(request);
if (!isSuccess)
{
Assert.False(response.IsSuccessStatusCode);
}
else
{
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseEnrollment = JsonConvert.DeserializeObject <Enrollment>(responseString);
Assert.NotNull(responseEnrollment);
Assert.NotNull(responseEnrollment.Child);
Assert.Equal(enrollment.Child.FirstName, responseEnrollment.Child.FirstName);
Assert.Equal(enrollment.Child.MiddleName, responseEnrollment.Child.MiddleName);
Assert.Equal(enrollment.Child.LastName, responseEnrollment.Child.LastName);
Assert.Null(responseEnrollment.Child.Family);
Assert.Empty(responseEnrollment.Child.Enrollments);
Assert.Equal(site.Id, responseEnrollment.SiteId);
Assert.Null(responseEnrollment.Site);
Assert.Equal(enrollment.AgeGroup, responseEnrollment.AgeGroup);
Assert.Equal(enrollment.Entry, responseEnrollment.Entry);
Assert.Equal(enrollment.Exit, responseEnrollment.Exit);
Assert.Equal(enrollment.ExitReason, responseEnrollment.ExitReason);
Assert.Null(responseEnrollment.Fundings);
using (var context = new TestHedwigContextProvider().Context)
{
var dbEnrollment = context.Enrollments.FirstOrDefault(
e => e.Id == responseEnrollment.Id
);
Assert.NotNull(dbEnrollment);
}
}
}
