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()); }