/// <summary>
/// Creates an instance of a data proxy which bind a given household member to a given household.
/// </summary>
/// <returns>Instance of a data proxy which bind a given household member to a given household.</returns>
private IMemberOfHouseholdProxy CreateSut(Guid identifier, IHouseholdMember householdMember, IHousehold household, DateTime creationTime)
{
return(new MemberOfHouseholdProxy(householdMember, household, creationTime)
{
Identifier = identifier
});
}
/// <summary>
/// Gets the household data for one of the current user households.
/// </summary>
/// <param name="householdMember">Household member on which to get household data for one of the households.</param>
/// <param name="query">Query for getting household data for one of the current user households.</param>
/// <param name="translationInfo">Translation informations which can be used for translation.</param>
/// <returns>Household.</returns>
public override IHousehold GetData(IHouseholdMember householdMember, HouseholdDataGetQuery query, ITranslationInfo translationInfo)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
if (query == null)
{
throw new ArgumentNullException("query");
}
if (translationInfo == null)
{
throw new ArgumentNullException("translationInfo");
}
var household = householdMember.Households.SingleOrDefault(m => m.Identifier.HasValue && m.Identifier.Value == query.HouseholdIdentifier);
if (household == null)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IdentifierUnknownToSystem, query.HouseholdIdentifier));
}
household.Translate(translationInfo.CultureInfo, false);
return(household);
}
public void TestThatModifyDataCallsHouseholdMemberRemoveWithHouseholdMemberForMailAddressOnHousehold()
{
HouseholdRemoveHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHousehold householdMock = DomainObjectMockBuilder.BuildHouseholdMock();
Assert.That(householdMock, Is.Not.Null);
Assert.That(householdMock.HouseholdMembers, Is.Not.Null);
Assert.That(householdMock.HouseholdMembers, Is.Not.Empty);
IHouseholdMember householdMemberMock = householdMock.HouseholdMembers.ElementAt(_random.Next(0, householdMock.HouseholdMembers.Count() - 1));
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.MailAddress, Is.Not.Null);
Assert.That(householdMemberMock.MailAddress, Is.Not.Empty);
HouseholdRemoveHouseholdMemberCommand householdRemoveHouseholdMemberCommand = _fixture.Build <HouseholdRemoveHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, householdMemberMock.MailAddress)
.Create();
sut.ModifyData(householdMock, householdRemoveHouseholdMemberCommand);
householdMock.AssertWasCalled(m => m.HouseholdMemberRemove(Arg <IHouseholdMember> .Is.Equal(householdMemberMock)), opt => opt.Repeat.Once());
}
public void TestThatGetDataCallsTranslateOnHouseholdForHouseholdIdentifier()
{
HouseholdDataGetQueryHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
IHousehold householdMock = householdMemberMock.Households.FirstOrDefault();
Assert.That(householdMock, Is.Not.Null);
// ReSharper disable PossibleInvalidOperationException
Guid householdIdentifier = householdMock.Identifier.Value;
// ReSharper restore PossibleInvalidOperationException
HouseholdDataGetQuery householdDataGetQuery = BuildHouseholdDataGetQuery(householdIdentifier);
ITranslationInfo translationInfoMock = DomainObjectMockBuilder.BuildTranslationInfoMock();
sut.GetData(householdMemberMock, householdDataGetQuery, translationInfoMock);
householdMock.AssertWasCalled(m => m.Translate(Arg <CultureInfo> .Is.Equal(translationInfoMock.CultureInfo), Arg <bool> .Is.Equal(false), Arg <bool> .Is.Equal(true)), opt => opt.Repeat.Once());
}
public void TestThatGetDataReturnsHouseholdForHouseholdIdentifier()
{
HouseholdDataGetQueryHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
IHousehold householdMock = householdMemberMock.Households.FirstOrDefault();
Assert.That(householdMock, Is.Not.Null);
// ReSharper disable PossibleInvalidOperationException
Guid householdIdentifier = householdMock.Identifier.Value;
// ReSharper restore PossibleInvalidOperationException
HouseholdDataGetQuery householdDataGetQuery = BuildHouseholdDataGetQuery(householdIdentifier);
IHousehold result = sut.GetData(householdMemberMock, householdDataGetQuery, DomainObjectMockBuilder.BuildTranslationInfoMock());
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(householdMock));
}
/// <summary>
/// Adds validation rules for the command for upgrading the membership on the current users household member account.
/// </summary>
/// <param name="householdMember">Household member on which the membership should be upgraded.</param>
/// <param name="command">Command for upgrading the membership on the current users household member account.</param>
/// <param name="specification">Specification which encapsulates validation rules.</param>
public override void AddValidationRules(IHouseholdMember householdMember, HouseholdMemberUpgradeMembershipCommand command, ISpecification specification)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
if (command == null)
{
throw new ArgumentNullException("command");
}
if (specification == null)
{
throw new ArgumentNullException("specification");
}
var currentMembership = householdMember.Membership;
specification.IsSatisfiedBy(() => CommonValidations.HasValue(command.Membership), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "Membership")))
.IsSatisfiedBy(() => CommonValidations.IsLegalEnumValue(command.Membership, new List <Membership> {
Membership.Deluxe, Membership.Premium
}), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyIsInvalid, command.Membership, "Membership")))
.IsSatisfiedBy(() => _domainObjectValidations.CanUpgradeMembership(currentMembership, (Membership)Enum.Parse(typeof(Membership), command.Membership)), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.MembershipCannotDowngrade)))
.IsSatisfiedBy(() => CommonValidations.IsDateTimeInPast(command.PaymentTime), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.DateTimeValueForPropertyIsNotInPast, "PaymentTime")))
.IsSatisfiedBy(() => CommonValidations.HasValue(command.PaymentReference), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "PaymentReference")))
.IsSatisfiedBy(() => CommonValidations.IsLengthValid(command.PaymentReference, 1, 128), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.LengthForPropertyIsInvalid, "PaymentReference", 1, 128)))
.IsSatisfiedBy(() => CommonValidations.ContainsIllegalChar(command.PaymentReference) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "PaymentReference")));
}
/// <summary>
/// Build a mockup for a household.
/// </summary>
/// <returns>Mockup for a household.</returns>
public static IHousehold BuildHouseholdMock(Guid?householdIdentifier = null, IHouseholdMember householdMember = null)
{
IHousehold householdMock = MockRepository.GenerateMock <IHousehold>();
householdMock.Stub(m => m.Identifier)
.Return(householdIdentifier ?? Guid.NewGuid())
.Repeat.Any();
householdMock.Stub(m => m.Name)
.Return(Fixture.Create <string>())
.Repeat.Any();
householdMock.Stub(m => m.Description)
.Return(Fixture.Create <string>())
.Repeat.Any();
householdMock.Stub(m => m.CreationTime)
.Return(DateTime.Today)
.Repeat.Any();
householdMock.Stub(m => m.HouseholdMembers)
.Return(new List <IHouseholdMember> {
householdMember ?? BuildHouseholdMemberMock()
})
.Repeat.Any();
householdMock.Stub(m => m.Storages)
.Return(BuildStorageMockCollection(householdMock))
.Repeat.Any();
return(householdMock);
}
public void TestThatModifyDataCallsIsNullWithHouseholdMemberOnCommonValidationsWhenHouseholdDoesHaveHouseholdMemberWithMailAddress()
{
ITranslationInfo translationInfoMock = DomainObjectMockBuilder.BuildTranslationInfoMock();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(translationInfoMock);
Assert.That(sut, Is.Not.Null);
IHousehold householdMock = DomainObjectMockBuilder.BuildHouseholdMock();
Assert.That(householdMock, Is.Not.Null);
Assert.That(householdMock.HouseholdMembers, Is.Not.Null);
Assert.That(householdMock.HouseholdMembers, Is.Not.Empty);
IHouseholdMember householdMemberMock = householdMock.HouseholdMembers.ElementAt(_random.Next(0, householdMock.HouseholdMembers.Count() - 1));
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.MailAddress, Is.Not.Null);
Assert.That(householdMemberMock.MailAddress, Is.Not.Empty);
string mailAddress = householdMemberMock.MailAddress;
Assert.That(householdMock.HouseholdMembers.Any(householdMember => string.Compare(householdMember.MailAddress, mailAddress, StringComparison.OrdinalIgnoreCase) == 0), Is.True);
HouseholdAddHouseholdMemberCommand householdAddHouseholdMemberCommand = _fixture.Build <HouseholdAddHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, mailAddress)
.With(m => m.TranslationInfoIdentifier, Guid.NewGuid())
.Create();
sut.ModifyData(householdMock, householdAddHouseholdMemberCommand);
_commonValidationsMock.AssertWasCalled(m => m.IsNull(Arg <IHouseholdMember> .Is.Equal(householdMemberMock)), opt => opt.Repeat.Once());
}
/// <summary>
/// Upgrade membership on the current users household member account.
/// </summary>
/// <param name="householdMember">Household member on which the membership should be upgraded.</param>
/// <param name="command">Command for upgrading the membership on the current users household member account.</param>
/// <returns>Household member with the upgraded membership.</returns>
public override IIdentifiable ModifyData(IHouseholdMember householdMember, HouseholdMemberUpgradeMembershipCommand command)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
if (command == null)
{
throw new ArgumentNullException("command");
}
var dataProvider = HouseholdDataRepository.Get <IDataProvider>(command.DataProviderIdentifier);
var handlesPayments = dataProvider != null && dataProvider.HandlesPayments;
Specification.IsSatisfiedBy(() => CommonValidations.IsNotNull(dataProvider), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IdentifierUnknownToSystem, command.DataProviderIdentifier)))
.IsSatisfiedBy(() => handlesPayments, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.DataProviderDoesNotHandlesPayments, dataProvider != null ? dataProvider.Name : null)))
.Evaluate();
var paymentReceipt = string.IsNullOrWhiteSpace(command.PaymentReceipt) ? null : Convert.FromBase64String(command.PaymentReceipt);
var insertedPayment = HouseholdDataRepository.Insert <IPayment>(new Payment(householdMember, dataProvider, command.PaymentTime, command.PaymentReference, paymentReceipt));
try
{
householdMember.PaymentAdd(insertedPayment);
householdMember.MembershipApply((Membership)Enum.Parse(typeof(Membership), command.Membership));
return(HouseholdDataRepository.Update(householdMember));
}
catch
{
HouseholdDataRepository.Delete(insertedPayment);
throw;
}
}
public void TestThatModifyDataCallsIsNotNullWithHouseholdOnCommonValidations()
{
MyHouseholdDataModificationCommandHandler <MyHouseholdDataModificationCommand> sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
IHousehold householdMock = householdMemberMock.Households.FirstOrDefault();
Assert.IsNotNull(householdMock);
MyHouseholdDataModificationCommand command = _fixture.Build <MyHouseholdDataModificationCommand>()
// ReSharper disable PossibleInvalidOperationException
.With(m => m.HouseholdIdentifier, householdMock.Identifier.Value)
// ReSharper restore PossibleInvalidOperationException
.Create();
sut.ModifyData(householdMemberMock, command);
_commonValidationsMock.AssertWasCalled(m => m.IsNotNull(Arg <IHousehold> .Is.Equal(householdMock)), opt => opt.Repeat.Once());
}
/// <summary>
/// Functionality which can handle a query for getting some data for a household member.
/// </summary>
/// <param name="query">Query for getting some data for a household member.</param>
/// <returns>View of the selected data.</returns>
public virtual TView Query(TQuery query)
{
ArgumentNullGuard.NotNull(query, nameof(query));
ITranslationInfo translationInfo = GetTranslationInfo(query);
IHouseholdMember householdMember = HouseholdDataRepository.HouseholdMemberGetByMailAddress(ClaimValueProvider.MailAddress);
if (householdMember == null)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberNotCreated));
}
if (ShouldBeActivated && householdMember.IsActivated == false)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberNotActivated));
}
if (ShouldHaveAcceptedPrivacyPolicy && householdMember.IsPrivacyPolicyAccepted == false)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberHasNotAcceptedPrivacyPolicy));
}
if (householdMember.HasRequiredMembership(RequiredMembership) == false)
{
throw new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberHasNotRequiredMembership));
}
TData data = GetData(householdMember, query, translationInfo);
return(ObjectMapper.Map <TData, TView>(data, translationInfo?.CultureInfo));
}
public void TestThatModifyDataCallsModifyDataWithHousehold()
{
MyHouseholdDataModificationCommandHandler <MyHouseholdDataModificationCommand> sut = CreateSut();
Assert.That(sut, Is.Not.Null);
Assert.That(sut.ModifyDataIsCalled, Is.False);
Assert.That(sut.HandledHousehold, Is.Null);
Assert.That(sut.HandledCommand, Is.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
IHousehold householdMock = householdMemberMock.Households.FirstOrDefault();
Assert.That(householdMock, Is.Not.Null);
MyHouseholdDataModificationCommand command = _fixture.Build <MyHouseholdDataModificationCommand>()
// ReSharper disable PossibleInvalidOperationException
.With(m => m.HouseholdIdentifier, householdMock.Identifier.Value)
// ReSharper restore PossibleInvalidOperationException
.Create();
sut.ModifyData(householdMemberMock, command);
Assert.That(sut.ModifyDataIsCalled, Is.True);
Assert.That(sut.HandledHousehold, Is.Not.Null);
Assert.That(sut.HandledHousehold, Is.EqualTo(householdMock));
Assert.That(sut.HandledCommand, Is.Not.Null);
Assert.That(sut.HandledCommand, Is.EqualTo(command));
}
/// <summary>
/// Gets the data which indicates whether the household member has been activated.
/// </summary>
/// <param name="householdMember">Household member.</param>
/// <param name="query">Query which can check whether the current user has been activated.</param>
/// <param name="translationInfo">Translation informations which can be used for translation.</param>
/// <returns>Data which indicates whether the household member has been activated.</returns>
public override bool GetData(IHouseholdMember householdMember, HouseholdMemberIsActivatedQuery query, ITranslationInfo translationInfo)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
return(householdMember.IsActivated);
}
/// <summary>
/// Creates a ata proxy which bind a given household member to a given household.
/// </summary>
/// <param name="householdMember">Household member which are member of the household.</param>
/// <param name="household">Household which the household member are member of.</param>
/// <param name="creationTime">Date and time for when the membership to the household was created.</param>
public MemberOfHouseholdProxy(IHouseholdMember householdMember, IHousehold household, DateTime creationTime)
{
ArgumentNullGuard.NotNull(householdMember, nameof(householdMember))
.NotNull(household, nameof(household));
HouseholdMember = householdMember;
Household = household;
CreationTime = creationTime;
}
/// <summary>
/// Removes a household member from this household.
/// </summary>
/// <param name="householdMember">Household member which should be removed as a member of this household.</param>
/// <returns>Household member who has been removed af member of this household.</returns>
public override IHouseholdMember HouseholdMemberRemove(IHouseholdMember householdMember)
{
IHouseholdMember householdMemberToRemove = base.HouseholdMemberRemove(householdMember);
if (householdMemberToRemove != null)
{
_removedHouseholdMemberCollection.Add(householdMemberToRemove);
}
return(householdMemberToRemove);
}
public void TestThatHouseholdMemberGetByMailAddressReturnsNullWhenHouseholdMemberWasNotFoundByFoodWasteDataProvider()
{
IHouseholdDataRepository sut = CreateSut(new List <HouseholdMemberProxy>(0));
Assert.That(sut, Is.Not.Null);
IHouseholdMember result = sut.HouseholdMemberGetByMailAddress(_fixture.Create <string>());
Assert.That(result, Is.Null);
}
/// <summary>
/// Activate the current users household member account.
/// </summary>
/// <param name="householdMember">Household member which should be activated.</param>
/// <param name="command">Command for activating the current users household member account.</param>
/// <returns>The activated household member.</returns>
public override IIdentifiable ModifyData(IHouseholdMember householdMember, HouseholdMemberActivateCommand command)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
householdMember.ActivationTime = DateTime.Now;
return(HouseholdDataRepository.Update(householdMember));
}
/// <summary>
/// Modifies the data.
/// </summary>
/// <param name="householdMember">Household member for which to modify data.</param>
/// <param name="command">Command for modifying some data on a given household on the current household member.</param>
/// <returns>An identifiable domain object in the food waste domain.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="householdMember"/> or <paramref name="command"/> is null.</exception>
public override IIdentifiable ModifyData(IHouseholdMember householdMember, TCommand command)
{
ArgumentNullGuard.NotNull(householdMember, nameof(householdMember))
.NotNull(command, nameof(command));
IHousehold household = householdMember.Households.SingleOrDefault(m => m.Identifier.HasValue && m.Identifier.Value == command.HouseholdIdentifier);
Specification.IsSatisfiedBy(() => CommonValidations.IsNotNull(household), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IdentifierUnknownToSystem, command.HouseholdIdentifier)))
.Evaluate();
return(ModifyData(household, command));
}
/// <summary>
/// Adds merge fields and values to the fields and values which can be merged.
/// </summary>
/// <param name="householdMember">Household member on which merge fields and values should be added.</param>
/// <param name="translationInfo">Translation informations used to translate the merge values.</param>
public virtual void AddMergeFields(IHouseholdMember householdMember, ITranslationInfo translationInfo)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
if (translationInfo == null)
{
throw new ArgumentNullException("translationInfo");
}
_mergeFields.Add("[ActivationCode]", householdMember.ActivationCode);
}
/// <summary>
/// Modifies the data.
/// </summary>
/// <param name="household">Household on which to modify data.</param>
/// <param name="command">Command for removing a household member from a given household on the current users household account.</param>
/// <returns>The updated household.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="household"/> or <paramref name="command"/> is null.</exception>
public override IIdentifiable ModifyData(IHousehold household, HouseholdRemoveHouseholdMemberCommand command)
{
ArgumentNullGuard.NotNull(household, nameof(household))
.NotNull(command, nameof(command));
IHouseholdMember householdMemberForMailAddress = household.HouseholdMembers.SingleOrDefault(householdMember => string.Compare(householdMember.MailAddress, command.MailAddress, StringComparison.OrdinalIgnoreCase) == 0);
Specification.IsSatisfiedBy(() => CommonValidations.IsNotNull(householdMemberForMailAddress), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberDoesNotExistOnHousehold, command.MailAddress)))
.Evaluate();
household.HouseholdMemberRemove(householdMemberForMailAddress);
return(HouseholdDataRepository.Update(household));
}
public void TestThatHouseholdMemberGetByMailAddressReturnsHouseholdMemberWhenHouseholdMemberWasFoundByFoodWasteDataProvider()
{
HouseholdMemberProxy householdMemberProxy = new HouseholdMemberProxy();
IHouseholdDataRepository sut = CreateSut(new List <HouseholdMemberProxy> {
householdMemberProxy
});
Assert.That(sut, Is.Not.Null);
IHouseholdMember result = sut.HouseholdMemberGetByMailAddress(_fixture.Create <string>());
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(householdMemberProxy));
}
/// <summary>
/// Adds validation rules for the command which can accept privacy policy on the current users household member account.
/// </summary>
/// <param name="householdMember">Household member which should accecpt the privacy policy.</param>
/// <param name="command">Command for accepting privacy policy on the current users household member account.</param>
/// <param name="specification">Specification which encapsulates validation rules.</param>
public override void AddValidationRules(IHouseholdMember householdMember, HouseholdMemberAcceptPrivacyPolicyCommand command, ISpecification specification)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
if (command == null)
{
throw new ArgumentNullException("command");
}
if (specification == null)
{
throw new ArgumentNullException("specification");
}
}
/// <summary>
/// Adds validation rules for the command which can activate the current users household member account.
/// </summary>
/// <param name="householdMember">Household member which should be activated.</param>
/// <param name="command">Command for activating the current users household member account.</param>
/// <param name="specification">Specification which encapsulates validation rules.</param>
public override void AddValidationRules(IHouseholdMember householdMember, HouseholdMemberActivateCommand command, ISpecification specification)
{
if (householdMember == null)
{
throw new ArgumentNullException("householdMember");
}
if (command == null)
{
throw new ArgumentNullException("command");
}
if (specification == null)
{
throw new ArgumentNullException("specification");
}
specification.IsSatisfiedBy(() => CommonValidations.HasValue(command.ActivationCode), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "ActivationCode")))
.IsSatisfiedBy(() => CommonValidations.IsLengthValid(command.ActivationCode, 1, 64), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.LengthForPropertyIsInvalid, "ActivationCode", 1, 64)))
.IsSatisfiedBy(() => CommonValidations.ContainsIllegalChar(command.ActivationCode) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "ActivationCode")))
.IsSatisfiedBy(() => CommonValidations.Equals(command.ActivationCode, householdMember.ActivationCode), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.WrongActivationCodeForHouseholdMember)));
}
/// <summary>
/// Executes the functionality which can handle a command for modifying some data on a household member.
/// </summary>
/// <param name="command">Command for modifying some data on a household member.</param>
/// <returns>Service receipt.</returns>
public virtual ServiceReceiptResponse Execute(TCommand command)
{
ArgumentNullGuard.NotNull(command, nameof(command));
IHouseholdMember householdMember = HouseholdDataRepository.HouseholdMemberGetByMailAddress(ClaimValueProvider.MailAddress);
Specification.IsSatisfiedBy(() => CommonValidations.IsNotNull(householdMember), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberNotCreated)))
.IsSatisfiedBy(() => ShouldBeActivated == false || householdMember.IsActivated, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberNotActivated)))
.IsSatisfiedBy(() => ShouldHaveAcceptedPrivacyPolicy == false || householdMember.IsPrivacyPolicyAccepted, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberHasNotAcceptedPrivacyPolicy)))
.IsSatisfiedBy(() => householdMember.HasRequiredMembership(RequiredMembership), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.HouseholdMemberHasNotRequiredMembership)))
.Evaluate();
AddValidationRules(householdMember, command, Specification);
Specification.Evaluate();
IIdentifiable identifiableDomainObject = ModifyData(householdMember, command);
return(ObjectMapper.Map <IIdentifiable, ServiceReceiptResponse>(identifiableDomainObject));
}
public void TestThatModifyDataCallsHouseholdMemberAddWithHouseholdMemberForMailAddressOnHouseholdWhenHouseholdMemberForMailAddressExists()
{
IHouseholdMember householdMemberForMailAddressMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(householdMemberForMailAddress: householdMemberForMailAddressMock);
Assert.That(sut, Is.Not.Null);
IHousehold householdMock = DomainObjectMockBuilder.BuildHouseholdMock();
HouseholdAddHouseholdMemberCommand householdAddHouseholdMemberCommand = _fixture.Build <HouseholdAddHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, _fixture.Create <string>())
.With(m => m.TranslationInfoIdentifier, Guid.NewGuid())
.Create();
sut.ModifyData(householdMock, householdAddHouseholdMemberCommand);
householdMock.AssertWasCalled(m => m.HouseholdMemberAdd(Arg <IHouseholdMember> .Is.Equal(householdMemberForMailAddressMock)), opt => opt.Repeat.Once());
}
public void TestThatGetDataCallsHouseholdsOnHouseholdMember()
{
HouseholdDataGetQueryHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
// ReSharper disable PossibleInvalidOperationException
Guid householdIdentifier = householdMemberMock.Households.First().Identifier.Value;
// ReSharper restore PossibleInvalidOperationException
HouseholdDataGetQuery householdDataGetQuery = BuildHouseholdDataGetQuery(householdIdentifier);
sut.GetData(householdMemberMock, householdDataGetQuery, DomainObjectMockBuilder.BuildTranslationInfoMock());
householdMemberMock.AssertWasCalled(m => m.Households, opt => opt.Repeat.Times(3 + 1)); // Tree times in the unit test and one time in the query handler.
}
public void TestThatModifyDataCallsEvaluateOnSpecification()
{
MyHouseholdDataModificationCommandHandler <MyHouseholdDataModificationCommand> sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
MyHouseholdDataModificationCommand command = _fixture.Build <MyHouseholdDataModificationCommand>()
// ReSharper disable PossibleInvalidOperationException
.With(m => m.HouseholdIdentifier, householdMemberMock.Households.First().Identifier.Value)
// ReSharper restore PossibleInvalidOperationException
.Create();
sut.ModifyData(householdMemberMock, command);
_specificationMock.AssertWasCalled(m => m.Evaluate(), opt => opt.Repeat.Once());
}
public void TestThatModifyDataCallsHouseholdsOnHouseholdMember()
{
MyHouseholdDataModificationCommandHandler <MyHouseholdDataModificationCommand> sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
MyHouseholdDataModificationCommand command = _fixture.Build <MyHouseholdDataModificationCommand>()
// ReSharper disable PossibleInvalidOperationException
.With(m => m.HouseholdIdentifier, householdMemberMock.Households.First().Identifier.Value)
// ReSharper restore PossibleInvalidOperationException
.Create();
sut.ModifyData(householdMemberMock, command);
householdMemberMock.AssertWasCalled(m => m.Households, opt => opt.Repeat.Times(4)); // Tree times in the test and one time in AddValidationRules.
}
public void TestThatAddValidationRulesCallsIsSatisfiedByOnSpecification1Time()
{
MyHouseholdDataModificationCommandHandler <MyHouseholdDataModificationCommand> sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
MyHouseholdDataModificationCommand command = _fixture.Build <MyHouseholdDataModificationCommand>()
// ReSharper disable PossibleInvalidOperationException
.With(m => m.HouseholdIdentifier, householdMemberMock.Households.First().Identifier.Value)
// ReSharper restore PossibleInvalidOperationException
.Create();
sut.AddValidationRules(householdMemberMock, command, _specificationMock);
_specificationMock.AssertWasCalled(m => m.IsSatisfiedBy(Arg <Func <bool> > .Is.NotNull, Arg <IntranetBusinessException> .Is.NotNull), opt => opt.Repeat.Once());
}
public void TestThatGetDataThrowsIntranetBusinessExceptionWhenHouseholdIdentifierDoesNotExistOnHouseholdMember()
{
HouseholdDataGetQueryHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHouseholdMember householdMemberMock = DomainObjectMockBuilder.BuildHouseholdMemberMock();
Assert.That(householdMemberMock, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Null);
Assert.That(householdMemberMock.Households, Is.Not.Empty);
Guid householdIdentifier = Guid.NewGuid();
Assert.That(householdMemberMock.Households.Any(household => household.Identifier.HasValue && household.Identifier.Value == householdIdentifier), Is.False);
HouseholdDataGetQuery householdDataGetQuery = BuildHouseholdDataGetQuery(householdIdentifier);
IntranetBusinessException result = Assert.Throws <IntranetBusinessException>(() => sut.GetData(householdMemberMock, householdDataGetQuery, DomainObjectMockBuilder.BuildTranslationInfoMock()));
TestHelper.AssertIntranetBusinessExceptionIsValid(result, ExceptionMessage.IdentifierUnknownToSystem, householdIdentifier);
}
