public void CanBuildWithParameterlessConstr()
{
var di = new PhillyContainer();
di.Register <SimpleDependency>(LifeStyle.Transient);
var itm = di.Resolve <SimpleDependency>();
itm.Assert().NotNull();
itm.SomeValue.Assert().Equal("Blah");
}
public void references_itself__exception_thrown()
{
var di = new PhillyContainer();
di.Register <SelfRef>(LifeStyle.Transient);
Assert
.ThrowsAny(() => di.Resolve <SelfRef>())
.With(Trace);
}
public void circular_references__exception_thrown()
{
var di = new PhillyContainer();
di.Register <AWithB>(LifeStyle.Transient);
di.Register <BWithA>(LifeStyle.Transient);
Assert
.ThrowsAny(() => di.Resolve <AWithB>())
.With(Trace);
}
public void type_not_registered__exception_thrown()
{
var di = new PhillyContainer();
Assert
.ThrowsAny(() => di.Resolve <FirstImpl>())
.With(Trace)
.Map(x => x.Message)
.Equal("key Philadelphia.Tests.Client.Tests.DiContainerTests+FirstImpl is not registered in container");
}
public void RegisterAliasIsWorking()
{
var di = new PhillyContainer();
di.RegisterAlias <ISomeAbst, FirstImpl>(LifeStyle.Transient);
var itm = di.Resolve <ISomeAbst>();
itm.Assert().True(x => x.MyName == "first", "gets FirstImpl");
}
public void type_registered_with_mapping__cant_use_impl_when_resolving()
{
var di = new PhillyContainer();
di.RegisterAlias <ISomeAbst, FirstImpl>(LifeStyle.Transient);
Assert
.ThrowsAny(() => di.Resolve <FirstImpl>())
.With(Trace)
.Map(x => x.Message)
.Equal("key Philadelphia.Tests.Client.Tests.DiContainerTests+FirstImpl is not registered in container");
}
public void RegisterManyAliasesIsWorking()
{
var di = new PhillyContainer();
di.RegisterAlias <ISomeAbst, FirstImpl>(LifeStyle.Transient);
di.RegisterAlias <ISomeAbst, OtherImpl>(LifeStyle.Transient);
var itms = di.ResolveAll <ISomeAbst>().OrderBy(x => x.MyName).ToList();
itms.Assert().True(x => x.Count == 2, "two items returned by ResolveAll");
itms.Assert().True(x => x[0].MyName == "first", "result contains implementation FirstImpl");
itms.Assert().True(x => x[1].MyName == "other", "result contains implementation OtherImpl");
}
public void IsSingletonLifeStyleRespected()
{
var di = new PhillyContainer();
di.Register <PurportedSingleton>(LifeStyle.Singleton);
var itm1 = di.Resolve <PurportedSingleton>();
var itm2 = di.Resolve <PurportedSingleton>();
var itm3 = di.Resolve <PurportedSingleton>();
PurportedSingleton.InstancesCreated.Assert().Equal(1);
itm1.Assert().Equal(itm2);
itm3.Assert().Equal(itm2);
}
public Program(EnvironmentType env)
{
_di = new PhillyContainer();
Services.Register(_di); //registers discovered services from model
_di.RegisterAlias <IHttpRequester, BridgeHttpRequester>(LifeStyle.Singleton);
_di.Register <MainMenuFlow>(LifeStyle.Transient);
Toolkit.InitializeToolkit(null, x => _di.Resolve <ISomeService>().DataGridToSpreadsheet(x));
var forcedCulture = DocumentUtil.GetQueryParameterOrNull("forcedCulture");
I18n.ConfigureImplementation(() => new ToStringLocalization(forcedCulture));
_renderer = Toolkit.DefaultFormRenderer();
}
public static void OnReady()
{
var di = new PhillyContainer();
di.RegisterAlias <IHttpRequester, BridgeHttpRequester>(LifeStyle.Singleton);
Services.Register(di); //registers discovered services from model
di.Register <HelloFlow>(LifeStyle.Transient);
Toolkit.InitializeToolkit();
var renderer = Toolkit.DefaultFormRenderer();
var helloService = di.Resolve <IHelloWorldService>();
Document.Title = "PhiladelphiaPowered App";
di.Resolve <HelloFlow>().Run(renderer);
}
public void IsTransientLifeStyleRespected()
{
var di = new PhillyContainer();
di.Register <PurportedTransient>(LifeStyle.Transient);
var itm1 = di.Resolve <PurportedTransient>();
var itm2 = di.Resolve <PurportedTransient>();
var itm3 = di.Resolve <PurportedTransient>();
PurportedTransient.InstancesCreated.Assert().Equal(3);
itm1.Assert().NotEqual(itm2);
itm2.Assert().NotEqual(itm3);
itm1.Assert().NotEqual(itm3);
itm1.Assert().True(x => x.Id == 0, "itm1.Id == 0");
itm2.Assert().True(x => x.Id == 1, "itm2.Id == 1");
itm3.Assert().True(x => x.Id == 2, "itm2.Id == 2");
}
public void missing_dependency__error_thrown()
{
var di = new PhillyContainer();
di.Register <SimpleService>(LifeStyle.Transient);
Assert
.ThrowsAny(() => di.Resolve <SimpleService>())
.With(Trace)
.With(x => x
.Message
.Assert()
.Equal("Failed resolving [Philadelphia.Tests.Client.Tests.DiContainerTests+SimpleService]. Implementation: [constructor of Philadelphia.Tests.Client.Tests.DiContainerTests+SimpleService]"))
.With(x => x
.InnerException
.Assert()
.NotNull())
.With(x => x
.InnerException.Message
.Assert()
.Equal("key Philadelphia.Tests.Client.Tests.DiContainerTests+SimpleDependency is not registered in container"));
}
public static void OnReady()
{
var di = new PhillyContainer();
di.RegisterAlias <IHttpRequester, BridgeHttpRequester>(LifeStyle.Singleton);
Services.Register(di); //registers discovered services from model
di.Register <HelloWorldFlow>(LifeStyle.Transient);
Toolkit.InitializeToolkit();
var testOrNull = DocumentUtil.GetHashParameterOrNull(MagicsForTests.TestChoiceParamName);
if (testOrNull == null)
{
Document.Body.AppendChild(new HTMLSpanElement {
TextContent = "no test selected"
});
}
switch (EnumExtensions.GetEnumByLabel <MagicsForTests.ClientSideFlows>(testOrNull))
{
case MagicsForTests.ClientSideFlows.ServerSentEvents: {
IServerSentEventsService_RegisterListener_SseSubscriber listener = null;
var service = di.Resolve <IServerSentEventsService>();
var log = new HTMLDivElement {
Id = MagicsForTests.RunClientSideTestLogSpanId
};
log.Style.WhiteSpace = WhiteSpace.Pre;
void LogWriteLine(string x)
{
Logger.Debug(typeof(Program), "adding log line: {0}", x);
log.TextContent = log.TextContent + x + "\n";
}
void DoConnect()
{
if (listener != null)
{
throw new Exception("already connected");
}
var notifScopeRaw = DocumentUtil.GetHashParameterOrNull(MagicsForTests.ValueToSend);
var notifScope = JsonConvert.DeserializeObject <SomeNotifFilter>(notifScopeRaw);
listener = new IServerSentEventsService_RegisterListener_SseSubscriber(
() => notifScope, false);
listener.OnConnOpen += () => LogWriteLine("connected");
listener.OnError += (ev, crs) => LogWriteLine($"connection error {(int)crs}");
listener.OnMessage += x => LogWriteLine($"received: {x}");
listener.Connect();
}
var sendMsg = new HTMLButtonElement {
TextContent = "send", Id = MagicsForTests.RunClientSideTestSendBtnId
};
sendMsg.OnClick += async _ => {
var msgRaw = DocumentUtil.GetHashParameterOrNull(MagicsForTests.ValueToSend);
var msg = JsonConvert.DeserializeObject <SomeNotif>(msgRaw);
await service.Publish(msg);
};
var connectAction = new HTMLButtonElement {
TextContent = "connect", Id = MagicsForTests.RunClientSideTestConnectId
};
connectAction.OnClick += _ => DoConnect();
var disconnectAction = new HTMLButtonElement {
TextContent = "disconnect", Id = MagicsForTests.RunClientSideTestDisconnectId
};
disconnectAction.OnClick += _ => {
listener.Dispose();
listener = null;
};
Document.Body.AppendChild(log);
Document.Body.AppendChild(sendMsg);
Document.Body.AppendChild(connectAction);
Document.Body.AppendChild(disconnectAction);
//TODO add disconnect
}
break;
case MagicsForTests.ClientSideFlows.HelloWorld:
var renderer = Toolkit.DefaultFormRenderer();
di.Resolve <HelloWorldFlow>().Run(renderer);
break;
case MagicsForTests.ClientSideFlows.SerializationTest_String:
RunSerializationTestFlow(
MagicsForTests.Serialization.String.DefaultTypedVal,
s => s,
d => d,
val => di.Resolve <ISerDeserService>().ProcessString(val));
break;
case MagicsForTests.ClientSideFlows.SerializationTest_Int:
RunSerializationTestFlow(
MagicsForTests.Serialization.Int.DefaultTypedVal,
s => int.Parse(s),
d => d.ToString(),
val => di.Resolve <ISerDeserService>().ProcessInt(val));
break;
case MagicsForTests.ClientSideFlows.SerializationTest_DateTimeUtc:
RunSerializationTestFlow(
MagicsForTests.Serialization.DateTimeUTC.DefaultTypedVal,
s => Convert.ToDateTime(s),
d => d.ToStringYyyyMmDdHhMm(),
val => di
.Resolve <ISerDeserService>()
.ProcessDateTime(DateTime.SpecifyKind(val, DateTimeKind.Utc), true));
break;
case MagicsForTests.ClientSideFlows.SerializationTest_DateTimeLocal:
RunSerializationTestFlow(
MagicsForTests.Serialization.DateTimeLocal.DefaultTypedVal,
s => Convert.ToDateTime(s),
d => d.ToStringYyyyMmDdHhMm(),
val => di
.Resolve <ISerDeserService>()
.ProcessDateTime(DateTime.SpecifyKind(val, DateTimeKind.Local), false));
break;
case MagicsForTests.ClientSideFlows.SerializationTest_Long:
RunSerializationTestFlow(
MagicsForTests.Serialization.Long.DefaultTypedVal,
s => long.Parse(s),
d => d.ToString(),
val => di.Resolve <ISerDeserService>().ProcessLong(val));
break;
case MagicsForTests.ClientSideFlows.SerializationTest_Decimal:
RunSerializationTestFlow(
MagicsForTests.Serialization.Decimal.DefaultTypedVal,
s => decimal.Parse(s, CultureInfo.InvariantCulture),
d => d.ToString(CultureInfo.InvariantCulture),
val => di.Resolve <ISerDeserService>().ProcessDecimal(val));
break;
default:
Document.Body.AppendChild(new HTMLSpanElement {
TextContent = "unsupported test selected"
});
break;
}
}
