public void intercept_a_literal_object()
{
var widget = new AWidget();
var container = new Container(x =>
{
x.For <IWidget>().DecorateAllWith(w => new WidgetHolder(w));
x.For <IWidget>().Use(widget);
});
container.GetInstance <IWidget>()
.ShouldBeOfType <WidgetHolder>()
.Inner.ShouldBeTheSameAs(widget);
}
public void throw_if_not_concrete()
{
var clock = new Clock();
var widget = new AWidget();
var container = Container.For(_ =>
{
_.AddSingleton <IClock>(clock);
_.AddSingleton <IWidget>(widget);
});
Exception <InvalidOperationException> .ShouldBeThrownBy(() => { container.QuickBuild <IWidget>(); });
}
public static void HideWidget(AssetReference assetReference)
{
if (activeWidgets.ContainsKey(assetReference))
{
AWidget activeWidget = activeWidgets[assetReference];
if (activeWidget != null)
{
activeWidget.Hide();
activeWidgets.Remove(assetReference);
inactiveWidgetPool.Add(assetReference, activeWidget);
}
}
}
public void specify_an_array_as_a_constructor()
{
IWidget widget1 = new AWidget();
IWidget widget2 = new AWidget();
IWidget widget3 = new AWidget();
build <ClassWithWidgetArrayCtor>(i => i.EnumerableOf <IWidget>().Contains(x =>
{
x.Object(widget1);
x.Object(widget2);
x.Object(widget3);
})).Widgets.ShouldBe(new[] { widget1, widget2, widget3 });
}
public void specify_an_array_as_a_property()
{
IWidget widget1 = new AWidget();
IWidget widget2 = new AWidget();
IWidget widget3 = new AWidget();
build <ClassWithWidgetArraySetter>(i => i.TheArrayOf <IWidget>().Contains(x =>
{
x.Object(widget1);
x.Object(widget2);
x.Object(widget3);
})).Widgets.ShouldEqual(new[] { widget1, widget2, widget3 });
}
public static async Task <T> ShowWidget <T>(AssetReference assetReference, IWidgetProperties properties)
where T : AWidget
{
if (activeWidgets.ContainsKey(assetReference))
{
AWidget returnWidget = activeWidgets[assetReference];
returnWidget.ApplyProperties(properties);
return((T)returnWidget);
}
else if (inactiveWidgetPool.ContainsKey(assetReference))
{
AWidget widget = inactiveWidgetPool[assetReference];
widget.ApplyProperties(properties);
widget.Show();
activeWidgets.Add(assetReference, widget);
inactiveWidgetPool.Remove(assetReference);
return((T)widget);
}
else
{
GameObject result = await assetReference.LoadAssetAsync <GameObject>().Task;
AWidget assetWidget = result.GetComponent <AWidget>();
GameObject parentLayer;
if (assetWidget.GetComponentType() == UiComponentType.Static)
{
parentLayer = staticUiLayer;
}
else if (assetWidget.GetComponentType() == UiComponentType.Dynamic)
{
parentLayer = dynamicUiLayer;
}
else if (assetWidget.GetComponentType() == UiComponentType.Overlay)
{
parentLayer = overlayUiLayer;
}
else
{
Debug.LogError("Layer has not been defined for Widget: " + assetWidget.name);
return(null);
}
AWidget newWidget = GameObject.Instantiate(assetWidget, parentLayer.transform);
newWidget.Open();
newWidget.ApplyProperties(properties);
activeWidgets.Add(assetReference, newWidget);
return((T)newWidget);
}
}
public void Add_default_instance_with_literal()
{
var registry = new Registry();
var theWidget = new AWidget();
string theProfileName = "something";
registry.Profile(theProfileName)
.For <IWidget>().Use(theWidget);
PluginGraph graph = registry.Build();
var instance = (ObjectInstance)graph.ProfileManager.GetDefault(typeof(IWidget), "something");
Assert.AreSame(theWidget, instance.Object);
}
public void Add_default_instance_with_literal()
{
var registry = new Registry();
var theWidget = new AWidget();
var theProfileName = "something";
registry.Profile(theProfileName, p => { p.For <IWidget>().Use(theWidget); });
var graph = registry.Build();
graph.Profile("something").Families[typeof(IWidget)].GetDefaultInstance()
.ShouldBeOfType <ObjectInstance <AWidget, IWidget> >()
.Object.ShouldBeTheSameAs(theWidget);
}
public void throw_if_no_public_constructors()
{
var clock = new Clock();
var widget = new AWidget();
var container = Container.For(_ =>
{
_.AddSingleton <IClock>(clock);
_.AddSingleton <IWidget>(widget);
});
Exception <InvalidOperationException> .ShouldBeThrownBy(() =>
{
container.QuickBuild <GuyWithNoPublicConstructors>();
}).Message.ShouldContain(ConstructorInstance.NoPublicConstructors);
}
public void uses_greediest_constructor_it_can()
{
var clock = new Clock();
var widget = new AWidget();
var container = Container.For(_ =>
{
_.AddSingleton <IClock>(clock);
//_.AddSingleton<IWidget>(widget);
});
var user = container.QuickBuild <WidgetUser>();
user.Clock.ShouldBeSameAs(clock);
user.Widget.ShouldBeNull();
}
public void happy_path()
{
var clock = new Clock();
var widget = new AWidget();
var container = Container.For(_ =>
{
_.AddSingleton <IClock>(clock);
_.AddSingleton <IWidget>(widget);
});
var user = container.QuickBuild <WidgetUser>();
user.Clock.ShouldBeSameAs(clock);
user.Widget.ShouldBeSameAs(widget);
}
public void use_all_instances_of_an_enumerable_element_type()
{
var widget1 = new AWidget();
var widget2 = new AWidget();
var widget3 = new AWidget();
var container = new Container(x => {
x.For <IWidget>().AddInstances(o => {
o.Object(widget1);
o.Object(widget2);
o.Object(widget3);
});
});
container.GetInstance <ClassWithWidgets>().Widgets.ShouldHaveTheSameElementsAs(widget1, widget2, widget3);
}
public void inject_into_root_container()
{
var container = new Container(_ =>
{
_.Injectable <IWidget>();
});
var widget = new AWidget();
container.Inject <IWidget>(widget);
container.GetInstance <IWidget>()
.ShouldBeSameAs(widget);
container.GetInstance <WidgetUser>()
.Widget.ShouldBeSameAs(widget);
}
public void inject_into_root_container(bool replace)
{
var container = new Container(_ =>
{
_.Injectable <IWidget>();
});
var widget = new AWidget();
container.Inject(typeof(IWidget), widget, replace);
container.GetInstance <IWidget>()
.ShouldBeSameAs(widget);
container.GetInstance <WidgetUser>()
.Widget.ShouldBeSameAs(widget);
}
public void get_for_cached_instance_created_on_different_thread_returns_cached_instance()
{
var aWidget = new AWidget();
var instance = new ObjectInstance(aWidget);
cache.Get(typeof(IWidget), instance, new StubBuildSession());
object cachedWidget = null;
var thread =
new Thread(() => { cachedWidget = cache.Get(typeof(IWidget), instance, new StubBuildSession()); });
thread.Start();
// Allow 10ms for the thread to start and for Get call to complete
thread.Join(10);
cachedWidget.ShouldNotBeNull();
cachedWidget.ShouldBe(aWidget);
}
public void has()
{
var widget = new AWidget();
var instance = new ObjectInstance(widget);
cache.Has(typeof(IWidget), instance).ShouldBeFalse();
cache.Set(typeof(Rule), instance, widget);
cache.Has(typeof(IWidget), instance).ShouldBeFalse();
cache.Set(typeof(IWidget), new ObjectInstance(new AWidget()), widget);
cache.Has(typeof(IWidget), instance).ShouldBeFalse();
cache.Set(typeof(IWidget), instance, widget);
cache.Has(typeof(IWidget), instance).ShouldBeTrue();
}
public void replace_causes_replacement_of_previous_value_on_subsequent_call()
{
var container = new Container(_ =>
{
_.Injectable <IWidget>();
});
var replaced = new AWidget();
var widget = new AWidget();
container.Inject(typeof(IWidget), replaced, false);
container.Inject(typeof(IWidget), widget, true);
container.GetInstance <IWidget>()
.ShouldBeSameAs(widget);
container.GetInstance <WidgetUser>()
.Widget.ShouldBeSameAs(widget);
}
public void get_for_cached_instance_created_on_different_thread_returns_cached_instance()
{
var aWidget = new AWidget();
var instance = new ObjectInstance(aWidget);
cache.Get(typeof(IWidget), instance, new StubBuildSession());
object cachedWidget = null;
var thread = new Thread(() =>
{
cachedWidget = cache.Get(typeof(IWidget), instance, new StubBuildSession());
});
thread.Start();
// Allow 10ms for the thread to start and for Get call to complete
thread.Join(10);
Assert.NotNull(cachedWidget, "Get did not return cachedWidget within allowed time. Is your thread being blocked?");
Assert.AreEqual(aWidget, cachedWidget);
}
public void generic_calls_nongeneric_without_replace()
{
var container = new Derived(_ =>
{
_.Injectable <IWidget>();
});
var widget = new AWidget();
container.Inject <IWidget>(widget);
container.serviceType.ShouldBeSameAs(typeof(IWidget));
[email protected](widget);
container.replace.ShouldBeFalse();
container.GetInstance <IWidget>()
.ShouldBeSameAs(widget);
container.GetInstance <WidgetUser>()
.Widget.ShouldBeSameAs(widget);
}
public void inject_scoping_with_nested_container(bool replace)
{
var container = new Container(_ =>
{
_.Injectable <IWidget>();
});
var rootWidget = new AWidget();
container.Inject(typeof(IWidget), rootWidget, replace);
var nestedWidget = new BWidget();
var nested = container.GetNestedContainer();
nested.Inject <IWidget>(nestedWidget);
container.GetInstance <IWidget>()
.ShouldBeSameAs(rootWidget);
nested.GetInstance <IWidget>()
.ShouldBeSameAs(nestedWidget);
}
public void build_nested_container_with_defaults()
{
var container = new Container(_ =>
{
_.For <Blue>().Use <Blue>();
_.For <IWidget>().Use <DefaultWidget>();
_.For <Rule>().Use <ARule>();
});
var nestedWidget = new AWidget();
var nestedBlue = new Blue();
var arguments = new TypeArguments().Set(nestedBlue).Set <IWidget>(nestedWidget);
var nested = container.GetNestedContainer(arguments);
nested.GetInstance <IWidget>().ShouldBeTheSameAs(nestedWidget);
nested.GetInstance <Blue>().ShouldBeTheSameAs(nestedBlue);
// fallback to the parent w/ no defaults
nested.GetInstance <Rule>().ShouldBeOfType <ARule>();
// main container is not corrupted by the nested registrations
container.GetInstance <IWidget>().ShouldBeOfType <DefaultWidget>();
}
