public void Requesting_NoConfigurations_DoesntResolveServices_ThatUsesConfigurations()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);
            var services = registrator.FilterServices(registrator.FindServices());

            registrator.RegisterServices(services);

            Assert.That(engine.ResolveAll <IBarometer>().Count(), Is.EqualTo(0));
        }
        public void Requesting_MultipleConfigurations_GivesAllMatchingServices()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);
            var services = registrator.FilterServices(registrator.FindServices(), "High", "Medium", "Low");

            registrator.RegisterServices(services);

            Assert.That(engine.ResolveAll <IBarometer>().Count(), Is.EqualTo(2));
        }
        public void Services_AreAdded_ToTheContainer_WithServiceType()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(InterfacedService), typeof(NonAttributed));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);

            registrator.RegisterServices(registrator.FindServices());

            Assert.That(engine.Resolve <IService>(), Is.Not.Null);
            Assert.That(engine.Resolve <IService>(), Is.InstanceOf <InterfacedService>());
            Assert.That(new TestDelegate(() => engine.Resolve <NonAttributed>()), Throws.Exception);
        }
        public void RequstingConfiguration_AlsoRegisterd_ServicesWithoutConfiguration()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService), typeof(HighService), typeof(LowService));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);

            registrator.RegisterServices(registrator.FilterServices(registrator.FindServices(), "High"));

            Assert.That(engine.Resolve <SelfService>(), Is.InstanceOf <SelfService>());
            Assert.That(engine.Resolve <IBarometer>(), Is.InstanceOf <HighService>());
            Assert.That(engine.ResolveAll <IBarometer>().Count(), Is.EqualTo(1));
        }
        public void Resolves_OnlyRequestedConfiguration()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);
            var services = registrator.FilterServices(registrator.FindServices(), "High");

            registrator.RegisterServices(services);

            Assert.That(engine.Resolve <IBarometer>(), Is.InstanceOf <HighService>());
            Assert.That(engine.ResolveAll <IBarometer>().Count(), Is.EqualTo(1));
        }
        public void Services_AreSingletons()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);

            registrator.RegisterServices(registrator.FindServices());

            var one = engine.Resolve <SelfService>();
            var two = engine.Resolve <SelfService>();

            Assert.That(object.ReferenceEquals(one, two));
        }
        public void Services_CanDepend_OnEachOther()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService), typeof(DependingService));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);

            registrator.RegisterServices(registrator.FindServices());

            var service = engine.Resolve <DependingService>();

            Assert.That(service, Is.InstanceOf <DependingService>());
            Assert.That(service.service, Is.InstanceOf <SelfService>());
        }
        public void CanResolve_ServiceWithDependency_OnComponentInstance()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(DependingServiceWithMissingDependency).Assembly.GetTypes());
            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);

            registrator.RegisterServices(registrator.FindServices());

            engine.ContainerManager.AddComponentInstance <UnregisteredDependency>(new UnregisteredDependency(), "ud");

            var service = engine.Resolve <DependingServiceWithMissingDependency>();

            Assert.That(service, Is.InstanceOf <DependingServiceWithMissingDependency>());
        }
        public void Services_CanDepend_OnGenericServiceInterface()
        {
            ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(GenericInterfaceDependingService), typeof(GenericInterfacedService <>));

            DependencyAttributeRegistrator registrator = new DependencyAttributeRegistrator(finder, engine);

            registrator.RegisterServices(registrator.FindServices());

            var service = engine.Resolve <GenericInterfaceDependingService>();

            Assert.That(service, Is.InstanceOf <GenericInterfaceDependingService>());
            Assert.That(service.service, Is.InstanceOf <GenericInterfacedService <int> >());
        }
Ejemplo n.º 10
0
        private void InitializeContainer()
        {
            //register attributed dependency
            var attrDependency = new DependencyAttributeRegistrator(this.TypeFinder, this.ContainerManager);

            attrDependency.RegisterServices();

            //
            var drTypes     = this.TypeFinder.FindClassesOfType <IDependencyRegistrar>();
            var drInstances = new List <IDependencyRegistrar>();

            foreach (var drType in drTypes)
            {
                drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType));
            }
            //sort
            drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
            foreach (var dependencyRegistrar in drInstances)
            {
                dependencyRegistrar.Register(this.ContainerManager, this.TypeFinder);
            }
        }