public void Overrides_OverrideIsUsedInRecursiveBuilds()
{
// Setup
const int expectedValue = 42; // Just need a number, value has no significance.
// Act
var result = Container.Resolve <ObjectThatDependsOnSimpleObject>(
Override.Parameter("x", expectedValue));
// Verify
Assert.AreEqual(expectedValue, result.TestObject.X);
}
public void Overrides_NonMatchingOverridesAreIgnoredAlternative()
{
// Setup
const int expectedValue = 42; // Just need a number, value has no significance.
// Act
var result = Container.Resolve <SimpleTestObject>(
Override.Parameter("x", expectedValue),
Override.Parameter("y", expectedValue * 2));
// Verify
Assert.AreEqual(expectedValue, result.X);
}
public void ParameterOverrideCanResolveOverride()
{
// Setup
Container.RegisterType <IService, Service1>()
.RegisterType <IService, Service2>("other");
// Act
var result = Container.Resolve <ObjectTakingASomething>(
Override.Parameter("something", Resolve.Dependency <IService>("other")));
// Verify
Assert.IsInstanceOfType(result.MySomething, typeof(Service2));
}
public void Overrides_CanProvideConstructorParameterViaResolveCall()
{
// Setup
const int configuredValue = 15; // Just need a number, value has no significance.
const int expectedValue = 42; // Just need a number, value has no significance.
Container.RegisterType <SimpleTestObject>(new InjectionConstructor(configuredValue));
// Act
var result = Container.Resolve <SimpleTestObject>(Override.Parameter("x", expectedValue));
// Verify
Assert.AreEqual(expectedValue, result.X);
}
public void Overrides_OverrideDoeNotLastAfterResolveCall()
{
// Setup
const int configuredValue = 15; // Just need a number, value has no significance.
const int overrideValue = 42; // Just need a number, value has no significance.
Container.RegisterType <SimpleTestObject>(new InjectionConstructor(configuredValue));
// Act
Container.Resolve <SimpleTestObject>(Override.Parameter("x", overrideValue)
.OnType <SimpleTestObject>());
var result = Container.Resolve <SimpleTestObject>();
// Verify
Assert.AreEqual(configuredValue, result.X);
}
public void Overrides_OptionalViaParameter()
{
// Setup
IService x = new Service1();
IService y = new Service2();
// Act
var result = Container.Resolve <Foo>(
Override.Parameter("x", x),
Override.Parameter("y", y));
// Verify
Assert.IsNotNull(result);
Assert.IsNotNull(result.Fred);
Assert.IsNotNull(result.George);
}
public void Overrides_InjectedParameterWithParameterOverride()
{
// Setup
var noOverride = "default";
var parOverride = "custom-via-parameteroverride";
Container.RegisterType <TestType>(new InjectionConstructor(noOverride));
// Act
var defaultValue = Container.Resolve <TestType>().ToString();
var parValue = Container.Resolve <TestType>(Override.Parameter <string>("dependency", parOverride))
.ToString();
// Verify
Assert.AreSame(noOverride, defaultValue);
Assert.AreSame(parOverride, parValue);
}
public void InjectedParameterWithDependencyOverride()
{
// Setup
var noOverride = "default";
var depOverride = "custom-via-override";
Container.RegisterType <TestType>(Invoke.Constructor(noOverride));
// Act
var defaultValue = Container.Resolve <TestType>().ToString();
var depValue = Container.Resolve <TestType>(Override.Dependency <string>(depOverride)).ToString();
var propValue = Container.Resolve <TestType>(Override.Parameter <string>(depOverride)).ToString();
// Verify
Assert.AreSame(noOverride, defaultValue);
Assert.AreSame(noOverride, depValue);
Assert.AreSame(depOverride, propValue);
}
public void CanOverrideDependencyWithExplicitInjectionParameterValue()
{
// Setup
Container
.RegisterType <Outer>(Invoke.Constructor(typeof(Inner), 10))
.RegisterType <Inner>(Invoke.Constructor(20, "ignored"));
// resolves overriding only the parameter for the Bar instance
// Act
var instance = Container.Resolve <Outer>(
Override.Parameter <int>(Inject.Parameter(50)).OnType <Inner>());
// Verify
Assert.AreEqual(10, instance.LogLevel);
Assert.AreEqual(50, instance.Inner.LogLevel);
}
public void Overrides_TypePassedToFactoryAttr()
{
// Arrange
var resolver = new ValidatingResolverFactory(1);
Container.RegisterType <Service>(
new InjectionMethod(nameof(Service.DependencyAttribute)));
// Act
var result = Container.Resolve <Service>(Override.Parameter(typeof(object), "value", resolver));
// Assert
Assert.IsNotNull(result.Value);
Assert.IsInstanceOfType(result.Value, typeof(object));
Assert.AreEqual(1, result.Value);
Assert.AreEqual(typeof(object), resolver.Type);
}
// https://github.com/unitycontainer/container/issues/140
public void Issue_Container_140()
{
// Setup
var noOverride = "default";
var parOverride = "custom-via-parameteroverride";
var depOverride = "custom-via-dependencyoverride";
Container.RegisterType <Foo>(new InjectionConstructor(noOverride));
// Act
var defaultValue = Container.Resolve <Foo>().ToString();
var depValue = Container.Resolve <Foo>(Override.Dependency <string>(depOverride)).ToString();
var parValue = Container.Resolve <Foo>(Override.Parameter <string>("dependency", parOverride))
.ToString();
// Verify
Assert.AreSame(noOverride, defaultValue);
Assert.AreSame(parOverride, parValue);
Assert.AreSame(depOverride, depValue);
}
public void Overrides_TypeAndNamePassedToFactoryGeneric()
{
// Arrange
var value = "value";
var resolver = new ValidatingResolverFactory(value);
Container.RegisterType <Service>(
new InjectionMethod(nameof(Service.NamedDependencyAttribute)));
// Act
var result = Container.Resolve <Service>(Override.Parameter <string>("value", resolver));
// Assert
Assert.IsNotNull(result.Value);
Assert.IsInstanceOfType(result.Value, typeof(string));
Assert.AreEqual(value, result.Value);
Assert.AreEqual(typeof(string), resolver.Type);
Assert.AreEqual(Name, resolver.Name);
}
