private NextSection AddGuardianPartnerBenefits(NextSection current, Action <Benefits> mutator = null)
{
current.Section.Should().Be(Sections.GuardianPartnerBenefits);
return(NextSection(current.Section, () => new AddGuardianPartnerBenefits {
FormId = current.Id, GuardianPartnerBenefits = BenefitsBuilder.NewWithBenefit(mutator)
}.Execute()));
}
protected static BsgDetail NewBsgDetail(string formId, int childCount = 2)
{
var detail = new BsgDetail
{
Id = formId,
Consent = ConsentBuilder.NewValid(),
ApplicantDetails = ApplicantDetailsBuilder.NewValid(),
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
ExistingChildren = ExistingChildrenBuilder.NewValid(childCount),
ApplicantBenefits = BenefitsBuilder.NewWithBenefit(),
PartnerBenefits = BenefitsBuilder.NewWithBenefit(),
GuardianBenefits = BenefitsBuilder.NewWithBenefit(),
GuardianPartnerBenefits = BenefitsBuilder.NewWithBenefit(),
PartnerDetails = RelationDetailsBuilder.NewValid("partner"),
GuardianDetails = RelationDetailsBuilder.NewValid("guardian"),
GuardianPartnerDetails = RelationDetailsBuilder.NewValid("guardian partner"),
HealthProfessional = HealthProfessionalBuilder.NewValid(),
PaymentDetails = PaymentDetailsBuilder.NewValid(),
Evidence = EvidenceBuilder.NewValid(),
Declaration = DeclarationBuilder.NewValid(),
};
return(detail);
}
public BestStartGrantBuilder WithCompletedSections(bool markAsCompleted = true)
{
With(f => f.Consent, ConsentBuilder.NewValid());
With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid());
With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid());
With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid());
With(f => f.ApplicantBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.PartnerBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.GuardianBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.GuardianPartnerBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.PartnerDetails, RelationDetailsBuilder.NewValid("partner"));
With(f => f.GuardianDetails, RelationDetailsBuilder.NewValid("guardian"));
With(f => f.GuardianPartnerDetails, RelationDetailsBuilder.NewValid("guardian partner"));
With(f => f.HealthProfessional, HealthProfessionalBuilder.NewValid());
With(f => f.PaymentDetails, PaymentDetailsBuilder.NewValid());
With(f => f.Evidence, EvidenceBuilder.NewValid());
With(f => f.Declaration, DeclarationBuilder.NewValid());
With(f => f.Started, DomainRegistry.NowUtc() - TimeSpan.FromHours(24));
With(f => f.Completed, DomainRegistry.NowUtc());
With(f => f.UserId, _instance.ApplicantDetails?.EmailAddress);
VerifyConsistent(_instance);
if (!markAsCompleted)
{
With(f => f.Completed, null);
}
return(this);
}
public void RequiresGuardianPartnerBenefits_NotRequiredWhenAnyBenefitsNotRequired()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid().Under25CareLeaver(TestNowUtc.Value))
.With(f => f.GuardianBenefits, BenefitsBuilder.NewNone())
.Value();
Navigation.RequiresGuardianPartnerBenefits(form).Should().BeFalse("should not prompt for benefits when already entitled");
}
public void NextSectionClearsSkippedSections()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid(ad => ad.Under16(TestNowUtc.Value)))
.With(f => f.ApplicantBenefits, BenefitsBuilder.NewWithBenefit())
.With(f => f.Declaration, DeclarationBuilder.NewValid())
.Insert();
form.AddExistingChildren(ExistingChildrenBuilder.NewValid());
form = Repository.Load <BestStartGrant>(form.Id);
form.Declaration.Should().NotBeNull("should not be overwritten by moving to the next section");
form.ApplicantBenefits.Should().BeNull("intermediate 'ApplicantBenefits' section should be cleared based on answers");
}
public void Execute_StoresBenefitsDetails()
{
var existingForm = new BestStartGrantBuilder("form123")
.Insert();
existingForm.GuardianPartnerBenefits.Should().BeNull("no data stored before executing command");
var cmd = new AddGuardianPartnerBenefits
{
FormId = "form123",
GuardianPartnerBenefits = BenefitsBuilder.NewWithBenefit(),
};
cmd.Execute();
var updatedForm = Repository.Load <BestStartGrant>("form123");
updatedForm.GuardianPartnerBenefits.Should().NotBeNull();
updatedForm.GuardianPartnerBenefits.HasIncomeSupport.Should().Be(cmd.GuardianPartnerBenefits.HasIncomeSupport);
}
public void RequiresGuardianPartnerBenefits()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.GuardianBenefits, null)
.Value();
Navigation.RequiresGuardianPartnerBenefits(form).Should().BeFalse("guardian partner benefits not required if guardian benefits not asked");
Builder.Modify(form).With(f => f.GuardianBenefits, BenefitsBuilder.NewWithBenefit());
Navigation.RequiresGuardianPartnerBenefits(form).Should().BeFalse("guardian partner benefits not required if guardian benefits positive");
form.GuardianBenefits.None();
Navigation.RequiresGuardianPartnerBenefits(form).Should().BeTrue("guardian partner benefits required if guardian benefits asked but answered 'no'");
form.GuardianBenefits.Unknown();
Navigation.RequiresGuardianPartnerBenefits(form).Should().BeTrue("guardian partner benefits required if guardian benefits asked but answered 'don't know'");
}
public void RequiresGuardianDetails_FullTimeEducation()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid().PartOfGuardianBenefits(TestNowUtc.Value))
.With(f => f.GuardianBenefits, null)
.Value();
Navigation.RequiresGuardianDetails(form).Should().BeFalse("until guardian benefits are collected, we don't need their details");
Builder.Modify(form).With(f => f.GuardianBenefits, BenefitsBuilder.NewNone());
Navigation.RequiresGuardianDetails(form).Should().BeFalse("guardian details not required if we know they don't have a qualifying benefit");
form.GuardianBenefits.WithBenefit();
Navigation.RequiresGuardianDetails(form).Should().BeTrue("guardian details required if relying on their qualifying benefits");
form.GuardianBenefits.Unknown();
Navigation.RequiresGuardianDetails(form).Should().BeTrue("guardian details required if not sure if relying on their benefits");
}
public void RequiresPartnerDetails()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid().Over25(TestNowUtc.Value))
.With(f => f.ApplicantBenefits, BenefitsBuilder.NewNone())
.With(f => f.PartnerBenefits, null)
.Value();
Navigation.RequiresPartnerBenefits(form).Should().BeTrue("test logic requires that the partner benefits are requested");
Navigation.RequiresPartnerDetails(form).Should().BeFalse("until partner benefits are collected, we don't need their details");
Builder.Modify(form).With(f => f.PartnerBenefits, BenefitsBuilder.NewNone());
Navigation.RequiresPartnerDetails(form).Should().BeFalse("partner details not required if we know they don't have a qualifying benefit");
form.PartnerBenefits.WithBenefit();
Navigation.RequiresPartnerDetails(form).Should().BeTrue("partner details required if relying in their qualifying benefits");
form.PartnerBenefits.Unknown();
Navigation.RequiresPartnerDetails(form).Should().BeTrue("partner details required if not sure if relying on their benefits");
}
public void Ineligible_NoGuardianPartnerBenefits()
{
Func <Action <BestStartGrant>, BestStartGrant> form = mutator => new BestStartGrantBuilder("form")
.WithCompletedSections()
.With(f => f.GuardianBenefits, BenefitsBuilder.NewNone())
.With(f => f.GuardianPartnerBenefits, BenefitsBuilder.NewNone())
.Value(mutator);
var lastBenefitsSection = Sections.GuardianPartnerBenefits;
Navigation.IsIneligible(form(f => { }), lastBenefitsSection).Should().BeTrue("not eligible when guardian's partner has no benefits");
Navigation.IsIneligible(form(f => { }), lastBenefitsSection - 1).Should().BeFalse("ineligibility not determined until both guardian and guardian partner benefits are complete");
Navigation.IsIneligible(form(f => f.GuardianPartnerBenefits.WithBenefit()), lastBenefitsSection).Should().BeFalse("not ineligible if guardian's partner on a benefit");
Navigation.IsIneligible(form(f => f.GuardianBenefits.Unknown()), lastBenefitsSection).Should().BeFalse("cannot assume ineligible if guardian benefit not known");
Navigation.IsIneligible(form(f => f.GuardianPartnerBenefits.Unknown()), lastBenefitsSection).Should().BeFalse("cannot assume ineligible if guardian partner benefit not known");
}
protected void GuardianPartnerBenefitsShouldBeInvalid(BestStartGrant form, Action <Benefits> mutator)
{
ShouldBeInvalid(() => form.AddGuardianPartnerBenefits(BenefitsBuilder.NewWithBenefit(mutator)));
}
public void Construct(BenefitsBuilder benefitsBuilder)
{
benefitsBuilder.BuildAddBenefits();
}
protected void ApplicantBenefitsShouldBeInvalid(BestStartGrant form, Action <Benefits> mutator)
{
ShouldBeInvalid(() => form.AddApplicantBenefits(BenefitsBuilder.NewWithBenefit(mutator)));
}
