public void BuildNullObject7()
{
UnityContainer uc = new UnityContainer();
SimpleClass myObject1 = new SimpleClass();
SimpleClass myObject2 = new SimpleClass();
uc.BuildUp(myObject1, String.Empty);
uc.BuildUp(myObject2, (string)null);
Assert.AreNotEqual(uc.Resolve<SimpleClass>(), myObject2);
}
protected override WorkflowServiceHost CreateWorkflowServiceHost(WorkflowService service, Uri[] baseAddresses)
{
var container = new UnityContainer();
ConfigureContainer(container);
var host = base.CreateWorkflowServiceHost(service, baseAddresses);
var injectionType = ConfigureInjectionType();
if (injectionType == InjectionTypes.Push)
{
container.AddNewExtension<WorkflowExtension>();
var rootActivity = host.Activity;
container.BuildUp(rootActivity.GetType(), rootActivity);
}
else
{
var diExtension = new DependencyInjectionExtension(container);
host.WorkflowExtensions.Add(diExtension);
}
ConfigureServiceHost(host);
return host;
}
public void BuildNullObject4()
{
UnityContainer uc = new UnityContainer();
object myNullObject = null;
AssertHelper.ThrowsException<ArgumentNullException>(() => uc.BuildUp(typeof(object), myNullObject, "myNullObject"), "Null object is not allowed");
}
public void BuildNullObject6()
{
UnityContainer uc = new UnityContainer();
SimpleClass myObject = new SimpleClass();
uc.BuildUp(myObject, String.Empty);
Assert.AreNotEqual(uc.Resolve<SimpleClass>(), myObject);
}
/// <summary>
/// When overridden in a derived class, creates a <see cref="T:System.ServiceModel.ServiceHostBase"/> with a specific base address using custom initiation data.
/// </summary>
/// <param name="constructorString">The initialization data that is passed to the <see cref="T:System.ServiceModel.ServiceHostBase"/> instance being constructed by the factory.</param>
/// <param name="baseAddresses">An <see cref="T:System.Array"/> of type <see cref="T:System.Uri"/> that contains the base addresses of the host.</param>
/// <returns>
/// The <see cref="T:System.ServiceModel.ServiceHostBase"/> object with the specified base addresses and initialized with the custom initiation data.
/// </returns>
public override ServiceHostBase CreateServiceHost(
string constructorString,
Uri[] baseAddresses)
{
var container = new UnityContainer().LoadConfiguration();
var instance = new ClientService { Container = container };
container.BuildUp(instance);
var serviceBusHost = new ServiceHost(instance, baseAddresses);
return serviceBusHost;
}
public void TypeBasedOverrideWithBuildUp()
{
MySimpleType instance = new MySimpleType();
instance.X = 111;
PropertyOverride overrideParam = new PropertyOverride("X", 222);
TypeBasedOverride overrideDecorator = new TypeBasedOverride(typeof(MySimpleType), overrideParam);
UnityContainer container = new UnityContainer();
var result = container.BuildUp<MySimpleType>(instance, overrideDecorator);
Assert.AreEqual<int>(222, result.X);
}
public void Check2PropertyDependencyBuildUpWorks()
{
UnityContainer uc = new UnityContainer();
My2PropertyDependencyClass obj1 = new My2PropertyDependencyClass();
Assert.IsNotNull(obj1);
Assert.IsNull(obj1.MyFirstObj);
Assert.IsNull(obj1.MySecondObj);
uc.BuildUp(obj1);
Assert.IsNotNull(obj1.MyFirstObj);
Assert.IsNotNull(obj1.MySecondObj);
}
public void BuildupLazyInstance()
{
IUnityContainer container = new UnityContainer();
container.RegisterType<Lazy<EmailService>>();
var lazyDependency = new Lazy<LazyDependency>();
var lazy = container.BuildUp(lazyDependency);
var lazyreturned = container.Resolve<Lazy<LazyDependency>>();
Assert.AreEqual(lazy, lazyDependency);
Assert.IsFalse(lazyreturned.IsValueCreated);
var ld = (LazyDependency)lazyreturned.Value;
Assert.IsFalse(ld.Service.IsValueCreated);
Assert.IsNotNull(ld.Service.Value);
}
private static void Main(string[] args)
{
if (args.Length == 0)
{
args = new[] { "10", "+", "20", "+", "30" };
}
using (var container = new UnityContainer())
{
Bootstrapper.SetupContainer(container);
var calculator = container.Resolve<ICalculator>();
int result = calculator.Evaluate(args);
var resultWriter = container.BuildUp(new ConsoleAndFileResultWriter("output.txt"));
resultWriter.WriteResult(result);
}
}
private static void Main(string[] args)
{
if (args.Length == 0)
{
args = new[] { "10", "+", "20", "+", "30" };
}
using (var container = new UnityContainer())
{
Bootstrapper.SetupContainer(container);
var calculator = container.Resolve<ICalculator>();
int result = calculator.Evaluate(args);
// This is the second possible solution - use a concrete type for variable passed to BuildUp method
ConsoleAndFileResultWriter resultWriter = new ConsoleAndFileResultWriter("output.txt");
resultWriter = container.BuildUp(resultWriter);
resultWriter.WriteResult(result);
}
}
public void BuildBaseAndChildObject4()
{
UnityContainer uc = new UnityContainer();
BaseStub1 objBase = new BaseStub1();
Assert.IsNotNull(objBase);
Assert.IsNull(objBase.InterfaceProp);
uc.BuildUp(typeof(Interface1), objBase);
Assert.IsNotNull(objBase.InterfaceProp);
}
public void IntegrationWithBitcoinDaemonTest()
{
var accountId = UnitTestHelper.Random.Next(1, int.MaxValue);
var container = new UnityContainer();
var logger = LogManager.GetLogger(typeof(IncomingTransactionProcessorTests));
container.RegisterInstance(logger);
var mockService = new Mock<IClientService>(MockBehavior.Strict);
container.RegisterInstance(mockService.Object);
var mockRpcClient = new Mock<RpcClient> { CallBase = true };
mockRpcClient.Object.Hostname = "127.0.0.1";
mockRpcClient.Object.PortNumber = 8502;
mockRpcClient.Object.Credential = new NetworkCredential("user", "password");
container.RegisterInstance<IRpcClient>(mockRpcClient.Object);
var processor = new Mock<IncomingTransactionProcessor> { CallBase = true };
container.BuildUp(processor.Object);
var amount = 0.00001m * UnitTestHelper.Random.Next(1, 100);
// Locate the most recent transaction before this point
// TODO: Magic number
var lastTransaction =
mockRpcClient.Object.GetTransactions(null, 100, 0).OrderBy(x => x.Time).Where(x => x.Category == "receive").LastOrDefault();
var lastTransactionId = lastTransaction == null ? null : lastTransaction.TransactionId;
Console.WriteLine("Last transaction (actual) before test is " + lastTransactionId ?? "<none>");
// Create a new address for the account
var accountAddress = mockRpcClient.Object.GetNewAddress(accountId.ToString(CultureInfo.InvariantCulture));
Console.WriteLine("New address for account " + accountId + " is " + accountAddress);
// Send the amount
var transactionId = mockRpcClient.Object.Send("Free", accountAddress, amount);
Console.WriteLine("Sent " + amount + " BTC from 'Free' to " + accountAddress + " with transaction id #" + transactionId);
var sessionId = Guid.NewGuid();
mockService.Setup(s => s.GetLastProcessedTransactionId(sessionId)).Returns(lastTransactionId);
mockService.Setup(s => s.TransactionIsProcessed(sessionId, transactionId)).Returns(false);
mockService.Setup(s => s.CreditTransactionWithHold(sessionId, accountId, transactionId, amount, "EXU"));
mockService.Setup(s => s.ReleaseTransactionHold(sessionId, transactionId));
Console.WriteLine("Processing transaction log. Mocking will prevent anything but #" + transactionId + " from being processed.");
// Act
processor.Object.Process(sessionId);
// Assert
mockService.Verify(s => s.GetLastProcessedTransactionId(sessionId));
mockService.Verify(s => s.TransactionIsProcessed(sessionId, transactionId));
mockService.Verify(s => s.CreditTransactionWithHold(sessionId, accountId, transactionId, amount, "EXU"));
mockService.Verify(s => s.ReleaseTransactionHold(sessionId, transactionId));
}
public void SuccessfulProcessTransaction1()
{
var accountId = UnitTestHelper.Random.Next(1, int.MaxValue);
var transaction = new Transaction
{
Account = accountId.ToString(CultureInfo.InvariantCulture),
Address = UnitTestHelper.Random.Next(1, int.MaxValue).ToString(CultureInfo.InvariantCulture),
Amount = (decimal)(UnitTestHelper.Random.NextDouble() * 10000) / 100m,
Category = "receive",
Confirmations = UnitTestHelper.Random.Next(1, 250),
Time = DateTime.UtcNow.AddDays(-UnitTestHelper.Random.Next(1, 100)),
TransactionId = UnitTestHelper.Random.Next(1, int.MaxValue).ToString(CultureInfo.InvariantCulture)
};
var container = new UnityContainer();
var logger = LogManager.GetLogger(typeof(IncomingTransactionProcessorTests));
container.RegisterInstance(logger);
var sessionId = Guid.NewGuid();
var mockService = new Mock<IClientService>(MockBehavior.Strict);
mockService.Setup(s => s.TransactionIsProcessed(sessionId, transaction.TransactionId)).Returns(false);
mockService.Setup(s => s.CreditTransactionWithHold(sessionId, accountId, transaction.TransactionId, transaction.Amount, "EXU"));
mockService.Setup(s => s.ReleaseTransactionHold(sessionId, transaction.TransactionId));
container.RegisterInstance(mockService.Object);
var mockRpcClient = new Mock<IRpcClient>(MockBehavior.Strict);
mockRpcClient.Setup(r => r.Move(transaction.Account, "EXU", transaction.Amount, 1, null));
container.RegisterInstance(mockRpcClient.Object);
var processor = new Mock<IncomingTransactionProcessor>() { CallBase = true };
container.BuildUp(processor.Object);
// Act
processor.Object.Process(sessionId, transaction);
// Assert
mockService.Verify(s => s.TransactionIsProcessed(sessionId, transaction.TransactionId), Times.Once());
mockService.Verify(s => s.CreditTransactionWithHold(sessionId, accountId, transaction.TransactionId, transaction.Amount, "EXU"), Times.Once());
mockService.Verify(s => s.ReleaseTransactionHold(sessionId, transaction.TransactionId), Times.Once());
mockRpcClient.Verify(r => r.Move(transaction.Account, "EXU", transaction.Amount, 1, null), Times.Once());
}
public void ShouldNotThrowIfValidationOnParameterAttributePasses()
{
IUnityContainer factory = new UnityContainer().AddNewExtension<Interception>();
factory.Configure<Interception>().SetDefaultInterceptorFor<TestObject>(new TransparentProxyInterceptor());
AddValidationPolicy(factory, string.Empty, SpecificationSource.Both,
new TypeMatchingRule("TestObject"));
TestObject target = factory.BuildUp<TestObject>(new TestObject(false, false));
target.GetValueByKey("key");
}
public void BuildUpPrimitiveAndDotNetClassTest()
{
IUnityContainer uc = new UnityContainer();
int i = 0;
uc.BuildUp(i, "a");
AssertHelper.ThrowsException<ResolutionFailedException>(() => uc.Resolve(typeof(int), "a"));
}
public void BuildUnmatchedObject1()
{
UnityContainer uc = new UnityContainer();
BuildUnmatchedObject1_TestClass obj1 = new BuildUnmatchedObject1_TestClass();
uc.BuildUp(typeof(object), obj1);
Assert.IsNull(obj1.MyFirstObj);
}
public void BuildNullObject11()
{
UnityContainer uc = new UnityContainer();
SimpleClass myObject1 = new SimpleClass();
uc.BuildUp(myObject1, " a b c ");
Assert.AreNotEqual(uc.Resolve(typeof(SimpleClass), "a b c"), myObject1);
}
public void BuildContainedObject1()
{
UnityContainer uc = new UnityContainer();
MainClass objMain = new MainClass();
Assert.IsNotNull(objMain);
Assert.IsNull(objMain.ContainedObj);
uc.BuildUp(objMain);
Assert.IsNotNull(objMain.ContainedObj);
Assert.IsNotNull(objMain.ContainedObj.DependencyProp1);
Assert.IsNull(objMain.ContainedObj.RegularProp1);
}
public void BuildUpTest()
{
IUnityContainer container = new UnityContainer();
container.BuildUp(this);
}
public void SuccessfulProcessTest1()
{
// Arrange
var container = new UnityContainer();
var appender = new log4net.Appender.ConsoleAppender { Layout = new log4net.Layout.SimpleLayout() };
log4net.Config.BasicConfigurator.Configure(appender);
var logger = LogManager.GetLogger(typeof(IncomingTransactionProcessorTests));
container.RegisterInstance(logger);
var sessionId = Guid.NewGuid();
var mockService = new Mock<IClientService>(MockBehavior.Strict);
mockService.Setup(s => s.GetLastProcessedTransactionId(sessionId)).Returns(default(string));
container.RegisterInstance(mockService.Object);
var mockRpcClient = new Mock<IRpcClient>(MockBehavior.Strict);
var transactions = new List<Transaction>
{
new Transaction
{
Account = "100",
Address = "address",
Amount = 50m,
Category = "receive",
Confirmations = 1,
Time = DateTime.UtcNow.AddMinutes(-11),
TransactionId = "1000"
},
new Transaction
{
Account = "101",
Address = "address",
Amount = 75m,
Category = "receive",
Confirmations = 1,
Time = DateTime.UtcNow.AddMinutes(-10),
TransactionId = "1001"
},
};
mockRpcClient.Setup(r => r.GetTransactions(null, 1000, 0)).Returns(transactions.Take(1).ToList());
////mockRpcClient.Setup(r => r.GetTransactions(null, 12, 0)).Returns(transactions.Take(2).ToList());
////mockRpcClient.Setup(r => r.GetTransactions(null, 14, 0)).Returns(transactions.Take(2).ToList());
container.RegisterInstance(mockRpcClient.Object);
var processor = new Mock<IncomingTransactionProcessor>() { CallBase = true };
processor.Setup(p => p.Process(sessionId, It.IsAny<Transaction>()));
container.BuildUp(processor.Object);
// Act
processor.Object.Process(sessionId);
// Assert
mockService.Verify(s => s.GetLastProcessedTransactionId(sessionId), Times.Once());
mockRpcClient.Verify(r => r.GetTransactions(null, 1000, 0), Times.Once());
////mockRpcClient.Verify(r => r.GetTransactions(null, 12, 0), Times.Once());
////mockRpcClient.Verify(r => r.GetTransactions(null, 14, 0), Times.Once());
processor.Verify(p => p.Process(sessionId, It.IsAny<Transaction>()), Times.Exactly(1));
}
public void BuildUnmatchedObject2()
{
UnityContainer uc = new UnityContainer();
BuildUnmatchedObject2__PropertyDependencyClassStub2 obj2 = new BuildUnmatchedObject2__PropertyDependencyClassStub2();
Assert.IsNotNull(obj2);
Assert.IsNull(obj2.MyFirstObj);
Assert.IsNull(obj2.MySecondObj);
AssertHelper.ThrowsException<ArgumentException>(() => uc.BuildUp(typeof(BuildUnmatchedObject2_PropertyDependencyClassStub1), obj2), "type of the object should match");
}
public void PropertyOverrideWithBuildUp()
{
MySimpleTypeForPropertyOverride instance = new MySimpleTypeForPropertyOverride();
instance.X = 111;
PropertyOverride overrideParam = new PropertyOverride("X", 222);
IUnityContainer container = new UnityContainer();
var result = container.BuildUp<MySimpleTypeForPropertyOverride>(instance, overrideParam);
Assert.AreEqual<int>(222, result.X);
}
static void BuildUp()
{
Console.Write("Straight:\t");
watch.Start();
for(int i = 0; i < n; ++i) {
var c = new TestClass5();
c.t = new TestClass1();
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Reset();
Console.Write("pooDI:\t\t");
watch.Start();
var pooDI = new DI.Container();
pooDI.RegisterType<ITestClass1, TestClass1>(false);
for(int i = 0; i < n; ++i) {
var c = new TestClass5();
pooDI.BuildUp<TestClass5>(c);
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Reset();
Console.Write("Unity:\t\t");
watch.Start();
var unity = new UnityContainer();
unity.RegisterType<ITestClass1, TestClass1>();
for(int i = 0; i < n; ++i) {
var c = new TestClass5();
unity.BuildUp<TestClass5>(c);
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Reset();
Console.Write("Ninject:\t");
watch.Start();
var kernel = new StandardKernel();
kernel.Bind<ITestClass1>().To<TestClass1>();
for(int i = 0; i < n; ++i) {
var c = new TestClass5();
kernel.Inject(c);
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Reset();
Console.Write("Autofac:\t");
watch.Start();
var builder = new ContainerBuilder();
builder.RegisterType<TestClass1>().As<ITestClass1>();
var container = builder.Build();
for(int i = 0; i < n; ++i) {
var c = new TestClass5();
container.InjectProperties<TestClass5>(c);
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Reset();
Console.WriteLine("Castle Windsor:\tNot supported");
}
public void BuildBaseAndChildObject3()
{
UnityContainer uc = new UnityContainer();
BaseStub1 objBase = new BaseStub1();
Assert.IsNotNull(objBase);
Assert.IsNull(objBase.BaseProp);
uc.BuildUp(typeof(BaseStub1), objBase);
Assert.IsNotNull(objBase.BaseProp);
AssertHelper.ThrowsException<ArgumentException>(() => uc.BuildUp(typeof(ChildStub1), objBase), "type of the object should match");
}
public void BuildBaseAndChildObject2()
{
UnityContainer uc = new UnityContainer();
ChildStub1 objChild = new ChildStub1();
Assert.IsNotNull(objChild);
Assert.IsNull(objChild.BaseProp);
Assert.IsNull(objChild.ChildProp);
uc.BuildUp(typeof(ChildStub1), objChild);
Assert.IsNotNull(objChild.BaseProp);
Assert.IsNotNull(objChild.ChildProp); //ChildProp get created
}
public void BuildBaseAndChildObject1()
{
UnityContainer uc = new UnityContainer();
ChildStub1 objChild = new ChildStub1();
Assert.IsNotNull(objChild);
Assert.IsNull(objChild.BaseProp);
Assert.IsNull(objChild.ChildProp);
uc.BuildUp(typeof(BaseStub1), objChild);
Assert.IsNotNull(objChild.BaseProp);
Assert.IsNull(objChild.ChildProp); //the base does not know about child, so it will not build the child property
uc.BuildUp(typeof(ChildStub1), objChild);
Assert.IsNotNull(objChild.BaseProp);
Assert.IsNotNull(objChild.ChildProp); //ChildProp get created
uc.BuildUp(typeof(BaseStub1), objChild);
Assert.IsNotNull(objChild.BaseProp);
Assert.IsNotNull(objChild.ChildProp); //ChildProp is not touched, so it is still NotNull
}
public void BuildAbstractBaseAndChildObject2()
{
UnityContainer uc = new UnityContainer();
ConcreteChild objChild = new ConcreteChild();
Assert.IsNotNull(objChild);
Assert.IsNull(objChild.AbsBaseProp);
Assert.IsNull(objChild.ChildProp);
uc.BuildUp(typeof(ConcreteChild), objChild);
Assert.IsNotNull(objChild.AbsBaseProp);
Assert.IsNotNull(objChild.ChildProp); //ChildProp get created
}
public void BuildInterfacePropertyInjectTest2()
{
UnityContainer uc = new UnityContainer();
BarClass2 objBase = new BarClass2();
uc.BuildUp(typeof(IFooInterface2), objBase);
Assert.IsNull(objBase.InterfaceProp);
}
public void CanOverrideInjectionPropertyForContainerControlledInstanceUsingBuildUp()
{
TypeToInjectForPropertyOverride1 defaultInjected = new TypeToInjectForPropertyOverride1(111);
TypeToInjectForPropertyOverride2 overrideInjected = new TypeToInjectForPropertyOverride2(222);
UnityContainer container = new UnityContainer();
container.RegisterType<ISubjectTypeToInjectForPropertyOverride, SubjectType1ToInjectForPropertyOverride>(
new ContainerControlledLifetimeManager(), new InjectionProperty("InjectedObject", defaultInjected));
var result1 = container.Resolve<SubjectType1ToInjectForPropertyOverride>();
var result2 = container.BuildUp<SubjectType1ToInjectForPropertyOverride>(result1,
new PropertyOverride("InjectedObject", overrideInjected));
var result3 = container.Resolve<SubjectType1ToInjectForPropertyOverride>();
Assert.AreEqual<SubjectType1ToInjectForPropertyOverride>(result1, result2);
Assert.IsInstanceOfType(result2.InjectedObject, typeof(TypeToInjectForPropertyOverride2));
Assert.AreEqual<int>(222, result2.InjectedObject.Value);
Assert.IsInstanceOfType(result3.InjectedObject, typeof(TypeToInjectForPropertyOverride2));
Assert.AreEqual<int>(222, result3.InjectedObject.Value);
}
/// <summary>
/// The get unity container.
/// </summary>
private static IUnityContainer CreateUnityContainer()
{
var container = new UnityContainer().LoadConfiguration();
// Bypass service proxy for local testing
#if Dev
container.RegisterInstance<IFaultFactory>(new FaultFactory());
container.RegisterType<IOliveContext, OliveContext>();
var clientService = new ClientService();
container.BuildUp(clientService);
container.RegisterInstance<IClientService>(clientService);
#else
// Register the channel factory in code for now, because I don't know how to
// register generic types in configuration files.
container.RegisterType<IChannelFactory<IClientService>, ChannelFactory<IClientService>>(new ContainerControlledLifetimeManager(), new InjectionConstructor(string.Empty));
// Register the service interface with a factory that creates it using the channel.
container.RegisterType<IClientService>(new InjectionFactory(c => c.Resolve<ChannelFactory<IClientService>>().CreateChannel()));
#endif
return container;
}
