public void ShouldFailOnNoMatchingConstructorTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
IReflectionFascade mockReflectionFascade;
Type activatorType;
object result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
ConstructorInfo _unusedConstructorInfo = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
// TODO: reflection to fascade classes
IReflectionFascade stubReflectionFascade;
stubReflectionFascade = new ReflectionFascade(new DataTypeFascade());
mockReflectionFascade = stubReflectionFascade;
activatorType = typeof(MockAmbiguousCtorMatchDependantObject);
//Expect.On(mockReflectionFascade).Exactly(4).Method(x => x.GetOneAttribute<DependencyInjectionAttribute>(_unusedConstructorInfo)).WithAnyArguments().Will(Return.Value<DependencyInjectionAttribute>((DependencyInjectionAttribute)null));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(mockReflectionFascade, activatorType);
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, typeof(object), "boaty_mcboatface_NO_MATCH_right?");
}
protected void Initalize()
{
mocks = new List <Mock <IParentInterface> >();
mocks.Add(Factory.CreateMock <IParentInterface>("parentInterfaceMock"));
mocks.Add(Factory.CreateMock <IChildInterface>("childInterfaceMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <IGenericInterface <System.Version> >("genericInterfaceOfVersionMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <ParentClass>("parentClassMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <ChildClass>(DefinedAs.Named("classMock").WithArgs("Phil")).As <IParentInterface>());
mocks.Add(Factory.CreateMock <GenericClass <System.Version> >("genericClassOfVersionMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <AbstractParentClass>("abstractParentClassMock").As <IParentInterface>());
//mocks.Add(Factory.CreateMock<SealedChildClass>("sealedChildClassMock").As<IParentInterface>());
#if !SILVERLIGHT
mocks.Add(Factory.CreateMock <ExplicitImplementationParentClass>("explicitImplementationParentClassMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <InternalParentClass>("internalParentClassMock").As <IParentInterface>());
#endif
instances = new List <IParentInterface>();
instances.Add(Factory.CreateInstance <IParentInterface>("parentInterfaceInstance"));
instances.Add(Factory.CreateInstance <IChildInterface>("childInterfaceInstance"));
instances.Add(Factory.CreateInstance <IGenericInterface <System.Version> >("genericInterfaceOfVersionInstance"));
instances.Add(Factory.CreateInstance <ParentClass>("parentClassInstance"));
instances.Add(Factory.CreateInstance <ChildClass>(DefinedAs.Named("classInstance").WithArgs("Phil")));
instances.Add(Factory.CreateInstance <GenericClass <System.Version> >("genericClassOfVersionInstance"));
instances.Add(Factory.CreateInstance <AbstractParentClass>("abstractParentClassInstance"));
#if !SILVERLIGHT
instances.Add(Factory.CreateInstance <ExplicitImplementationParentClass>("explicitImplementationParentClassInstance"));
instances.Add(Factory.CreateInstance <InternalParentClass>("internalParentClassInstance"));
#endif
}
public void ShouldCreateAndEvaluateTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
IReflectionFascade mockReflectionFascade;
Type activatorType;
object result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
ConstructorInfo _unusedConstructorInfo = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
// TODO: reflection to fascade classes
IReflectionFascade stubReflectionFascade;
stubReflectionFascade = new ReflectionFascade(new DataTypeFascade());
mockReflectionFascade = stubReflectionFascade;
activatorType = typeof(MockDependantObject);
//Expect.On(mockReflectionFascade).Exactly(4).Method(x => x.GetOneAttribute<DependencyInjectionAttribute>(_unusedConstructorInfo)).WithAnyArguments().Will(Return.Value<DependencyInjectionAttribute>((DependencyInjectionAttribute)null));
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), "named_dep_obj", true).Will(Return.Value(new MockDependantObject("left")));
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), string.Empty, true).Will(Return.Value(new MockDependantObject("right")));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(mockReflectionFascade, activatorType);
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.IsInstanceOf <MockDependantObject>(result);
Assert.IsNotNull(((MockDependantObject)result).Text);
Assert.AreEqual(string.Empty, ((MockDependantObject)result).Text);
Assert.IsNotNull(((MockDependantObject)result).Left);
Assert.IsNotNull(((MockDependantObject)result).Right);
Assert.AreEqual("left", ((MockDependantObject)result).Left.Text);
Assert.AreEqual("right", ((MockDependantObject)result).Right.Text);
transientActivatorAutoWiringDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateAndEvaluateUntypedTest()
{
InstanceDependencyResolution <int> instanceDependencyResolution;
IDependencyManager mockDependencyManager;
int value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
value = 11;
instanceDependencyResolution = new InstanceDependencyResolution <int>(value);
Assert.AreEqual(DependencyLifetime.Instance, instanceDependencyResolution.DependencyLifetime);
result = instanceDependencyResolution.Resolve(mockDependencyManager, typeof(int), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
instanceDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateAndEvaluateTest()
{
TransientFactoryMethodDependencyResolution transientFactoryMethodDependencyResolution;
IDependencyManager mockDependencyManager;
Func<object> value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
value = () => 11;
transientFactoryMethodDependencyResolution = new TransientFactoryMethodDependencyResolution(value);
Assert.AreEqual(DependencyLifetime.Transient, transientFactoryMethodDependencyResolution.DependencyLifetime);
result = transientFactoryMethodDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
transientFactoryMethodDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnNullTypeResolveUntypedTest()
{
TransientActivatorAutoWiringDependencyResolution <MockDependantObject> transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
IReflectionFascade mockReflectionFascade;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution <MockDependantObject>(mockReflectionFascade);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void ShouldFailOnNullKeyResolveUntypedTest()
{
SingletonWrapperDependencyResolution <int> singletonWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution <int> mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution <int> >();
singletonWrapperDependencyResolution = new SingletonWrapperDependencyResolution <int>(mockDependencyResolution);
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(int), null);
}
public void ShouldCreateAndEvaluateTest()
{
InstanceDependencyResolution instanceDependencyResolution;
IDependencyManager mockDependencyManager;
int value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
value = 11;
instanceDependencyResolution = new InstanceDependencyResolution(value);
Assert.AreEqual(DependencyLifetime.Instance, instanceDependencyResolution.DependencyLifetime);
result = instanceDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
instanceDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateAndEvaluateTest()
{
TransientActivatorAutoWiringDependencyResolution <MockDependantObject> transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
MockDependantObject result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), "named_dep_obj", true).Will(Return.Value(new MockDependantObject("left")));
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), string.Empty, true).Will(Return.Value(new MockDependantObject("right")));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution <MockDependantObject>();
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, string.Empty);
Assert.IsNotNull(result);
Assert.IsInstanceOf <MockDependantObject>(result);
Assert.IsNotNull(result.Text);
Assert.AreEqual(string.Empty, result.Text);
Assert.IsNotNull(result.Left);
Assert.IsNotNull(result.Right);
Assert.AreEqual("left", result.Left.Text);
Assert.AreEqual("right", result.Right.Text);
transientActivatorAutoWiringDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateAndEvaluateTest()
{
TransientFactoryMethodDependencyResolution <int> transientFactoryMethodDependencyResolution;
IDependencyManager mockDependencyManager;
Func <int> value;
Func <ValueTask <int> > asyncValue;
int result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
value = () => 11;
asyncValue = async() => await Task.FromResult <int>(7);
transientFactoryMethodDependencyResolution = new TransientFactoryMethodDependencyResolution <int>(value, asyncValue);
Assert.AreEqual(DependencyLifetime.Transient, transientFactoryMethodDependencyResolution.DependencyLifetime);
result = transientFactoryMethodDependencyResolution.Resolve(mockDependencyManager, string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
transientFactoryMethodDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public static void IsValidDependencyMagicMethod(IDependencyManager dependencyManager)
{
if ((object)dependencyManager == null)
{
throw new ArgumentNullException(nameof(dependencyManager));
}
MockFactory mockFactory;
IDependencyResolution mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
Type _unusedType = null;
string _unusedString = null;
Type targetType;
string selectorKey;
bool includeAssignableTypes;
mockFactory = new MockFactory();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
targetType = typeof(IFormattable);
selectorKey = UNCOMMON_SELECTOR_KEY;
includeAssignableTypes = false;
dependencyManager.AddResolution(targetType, selectorKey, includeAssignableTypes, mockDependencyResolution);
Expect.On(mockDependencyResolution).Any.Method(m => m.Resolve(_unusedDependencyManager, _unusedType, _unusedString)).With(dependencyManager, targetType, selectorKey).WillReturn(1234.5678);
Expect.On(mockDependencyResolution).One.Method(m => m.Dispose());
}
public void ShouldFailOnMockUnmarkedParametersMatchTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
Type activatorType;
object result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
ConstructorInfo _unusedConstructorInfo = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
activatorType = typeof(MockAmbiguousCtorMatchDependantObject);
//Expect.On().Exactly(4).Method(x => x.GetOneAttribute<DependencyInjectionAttribute>(_unusedConstructorInfo)).WithAnyArguments().Will(Return.Value<DependencyInjectionAttribute>((DependencyInjectionAttribute)null));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(activatorType);
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, typeof(object), "i_haz_no_marked_params");
}
public void ShouldCreateAndEvaluateUntypedTest()
{
TransientFactoryMethodDependencyResolution <int> transientFactoryMethodDependencyResolution;
IDependencyManager mockDependencyManager;
Func <int> value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
value = () => 11;
transientFactoryMethodDependencyResolution = new TransientFactoryMethodDependencyResolution <int>(value);
Assert.AreEqual(DependencyLifetime.Transient, transientFactoryMethodDependencyResolution.DependencyLifetime);
result = transientFactoryMethodDependencyResolution.Resolve(mockDependencyManager, typeof(int), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
transientFactoryMethodDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnNullKeyResolveUntypedTest()
{
ContextWrapperDependencyResolution <int> contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution <int> mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution <int> >();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution <int>(ContextScope.LocalThreadSafe, mockDependencyResolution);
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(int), null);
}
public void ShouldFailOnNullTypeResolveTest()
{
SingletonWrapperDependencyResolution singletonWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
singletonWrapperDependencyResolution = new SingletonWrapperDependencyResolution(mockDependencyResolution);
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void ShouldMakeNullableTypeTest()
{
ReflectionFascade reflectionFascade;
Type conversionType;
Type nullableType;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
conversionType = typeof(int);
nullableType = reflectionFascade.MakeNullableType(conversionType);
Assert.AreEqual(typeof(int?), nullableType);
conversionType = typeof(int?);
nullableType = reflectionFascade.MakeNullableType(conversionType);
Assert.AreEqual(typeof(int?), nullableType);
conversionType = typeof(IDisposable);
nullableType = reflectionFascade.MakeNullableType(conversionType);
Assert.AreEqual(typeof(IDisposable), nullableType);
}
public void ShouldFailOnNullTypeResolveTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(ContextScope.LocalThreadSafe, mockDependencyResolution);
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void ShouldClearTypeResolutionsTest()
{
DependencyManager dependencyManager;
MockFactory mockFactory;
IDependencyResolution mockDependencyResolution;
Type targetType;
string selectorKey;
bool includeAssignableTypes;
bool result;
mockFactory = new MockFactory();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
Expect.On(mockDependencyResolution).One.Method(m => m.Dispose());
dependencyManager = new DependencyManager();
targetType = typeof(object);
selectorKey = COMMON_SELECTOR_KEY;
includeAssignableTypes = false;
result = dependencyManager.ClearTypeResolutions(targetType, includeAssignableTypes);
Assert.IsFalse(result);
dependencyManager.AddResolution(targetType, selectorKey, includeAssignableTypes, mockDependencyResolution);
result = dependencyManager.ClearTypeResolutions(targetType, includeAssignableTypes);
Assert.IsTrue(result);
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnNotAssignableResolveDependencyTest()
{
DependencyManager dependencyManager;
MockFactory mockFactory;
IDependencyResolution mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
Type _unusedType = null;
string _unusedString = null;
Type targetType;
string selectorKey;
object value;
bool includeAssignableTypes;
dependencyManager = new DependencyManager();
mockFactory = new MockFactory();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
targetType = typeof(IDisposable);
selectorKey = COMMON_SELECTOR_KEY;
includeAssignableTypes = false;
Expect.On(mockDependencyResolution).One.Method(x => x.Resolve(_unusedDependencyManager, _unusedType, _unusedString)).With(dependencyManager, targetType, selectorKey).Will(Return.Value(1));
dependencyManager.AddResolution(targetType, selectorKey, includeAssignableTypes, mockDependencyResolution);
value = dependencyManager.ResolveDependency <IDisposable>(selectorKey, includeAssignableTypes);
}
public void ShouldResolveDependencyTest()
{
DependencyManager dependencyManager;
MockFactory mockFactory;
IDependencyResolution mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
Type _unusedType = null;
string _unusedString = null;
Type targetType;
string selectorKey;
bool includeAssignableTypes;
object value;
dependencyManager = new DependencyManager();
mockFactory = new MockFactory();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
targetType = typeof(object);
selectorKey = COMMON_SELECTOR_KEY;
includeAssignableTypes = false;
Expect.On(mockDependencyResolution).One.Method(x => x.Resolve(_unusedDependencyManager, _unusedType, _unusedString)).With(dependencyManager, targetType, selectorKey).Will(Return.Value(1));
dependencyManager.AddResolution(targetType, selectorKey, includeAssignableTypes, mockDependencyResolution);
value = dependencyManager.ResolveDependency(targetType, selectorKey, includeAssignableTypes);
Assert.IsNotNull(value);
Assert.AreEqual(1, value);
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateAndEvaluateTest()
{
TransientActivatorAutoWiringDependencyResolution<MockDependantObject> transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
MockDependantObject result;
MockFactory mockFactory;
string _unusedString = null;
bool _unusedBoolean = false;
Type _unusedType = null;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), "named_dep_obj", true).Will(Return.Value(new MockDependantObject("left")));
Expect.On(mockDependencyManager).One.Method(m => m.ResolveDependency(_unusedType, _unusedString, _unusedBoolean)).With(typeof(MockDependantObject), string.Empty, true).Will(Return.Value(new MockDependantObject("right")));
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution<MockDependantObject>();
Assert.AreEqual(DependencyLifetime.Transient, transientActivatorAutoWiringDependencyResolution.DependencyLifetime);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, string.Empty);
Assert.IsNotNull(result);
Assert.IsInstanceOf<MockDependantObject>(result);
Assert.IsNotNull(result.Text);
Assert.AreEqual(string.Empty, result.Text);
Assert.IsNotNull(result.Left);
Assert.IsNotNull(result.Right);
Assert.AreEqual("left", result.Left.Text);
Assert.AreEqual("right", result.Right.Text);
transientActivatorAutoWiringDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldGetErrors()
{
ReflectionFascade reflectionFascade;
MockException mockException;
string message;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
try
{
try
{
throw new InvalidOperationException("ioe.collected.outer", new DivideByZeroException("dbze.collected.inner"));
}
catch (Exception ex)
{
mockException = new MockException("me.outer", new BadImageFormatException("bie.inner"));
mockException.CollectedExceptions.Add(ex);
throw mockException;
}
}
catch (Exception ex)
{
message = reflectionFascade.GetErrors(ex, 0);
Console.WriteLine(message);
}
}
public void ShouldGetAttributeTest()
{
ReflectionFascade reflectionFascade;
MockSingleTestAttibute sta;
Type targetType;
MethodInfo methodInfo;
ParameterInfo parameterInfo;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
targetType = typeof(MockTestAttributedClass);
var _targetType = targetType.GetTypeInfo();
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
sta = reflectionFascade.GetOneAttribute <MockSingleTestAttibute>(_targetType.Module);
Assert.IsNotNull(sta);
Assert.AreEqual(int.MinValue, sta.Value);
sta = reflectionFascade.GetOneAttribute <MockSingleTestAttibute>(_targetType.Assembly);
Assert.IsNotNull(sta);
Assert.AreEqual(int.MaxValue, sta.Value);
sta = reflectionFascade.GetOneAttribute <MockSingleTestAttibute>(targetType);
Assert.IsNotNull(sta);
Assert.AreEqual(1, sta.Value);
methodInfo = targetType.GetMethod(nameof(MockTestAttributedClass.MyMethod));
Assert.IsNotNull(methodInfo);
sta = reflectionFascade.GetOneAttribute <MockSingleTestAttibute>(methodInfo);
Assert.IsNotNull(sta);
Assert.AreEqual(2, sta.Value);
parameterInfo = methodInfo.GetParameters().Single(p => p.Name == "obj");
Assert.IsNotNull(parameterInfo);
sta = reflectionFascade.GetOneAttribute <MockSingleTestAttibute>(parameterInfo);
Assert.IsNotNull(sta);
Assert.AreEqual(4, sta.Value);
parameterInfo = methodInfo.ReturnParameter;
Assert.IsNotNull(parameterInfo);
sta = reflectionFascade.GetOneAttribute <MockSingleTestAttibute>(parameterInfo);
Assert.IsNotNull(sta);
Assert.AreEqual(8, sta.Value);
}
public void ShouldFailOnNullKeyResolveTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
IReflectionFascade mockReflectionFascade;
object result;
MockFactory mockFactory;
Type activatorType;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
activatorType = typeof(int);
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(mockReflectionFascade, activatorType);
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, typeof(object), null);
}
public void ShouldFailOnNullContextualStorageStrategyCreateTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IContextualStorageStrategy mockContextualStorageStrategy;
IDependencyResolution mockDependencyResolution;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockContextualStorageStrategy = null;
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(mockContextualStorageStrategy, mockDependencyResolution);
}
public void ShouldFailOnNullAssemblyCreateTest()
{
AssemblyInformationFascade assemblyInformationFascade;
MockFactory mockFactory;
IReflectionFascade mockReflectionFascade;
Assembly mockAssembly;
mockFactory = new MockFactory();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
mockAssembly = null;
assemblyInformationFascade = new AssemblyInformationFascade(mockReflectionFascade, mockAssembly);
}
public void ShouldCreateAndEvaluateTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
Type _unusedType = null;
string _unusedString = null;
object result;
const int EXPECTED = 11;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance<IDependencyResolution>();
Expect.On(mockDependencyResolution).One.Method(m => m.Resolve(_unusedDependencyManager, _unusedType, _unusedString)).With(mockDependencyManager, typeof(object), string.Empty).WillReturn(EXPECTED);
Expect.On(mockDependencyResolution).One.Method(m => m.Dispose());
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(ContextScope.LocalThreadSafe, mockDependencyResolution);
Assert.AreEqual(DependencyLifetime.Singleton, contextWrapperDependencyResolution.DependencyLifetime);
// should be thawed at this point
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(EXPECTED, result);
// should be frozen at this point
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(EXPECTED, result);
contextWrapperDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnDataTypeFascadeCreateTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = null;
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
}
public void ShouldCreateAndEvaluateTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
Type _unusedType = null;
string _unusedString = null;
object result;
const int EXPECTED = 11;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance <IDependencyResolution>();
Expect.On(mockDependencyResolution).One.Method(m => m.Resolve(_unusedDependencyManager, _unusedType, _unusedString)).With(mockDependencyManager, typeof(object), string.Empty).WillReturn(EXPECTED);
Expect.On(mockDependencyResolution).One.Method(m => m.Dispose());
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(ContextScope.LocalThreadSafe, mockDependencyResolution);
Assert.AreEqual(DependencyLifetime.Singleton, contextWrapperDependencyResolution.DependencyLifetime);
// should be thawed at this point
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(EXPECTED, result);
// should be frozen at this point
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(EXPECTED, result);
contextWrapperDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnNullTargetGetZeroAttributesTest()
{
ReflectionFascade reflectionFascade;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
reflectionFascade.GetZeroAttributes <MockMultipleTestAttibute>(null);
}
public void ShouldFailOnNullConversionTypeMakeNullableTypeTest()
{
ReflectionFascade reflectionFascade;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
reflectionFascade.MakeNullableType(null);
}
public void ShouldFailOnNullActualTypeCreateTest()
{
TransientActivatorAutoWiringDependencyResolution transientActivatorAutoWiringDependencyResolution;
Type activatorType;
IReflectionFascade mockReflectionFascade;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
activatorType = null;
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution(mockReflectionFascade, activatorType);
}
public void ShouldFailOnMultiDefinedGetAttributeTest()
{
ReflectionFascade reflectionFascade;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
reflectionFascade.GetOneAttribute <MockMultipleTestAttibute>(typeof(MockTestAttributedClass));
}
public void ShouldFailOnNullKeyResolveTest()
{
TransientDefaultConstructorDependencyResolution transientDefaultConstructorDependencyResolution;
IDependencyManager mockDependencyManager;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance <IDependencyManager>();
transientDefaultConstructorDependencyResolution = new TransientDefaultConstructorDependencyResolution(typeof(int));
result = transientDefaultConstructorDependencyResolution.Resolve(mockDependencyManager, typeof(object), null);
}
public void ShouldGetNoAttributesTest()
{
ReflectionFascade reflectionFascade;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance <IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
reflectionFascade.GetZeroAttributes <AssemblyDescriptionAttribute>(typeof(MockTestAttributedClass));
}
public void ShouldCreateAndEvaluateUntypedTest()
{
SingletonWrapperDependencyResolution<int> singletonWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution<int> mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
string _unusedString = null;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
mockDependencyResolution = mockFactory.CreateInstance<IDependencyResolution<int>>();
Expect.On(mockDependencyResolution).One.Method(m => m.Resolve(_unusedDependencyManager, _unusedString)).With(mockDependencyManager, string.Empty).WillReturn(11);
Expect.On(mockDependencyResolution).One.Method(m => m.Dispose());
singletonWrapperDependencyResolution = new SingletonWrapperDependencyResolution<int>(mockDependencyResolution);
Assert.AreEqual(DependencyLifetime.Singleton, singletonWrapperDependencyResolution.DependencyLifetime);
// should be thawed at this point
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(int), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
// should be frozen at this point
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(int), string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(11, result);
singletonWrapperDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldExecuteReaderCloseConnectionSprocWithParametersTest()
{
IAdoNetYieldingFascade adoNetYieldingFascade;
MockFactory mockFactory;
DbConnection mockDbConnection;
DbCommand mockDbCommand;
DbParameterCollection mockDbParameterCollection;
DbParameter[] mockDbParameters;
DbParameter mockDbParameter0;
DbParameter mockDbParameter1;
DbDataReader mockDbDataReader;
IReflectionFascade mockReflectionFascade;
DbDataReader dbDataReader;
CommandBehavior _unusedCommandBehavior = CommandBehavior.Default;
DbParameter _unusedDbParameter = null;
mockFactory = new MockFactory();
mockDbConnection = mockFactory.CreateInstance<DbConnection>();
mockDbCommand = mockFactory.CreateInstance<DbCommand>();
mockDbParameterCollection = mockFactory.CreateInstance<DbParameterCollection>();
mockDbParameter0 = mockFactory.CreateInstance<DbParameter>();
mockDbParameter1 = mockFactory.CreateInstance<DbParameter>();
mockDbParameters = new DbParameter[] { mockDbParameter0, mockDbParameter1 };
mockDbDataReader = mockFactory.CreateInstance<DbDataReader>();
mockReflectionFascade = mockFactory.CreateInstance<IReflectionFascade>();
Expect.On(mockDbConnection).One.Method(x => x.CreateCommand()).Will(Return.Value(mockDbCommand));
Expect.On(mockDbCommand).Exactly(2).GetProperty(x => x.Parameters).Will(Return.Value(mockDbParameterCollection));
Expect.On(mockDbCommand).One.Method(x => x.Dispose());
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandType).To(CommandType.StoredProcedure);
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandText).To("blah blah blah");
Expect.On(mockDbCommand).One.SetProperty(x => x.Transaction).To(null);
Expect.On(mockDbCommand).One.Method(x => x.ExecuteReader(_unusedCommandBehavior)).With(CommandBehavior.CloseConnection).Will(Return.Value(mockDbDataReader));
Expect.On(mockDbParameter0).One.GetProperty(x => x.Value).Will(Return.Value(1));
Expect.On(mockDbParameter1).One.GetProperty(x => x.Value).Will(Return.Value(null));
Expect.On(mockDbParameter1).One.SetProperty(x => x.Value).To(DBNull.Value);
Expect.On(mockDbParameterCollection).One.Method(x => x.Add(_unusedDbParameter)).With(mockDbParameter0).Will(Return.Value(0));
Expect.On(mockDbParameterCollection).One.Method(x => x.Add(_unusedDbParameter)).With(mockDbParameter1).Will(Return.Value(0));
Expect.On(mockDbDataReader).One.Method(x => x.Dispose());
adoNetYieldingFascade = new AdoNetYieldingFascade(mockReflectionFascade);
dbDataReader = adoNetYieldingFascade.ExecuteReader(mockDbConnection, null, CommandType.StoredProcedure, "blah blah blah", mockDbParameters, CommandBehavior.CloseConnection, null, false);
Assert.IsNotNull(dbDataReader);
dbDataReader.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnNullDependencyManagerResolveTest()
{
SingletonWrapperDependencyResolution singletonWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = null;
mockDependencyResolution = mockFactory.CreateInstance<IDependencyResolution>();
singletonWrapperDependencyResolution = new SingletonWrapperDependencyResolution(mockDependencyResolution);
result = singletonWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
}
public static void IsValidAssemblyLoaderEventSinkMethod(AssemblyLoaderEventType assemblyLoaderEventType, AssemblyLoaderContainerContext assemblyLoaderContainerContext)
{
if ((object)assemblyLoaderContainerContext == null)
throw new ArgumentNullException(nameof(assemblyLoaderContainerContext));
switch (assemblyLoaderEventType)
{
case AssemblyLoaderEventType.Startup:
MockFactory mockFactory;
IDependencyResolution mockDependencyResolution;
IDependencyManager _unusedDependencyManager = null;
Type _unusedType = null;
string _unusedString = null;
Type targetType;
string selectorKey;
bool includeAssignableTypes;
mockFactory = new MockFactory();
mockDependencyResolution = mockFactory.CreateInstance<IDependencyResolution>();
targetType = typeof(IFormattable);
selectorKey = UNCOMMON_SELECTOR_KEY;
includeAssignableTypes = false;
assemblyLoaderContainerContext.DependencyManager.AddResolution(targetType, selectorKey, includeAssignableTypes, mockDependencyResolution);
Expect.On(mockDependencyResolution).Any.Method(m => m.Resolve(_unusedDependencyManager, _unusedType, _unusedString)).With(assemblyLoaderContainerContext.DependencyManager, targetType, selectorKey).WillReturn(1234.5678);
Expect.On(mockDependencyResolution).One.Method(m => m.Dispose());
break;
case AssemblyLoaderEventType.Shutdown:
break;
default:
throw new ArgumentOutOfRangeException(nameof(assemblyLoaderEventType), assemblyLoaderEventType, null);
}
}
public void ShouldCreateAndEvaluateTest()
{
TransientDefaultConstructorDependencyResolution<MockDependantObject> transientDefaultConstructorDependencyResolution;
IDependencyManager mockDependencyManager;
MockDependantObject result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
transientDefaultConstructorDependencyResolution = new TransientDefaultConstructorDependencyResolution<MockDependantObject>();
Assert.AreEqual(DependencyLifetime.Transient, transientDefaultConstructorDependencyResolution.DependencyLifetime);
result = transientDefaultConstructorDependencyResolution.Resolve(mockDependencyManager, string.Empty);
Assert.IsNotNull(result);
Assert.IsNull(result.Text);
transientDefaultConstructorDependencyResolution.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldCreateTest()
{
Tokenizer tokenizer;
MockFactory mockFactory;
IDictionary<string, ITokenReplacementStrategy> mockTokenReplacementStrategies;
mockFactory = new MockFactory();
mockTokenReplacementStrategies = mockFactory.CreateInstance<IDictionary<string, ITokenReplacementStrategy>>();
tokenizer = new Tokenizer(true);
Assert.IsNotNull(tokenizer);
Assert.IsNotNull(tokenizer.TokenReplacementStrategies);
Assert.IsTrue(tokenizer.StrictMatching);
tokenizer = new Tokenizer(mockTokenReplacementStrategies, true);
Assert.IsNotNull(tokenizer);
Assert.IsNotNull(tokenizer.TokenReplacementStrategies);
Assert.IsTrue(tokenizer.StrictMatching);
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldFailOnInvalidValueGetTypedBooleanTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "BadAppConfigFascadeValueBoolean";
string __unusedString = null;
Boolean __unusedBoolean;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
Expect.On(mockConfigurationRoot).One.GetProperty(p => p[KEY]).WillReturn(UNATTAINABLE_VALUE);
Expect.On(mockDataTypeFascade).One.Method(m => m.TryParse<Boolean>(__unusedString, out __unusedBoolean)).With(UNATTAINABLE_VALUE, new AndMatcher(new ArgumentsMatcher.OutMatcher(), new AlwaysMatcher(true, string.Empty))).WillReturn(false);
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
appConfigFascade.GetAppSetting<Boolean>(KEY);
}
public void ShouldFailOnNullContextualStorageStrategyCreateTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IContextualStorageStrategy mockContextualStorageStrategy;
IDependencyResolution mockDependencyResolution;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockContextualStorageStrategy = null;
mockDependencyResolution = mockFactory.CreateInstance<IDependencyResolution>();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(mockContextualStorageStrategy, mockDependencyResolution);
}
public void ShouldHaveTrueHasAppSettingTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "AppConfigFascadeValueBoolean";
bool expected, value;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
expected = true;
Expect.On(mockConfigurationRoot).One.GetProperty(p => p[KEY]).WillReturn(UNATTAINABLE_VALUE);
value = appConfigFascade.HasAppSetting(KEY);
Assert.AreEqual(expected, value);
}
public void ShouldGetUntypedUInt64Test()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "AppConfigFascadeValueUInt64";
UInt64 expected;
object value;
Type __unusedType = null;
string __unusedString = null;
object __unusedUInt64;
Type valueType = typeof(UInt64);
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
expected = 0L;
Expect.On(mockConfigurationRoot).One.GetProperty(p => p[KEY]).WillReturn(UNATTAINABLE_VALUE);
Expect.On(mockDataTypeFascade).One.Method(m => m.TryParse(__unusedType, __unusedString, out __unusedUInt64)).With(valueType, UNATTAINABLE_VALUE, new AndMatcher(new ArgumentsMatcher.OutMatcher(), new AlwaysMatcher(true, string.Empty))).Will(new SetNamedParameterAction("result", expected), Return.Value(true));
value = appConfigFascade.GetAppSetting(valueType, KEY);
Assert.AreEqual(expected, value);
}
public void ShouldMakeNullableTypeTest()
{
ReflectionFascade reflectionFascade;
Type conversionType;
Type nullableType;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
conversionType = typeof(int);
nullableType = reflectionFascade.MakeNullableType(conversionType);
Assert.AreEqual(typeof(int?), nullableType);
conversionType = typeof(int?);
nullableType = reflectionFascade.MakeNullableType(conversionType);
Assert.AreEqual(typeof(int?), nullableType);
conversionType = typeof(IDisposable);
nullableType = reflectionFascade.MakeNullableType(conversionType);
Assert.AreEqual(typeof(IDisposable), nullableType);
}
public void ShouldFailOnNullDependencyManagerResolveTest()
{
ContextWrapperDependencyResolution contextWrapperDependencyResolution;
IDependencyManager mockDependencyManager;
IDependencyResolution mockDependencyResolution;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = null;
mockDependencyResolution = mockFactory.CreateInstance<IDependencyResolution>();
contextWrapperDependencyResolution = new ContextWrapperDependencyResolution(ContextScope.LocalThreadSafe, mockDependencyResolution);
result = contextWrapperDependencyResolution.Resolve(mockDependencyManager, typeof(object), string.Empty);
}
public void ShouldFailOnNullKeyResolveUntypedTest()
{
InstanceDependencyResolution<int> instanceDependencyResolution;
IDependencyManager mockDependencyManager;
int value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
value = 11;
instanceDependencyResolution = new InstanceDependencyResolution<int>(value);
result = instanceDependencyResolution.Resolve(mockDependencyManager, typeof(int), null);
}
public void ShouldFailOnNullTypeResolveUntypedTest()
{
TransientActivatorAutoWiringDependencyResolution<MockDependantObject> transientActivatorAutoWiringDependencyResolution;
IDependencyManager mockDependencyManager;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
transientActivatorAutoWiringDependencyResolution = new TransientActivatorAutoWiringDependencyResolution<MockDependantObject>();
result = transientActivatorAutoWiringDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void ShouldInferDbTypeForClrTypeTest()
{
IAdoNetYieldingFascade adoNetYieldingFascade;
MockFactory mockFactory;
IReflectionFascade mockReflectionFascade;
DbType dbType;
mockFactory = new MockFactory();
mockReflectionFascade = mockFactory.CreateInstance<IReflectionFascade>();
adoNetYieldingFascade = new AdoNetYieldingFascade(mockReflectionFascade);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Boolean));
Assert.AreEqual(DbType.Boolean, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Byte));
Assert.AreEqual(DbType.Byte, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(DateTime));
Assert.AreEqual(DbType.DateTime, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(DateTimeOffset));
Assert.AreEqual(DbType.DateTimeOffset, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Decimal));
Assert.AreEqual(DbType.Decimal, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Double));
Assert.AreEqual(DbType.Double, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Guid));
Assert.AreEqual(DbType.Guid, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Int16));
Assert.AreEqual(DbType.Int16, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Int32));
Assert.AreEqual(DbType.Int32, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Int64));
Assert.AreEqual(DbType.Int64, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(SByte));
Assert.AreEqual(DbType.SByte, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Single));
Assert.AreEqual(DbType.Single, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(UInt16));
Assert.AreEqual(DbType.UInt16, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(UInt32));
Assert.AreEqual(DbType.UInt32, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(UInt64));
Assert.AreEqual(DbType.UInt64, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Byte[]));
Assert.AreEqual(DbType.Binary, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Object));
Assert.AreEqual(DbType.Object, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(UInt64));
Assert.AreEqual(DbType.UInt64, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(DbType));
Assert.AreEqual(DbType.Int32, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(Int32?));
Assert.AreEqual(DbType.Int32, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(String));
Assert.AreEqual(DbType.String, dbType);
dbType = adoNetYieldingFascade.InferDbTypeForClrType(typeof(String).MakeByRefType());
Assert.AreEqual(DbType.String, dbType);
}
public void ShouldFailOnNullTypeInferDbTypeForClrTypeTest()
{
IAdoNetYieldingFascade adoNetYieldingFascade;
MockFactory mockFactory;
IReflectionFascade mockReflectionFascade;
mockFactory = new MockFactory();
mockReflectionFascade = mockFactory.CreateInstance<IReflectionFascade>();
adoNetYieldingFascade = new AdoNetYieldingFascade(mockReflectionFascade);
adoNetYieldingFascade.InferDbTypeForClrType(null);
}
public void ShouldFailOnNullConnectionStaticExecuteReaderTest()
{
IAdoNetYieldingFascade adoNetYieldingFascade;
MockFactory mockFactory;
IReflectionFascade mockReflectionFascade;
mockFactory = new MockFactory();
mockReflectionFascade = mockFactory.CreateInstance<IReflectionFascade>();
adoNetYieldingFascade = new AdoNetYieldingFascade(mockReflectionFascade);
adoNetYieldingFascade.ExecuteReader(null, null, CommandType.StoredProcedure, null, null, CommandBehavior.CloseConnection, null, false);
}
public void ShouldFailOnInvalidValueGetUntypedUInt64Test()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "BadAppConfigFascadeValueUInt64";
Type __unusedType = null;
string __unusedString = null;
object __unusedUInt64;
Type valueType = typeof(UInt64);
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
Expect.On(mockConfigurationRoot).One.GetProperty(p => p[KEY]).WillReturn(UNATTAINABLE_VALUE);
Expect.On(mockDataTypeFascade).One.Method(m => m.TryParse(__unusedType, __unusedString, out __unusedUInt64)).With(valueType, UNATTAINABLE_VALUE, new AndMatcher(new ArgumentsMatcher.OutMatcher(), new AlwaysMatcher(true, string.Empty))).WillReturn(false);
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
appConfigFascade.GetAppSetting(valueType, KEY);
}
public void ShouldFailOnNullKeyHasAppSettingTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = null;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
appConfigFascade.HasAppSetting(KEY);
}
public void ShouldFailOnNonExistKeyGetTypedCharTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "NotThereAppConfigFascadeValueChar";
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
Expect.On(mockConfigurationRoot).One.GetProperty(p => p[KEY]).WillReturn(null);
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
appConfigFascade.GetAppSetting<Char>(KEY);
}
public void ShouldFailOnNullTypeGetUntypedAppSettingTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "";
Type valueType = null;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
appConfigFascade.GetAppSetting(valueType, KEY);
}
public void ShouldFailOnNullTypeResolveTest()
{
InstanceDependencyResolution instanceDependencyResolution;
IDependencyManager mockDependencyManager;
int value;
object result;
MockFactory mockFactory;
mockFactory = new MockFactory();
mockDependencyManager = mockFactory.CreateInstance<IDependencyManager>();
value = 11;
instanceDependencyResolution = new InstanceDependencyResolution(value);
result = instanceDependencyResolution.Resolve(mockDependencyManager, null, string.Empty);
}
public void ShouldGetTypedEnumTest()
{
AppConfigFascade appConfigFascade;
IConfigurationRoot mockConfigurationRoot;
IDataTypeFascade mockDataTypeFascade;
MockFactory mockFactory;
const string KEY = "AppConfigFascadeValueEnum";
CharSet expected, value;
Type __unusedType = null;
string __unusedString = null;
CharSet __unusedCharSet;
mockFactory = new MockFactory();
mockConfigurationRoot = mockFactory.CreateInstance<IConfigurationRoot>();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
appConfigFascade = new AppConfigFascade(mockConfigurationRoot, mockDataTypeFascade);
expected = CharSet.Unicode;
Expect.On(mockConfigurationRoot).One.GetProperty(p => p[KEY]).WillReturn(UNATTAINABLE_VALUE);
Expect.On(mockDataTypeFascade).One.Method(m => m.TryParse<CharSet>(__unusedString, out __unusedCharSet)).With(UNATTAINABLE_VALUE, new AndMatcher(new ArgumentsMatcher.OutMatcher(), new AlwaysMatcher(true, string.Empty))).Will(new SetNamedParameterAction("result", expected), Return.Value(true));
value = appConfigFascade.GetAppSetting<CharSet>(KEY);
Assert.AreEqual(expected, value);
}
public void ShouldExecuteReaderCloseConnectionTextNoParametersTest()
{
IAdoNetYieldingFascade adoNetYieldingFascade;
MockFactory mockFactory;
DbConnection mockDbConnection;
DbCommand mockDbCommand;
DbDataReader mockDbDataReader;
IReflectionFascade mockReflectionFascade;
DbDataReader dbDataReader;
CommandBehavior _unusedCommandBehavior = CommandBehavior.Default;
mockFactory = new MockFactory();
mockDbConnection = mockFactory.CreateInstance<DbConnection>();
mockDbCommand = mockFactory.CreateInstance<DbCommand>();
mockDbDataReader = mockFactory.CreateInstance<DbDataReader>();
mockReflectionFascade = mockFactory.CreateInstance<IReflectionFascade>();
Expect.On(mockDbConnection).One.Method(x => x.CreateCommand()).Will(Return.Value(mockDbCommand));
Expect.On(mockDbCommand).One.Method(x => x.Dispose());
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandType).To(CommandType.Text);
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandText).To("blah blah blah");
Expect.On(mockDbCommand).One.SetProperty(x => x.Transaction).To(null);
Expect.On(mockDbCommand).One.Method(x => x.ExecuteReader(_unusedCommandBehavior)).With(CommandBehavior.CloseConnection).Will(Return.Value(mockDbDataReader));
Expect.On(mockDbDataReader).One.Method(x => x.Dispose());
Expect.On(mockDbCommand).One.SetProperty(x => x.CommandTimeout).To(15);
Expect.On(mockDbCommand).One.Method(x => x.Prepare());
adoNetYieldingFascade = new AdoNetYieldingFascade(mockReflectionFascade);
dbDataReader = adoNetYieldingFascade.ExecuteReader(mockDbConnection, null, CommandType.Text, "blah blah blah", null, CommandBehavior.CloseConnection, 15, true);
Assert.IsNotNull(dbDataReader);
dbDataReader.Dispose();
mockFactory.VerifyAllExpectationsHaveBeenMet();
}
public void ShouldReflectionOnlySetLogicalPropertyValueTest()
{
ReflectionFascade reflectionFascade;
MockObject mockObject;
string propertyName;
object propertyValue;
bool result;
MockFactory mockFactory;
IDataTypeFascade mockDataTypeFascade;
string _unusedString = null;
object _unusedObject = null;
Type _unusedType = null;
mockFactory = new MockFactory();
mockDataTypeFascade = mockFactory.CreateInstance<IDataTypeFascade>();
Expect.On(mockDataTypeFascade).One.Method(m => m.IsNullOrWhiteSpace(_unusedString)).With((object)null).Will(Return.Value(true));
Expect.On(mockDataTypeFascade).One.Method(m => m.IsNullOrWhiteSpace(_unusedString)).With(string.Empty).Will(Return.Value(true));
Expect.On(mockDataTypeFascade).One.Method(m => m.IsNullOrWhiteSpace(_unusedString)).With("FirstName").Will(Return.Value(false));
Expect.On(mockDataTypeFascade).Exactly(2).Method(m => m.ChangeType(_unusedObject, _unusedType)).WithAnyArguments().Will(Return.Value(null));
Expect.On(mockDataTypeFascade).One.Method(m => m.IsNullOrWhiteSpace(_unusedString)).With("NoGetter").Will(Return.Value(false));
Expect.On(mockDataTypeFascade).One.Method(m => m.IsNullOrWhiteSpace(_unusedString)).With("NoSetter").Will(Return.Value(false));
reflectionFascade = new ReflectionFascade(mockDataTypeFascade);
propertyValue = null;
// null, null
mockObject = null;
propertyName = null;
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsFalse(result);
Assert.IsNull(propertyValue);
// null, ""
mockObject = null;
propertyName = string.Empty;
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsFalse(result);
Assert.IsNull(propertyValue);
// null, "PropName"
mockObject = null;
propertyName = "FirstName";
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsFalse(result);
Assert.IsNull(propertyValue);
// !null, null
mockObject = new MockObject();
propertyName = null;
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsFalse(result);
Assert.IsNull(propertyValue);
// !null, ""
mockObject = new MockObject();
propertyName = string.Empty;
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsFalse(result);
Assert.IsNull(propertyValue);
// !null, "PropName"
mockObject = new MockObject();
propertyName = "FirstName";
propertyValue = "john";
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsTrue(result);
Assert.IsNotNull(propertyValue);
Assert.AreEqual("john", propertyValue);
// !null, "PropName:PropName!!!getter"
mockObject = new MockObject();
propertyName = "NoGetter";
propertyValue = "john";
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsTrue(result);
Assert.IsNotNull(propertyValue);
Assert.AreEqual("john", propertyValue);
// !null, "PropName:PropName!!!setter"
mockObject = new MockObject();
mockObject.FirstName = "john";
propertyName = "NoSetter";
result = reflectionFascade.SetLogicalPropertyValue(mockObject, propertyName, propertyValue);
Assert.IsFalse(result);
}
