public async Task Post_DuplicateName_RendersError()
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId)).Id;
await TestData.CreateVenue(provider.ProviderId, venueName : "Venue B");
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Name", "Venue B")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/name")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var doc = await response.GetDocument();
doc.AssertHasError("Name", "Location name must not already exist");
}
public async Task Post_ValidRequest_UpdatesFormFlowInstanceAndRedirects(string website)
{
// Arrange
var providerId = await TestData.CreateProvider();
var venueId = await TestData.CreateVenue(providerId);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Website", website)
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/website")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Found);
response.Headers.Location.OriginalString.Should().Be($"/venues/{venueId}");
var formFlowInstance = GetFormFlowInstance(venueId);
formFlowInstance.State.Website.Should().Be(website);
}
public async Task Post_ValidRequestUpdatesFlowStateAndRedirects(
ApprenticeshipLocationType locationType,
string expectedRedirect)
{
// Arrange
var provider = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
await User.AsProviderUser(provider.ProviderId, ProviderType.Apprenticeships);
var mptxInstance = CreateMptxInstance(new FlowModel());
var requestContent = new FormUrlEncodedContentBuilder()
.Add("LocationType", locationType.ToString())
.ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-locations?providerId={provider.ProviderId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
var state = GetMptxInstance <FlowModel>(mptxInstance.InstanceId).State;
Assert.Equal(locationType, state.ApprenticeshipLocationType);
Assert.Equal(HttpStatusCode.Found, response.StatusCode);
Assert.StartsWith(expectedRedirect, response.Headers.Location.OriginalString);
}
public async Task DeleteVenue_Post_WithProviderContextProviderIdNotEqualToPostProviderId_ReturnsBadRequest()
{
// 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), Guid.NewGuid())
.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.Status400BadRequest);
}
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 Post_ProviderUser_ReturnsForbidden()
{
// Arrange
var provider = await TestData.CreateProvider(
providerType : ProviderType.FE | ProviderType.Apprenticeships,
providerName : "Provider name",
alias : "Trading name");
var content = new FormUrlEncodedContentBuilder()
.Add("DisplayNameSource", "TradingName")
.ToContent();
var request = new HttpRequestMessage(
HttpMethod.Post,
$"providers/display-name?providerId={provider.ProviderId}")
{
Content = content
};
await User.AsProviderUser(provider.ProviderId, ProviderType.FE | ProviderType.Apprenticeships);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
public async Task DeleteVenue_Post_WithMismatchedProvider_ReturnsForbidden(TestUserType userType)
{
// Arrange
var provider1 = await TestData.CreateProvider(providerType : ProviderType.FE);
var provider2 = await TestData.CreateProvider(providerType : ProviderType.FE);
var venue = await TestData.CreateVenue(provider1.ProviderId);
await User.AsTestUser(userType, provider2.ProviderId);
var requestContent = new FormUrlEncodedContentBuilder()
.Add(nameof(Command.Confirm), true)
.Add(nameof(Command.ProviderId), provider1)
.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.Status403Forbidden);
}
public async Task Post_ValidRequest_UpdatesJourneyInstanceAndRedirects(string phoneNumber)
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId)).Id;
var requestContent = new FormUrlEncodedContentBuilder()
.Add("PhoneNumber", phoneNumber)
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/phone-number")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Found);
response.Headers.Location.OriginalString.Should().Be($"/venues/{venueId}");
var journeyInstance = GetJourneyInstance(venueId);
journeyInstance.State.PhoneNumber.Should().Be(phoneNumber);
}
public async Task Post_UserCannotAccessVenue_ReturnsForbidden(TestUserType userType)
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId)).Id;
var anotherProvider = await TestData.CreateProvider();
var requestContent = new FormUrlEncodedContentBuilder()
.Add("PhoneNumber", "020 7946 0000")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/phone-number")
{
Content = requestContent
};
await User.AsTestUser(userType, anotherProvider.ProviderId);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task Post_NotConfirmed_ReturnsError()
{
// Arrange
var providerId = await TestData.CreateProvider();
var courseId = await TestData.CreateCourse(providerId, createdBy : User.ToUserInfo());
var courseRunId = await GetCourseRunIdForCourse(courseId);
var requestContent = new FormUrlEncodedContentBuilder()
.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
var doc = await response.GetDocument();
doc.AssertHasError("Confirm", "Confirm you want to delete the course");
}
public async Task Post_InvalidPhoneNumber_RendersError()
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId)).Id;
var requestContent = new FormUrlEncodedContentBuilder()
.Add("PhoneNumber", "xxx")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/phone-number")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var doc = await response.GetDocument();
doc.AssertHasError("PhoneNumber", "Enter a telephone number in the correct format");
}
public async Task Post_UserCannotAccessCourse_ReturnsForbidden(TestUserType userType)
{
// Arrange
var anotherProviderId = await TestData.CreateProvider(ukprn : 23456);
var providerId = await TestData.CreateProvider(ukprn : 12345);
var courseId = await TestData.CreateCourse(providerId, 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.AsTestUser(userType, anotherProviderId);
CreateFormFlowInstance(courseId, courseRunId);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
public async Task Post_CourseRunDoesNotExist_ReturnsNotFound()
{
// Arrange
var providerId = await TestData.CreateProvider();
var courseId = await TestData.CreateCourse(providerId, createdBy : User.ToUserInfo());
var courseRunId = Guid.NewGuid();
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.NotFound, response.StatusCode);
}
public async Task Post_CourseDoesNotExist_ReturnsNotFound()
{
// Arrange
var tLevelDefinitions = await TestData.CreateInitialTLevelDefinitions();
var provider = await TestData.CreateProvider(
providerType : ProviderType.TLevels,
tLevelDefinitionIds : tLevelDefinitions.Select(tld => tld.TLevelDefinitionId).ToArray());
var tLevelId = Guid.NewGuid();
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Confirm", "true")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"/t-levels/{tLevelId}/delete")
{
Content = requestContent
};
CreateJourneyInstance(tLevelId);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public async Task PostRemove_ModeNotEdit_ReturnsBadRequest()
{
// Arrange
var provider = await TestData.CreateProvider(providerType : ProviderType.Apprenticeships);
var parentMptxInstance = MptxManager.CreateInstance(new ParentFlow());
var childMptxInstance = MptxManager.CreateInstance <FlowModel, IFlowModelCallback>(
parentMptxInstance.InstanceId,
FlowModel.Add(provider.ProviderId, cancelable: true),
new Dictionary <string, object>()
{
{ "ReturnUrl", "callback" }
});
await User.AsProviderUser(provider.ProviderId, ProviderType.Apprenticeships);
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync(
$"apprenticeships/remove-classroom-location?ffiid={childMptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
/// <summary>
/// 单条发送
/// 一次发送一条短信，常用于短信验证、找回密码、短信登录、监控报警
/// </summary>
/// <param name="sms"></param>
/// <returns></returns>
public async Task <SmsResult> Send(SingleSendSms sms)
{
const string apiUrl = "https://sms.yunpian.com/v2/sms/single_send.json";
Check.NotNull(sms, nameof(sms));
Check.NotNullOrWhiteSpace(sms.Mobile, nameof(sms.Mobile));
Check.NotNullOrWhiteSpace(sms.Text, nameof(sms.Text));
var content = new FormUrlEncodedContentBuilder
{
{
"apikey", _yunPianConfiguration.ApiKey
},
{
"mobile", sms.Mobile
},
{
"text", sms.Text
}
};
ApplySendOption(content, sms.Option);
return((await new ApiHttpClient().PostAsync <SendResultItem>(apiUrl, content)).ToSmsResult());
}
public async Task Post_MissingVenueId_RendersErrorMessage()
{
// Arrange
var provider = await TestData.CreateProvider(providerType : ProviderType.Apprenticeships);
var parentMptxInstance = MptxManager.CreateInstance(new ParentFlow());
var childMptxInstance = MptxManager.CreateInstance <FlowModel, IFlowModelCallback>(
parentMptxInstance.InstanceId,
FlowModel.Add(provider.ProviderId, cancelable: true),
new Dictionary <string, object>()
{
{ "ReturnUrl", "callback" }
});
await User.AsProviderUser(provider.ProviderId, ProviderType.Apprenticeships);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Radius", 15)
.Add("DeliveryModes", ApprenticeshipDeliveryMode.DayRelease)
.Add("DeliveryModes", ApprenticeshipDeliveryMode.BlockRelease)
.ToContent();
// Act
var response = await HttpClient.PostAsync(
$"/apprenticeships/classroom-location?ffiid={childMptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var doc = await response.GetDocument();
doc.AssertHasError("VenueId", "Select the location");
}
/// <summary>
/// 批量发送不同内容
/// 批量发送短信内容带变量的订单状态通知，活动信息群发
/// </summary>
/// <param name="sms"></param>
/// <returns></returns>
public async Task <SmsResult> Send(MultiSendSms sms)
{
const string apiUrl = "https://sms.yunpian.com/v2/sms/multi_send.json";
Check.NotNull(sms, nameof(sms));
Check.NotNullOrEmpty(sms.Mobile, nameof(sms.Mobile));
Check.NotNullOrEmpty(sms.Text, nameof(sms.Text));
var content = new FormUrlEncodedContentBuilder
{
{
"apikey", _yunPianConfiguration.ApiKey
},
{
"mobile", string.Join(",", sms.Mobile)
},
{
"text", string.Join(",", sms.Text)
}
};
ApplySendOption(content, sms.Option);
return(await new ApiHttpClient().PostAsync <SmsResult>(apiUrl, content));
}
public async Task Post_ValidRequest_UpdatesDisplayNameSourceAndRedirects()
{
// Arrange
var provider = await TestData.CreateProvider(
providerName : "Provider name",
alias : "Trading name");
var content = new FormUrlEncodedContentBuilder()
.Add("DisplayNameSource", "TradingName")
.ToContent();
var request = new HttpRequestMessage(
HttpMethod.Post,
$"providers/display-name?providerId={provider.ProviderId}")
{
Content = content
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.Found, response.StatusCode);
Assert.Equal($"/providers?providerId={provider.ProviderId}", response.Headers.Location.OriginalString);
SqlQuerySpy.VerifyQuery <SetProviderDisplayNameSource, OneOf <NotFound, Success> >(q =>
q.ProviderId == provider.ProviderId && q.DisplayNameSource == ProviderDisplayNameSource.TradingName);
}
public async Task Post_InvalidWebsite_RendersError()
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId, createdBy: User.ToUserInfo())).VenueId;
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Website", ":bad/website")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/website")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var doc = await response.GetDocument();
doc.AssertHasErrorWithCode("Website", "VENUE_WEBSITE_FORMAT");
}
public async Task DeleteVenue_Post_WithConfirmNotTrue_ReturnsExpectedOutputWithError(bool?confirm)
{
// 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), confirm)
.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.Status400BadRequest);
var doc = await response.GetDocument();
doc.GetElementByTestId("confirm-error-message").TextContent.Should().Be("Confirm you want to delete the location");
}
public async Task Post_SubmissionOutcomeNotKnownReturnsBadRequest()
{
// Arrange
var ukprn = 12345;
var providerId = await TestData.CreateProvider(
ukprn : ukprn,
providerName : "Provider 1",
apprenticeshipQAStatus : ApprenticeshipQAStatus.InProgress);
var providerUserId = $"{ukprn}-user";
await TestData.CreateUser(providerUserId, "*****@*****.**", "Provider 1", "Person", providerId);
var standard = await TestData.CreateStandard(standardCode : 1234, version : 1, standardName : "Test Standard");
var apprenticeshipId = await TestData.CreateApprenticeship(providerId, standard, createdBy : User.ToUserInfo());
await TestData.CreateApprenticeshipQASubmission(
providerId,
submittedOn : Clock.UtcNow,
submittedByUserId : providerUserId,
providerMarketingInformation : "The overview",
apprenticeshipIds : new[] { apprenticeshipId });
await User.AsHelpdesk();
var requestContent = new FormUrlEncodedContentBuilder().ToContent();
// Act
var response = await HttpClient.PostAsync($"apprenticeship-qa/{providerId}/complete", requestContent);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task DeleteVenue_Post_WithExistingCourse_RendersExpectedOutputWithErrorMessageAndDeleteDisabled()
{
// Arrange
var provider = await TestData.CreateProvider(
providerType : ProviderType.FE);
await User.AsTestUser(TestUserType.ProviderUser, provider.ProviderId);
var venue = await TestData.CreateVenue(provider.ProviderId);
var courseId = await TestData.CreateCourse(provider.ProviderId, User.ToUserInfo(), configureCourseRuns : builder =>
builder.WithCourseRun(CourseDeliveryMode.ClassroomBased, CourseStudyMode.FullTime, CourseAttendancePattern.Daytime, venueId: venue.Id));
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.Status400BadRequest);
var doc = await response.GetDocument();
Assert.Null(doc.GetElementByTestId("delete-location-button"));
Assert.NotNull(doc.GetElementByTestId($"affected-course-{courseId}"));
doc.GetElementByTestId("affected-courses-error-message").TextContent.Should().Be("The affected courses have changed");
}
public async Task Post_NotApprenticeshipProviderReturnsForbidden()
{
// Arrange
var provider = await TestData.CreateProvider(
apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted,
providerType : ProviderType.FE);
await User.AsProviderUser(provider.ProviderId, ProviderType.FE);
var flowModel = new FlowModel();
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.EmployerBased);
flowModel.SetApprenticeshipIsNational(false);
var mptxInstance = CreateMptxInstance(flowModel);
var regions = await RegionCache.GetAllRegions();
var subRegion1Id = regions.First().SubRegions.First().Id;
var subRegion2Id = regions.Skip(1).First().SubRegions.First().Id;
var requestContent = new FormUrlEncodedContentBuilder()
.Add("RegionIds", subRegion1Id)
.Add("RegionIds", subRegion2Id)
.ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-employer-locations-regions?providerId={provider.ProviderId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
public async Task Post_InvalidWebsite_RendersError()
{
// Arrange
var providerId = await TestData.CreateProvider();
var venueId = await TestData.CreateVenue(providerId);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Website", ":bad/website")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/website")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var doc = await response.GetDocument();
doc.AssertHasError("Website", "Enter a website in the correct format");
}
public async Task Post_InvalidRegionIdRendersError()
{
// Arrange
var provider = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
await User.AsProviderUser(provider.ProviderId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.EmployerBased);
flowModel.SetApprenticeshipIsNational(false);
var mptxInstance = CreateMptxInstance(flowModel);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("RegionIds", "bad-region-id")
.ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-employer-locations-regions?providerId={provider.ProviderId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var doc = await response.GetDocument();
var errorSummary = doc.GetElementsByClassName("govuk-error-summary__list").First();
Assert.Contains(
errorSummary.GetElementsByTagName("a"),
e => e.TextContent.Trim() == "Select at least one sub-region");
}
public async Task Post_UserCannotAccessVenue_ReturnsForbidden(TestUserType userType)
{
// Arrange
var providerId = await TestData.CreateProvider(ukprn : 12345);
var venueId = await TestData.CreateVenue(providerId);
var anotherProviderId = await TestData.CreateProvider(ukprn : 67890);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Website", "new-provider.com")
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/website")
{
Content = requestContent
};
await User.AsTestUser(userType, anotherProviderId);
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
public async Task Post_RegionIdSpecifiedStoresExpandedSubRegionsInState()
{
// Arrange
var provider = await TestData.CreateProvider(apprenticeshipQAStatus : ApprenticeshipQAStatus.NotStarted);
await User.AsProviderUser(provider.ProviderId, ProviderType.Apprenticeships);
var flowModel = new FlowModel();
flowModel.SetApprenticeshipLocationType(ApprenticeshipLocationType.EmployerBased);
flowModel.SetApprenticeshipIsNational(false);
var mptxInstance = CreateMptxInstance(flowModel);
var requestContent = new FormUrlEncodedContentBuilder()
.Add("RegionIds", "E12000001")
.ToContent();
// Act
var response = await HttpClient.PostAsync(
$"new-apprenticeship-provider/apprenticeship-employer-locations-regions?providerId={provider.ProviderId}&ffiid={mptxInstance.InstanceId}",
requestContent);
// Assert
var regions = await RegionCache.GetAllRegions();
var region = regions.Single(r => r.Id == "E12000001");
var state = GetMptxInstance <FlowModel>(mptxInstance.InstanceId).State;
Assert.All(region.SubRegions, sr => state.ApprenticeshipLocationSubRegionIds.Contains(sr.Id));
}
public async Task Date(string day, string month, string year, string expectedErrorMessage)
{
// Arrange
var content = new FormUrlEncodedContentBuilder()
.Add("DateOfBirth.Day", day)
.Add("DateOfBirth.Month", month)
.Add("DateOfBirth.Year", year)
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, "ValidatorBaseTests")
{
Content = content
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.EnsureSuccessStatusCode();
var json = JObject.Parse(await response.Content.ReadAsStringAsync());
var errors = (JArray)json["errors"];
var error = Assert.Single(errors);
Assert.Equal("DateOfBirth", error.SelectToken("propertyName").ToString());
Assert.Equal(expectedErrorMessage, error.SelectToken("errorMessage").ToString());
}
public async Task Post_NameTooLong_RendersError()
{
// Arrange
var provider = await TestData.CreateProvider();
var venueId = (await TestData.CreateVenue(provider.ProviderId)).Id;
var requestContent = new FormUrlEncodedContentBuilder()
.Add("Name", new string('x', 251)) // limit is 250
.ToContent();
var request = new HttpRequestMessage(HttpMethod.Post, $"venues/{venueId}/name")
{
Content = requestContent
};
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var doc = await response.GetDocument();
doc.AssertHasError("Name", "Location name must be 250 characters or fewer");
}
