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));
}
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());
}
/// <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 TestThatModifyDataCallsIsNotNullWithNullOnCommonValidationsWhenHouseholdDoesNotHaveHouseholdMemberWithMailAddress()
{
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);
string mailAddress = _fixture.Create <string>();
Assert.That(householdMock.HouseholdMembers.Any(householdMember => string.Compare(householdMember.MailAddress, mailAddress, StringComparison.OrdinalIgnoreCase) == 0), Is.False);
HouseholdRemoveHouseholdMemberCommand householdRemoveHouseholdMemberCommand = _fixture.Build <HouseholdRemoveHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, mailAddress)
.Create();
sut.ModifyData(householdMock, householdRemoveHouseholdMemberCommand);
_commonValidationsMock.AssertWasCalled(m => m.IsNotNull(Arg <IHouseholdMember> .Is.Null), opt => opt.Repeat.Once());
}
public static IChoiceModelRunner Get(IHousehold household, int randomSeed)
{
var runner = (IChoiceModelRunner)Activator.CreateInstance(_type, household);
runner.SetRandomSeed(randomSeed);
return(runner);
}
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());
}
/// <summary>
/// Creates an instance of the data proxy to a given storage which should be used for unit testing.
/// </summary>
/// <returns>Instance of the data proxy to a given storage which should be used for unit testing.</returns>
private IStorageProxy CreateSut(Guid storageIdentifier, IHousehold household, int sortOrder, IStorageType storageType, int temperature, DateTime creationTime, string description = null)
{
return(new StorageProxy(household, sortOrder, storageType, temperature, creationTime, description)
{
Identifier = storageIdentifier
});
}
public IExcangeAction Excange(IHousehold MyHousehold, IExchangeRules ExchangeRules)
{
foreach (AnimalKind animalKinndFrom in Enum.GetValues(typeof(AnimalKind)))
{
bool started = false;
foreach (AnimalKind animalKinndTo in Enum.GetValues(typeof(AnimalKind)))
{
if (started)
{
var animalFrom = Animal.GetAnimal(animalKinndFrom);
var animalTo = Animal.GetAnimal(animalKinndTo);
if ((animalFrom.IsWild) || (animalTo.IsWild))
{
continue;
}
if (
(MyHousehold.GetAnimalCount(animalFrom) > 0)
&&
(((MyHousehold.GetAnimalCount(animalTo) == 0) || ((animalTo.Kind != AnimalKind.SmallDog) && (animalTo.Kind != AnimalKind.BigDog))))
&&
(ExchangeRules.TryGetAction(animalFrom, MyHousehold.GetAnimalCount(animalFrom), animalTo, out IExcangeAction result, out string errorMessage))
&&
((MyHousehold.GetAnimalCount(animalFrom) - result.AnimalFromCount) > 0)
)
{
return(result);
}
}
started = (started || (animalKinndFrom == animalKinndTo));
}
}
return(null);
}
public void TestThatCreateUpdateCommandReturnsSqlCommandForUpdate(bool hasDescription)
{
Guid identifier = Guid.NewGuid();
Guid householdIdentifier = Guid.NewGuid();
IHousehold householdMock = DomainObjectMockBuilder.BuildHouseholdMock(householdIdentifier);
int sortOrder = GetLegalSortOrder();
Guid storageTypeIdentifier = Guid.NewGuid();
IStorageType storageTypeMock = DomainObjectMockBuilder.BuildStorageTypeMock(storageTypeIdentifier);
int temperature = GetLegalTemperature(storageTypeMock.TemperatureRange);
DateTime creationTime = DateTime.Now;
string description = hasDescription ? _fixture.Create <string>() : null;
IStorageProxy sut = CreateSut(identifier, householdMock, sortOrder, storageTypeMock, temperature, creationTime, description);
Assert.That(sut, Is.Not.Null);
// ReSharper disable StringLiteralTypo
new DbCommandTestBuilder("UPDATE Storages SET HouseholdIdentifier=@householdIdentifier,SortOrder=@sortOrder,StorageTypeIdentifier=@storageTypeIdentifier,Descr=@descr,Temperature=@temperature,CreationTime=@creationTime WHERE StorageIdentifier=@storageIdentifier")
// ReSharper restore StringLiteralTypo
.AddCharDataParameter("@storageIdentifier", identifier)
.AddCharDataParameter("@householdIdentifier", householdIdentifier)
.AddTinyIntDataParameter("@sortOrder", sortOrder, 4)
.AddCharDataParameter("@storageTypeIdentifier", storageTypeIdentifier)
// ReSharper disable StringLiteralTypo
.AddVarCharDataParameter("@descr", description, 2048, true)
// ReSharper restore StringLiteralTypo
.AddTinyIntDataParameter("@temperature", temperature, 4)
.AddDateTimeDataParameter("@creationTime", creationTime.ToUniversalTime())
.Build()
.Run(sut.CreateUpdateCommand());
}
/// <summary>
/// Build a mockup for a storage.
/// </summary>
/// <returns>Mockup for a storage.</returns>
public static IStorage BuildStorageMock(IHousehold household = null, int?sortOrder = null, IStorageType storageType = null, bool hasDescription = true)
{
if (storageType == null)
{
storageType = BuildStorageTypeMock();
}
IStorage storage = MockRepository.GenerateMock <IStorage>();
storage.Stub(m => m.Identifier)
.Return(Guid.NewGuid())
.Repeat.Any();
storage.Stub(m => m.Household)
.Return(household ?? BuildHouseholdMock())
.Repeat.Any();
storage.Stub(m => m.SortOrder)
.Return(sortOrder ?? Random.Next(1, 100))
.Repeat.Any();
storage.Stub(m => m.StorageType)
.Return(storageType)
.Repeat.Any();
storage.Stub(m => m.Description)
.Return(hasDescription ? Fixture.Create <string>() : null)
.Repeat.Any();
storage.Stub(m => m.Temperature)
.Return(Random.Next(storageType.TemperatureRange.StartValue, storageType.TemperatureRange.EndValue))
.Repeat.Any();
storage.Stub(m => m.CreationTime)
.Return(DateTime.Now)
.Repeat.Any();
return(storage);
}
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));
}
private static TWrapper CreateWrapper(IHousehold household)
{
var type = typeof(TWrapper);
var instance = Activator.CreateInstance(type, household);
return((TWrapper)instance);
}
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 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>
/// 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;
}
public ChoiceModelRunner(IHousehold household)
{
_household =
Global
.Kernel
.Get <IWrapperFactory <IHouseholdCreator> >()
.Creator
.CreateWrapper(household);
}
/// <summary>
/// Removes a household from the household member.
/// </summary>
/// <param name="household">Household where the membership for the household member should be removed.</param>
/// <returns>Household where the membership for the household member has been removed.</returns>
public override IHousehold HouseholdRemove(IHousehold household)
{
IHousehold householdToRemove = base.HouseholdRemove(household);
if (householdToRemove != null)
{
_removedHouseholdCollection.Add(householdToRemove);
}
return(householdToRemove);
}
/// <summary>
/// Modifies the data.
/// </summary>
/// <param name="household">Household on which to modify data.</param>
/// <param name="command">Command for updating a household to 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, HouseholdUpdateCommand command)
{
ArgumentNullGuard.NotNull(household, nameof(household))
.NotNull(command, nameof(command));
household.Name = command.Name;
household.Description = command.Description;
return(HouseholdDataRepository.Update(household));
}
/// <summary>
/// Build a collection of mockups for some storages.
/// </summary>
/// <returns>Collection of mockups for some storages.</returns>
public static IEnumerable <IStorage> BuildStorageMockCollection(IHousehold household = null)
{
return(new List <IStorage>
{
BuildStorageMock(household, 1, BuildStorageTypeMock(StorageType.IdentifierForRefrigerator, 1)),
BuildStorageMock(household, 2, BuildStorageTypeMock(StorageType.IdentifierForFreezer, 2)),
BuildStorageMock(household, 3, BuildStorageTypeMock(StorageType.IdentifierForKitchenCabinets, 3)),
BuildStorageMock(household, 4, BuildStorageTypeMock(StorageType.IdentifierForShoppingBasket, 4))
});
}
/// <summary>
/// Creates a data proxy to a given storage.
/// </summary>
/// <param name="household">Household where the storage are placed.</param>
/// <param name="sortOrder">Sort order for the storage.</param>
/// <param name="storageType">Storage type for the storage.</param>
/// <param name="temperature">Temperature for the storage.</param>
/// <param name="creationTime">Creation date and time for when the storage was created.</param>
/// <param name="description">Description for the storage.</param>
/// <param name="dataProvider">The data provider which the created data proxy should use.</param>
public StorageProxy(IHousehold household, int sortOrder, IStorageType storageType, int temperature, DateTime creationTime, string description = null, IDataProviderBase <MySqlDataReader, MySqlCommand> dataProvider = null)
: base(household, sortOrder, storageType, temperature, creationTime, description)
{
if (dataProvider == null)
{
return;
}
_dataProvider = (IFoodWasteDataProvider)dataProvider;
}
/// <summary>
/// Modifies the data.
/// </summary>
/// <param name="household">Household on 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>
public override IIdentifiable ModifyData(IHousehold household, TCommand command)
{
Assert.That(household, Is.Not.Null);
Assert.That(command, Is.Not.Null);
ModifyDataIsCalled = true;
HandledHousehold = household;
HandledCommand = command;
return(ModifyDataResult);
}
/// <summary>
/// Adds validation rules to the specification which encapsulates validation rules.
/// </summary>
/// <param name="household">Household on which to modify data.</param>
/// <param name="command">Command for modifying some data on a given household on the current household member.</param>
/// <param name="specification">Specification which encapsulates validation rules.</param>
public override void AddValidationRules(IHousehold household, TCommand command, ISpecification specification)
{
Assert.That(household, Is.Not.Null);
Assert.That(command, Is.Not.Null);
Assert.That(specification, Is.Not.Null);
Assert.That(specification, Is.EqualTo(base.Specification));
AddValidationRulesIsCalled = true;
HandledHousehold = household;
HandledCommand = command;
}
/// <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 validation rules to the specification which encapsulates validation rules.
/// </summary>
/// <param name="household">Household on which to modify data.</param>
/// <param name="command">Command for updating a household to the current users household account.</param>
/// <param name="specification">Specification which encapsulates validation rules.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="household"/>, <paramref name="command"/> or <paramref name="specification"/> is null.</exception>
public override void AddValidationRules(IHousehold household, HouseholdUpdateCommand command, ISpecification specification)
{
ArgumentNullGuard.NotNull(household, nameof(household))
.NotNull(command, nameof(command))
.NotNull(specification, nameof(specification));
specification.IsSatisfiedBy(() => CommonValidations.HasValue(command.Name), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "Name")))
.IsSatisfiedBy(() => CommonValidations.IsLengthValid(command.Name, 1, 64), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.LengthForPropertyIsInvalid, "Name", 1, 64)))
.IsSatisfiedBy(() => CommonValidations.ContainsIllegalChar(command.Name) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "Name")))
.IsSatisfiedBy(() => command.Description == null || CommonValidations.HasValue(command.Description), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "Description")))
.IsSatisfiedBy(() => command.Description == null || CommonValidations.IsLengthValid(command.Description, 1, 2048), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.LengthForPropertyIsInvalid, "Description", 1, 2048)))
.IsSatisfiedBy(() => command.Description == null || CommonValidations.ContainsIllegalChar(command.Description) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "Description")));
}
/// <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));
}
/// <summary>
/// Adds validation rules to the specification which encapsulates validation rules.
/// </summary>
/// <param name="household">Household on which to modify data.</param>
/// <param name="command">Command for adding a household member to a given household on the current users household account.</param>
/// <param name="specification">Specification which encapsulates validation rules.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="household"/>, <paramref name="command"/> or <paramref name="specification"/> is null.</exception>
public override void AddValidationRules(IHousehold household, HouseholdAddHouseholdMemberCommand command, ISpecification specification)
{
ArgumentNullGuard.NotNull(household, nameof(household))
.NotNull(command, nameof(command))
.NotNull(specification, nameof(specification));
string currentMailAddress = ClaimValueProvider.MailAddress;
string mailAddressToAdd = command.MailAddress;
specification.IsSatisfiedBy(() => CommonValidations.HasValue(command.MailAddress), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueMustBeGivenForProperty, "MailAddress")))
.IsSatisfiedBy(() => CommonValidations.IsLengthValid(command.MailAddress, 1, 128), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.LengthForPropertyIsInvalid, "MailAddress", 1, 128)))
.IsSatisfiedBy(() => CommonValidations.ContainsIllegalChar(command.MailAddress) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.ValueForPropertyContainsIllegalChars, "MailAddress")))
.IsSatisfiedBy(() => _domainObjectValidations.IsMailAddress(command.MailAddress), new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, command.MailAddress, "MailAddress")))
.IsSatisfiedBy(() => CommonValidations.Equals(mailAddressToAdd, currentMailAddress, StringComparison.OrdinalIgnoreCase) == false, new IntranetBusinessException(Resource.GetExceptionMessage(ExceptionMessage.CannotModifyHouseholdMembershipForYourself)));
}
/// <summary>
/// Creates a storage
/// </summary>
/// <param name="household">Household where the storage are placed.</param>
/// <param name="sortOrder">Sort order for the storage.</param>
/// <param name="storageType">Storage type for the storage.</param>
/// <param name="description">Description for the storage.</param>
/// <param name="temperature">Temperature for the storage.</param>
/// <param name="creationTime">Creation date and time for when the storage was created.</param>
/// <param name="domainObjectValidations">Implementation of the common validations used by domain objects in the food waste domain.</param>
protected Storage(IHousehold household, int sortOrder, IStorageType storageType, string description, int temperature, DateTime creationTime, IDomainObjectValidations domainObjectValidations)
{
ArgumentNullGuard.NotNull(household, nameof(household))
.NotNull(storageType, nameof(storageType))
.NotNull(domainObjectValidations, nameof(domainObjectValidations));
_domainObjectValidations = domainObjectValidations;
_household = household;
_sortOrder = ValidateSortOrder(sortOrder, nameof(sortOrder));
_storageType = storageType;
_description = description;
_temperature = ValidateTemperature(temperature, nameof(temperature));
_creationTime = creationTime;
}
public void TestThatModifyDataCallsUpdateWithHouseholdOnHouseholdDataRepository()
{
HouseholdRemoveHouseholdMemberCommandHandler sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IHousehold householdMock = DomainObjectMockBuilder.BuildHouseholdMock();
HouseholdRemoveHouseholdMemberCommand householdRemoveHouseholdMemberCommand = _fixture.Build <HouseholdRemoveHouseholdMemberCommand>()
.With(m => m.HouseholdIdentifier, Guid.NewGuid())
.With(m => m.MailAddress, _fixture.Create <string>())
.Create();
sut.ModifyData(householdMock, householdRemoveHouseholdMemberCommand);
_householdDataRepositoryMock.AssertWasCalled(m => m.Update(Arg <IHousehold> .Is.Equal(householdMock)), opt => opt.Repeat.Once());
}
/// <summary>
/// Creates an instance of the <see cref="HouseholdUpdateCommandHandler"/> which can be used for unit testing.
/// </summary>
/// <returns>Instance of the <see cref="HouseholdUpdateCommandHandler"/> which can be used for unit testing.</returns>
private HouseholdUpdateCommandHandler CreateSut(IHousehold updatedHousehold = null)
{
_specificationMock.Stub(m => m.IsSatisfiedBy(Arg <Func <bool> > .Is.Anything, Arg <Exception> .Is.Anything))
.WhenCalled(e =>
{
Func <bool> func = (Func <bool>)e.Arguments.ElementAt(0);
func();
})
.Return(_specificationMock)
.Repeat.Any();
_householdDataRepositoryMock.Stub(m => m.Update(Arg <IHousehold> .Is.Anything))
.Return(updatedHousehold ?? DomainObjectMockBuilder.BuildHouseholdMock())
.Repeat.Any();
return(new HouseholdUpdateCommandHandler(_householdDataRepositoryMock, _claimValueProviderMock, _objectMapperMock, _specificationMock, _commonValidationsMock, _exceptionBuilderMock));
}
public void TestThatModifyDataCallsHouseholdMembersOnHousehold()
{
HouseholdAddHouseholdMemberCommandHandler sut = CreateSut();
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.HouseholdMembers, opt => opt.Repeat.Once());
}
