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; }