public void Resolve_WhenServiceTypeIsNull_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws<ArgumentNullException>(() => serviceLocator.Resolve(null));
            }
            public void ResolveHandleByComponentId_WhenComponentIdIsNull_Throws()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws <ArgumentNullException>(() => serviceLocator.ResolveHandleByComponentId(null));
            }
            public void ResolveAllHandles_WhenServiceTypeIsNull_Throws()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws <ArgumentNullException>(() => serviceLocator.ResolveAllHandles(null));
            }
            public void HasService_WhenServiceTypeIsNull_Throws()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws <ArgumentNullException>(() => serviceLocator.HasService(null));
            }
            public void HasComponent_WhenComponentIdIsNull_Throws()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws <ArgumentNullException>(() => serviceLocator.HasComponent(null));
            }
        public void Registry_Always_ReturnsRegistry()
        {
            var registry       = MockRepository.GenerateStub <IRegistry>();
            var serviceLocator = new RegistryServiceLocator(registry);

            Assert.AreSame(registry, serviceLocator.Registry);
        }
        public void Registry_Always_ReturnsRegistry()
        {
            var registry = MockRepository.GenerateStub<IRegistry>();
            var serviceLocator = new RegistryServiceLocator(registry);

            Assert.AreSame(registry, serviceLocator.Registry);
        }
            public void Resolve_WhenServiceTypeNotRegistered_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var ex = Assert.Throws<RuntimeException>(() => serviceLocator.Resolve(typeof(DummyService)));
                Assert.Contains(ex.Message, "Could not resolve component for service type '" + typeof(DummyService) + "' because there do not appear to be any components registered and enabled for that service type.");
            }
            public void ResolveAllHandlesGeneric_WhenServiceTypeNotRegistered_ReturnsAnEmptyList()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.ResolveAllHandles <DummyService, DummyTraits>();

                Assert.IsEmpty(result);
            }
            public void ResolveAllHandles_WhenServiceTypeNotRegistered_ReturnsAnEmptyList()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.ResolveAllHandles(typeof(DummyService));

                Assert.IsEmpty(result);
            }
            public void ResolveHandleByComponentId_WhenComponentNotRegistered_Throws()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var ex = Assert.Throws <RuntimeException>(() => serviceLocator.ResolveHandleByComponentId("componentId"));

                Assert.Contains(ex.Message, "Could not resolve component with id 'componentId' because it does not appear to be registered.");
            }
            public void Resolve_WhenServiceTypeNotRegistered_Throws()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var ex = Assert.Throws <RuntimeException>(() => serviceLocator.Resolve(typeof(DummyService)));

                Assert.Contains(ex.Message, "Could not resolve component for service type '" + typeof(DummyService) + "' because there do not appear to be any components registered and enabled for that service type.");
            }
            public void HasService_WhenServiceTypeNotRegistered_ReturnsFalse()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.HasService(typeof(DummyService));

                Assert.IsFalse(result);
            }
            public void HasComponent_WhenComponentNotRegistered_ReturnsFalse()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.HasComponent("componentId");

                Assert.IsFalse(result);
            }
            public void ResolveHandleGeneric_WhenServiceTypeMapsToExactlyOneComponent_ReturnsComponentHandle()
            {
                var registry            = new FakeRegistry();
                var serviceLocator      = new RegistryServiceLocator(registry);
                var serviceDescriptor   = registry.RegisterService(typeof(DummyService));
                var componentDescriptor = registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var componentHandle = serviceLocator.ResolveHandle <DummyService, DummyTraits>();

                Assert.AreSame(componentDescriptor, componentHandle.Descriptor);
            }
            public void Resolve_WhenServiceTypeRegisteredButMoreThanOneComponent_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                registry.RegisterComponent(serviceDescriptor, "component1Id", typeof(DummyComponent));
                registry.RegisterComponent(serviceDescriptor, "component2Id", typeof(DummyComponent2));

                var ex = Assert.Throws<RuntimeException>(() => serviceLocator.Resolve(typeof(DummyService)));
                Assert.Contains(ex.Message, "Could not resolve component for service type '" + typeof(DummyService) + "' because there are more than one of them registered and enabled so the request is ambiguous.");
            }
            public void ResolveAllHandlesGeneric_WhenServiceTypeRegisteredButNoComponents_ReturnsAnEmptyList()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                registry.RegisterService(typeof(DummyService));

                var result = serviceLocator.ResolveAllHandles <DummyService, DummyTraits>();

                Assert.IsEmpty(result);
            }
            public void ResolveHandleByComponentId_WhenComponentRegistered_ReturnsComponentHandle()
            {
                var registry            = new FakeRegistry();
                var serviceLocator      = new RegistryServiceLocator(registry);
                var serviceDescriptor   = registry.RegisterService(typeof(DummyService));
                var componentDescriptor = registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var componentHandle = serviceLocator.ResolveHandleByComponentId("componentId");

                Assert.AreSame(componentDescriptor, componentHandle.Descriptor);
            }
            public void Resolve_WhenServiceTypeMapsToExactlyOneComponent_ReturnsResolvedComponent()
            {
                var registry          = new FakeRegistry();
                var serviceLocator    = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));

                registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var component = (DummyComponent)serviceLocator.Resolve(typeof(DummyService));

                Assert.IsNotNull(component);
            }
            public void ResolveByComponentId_WhenComponentRegistered_ReturnsResolvedComponent()
            {
                var registry          = new FakeRegistry();
                var serviceLocator    = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));

                registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var component = (DummyComponent)serviceLocator.ResolveByComponentId("componentId");

                Assert.IsNotNull(component);
            }
            public void HasComponent_WhenComponentRegisteredButDisabled_ReturnsFalse()
            {
                var registry       = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var service        = registry.RegisterService(typeof(DummyService));

                registry.RegisterDisabledComponent(service, "componentId", typeof(DummyComponent2));

                var result = serviceLocator.HasComponent("componentId");

                Assert.IsFalse(result);
            }
            public void ResolveHandleGeneric_WhenServiceTypeMapsToExactlyOneComponentButItIsDisabled_Throws()
            {
                var registry          = new FakeRegistry();
                var serviceLocator    = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));

                registry.RegisterDisabledComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var ex = Assert.Throws <RuntimeException>(() => serviceLocator.ResolveHandle <DummyService, DummyTraits>());

                Assert.Contains(ex.Message, "Could not resolve component for service type '" + typeof(DummyService) + "' because there do not appear to be any components registered and enabled for that service type.");
            }
            public void ResolveHandleByComponentId_WhenComponentRegisteredButItIsDisabled_ReturnsComponentHandle()
            {
                var registry          = new FakeRegistry();
                var serviceLocator    = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));

                registry.RegisterDisabledComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var ex = Assert.Throws <RuntimeException>(() => serviceLocator.ResolveHandleByComponentId("componentId"));

                Assert.Contains(ex.Message, "Could not resolve component with id 'componentId' because it has been disabled.  Reason: ");
            }
            public void Resolve_WhenServiceTypeRegisteredButMoreThanOneComponent_Throws()
            {
                var registry          = new FakeRegistry();
                var serviceLocator    = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));

                registry.RegisterComponent(serviceDescriptor, "component1Id", typeof(DummyComponent));
                registry.RegisterComponent(serviceDescriptor, "component2Id", typeof(DummyComponent2));

                var ex = Assert.Throws <RuntimeException>(() => serviceLocator.Resolve(typeof(DummyService)));

                Assert.Contains(ex.Message, "Could not resolve component for service type '" + typeof(DummyService) + "' because there are more than one of them registered and enabled so the request is ambiguous.");
            }
            public void ResolveAllHandlesGeneric_WhenServiceTypeRegisteredAndAtLeastOneComponent_ReturnsAllComponentHandles()
            {
                var registry             = new FakeRegistry();
                var serviceLocator       = new RegistryServiceLocator(registry);
                var serviceDescriptor    = registry.RegisterService(typeof(DummyService));
                var component1Descriptor = registry.RegisterComponent(serviceDescriptor, "component1Id", typeof(DummyComponent));
                var component2Descriptor = registry.RegisterComponent(serviceDescriptor, "component2Id", typeof(DummyComponent2));

                var result = serviceLocator.ResolveAllHandles <DummyService, DummyTraits>();

                Assert.Count(2, result);
                Assert.AreSame(component1Descriptor, result[0].Descriptor);
                Assert.AreSame(component2Descriptor, result[1].Descriptor);
            }
            public void ResolveAllGeneric_WhenServiceTypeRegisteredAndAtLeastOneComponent_ReturnsAllResolvedComponents()
            {
                var registry          = new FakeRegistry();
                var serviceLocator    = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));

                registry.RegisterComponent(serviceDescriptor, "component1Id", typeof(DummyComponent));
                registry.RegisterComponent(serviceDescriptor, "component2Id", typeof(DummyComponent2));

                var result = serviceLocator.ResolveAll <DummyService>();

                Assert.Count(2, result);
                Assert.IsInstanceOfType <DummyComponent>(result[0]);
                Assert.IsInstanceOfType <DummyComponent2>(result[1]);
            }
            public void HasComponent_WhenComponentNotRegistered_ReturnsFalse()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.HasComponent("componentId");

                Assert.IsFalse(result);
            }
            public void HasComponent_WhenComponentRegisteredButDisabled_ReturnsFalse()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var service = registry.RegisterService(typeof(DummyService));
                registry.RegisterDisabledComponent(service, "componentId", typeof(DummyComponent2));

                var result = serviceLocator.HasComponent("componentId");

                Assert.IsFalse(result);
            }
            public void HasService_WhenServiceTypeRegisteredButDisabled_ReturnsFalse()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                registry.RegisterDisabledService(typeof(DummyService));

                var result = serviceLocator.HasService(typeof(DummyService));

                Assert.IsFalse(result);
            }
            public void HasComponent_WhenComponentIdIsNull_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws<ArgumentNullException>(() => serviceLocator.HasComponent(null));
            }
            public void ResolveHandleByComponentId_WhenComponentRegisteredButItIsDisabled_ReturnsComponentHandle()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                registry.RegisterDisabledComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var ex = Assert.Throws<RuntimeException>(() => serviceLocator.ResolveHandleByComponentId("componentId"));
                Assert.Contains(ex.Message, "Could not resolve component with id 'componentId' because it has been disabled.  Reason: ");
            }
            public void ResolveByComponentId_WhenComponentRegistered_ReturnsResolvedComponent()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var component = (DummyComponent)serviceLocator.ResolveByComponentId("componentId");

                Assert.IsNotNull(component);
            }
            public void ResolveHandleByComponentId_WhenComponentNotRegistered_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var ex = Assert.Throws<RuntimeException>(() => serviceLocator.ResolveHandleByComponentId("componentId"));
                Assert.Contains(ex.Message, "Could not resolve component with id 'componentId' because it does not appear to be registered.");
            }
            public void ResolveAllHandles_WhenServiceTypeNotRegistered_ReturnsAnEmptyList()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.ResolveAllHandles(typeof(DummyService));

                Assert.IsEmpty(result);
            }
            public void ResolveAllHandlesGeneric_WhenServiceTypeRegisteredAndAtLeastOneComponent_ReturnsAllComponentHandles()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                var component1Descriptor = registry.RegisterComponent(serviceDescriptor, "component1Id", typeof(DummyComponent));
                var component2Descriptor = registry.RegisterComponent(serviceDescriptor, "component2Id", typeof(DummyComponent2));

                var result = serviceLocator.ResolveAllHandles<DummyService, DummyTraits>();

                Assert.Count(2, result);
                Assert.AreSame(component1Descriptor, result[0].Descriptor);
                Assert.AreSame(component2Descriptor, result[1].Descriptor);
            }
            public void ResolveHandleByComponentId_WhenComponentIdIsNull_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                Assert.Throws<ArgumentNullException>(() => serviceLocator.ResolveHandleByComponentId(null));
            }
            public void ResolveAllHandlesGeneric_WhenServiceTypeRegisteredButNoComponents_ReturnsAnEmptyList()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                registry.RegisterService(typeof(DummyService));

                var result = serviceLocator.ResolveAllHandles<DummyService, DummyTraits>();

                Assert.IsEmpty(result);
            }
            public void ResolveHandleGeneric_WhenServiceTypeMapsToExactlyOneComponent_ReturnsComponentHandle()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                var componentDescriptor = registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var componentHandle = serviceLocator.ResolveHandle<DummyService, DummyTraits>();

                Assert.AreSame(componentDescriptor, componentHandle.Descriptor);
            }
            public void ResolveAllHandlesGeneric_WhenServiceTypeNotRegistered_ReturnsAnEmptyList()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);

                var result = serviceLocator.ResolveAllHandles<DummyService, DummyTraits>();

                Assert.IsEmpty(result);
            }
            public void ResolveAllGeneric_WhenServiceTypeRegisteredAndAtLeastOneComponent_ReturnsAllResolvedComponents()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                registry.RegisterComponent(serviceDescriptor, "component1Id", typeof(DummyComponent));
                registry.RegisterComponent(serviceDescriptor, "component2Id", typeof(DummyComponent2));

                var result = serviceLocator.ResolveAll<DummyService>();

                Assert.Count(2, result);
                Assert.IsInstanceOfType<DummyComponent>(result[0]);
                Assert.IsInstanceOfType<DummyComponent2>(result[1]);
            }
            public void ResolveHandleByComponentId_WhenComponentRegistered_ReturnsComponentHandle()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                var componentDescriptor = registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var componentHandle = serviceLocator.ResolveHandleByComponentId("componentId");

                Assert.AreSame(componentDescriptor, componentHandle.Descriptor);
            }
            public void Resolve_WhenServiceTypeMapsToExactlyOneComponent_ReturnsResolvedComponent()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                registry.RegisterComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var component = (DummyComponent)serviceLocator.Resolve(typeof(DummyService));

                Assert.IsNotNull(component);
            }
            public void ResolveHandleGeneric_WhenServiceTypeMapsToExactlyOneComponentButItIsDisabled_Throws()
            {
                var registry = new FakeRegistry();
                var serviceLocator = new RegistryServiceLocator(registry);
                var serviceDescriptor = registry.RegisterService(typeof(DummyService));
                registry.RegisterDisabledComponent(serviceDescriptor, "componentId", typeof(DummyComponent));

                var ex = Assert.Throws<RuntimeException>(() => serviceLocator.ResolveHandle<DummyService, DummyTraits>());
                Assert.Contains(ex.Message, "Could not resolve component for service type '" + typeof(DummyService) + "' because there do not appear to be any components registered and enabled for that service type.");
            }