public async Task TLevels_Get_WithNoTLevels_ReturnsOkWithEmptyCollection()
{
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetTLevels>()))
.ReturnsAsync(Array.Empty <TLevel>());
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <CosmosQueries.GetProvidersByIds>()))
.ReturnsAsync(new Dictionary <Guid, CosmosModels.Provider>());
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetProvidersByIds>()))
.ReturnsAsync(new Dictionary <Guid, Provider>());
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetVenuesByIds>()))
.ReturnsAsync(new Dictionary <Guid, Venue>());
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <CosmosQueries.GetFeChoicesByProviderUkprns>()))
.ReturnsAsync(new Dictionary <int, CosmosModels.FeChoice>());
// Act
var response = await HttpClient.GetAsync($"tlevels");
// Assert
response.StatusCode.Should().Be(StatusCodes.Status200OK);
var result = JObject.Parse(await response.Content.ReadAsStringAsync());
result.Should().NotBeNull();
result["tLevels"].ToArray().Should().BeEmpty();
}
public async Task DeleteVenue_Post_DeletesVenueAndRedirects()
{
// Arrange
var provider = await TestData.CreateProvider(
providerType : ProviderType.FE);
await User.AsTestUser(TestUserType.ProviderUser, provider.ProviderId);
var venue = await TestData.CreateVenue(provider.ProviderId);
var requestContent = new FormUrlEncodedContentBuilder()
.Add(nameof(Command.Confirm), true)
.Add(nameof(Command.ProviderId), provider.ProviderId)
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"/venues/{venue.Id}/delete")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(StatusCodes.Status302Found);
response.Headers.Location.OriginalString.Should().Be($"/venues/{venue.Id}/delete-success?providerId={provider.ProviderId}");
CosmosDbQueryDispatcher.VerifyExecuteQuery <Core.DataStore.CosmosDb.Queries.DeleteVenue, OneOf <NotFound, Success> >(q => q.VenueId == venue.Id, Times.Once());
}
public async Task PostConfirmation_ValidRequestUpdatesDbAndRedirects()
{
// Arrange
var provider = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
await User.AsProviderUser(provider.ProviderId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetProviderDetails("<p>New marketing info</p>");
var mptxInstance = CreateMptxInstance(flowModel);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/provider-detail-confirmation?providerId={provider.ProviderId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
CosmosDbQueryDispatcher.Verify(mock => mock.ExecuteQuery(It.Is <UpdateProviderInfo>(c =>
c.ProviderId == provider.ProviderId &&
c.MarketingInformation == "<p>New marketing info</p>" &&
c.UpdatedBy.UserId == User.UserId &&
c.UpdatedOn == Clock.UtcNow)));
Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
Assert.Equal(
"/new-apprenticeship-provider/find-standard",
UrlHelper.StripQueryParams(response.Headers.Location.OriginalString));
}
public async Task SyncProviderData_ProviderDoesNotExist_CreatesProviderInfo()
{
// Arrange
const int ukprn = 1234569;
var ukrlpData = GenerateUkrlpProviderData(ukprn);
var ukrlpContact = ukrlpData.ProviderContact.Single();
var ukrlpSyncHelper = SetupUkrlpSyncHelper(ukprn, ukrlpData);
ICollection <CreateProviderFromUkrlpData> capturedUpdateCommands = new List <CreateProviderFromUkrlpData>();
CosmosDbQueryDispatcher.Setup(mock => mock.ExecuteQuery(Capture.In(capturedUpdateCommands)));
// Act
await ukrlpSyncHelper.SyncProviderData(ukprn);
// Assert
var createCommand = capturedUpdateCommands.Should().ContainSingle().Subject;
createCommand.Alias.Should().Be(ukrlpData.ProviderAliases.Single().ProviderAlias);
createCommand.DateUpdated.Should().Be(Clock.UtcNow);
createCommand.ProviderName.Should().Be(ukrlpData.ProviderName);
createCommand.ProviderStatus.Should().Be(ukrlpData.ProviderStatus);
createCommand.ProviderType.Should().Be(ProviderType.None);
createCommand.Status.Should().Be(ProviderStatus.Registered);
createCommand.Ukprn.Should().Be(ukprn);
var actualContact = createCommand.Contacts.Should().ContainSingle().Subject;
AssertContactMapping(actualContact, ukrlpContact);
}
public async Task Post_ValidSetsCorrectStatusAndRequestRendersExpectedOutput(
bool passed,
ApprenticeshipQAStatus expectedStatus,
bool expectApprenticeshipToBeMadeLive)
{
// Arrange
var provider = await TestData.CreateProvider(
providerName : "Provider 1",
apprenticeshipQAStatus : ApprenticeshipQAStatus.InProgress);
var providerUser = await TestData.CreateUser(providerId : provider.ProviderId);
var standard = await TestData.CreateStandard(standardCode : 1234, version : 1, standardName : "Test Standard");
var apprenticeshipId = (await TestData.CreateApprenticeship(provider.ProviderId, standard, createdBy: User.ToUserInfo())).Id;
var submissionId = await TestData.CreateApprenticeshipQASubmission(
provider.ProviderId,
submittedOn : Clock.UtcNow,
submittedByUserId : providerUser.UserId,
providerMarketingInformation : "The overview",
apprenticeshipIds : new[] { apprenticeshipId });
await TestData.UpdateApprenticeshipQASubmission(
submissionId,
providerAssessmentPassed : passed,
apprenticeshipAssessmentsPassed : passed,
passed : passed,
lastAssessedByUserId : User.UserId,
lastAssessedOn : Clock.UtcNow);
await User.AsHelpdesk();
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync($"apprenticeship-qa/{provider.ProviderId}/complete", requestContent);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var doc = await response.GetDocument();
var providerName = doc.GetElementById("pttcd-apprenticeship-qa-complete-provider-name").TextContent.Trim();
Assert.Equal("Provider 1", providerName);
var newStatus = await WithSqlQueryDispatcher(dispatcher => dispatcher.ExecuteQuery(new GetProviderApprenticeshipQAStatus()
{
ProviderId = provider.ProviderId
}));
Assert.Equal(expectedStatus, newStatus);
CosmosDbQueryDispatcher.VerifyExecuteQuery <UpdateApprenticeshipStatus, OneOf <NotFound, Success> >(
q => q.ApprenticeshipId == apprenticeshipId && q.ProviderUkprn == provider.Ukprn && q.Status == 1,
expectApprenticeshipToBeMadeLive ? Times.Once() : Times.Never());
}
private void ResetMocks()
{
CosmosDbQueryDispatcher.Reset();
FindACourseOfferingSearchClient.Reset();
LarsSearchClient.Reset();
RegionCache.Reset();
SqlQueryDispatcher.Reset();
RegionCache.Setup(c => c.GetAllRegions()).ReturnsAsync(Array.Empty <Region>());
}
public async Task Post_ValidRequest_UpdatesDatabaseAndRedirects()
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId)).Id;
var journeyInstance = await CreateJourneyInstance(venueId);
journeyInstance.UpdateState(state =>
{
state.Name = "Updated name";
state.Email = "*****@*****.**";
state.PhoneNumber = "02345 678901";
state.Website = "updated-provider.com";
state.AddressLine1 = "Updated line 1";
state.AddressLine2 = "Updated line 2";
state.Town = "Updated town";
state.County = "Updated county";
state.Postcode = "UP1 D8D";
state.Latitude = 42;
state.Longitude = 42;
});
var requestContent = new FormUrlEncodedContentBuilder()
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Found);
response.Headers.Location.OriginalString.Should().Be($"/venues?providerId={provider.ProviderId}");
CosmosDbQueryDispatcher.VerifyExecuteQuery <UpdateVenue, OneOf <NotFound, Venue> >(q =>
q.VenueId == venueId &&
q.Name == "Updated name" &&
q.Email == "*****@*****.**" &&
q.PhoneNumber == "02345 678901" &&
q.Website == "updated-provider.com" &&
q.AddressLine1 == "Updated line 1" &&
q.AddressLine2 == "Updated line 2" &&
q.Town == "Updated town" &&
q.County == "Updated county" &&
q.Postcode == "UP1 D8D" &&
q.Latitude == 42 &&
q.Longitude == 42 &&
q.UpdatedBy.UserId == User.UserId &&
q.UpdatedDate == Clock.UtcNow);
}
public async Task TLevels_Get_WithTLevels_ReturnsOkWithExpectedTLevelsCollection()
{
var provider1 = CreateProvider(1);
var sqlProvider1 = CreateSqlProvider(provider1);
var provider1FeChoice = CreateFeChoice(1, provider1.Ukprn);
var provider1Venue1 = CreateVenue(1);
var provider1Venue2 = CreateVenue(2);
var provider1TLevelLocation1 = CreateTLevelLocation(1, provider1Venue1.VenueId);
var provider1TLevelLocation2 = CreateTLevelLocation(2, provider1Venue1.VenueId);
var provider1TLevelLocation3 = CreateTLevelLocation(3, provider1Venue2.VenueId);
// Provider1, with one location
var provider1TLevel1 = CreateTLevel(1, provider1, new[] { provider1TLevelLocation1 });
// Provider1, with two locations
var provider1TLevel2 = CreateTLevel(2, provider1, new[] { provider1TLevelLocation2, provider1TLevelLocation3 });
var provider2 = CreateProvider(2);
var sqlProvider2 = CreateSqlProvider(provider2);
var provider2Venue1 = CreateVenue(3);
var provider2TLevelLocation1 = CreateTLevelLocation(4, provider2Venue1.VenueId);
// Provider2, with one location, no FeChoices
var provider2TLevel1 = CreateTLevel(3, provider2, new[] { provider2TLevelLocation1 });
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetTLevels>()))
.ReturnsAsync(new[] { provider1TLevel1, provider1TLevel2, provider2TLevel1 });
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <CosmosQueries.GetProvidersByIds>()))
.ReturnsAsync(new[] { provider1, provider2 }.ToDictionary(p => p.Id, p => p));
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetProvidersByIds>()))
.ReturnsAsync(new[] { sqlProvider1, sqlProvider2 }.ToDictionary(p => p.ProviderId, p => p));
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetVenuesByIds>()))
.ReturnsAsync(new[] { provider1Venue1, provider1Venue2, provider2Venue1 }.ToDictionary(v => v.VenueId, v => v));
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <CosmosQueries.GetFeChoicesByProviderUkprns>()))
.ReturnsAsync(new[] { provider1FeChoice }.ToDictionary(f => f.UKPRN, f => f));
// Act
var response = await HttpClient.GetAsync($"tlevels");
// Assert
response.StatusCode.Should().Be(StatusCodes.Status200OK);
var result = JObject.Parse(await response.Content.ReadAsStringAsync());
result.Should().NotBeNull();
var tLevels = result["tLevels"].ToArray();
tLevels.Should().NotBeNullOrEmpty();
tLevels.Length.Should().Be(3);
AssertHasTLevel(tLevels, provider1, sqlProvider1, new[] { provider1Venue1, provider1Venue2 }, provider1TLevel1, provider1FeChoice);
AssertHasTLevel(tLevels, provider1, sqlProvider1, new[] { provider1Venue1, provider1Venue2 }, provider1TLevel2, provider1FeChoice);
AssertHasTLevel(tLevels, provider2, sqlProvider2, new[] { provider2Venue1 }, provider2TLevel1, null);
public async Task SyncProviderData_ProviderAlreadyExists_UpdatesProviderInfo()
{
// Arrange
const int ukprn = 1234567;
var providerId = await TestData.CreateProvider(
ukprn,
providerName : "Test Provider",
providerType : ProviderType.FE | ProviderType.Apprenticeships,
providerStatus : "Provider deactivated, not verified",
contacts : new[]
{
new CreateProviderContact
{
ContactType = "P",
ContactTelephone1 = "0123456789",
ContactWebsiteAddress = "http://www.example.com",
ContactEmail = "*****@*****.**",
AddressSaonDescription = "SAON Description",
AddressPaonDescription = "PAON Description",
AddressStreetDescription = "Street",
AddressLocality = "Locality",
AddressItems = new[] { "ItemDescription" },
AddressPostTown = "PostTown",
AddressPostCode = "Postcode",
PersonalDetailsFamilyName = "FamilyName",
PersonalDetailsGivenName = "GivenName"
}
});
var ukrlpData = GenerateUkrlpProviderData(ukprn);
var ukrlpContact = ukrlpData.ProviderContact.Single();
var ukrlpSyncHelper = SetupUkrlpSyncHelper(ukprn, ukrlpData);
ICollection <UpdateProviderFromUkrlpData> capturedUpdateCommands = new List <UpdateProviderFromUkrlpData>();
CosmosDbQueryDispatcher.Setup(mock => mock.ExecuteQuery(Capture.In(capturedUpdateCommands)));
// Act
await ukrlpSyncHelper.SyncProviderData(ukprn);
// Assert
var updateCommand = capturedUpdateCommands.Should().ContainSingle().Subject;
updateCommand.Alias.Should().Be(ukrlpData.ProviderAliases.Single().ProviderAlias);
updateCommand.DateUpdated.Should().Be(Clock.UtcNow);
updateCommand.ProviderName.Should().Be(ukrlpData.ProviderName);
updateCommand.ProviderId.Should().Be(providerId);
updateCommand.ProviderStatus.Should().Be(ukrlpData.ProviderStatus);
var actualContact = updateCommand.Contacts.Should().ContainSingle().Subject;
AssertContactMapping(actualContact, ukrlpContact);
}
public async Task Handle_WithCourseIdNotFound_ReturnsNotFound()
{
var courseId = Guid.NewGuid();
var courseRunId = Guid.NewGuid();
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetCourseById>()))
.ReturnsAsync((Course)null);
var result = await HttpClient.GetAsync(CourseRunDetailUrl(courseId, courseRunId));
result.StatusCode.Should().Be(StatusCodes.Status404NotFound);
}
public async Task Post_ValidRequest_DeletesCourseRunAndRedirects()
{
// Arrange
var provider = await TestData.CreateProvider();
var courseId = await TestData.CreateCourse(
provider.ProviderId,
qualificationCourseTitle : "Maths",
createdBy : User.ToUserInfo());
var courseRunId = await GetCourseRunIdForCourse(courseId);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Confirm", "true")
.ToContent();
var request = new HttpRequestMessage(
HttpMethod.Post,
$"/courses/{courseId}/course-runs/{courseRunId}/delete?returnUrl=%2fcourses")
{
Content = requestContent
};
await User.AsProviderUser(provider.ProviderId, ProviderType.FE);
CreateJourneyInstance(courseId, courseRunId);
DeleteCourseRunQuery capturedDeleteCourseRunQuery = null;
CosmosDbQueryDispatcher.Callback <DeleteCourseRunQuery, OneOf <NotFound, Success> >(q => capturedDeleteCourseRunQuery = q);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.Found, response.StatusCode);
Assert.Equal(
$"/courses/{courseId}/course-runs/{courseRunId}/delete/confirmed",
response.Headers.Location.OriginalString);
CosmosDbQueryDispatcher.Verify(d => d.ExecuteQuery(It.IsAny <DeleteCourseRunQuery>()), Times.Once);
using (new AssertionScope())
{
capturedDeleteCourseRunQuery.Should().NotBeNull();
capturedDeleteCourseRunQuery.CourseId.Should().Be(courseId);
capturedDeleteCourseRunQuery.CourseRunId.Should().Be(courseRunId);
capturedDeleteCourseRunQuery.ProviderUkprn.Should().Be(provider.Ukprn);
capturedDeleteCourseRunQuery.UpdatedBy.Should().Be(TestUserInfo.DefaultUserId);
capturedDeleteCourseRunQuery.UpdatedDate.Should().Be(MutableClock.Start);
}
}
public async Task PostConfirmation_ValidRequestWithRegions_CreatesValidApprenticeship()
{
// Arrange
var providerId = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
var standardCode = 123;
var standardVersion = 1;
var standard = await TestData.CreateStandard(standardCode, standardVersion, standardName : "My standard");
await User.AsProviderUser(providerId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetProviderDetails("Provider 1 rocks");
flowModel.SetApprenticeshipStandardOrFramework(standard);
flowModel.SetApprenticeshipDetails(
marketingInformation: "My apprenticeship",
website: "http://provider.com/apprenticeship",
contactTelephone: "01234 5678902",
contactEmail: "*****@*****.**",
contactWebsite: "http://provider.com");
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.EmployerBased);
flowModel.SetApprenticeshipLocationRegionIds(new[]
{
"E06000001", // County Durham
"E10000009" // Dorset
});
var mptxInstance = CreateMptxInstance(flowModel);
Guid apprenticeshipId = default;
CosmosDbQueryDispatcher.Callback <CreateApprenticeship, Success>(q => apprenticeshipId = q.Id);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-confirmation?providerId={providerId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
CosmosDbQueryDispatcher.Verify(mock => mock.ExecuteQuery(It.Is <CreateApprenticeship>(q =>
q.ApprenticeshipLocations.Single().ApprenticeshipLocationType == ApprenticeshipLocationType.EmployerBased &&
q.ApprenticeshipLocations.Single().DeliveryModes.Single() == ApprenticeshipDeliveryMode.EmployerAddress &&
q.ApprenticeshipLocations.Single().National == false &&
q.ApprenticeshipLocations.Single().VenueId == null &&
q.ApprenticeshipLocations.Single().Regions.Contains("E06000001") &&
q.ApprenticeshipLocations.Single().Regions.Contains("E10000009"))));
}
public async Task PostConfirmation_ValidRequestWithVenue_CreatesValidApprenticeship()
{
// Arrange
var providerId = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
var standardCode = 123;
var standardVersion = 1;
var standard = await TestData.CreateStandard(standardCode, standardVersion, standardName : "My standard");
var venueId = await TestData.CreateVenue(providerId);
await User.AsProviderUser(providerId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetProviderDetails("Provider 1 rocks");
flowModel.SetApprenticeshipStandardOrFramework(standard);
flowModel.SetApprenticeshipDetails(
marketingInformation: "My apprenticeship",
website: "http://provider.com/apprenticeship",
contactTelephone: "01234 5678902",
contactEmail: "*****@*****.**",
contactWebsite: "http://provider.com");
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.ClassroomBased);
flowModel.SetClassroomLocationForVenue(
venueId,
originalVenueId: null,
radius: 5,
deliveryModes: new[] { ApprenticeshipDeliveryMode.BlockRelease });
var mptxInstance = CreateMptxInstance(flowModel);
Guid apprenticeshipId = default;
CosmosDbQueryDispatcher.Callback <CreateApprenticeship, Success>(q => apprenticeshipId = q.Id);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-confirmation?providerId={providerId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
CosmosDbQueryDispatcher.Verify(mock => mock.ExecuteQuery(It.Is <CreateApprenticeship>(q =>
q.ApprenticeshipLocations.Single().ApprenticeshipLocationType == ApprenticeshipLocationType.ClassroomBased &&
q.ApprenticeshipLocations.Single().DeliveryModes.Single() == ApprenticeshipDeliveryMode.BlockRelease &&
q.ApprenticeshipLocations.Single().Radius == 5 &&
q.ApprenticeshipLocations.Single().VenueId == venueId)));
}
public async Task Post_MissingClassroomLocations_RendersErrorMessage()
{
// Arrange
var providerId = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
var standardCode = 123;
var standardVersion = 1;
var standard = await TestData.CreateStandard(standardCode, standardVersion, standardName : "My standard");
await User.AsProviderUser(providerId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetProviderDetails("Provider 1 rocks");
flowModel.SetApprenticeshipStandardOrFramework(standard);
flowModel.SetApprenticeshipDetails(
marketingInformation: "My apprenticeship",
website: "http://provider.com/apprenticeship",
contactTelephone: "01234 5678902",
contactEmail: "*****@*****.**",
contactWebsite: "http://provider.com");
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.ClassroomBased);
var mptxInstance = CreateMptxInstance(flowModel);
Guid apprenticeshipId = default;
CosmosDbQueryDispatcher.Callback <CreateApprenticeship, Success>(q => apprenticeshipId = q.Id);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-confirmation?providerId={providerId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var doc = await response.GetDocument();
Assert.NotNull(doc.GetElementsByClassName("govuk-error-summary"));
}
public async Task Post_ValidRequest_DeletesCourseRunAndRedirects()
{
// Arrange
var providerId = await TestData.CreateProvider(ukprn : 12345);
var courseId = await TestData.CreateCourse(
providerId,
qualificationCourseTitle : "Maths",
createdBy : User.ToUserInfo());
var courseRunId = await GetCourseRunIdForCourse(courseId);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Confirm", "true")
.ToContent();
var request = new HttpRequestMessage(
HttpMethod.Post,
$"/courses/{courseId}/course-runs/{courseRunId}/delete?returnUrl=%2fcourses")
{
Content = requestContent
};
await User.AsProviderUser(providerId, ProviderType.FE);
CreateFormFlowInstance(courseId, courseRunId);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.Found, response.StatusCode);
Assert.Equal(
$"/courses/{courseId}/course-runs/{courseRunId}/delete/confirmed",
response.Headers.Location.OriginalString);
CosmosDbQueryDispatcher.VerifyExecuteQuery <DeleteCourseRunQuery, OneOf <NotFound, Success> >(q =>
q.CourseId == courseId && q.CourseRunId == courseRunId && q.ProviderUkprn == 12345);
}
public async Task Post_ValidRequest_UpdatesProviderTypeAndRedirects(ProviderType providerType)
{
// Arrange
var providerId = await TestData.CreateProvider(providerType : ProviderType.Undefined);
var content = new FormUrlEncodedContentBuilder()
.Add("ProviderType", (int)providerType)
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"providers/provider-type?providerId={providerId}")
{
Content = content
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Found);
response.Headers.Location.OriginalString.Should().Be($"/providers?providerId={providerId}");
CosmosDbQueryDispatcher.VerifyExecuteQuery <UpdateProviderType, OneOf <NotFound, Success> >(q =>
q.ProviderId == providerId && q.ProviderType == providerType);
}
public async Task ValidRequest_ReturnsOkWithExpectedOutput()
{
// Arrange
var providerId = Guid.NewGuid();
var providerName = "Test Provider";
var providerUkprn = 123456;
var providerContactEmail = "*****@*****.**";
var providerEmployerSatisfaction = 9m;
var providerLearnerSatisfaction = 10m;
var tLevelDefinitionId = Guid.NewGuid();
var tLevelDefinitionName = "T Level name";
var tLevelDefinitionFrameworkCode = 4;
var tLevelDefinitionProgType = 3;
var tLevelDefinitionQualificationLevel = 5;
var venueId = Guid.NewGuid();
var venueName = "Venue";
var venueAddressLine1 = "Venue address line 1";
var venueAddressLine2 = "Venue address line 2";
var venueTown = "Venue town";
var venueCounty = "Venue county";
var venuePostcode = "AB1 2DE";
var venueTelephone = "01234 567890";
var venueEmail = "*****@*****.**";
var venueWebsite = "exampleprovider.com/venue";
var venueLatitude = 1d;
var venueLongitude = 2d;
var tLevelId = Guid.NewGuid();
var whoFor = "Who for";
var entryRequirements = "Entry requirements";
var whatYoullLearn = "What you'll learn";
var howYoullLearn = "How you'll learn";
var howYoullBeAssessed = "How you'll be assessed";
var whatYouCanDoNext = "What you can do next";
var yourReference = "YOUR-REF";
var startDate = new DateTime(2021, 4, 1);
var website = "http://exampleprovider.com/tlevel";
var tLevelLocationId = Guid.NewGuid();
var now = DateTime.UtcNow;
SqlQueryDispatcher
.Setup(d => d.ExecuteQuery(It.Is <GetTLevel>(q => q.TLevelId == tLevelId)))
.ReturnsAsync(new TLevel()
{
TLevelId = tLevelId,
TLevelStatus = TLevelStatus.Live,
TLevelDefinition = new TLevelDefinition()
{
TLevelDefinitionId = tLevelDefinitionId,
Name = tLevelDefinitionName,
FrameworkCode = tLevelDefinitionFrameworkCode,
ProgType = tLevelDefinitionProgType,
QualificationLevel = tLevelDefinitionQualificationLevel
},
ProviderId = providerId,
ProviderName = providerName,
WhoFor = whoFor,
EntryRequirements = entryRequirements,
WhatYoullLearn = whatYoullLearn,
HowYoullLearn = howYoullLearn,
HowYoullBeAssessed = howYoullBeAssessed,
WhatYouCanDoNext = whatYouCanDoNext,
YourReference = yourReference,
StartDate = startDate,
Locations = new[]
{
new TLevelLocation()
{
TLevelLocationId = tLevelLocationId,
TLevelLocationStatus = TLevelLocationStatus.Live,
VenueId = venueId,
VenueName = venueName
}
},
Website = website,
CreatedOn = now,
UpdatedOn = now
});
SqlQueryDispatcher
.Setup(d => d.ExecuteQuery(It.Is <GetProviderById>(q => q.ProviderId == providerId)))
.ReturnsAsync(new Provider()
{
ProviderId = providerId,
ProviderType = ProviderType.TLevels,
ProviderName = providerName,
Ukprn = providerUkprn
});
SqlQueryDispatcher
.Setup(d => d.ExecuteQuery(It.Is <GetVenuesByIds>(q => q.VenueIds.SingleOrDefault() == venueId)))
.ReturnsAsync(new Dictionary <Guid, Venue>()
{
{
venueId,
new Venue()
{
VenueId = venueId,
VenueName = venueName,
AddressLine1 = venueAddressLine1,
AddressLine2 = venueAddressLine2,
Town = venueTown,
County = venueCounty,
Postcode = venuePostcode,
Telephone = venueTelephone,
Email = venueEmail,
Website = venueWebsite,
Latitude = venueLatitude,
Longitude = venueLongitude
}
}
});
CosmosDbQueryDispatcher
.Setup(d => d.ExecuteQuery(It.Is <Core.DataStore.CosmosDb.Queries.GetProviderById>(q => q.ProviderId == providerId)))
.ReturnsAsync(new Core.DataStore.CosmosDb.Models.Provider()
{
Id = providerId,
UnitedKingdomProviderReferenceNumber = providerUkprn.ToString(),
ProviderType = ProviderType.TLevels,
ProviderContact = new[]
{
new Core.DataStore.CosmosDb.Models.ProviderContact()
{
ContactType = "P", // Primary,
ContactEmail = providerContactEmail
}
},
ProviderAliases = Array.Empty <Core.DataStore.CosmosDb.Models.ProviderAlias>()
});
CosmosDbQueryDispatcher
.Setup(d => d.ExecuteQuery(It.Is <Core.DataStore.CosmosDb.Queries.GetFeChoiceForProvider>(q => q.ProviderUkprn == providerUkprn)))
.ReturnsAsync(new Core.DataStore.CosmosDb.Models.FeChoice()
{
UKPRN = providerUkprn,
Id = Guid.NewGuid(),
EmployerSatisfaction = providerEmployerSatisfaction,
LearnerSatisfaction = providerLearnerSatisfaction,
CreatedDateTimeUtc = now
});
// Act
var response = await HttpClient.GetAsync($"tleveldetail?tlevelid={tLevelId}");
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
var json = JObject.Parse(await response.Content.ReadAsStringAsync());
using (new AssertionScope())
{
json["offeringType"].ToObject <string>().Should().Be("TLevel");
json["tLevelId"].ToObject <string>().Should().Be(tLevelId.ToString());
json["tLevelDefinitionId"].ToObject <string>().Should().Be(tLevelDefinitionId.ToString());
json["qualification"]["frameworkCode"].ToObject <int>().Should().Be(tLevelDefinitionFrameworkCode);
json["qualification"]["progType"].ToObject <int>().Should().Be(tLevelDefinitionProgType);
json["qualification"]["qualificationLevel"].ToObject <string>().Should().Be(tLevelDefinitionQualificationLevel.ToString());
json["qualification"]["tLevelName"].ToObject <string>().Should().Be(tLevelDefinitionName);
json["provider"]["providerName"].ToObject <string>().Should().Be(providerName);
json["provider"]["ukprn"].ToObject <int>().Should().Be(providerUkprn);
json["provider"]["email"].ToObject <string>().Should().Be(providerContactEmail);
json["provider"]["employerSatisfaction"].ToObject <decimal?>().Should().Be(providerEmployerSatisfaction);
json["provider"]["learnerSatisfaction"].ToObject <decimal?>().Should().Be(providerLearnerSatisfaction);
json["whoFor"].ToObject <string>().Should().Be(whoFor);
json["entryRequirements"].ToObject <string>().Should().Be(entryRequirements);
json["whatYoullLearn"].ToObject <string>().Should().Be(whatYoullLearn);
json["howYoullLearn"].ToObject <string>().Should().Be(howYoullLearn);
json["howYoullBeAssessed"].ToObject <string>().Should().Be(howYoullBeAssessed);
json["whatYouCanDoNext"].ToObject <string>().Should().Be(whatYouCanDoNext);
json["website"].ToObject <string>().Should().Be(website);
json["startDate"].ToObject <DateTime>().Should().Be(startDate);
json["deliveryMode"].ToObject <string>().Should().Be("ClassroomBased");
json["attendancePattern"].ToObject <string>().Should().Be("Daytime");
json["studyMode"].ToObject <string>().Should().Be("FullTime");
json["durationUnit"].ToObject <string>().Should().Be("Years");
json["durationValue"].ToObject <int>().Should().Be(2);
json["cost"].ToObject <decimal?>().Should().BeNull();
json["costDescription"].ToObject <string>().Should().Be("T Levels are currently only available to 16-19 year olds. Contact us for details of other suitable courses.");
var location = json["locations"].ToArray().Should().ContainSingle().Subject;
location["tLevelLocationId"].ToObject <string>().Should().Be(tLevelLocationId.ToString());
location["venueName"].ToObject <string>().Should().Be(venueName);
location["addressLine1"].ToObject <string>().Should().Be(venueAddressLine1);
location["addressLine2"].ToObject <string>().Should().Be(venueAddressLine2);
location["town"].ToObject <string>().Should().Be(venueTown);
location["county"].ToObject <string>().Should().Be(venueCounty);
location["postcode"].ToObject <string>().Should().Be(venuePostcode);
location["telephone"].ToObject <string>().Should().Be(venueTelephone);
location["email"].ToObject <string>().Should().Be(venueEmail);
location["website"].ToObject <string>().Should().Be("http://" + venueWebsite);
location["latitude"].ToObject <double>().Should().Be(venueLatitude);
location["longitude"].ToObject <double>().Should().Be(venueLongitude);
}
}
public async Task Handle_WithValidCourseIdAndCourseRunId_ReturnsOkWithResult()
{
var venue = new Venue
{
Id = Guid.NewGuid(),
VenueName = "TestVenueName"
};
var lars = new Core.Search.Models.Lars
{
LearnAimRef = "00112233",
LearnAimRefTitle = "TestLearnAimRefTitle"
};
var courseRun = new CourseRun
{
Id = Guid.NewGuid(),
RecordStatus = CourseStatus.Live,
VenueId = venue.Id
};
var alternativeCourseRun = new CourseRun
{
Id = Guid.NewGuid(),
RecordStatus = CourseStatus.Live,
VenueId = venue.Id
};
var course = new Course
{
Id = Guid.NewGuid(),
ProviderUKPRN = 12345678,
LearnAimRef = lars.LearnAimRef,
CourseRuns = new[]
{
courseRun,
alternativeCourseRun
}
};
var provider = new Provider
{
Id = Guid.NewGuid(),
UnitedKingdomProviderReferenceNumber = "12345678",
ProviderContact = new[]
{
new ProviderContact
{
ContactEmail = "*****@*****.**",
ContactType = "P"
}
}
};
var sqlProvider = new Core.DataStore.Sql.Models.Provider
{
ProviderId = provider.Id,
ProviderName = "TestProviderAlias",
DisplayNameSource = ProviderDisplayNameSource.ProviderName
};
var feChoice = new FeChoice
{
UKPRN = course.ProviderUKPRN,
EmployerSatisfaction = 1.2M,
LearnerSatisfaction = 3.4M
};
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetCourseById>()))
.ReturnsAsync(course);
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetProviderByUkprn>()))
.ReturnsAsync(provider);
LarsSearchClient.Setup(s => s.Search(It.IsAny <LarsLearnAimRefSearchQuery>()))
.ReturnsAsync(new SearchResult <Core.Search.Models.Lars>
{
Items = new[] { new SearchResultItem <Core.Search.Models.Lars> {
Record = lars
} }
});
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetVenuesByProvider>()))
.ReturnsAsync(new[] { venue });
CosmosDbQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <GetFeChoiceForProvider>()))
.ReturnsAsync(feChoice);
SqlQueryDispatcher.Setup(s => s.ExecuteQuery(It.IsAny <Core.DataStore.Sql.Queries.GetProviderById>()))
.ReturnsAsync(sqlProvider);
var result = await HttpClient.GetAsync(CourseRunDetailUrl(course.Id, courseRun.Id));
result.StatusCode.Should().Be(StatusCodes.Status200OK);
var resultJson = JObject.Parse(await result.Content.ReadAsStringAsync());
using (new AssertionScope())
{
resultJson.ToObject <object>().Should().NotBeNull();
resultJson["provider"].ToObject <object>().Should().NotBeNull();
resultJson["provider"]["ukprn"].ToObject <int>().Should().Be(provider.Ukprn);
resultJson["provider"]["providerName"].ToObject <string>().Should().Be(sqlProvider.DisplayName);
resultJson["provider"]["tradingName"].ToObject <string>().Should().Be(sqlProvider.DisplayName);
resultJson["provider"]["email"].ToObject <string>().Should().Be(provider.ProviderContact.Single().ContactEmail);
resultJson["provider"]["learnerSatisfaction"].ToObject <decimal>().Should().Be(feChoice.LearnerSatisfaction);
resultJson["provider"]["employerSatisfaction"].ToObject <decimal>().Should().Be(feChoice.EmployerSatisfaction);
resultJson["course"].ToObject <object>().Should().NotBeNull();
resultJson["course"]["courseId"].ToObject <Guid>().Should().Be(course.Id);
resultJson["venue"].ToObject <object>().Should().NotBeNull();
resultJson["venue"]["venueName"].ToObject <string>().Should().Be(venue.VenueName);
resultJson["qualification"].ToObject <object>().Should().NotBeNull();
resultJson["qualification"]["learnAimRef"].ToObject <string>().Should().Be(lars.LearnAimRef);
resultJson["qualification"]["learnAimRefTitle"].ToObject <string>().Should().Be(lars.LearnAimRefTitle);
resultJson["alternativeCourseRuns"][0]["courseRunId"].ToObject <Guid>().Should().Be(alternativeCourseRun.Id);
resultJson["courseRunId"].ToObject <Guid>().Should().Be(courseRun.Id);
}
}
public async Task Post_ValidRequest_CreatesVenueCompletesJourneyAndRedirects()
{
// Arrange
var provider = await TestData.CreateProvider();
var addressLine1 = "Test Venue line 1";
var addressLine2 = "Test Venue line 2";
var town = "Town";
var county = "County";
var postcode = "AB1 2DE";
var name = "My Venue";
var email = "*****@*****.**";
var telephone = "020 7946 0000";
var website = "example.com";
var latitude = 42M;
var longitude = 43M;
var journeyInstance = CreateJourneyInstance(
provider.ProviderId,
new AddVenueJourneyModel()
{
AddressLine1 = addressLine1,
AddressLine2 = addressLine2,
County = county,
Email = email,
Latitude = latitude,
Longitude = longitude,
Name = name,
AddressIsOutsideOfEngland = false,
Telephone = telephone,
Postcode = postcode,
Town = town,
Website = website,
ValidStages = AddVenueCompletedStages.All
});
var request = new HttpRequestMessage(
HttpMethod.Post,
$"/venues/add/publish?providerId={provider.ProviderId}&ffiid={journeyInstance.InstanceId.UniqueKey}");
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Found);
response.Headers.Location.OriginalString.Should().Be(
$"/venues/add/success?providerId={provider.ProviderId}&ffiid={journeyInstance.InstanceId.UniqueKey}");
GetJourneyInstance <AddVenueJourneyModel>(journeyInstance.InstanceId).Completed.Should().BeTrue();
CosmosDbQueryDispatcher.VerifyExecuteQuery <CreateVenue, Success>(q =>
q.ProviderUkprn == provider.Ukprn &&
q.Name == name &&
q.Email == email &&
q.Telephone == telephone &&
q.Website == website &&
q.AddressLine1 == addressLine1 &&
q.AddressLine2 == addressLine2 &&
q.Town == town &&
q.County == county &&
q.Postcode == postcode &&
q.Latitude == latitude &&
q.Longitude == longitude &&
q.CreatedBy.UserId == User.UserId &&
q.CreatedDate == Clock.UtcNow);
}
public async Task PostConfirmation_ValidRequestWithNationalLocations_CreatesApprenticeshipQASubmissionUpdatesQAStatusAndReturnsConfirmation()
{
// Arrange
var providerId = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
var standardCode = 123;
var standardVersion = 1;
var standard = await TestData.CreateStandard(standardCode, standardVersion, standardName : "My standard");
await User.AsProviderUser(providerId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetProviderDetails("Provider 1 rocks");
flowModel.SetApprenticeshipStandardOrFramework(standard);
flowModel.SetApprenticeshipDetails(
marketingInformation: "My apprenticeship",
website: "http://provider.com/apprenticeship",
contactTelephone: "01234 5678902",
contactEmail: "*****@*****.**",
contactWebsite: "http://provider.com");
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.EmployerBased);
flowModel.SetApprenticeshipIsNational(true);
var mptxInstance = CreateMptxInstance(flowModel);
Guid apprenticeshipId = default;
CosmosDbQueryDispatcher.Callback <CreateApprenticeship, Success>(q => apprenticeshipId = q.Id);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-confirmation?providerId={providerId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
CosmosDbQueryDispatcher.Verify(mock => mock.ExecuteQuery(It.Is <CreateApprenticeship>(q =>
q.ApprenticeshipTitle == "My standard" &&
q.ApprenticeshipType == ApprenticeshipType.StandardCode &&
q.ContactEmail == "*****@*****.**" &&
q.ContactTelephone == "01234 5678902" &&
q.ContactWebsite == "http://provider.com" &&
q.CreatedByUser.UserId == User.UserId &&
q.CreatedDate == Clock.UtcNow &&
q.MarketingInformation == "My apprenticeship" &&
q.ProviderId == providerId &&
q.StandardOrFramework.Standard.StandardCode == standardCode &&
q.StandardOrFramework.Standard.Version == standardVersion &&
q.Url == "http://provider.com/apprenticeship" &&
q.Status == 2)));
SqlQuerySpy.VerifyQuery <CreateApprenticeshipQASubmission, int>(q =>
q.Apprenticeships.Single().ApprenticeshipId == apprenticeshipId &&
q.Apprenticeships.Single().ApprenticeshipMarketingInformation == "My apprenticeship" &&
q.Apprenticeships.Single().ApprenticeshipTitle == "My standard" &&
q.ProviderId == providerId &&
q.ProviderMarketingInformation == "Provider 1 rocks" &&
q.SubmittedByUserId == User.UserId &&
q.SubmittedOn == Clock.UtcNow);
SqlQuerySpy.VerifyQuery <SetProviderApprenticeshipQAStatus, None>(q =>
q.ProviderId == providerId && q.ApprenticeshipQAStatus == ApprenticeshipQAStatus.Submitted);
var doc = await response.GetDocument();
Assert.Equal(
"Quality assurance submitted",
doc.GetElementsByClassName("govuk-panel__title").Single().TextContent.Trim());
}
public async Task PostConfirmation_ValidRequestWithExistingApprenticeshipRegionsAndVenue_UpdatesApprenticeship()
{
// Arrange
var ukprn = 12347;
var providerUserId = $"{ukprn}-user";
var adminUserId = $"admin-user";
var contactTelephone = "1111 111 1111";
var contactWebsite = "https://somerandomprovider.com";
var marketingInfo = "Providing Online training";
var regions = new List <string> {
"123"
};
var standardCode = 123;
var standardVersion = 1;
var providerId = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
var user = await TestData.CreateUser(providerUserId, "*****@*****.**", "Provider 1", "Person", providerId);
var adminUser = await TestData.CreateUser(adminUserId, "*****@*****.**", "admin", "admin", null);
var standard = await TestData.CreateStandard(standardCode, standardVersion, standardName : "My standard");
var apprenticeshipId = await TestData.CreateApprenticeship(providerId,
standard,
createdBy : user,
contactEmail : adminUser.Email,
contactTelephone : contactTelephone,
contactWebsite : contactWebsite,
marketingInformation : marketingInfo,
locations : new[]
{
CreateApprenticeshipLocation.CreateRegions(regions)
});
var venueId = await TestData.CreateVenue(providerId);
await User.AsProviderUser(providerId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetProviderDetails("Provider 1 rocks");
flowModel.SetApprenticeshipStandardOrFramework(standard);
flowModel.SetApprenticeshipDetails(
marketingInformation: "My apprenticeship",
website: "http://provider.com/apprenticeship",
contactTelephone: "01234 5678902",
contactEmail: "*****@*****.**",
contactWebsite: "http://provider.com");
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.ClassroomBasedAndEmployerBased);
flowModel.SetApprenticeshipLocationRegionIds(new[]
{
"E06000001", // County Durham
"E10000009" // Dorset
});
flowModel.SetApprenticeshipId(apprenticeshipId);
flowModel.SetClassroomLocationForVenue(
venueId,
originalVenueId: null,
radius: 5,
deliveryModes: new[] { ApprenticeshipDeliveryMode.BlockRelease });
var mptxInstance = CreateMptxInstance(flowModel);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-confirmation?providerId={providerId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
CosmosDbQueryDispatcher.Verify(mock => mock.ExecuteQuery(It.Is <UpdateApprenticeship>(q =>
q.ApprenticeshipLocations.Any(l =>
l.ApprenticeshipLocationType == ApprenticeshipLocationType.ClassroomBased &&
l.DeliveryModes.Single() == ApprenticeshipDeliveryMode.BlockRelease &&
l.Radius == 5 &&
l.VenueId == venueId) &&
q.ApprenticeshipLocations.Any(l =>
l.ApprenticeshipLocationType == ApprenticeshipLocationType.EmployerBased &&
l.DeliveryModes.Single() == ApprenticeshipDeliveryMode.EmployerAddress &&
l.National == false &&
l.VenueId == null &&
l.Regions.Contains("E06000001") &&
l.Regions.Contains("E10000009")))));
}
