public void CreateStub_WhenComponentIdIsNull_Throws()
{
var component = MockRepository.GenerateStub <DummyService>();
var traits = new DummyTraits();
Assert.Throws <ArgumentNullException>(() => ComponentHandle.CreateStub <DummyService, DummyTraits>(null, component, traits));
}
public void CreateStub_WhenArgumentsValid_ReturnsHandleWithStubbedDescriptor()
{
var componentId = "componentId";
var component = MockRepository.GenerateStub <DummyService>();
var traits = new DummyTraits();
var handle = ComponentHandle.CreateStub <DummyService, DummyTraits>(componentId, component, traits);
Assert.Multiple(() =>
{
Assert.AreEqual(componentId, handle.Id);
Assert.AreEqual(typeof(DummyService), handle.ServiceType);
Assert.AreEqual(typeof(DummyTraits), handle.TraitsType);
Assert.AreSame(component, handle.GetComponent());
Assert.AreSame(traits, handle.GetTraits());
object x = null;
Assert.Throws <NotSupportedException>(() => x = handle.Descriptor.Plugin);
Assert.Throws <NotSupportedException>(() => x = handle.Descriptor.Service);
Assert.AreEqual(componentId, handle.Descriptor.ComponentId);
Assert.AreEqual(new TypeName(component.GetType()), handle.Descriptor.ComponentTypeName);
Assert.Throws <NotSupportedException>(() => x = handle.Descriptor.ComponentHandlerFactory);
Assert.Throws <NotSupportedException>(() => x = handle.Descriptor.ComponentProperties);
Assert.Throws <NotSupportedException>(() => x = handle.Descriptor.TraitsProperties);
Assert.IsFalse(handle.Descriptor.IsDisabled);
Assert.Throws <InvalidOperationException>(() => x = handle.Descriptor.DisabledReason);
Assert.AreEqual(component.GetType(), handle.Descriptor.ResolveComponentType());
Assert.Throws <NotSupportedException>(() => handle.Descriptor.ResolveComponentHandler());
Assert.AreSame(component, handle.Descriptor.ResolveComponent());
Assert.Throws <NotSupportedException>(() => handle.Descriptor.ResolveTraitsHandler());
Assert.AreSame(traits, handle.Descriptor.ResolveTraits());
});
}
public void CreateStub_WhenComponentIsNull_Throws()
{
var componentId = "componentId";
var traits = new DummyTraits();
Assert.Throws <ArgumentNullException>(() => ComponentHandle.CreateStub <DummyService, DummyTraits>(componentId, null, traits));
}
public void GetTraitsTyped_WhenComponentCanBeResolved_ReturnsAndMemoizesIt()
{
var traits = new DummyTraits();
var componentDescriptor = CreateStubComponentDescriptor <DummyService, DummyTraits>();
var componentHandle = ComponentHandle.CreateInstance <DummyService, DummyTraits>(componentDescriptor);
componentDescriptor.Expect(x => x.ResolveTraits()).Return(traits);
// first time
DummyTraits result = componentHandle.GetTraits();
Assert.AreSame(traits, result);
// second time should be same but method only called once
result = componentHandle.GetTraits();
Assert.AreSame(traits, result);
componentDescriptor.VerifyAllExpectations();
}
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();
}
