[ninject commit] r142 - in experiments/ninject2/src: Ninject.Tests Ninject.Tests/Unit Ninject/Planning/Directives

[codesite...@google.com]

Author: nkohari
Date: Sat Feb 14 10:20:28 2009
New Revision: 142

Added:
experiments/ninject2/src/Ninject.Tests/Unit/NamedAttributeTests.cs

experiments/ninject2/src/Ninject.Tests/Unit/PropertyInjectionStrategyTests.cs
Modified:
experiments/ninject2/src/Ninject.Tests/Ninject.Tests.csproj

experiments/ninject2/src/Ninject.Tests/Unit/MethodInjectionStrategyTests.cs

experiments/ninject2/src/Ninject/Planning/Directives/MethodInjectionDirectiveBase.cs

experiments/ninject2/src/Ninject/Planning/Directives/PropertyInjectionDirective.cs

Log:


Modified: experiments/ninject2/src/Ninject.Tests/Ninject.Tests.csproj
==============================================================================
--- experiments/ninject2/src/Ninject.Tests/Ninject.Tests.csproj (original)
+++ experiments/ninject2/src/Ninject.Tests/Ninject.Tests.csproj Sat Feb 14
10:20:28 2009
@@ -65,6 +65,8 @@
<Compile Include="Unit\ConstantProviderTests.cs" />
<Compile Include="Unit\ActivationScopeTests.cs" />
<Compile Include="Unit\BindingActionStrategyTests.cs" />
+ <Compile Include="Unit\NamedAttributeTests.cs" />
+ <Compile Include="Unit\PropertyInjectionStrategyTests.cs" />
<Compile Include="Unit\PropertyInjectionDirectiveTests.cs" />
<Compile Include="Unit\MethodInjectionDirectiveBaseTests.cs" />
<Compile Include="Unit\StartableStrategyTests.cs" />
@@ -100,4 +102,4 @@
<Target Name="AfterBuild">
</Target>
-->
-</Project>
\ No newline at end of file
+</Project>

Modified:
experiments/ninject2/src/Ninject.Tests/Unit/MethodInjectionStrategyTests.cs
==============================================================================
---
experiments/ninject2/src/Ninject.Tests/Unit/MethodInjectionStrategyTests.cs
(original)
+++
experiments/ninject2/src/Ninject.Tests/Unit/MethodInjectionStrategyTests.cs
Sat Feb 14 10:20:28 2009
@@ -27,20 +27,23 @@

public class WhenActivateIsCalled : MethodInjectionStrategyContext
{
- [Fact]
- public void
CreatesAndInvokesMethodInjectorsAsDescribedByMethodInjectionDirectivesInPlan()
- {
- var instance = new Dummy();
+ protected Dummy instance = new Dummy();
+ protected MethodInfo method1 = typeof(Dummy).GetMethod("Foo");
+ protected MethodInfo method2 = typeof(Dummy).GetMethod("Bar");
+ protected Mock<IContext> contextMock;
+ protected Mock<IPlan> planMock;
+ protected Mock<IMethodInjector> methodInjectorMock1;
+ protected Mock<IMethodInjector> methodInjectorMock2;
+ protected FakeMethodInjectionDirective[] directives;

- var method1 = typeof(Dummy).GetMethod("Foo");
- var method2 = typeof(Dummy).GetMethod("Bar");
-
- var contextMock = new Mock<IContext>();
- var planMock = new Mock<IPlan>();
- var methodInjectorMock1 = new Mock<IMethodInjector>();
- var methodInjectorMock2 = new Mock<IMethodInjector>();
+ public WhenActivateIsCalled()
+ {
+ contextMock = new Mock<IContext>();
+ planMock = new Mock<IPlan>();
+ methodInjectorMock1 = new Mock<IMethodInjector>();
+ methodInjectorMock2 = new Mock<IMethodInjector>();

- var directives = new[] { new FakeMethodInjectionDirective(method1), new
FakeMethodInjectionDirective(method2) };
+ directives = new[] { new FakeMethodInjectionDirective(method1), new
FakeMethodInjectionDirective(method2) };

injectorFactoryMock.Setup(x =>
x.GetMethodInjector(method1)).Returns(methodInjectorMock1.Object).AtMostOnce();
injectorFactoryMock.Setup(x =>
x.GetMethodInjector(method2)).Returns(methodInjectorMock2.Object).AtMostOnce();
@@ -49,14 +52,38 @@
contextMock.SetupGet(x => x.Instance).Returns(instance);

planMock.Setup(x =>
x.GetAll<MethodInjectionDirective>()).Returns(directives);
+ }

+ [Fact]
+ public void ReadsMethodInjectorsFromPlan()
+ {
strategy.Activate(contextMock.Object);

- contextMock.VerifyGet(x => x.Plan);
planMock.Verify(x => x.GetAll<MethodInjectionDirective>());
+ }
+
+ [Fact]
+ public void CreatesMethodInjectorsForEachDirective()
+ {
+ strategy.Activate(contextMock.Object);
+
injectorFactoryMock.Verify(x => x.GetMethodInjector(method1));
injectorFactoryMock.Verify(x => x.GetMethodInjector(method2));
+ }
+
+ [Fact]
+ public void ResolvesValuesForEachTargetOfEachDirective()
+ {
+ strategy.Activate(contextMock.Object);
+
directives.Map(d => d.TargetMocks.Map(m => m.Verify(x =>
x.ResolveWithin(contextMock.Object))));
+ }
+
+ [Fact]
+ public void InvokesInjectorsForEachDirective()
+ {
+ strategy.Activate(contextMock.Object);
+
methodInjectorMock1.Verify(x => x.Invoke(instance, It.Is<object[]>(a =>
a.Length == 2)));
methodInjectorMock2.Verify(x => x.Invoke(instance, It.Is<object[]>(a =>
a.Length == 1)));
}
@@ -68,7 +95,7 @@

public FakeMethodInjectionDirective(MethodInfo method) : base(method) { }

- protected override ITarget[] GetParameterTargets(MethodInfo method)
+ protected override ITarget[] CreateTargetsFromParameters(MethodInfo
method)
{
TargetMocks = method.GetParameters().Select(p => new
Mock<ITarget>()).ToArray();
return TargetMocks.Select(m => m.Object).ToArray();
@@ -80,4 +107,4 @@
public void Foo(int a, string b) { }
public void Bar(IWeapon weapon) { }
}
-}
\ No newline at end of file
+}

Added: experiments/ninject2/src/Ninject.Tests/Unit/NamedAttributeTests.cs
==============================================================================
--- (empty file)
+++ experiments/ninject2/src/Ninject.Tests/Unit/NamedAttributeTests.cs Sat
Feb 14 10:20:28 2009
@@ -0,0 +1,36 @@
+using System;
+using Moq;
+using Ninject.Planning.Bindings;
+using Xunit;
+
+namespace Ninject.Tests.Unit.NamedAttributeTests
+{
+ public class NamedAttributeContext
+ {
+ protected readonly NamedAttribute attribute;
+ protected readonly Mock<IBindingMetadata> metadataMock;
+
+ public NamedAttributeContext()
+ {
+ attribute = new NamedAttribute("foo");
+ metadataMock = new Mock<IBindingMetadata>();
+ }
+ }
+
+ public class WhenMatchesIsCalled : NamedAttributeContext
+ {
+ [Fact]
+ public void ReturnsTrueIfTheNameMatches()
+ {
+ metadataMock.SetupGet(x => x.Name).Returns("foo");
+ Assert.True(attribute.Matches(metadataMock.Object));
+ }
+
+ [Fact]
+ public void ReturnsFalseIfTheNameDoesNotMatch()
+ {
+ metadataMock.SetupGet(x => x.Name).Returns("bar");
+ Assert.False(attribute.Matches(metadataMock.Object));
+ }
+ }
+}
\ No newline at end of file

Added:
experiments/ninject2/src/Ninject.Tests/Unit/PropertyInjectionStrategyTests.cs
==============================================================================
--- (empty file)
+++
experiments/ninject2/src/Ninject.Tests/Unit/PropertyInjectionStrategyTests.cs
Sat Feb 14 10:20:28 2009
@@ -0,0 +1,110 @@
+using System;
+using System.Reflection;
+using Moq;
+using Ninject.Activation;
+using Ninject.Activation.Strategies;
+using Ninject.Injection;
+using Ninject.Parameters;
+using Ninject.Planning;
+using Ninject.Planning.Directives;
+using Ninject.Planning.Targets;
+using Xunit;
+
+namespace Ninject.Tests.Unit.PropertyInjectionStrategyTests
+{
+ public class PropertyInjectionDirectiveContext
+ {
+ protected Mock<IInjectorFactory> injectorFactoryMock;
+ protected readonly PropertyInjectionStrategy strategy;
+
+ public PropertyInjectionDirectiveContext()
+ {
+ injectorFactoryMock = new Mock<IInjectorFactory>();
+ strategy = new PropertyInjectionStrategy(injectorFactoryMock.Object);
+ }
+ }
+
+ public class WhenActivateIsCalled : PropertyInjectionDirectiveContext
+ {
+ protected Dummy instance = new Dummy();
+ protected PropertyInfo property1 = typeof(Dummy).GetProperty("Foo");
+ protected PropertyInfo property2 = typeof(Dummy).GetProperty("Bar");
+ protected Mock<IContext> contextMock;
+ protected Mock<IPlan> planMock;
+ protected Mock<IPropertyInjector> propertyInjectorMock1;
+ protected Mock<IPropertyInjector> propertyInjectorMock2;
+ protected FakePropertyInjectionDirective[] directives;
+
+ public WhenActivateIsCalled()
+ {
+ contextMock = new Mock<IContext>();
+ planMock = new Mock<IPlan>();
+ propertyInjectorMock1 = new Mock<IPropertyInjector>();
+ propertyInjectorMock2 = new Mock<IPropertyInjector>();
+
+ directives = new[] { new FakePropertyInjectionDirective(property1), new
FakePropertyInjectionDirective(property2) };
+
+ injectorFactoryMock.Setup(x =>
x.GetPropertyInjector(property1)).Returns(propertyInjectorMock1.Object).AtMostOnce();
+ injectorFactoryMock.Setup(x =>
x.GetPropertyInjector(property2)).Returns(propertyInjectorMock2.Object).AtMostOnce();
+
+ contextMock.SetupGet(x => x.Plan).Returns(planMock.Object);
+ contextMock.SetupGet(x => x.Instance).Returns(instance);
+ contextMock.SetupGet(x => x.Parameters).Returns(new IParameter[0]);
+
+ planMock.Setup(x =>
x.GetAll<PropertyInjectionDirective>()).Returns(directives);
+ }
+
+ [Fact]
+ public void ReadsMethodInjectorsFromPlan()
+ {
+ strategy.Activate(contextMock.Object);
+
+ planMock.Verify(x => x.GetAll<PropertyInjectionDirective>());
+ }
+
+ [Fact]
+ public void CreatesMethodInjectorsForEachDirective()
+ {
+ strategy.Activate(contextMock.Object);
+
+ injectorFactoryMock.Verify(x => x.GetPropertyInjector(property1));
+ injectorFactoryMock.Verify(x => x.GetPropertyInjector(property2));
+ }
+
+ [Fact]
+ public void ResolvesValuesForEachTargetOfEachDirective()
+ {
+ strategy.Activate(contextMock.Object);
+
+ directives.Map(d => d.TargetMock.Verify(x =>
x.ResolveWithin(contextMock.Object)));
+ }
+
+ [Fact]
+ public void InvokesInjectorsForEachDirective()
+ {
+ strategy.Activate(contextMock.Object);
+
+ propertyInjectorMock1.Verify(x => x.Invoke(instance, null));
+ propertyInjectorMock2.Verify(x => x.Invoke(instance, null));
+ }
+ }
+
+ public class FakePropertyInjectionDirective : PropertyInjectionDirective
+ {
+ public Mock<ITarget> TargetMock { get; private set; }
+
+ public FakePropertyInjectionDirective(PropertyInfo property) :
base(property) { }
+
+ protected override ITarget CreateTarget(PropertyInfo property)
+ {
+ TargetMock = new Mock<ITarget>();
+ return TargetMock.Object;
+ }
+ }
+
+ public class Dummy
+ {
+ public int Foo { get; set; }
+ public string Bar { get; set; }
+ }
+}
\ No newline at end of file

Modified:
experiments/ninject2/src/Ninject/Planning/Directives/MethodInjectionDirectiveBase.cs
==============================================================================
---
experiments/ninject2/src/Ninject/Planning/Directives/MethodInjectionDirectiveBase.cs
(original)
+++
experiments/ninject2/src/Ninject/Planning/Directives/MethodInjectionDirectiveBase.cs
Sat Feb 14 10:20:28 2009
@@ -44,7 +44,7 @@
{
get
{
- if (_targets == null) _targets = GetParameterTargets(Member);
+ if (_targets == null) _targets = CreateTargetsFromParameters(Member);
return _targets;
}
}
@@ -63,9 +63,9 @@
/// </summary>
/// <param name="method">The method.</param>
/// <returns>The targets for the method's parameters.</returns>
- protected virtual ITarget[] GetParameterTargets(T method)
+ protected virtual ITarget[] CreateTargetsFromParameters(T method)
{
return method.GetParameters().Select(parameter => new
ParameterTarget(method, parameter)).ToArray();
}
}
-}
\ No newline at end of file
+}

Modified:
experiments/ninject2/src/Ninject/Planning/Directives/PropertyInjectionDirective.cs
==============================================================================
---
experiments/ninject2/src/Ninject/Planning/Directives/PropertyInjectionDirective.cs
(original)
+++
experiments/ninject2/src/Ninject/Planning/Directives/PropertyInjectionDirective.cs
Sat Feb 14 10:20:28 2009
@@ -27,6 +27,8 @@
/// </summary>
public class PropertyInjectionDirective : IDirective
{
+ private ITarget _target;
+
/// <summary>
/// Gets or sets the member the directive describes.
/// </summary>
@@ -35,7 +37,14 @@
/// <summary>
/// Gets or sets the injection target for the directive.
/// </summary>
- public ITarget Target { get; private set; }
+ public ITarget Target
+ {
+ get
+ {
+ if (_target == null) _target = CreateTarget(Member);
+ return _target;
+ }
+ }

/// <summary>
/// Initializes a new instance of the <see
cref="PropertyInjectionDirective"/> class.
@@ -44,7 +53,16 @@
public PropertyInjectionDirective(PropertyInfo member)
{
Member = member;
- Target = new PropertyTarget(member);
+ }
+
+ /// <summary>
+ /// Creates a target for the property.
+ /// </summary>
+ /// <param name="propertyInfo">The property.</param>
+ /// <returns>The target for the property.</returns>
+ protected virtual ITarget CreateTarget(PropertyInfo propertyInfo)
+ {
+ return new PropertyTarget(propertyInfo);
}
}
-}
\ No newline at end of file
+}