public void CannotInsertOneNameTwice() { var store = new ComponentStore(); var name = "test"; store.Add<IService, ClassWithNoDependencies>(name); Assert.Throws<NameAlreadyRegisteredException>(() => store.Add<IService, ClassWithNoDependencies>(name)); }
public void CanInsertServiceTwice() { var store = new ComponentStore(); store.Add<IService, ClassWithNoDependencies>(); Assert.DoesNotThrow(() => store.Add<IService, ClassWithNoDependencies>()); }
public void CanSplitGraph() { /* * Dotty Graph: * * digraph G { * a [label="IService :: A"] ; * a -> b [label="service1"] ; * a -> c [label="service2"] ; * b [label="IService :: B"] ; * b -> d ; * d [label="IService :: C"] ; * c [label="IService :: B"] ; * c -> f ; * f [label="IService :: C"] ; * } */ var store = new ComponentStore(); store.Add <IService, ClassWithTwoDependenciesOnItsOwnService>(); store.Add <IService, ClassWithDependencyOnItsOwnService>(); store.Add <IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve <IService>(); Assert.IsType(typeof(ClassWithTwoDependenciesOnItsOwnService), service); }
public void CanInsertServiceTwice() { var store = new ComponentStore(); store.Add <IService, ClassWithNoDependencies>(); Assert.DoesNotThrow(() => store.Add <IService, ClassWithNoDependencies>()); }
public void CanInsertServiceTwice() { var store = new ComponentStore(); store.Add <IService, ClassWithNoDependencies>(); store.Add <IService, ClassWithNoDependencies>(); }
public void CannotInsertOneNameTwice() { var store = new ComponentStore(); var name = "test"; store.Add <IService, ClassWithNoDependencies>(name); Assert.Throws <NameAlreadyRegisteredException>(() => store.Add <IService, ClassWithNoDependencies>(name)); }
public void CanResolveClassWithOneDependency() { IComponentStore componentStore = new ComponentStore(); componentStore.Add<IService, ClassWithNoDependencies>(); componentStore.Add<IService2, ClassWithOneDependency>(); PandoraContainer locator = new PandoraContainer(componentStore); var result = locator.Resolve<IService2>(); Assert.IsType<ClassWithOneDependency>(result); }
public void CanResolveClassWithTwoDependenciesOnItsOwnServiceWithOnlyOneSubdependencyRegistration() { var store = new ComponentStore(); store.Add<IService, ClassWithTwoDependenciesOnItsOwnService>(); store.Add<IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve<IService>(); Assert.IsType(typeof (ClassWithTwoDependenciesOnItsOwnService), service); }
public void CanRetrieveServiceByName() { var store = new ComponentStore(); //This registration is to give the container something to choose from, in case named lookup won't work store.Add<IService, ClassWithDependencyOnItsOwnService>("memory.repository"); store.Add<IService, ClassWithNoDependencies>("db.repository"); var container = new PandoraContainer(store); var service = container.Resolve<IService>("db.repository"); Assert.IsType<ClassWithNoDependencies>(service); }
public void DependencyMissingExceptionPropagatesThroughMultipleLevels() { var store = new ComponentStore(); store.Add <IService3, ClassDependingOnClassWithOneDependency>(); store.Add <IService2, ClassWithOneDependency>(); var container = new PandoraContainer(store); Assert.Throws <DependencyMissingException>(() => container.Resolve <IService3>()); }
public void ReturnsAllServicesForGivenType() { var store = new ComponentStore(); store.Add<IService, ClassWithNoDependencies>("test1"); store.Add<IService, ClassWithDependencyOnItsOwnService>(); store.Add<IService2, ClassWithOneDependency>(); var container = new PandoraContainer(store); var enumerable = container.ResolveAll<IService>(); Assert.Equal(2, enumerable.Count()); }
public void CanResolveClassWithOneDependency() { IComponentStore componentStore = new ComponentStore(); componentStore.Add <IService, ClassWithNoDependencies>(); componentStore.Add <IService2, ClassWithOneDependency>(); PandoraContainer locator = new PandoraContainer(componentStore); var result = locator.Resolve <IService2>(); Assert.IsType <ClassWithOneDependency>(result); }
public void CanResolveClassWithMultipleDependencies() { var store = new ComponentStore(); store.Add<IService, ClassWithNoDependencies>(); store.Add<IService2, ClassWithOneDependency>(); store.Add<IService3, ClassDependingOnClassWithOneDependency>(); var container = new PandoraContainer(store); var result = container.Resolve<IService3>(); Assert.IsType<ClassDependingOnClassWithOneDependency>(result); }
public void CanResolveClassWithMultipleDependencies() { var store = new ComponentStore(); store.Add <IService, ClassWithNoDependencies>(); store.Add <IService2, ClassWithOneDependency>(); store.Add <IService3, ClassDependingOnClassWithOneDependency>(); var container = new PandoraContainer(store); var result = container.Resolve <IService3>(); Assert.IsType <ClassDependingOnClassWithOneDependency>(result); }
public void CanRetrieveServiceByName() { var store = new ComponentStore(); //This registration is to give the container something to choose from, in case named lookup won't work store.Add <IService, ClassWithDependencyOnItsOwnService>("memory.repository"); store.Add <IService, ClassWithNoDependencies>("db.repository"); var container = new PandoraContainer(store); var service = container.Resolve <IService>("db.repository"); Assert.IsType <ClassWithNoDependencies>(service); }
public void CanSpecifyDependencyByName() { var store = new ComponentStore(); store.Add<IService, ClassWithNoDependencies>("service1"); store.Add<IService, ClassWithNoDependencies2>("service2"); store.Add<ClassWithOneDependency, ClassWithOneDependency>() .Parameters["dependency"] = "service2"; var container = new PandoraContainer(store); var service2 = container.Resolve<ClassWithOneDependency>(); Assert.IsType<ClassWithNoDependencies2>(service2.Dependency); }
public void ReturnsAllServicesForGivenType() { var store = new ComponentStore(); store.Add <IService, ClassWithNoDependencies>("test1"); store.Add <IService, ClassWithDependencyOnItsOwnService>(); store.Add <IService2, ClassWithOneDependency>(); var container = new PandoraContainer(store); var enumerable = container.ResolveAll <IService>(); Assert.Equal(2, enumerable.Count()); }
public void CanResolveClassWithTwoDependenciesOnItsOwnServiceWithOnlyOneSubdependencyRegistration() { var store = new ComponentStore(); store.Add <IService, ClassWithTwoDependenciesOnItsOwnService>(); store.Add <IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve <IService>(); Assert.IsType(typeof(ClassWithTwoDependenciesOnItsOwnService), service); }
public void CanSpecifyDependencyByName() { var store = new ComponentStore(); store.Add <IService, ClassWithNoDependencies>("service1"); store.Add <IService, ClassWithNoDependencies2>("service2"); store.Add <ClassWithOneDependency, ClassWithOneDependency>() .Parameters["dependency"] = "service2"; var container = new PandoraContainer(store); var service2 = container.Resolve <ClassWithOneDependency>(); Assert.IsType <ClassWithNoDependencies2>(service2.Dependency); }
public void CanResolveDependencyChainOfSameService() { var store = new ComponentStore(); store.Add <IService, ClassWithDependencyOnItsOwnService>(); store.Add <IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve <IService>(); Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), service); var ownService = (ClassWithDependencyOnItsOwnService)service; Assert.IsType(typeof(ClassWithNoDependencies), ownService.SubService); }
public void CanResolveConcreteType() { var store = new ComponentStore(); store.Add<ClassWithNoDependencies, ClassWithNoDependencies>(); var container = new PandoraContainer(store); Assert.DoesNotThrow(() => container.Resolve<ClassWithNoDependencies>()); }
public void ThrowsExceptionIfDependencyCouldNotBeSatisfied() { var store = new ComponentStore(); store.Add <ClassWithOneDependency, ClassWithOneDependency>(); var container = new PandoraContainer(store); Assert.Throws <DependencyMissingException>(() => container.Resolve <ClassWithOneDependency>()); }
public void CanResolveConcreteType() { var store = new ComponentStore(); store.Add <ClassWithNoDependencies, ClassWithNoDependencies>(); var container = new PandoraContainer(store); container.Resolve <ClassWithNoDependencies>(); }
public void CanResolveWhenGivenTwoConstructorsWhereOneCantBeSatisfied() { var store = new ComponentStore(); store.Add <IService4, ClassWithMultipleConstructors>(); var container = new PandoraContainer(store); container.Resolve <IService4>(); }
public void CanInsertRegistration() { var store = new ComponentStore(); store.Add <IService, ClassWithNoDependencies>(); var registration = store.GetRegistrationsForService <IService>()[0]; Assert.Equal(registration.Implementor, typeof(ClassWithNoDependencies)); }
public void ExcludesServicesThatCantBeCreated() { var store = new ComponentStore(); store.Add<IService, ClassWithDependencyOnItsOwnService>(); var container = new PandoraContainer(store); var enumerable = container.ResolveAll<IService>(); Assert.Equal(0, enumerable.Count()); }
public void CanResolveClassWithoutDependencies() { var componentStore = new ComponentStore(); componentStore.Add<IService, ClassWithNoDependencies>(); var container = new PandoraContainer(componentStore); var result = container.Resolve<IService>(); Assert.IsType<ClassWithNoDependencies>(result); }
public void ThrowsDependencyMissingExceptionIfDependencyChainCannotBeSatisfied() { var store = new ComponentStore(); store.Add <IService, ClassWithDependencyOnItsOwnService>(); var container = new PandoraContainer(store); Assert.Throws <DependencyMissingException>(() => container.Resolve <IService>()); }
public void ExcludesServicesThatCantBeCreated() { var store = new ComponentStore(); store.Add <IService, ClassWithDependencyOnItsOwnService>(); var container = new PandoraContainer(store); var enumerable = container.ResolveAll <IService>(); Assert.Equal(0, enumerable.Count()); }
public void CanResolveDependencyChainOfSameServiceWithMultipleLevels() { var store = new ComponentStore(); store.Add <IService, ClassWithDependencyOnItsOwnService>(); store.Add <IService, ClassWithDependencyOnItsOwnService>(); store.Add <IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve <IService>(); var level1 = (ClassWithDependencyOnItsOwnService)service; var level2 = (ClassWithDependencyOnItsOwnService)level1.SubService; var level3 = (ClassWithNoDependencies)level2.SubService; Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level1); Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level2); Assert.IsType(typeof(ClassWithNoDependencies), level3); }
public void CanInsertRegistration() { var store = new ComponentStore(); Assert.DoesNotThrow(() => store.Add<IService, ClassWithNoDependencies>() ); var registration = store.GetRegistrationsForService<IService>()[0]; Assert.Equal(registration.Implementor, typeof(ClassWithNoDependencies)); }
public void CanResolveClassWithoutDependencies() { var componentStore = new ComponentStore(); componentStore.Add <IService, ClassWithNoDependencies>(); var container = new PandoraContainer(componentStore); var result = container.Resolve <IService>(); Assert.IsType <ClassWithNoDependencies>(result); }
public void ActivationHappensEveryTime() { var store = new ComponentStore(); var registration = store.Add<IService, ClassWithNoDependencies>(); registration.Lifestyle = ComponentLifestyles.Transient; var container = new PandoraContainer(store); var service = container.Resolve<IService>(); var service2 = container.Resolve<IService>(); Assert.NotSame(service, service2); }
public void Update(GameTime gameTime) { var asteroids = _components.GetAllOfType <Asteroid>(); foreach (var asteroid in asteroids) { if (asteroid.Destroyed) { if (asteroid.Size == 5) { _components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Medium, asteroid.Position)); _components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Medium, asteroid.Position)); _components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Medium, asteroid.Position)); } else if (asteroid.Size == 3) { _components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Small, asteroid.Position)); _components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Small, asteroid.Position)); _components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Small, asteroid.Position)); } _components.Remove <Asteroid>(asteroid); } } }
public void ActivationHappensOnlyOnceForSingletonComponents() { var store = new ComponentStore(); var registration = store.Add <IService, ClassWithNoDependencies>("test"); registration.Lifestyle = ComponentLifestyles.Singleton; var container = new PandoraContainer(store); var service = container.Resolve <IService>("test"); var service2 = container.Resolve <IService>("test"); Assert.Same(service, service2); }
public void Fire() { var fireball = _components.GetSingleOrDefault <Fireball>(); if (fireball == null) { var ship = _components.GetSingle <Ship>(); _components.Add(new Fireball(_gameScreen.Textures["Fireball"], ship.Position, ship.Direction, ship.Rotation)); } else // fireball.Update(gameTime); if (fireball.Destroyed) { _components.Remove <Fireball>(fireball); } }
public void CannotInsertInterfaceAsImplementor() { var store = new ComponentStore(); Assert.Throws <RegistrationException>(() => store.Add <IService, IService>()); }
public void CannotInsertInterfaceAsImplementor() { var store = new ComponentStore(); Assert.Throws<RegistrationException>(() => store.Add<IService, IService>()); }
public void CanResolveDependencyChainOfSameServiceWithMultipleLevels() { var store = new ComponentStore(); store.Add<IService, ClassWithDependencyOnItsOwnService>(); store.Add<IService, ClassWithDependencyOnItsOwnService>(); store.Add<IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve<IService>(); var level1 = (ClassWithDependencyOnItsOwnService) service; var level2 = (ClassWithDependencyOnItsOwnService) level1.SubService; var level3 = (ClassWithNoDependencies)level2.SubService; Assert.IsType(typeof (ClassWithDependencyOnItsOwnService), level1); Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level2); Assert.IsType(typeof(ClassWithNoDependencies), level3); }
public void CanResolveWhenGivenTwoConstructorsWhereOneCantBeSatisfied() { var store = new ComponentStore(); store.Add<IService4, ClassWithMultipleConstructors>(); var container = new PandoraContainer(store); Assert.DoesNotThrow(() => container.Resolve<IService4>()); }
public void CanSplitGraph() { /* * Dotty Graph: * digraph G { a [label="IService :: A"] ; a -> b [label="service1"] ; a -> c [label="service2"] ; b [label="IService :: B"] ; b -> d ; d [label="IService :: C"] ; c [label="IService :: B"] ; c -> f ; f [label="IService :: C"] ; } */ var store = new ComponentStore(); store.Add<IService, ClassWithTwoDependenciesOnItsOwnService>(); store.Add<IService, ClassWithDependencyOnItsOwnService>(); store.Add<IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve<IService>(); Assert.IsType(typeof (ClassWithTwoDependenciesOnItsOwnService), service); }
public void DependencyMissingExceptionPropagatesThroughMultipleLevels() { var store = new ComponentStore(); store.Add<IService3, ClassDependingOnClassWithOneDependency>(); store.Add<IService2, ClassWithOneDependency>(); var container = new PandoraContainer(store); Assert.Throws<DependencyMissingException>(() => container.Resolve<IService3>()); }
public void ThrowsDependencyMissingExceptionIfDependencyChainCannotBeSatisfied() { var store = new ComponentStore(); store.Add<IService, ClassWithDependencyOnItsOwnService>(); var container = new PandoraContainer(store); Assert.Throws<DependencyMissingException>(() => container.Resolve<IService>()); }
public void ThrowsExceptionIfDependencyCouldNotBeSatisfied() { var store = new ComponentStore(); store.Add<ClassWithOneDependency, ClassWithOneDependency>(); var container = new PandoraContainer(store); Assert.Throws<DependencyMissingException>(() => container.Resolve<ClassWithOneDependency>()); }
public void CanResolveDependencyChainOfSameService() { var store = new ComponentStore(); store.Add<IService, ClassWithDependencyOnItsOwnService>(); store.Add<IService, ClassWithNoDependencies>(); var container = new PandoraContainer(store); var service = container.Resolve<IService>(); Assert.IsType(typeof (ClassWithDependencyOnItsOwnService), service); var ownService = (ClassWithDependencyOnItsOwnService)service; Assert.IsType(typeof (ClassWithNoDependencies), ownService.SubService); }