public void ShouldAddTenAdvicesToIngredientAndThenRemoveFive()
{
var ingredient = IngredientBuilder.BuildIngredient();
_ingredientRepository.Add(ingredient);
_ingredientRepository.Persist();
for (int i = 0; i < 10; i++)
{
var newAdvice = AdviceBuilder.BuildAdvice <IngredientAdvice>("Advice_" + i);
ingredient.AddAdvice(newAdvice);
_ingredientRepository.Persist();
}
var advices = _ingredientRepository.FindOne(i => i != null).IngredientAdvices;
for (int i = 0; i < 5; i++)
{
var indexCopy = i;
var adviceToDelete = _ingredientAdviceRepository.FindOne(a => a == advices[indexCopy]);
_ingredientAdviceRepository.Delete(adviceToDelete);
_ingredientAdviceRepository.Persist();
}
_ingredientRepository.Refresh(ingredient);
_ingredientRepository.FindOne(i => i != null).IngredientAdvices.Count.ShouldEqual(5);
using (var dataContext = GetNewDataContext())
{
var result =
dataContext.GetTableForType(typeof(IngredientAdvice)).OfType <IngredientAdvice>().ToList();
result.Count.ShouldEqual(5);
}
}
public void SetValues()
{
var construction = ObjectMother.GetConstruction();
var method = ObjectMother.GetMethodInfo();
var pointcut = ObjectMother.GetPointcut();
var builder = new AdviceBuilder()
.SetConstruction(construction)
.SetMethod(method)
.SetName("name")
.SetRole("role")
.SetExecution(AdviceExecution.Around)
.SetScope(AdviceScope.Static)
.SetPriority(1)
.AddPointcut(pointcut);
var result = builder.Build();
Assert.That(result.Construction, Is.SameAs(construction));
Assert.That(result.Method, Is.SameAs(method));
Assert.That(result.Name, Is.EqualTo("name"));
Assert.That(result.Role, Is.EqualTo("role"));
Assert.That(result.Execution, Is.EqualTo(AdviceExecution.Around));
Assert.That(result.Scope, Is.EqualTo(AdviceScope.Static));
Assert.That(result.Priority, Is.EqualTo(1));
Assert.That(result.Pointcuts, Has.Member(pointcut));
}
public void SetUp()
{
_pointcutBuilderMock = MockRepository.GenerateStrictMock <IPointcutBuilder>();
_orderingBuilderMock = MockRepository.GenerateStrictMock <IOrderingBuilder>();
_mappingBuilderMock = MockRepository.GenerateStrictMock <IContextMappingBuilder>();
_builder = new AdviceBuilder(_pointcutBuilderMock, _orderingBuilderMock, _mappingBuilderMock);
}
private void CheckThrowForMultipleSet(Action <AdviceBuilder> action)
{
var adviceBuilder = new AdviceBuilder();
Assert.That(
() =>
{
action(adviceBuilder);
action(adviceBuilder);
},
Throws.Exception);
}
public void ThrowsForMultiplePointcutTypes()
{
var builder = new AdviceBuilder();
var pointcutType = typeof(TypePointcut);
var pointcut1 = ObjectMother.GetPointcut(pointcutType);
var pointcut2 = ObjectMother.GetPointcut(pointcutType);
builder.AddPointcut(pointcut1);
var message = string.Format("Cannot add multiple pointcuts of type '{0}'", pointcutType.Name);
Assert.That(() => builder.AddPointcut(pointcut2), Throws.InvalidOperationException.With.Message.EqualTo(message));
}
public void ShouldFindOneAdviceOnProductIngredient()
{
var product = _productRepository.FindOne(p => p != null);
var ingredientAdvice = AdviceBuilder.BuildAdvice <IngredientAdvice>();
product.Ingredients[0].IngredientAdvices.Add(ingredientAdvice);
_productRepository.Persist();
using (var dataContext = GetNewDataContext())
{
var prod = dataContext.GetTable <Product>().Where(p => p != null).Single();
prod.Ingredients[0].IngredientAdvices.Count.ShouldEqual(1);
}
}
private void CheckThrowForMissing(
string missingMember,
IAspectConstruction construction = null,
MethodInfo method = null,
AdviceExecution execution = AdviceExecution.Undefined,
AdviceScope scope = AdviceScope.Undefined)
{
var builder = new AdviceBuilder()
.SetConstruction(construction)
.SetMethod(method)
.SetExecution(execution)
.SetScope(scope);
var message = string.Format("Cannot build advice without having set its {0}.", missingMember);
Assert.That(() => builder.Build(), Throws.InvalidOperationException.With.Message.EqualTo(message));
}
public void ShouldAddTenAdvicesToIngredient()
{
var ingredient = IngredientBuilder.BuildIngredient();
_ingredientRepository.Add(ingredient);
_ingredientRepository.Persist();
for (int i = 0; i < 10; i++)
{
var newAdvice = AdviceBuilder.BuildAdvice <IngredientAdvice>("Advice_" + i);
ingredient.AddAdvice(newAdvice);
_ingredientRepository.Persist();
}
_ingredientRepository.FindOne(i => i != null).IngredientAdvices.Count.ShouldEqual(10);
using (var dataContext = GetNewDataContext())
{
var result =
dataContext.GetTableForType(typeof(IngredientAdvice)).OfType <IngredientAdvice>().ToList();
result.Count.ShouldEqual(10);
}
}
public void Copy()
{
var builder = new AdviceBuilder()
.SetConstruction(ObjectMother.GetConstruction())
.SetMethod(ObjectMother.GetMethodInfo())
.SetName("name")
.SetRole("name")
.SetExecution(AdviceExecution.Around)
.SetScope(AdviceScope.Static)
.SetPriority(1)
.AddPointcut(ObjectMother.GetPointcut());
var copiedAdvice = builder.Copy().Build();
var originalAdvice = builder.Build();
Assert.That(copiedAdvice.Construction, Is.SameAs(originalAdvice.Construction));
Assert.That(copiedAdvice.Method, Is.SameAs(originalAdvice.Method));
Assert.That(copiedAdvice.Name, Is.EqualTo(originalAdvice.Name));
Assert.That(copiedAdvice.Role, Is.EqualTo(originalAdvice.Role));
Assert.That(copiedAdvice.Execution, Is.EqualTo(originalAdvice.Execution));
Assert.That(copiedAdvice.Scope, Is.EqualTo(originalAdvice.Scope));
Assert.That(copiedAdvice.Priority, Is.EqualTo(originalAdvice.Priority));
Assert.That(copiedAdvice.Pointcuts, Is.EquivalentTo(originalAdvice.Pointcuts));
}
