private NextSection AddExpectedChildren(NextSection current, Action <ExpectedChildren> mutator = null)
{
current.Section.Should().Be(Sections.ExpectedChildren);
return(NextSection(current.Section, () => new AddExpectedChildren {
FormId = current.Id, ExpectedChildren = ExpectedChildrenBuilder.NewValid(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 ChangeOfCircsBuilder WithCompletedSections(bool markAsCompleted = true, bool excludeOptionalSections = false)
{
With(f => f.Consent, ConsentBuilder.NewValid());
With(f => f.UserId, "*****@*****.**");
With(f => f.ExistingApplicantDetails, ApplicantDetailsBuilder.NewValid(ad => ad.Address = AddressBuilder.NewValid("existing")));
With(f => f.ExistingPaymentDetails, PaymentDetailsBuilder.NewValid());
With(f => f.Options, OptionsBuilder.NewValid());
if (!excludeOptionalSections)
{
With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid());
With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid());
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());
VerifyConsistent(_instance);
if (!markAsCompleted)
{
With(f => f.Completed, null);
}
return(this);
}
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);
}
protected void ExpectedChildrenShouldBeValid(BestStartGrant form, Action <ExpectedChildren> mutator, Action <ExpectedChildren> postVerify = null)
{
var expectedChildren = ExpectedChildrenBuilder.NewValid(mutator);
ShouldBeValid(() => form.AddExpectedChildren(expectedChildren));
postVerify?.Invoke(expectedChildren);
}
public void Execute_ValidatesExpectedChildren()
{
var cmd = new Validate
{
ExpectedChildren = ExpectedChildrenBuilder.NewValid(m => m.Invalid()),
};
Assert.Throws <DomainException>(() => cmd.Execute());
}
public void Execute_WhenValid_ReturnsTrue()
{
var cmd = new Validate
{
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
HealthProfessional = HealthProfessionalBuilder.NewValid(),
};
var valid = cmd.Execute();
valid.Should().BeTrue();
}
protected static CocDetail NewCocDetail(string formId)
{
var detail = new CocDetail
{
Id = formId,
Consent = ConsentBuilder.NewValid(),
Identity = "*****@*****.**",
Options = OptionsBuilder.NewValid(),
ApplicantDetails = ApplicantDetailsBuilder.NewValid(),
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
HealthProfessional = HealthProfessionalBuilder.NewValid(),
PaymentDetails = PaymentDetailsBuilder.NewValid(),
Evidence = EvidenceBuilder.NewValid(),
Declaration = DeclarationBuilder.NewValid(),
};
return(detail);
}
public void Execute_StoresExpectedChildren()
{
var existingForm = new ChangeOfCircsBuilder("form123")
.Insert();
existingForm.ExpectedChildren.Should().BeNull("no data stored before executing command");
var cmd = new AddExpectedChildren
{
FormId = "form123",
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
};
cmd.Execute();
var updatedForm = Repository.Load <ChangeOfCircs>("form123");
updatedForm.ExpectedChildren.Should().NotBeNull();
updatedForm.ExpectedChildren.ExpectancyDate.Should().Be(cmd.ExpectedChildren.ExpectancyDate);
}
public void Execute_StoresExpectedDetails()
{
var existingForm = new BestStartGrantBuilder("form123")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid())
.Insert();
existingForm.ExpectedChildren.Should().BeNull("no data stored before executing command");
var cmd = new AddExpectedChildren
{
FormId = "form123",
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
};
cmd.Execute();
var updatedForm = Repository.Load <BestStartGrant>("form123");
updatedForm.ExpectedChildren.Should().NotBeNull();
updatedForm.ExpectedChildren.ExpectancyDate.Should().Be(cmd.ExpectedChildren.ExpectancyDate);
}
public void Execute_StoresHealthProfessionalDetails()
{
var existingForm = new BestStartGrantBuilder("form123")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid())
.With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid())
.With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid())
.Insert();
existingForm.HealthProfessional.Should().BeNull("no data stored before executing command");
var cmd = new AddHealthProfessional
{
FormId = "form123",
HealthProfessional = HealthProfessionalBuilder.NewValid(),
};
cmd.Execute();
var updatedForm = Repository.Load <BestStartGrant>("form123");
updatedForm.HealthProfessional.Should().NotBeNull();
updatedForm.HealthProfessional.Pin.Should().Be(cmd.HealthProfessional.Pin);
}
public void RequiresApplicantBenefits_NotRequiredWhenAllChildrenKinshipCare()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid(0))
.Value();
Navigation.RequiresApplicantBenefits(form).Should().BeTrue("should ask for applicant benefits if no existing children with kinship care");
Builder.Modify(form).With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid(3).LastNotKinshipCare());
Navigation.RequiresApplicantBenefits(form).Should().BeTrue("should ask for applicant benefits if not all children in kinship care");
Builder.Modify(form).With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid(3).AllKinshipCare());
Navigation.RequiresApplicantBenefits(form).Should().BeFalse("should not ask for applicant benefits is all children are kinship care");
Builder.Modify(form).With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid(m => { m.ExpectancyDate = null; m.ExpectedBabyCount = 1; }));
Navigation.RequiresApplicantBenefits(form).Should().BeTrue("should not ask for applicant benefits, since an expected child is not expected to be in kinship care");
Builder.Modify(form).With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid(m => { m.ExpectancyDate = TestNowUtc.Value; m.ExpectedBabyCount = null; }));
Navigation.RequiresApplicantBenefits(form).Should().BeTrue("should not ask for applicant benefits, since an expected child is not expected to be in kinship care");
}
protected void ExpectedChildrenShouldBeInvalid(ChangeOfCircs form, Action <ExpectedChildren> mutator)
{
ShouldBeInvalid(() => form.AddExpectedChildren(ExpectedChildrenBuilder.NewValid(mutator)));
}
public void Ineligible_NoChildren()
{
Func <Action <BestStartGrant>, BestStartGrant> form = mutator => new BestStartGrantBuilder("form")
.WithCompletedSections()
.With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid(childCount: 0))
.With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid(ec => ec.NoBabyExpected()))
.Value(mutator);
var lastChildSection = (Sections)Math.Max((int)Sections.ExistingChildren, (int)Sections.ExpectedChildren);
Navigation.IsIneligible(form(f => { }), lastChildSection).Should().BeTrue("not eligible when there are no existing or expected children");
Navigation.IsIneligible(form(f => { }), lastChildSection - 1).Should().BeFalse("ineligibility is not determined until both children sections are complete");
Navigation.IsIneligible(form(f => { }), lastChildSection - 1).Should().BeFalse("ineligibility is not determined until both children sections are complete");
Navigation.IsIneligible(form(f => f.ExpectedChildren.ExpectedBabyCount(1)), lastChildSection).Should().BeFalse("not ineligible if you are due a baby");
Navigation.IsIneligible(form(f => f.ExpectedChildren.ExpectedBabyCount(2)), lastChildSection).Should().BeFalse("not ineligible if you are due a baby");
Navigation.IsIneligible(form(f => f.ExistingChildren.AddChild()), lastChildSection).Should().BeFalse("potentially not ineligible if you have an existing child");
}
protected void ExpectedChildrenShouldBeInvalid(BestStartGrant form, Action <ExpectedChildren> mutator)
{
ShouldBeInvalid(() => form.AddExpectedChildren(ExpectedChildrenBuilder.NewValid(mutator)));
}
