public void RegisterObjectResolver()
{
var resolver = new Mock <ArgumentResolver <object> >();
var obj = new object();
resolver.Setup(_ => _.CanResolve(It.IsAny <ArgumentModel>())).Returns(true);
resolver.Setup(_ => _.Resolve(It.IsAny <ArgumentModel>())).Returns(obj);
var factory = new DefaultArgumentResolverFactory();
var dummyArg = new ArgumentModel();
factory.Register(resolver.Object);
var createdResolver_1 = factory.CreateResolver(typeof(object));
var createdResolver_2 = factory.CreateResolver <object>();
Assert.NotNull(createdResolver_1);
Assert.NotNull(createdResolver_2);
Assert.True(createdResolver_1.CanResolve(dummyArg));
Assert.True(createdResolver_2.CanResolve(dummyArg));
Assert.Same(obj, createdResolver_1.Resolve(dummyArg));
Assert.Same(obj, createdResolver_2.Resolve(dummyArg));
}
public void RegisterThrowsException()
{
var mockResolver = new Mock <ArgumentResolver <string> >();
var factory = new DefaultArgumentResolverFactory();
Assert.Throws <ArgumentException>(() => factory.Register <string, StringResolver>());
}
public void RegisterOverrideWorks()
{
var mockResolver = new Mock <ArgumentResolver <string> >();
var factory = new DefaultArgumentResolverFactory();
factory.Register(typeof(string), mockResolver.Object.GetType(), true);
factory.Register <string, StringResolver>(true);
}
public void CreateEnumResolver()
{
var factory = new DefaultArgumentResolverFactory();
var output = factory.CreateResolver <Output>();
var output2 = factory.CreateResolver(typeof(Output));
Assert.NotNull(output);
Assert.NotNull(output2);
Assert.Same(output, output2);
}
public void ContainsWork()
{
var factory = new DefaultArgumentResolverFactory();
Assert.True(factory.Contains <string>());
Assert.True(factory.Contains <int>());
Assert.True(factory.Contains <double>());
Assert.True(factory.Contains <bool>());
Assert.True(factory.Contains <Output>());
Assert.False(factory.Contains <RandomType>());
}
public void RegisterAndGet()
{
var instance = new RandomType();
var mockResolver = new Mock <ArgumentResolver <RandomType> >();
mockResolver.Setup(_ => _.CanResolve(It.IsAny <ArgumentModel>())).Returns(true);
mockResolver.Setup(_ => _.Resolve(It.IsAny <ArgumentModel>())).Returns(instance);
var factory = new DefaultArgumentResolverFactory();
factory.Register(mockResolver.Object);
var resolver = factory.CreateResolver <RandomType>();
var model = new ArgumentModel();
Assert.Same(mockResolver.Object, resolver);
Assert.True(resolver.CanResolve(model));
Assert.Same(instance, resolver.Resolve(model));
mockResolver.VerifyAll();
}
