public void hook_receives_mediator_and_mediatedItem()
{
SupportView mediatedItem = new SupportView();
object injectedMediator = null;
object injectedView = null;
injector.Map(typeof(Action <MediatorHook>), "callback").ToValue((Action <MediatorHook>) delegate(MediatorHook hook) {
injectedMediator = hook.mediator;
injectedView = hook.mediatedItem;
});
MediatorMapping mapping = new MediatorMapping(CreateTypeFilter(
new Type[1] {
typeof(SupportView)
}),
typeof(ViewInjectedMediator));
mapping.WithHooks(typeof(MediatorHook));
factory.CreateMediators(mediatedItem, typeof(SupportView), new List <IMediatorMapping> {
mapping
});
Assert.That(injectedMediator, Is.InstanceOf <ViewInjectedMediator>());
Assert.That(injectedView, Is.EqualTo(mediatedItem));
}
public void Mediator_Lifecycle_Methods_Are_Invoked()
{
List <string> expected = new List <string> {
"preInitialize", "initialize", "postInitialize",
"preDestroy", "destroy", "postDestroy"
};
List <string> actual = new List <string>();
foreach (string phase in expected)
{
Action <string> callback = delegate(string ph) {
actual.Add(ph);
};
injector.Map(typeof(Action <string>), phase + "Callback").ToValue(callback);
}
SupportView item = new SupportView();
object mediator = injector.InstantiateUnmapped(typeof(LifecycleReportingMediator));
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(LifecycleReportingMediator));
manager.AddMediator(mediator, item, mapping);
manager.RemoveMediator(mediator, item, mapping);
Assert.That(actual, Is.EquivalentTo(expected));
}
public void Mediator_Is_Created()
{
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
object mediator = factory.CreateMediators(new SupportView(), typeof(SupportView), new List <IMediatorMapping> {
mapping
})[0];
Assert.That(mediator, Is.InstanceOf(typeof(CallbackMediator)));
}
/*============================================================================*/
/* Private Functions */
/*============================================================================*/
private MediatorMapping CreateMapping(Type mediatorType)
{
MediatorMapping mapping = new MediatorMapping(_typeFilter, mediatorType);
_handler.AddMapping(mapping);
_mappings [mediatorType] = mapping;
if (_logger != null)
{
_logger.Debug("{0} mapped to {1}", _typeFilter, mapping);
}
return(mapping);
}
public void mediatedItem_is_injected_as_exact_type_into_mediator()
{
SupportView expected = new SupportView();
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(ViewInjectedMediator));
ViewInjectedMediator mediator = factory.CreateMediators(expected, typeof(SupportView), new List <IMediatorMapping> {
mapping
})[0] as ViewInjectedMediator;
Assert.That(mediator.mediatedItem, Is.EqualTo(expected));
}
public void Mediator_Is_Given_NonDisplayObject_View()
{
float expected = 1.5f;
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(float)
}), typeof(LifecycleReportingMediator));
LifecycleReportingMediator mediator = injector.InstantiateUnmapped(typeof(LifecycleReportingMediator)) as LifecycleReportingMediator;
manager.AddMediator(mediator, expected, mapping);
Assert.That(mediator.view, Is.EqualTo(expected));
}
public void getMediator()
{
SupportView mediatedItem = new SupportView();
IMediatorMapping mapping =
new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
factory.CreateMediators(mediatedItem, typeof(SupportView), new List <IMediatorMapping> {
mapping
});
Assert.That(factory.GetMediator(mediatedItem, mapping), Is.Not.Null);
}
private int MediatorsCreatedWithGuards(params object[] guards)
{
MediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
mapping.WithGuards(guards);
List <object> mediators = factory.CreateMediators(new SupportView(), typeof(SupportView), new List <IMediatorMapping> {
mapping
});
return(mediators.Count);
}
public void Mediator_Is_Injected_Into()
{
int expected = 128;
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(InjectedMediator));
injector.Map(typeof(int)).ToValue(expected);
InjectedMediator mediator = factory.CreateMediators(new SupportView(), typeof(SupportView), new List <IMediatorMapping> {
mapping
}) [0] as InjectedMediator;
Assert.That(mediator.number, Is.EqualTo(expected));
}
public void Mediator_For_UIComponent_Is_Initialized()
{
SupportView view = new SupportView();
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(LifecycleReportingMediator));
LifecycleReportingMediator mediator = injector.InstantiateUnmapped(typeof(LifecycleReportingMediator)) as LifecycleReportingMediator;
factory.Setup(f => f.GetMediator(It.IsAny <object> (), It.IsAny <IMediatorMapping>())).Returns(mediator);
Assert.That(mediator.initialized, Is.False);
manager.AddMediator(mediator, view, mapping);
container.AddChild(view);
Assert.That(mediator.initialized, Is.True);
}
public void View_Is_Handled()
{
object createdMediator = null;
Action <object> callback = delegate(object mediator) {
createdMediator = mediator;
};
injector.Map(typeof(Action <object>), "callback").ToValue(callback);
MediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type [1] {
typeof(SupportView)
}), typeof(CallbackMediator));
handler.AddMapping(mapping);
handler.HandleView(new SupportView(), typeof(SupportView));
Assert.That(createdMediator, Is.Not.Null);
}
public void expected_number_of_mediators_are_returned_for_mappings_and_mediatedItem()
{
SupportView mediatedItem = new SupportView();
MediatorMapping mapping1 =
new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(ViewInjectedMediator));
MediatorMapping mapping2 =
new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportContainer)
}), typeof(ViewInjectedAsRequestedMediator));
List <object> mediators = factory.CreateMediators(mediatedItem, typeof(SupportView), new List <IMediatorMapping> {
mapping1, mapping2
});
Assert.That(mediators.Count, Is.EqualTo(2));
}
public void removeMediator_removes_mediator_from_manager()
{
SupportView mediatedItem = new SupportView();
IMediatorMapping mapping =
new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
injector.Map <IMediatorManager> ().ToValue(manager.Object);
factory = new MediatorFactory(injector);
factory.CreateMediators(mediatedItem, typeof(SupportView), new List <IMediatorMapping> {
mapping
});
factory.RemoveMediators(mediatedItem);
factory.RemoveMediators(mediatedItem);
manager.Verify(_manager => _manager.RemoveMediator(It.IsAny <CallbackMediator> (), It.Is <object> (arg2 => arg2 == mediatedItem), It.Is <IMediatorMapping> (arg3 => arg3 == mapping)), Times.Once);
}
/*============================================================================*/
/* Private Functions */
/*============================================================================*/
private int HookCallCount(params object[] hooks)
{
int hookCallCount = 0;
Action hookCallback = delegate() {
hookCallCount++;
};
injector.Map(typeof(Action), "hookCallback").ToValue(hookCallback);
MediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
mapping.WithHooks(hooks);
factory.CreateMediators(new SupportView(), typeof(SupportView), new List <IMediatorMapping> {
mapping
});
return(hookCallCount);
}
public void removeAllMediators_removes_all_mediators_from_manager()
{
SupportView mediatedItem1 = new SupportView();
SupportView mediatedItem2 = new SupportView();
IMediatorMapping mapping1 =
new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
IMediatorMapping mapping2 =
new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportContainer)
}), typeof(ViewInjectedAsRequestedMediator));
injector.Map <IMediatorManager> ().ToValue(manager.Object);
factory = new MediatorFactory(injector);
factory.CreateMediators(mediatedItem1, typeof(SupportView), new List <IMediatorMapping> {
mapping1, mapping2
});
factory.CreateMediators(mediatedItem2, typeof(SupportView), new List <IMediatorMapping> {
mapping1, mapping2
});
factory.RemoveAllMediators();
manager.Verify(_manager => _manager.RemoveMediator(
It.IsAny <CallbackMediator>(),
It.Is <object>(arg2 => arg2 == mediatedItem1),
It.Is <IMediatorMapping>(arg3 => arg3 == mapping1)), Times.Once);
manager.Verify(_manager => _manager.RemoveMediator(
It.IsAny <ViewInjectedAsRequestedMediator>(),
It.Is <object>(arg2 => arg2 == mediatedItem1),
It.Is <IMediatorMapping>(arg3 => arg3 == mapping2)), Times.Once);
manager.Verify(_manager => _manager.RemoveMediator(
It.IsAny <CallbackMediator>(),
It.Is <object>(arg2 => arg2 == mediatedItem2),
It.Is <IMediatorMapping>(arg3 => arg3 == mapping1)), Times.Once);
manager.Verify(_manager => _manager.RemoveMediator(
It.IsAny <ViewInjectedAsRequestedMediator>(),
It.Is <object>(arg2 => arg2 == mediatedItem2),
It.Is <IMediatorMapping>(arg3 => arg3 == mapping2)), Times.Once);
}
public void Mediator_Is_Removed_From_Factory_When_View_Leaves_Stage()
{
int callCount = 0;
object actualView = null;
manager.ViewRemoved += (Action <object>) delegate(object eventView) {
callCount++;
actualView = eventView;
};
SupportView view = new SupportView();
IMediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
object mediator = injector.InstantiateUnmapped(typeof(CallbackMediator));
container.AddChild(view);
manager.AddMediator(mediator, view, mapping);
container.RemoveChild(view);
Assert.That(callCount, Is.EqualTo(1));
Assert.That(actualView, Is.EqualTo(view));
}
public void Mediator_Is_NOT_Removed_When_View_Leaves_Stage_When_AutoRemove_Is_False()
{
int callCount = 0;
manager.ViewRemoved += (Action <object>) delegate(object eventView) {
callCount++;
};
SupportView view = new SupportView();
MediatorMapping mapping = new MediatorMapping(CreateTypeFilter(new Type[1] {
typeof(SupportView)
}), typeof(CallbackMediator));
mapping.AutoRemove(false);
object mediator = injector.InstantiateUnmapped(typeof(CallbackMediator));
container.AddChild(view);
manager.AddMediator(mediator, view, mapping);
container.RemoveChild(view);
Assert.That(callCount, Is.EqualTo(0));
}