public void Then_the_dictionary_value_and_key_must_be_injected_with_registered_types()
{
const string keyidentifier = "keyidentifier";
const string dictionaryId = "dicid";
FluentApplicationContext.Register <TestObject>()
.Bind(x => x.PropertyX).To(keyidentifier);
FluentApplicationContext.Register <TestObject>(dictionaryId)
.Bind(x => x.TestObjectKeyValueDictionary).ToDefinition(
Inline.Dictionary <TestObject, TestObject>()
.AddEntry()
.WithKey <TestObject>()
.AndValue <TestObject>()
);
IApplicationContext applicationContext = _applicationContextContainer.InitialiseContext();
var initialisedObject = applicationContext.GetObject <TestObject>(dictionaryId);
var keyObject = applicationContext.GetObject <TestObject>();
Assert.IsTrue(initialisedObject.TestObjectKeyValueDictionary.ContainsKey(keyObject));
Assert.AreSame(keyObject, initialisedObject.TestObjectKeyValueDictionary[keyObject]);
}
public void Then_the_dictionary_key_and_value_must_be_injected_with_inline_objects()
{
const string dictionaryId = "dicid";
FluentApplicationContext.Register <TestObject>(dictionaryId)
.Bind(x => x.TestObjectKeyValueDictionary).ToDefinition(
Inline.Dictionary <TestObject, TestObject>()
.AddEntry()
.WithKeyDefinition(
Inline.Object <TestObject>()
.Bind(x => x.PropertyX).To("somekeyvalue")
)
.AndValueDefinition(
Inline.Object <TestObject>()
.Bind(x => x.PropertyX).To("somevalue"))
);
IApplicationContext applicationContext = _applicationContextContainer.InitialiseContext();
var initialisedObject = applicationContext.GetObject <TestObject>(dictionaryId);
Assert.IsTrue(initialisedObject.TestObjectKeyValueDictionary.Keys.Where(l => l.PropertyX.Equals("somekeyvalue")).Count() > 0);
Assert.IsTrue(initialisedObject.TestObjectKeyValueDictionary.Values.Where(l => l.PropertyX.Equals("somevalue")).Count() > 0);
Assert.AreEqual("somevalue", initialisedObject.TestObjectKeyValueDictionary.Where(k => k.Value.PropertyX.Equals("somevalue")).Single().Value.PropertyX);
}
public void Then_the_dictionary_must_be_injected()
{
const string identifier = "myobjectname";
FluentApplicationContext.Register <ObjectWithProperties>(identifier)
.Bind(x => x.ADictionaryProperty).ToDefinition(
Inline.Dictionary <string, string>()
.AddEntry().WithKey("myvalue").AndValue("somevalue"));
IApplicationContext applicationContext = _applicationContextContainer.InitialiseContext();
var initialisedObject = (ObjectWithProperties)applicationContext.GetObject(identifier);
Assert.IsTrue(initialisedObject.ADictionaryProperty.ContainsKey("myvalue"));
Assert.AreEqual("somevalue", initialisedObject.ADictionaryProperty["myvalue"]);
}
public void Then_the_dictionary_key_must_be_injected_with_registered_object()
{
const string identifier = "myobjectname";
const string dictionaryId = "dicid";
FluentApplicationContext.Register <TestObject>(identifier)
.Bind(x => x.PropertyX).To("somevalue");
FluentApplicationContext.Register <TestObject>(dictionaryId)
.Bind(x => x.TestObjectKeyDictionary).ToDefinition(
Inline.Dictionary <TestObject, string>()
.AddEntry().WithKey <TestObject>(identifier).AndValue("somevalue"));
IApplicationContext applicationContext = _applicationContextContainer.InitialiseContext();
var keyTestObject = applicationContext.GetObject <TestObject>(identifier);
var initialisedObject = applicationContext.GetObject <TestObject>(dictionaryId);
Assert.IsTrue(initialisedObject.TestObjectKeyDictionary.ContainsKey(keyTestObject));
Assert.AreEqual("somevalue", initialisedObject.TestObjectKeyDictionary[keyTestObject]);
}
public void Demo()
{
FluentApplicationContext.Register <TestObject>()
.AsNonSingleton()
.Bind(x => x.PropertyX).To("a value");
FluentApplicationContext.Register <TestObject>().Bind(x => x.PropertyX).To <String>();
FluentApplicationContext.Register <TestObject>().Bind(x => x.PropertyX).To <String>("something");
FluentApplicationContext.Register <TestObject>().Bind(x => x.PropertyX).To("something");
FluentApplicationContext.Register <TestObject>().Bind(x => x.SomeDictionary).ToDefinition(
Inline.Dictionary <string, String>()
.AddEntry().WithKey <String>().AndValue("adsf")
.AddEntry().WithKey("asdfasdf").AndValue <String>()
.AddEntry().WithKey("asdfasdf").AndValueDefinition(
Inline.Object <String>()
.Bind(x => x.ToString()).To("1"))
.AddEntry()
.WithKeyDefinition(
Inline.Object <string>())
.AndValueDefinition(
Inline.Object <String>()
.Bind(x => x.ToString()).To("1"))
);
Inline.Dictionary <string, string>()
.AddEntry().WithKey <String>().AndValue("adsf")
.AddEntry().WithKey("asdfasdf").AndValue <String>();
FluentApplicationContext.Register <TestObject>()
.BindConstructorArgument <String>()
.ToDefinition(Inline.Object <String>());
FluentApplicationContext.Bind <IDictionary <string, string> >()
.To <Dictionary <string, string> >().When(Is.RunningEnvironment("PROD"));
}
public void Then_the_associated_repository_must_be_used()
{
FluentApplicationContext.Register <TestObjectRepository>();
FluentApplicationContext.Register <TestObject>();
FluentApplicationContext.Register <Repositories>()
.Bind(x => x.Registry).ToDefinition(
Inline.Dictionary <string, IRepository>()
.AddEntry()
.WithKey(typeof(TestObject).FullName).AndValue <TestObjectRepository>()
);
IApplicationContext context = _applicationContextContainer.InitialiseContext();
string id = "1";
var otherTestObject = context.GetObject <TestObject>();
var testObject = context.GetObjectById <TestObject>(id);
Assert.AreNotEqual(otherTestObject, testObject);
Assert.AreEqual(id, testObject.PropertyX);
}
public void Then_the_dictionary_value_must_be_injected_with_registered_object()
{
const string identifier = "myobjectname";
const string dictionaryId = "dicid";
FluentApplicationContext.Register <TestObject>(identifier)
.Bind(x => x.PropertyX).To("somevalue");
FluentApplicationContext.Register <TestObject>(dictionaryId)
.Bind(x => x.TestObjectValueDictionary).ToDefinition(
Inline.Dictionary <string, TestObject>()
.AddEntry()
.WithKey("mykey")
.AndValue <TestObject>(identifier)
);
IApplicationContext applicationContext = _applicationContextContainer.InitialiseContext();
var initialisedObject = applicationContext.GetObject <TestObject>(dictionaryId);
Assert.IsTrue(initialisedObject.TestObjectValueDictionary.Values.Where(l => l.PropertyX.Equals("somevalue")).Count() > 0);
Assert.AreEqual("somevalue", initialisedObject.TestObjectValueDictionary.Where(k => k.Value.PropertyX.Equals("somevalue")).Single().Value.PropertyX);
}
