Unit testing Composite UI Application Block modules

Unit testing of CAB modules can be difficult because of all the dependency injection going on. Typically you will unit test at least all your presenters. The problem is that you will probably need the presenter to be built up by Objectbuilder which injects the references to WorkItem and State objects on the presenter. What you need is some mock object that takes the place of the RootWorkItem providing a context under which to run your WorkItems and presenters. Take a cue from the PAG team and borrow their TestableRootWorkItem from the nUnit project that comes with CAB.

Although you may be able to use it out of the box, the reality is that you will probably need to modify it to add services that your WorkItems require. Just add these in the TestableAddServices method.

 

using Microsoft.Practices.CompositeUI.BuilderStrategies;
using Microsoft.Practices.CompositeUI.Commands;
using Microsoft.Practices.CompositeUI.EventBroker;
using Microsoft.Practices.ObjectBuilder;
using Microsoft.Practices.CompositeUI.Services;

namespace Microsoft.Practices.CompositeUI.Tests
{
    public class TestableRootWorkItem : WorkItem //WorkItemBase
    {
        public TestableRootWorkItem()
        {
            InitializeRootWorkItem(CreateBuilder());

            Services.AddNew<CommandAdapterMapService, ICommandAdapterMapService>();
            Services.AddNew<TraceSourceCatalogService, ITraceSourceCatalogService>();

            TestableAddServices();

            BuildUp();
        }

        protected virtual void TestableAddServices()
        {
            //Do these module loaders really need to be added?
            Services.AddNew<ModuleLoaderService, IModuleLoaderService>();
        }
        public Builder Builder
        {
            get { return InnerBuilder; }
        }

        public IReadWriteLocator Locator
        {
            get { return InnerLocator; }
        }

        private Builder CreateBuilder()
        {
            Builder builder = new Builder();

            builder.Strategies.AddNew<EventBrokerStrategy>(BuilderStage.Initialization);
            builder.Strategies.AddNew<CommandStrategy>(BuilderStage.Initialization);
            builder.Strategies.AddNew<ObjectBuiltNotificationStrategy>(BuilderStage.PostInitialization);

            builder.Policies.SetDefault<ObjectBuiltNotificationPolicy>(new ObjectBuiltNotificationPolicy());
            builder.Policies.SetDefault<ISingletonPolicy>(new SingletonPolicy(true));

            return builder;
        }
    }
}

Using the TestableRootWorkItem is easy. The key is to realize that ObjectBuilder builds up an object when you add the object to a ManagedObjectCollection such as WorkItem.Items. The simple act of adding the object to the collection causes all dependent objects to be injected. Here's a sample test.

        [Test]
        public void RunBatchClose()
        {
            TestableRootWorkItem root = new TestableRootWorkItem();
            BatchCloseWorkItem wi = root.WorkItems.AddNew<BatchCloseWorkItem>();
            BatchCloseController controller = wi.Items.AddNew<BatchCloseController>();
            DataImportDTO batch = GetFirstOpenBatch();
            Assert.IsNotNull(batch);
        }