public void ProbesSharedStateFactories() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); ISharedStateFactory ssf1 = A.Fake <ISharedStateFactory>(); ISharedStateFactory ssf2 = A.Fake <ISharedStateFactory>(); ISharedStateFactory ssf3 = A.Fake <ISharedStateFactory>(); ISharedStateFactory ssf4 = A.Fake <ISharedStateFactory>(); IDictionary ssf3ProvidedState = new Hashtable(); SharedStateAwareProcessor ssap = new SharedStateAwareProcessor(); ssap.SharedStateFactories = new ISharedStateFactory[] { ssf1, ssf2, ssf3, ssf4 }; of.RegisterSingleton("ssap", ssap); ISharedStateAware ssa = A.Fake <ISharedStateAware>(); // Ensure we iterate over configured SharedStateFactories until // the first provider is found that // a) true == provider.CanProvideState( instance, name ) // b) null != provider.GetSharedState( instance, name ) A.CallTo(() => ssa.SharedState).Returns(null).Once(); A.CallTo(() => ssf1.CanProvideState(ssa, "pageName")).Returns(false).Once(); A.CallTo(() => ssf2.CanProvideState(ssa, "pageName")).Returns(true).Once(); A.CallTo(() => ssf2.GetSharedStateFor(ssa, "pageName")).Returns(null); A.CallTo(() => ssf3.CanProvideState(ssa, "pageName")).Returns(true).Once(); A.CallTo(() => ssf3.GetSharedStateFor(ssa, "pageName")).Returns(ssf3ProvidedState).Once(); ssap.PostProcessBeforeInitialization(ssa, "pageName"); Assert.That(Equals(ssa.SharedState, ssf3ProvidedState)); }
/// <summary> /// Initializes a new instance of the <see cref="GenericApplicationContext"/> class. /// </summary> /// <param name="name">The name of the application context.</param> /// <param name="caseSensitive">if set to <c>true</c> names in the context are case sensitive.</param> /// <param name="parent">The parent application context.</param> /// <param name="objectFactory">The object factory to use for this context</param> public GenericApplicationContext(string name, bool caseSensitive, IApplicationContext parent, DefaultListableObjectFactory objectFactory) : base(name, caseSensitive, parent) { AssertUtils.ArgumentNotNull(objectFactory, "objectFactory", "ObjectFactory must not be null"); this.objectFactory = objectFactory; this.objectFactory.ParentObjectFactory = base.GetInternalParentObjectFactory(); }
private void InitFactory(DefaultListableObjectFactory factory) { Console.WriteLine("init factory"); RootObjectDefinition tee = new RootObjectDefinition(typeof(Tee), true); tee.IsLazyInit = true; ConstructorArgumentValues teeValues = new ConstructorArgumentValues(); teeValues.AddGenericArgumentValue("test"); tee.ConstructorArgumentValues = teeValues; RootObjectDefinition bar = new RootObjectDefinition(typeof(BBar), false); ConstructorArgumentValues barValues = new ConstructorArgumentValues(); barValues.AddGenericArgumentValue(new RuntimeObjectReference("tee")); barValues.AddGenericArgumentValue(5); bar.ConstructorArgumentValues = barValues; RootObjectDefinition foo = new RootObjectDefinition(typeof(FFoo), false); MutablePropertyValues fooValues = new MutablePropertyValues(); fooValues.Add("i", 5); fooValues.Add("bar", new RuntimeObjectReference("bar")); fooValues.Add("copy", new RuntimeObjectReference("bar")); fooValues.Add("s", "test"); foo.PropertyValues = fooValues; factory.RegisterObjectDefinition("foo", foo); factory.RegisterObjectDefinition("bar", bar); factory.RegisterObjectDefinition("tee", tee); }
public void SetUp() { this.objectFactory = new DefaultListableObjectFactory(); IObjectDefinitionReader reader = new XmlObjectDefinitionReader(this.objectFactory); reader.LoadObjectDefinitions(new ReadOnlyXmlTestResource("collectionMergingGeneric.xml", GetType())); }
public void MakeSurePrototypeTargetIsNotNeedlesslyCreatedDuringInitialization_Integration() { try { RootObjectDefinition advice = new RootObjectDefinition(typeof(NopInterceptor)); // prototype target... RootObjectDefinition target = new RootObjectDefinition(typeof(InstantiationCountingCommand), false); DefaultListableObjectFactory ctx = new DefaultListableObjectFactory(); ctx.RegisterObjectDefinition("advice", advice); ctx.RegisterObjectDefinition("prototype", target); ProxyFactoryObject fac = new ProxyFactoryObject(); fac.ProxyInterfaces = new string[] { typeof(ICommand).FullName }; fac.IsSingleton = false; fac.InterceptorNames = new string[] { "advice", "prototype" }; fac.ObjectFactory = ctx; Assert.AreEqual(0, InstantiationCountingCommand.NumberOfInstantiations, "Prototype target instance is being (needlessly) created during PFO initialization."); fac.GetObject(); Assert.AreEqual(1, InstantiationCountingCommand.NumberOfInstantiations, "Expected 1 inst"); fac.GetObject(); Assert.AreEqual(2, InstantiationCountingCommand.NumberOfInstantiations); } finally { InstantiationCountingCommand.NumberOfInstantiations = 0; } }
public void DoesNotAcceptInfrastructureAdvisorsDuringScanning() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); GenericObjectDefinition infrastructureAdvisorDefinition = new GenericObjectDefinition(); infrastructureAdvisorDefinition.ObjectType = typeof(TestAdvisor); infrastructureAdvisorDefinition.PropertyValues.Add("Name", "InfrastructureAdvisor"); infrastructureAdvisorDefinition.Role = ObjectRole.ROLE_INFRASTRUCTURE; of.RegisterObjectDefinition("infrastructure", infrastructureAdvisorDefinition); GenericObjectDefinition regularAdvisorDefinition = new GenericObjectDefinition(); regularAdvisorDefinition.ObjectType = typeof(TestAdvisor); regularAdvisorDefinition.PropertyValues.Add("Name", "RegularAdvisor"); // regularAdvisorDefinition.Role = ObjectRole.ROLE_APPLICATION; of.RegisterObjectDefinition("regular", regularAdvisorDefinition); TestAdvisorAutoProxyCreator apc = new TestAdvisorAutoProxyCreator(); apc.ObjectFactory = of; object[] advisors = apc.GetAdvicesAndAdvisorsForObject(typeof(object), "dummyTarget"); Assert.AreEqual(1, advisors.Length); Assert.AreEqual("RegularAdvisor", ((TestAdvisor)advisors[0]).Name); Assert.AreEqual(1, apc.CheckedAdvisors.Count); Assert.AreEqual("regular", apc.CheckedAdvisors[0]); }
public void IgnoresAlreadyPopulatedState() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); MockRepository mocks = new MockRepository(); ISharedStateFactory ssf1 = (ISharedStateFactory)mocks.CreateMock(typeof(ISharedStateFactory)); ISharedStateAware ssa = (ISharedStateAware)mocks.DynamicMock(typeof(ISharedStateAware)); SharedStateAwareProcessor ssap = new SharedStateAwareProcessor(); ssap.SharedStateFactories = new ISharedStateFactory[] { ssf1 }; of.RegisterSingleton("ssap", ssap); using (Record(mocks)) { // preset SharedState - ssap must ignore it Expect.Call(ssa.SharedState).Return(new Hashtable()); // expect nothing else! } using (Playback(mocks)) { ssap.PostProcessBeforeInitialization(ssa, "myPage"); } }
public void ThrowsTypeLoadExceptionIfProxyInterfacesValueIsSpecifiedInsteadOfListElement() { using (DefaultListableObjectFactory of = new DefaultListableObjectFactory()) { XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(of); reader.LoadObjectDefinitions(new StringResource( @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:r='http://www.springframework.net/remoting'> <r:saoExporter id='ISimpleCounterExporter' targetName='ISimpleCounterProxy' serviceName='RemotedSaoCounterProxy' /> <object id='ISimpleCounter' type='Spring.Remoting.SimpleCounter, Spring.Services.Tests' /> <object id='ISimpleCounterProxy' type='Spring.Aop.Framework.ProxyFactoryObject, Spring.Aop'> <property name='proxyInterfaces' value='Spring.Remoting.ISimpleCounter, Spring.Services.Tests' /> <property name='target' ref='ISimpleCounter'/> </object> </objects> ")); try { SaoExporter saoExporter = (SaoExporter)of.GetObject("ISimpleCounterExporter"); Assert.Fail(); } catch (ObjectCreationException oce) { TypeLoadException tle = (TypeLoadException)oce.GetBaseException(); Assert.AreEqual("Could not load type from string value ' Spring.Services.Tests'.", tle.Message); } } }
public void SingletonProxyWithPrototypeTargetCreatesTargetOnlyOnce() { try { RootObjectDefinition advice = new RootObjectDefinition(typeof(NopInterceptor)); // prototype target... RootObjectDefinition target = new RootObjectDefinition(typeof(InstantiationCountingCommand), false); DefaultListableObjectFactory ctx = new DefaultListableObjectFactory(); ctx.RegisterObjectDefinition("advice", advice); ctx.RegisterObjectDefinition("prototype", target); ProxyFactoryObject fac = new ProxyFactoryObject(); fac.ProxyInterfaces = new string[] { typeof(ICommand).FullName }; fac.IsSingleton = true; fac.InterceptorNames = new string[] { "advice", "prototype" }; fac.ObjectFactory = ctx; Assert.AreEqual(0, InstantiationCountingCommand.NumberOfInstantiations, "First Call"); fac.GetObject(); Assert.AreEqual(1, InstantiationCountingCommand.NumberOfInstantiations, "Second Call"); fac.GetObject(); Assert.AreEqual(1, InstantiationCountingCommand.NumberOfInstantiations, "Third Call"); } finally { InstantiationCountingCommand.NumberOfInstantiations = 0; } }
public void CanExportFromFactoryObjectIfObjectTypeIsInterface() { using (DefaultListableObjectFactory of = new DefaultListableObjectFactory()) { MockRepository mocks = new MockRepository(); IFactoryObject simpleCounterFactory = (IFactoryObject)mocks.DynamicMock(typeof(IFactoryObject)); Expect.Call(simpleCounterFactory.ObjectType).Return(typeof(ISimpleCounter)); Expect.Call(simpleCounterFactory.IsSingleton).Return(true); Expect.Call(simpleCounterFactory.GetObject()).Return(new SimpleCounter()); mocks.ReplayAll(); of.RegisterSingleton("simpleCounter", simpleCounterFactory); SaoExporter saoExporter = new SaoExporter(); saoExporter.ObjectFactory = of; saoExporter.TargetName = "simpleCounter"; saoExporter.ServiceName = "RemotedSaoCallCounter"; saoExporter.AfterPropertiesSet(); of.RegisterSingleton("simpleCounterExporter", saoExporter); // also tests SaoExporter.Dispose()! AssertExportedService(saoExporter.ServiceName, 2); mocks.VerifyAll(); } }
public void SunnyDayReplaceMethod_WithArgumentAcceptingReplacer() { RootObjectDefinition replacerDef = new RootObjectDefinition(typeof(NewsFeedFactory)); RootObjectDefinition managerDef = new RootObjectDefinition(typeof(NewsFeedManagerWith_Replace_MethodThatTakesArguments)); ReplacedMethodOverride theOverride = new ReplacedMethodOverride("CreateNewsFeed", "replacer"); // we must specify parameter type fragments... theOverride.AddTypeIdentifier(typeof(string).FullName); managerDef.MethodOverrides.Add(theOverride); DefaultListableObjectFactory factory = new DefaultListableObjectFactory(); factory.RegisterObjectDefinition("manager", managerDef); factory.RegisterObjectDefinition("replacer", replacerDef); NewsFeedManagerWith_Replace_MethodThatTakesArguments manager = (NewsFeedManagerWith_Replace_MethodThatTakesArguments)factory["manager"]; NewsFeed feed1 = manager.CreateNewsFeed("So sad... to be all alone in the world"); Assert.IsNotNull(feed1, "The CreateNewsFeed() method is not being replaced."); Assert.AreEqual("So sad... to be all alone in the world", feed1.Name); NewsFeed feed2 = manager.CreateNewsFeed("Oh Muzzy!"); // NewsFeedFactory always yields a new NewsFeed (see class definition below)... Assert.IsFalse(ReferenceEquals(feed1, feed2)); }
public void LookupMethodWithNullMethodInstantiatedWithCtorArg() { RootObjectDefinition feedDef = new RootObjectDefinition(typeof(NewsFeed)); feedDef.IsSingleton = false; feedDef.PropertyValues.Add("name", "Bingo"); RootObjectDefinition managerDef = new RootObjectDefinition(typeof(ReturnsNullNewsFeedManager)); managerDef.MethodOverrides.Add(new LookupMethodOverride("CreateNewsFeed", "feed")); managerDef.ConstructorArgumentValues.AddNamedArgumentValue("name", "Bingo"); DefaultListableObjectFactory factory = new DefaultListableObjectFactory(); factory.RegisterObjectDefinition("manager", managerDef); factory.RegisterObjectDefinition("feed", feedDef); ReturnsNullNewsFeedManager manager = (ReturnsNullNewsFeedManager)factory["manager"]; Assert.AreEqual("Bingo", manager.Name); NewsFeed feed1 = manager.CreateNewsFeed(); Assert.IsNotNull(feed1, "The CreateNewsFeed() method is not being replaced."); NewsFeed feed2 = manager.CreateNewsFeed(); // assert that the object (prototype) is definitely being looked up each time... Assert.IsFalse(ReferenceEquals(feed1, feed2)); }
public void LookupMethodWithNullMethod() { try { RootObjectDefinition feedDef = new RootObjectDefinition(typeof(NewsFeed)); feedDef.IsSingleton = false; feedDef.PropertyValues.Add("name", "Bingo"); RootObjectDefinition managerDef = new RootObjectDefinition(typeof(ReturnsNullNewsFeedManager)); managerDef.MethodOverrides.Add(new LookupMethodOverride("CreateNewsFeed", "feed")); DefaultListableObjectFactory factory = new DefaultListableObjectFactory(); factory.RegisterObjectDefinition("manager", managerDef); factory.RegisterObjectDefinition("feed", feedDef); INewsFeedManager manager = (INewsFeedManager)factory["manager"]; NewsFeed feed1 = manager.CreateNewsFeed(); Assert.IsNotNull(feed1, "The CreateNewsFeed() method is not being replaced."); NewsFeed feed2 = manager.CreateNewsFeed(); // assert that the object (prototype) is definitely being looked up each time... Assert.IsFalse(ReferenceEquals(feed1, feed2)); } catch (Exception ex) { Console.Out.WriteLine("ex = {0}", ex); } }
[Ignore] //this test cannot co-exist with AutoRegistersAllWellknownNamespaceParsers b/c that test will have already loaded the Spring.Data ass'y public void AutoRegistersWellknownNamespaceParser() { try { Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); foreach (Assembly assembly in loadedAssemblies) { if (assembly.GetName(true).Name.StartsWith("Spring.Data")) { Assert.Fail("Spring.Data is already loaded - this test checks if it gets loaded during xml parsing"); } } NamespaceParserRegistry.Reset(); DefaultListableObjectFactory of = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(of); reader.LoadObjectDefinitions(new StringResource( @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:tx='http://www.springframework.net/tx'> <tx:attribute-driven /> </objects> ")); object apc = of.GetObject(AopNamespaceUtils.AUTO_PROXY_CREATOR_OBJECT_NAME); Assert.NotNull(apc); } finally { NamespaceParserRegistry.Reset(); } }
protected void SetUp() { parent = new DefaultListableObjectFactory(); IDictionary m = new Hashtable(); m["name"] = "Albert"; parent.RegisterObjectDefinition("father", new RootObjectDefinition(typeof(TestObject), new MutablePropertyValues(m))); m = new Hashtable(); m["name"] = "Roderick"; parent.RegisterObjectDefinition("rod", new RootObjectDefinition(typeof(TestObject), new MutablePropertyValues(m))); // for testing dynamic ctor arguments + parent.GetObject() call propagation parent.RegisterObjectDefinition("namedfather", new RootObjectDefinition(typeof(TestObject), false)); parent.RegisterObjectDefinition("typedfather", new RootObjectDefinition(typeof(TestObject), false)); // add unsupported IObjectDefinition implementation... UnsupportedObjectDefinitionImplementation unsupportedDefinition = new UnsupportedObjectDefinitionImplementation(); parent.RegisterObjectDefinition("unsupportedDefinition", unsupportedDefinition); XmlObjectFactory factory; factory = new XmlObjectFactory(new ReadOnlyXmlTestResource("test.xml", GetType()), parent); // TODO: should this be allowed? //this.factory.RegisterObjectDefinition("typedfather", new RootObjectDefinition(typeof(object), false)); factory.AddObjectPostProcessor(new AnonymousClassObjectPostProcessor()); factory.AddObjectPostProcessor(new LifecycleObject.PostProcessor()); factory.PreInstantiateSingletons(); base.ObjectFactory = factory; }
public void ProxyTransparentProxy() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); ConstructorArgumentValues ctorArgs = new ConstructorArgumentValues(); ctorArgs.AddNamedArgumentValue("objectType", typeof(ITestObject)); of.RegisterObjectDefinition("bar", new RootObjectDefinition(typeof(TransparentProxyFactory), ctorArgs, null)); TestAutoProxyCreator apc = new TestAutoProxyCreator(of); of.AddObjectPostProcessor(apc); ITestObject o = of.GetObject("bar") as ITestObject; Assert.IsTrue(AopUtils.IsAopProxy(o)); // ensure interceptors get called o.Foo(); Assert.AreEqual(1, apc.NopInterceptor.Count); IAdvised advised = (IAdvised)o; // ensure target was called object target = advised.TargetSource.GetTarget(); Assert.AreEqual(1, TransparentProxyFactory.GetRealProxy(target).Count); }
/// <summary> /// Load all registered configuration into spring. This method should only be called internally by the FluentApplicationContext, i.e. you shouldn't call it. /// </summary> /// <param name="objectFactory">The object factory.</param> public static void LoadConfiguration(DefaultListableObjectFactory objectFactory) { // This check is mainly for backward compability and avoid people trying to register their configuration twice. if (!_configurationRegistry.ContainsConfiguration()) { if (_assembliesList.Count == 0) { _assembliesList.Add(() => AppDomain.CurrentDomain.GetAssemblies()); } IList <Type> applicationContextConfigurerTypes = new List <Type>(); // only load the configuration once (in case the assembly was registered twice) foreach (Type type in from assemblies in _assembliesList from assembly in assemblies() from type in assembly.GetTypes() where type.GetInterfaces().Contains(typeof(ICanConfigureApplicationContext)) where !applicationContextConfigurerTypes.Contains(type) select type) { applicationContextConfigurerTypes.Add(type); } // load each class containing configuration. foreach (ICanConfigureApplicationContext contextConfigurer in applicationContextConfigurerTypes.Select(applicationContextConfigurerType => (ICanConfigureApplicationContext)Activator.CreateInstance(applicationContextConfigurerType))) { contextConfigurer.Configure(); } } _configurationRegistry.LoadObjectDefinitions(objectFactory); }
public void Setup() { objectFactory = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(objectFactory); reader.LoadObjectDefinitions(new ReadOnlyXmlTestResource("objectNameGeneration.xml", GetType())); }
public void ParsesAutowireCandidate() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(of); reader.LoadObjectDefinitions(new StringResource( @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' default-autowire-candidates='test1*,test4*'> <object id='test1' type='Spring.Objects.TestObject, Spring.Core.Tests' /> <object id='test2' type='Spring.Objects.TestObject, Spring.Core.Tests' autowire-candidate='false' /> <object id='test3' type='Spring.Objects.TestObject, Spring.Core.Tests' autowire-candidate='true' /> <object id='test4' type='Spring.Objects.TestObject, Spring.Core.Tests' autowire-candidate='default' /> <object id='test5' type='Spring.Objects.TestObject, Spring.Core.Tests' autowire-candidate='default' /> </objects> ")); var od = (AbstractObjectDefinition)of.GetObjectDefinition("test1"); Assert.That(od.IsAutowireCandidate, Is.True, "No attribute set should default to true"); od = (AbstractObjectDefinition)of.GetObjectDefinition("test2"); Assert.That(od.IsAutowireCandidate, Is.False, "Specifically attribute set to false should set to false"); od = (AbstractObjectDefinition)of.GetObjectDefinition("test3"); Assert.That(od.IsAutowireCandidate, Is.True, "Specifically attribute set to true should set to false"); od = (AbstractObjectDefinition)of.GetObjectDefinition("test4"); Assert.That(od.IsAutowireCandidate, Is.True, "Attribute set to default should check pattern and return true"); od = (AbstractObjectDefinition)of.GetObjectDefinition("test5"); Assert.That(od.IsAutowireCandidate, Is.False, "Attribute set to default should check pattern and return false"); }
public void ParsesObjectAttributes() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(of); reader.LoadObjectDefinitions(new StringResource( @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net'> <object id='test1' type='Spring.Objects.TestObject, Spring.Core.Tests' singleton='false' abstract='true' /> <object id='test2' type='Spring.Objects.TestObject, Spring.Core.Tests' singleton='true' abstract='false' lazy-init='true' autowire='no' dependency-check='simple' depends-on='test1' init-method='init' destroy-method='destroy' /> </objects> ")); AbstractObjectDefinition od1 = (AbstractObjectDefinition)of.GetObjectDefinition("test1"); Assert.IsFalse(od1.IsSingleton); Assert.IsTrue(od1.IsAbstract); Assert.IsFalse(od1.IsLazyInit); AbstractObjectDefinition od2 = (AbstractObjectDefinition)of.GetObjectDefinition("test2"); Assert.IsTrue(od2.IsSingleton); Assert.IsFalse(od2.IsAbstract); Assert.IsTrue(od2.IsLazyInit); Assert.AreEqual(AutoWiringMode.No, od2.AutowireMode); Assert.AreEqual("init", od2.InitMethodName); Assert.AreEqual("destroy", od2.DestroyMethodName); Assert.AreEqual(1, od2.DependsOn.Count); Assert.AreEqual("test1", od2.DependsOn[0]); Assert.AreEqual(DependencyCheckingMode.Simple, od2.DependencyCheck); }
public void ParsesNonDefaultNamespace() { try { NamespaceParserRegistry.Reset(); DefaultListableObjectFactory of = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(of); reader.LoadObjectDefinitions(new StringResource( @"<?xml version='1.0' encoding='UTF-8' ?> <core:objects xmlns:core='http://www.springframework.net'> <core:object id='test2' type='Spring.Objects.TestObject, Spring.Core.Tests'> <core:property name='Sibling'> <core:object type='Spring.Objects.TestObject, Spring.Core.Tests' /> </core:property> </core:object> </core:objects> ")); TestObject test2 = (TestObject)of.GetObject("test2"); Assert.AreEqual(typeof(TestObject), test2.GetType()); Assert.IsNotNull(test2.Sibling); } finally { NamespaceParserRegistry.Reset(); } }
private static NamedObjectDefinition Find(string url, string objectName) { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); RootObjectDefinition rod = new RootObjectDefinition(typeof(Type1)); of.RegisterObjectDefinition(objectName, rod); return(FindWebObjectDefinition(url, of)); }
public void OrderOfKnownProcessorInterfaces() { DefaultListableObjectFactory objectFactory = (DefaultListableObjectFactory)this._context.ObjectFactory; RootObjectDefinition def; def = new RootObjectDefinition(typeof(EverythingAwareObjectPostProcessor)); objectFactory.RegisterObjectDefinition("everythingAwareObjectPostProcessor", def); _context.Refresh(); }
protected override void AddPersistenceExceptionTranslation(ProxyFactory pf, IPersistenceExceptionTranslator pet) { if (AttributeUtils.FindAttribute(pf.TargetType, typeof(RepositoryAttribute)) != null) { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); of.RegisterObjectDefinition("peti", new RootObjectDefinition(typeof(PersistenceExceptionTranslationInterceptor))); of.RegisterSingleton("pet", pet); pf.AddAdvice((PersistenceExceptionTranslationInterceptor)of.GetObject("peti")); } }
public void Can_Create_Custom_Scan_Routine() { var scanner = new ScanOverridingAssemblyObjectDefinitionScanner(); var registry = new DefaultListableObjectFactory(); scanner.ScanAndRegisterTypes(registry); Assert.That(registry.ObjectDefinitionCount, Is.EqualTo(1), "found multiple definitions"); Assert.That(registry.GetObject <ComponentScan.ScanComponentsAndAddToContext.ConfigurationImpl>(), Is.Not.Null, "correct single defintion was not registered"); }
public void CanCreateHostTwice() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); string svcRegisteredName = System.Guid.NewGuid().ToString(); of.RegisterObjectDefinition(svcRegisteredName, new RootObjectDefinition(new RootObjectDefinition(typeof(Service)))); SpringServiceHost ssh = new SpringServiceHost(svcRegisteredName, of, true); SpringServiceHost ssh1 = new SpringServiceHost(svcRegisteredName, of, true); }
public void BailsIfTargetNotFound() { using (DefaultListableObjectFactory of = new DefaultListableObjectFactory()) { SaoExporter saoExporter = new SaoExporter(); saoExporter.ObjectFactory = of; saoExporter.TargetName = "DOESNOTEXIST"; saoExporter.ServiceName = "RemotedSaoSingletonCounter"; saoExporter.AfterPropertiesSet(); } }
public void ThrowsObjectDefinitionStoreExceptionOnErrorDuringObjectDefinitionRegistration() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new TestXmlObjectDefinitionReader(of); reader.LoadObjectDefinitions(new StringResource( @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net'> <object id='test2' type='Spring.Objects.TestObject, Spring.Core.Tests' /> </objects> ")); }
public void DefaultObjectFactoryProcessorsDontGetAddedTwice() { MockApplicationContext myContext = new MockApplicationContext("myContext"); DefaultListableObjectFactory objectFactory = (DefaultListableObjectFactory)myContext.ObjectFactory; Assert.AreEqual(0, objectFactory.ObjectPostProcessorCount); myContext.Refresh(); int defaultProcessors = objectFactory.ObjectPostProcessors.Count; myContext.Refresh(); Assert.AreEqual(defaultProcessors, objectFactory.ObjectPostProcessors.Count); }
public virtual void StaticEventWiring() { DefaultListableObjectFactory factory = new DefaultListableObjectFactory(); XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(factory); reader.LoadObjectDefinitions(new ReadOnlyXmlTestResource("event-wiring.xml", GetType())); TestEventHandler staticHandler = factory["staticEventListener"] as TestEventHandler; // raise the event... handlers should be notified at this point (obviously) TestObject.OnStaticClick(); Assert.IsTrue(staticHandler.EventWasHandled, "The instance handler did not get notified when the static event was raised (and was probably not wired up in the first place)."); }