public void ShouldLoadAssemblyIntoLoaderAtRuntime()
{
var path = Path.Combine(@"..\..\..\SampleFileWatcherLibrary\bin\Debug",
AppDomain.CurrentDomain.BaseDirectory);
var targetFile = "SampleFileWatcherLibrary.dll";
var sourceFileName = Path.Combine(path, targetFile);
var container = new ServiceContainer();
container.AutoLoadFrom(AppDomain.CurrentDomain.BaseDirectory, "dummy.dll");
// There should be nothing loaded at this point since the assembly hasn't
// been copied to the target directory yet
Assert.False(container.Contains(typeof(ISampleService)));
// Copy the assembly to the target directory
// and watch for changes
var targetFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "dummy.dll");
File.Copy(sourceFileName, targetFileName, true);
// Give the watcher thread enough time to load the assembly into memory
Thread.Sleep(500);
Assert.True(container.Contains(typeof(ISampleService)));
var instance = container.GetService <ISampleService>();
Assert.NotNull(instance);
var typeName = instance.GetType().Name;
Assert.Equal("SampleFileWatcherServiceClassAddedAtRuntime", typeName);
}
ContainerMustLoadSpecificGenericServiceTypesFromAGenericConcreteClassMarkedWithTheImplementsAttribute()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll");
string serviceName = "SpecificGenericService";
// The container must be able to create both registered service types
Assert.IsTrue(container.Contains(serviceName, typeof(ISampleGenericService <int>)));
Assert.IsTrue(container.Contains(serviceName, typeof(ISampleGenericService <double>)));
// Both service types must be valid services
Assert.IsNotNull(container.GetService <ISampleGenericService <int> >());
Assert.IsNotNull(container.GetService <ISampleGenericService <double> >());
}
public Element Parse(XElement element)
{
Node node = new Node
{
Name = element.Attribute("name").Value,
ID = element.Attribute("id").Value,
Cooperation = Convert.ToInt32(element.Attribute("cooperation").Value)
};
string category = element.Attribute("category").Value;
node.NodeType = Utils.Convert(category);
if (element.HasElements)
{
List <Element> nodes = new List <Element>();
element.Elements().ToList().ForEach(entry =>
{
string nodeName = entry.Name.LocalName;
if (ServiceContainer.Contains(nodeName))
{
IWorkflowParse parseService = (ServiceContainer.Resolve(nodeName) as IWorkflowParse);
nodes.Add(parseService.Parse(entry));
}
});
node.Transitions.AddRange(nodes.Where(transition => (transition is Transition)).Cast <Transition>());
node.Actions.AddRange(nodes.Where(action => (action is Action)).Cast <Action>());
node.Groups.AddRange(nodes.Where(group => (group is Group)).Cast <Group>());
node.Actors.AddRange(nodes.Where(actor => (actor is Actor)).Cast <Actor>());
node.Command = nodes.Where(command => (command is Command)).Cast <Command>().FirstOrDefault();
}
return(node);
}
public void ContainerMustLoadAssemblyFromMemory()
{
var container = new ServiceContainer();
container.LoadFrom(typeof(SampleClass).Assembly);
// Verify that the container loaded the sample assembly into memory
Assert.IsTrue(container.Contains(typeof(ISampleService)));
}
public void ShouldReportThatServiceExistsForStronglyTypedFunctor()
{
var container = new ServiceContainer();
Func <int, int, int> addOperation1 = (a, b) => a + b;
container.AddService("Add", addOperation1);
Assert.IsTrue(container.Contains("Add", typeof(int), 1, 1));
}
ContainerMustLoadAnyGenericServiceTypeInstanceFromAGenericConcreteClassMarkedWithTheImplementsAttribute()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll");
string serviceName = "NonSpecificGenericService";
// The container must be able to create any type that derives from ISampleService<T>
// despite whether or not the specific generic service type is explicitly registered as a service
Assert.IsTrue(container.Contains(serviceName, typeof(ISampleGenericService <int>)));
Assert.IsTrue(container.Contains(serviceName, typeof(ISampleGenericService <double>)));
Assert.IsTrue(container.Contains(serviceName, typeof(ISampleGenericService <string>)));
// Both service types must be valid services
Assert.IsNotNull(container.GetService <ISampleGenericService <int> >());
Assert.IsNotNull(container.GetService <ISampleGenericService <double> >());
Assert.IsNotNull(container.GetService <ISampleGenericService <string> >());
}
public void ContainerMustHoldAnonymousFactoryInstance()
{
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
// Give it a random service interface type
Type serviceType = typeof(IDisposable);
// Manually add the factory instance
container.AddFactory(serviceType, mockFactory.Object);
Assert.IsTrue(container.Contains(serviceType), "The container needs to have a factory for service type '{0}'", serviceType);
}
public void ContainerServicesShouldBeLazyIfProxyFactoryExists()
{
var container = new ServiceContainer();
container.AddService <IProxyFactory>(new ProxyFactory());
Assert.IsTrue(container.Contains(typeof(IProxyFactory)));
// The instance should never be created
container.AddService(typeof(ISampleService), typeof(SampleLazyService));
var result = container.GetService <ISampleService>();
Assert.IsFalse(SampleLazyService.IsInitialized);
}
public Element Parse(XElement element)
{
Node node = new Node
{
Name = element.Attribute("name").Value,
ID = element.Attribute("id").Value,
Cooperation = element.Attribute("cooperation").Value,
Assistant = element.Attribute("assistant").Value
};
XAttribute back = element.Attribute("back");
XAttribute url = element.Attribute("url");
XAttribute attr = element.Attribute("veto");
node.Veto = attr != null && attr.Value == "0" ? String.Empty : "Smartflow.Core.Components.VetoService";
node.Back = back == null ? String.Empty : back.Value;
node.Url = url == null ? String.Empty : url.Value;
string category = element.Attribute("category").Value;
node.NodeType = Internals.Utils.Convert(category);
if (element.HasElements)
{
List <Element> nodes = new List <Element>();
element.Elements().ToList().ForEach(entry =>
{
string nodeName = entry.Name.LocalName;
if (ServiceContainer.Contains(nodeName))
{
IWorkflowParse parseService = (ServiceContainer.Resolve(nodeName) as IWorkflowParse);
nodes.Add(parseService.Parse(entry));
}
});
node.Transitions.AddRange(nodes.Where(transition => (transition is Transition)).Cast <Transition>());
node.Actions.AddRange(nodes.Where(action => (action is Action)).Cast <Action>());
node.Groups.AddRange(nodes.Where(group => (group is Group)).Cast <Group>());
node.Actors.AddRange(nodes.Where(actor => (actor is Actor)).Cast <Actor>());
node.Rules.AddRange(nodes.Where(rule => (rule is Elements.Rule)).Cast <Elements.Rule>());
node.Carbons.AddRange(nodes.Where(carbon => (carbon is Elements.Carbon)).Cast <Elements.Carbon>());
node.Organizations.ToList().AddRange(nodes.Where(org => (org is Elements.Organization)).Cast <Elements.Organization>());
node.Command = nodes.Where(command => (command is Command)).Cast <Command>().FirstOrDefault();
if (node.Command != null)
{
node.Command.Node = node;
}
}
return(node);
}
public BasePager(IReportModel reportModel)
{
if (reportModel == null)
{
throw new ArgumentNullException("reportModel");
}
this.ReportModel = reportModel;
if (!ServiceContainer.Contains(typeof(ILayouter)))
{
ServiceContainer.AddService <ILayouter>(new Layouter());
}
this.Graphics = CreateGraphicObject.FromSize(this.ReportModel.ReportSettings.PageSize);
}
public void ContainerMustAllowInjectingCustomFactoriesForOpenGenericTypeDefinitions()
{
var container = new ServiceContainer();
var factory = new SampleOpenGenericFactory();
container.AddFactory(typeof(ISampleGenericService <>), factory);
// The container must report that it *can* create
// the generic service type
Assert.IsTrue(container.Contains(typeof(ISampleGenericService <int>)));
var result = container.GetService <ISampleGenericService <int> >();
Assert.IsNotNull(result);
Assert.IsTrue(result.GetType() == typeof(SampleGenericImplementation <int>));
}
public void ContainerMustUseUnnamedContainsMethodIfNameIsNull()
{
var mockFactory = new Mock <IFactory>();
var mockService = new Mock <ISerializable>();
var container = new ServiceContainer();
Type serviceType = typeof(ISerializable);
// Use unnamed AddFactory method
container.AddFactory(serviceType, mockFactory.Object);
// The container should use the
// IContainer.Contains(Type) method instead of the
// IContainer.Contains(string, Type) method if the
// service name is blank
Assert.IsTrue(container.Contains(null, typeof(ISerializable)));
}
public void FactoryAttributeLoaderMustInjectStronglyTypedFactoryIntoContainer()
{
var container = new ServiceContainer();
Type serviceType = typeof(ISampleService);
ITypeLoader loader = new FactoryAttributeLoader();
IEnumerable <Action <IServiceContainer> > actions = loader.Load(typeof(SampleStronglyTypedFactory));
// The factory loader should return a set of actions
// that will inject that custom factory into the container
// itself
foreach (var action in actions)
{
action(container);
}
Assert.IsTrue(container.Contains(serviceType));
}
public void ContainerMustHoldNamedFactoryInstance()
{
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
// Randomly assign an interface type
// NOTE: The actual interface type doesn't matter
Type serviceType = typeof(ISerializable);
container.AddFactory("MyService", serviceType, mockFactory.Object);
Assert.IsTrue(container.Contains("MyService", serviceType), "The container is supposed to contain a service named 'MyService'");
var instance = new object();
mockFactory.Expect(f => f.CreateInstance(
It.Is <IFactoryRequest>(request => request.ServiceName == "MyService" && request.ServiceType == serviceType)))
.Returns(instance);
Assert.AreSame(instance, container.GetService("MyService", serviceType));
}
public void LazyObjectShouldNeverBeInitialized()
{
var container = new ServiceContainer();
container.AddService <IProxyFactory>(new ProxyFactory());
container.AddService <IMethodBuilder <MethodInfo> >(new MethodBuilder());
Assert.IsTrue(container.Contains(typeof(IProxyFactory)));
var proxyFactory = container.GetService <IProxyFactory>();
var interceptor = new LazyInterceptor <ISampleService>(() => new SampleLazyService());
SampleLazyService.Reset();
// The instance should be uninitialized at this point
var proxy = proxyFactory.CreateProxy <ISampleService>(interceptor);
Assert.IsFalse(SampleLazyService.IsInitialized);
// The instance should be initialized once the method is called
proxy.DoSomething();
Assert.IsTrue(SampleLazyService.IsInitialized);
}
public void ContainsService()
{
bool contains = ServiceContainer.Contains(typeof(ITestInterface));
Assert.That(contains, Is.True);
}
public void DosNotContainsService()
{
bool contains = ServiceContainer.Contains(typeof(IServiceProvider));
Assert.That(contains, Is.False);
}
