public void Apply_adds_new_attribute()
        {
            // Arrange
            const string animalId                 = "AnimalId";
            const string animalTypeId             = "AnimalTypeId";
            const string attributeId              = "AttributeId";
            const string newAttributeId           = "NewAttributeId";
            const string newRulesetId             = "NewRuleset";
            const int    newAttributeInitialValue = 23;

            var animal = new Animal
            {
                Id         = animalId,
                TypeId     = animalTypeId,
                Attributes = new Dictionary <string, decimal>
                {
                    { attributeId, 0 }
                }
            };

            var oldRuleset = Build.Ruleset("OldRuleset")
                             .WithAnimalType(animalTypeId)
                             .HavingAttribute(attributeId)
                             .And.Finish;
            var newRuleset = Build.Ruleset(newRulesetId)
                             .WithAnimalType(animalTypeId)
                             .HavingAttribute(attributeId)
                             .HavingAttribute(newAttributeId, initialValue: newAttributeInitialValue)
                             .And.Finish;

            var target = new AnimalRulesetChangeEventHandler();

            var e = new AnimalRulesetChangeEvent {
                AnimalId = animalId, NewVersionId = newRulesetId
            };
            var mockAnimalContext = new MockAnimalEventContext(animal, oldRuleset, newRuleset);

            // Act
            target.Apply(e, mockAnimalContext);

            // Assert
            Assert.Contains(newAttributeId, animal.Attributes.Keys);
            Assert.Equal(newAttributeInitialValue, animal.Attributes[newAttributeId]);
        }
        public void Appply_instantiates_a_new_animal()
        {
            // ArrangeNa
            const string  ownerUserId           = "UserId";
            const string  animalId              = "AnimalId";
            const string  animalName            = "Snowball";
            const string  animalTypeId          = "PigTypeId";
            const string  attributeId           = "AttributeId";
            const decimal attributeInitialValue = 30.5M;
            DateTime      time = DateTime.UtcNow;

            var ruleset = Build.Ruleset()
                          .WithAnimalType(animalTypeId)
                          .HavingAttribute(attributeId, initialValue: attributeInitialValue)
                          .And.Finish;

            var target = new CreateAnimalEventHandler();

            CreateAnimalEvent e = new CreateAnimalEvent
            {
                AnimalId     = animalId,
                OwnerUserId  = ownerUserId,
                AnimalTypeId = animalTypeId,
                Name         = animalName,
                Time         = time
            };

            var context = new MockAnimalEventContext(null, ruleset);

            // Act
            target.Apply(e, context);

            // Assert
            Animal animal = context.Animal;

            Assert.NotNull(animal);
            Assert.Equal(animalId, animal.Id);
            Assert.Equal(ownerUserId, animal.UserId);
            Assert.Equal(animalTypeId, animal.TypeId);
            Assert.Equal(time, animal.LastCalculated);
            Assert.Equal(attributeInitialValue, animal.Attributes[attributeId]);
        }