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); }