public void ResolveTraitsType_WhenServiceTypeHasInvalidTraitsAttribute_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyServiceWithInvalidTraits))));

                var ex = Assert.Throws<RuntimeException>(() => service.ResolveTraitsType());
                Assert.Contains(ex.Message, "Could not resolve the traits type of service 'serviceId'.");
            }
            public void Indexer_WhenComponentIdIsRegistered_ReturnsComponent()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName("Component, Assembly")));

                var result = registry.Components["componentId"];

                Assert.AreSame(component, result);
            }
            public void FindByServiceTypeName_WhenComponentsNotRegistered_ReturnsEmptyList()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyService))));

                var result = registry.Components.FindByServiceTypeName(new TypeName(typeof(DummyService)));

                Assert.IsEmpty(result);
            }
            public void RegisterComponent_WhenComponentIdNotUnique_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));
                registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName("Component, Assembly")));

                var ex = Assert.Throws<ArgumentException>(() =>
                {
                    registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName("Component, Assembly")));
                });
                Assert.Contains(ex.Message, "There is already a component registered with id 'componentId'.");
            }
            public void Indexer_WhenServiceIdIsRegistered_ReturnsService()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));

                var result = registry.Services["serviceId"];

                Assert.AreSame(service, result);
            }
            public void RegisterComponent_WhenArgumentsValidButNoComponentTypeNameProvided_UsesTheDefaultComponentTypeSepcifiedByTheService()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly"))
                    {
                        DefaultComponentTypeName = new TypeName("Component, Assembly")
                    });
                var handlerFactory = MockRepository.GenerateStub<IHandlerFactory>();

                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", null));

                Assert.Multiple(() =>
                {
                    Assert.AreSame(plugin, component.Plugin);
                    Assert.AreSame(service, component.Service);
                    Assert.AreEqual("componentId", component.ComponentId);
                    Assert.AreEqual(new TypeName("Component, Assembly"), component.ComponentTypeName);
                });
            }
            public void RegisterComponent_WhenServiceBelongsToDifferentRegistry_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var foreignRegistry = new Registry();
                var foreignPlugin = foreignRegistry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var foreignService = foreignRegistry.RegisterService(new ServiceRegistration(foreignPlugin, "serviceId", new TypeName("Service, Assembly")));

                var ex = Assert.Throws<ArgumentException>(() =>
                {
                    registry.RegisterComponent(new ComponentRegistration(plugin, foreignService, "componentId", new TypeName("Component, Assembly")));
                });
                Assert.Contains(ex.Message, "The specified service descriptor does not belong to this registry.");
            }
            public void ResolveComponentTraits_WhenWellFormed_ReturnsComponentTraitsObject()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var handlerFactory = MockRepository.GenerateMock<IHandlerFactory>();
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyServiceWithTraits)))
                {
                    TraitsHandlerFactory = handlerFactory,
                });
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName(typeof(DummyComponent)))
                {
                    TraitsProperties = { { "Name", "Value" } }
                });
                var handler = MockRepository.GenerateMock<IHandler>();
                var traitsInstance = new DummyTraits();

                handlerFactory.Expect(x => x.CreateHandler(null, null, null, null))
                    .Constraints(Is.NotNull(), Is.Equal(typeof(Traits)), Is.Equal(typeof(DummyTraits)), Is.Equal(new PropertySet() { { "Name", "Value" } }))
                    .Return(handler);
                handler.Expect(x => x.Activate()).Return(traitsInstance);

                var result = (DummyTraits)component.ResolveTraits();

                Assert.AreSame(traitsInstance, result);
                handlerFactory.VerifyAllExpectations();
                handler.VerifyAllExpectations();
            }
            public void ResolveComponentTraits_WhenActivationFails_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var handlerFactory = MockRepository.GenerateMock<IHandlerFactory>();
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyServiceWithTraits)))
                {
                    TraitsHandlerFactory = handlerFactory,
                });
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName(typeof(DummyComponent)))
                {
                    TraitsProperties = { { "Name", "Value" } }
                });
                var handler = MockRepository.GenerateMock<IHandler>();

                handlerFactory.Expect(x => x.CreateHandler(null, null, null, null))
                    .Constraints(Is.NotNull(), Is.Equal(typeof(Traits)), Is.Equal(typeof(DummyTraits)), Is.Equal(new PropertySet() { { "Name", "Value" } }))
                    .Return(handler);
                handler.Expect(x => x.Activate()).Throw(new InvalidOperationException("Boom"));

                var ex = Assert.Throws<RuntimeException>(() => component.ResolveTraits());
                Assert.AreEqual("Could not resolve traits of component 'componentId'.", ex.Message);
                handlerFactory.VerifyAllExpectations();
                handler.VerifyAllExpectations();
            }
            public void ResolveComponentHandler_WhenHandlerFactorySucceeds_ReturnsHandler()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyService))));
                var handlerFactory = MockRepository.GenerateMock<IHandlerFactory>();
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName(typeof(DummyComponent)))
                {
                    ComponentHandlerFactory = handlerFactory,
                    ComponentProperties = { { "Name", "Value" } }
                });
                var handler = MockRepository.GenerateStub<IHandler>();

                handlerFactory.Expect(x => x.CreateHandler(null, null, null, null))
                    .Constraints(Is.NotNull(), Is.Equal(typeof(DummyService)), Is.Equal(typeof(DummyComponent)), Is.Equal(new PropertySet() { { "Name", "Value" } }))
                    .Return(handler);

                var result = component.ResolveComponentHandler();

                Assert.AreSame(handler, result);
                handlerFactory.VerifyAllExpectations();
            }
            public void ResolveComponentHandler_WhenComponentHasDependencyOnComponentDescriptor_OwnComponentDescriptorIsResolved()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyServiceWithTraits))));
                var handlerFactory = MockRepository.GenerateMock<IHandlerFactory>();
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName(typeof(DummyComponentWithTraits)))
                {
                    ComponentHandlerFactory = handlerFactory,
                    ComponentProperties = { { "Name", "Value" } }
                });
                var handler = MockRepository.GenerateStub<IHandler>();

                handlerFactory.Expect(x => x.CreateHandler(null, null, null, null))
                    .IgnoreArguments()
                    .Return(handler);

                component.ResolveComponentHandler();

                var args = handlerFactory.GetArgumentsForCallsMadeOn(x => x.CreateHandler(null, null, null, null), x => x.IgnoreArguments());
                var suppliedDependencyResolver = (IObjectDependencyResolver)args[0][0];

                var dependencyResolution = suppliedDependencyResolver.ResolveDependency("descriptor", typeof(IComponentDescriptor), null);
                Assert.AreSame(component, dependencyResolution.Value);
            }
            public void ResolveComponentHandler_WhenHandlerFactoryFails_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyService))));
                var handlerFactory = MockRepository.GenerateMock<IHandlerFactory>();
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName(typeof(DummyComponent)))
                {
                    ComponentHandlerFactory = handlerFactory,
                    ComponentProperties = { { "Name", "Value" } }
                });

                handlerFactory.Expect(x => x.CreateHandler(null, null, null, null))
                    .Constraints(Is.NotNull(), Is.Equal(typeof(DummyService)), Is.Equal(typeof(DummyComponent)), Is.Equal(new PropertySet() { { "Name", "Value" } }))
                    .Throw(new Exception("Boom"));

                var ex = Assert.Throws<RuntimeException>(() => component.ResolveComponentHandler());
                Assert.Contains(ex.Message, "Could not resolve the component handler of component 'componentId'.");
                handlerFactory.VerifyAllExpectations();
            }
            public void ResolveComponentType_WhenTypeIsValid_ReturnsType()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName(typeof(DummyComponent))));

                var componentType = component.ResolveComponentType();

                Assert.AreEqual(typeof(DummyComponent), componentType);
            }
            public void ResolveComponentType_WhenTypeIsInvalid_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", new TypeName("InvalidComponent, Assembly")));

                var ex = Assert.Throws<RuntimeException>(() => component.ResolveComponentType());
                Assert.Contains(ex.Message, "Could not resolve the component type of component 'componentId'.");
            }
            public void DisabledReason_WhenServiceDisabled_DescribesTheDependency()
            {
                var registry = new Registry();
                var plugin1 = registry.RegisterPlugin(new PluginRegistration("plugin1Id", new TypeName("Plugin1, Assembly"), new DirectoryInfo(@"C:\")));
                var plugin2 = registry.RegisterPlugin(new PluginRegistration("plugin2Id", new TypeName("Plugin2, Assembly"), new DirectoryInfo(@"C:\"))
                {
                    PluginDependencies = { plugin1 }
                });
                var service = registry.RegisterService(new ServiceRegistration(plugin1, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin2, service, "componentId", new TypeName("Component, Assembly")));

                plugin1.Disable("The reason");

                // Now that plugin dependencies have been implemented, we see a different message than before.
                // However if later we add a feature to disable individual services independently of a plugin
                // then we should see the following message:
                // Assert.AreEqual("The service implemented by this component was disabled.  Reason: The plugin that provides this service was disabled.  Reason: The reason", component.DisabledReason);

                Assert.AreEqual("The plugin that provides this component was disabled.  Reason: The plugin depends on another disabled plugin: 'plugin1Id'.", component.DisabledReason);
            }
            public void IsDisabled_WhenPluginDisabled_ReturnsTrue()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));

                plugin.Disable("The reason");

                Assert.IsTrue(service.IsDisabled);
            }
            public void RegisterComponent_WhenArgumentsValid_RegistersTheComponentAndReturnsItsDescriptor()
            {
                var registry = new Registry();
                var plugin1 = registry.RegisterPlugin(new PluginRegistration("plugin1Id", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var plugin2 = registry.RegisterPlugin(new PluginRegistration("plugin2Id", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin2, "serviceId", new TypeName("Service, Assembly")));
                var handlerFactory = MockRepository.GenerateStub<IHandlerFactory>();

                var component = registry.RegisterComponent(new ComponentRegistration(plugin2, service, "componentId", new TypeName("Component, Assembly"))
                {
                    ComponentProperties = { { "ConfigName", "Value" } },
                    TraitsProperties = { { "TraitName", "Value" } },
                    ComponentHandlerFactory = handlerFactory
                });

                Assert.Multiple(() =>
                {
                    Assert.AreSame(plugin2, component.Plugin);
                    Assert.AreSame(service, component.Service);
                    Assert.AreEqual("componentId", component.ComponentId);
                    Assert.AreEqual(new TypeName("Component, Assembly"), component.ComponentTypeName);
                    Assert.AreEqual(new PropertySet() { { "ConfigName", "Value" } }, component.ComponentProperties);
                    Assert.AreEqual(new PropertySet() { { "TraitName", "Value" } }, component.TraitsProperties);
                    Assert.AreSame(handlerFactory, component.ComponentHandlerFactory);
                });
            }
            public void DisabledReason_WhenPluginNotDisabled_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));

                var ex = Assert.Throws<InvalidOperationException>(() => { var x = service.DisabledReason; });
                Assert.AreEqual("The service has not been disabled.", ex.Message);
            }
            public void RegisterService_WhenServiceTypeNameNotUnique_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));

                var ex = Assert.Throws<ArgumentException>(() =>
                {
                    registry.RegisterService(new ServiceRegistration(plugin, "differentServiceId", new TypeName("Service, Assembly"))); // same service type
                });
                Assert.Contains(ex.Message, "There is already a service registered with type name 'Service, Assembly'.  This service has id 'differentServiceId' and the other service has id 'serviceId'.");
            }
            public void DisabledReason_WhenPluginDisabled_ReturnsTheReason()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));

                plugin.Disable("The reason");

                Assert.AreEqual("The plugin that provides this service was disabled.  Reason: The reason", service.DisabledReason);
            }
            public void RegisterComponent_WhenServiceBelongsToPluginNotIndicatedAsAPluginDependency_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var foreignPlugin = registry.RegisterPlugin(new PluginRegistration("foreignPluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var foreignService = registry.RegisterService(new ServiceRegistration(foreignPlugin, "foreignServiceId", new TypeName("Service, Assembly")));

                var ex = Assert.Throws<ArgumentException>(() =>
                {
                    registry.RegisterComponent(new ComponentRegistration(plugin, foreignService, "componentId", new TypeName("Component, Assembly")));
                });
                Assert.Contains(ex.Message, "The service belongs to a plugin that was not declared as a dependency of the plugin that provides this component.  Plugin 'pluginId' should declare a dependency on plugin 'foreignPluginId'.");
            }
            public void RegisterService_WhenArgumentsValid_RegistersTheServiceAndReturnsItsDescriptor()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var handlerFactory = MockRepository.GenerateStub<IHandlerFactory>();

                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly"))
                {
                    TraitsHandlerFactory = handlerFactory
                });

                Assert.Multiple(() =>
                {
                    Assert.AreSame(plugin, service.Plugin);
                    Assert.AreEqual("serviceId", service.ServiceId);
                    Assert.AreEqual(new TypeName("Service, Assembly"), service.ServiceTypeName);
                    Assert.AreSame(handlerFactory, service.TraitsHandlerFactory);
                });
            }
            public void RegisterComponent_WhenComponentMissingComponentTypeAndTheServiceDoesNotHaveADefaultComponentType_Throws()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName("Service, Assembly")));

                var ex = Assert.Throws<ArgumentException>(() =>
                {
                    registry.RegisterComponent(new ComponentRegistration(plugin, service, "componentId", null));
                });
                Assert.Contains(ex.Message, "The specified service descriptor does not have a default component type name so the component registration must specify a component type name but it does not.");
            }
            public void IsDisabled_WhenServiceDisabled_ReturnsTrue()
            {
                var registry = new Registry();
                var plugin1 = registry.RegisterPlugin(new PluginRegistration("plugin1Id", new TypeName("Plugin1, Assembly"), new DirectoryInfo(@"C:\")));
                var plugin2 = registry.RegisterPlugin(new PluginRegistration("plugin2Id", new TypeName("Plugin2, Assembly"), new DirectoryInfo(@"C:\"))
                {
                    PluginDependencies = { plugin1 }
                });
                var service = registry.RegisterService(new ServiceRegistration(plugin1, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin2, service, "componentId", new TypeName("Component, Assembly")));

                plugin1.Disable("The reason");

                Assert.IsTrue(component.IsDisabled);
            }
            public void GetByServiceTypeName_WhenServiceTypeNameIsRegistered_ReturnsService()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyService))));

                var result = registry.Services.GetByServiceTypeName(new TypeName(typeof(DummyService)));

                Assert.AreSame(service, result);
            }
            public void DisabledReason_WhenPluginAndServiceNotDisabled_Throws()
            {
                var registry = new Registry();
                var plugin1 = registry.RegisterPlugin(new PluginRegistration("plugin1Id", new TypeName("Plugin1, Assembly"), new DirectoryInfo(@"C:\")));
                var plugin2 = registry.RegisterPlugin(new PluginRegistration("plugin2Id", new TypeName("Plugin2, Assembly"), new DirectoryInfo(@"C:\"))
                    {
                        PluginDependencies = { plugin1 }
                    });
                var service = registry.RegisterService(new ServiceRegistration(plugin1, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin2, service, "componentId", new TypeName("Component, Assembly")));

                var ex = Assert.Throws<InvalidOperationException>(() => { var x = component.DisabledReason; });
                Assert.AreEqual("The component has not been disabled.", ex.Message);
            }
            public void FindByServiceTypeName_WhenComponentsRegistered_ReturnsComponentList()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyService))));
                var component1 = registry.RegisterComponent(new ComponentRegistration(plugin, service, "component1Id", new TypeName("Component1, Assembly")));
                var component2 = registry.RegisterComponent(new ComponentRegistration(plugin, service, "component2Id", new TypeName("Component2, Assembly")));

                var result = registry.Components.FindByServiceTypeName(new TypeName(typeof(DummyService)));

                Assert.AreElementsEqualIgnoringOrder(new[] { component1, component2 }, result);
            }
            public void DisabledReason_WhenPluginDisabled_ReturnsTheReason()
            {
                var registry = new Registry();
                var plugin1 = registry.RegisterPlugin(new PluginRegistration("plugin1Id", new TypeName("Plugin1, Assembly"), new DirectoryInfo(@"C:\")));
                var plugin2 = registry.RegisterPlugin(new PluginRegistration("plugin2Id", new TypeName("Plugin2, Assembly"), new DirectoryInfo(@"C:\"))
                    {
                        PluginDependencies = { plugin1 }
                    });
                var service = registry.RegisterService(new ServiceRegistration(plugin1, "serviceId", new TypeName("Service, Assembly")));
                var component = registry.RegisterComponent(new ComponentRegistration(plugin2, service, "componentId", new TypeName("Component, Assembly")));

                plugin2.Disable("The reason");

                Assert.AreEqual("The plugin that provides this component was disabled.  Reason: The reason", component.DisabledReason);
            }
            public void RegistryService_WhenRegistrationNull_Throws()
            {
                var registry = new Registry();

                Assert.Throws<ArgumentNullException>(() => registry.RegisterService(null));
            }
            public void ResolveTraitsType_WhenServiceTypeDoesNotHaveTraitsAttribute_ReturnsDefaultTraitsType()
            {
                var registry = new Registry();
                var plugin = registry.RegisterPlugin(new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")));
                var service = registry.RegisterService(new ServiceRegistration(plugin, "serviceId", new TypeName(typeof(DummyService))));

                var traitsType = service.ResolveTraitsType();

                Assert.AreEqual(typeof(Traits), traitsType);
            }