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());
}
public void TestThatHouseholdAddHouseholdMemberThrowsFaultExceptionWhenHouseholdMemberHasNotBeenCreated()
{
var client = _channelFactory.CreateChannel();
try
{
IList <TranslationInfoSystemView> translationInfoCollection = GetTranslationInfoCollection(client);
Assert.That(translationInfoCollection, Is.Not.Null);
Assert.That(translationInfoCollection, Is.Not.Empty);
foreach (var translationInfo in translationInfoCollection)
{
HouseholdAddHouseholdMemberCommand householdAddHouseholdMemberCommand = new HouseholdAddHouseholdMemberCommand
{
HouseholdIdentifier = Guid.NewGuid(),
MailAddress = $"test.{Guid.NewGuid().ToString("D").ToLower()}@osdevgrp.dk",
TranslationInfoIdentifier = translationInfo.TranslationInfoIdentifier
};
FaultException <FoodWasteFault> faultException = Assert.Throws <FaultException <FoodWasteFault> >(() => client.HouseholdAddHouseholdMember(householdAddHouseholdMemberCommand));
TestHelper.AssertFaultExceptionWithFoodWasteFault(faultException, FoodWasteFaultType.BusinessFault, SoapNamespaces.FoodWasteHouseholdDataServiceName, "HouseholdAddHouseholdMember", ExceptionMessage.HouseholdMemberNotCreated);
}
}
finally
{
ChannelTools.CloseChannel(client);
}
}
public virtual ServiceReceiptResponse HouseholdAddHouseholdMember(HouseholdAddHouseholdMemberCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
try
{
return(_commandBus.Publish <HouseholdAddHouseholdMemberCommand, ServiceReceiptResponse>(command));
}
catch (Exception ex)
{
throw _foodWasteFaultExceptionBuilder.Build(ex, SoapNamespaces.FoodWasteHouseholdDataServiceName, MethodBase.GetCurrentMethod());
}
}
public void TestThatAddValidationRulesDoesNotCallsEvaluateOnSpecification()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
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.AddValidationRules(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand, _specificationMock);
_specificationMock.AssertWasNotCalled(m => m.Evaluate());
}
public void TestThatModifyDataCallsEvaluateOnSpecification()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
_specificationMock.AssertWasCalled(m => m.Evaluate(), opt => opt.Repeat.Once());
}
public void TestThatModifyDataDoesNotCallGetForAnyHouseholdMemberOnHouseholdDataRepositoryWhenHouseholdMemberForMailAddressExists()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
_householdDataRepositoryMock.AssertWasNotCalled(m => m.Get <IHouseholdMember>(Arg <Guid> .Is.Anything));
}
public void TestThatAddValidationRulesCallsMailAddressOnClaimValueProvider()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
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.AddValidationRules(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand, _specificationMock);
_claimValueProviderMock.AssertWasCalled(m => m.MailAddress, opt => opt.Repeat.Once());
}
public void TestThatModifyDataCallsIsSatisfiedByOnSpecification2Times()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
_specificationMock.AssertWasCalled(m => m.IsSatisfiedBy(Arg <Func <bool> > .Is.NotNull, Arg <IntranetBusinessException> .Is.TypeOf), opt => opt.Repeat.Times(2));
}
public void TestThatAddValidationRulesCallsIsMailAddressWithMailAddressOnDomainObjectValidations()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
string mailAddress = _fixture.Create <string>();
HouseholdAddHouseholdMemberCommand householdAddHouseholdMemberCommand = _fixture.Build <HouseholdAddHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, mailAddress)
.With(m => m.TranslationInfoIdentifier, Guid.NewGuid())
.Create();
sut.AddValidationRules(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand, _specificationMock);
_domainObjectValidationsMock.AssertWasCalled(m => m.IsMailAddress(Arg <string> .Is.Equal(mailAddress)), opt => opt.Repeat.Once());
}
public void TestThatModifyDataCallsHouseholdMemberGetByMailAddressOnHouseholdDataRepository()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
string mailAddress = _fixture.Create <string>();
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
_householdDataRepositoryMock.AssertWasCalled(m => m.HouseholdMemberGetByMailAddress(Arg <string> .Is.Equal(mailAddress)), opt => opt.Repeat.Once());
}
public void TestThatModifyDataCallsGetWithIdentifierForCreatedHouseholdMemberOnHouseholdDataRepositoryWhenHouseholdMemberForMailAddressDoesNotExist()
{
Guid createdHouseholdMemberIdentifier = Guid.NewGuid();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(knownMailAddress: false, createdHouseholdMemberIdentifier: createdHouseholdMemberIdentifier);
Assert.That(sut, Is.Not.Null);
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
_householdDataRepositoryMock.AssertWasCalled(m => m.Get <IHouseholdMember>(Arg <Guid> .Is.Equal(createdHouseholdMemberIdentifier)), opt => opt.Repeat.Once());
}
public void TestThatModifyDataCallsIsNotNullWithTranslationInfoOnCommonValidations()
{
ITranslationInfo translationInfoMock = DomainObjectMockBuilder.BuildTranslationInfoMock();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(translationInfoMock);
Assert.That(sut, Is.Not.Null);
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
_commonValidationsMock.AssertWasCalled(m => m.IsNotNull(Arg <ITranslationInfo> .Is.Equal(translationInfoMock)), opt => opt.Repeat.Once());
}
public void TestThatModifyDataReturnsResultFromUpdateCalledWithHouseholdOnHouseholdDataRepository()
{
IHousehold updatedHouseholdMock = DomainObjectMockBuilder.BuildHouseholdMock();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(updatedHousehold: updatedHouseholdMock);
Assert.That(sut, Is.Not.Null);
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();
IIdentifiable result = sut.ModifyData(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(updatedHouseholdMock));
}
public void TestThatAddValidationRulesCallsEqualsWithMailAddressAndCurrentUserMailAddressOnCommonValidations()
{
string currentUserMailAddress = _fixture.Create <string>();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(currentUserMailAddress: currentUserMailAddress);
Assert.That(sut, Is.Not.Null);
string mailAddress = _fixture.Create <string>();
HouseholdAddHouseholdMemberCommand householdAddHouseholdMemberCommand = _fixture.Build <HouseholdAddHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, mailAddress)
.With(m => m.TranslationInfoIdentifier, Guid.NewGuid())
.Create();
sut.AddValidationRules(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand, _specificationMock);
_commonValidationsMock.AssertWasCalled(m => m.Equals(Arg <string> .Is.Equal(mailAddress), Arg <string> .Is.Equal(currentUserMailAddress), Arg <StringComparison> .Is.Equal(StringComparison.OrdinalIgnoreCase)), opt => opt.Repeat.Once());
}
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 TestThatModifyDataCallsHouseholdMemberAddOnLogicExecutorWhenHouseholdMemberForMailAddressDoesNotExist()
{
ITranslationInfo translationInfoMock = DomainObjectMockBuilder.BuildTranslationInfoMock();
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut(translationInfoMock, false);
Assert.That(sut, Is.Not.Null);
string mailAddress = _fixture.Create <string>();
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(DomainObjectMockBuilder.BuildHouseholdMock(), householdAddHouseholdMemberCommand);
// ReSharper disable PossibleInvalidOperationException
_logicExecutorMock.AssertWasCalled(m => m.HouseholdMemberAdd(Arg <string> .Is.Equal(mailAddress), Arg <Guid> .Is.Equal(translationInfoMock.Identifier.Value)), opt => opt.Repeat.Once());
// ReSharper restore PossibleInvalidOperationException
}
public void TestHouseholdCreationFlow()
{
var fixture = new Fixture();
using (var executor = new ClaimsPrincipalTestExecutor())
{
var translationInfoCollection = _householdDataService.TranslationInfoGetAll(new TranslationInfoCollectionGetQuery());
Assert.That(translationInfoCollection, Is.Not.Null);
Assert.That(translationInfoCollection, Is.Not.Empty);
var translationInfoIdentifier = translationInfoCollection.Take(1).First().TranslationInfoIdentifier;
var householdAddCommand = new HouseholdAddCommand
{
Name = fixture.Create <string>(),
Description = fixture.Create <string>(),
TranslationInfoIdentifier = translationInfoIdentifier
};
var householdAdd = _householdDataService.HouseholdAdd(householdAddCommand);
try
{
Assert.That(householdAdd, Is.Not.Null);
Assert.That(householdAdd.Identifier, Is.Not.Null);
Assert.That(householdAdd.Identifier.HasValue, Is.True);
// ReSharper disable PossibleInvalidOperationException
var householdIdentifier = householdAdd.Identifier.Value;
// ReSharper restore PossibleInvalidOperationException
Assert.That(householdIdentifier, Is.Not.EqualTo(default(Guid)));
var householdMemberIsCreated = _householdDataService.HouseholdMemberIsCreated(new HouseholdMemberIsCreatedQuery());
Assert.That(householdMemberIsCreated, Is.Not.Null);
Assert.That(householdMemberIsCreated.Result, Is.True);
var householdMemberIsActivated = _householdDataService.HouseholdMemberIsActivated(new HouseholdMemberIsActivatedQuery());
Assert.That(householdMemberIsActivated, Is.Not.Null);
Assert.That(householdMemberIsActivated.Result, Is.False);
var currentMailAddress = executor.MailAddress;
var householdMemberActivateCommand = new HouseholdMemberActivateCommand
{
ActivationCode = _householdDataRepository.HouseholdMemberGetByMailAddress(currentMailAddress).ActivationCode
};
var householdMemberActivate = _householdDataService.HouseholdMemberActivate(householdMemberActivateCommand);
Assert.That(householdMemberActivate, Is.Not.Null);
Assert.That(householdMemberActivate.Identifier, Is.Not.Null);
Assert.That(householdMemberActivate.Identifier.HasValue, Is.True);
householdMemberIsActivated = _householdDataService.HouseholdMemberIsActivated(new HouseholdMemberIsActivatedQuery());
Assert.That(householdMemberIsActivated, Is.Not.Null);
Assert.That(householdMemberIsActivated.Result, Is.True);
var householdMemberHasAcceptedPrivacyPolicy = _householdDataService.HouseholdMemberHasAcceptedPrivacyPolicy(new HouseholdMemberHasAcceptedPrivacyPolicyQuery());
Assert.That(householdMemberHasAcceptedPrivacyPolicy, Is.Not.Null);
Assert.That(householdMemberHasAcceptedPrivacyPolicy.Result, Is.False);
var householdMemberAcceptPrivacyPolicy = _householdDataService.HouseholdMemberAcceptPrivacyPolicy(new HouseholdMemberAcceptPrivacyPolicyCommand());
Assert.That(householdMemberAcceptPrivacyPolicy, Is.Not.Null);
Assert.That(householdMemberAcceptPrivacyPolicy.Identifier, Is.Not.Null);
Assert.That(householdMemberAcceptPrivacyPolicy.Identifier.HasValue, Is.True);
householdMemberHasAcceptedPrivacyPolicy = _householdDataService.HouseholdMemberHasAcceptedPrivacyPolicy(new HouseholdMemberHasAcceptedPrivacyPolicyQuery());
Assert.That(householdMemberHasAcceptedPrivacyPolicy, Is.Not.Null);
Assert.That(householdMemberHasAcceptedPrivacyPolicy.Result, Is.True);
var householdDataGetQuery = new HouseholdDataGetQuery
{
HouseholdIdentifier = householdIdentifier,
TranslationInfoIdentifier = translationInfoIdentifier
};
var householdData = _householdDataService.HouseholdDataGet(householdDataGetQuery);
Assert.That(householdData, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.EqualTo(householdIdentifier));
Assert.That(householdData.Name, Is.Not.Null);
Assert.That(householdData.Name, Is.Not.Empty);
Assert.That(householdData.Name, Is.EqualTo(householdAddCommand.Name));
Assert.That(householdData.Description, Is.Not.Null);
Assert.That(householdData.Description, Is.Not.Empty);
Assert.That(householdData.Description, Is.EqualTo(householdAddCommand.Description));
Assert.That(householdData.CreationTime, Is.EqualTo(DateTime.Now).Within(5).Seconds);
Assert.That(householdData.HouseholdMembers, Is.Not.Null);
Assert.That(householdData.HouseholdMembers, Is.Not.Empty);
Assert.That(householdData.HouseholdMembers.Count(), Is.EqualTo(1));
Assert.That(householdData.HouseholdMembers.SingleOrDefault(householdMember => string.Compare(householdMember.MailAddress, currentMailAddress, StringComparison.Ordinal) == 0), Is.Not.Null);
var householdUpdateCommand = new HouseholdUpdateCommand
{
HouseholdIdentifier = householdIdentifier,
Name = fixture.Create <string>(),
Description = fixture.Create <string>()
};
var householdUpdate = _householdDataService.HouseholdUpdate(householdUpdateCommand);
Assert.That(householdUpdate, Is.Not.Null);
Assert.That(householdUpdate.Identifier, Is.Not.Null);
Assert.That(householdUpdate.Identifier.HasValue, Is.True);
// ReSharper disable PossibleInvalidOperationException
Assert.That(householdUpdate.Identifier.Value, Is.EqualTo(householdIdentifier));
// ReSharper restore PossibleInvalidOperationException
householdData = _householdDataService.HouseholdDataGet(householdDataGetQuery);
Assert.That(householdData, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.EqualTo(householdIdentifier));
Assert.That(householdData.Name, Is.Not.Null);
Assert.That(householdData.Name, Is.Not.Empty);
Assert.That(householdData.Name, Is.EqualTo(householdUpdateCommand.Name));
Assert.That(householdData.Description, Is.Not.Null);
Assert.That(householdData.Description, Is.Not.Empty);
Assert.That(householdData.Description, Is.EqualTo(householdUpdateCommand.Description));
householdUpdateCommand = new HouseholdUpdateCommand
{
HouseholdIdentifier = householdIdentifier,
Name = fixture.Create <string>(),
Description = null
};
householdUpdate = _householdDataService.HouseholdUpdate(householdUpdateCommand);
Assert.That(householdUpdate, Is.Not.Null);
Assert.That(householdUpdate.Identifier, Is.Not.Null);
Assert.That(householdUpdate.Identifier.HasValue, Is.True);
// ReSharper disable PossibleInvalidOperationException
Assert.That(householdUpdate.Identifier.Value, Is.EqualTo(householdIdentifier));
// ReSharper restore PossibleInvalidOperationException
householdData = _householdDataService.HouseholdDataGet(householdDataGetQuery);
Assert.That(householdData, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.EqualTo(householdIdentifier));
Assert.That(householdData.Name, Is.Not.Null);
Assert.That(householdData.Name, Is.Not.Empty);
Assert.That(householdData.Name, Is.EqualTo(householdUpdateCommand.Name));
Assert.That(householdData.Description, Is.Null);
var secondaryMailAddress = string.Format("test.{0}@osdevgrp.dk", Guid.NewGuid().ToString("D").ToLower());
var householdAddHouseholdMemberCommand = new HouseholdAddHouseholdMemberCommand
{
HouseholdIdentifier = householdIdentifier,
MailAddress = secondaryMailAddress,
TranslationInfoIdentifier = translationInfoIdentifier
};
var householdAddHouseholdMember = _householdDataService.HouseholdAddHouseholdMember(householdAddHouseholdMemberCommand);
Assert.That(householdAddHouseholdMember.Identifier, Is.Not.Null);
Assert.That(householdAddHouseholdMember.Identifier.HasValue, Is.True);
// ReSharper disable PossibleInvalidOperationException
Assert.That(householdAddHouseholdMember.Identifier.Value, Is.EqualTo(householdIdentifier));
// ReSharper restore PossibleInvalidOperationException
householdData = _householdDataService.HouseholdDataGet(householdDataGetQuery);
Assert.That(householdData, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.EqualTo(householdIdentifier));
Assert.That(householdData.HouseholdMembers, Is.Not.Null);
Assert.That(householdData.HouseholdMembers, Is.Not.Empty);
Assert.That(householdData.HouseholdMembers.Count(), Is.EqualTo(2));
Assert.That(householdData.HouseholdMembers.SingleOrDefault(householdMember => string.Compare(householdMember.MailAddress, secondaryMailAddress, StringComparison.Ordinal) == 0), Is.Not.Null);
var householdRemoveHouseholdMemberCommand = new HouseholdRemoveHouseholdMemberCommand
{
HouseholdIdentifier = householdIdentifier,
MailAddress = secondaryMailAddress
};
var householdRemoveHouseholdMember = _householdDataService.HouseholdRemoveHouseholdMember(householdRemoveHouseholdMemberCommand);
Assert.That(householdRemoveHouseholdMember.Identifier, Is.Not.Null);
Assert.That(householdRemoveHouseholdMember.Identifier.HasValue, Is.True);
// ReSharper disable PossibleInvalidOperationException
Assert.That(householdRemoveHouseholdMember.Identifier.Value, Is.EqualTo(householdIdentifier));
// ReSharper restore PossibleInvalidOperationException
householdData = _householdDataService.HouseholdDataGet(householdDataGetQuery);
Assert.That(householdData, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.Not.Null);
Assert.That(householdData.HouseholdIdentifier, Is.EqualTo(householdIdentifier));
Assert.That(householdData.HouseholdMembers, Is.Not.Null);
Assert.That(householdData.HouseholdMembers, Is.Not.Empty);
Assert.That(householdData.HouseholdMembers.Count(), Is.EqualTo(1));
Assert.That(householdData.HouseholdMembers.SingleOrDefault(householdMember => string.Compare(householdMember.MailAddress, secondaryMailAddress, StringComparison.Ordinal) == 0), Is.Null);
}
finally
{
if (householdAdd != null && householdAdd.Identifier.HasValue)
{
_householdDataRepository.Delete(_householdDataRepository.Get <IHousehold>(householdAdd.Identifier.Value));
}
}
}
}
