public async Task Build_ShouldUseSpecifiedSuccessPage(EBehaviourType behaviourType)
{
// Arrange
var callBack = new Page();
_mockPageContentFactory
.Setup(_ => _.Build(It.IsAny <Page>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <FormSchema>(), It.IsAny <string>(), It.IsAny <FormAnswers>(), It.IsAny <List <object> >()))
.ReturnsAsync(new FormBuilderViewModel())
.Callback <Page, Dictionary <string, dynamic>, FormSchema, string, FormAnswers, List <object> >((a, b, c, d, e, f) => callBack = a);
_mockPageHelper
.Setup(_ => _.GetPageWithMatchingRenderConditions(It.IsAny <List <Page> >()))
.Returns(Page);
// Act
var result = await _factory.Build(string.Empty, new FormSchema { BaseURL = "base-test", FirstPageSlug = "page-one", Pages = new List <Page> {
new Page {
PageSlug = "success", Elements = new List <IElement> {
new H2()
}
}
} }, string.Empty, new FormAnswers(), behaviourType);
// Assert
_mockPageContentFactory.Verify(_ => _.Build(It.IsAny <Page>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <FormSchema>(), It.IsAny <string>(), It.IsAny <FormAnswers>(), It.IsAny <List <object> >()), Times.Once);
Assert.Equal("Success", result.ViewName);
Assert.Single(callBack.Elements);
Assert.Equal(EElementType.H2, callBack.Elements[0].Type);
}
public async Task <SuccessPageEntity> Process(EBehaviourType behaviourType, string form)
{
var baseForm = await _schemaFactory.Build(form);
if (baseForm.FormActions.Any())
{
await _actionsWorkflow.Process(baseForm.FormActions, baseForm, form);
}
return(await _pageService.FinalisePageJourney(form, behaviourType, baseForm));
}
public async Task <SuccessPageEntity> FinalisePageJourney(string form, EBehaviourType behaviourType, FormSchema baseForm)
{
var sessionGuid = _sessionHelper.GetSessionGuid();
if (string.IsNullOrEmpty(sessionGuid))
{
throw new ApplicationException("PageService::FinalisePageJourney: Session has expired");
}
var formData = _distributedCache.GetString(sessionGuid);
if (formData is null)
{
throw new ApplicationException("PageService::FinalisePageJourney: Session data is null");
}
var formAnswers = JsonConvert.DeserializeObject <FormAnswers>(formData);
var formFileUploadElements = baseForm.Pages.SelectMany(_ => _.Elements)
.Where(_ => _.Type.Equals(EElementType.FileUpload) || _.Type.Equals(EElementType.MultipleFileUpload))
.ToList();
if (formFileUploadElements.Any())
{
formFileUploadElements.ForEach(fileElement =>
{
var formFileAnswerData = formAnswers.Pages.SelectMany(_ => _.Answers).FirstOrDefault(_ => _.QuestionId.Equals($"{fileElement.Properties.QuestionId}{FileUploadConstants.SUFFIX}"))?.Response ?? string.Empty;
List <FileUploadModel> convertedFileUploadAnswer = JsonConvert.DeserializeObject <List <FileUploadModel> >(formFileAnswerData.ToString());
var fileStorageType = _configuration["FileStorageProvider:Type"];
var fileStorageProvider = _fileStorageProviders.Get(fileStorageType);
if (convertedFileUploadAnswer is not null && convertedFileUploadAnswer.Any())
{
convertedFileUploadAnswer.ForEach((_) =>
{
fileStorageProvider.Remove(_.Key);
});
}
});
}
if (baseForm.DocumentDownload)
{
await _distributedCache.SetStringAsync($"document-{sessionGuid}", JsonConvert.SerializeObject(formAnswers), _distributedCacheExpirationConfiguration.Document);
}
return(await _successPageContentFactory.Build(form, baseForm, sessionGuid, formAnswers, behaviourType));
}
public void GetNextPage_ShouldReturn_DefaultBehaviour(EBehaviourType type)
{
// Arrange
var behaviour = new BehaviourBuilder()
.WithBehaviourType(type)
.Build();
var page = new PageBuilder()
.WithBehaviour(behaviour)
.Build();
// Act
var result = page.GetNextPage(new Dictionary <string, dynamic>());
// Assert
Assert.Equal(type, result.BehaviourType);
}
public async Task Build_Should_AddDocumentDownloadButton_WhenDocumentDownloadEnabled(EBehaviourType behaviourType)
{
// Arrange
var callBack = new Page();
var element = new ElementBuilder()
.WithType(EElementType.H2)
.Build();
var page = new PageBuilder()
.WithElement(element)
.WithPageSlug("success")
.Build();
var formSchema = new FormSchemaBuilder()
.WithDocumentDownload(true)
.WithDocumentType(EDocumentType.Txt)
.WithFirstPageSlug("page-one")
.WithBaseUrl("base-test")
.WithPage(page)
.Build();
_mockPageContentFactory
.Setup(_ => _.Build(It.IsAny <Page>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <FormSchema>(), It.IsAny <string>(), It.IsAny <FormAnswers>(), It.IsAny <List <object> >()))
.ReturnsAsync(new FormBuilderViewModel())
.Callback <Page, Dictionary <string, dynamic>, FormSchema, string, FormAnswers, List <object> >((a, b, c, d, e, f) => callBack = a);
_mockPageHelper
.Setup(_ => _.GetPageWithMatchingRenderConditions(It.IsAny <List <Page> >()))
.Returns(formSchema.Pages.FirstOrDefault());
// Act
var result = await _factory.Build(string.Empty, formSchema, string.Empty, new FormAnswers(), behaviourType);
// Assert
Assert.Equal("Success", result.ViewName);
_mockPageContentFactory.Verify(_ => _.Build(It.IsAny <Page>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <FormSchema>(), It.IsAny <string>(), It.IsAny <FormAnswers>(), It.IsAny <List <object> >()), Times.Once);
Assert.Equal(2, callBack.Elements.Count);
Assert.Equal(EElementType.DocumentDownload, callBack.Elements[1].Type);
Assert.Equal($"Download {EDocumentType.Txt} document", callBack.Elements[1].Properties.Label);
}
private List <Behaviour> GetBehavioursByType(EBehaviourType type) => Behaviours.Where(_ => _.BehaviourType == type).ToList();
public BehaviourBuilder WithBehaviourType(EBehaviourType type)
{
_behaviourType = type;
return(this);
}
public async Task RenderAsync_ShouldDisableButton_OnClick_WhenPageHas_SubmitForm_OrSubmitAndPay_Action(EBehaviourType type)
{
//Arrange
var callback = new Button();
_mockIViewRender.Setup(_ => _.RenderAsync(It.IsAny <string>(), It.IsAny <Button>(), It.IsAny <Dictionary <string, dynamic> >()))
.Callback <string, Button, Dictionary <string, dynamic> >((a, b, c) => callback = b);
var element = new ElementBuilder()
.WithType(EElementType.Button)
.WithPropertyText("test text")
.Build();
var behaviour = new BehaviourBuilder()
.WithBehaviourType(type)
.Build();
var page = new PageBuilder()
.WithElement(element)
.WithBehaviour(behaviour)
.Build();
var schema = new FormSchemaBuilder()
.WithName("form-name")
.Build();
var formAnswers = new FormAnswers();
var viewModel = new Dictionary <string, dynamic>();
//Act
await element.RenderAsync(_mockIViewRender.Object, _mockElementHelper.Object, string.Empty, viewModel, page, schema, _mockHostingEnv.Object, formAnswers);
//Assert
Assert.True(callback.Properties.DisableOnClick);
_mockIViewRender.Verify(_ => _.RenderAsync(It.Is <string>(x => x.Equals("Button")), It.IsAny <Button>(), It.IsAny <Dictionary <string, object> >()), Times.Once);
}
public async Task Index_Post_Should_PerformRedirectToAction_WhenPageIsValid_And_SelectJourney_OnBehaviour(string viewName, EBehaviourType behaviourType)
{
// Arrange
var element = new ElementBuilder()
.WithType(EElementType.Address)
.WithQuestionId("test-address")
.WithAddressProvider("testAddressProvider")
.Build();
var behaviour = new BehaviourBuilder()
.WithBehaviourType(behaviourType)
.WithPageSlug("url")
.Build();
var page = new PageBuilder()
.WithElement(element)
.WithPageSlug("page-one")
.WithValidatedModel(true)
.WithBehaviour(behaviour)
.Build();
var viewModel = new ViewModelBuilder()
.WithEntry("Guid", Guid.NewGuid().ToString())
.WithEntry($"{element.Properties.QuestionId}-postcode", "SK11aa")
.Build();
_pageService.Setup(_ => _.ProcessRequest(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <IEnumerable <CustomFormFile> >(), It.IsAny <bool>()))
.ReturnsAsync(new ProcessRequestEntity {
Page = page
});
_pageService.Setup(_ => _.GetBehaviour(It.IsAny <ProcessRequestEntity>())).Returns(new Behaviour {
BehaviourType = behaviourType
});
// Act
var result = await _homeController.Index("form", "page-one", viewModel, null, "automatic");
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal(viewName, viewResult.ActionName);
}
public async Task <SuccessPageEntity> Build(string form, FormSchema baseForm, string sessionGuid, FormAnswers formAnswers, EBehaviourType behaviourType)
{
var page = baseForm.GetPage(_pageHelper, "success");
_distributedCache.Remove(sessionGuid);
_sessionHelper.RemoveSessionGuid();
if (page == null && behaviourType == EBehaviourType.SubmitAndPay)
{
page = GenerateGenericPaymentPage();
baseForm.Pages.Add(page);
}
if (page == null)
{
return(new SuccessPageEntity
{
ViewName = "Submit",
FormAnswers = formAnswers,
CaseReference = formAnswers.CaseReference,
FeedbackFormUrl = baseForm.FeedbackForm,
FeedbackPhase = baseForm.FeedbackPhase,
FormName = baseForm.FormName,
StartPageUrl = baseForm.StartPageUrl
});
}
if (baseForm.DocumentDownload)
{
baseForm.DocumentType.ForEach((docType) =>
{
var element = new ElementBuilder()
.WithType(EElementType.DocumentDownload)
.WithLabel($"Download {docType} document")
.WithSource($"/v2/document/Summary/{docType}/{sessionGuid}")
.WithDocumentType(docType)
.Build();
page.Elements.Add(element);
});
var successIndex = baseForm.Pages.IndexOf(page);
baseForm.Pages[successIndex] = page;
}
var result = await _pageFactory.Build(page, new Dictionary <string, dynamic>(), baseForm, sessionGuid, formAnswers);
return(new SuccessPageEntity
{
HtmlContent = result.RawHTML,
CaseReference = formAnswers.CaseReference,
FeedbackFormUrl = result.FeedbackForm,
FeedbackPhase = result.FeedbackPhase,
FormName = result.FormName,
StartPageUrl = result.StartPageUrl,
PageTitle = result.PageTitle,
BannerTitle = page.BannerTitle,
LeadingParagraph = page.LeadingParagraph,
DisplayBreadcrumbs = page.DisplayBreadCrumbs,
Breadcrumbs = baseForm.BreadCrumbs
});
}
private List <Behaviour> GetBehavioursByType(EBehaviourType type) => Behaviours.Where(_ => _.BehaviourType.Equals(type)).ToList();
public virtual void SetNewBehaviour(EBehaviourType NewBehaviour)
{
behaviourType = NewBehaviour;
}
