The Entire TestFixture:
[TestFixture]
public class ServicesModuleTests
{
private const string MessageSent = "Services Module
Initialized";
[Test]
public void
WhenInstantiated_ShouldCallIStatusMessageServicePublishMessage()
{
var mocks = new MockRepository();
var unity = mocks.DynamicMock<IUnityContainer>();
var aggregator = mocks.Stub<IEventAggregator>();
var service = mocks.DynamicMock<IStatusMessageService>();
var region = mocks.DynamicMock<IRegionManager>();
unity.Stub(container => container.Resolve<IEventAggregator>
()).Return(aggregator);
unity.Stub(container =>
container.Resolve<IStatusMessageService>()).Return(service);
mocks.ReplayAll();
new ServicesModule2(unity, region).Initialize();
unity.AssertWasCalled(container =>
container.Resolve<IStatusMessageService>());
unity.AssertWasCalled(container =>
container.Resolve<IEventAggregator>());
service.AssertWasCalled(messageService =>
messageService.PublishStatusMessage(MessageSent));
}
}
ServicesModule2 :
public class ServicesModule2 : IModule
{
public ServicesModule2(IUnityContainer container,
IRegionManager regionManager)
{
Container = container;
RegionManager = regionManager;
Presenters = new List<object>();
TheEventAggregator = Container.Resolve<IEventAggregator>
();
}
public IUnityContainer Container { get; private set; }
public IRegionManager RegionManager { get; private set; }
internal List<object> Presenters { get; private set; }
protected IEventAggregator TheEventAggregator { get; private
set; }
public void
RegisterViewsAndServicesNotLoadedThroughConfiguration()
{
Container.RegisterType<IStatusMessageService,
StatusMessageService>(new ContainerControlledLifetimeManager());
}
public void RegisterViewsWithRegions() { }
public void RaiseAnyPertinentEventsEtc()
{
Container.Resolve<IStatusMessageService>
().PublishStatusMessage("Services Module Initialized");
}
public string ConfigurationContainerName
{
get { return "Services"; }
}
public void Initialize()
{
var section = (UnityConfigurationSection)
ConfigurationManager.GetSection("Unity");
if (section != null && section.Containers
[ConfigurationContainerName] != null)
section.Containers
[ConfigurationContainerName].Configure(Container);
RegisterViewsAndServicesNotLoadedThroughConfiguration();
RegisterViewsWithRegions();
RaiseAnyPertinentEventsEtc();
}
}
IStatusMessageService interface:
public interface IStatusMessageService
{
void PublishStatusMessage(string formatString, params object[]
parameters);
}
StatusMessageService :
public class StatusMessageService : IStatusMessageService
{
private IEventAggregator TheEventAggregator { get; set; }
public StatusMessageService(IEventAggregator eventAggregator)
{
TheEventAggregator = eventAggregator;
}
public void PublishStatusMessage(string formatString, params
object[] parameters )
{
TheEventAggregator.GetEvent<DisplayStatusMessageEvent>
().Publish(string.Format(formatString, parameters));
}
}
The project is using the Prism, composite application framework, I
have the following test setup for the StatusMessageService, and this
behaves exactly as expected:
[TestFixture]
public class StatusMessageServiceTests
{
private const string MessageSent = "A status message";
private const string MessageUnsent = "A different status
message";
private DisplayStatusMessageEvent StatusMessageEventInstance
{ get; set; }
private IEventAggregator TheEventAggregatorStub { get; set; }
[SetUp]
public void TestSetup()
{
TheEventAggregatorStub =
MockRepository.GenerateStrictMock<IEventAggregator>();
StatusMessageEventInstance = new DisplayStatusMessageEvent
();
}
[Test]
public void
WhenPublishStatusMessageIsCalledOnTheService_ShouldReceiveMessageAtSubscriber
()
{
// When we call getevent<> on the aggregator, return the
StatusMessageEventInstance
TheEventAggregatorStub.Expect(aggregator =>
aggregator.GetEvent<DisplayStatusMessageEvent>()).Return
(StatusMessageEventInstance);
// subscribe to the event, and when it is fired make sure
the message is the same as the one sent.
StatusMessageEventInstance.Subscribe(actualMessage =>
{
Assert.That
(actualMessage, Is.EqualTo(MessageSent));
Assert.That
(actualMessage, Is.Not.EqualTo(MessageUnsent));
});
// instantiate the service and fire the event
new StatusMessageService
(TheEventAggregatorStub).PublishStatusMessage(MessageSent);
TheEventAggregatorStub.VerifyAllExpectations();
}
}
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Rhino.Mocks" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/rhinomocks?hl=en
-~----------~----~----~----~------~----~------~--~---
