public void NestedPropertyValidator_MayBeConditional() { var mockModule = new Mock <IModule>(MockBehavior.Loose); IRequestContext context = null; var mockInjector = new Mock <IInjector>(MockBehavior.Strict); mockInjector .Setup(i => i.TryGet(typeof(IRequestContext), null)) .Returns <Type, string>((iface, name) => context); Type proxyType = ProxyGenerator <IModule, ParameterValidator <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object, false); Assert.Throws <ValidationException>(() => module.DoSomething(new MyParameter2 { Value3 = new object(), Value2 = new MyParameter1 { Value1 = null } })); context = new Mock <IRequestContext>(MockBehavior.Strict).Object; Assert.DoesNotThrow(() => module.DoSomething(new MyParameter2 { Value3 = new object(), Value2 = new MyParameter1 { Value1 = null } })); }
public async Task TransactionManager_ShouldCallCommitOnSuccessfulAsyncInvocation() { var mockTransaction = new Mock <IDbTransaction>(MockBehavior.Strict); mockTransaction.Setup(tr => tr.Commit()); mockTransaction.Setup(tr => tr.Dispose()); var mockDbConnection = new Mock <IDbConnection>(MockBehavior.Strict); mockDbConnection .Setup(conn => conn.BeginTransaction(IsolationLevel.Unspecified)) .Returns(mockTransaction.Object); var mockModule = new Mock <IModule>(MockBehavior.Strict); mockModule .Setup(m => m.DoSomethingAsync()) .Returns(Task.FromResult(1)); Type proxyType = ProxyGenerator <IModule, TransactionManager <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, new Lazy <IDbConnection>(() => mockDbConnection.Object)) !; int result = await module.DoSomethingAsync(); Assert.That(result, Is.EqualTo(1)); mockDbConnection.Verify(conn => conn.BeginTransaction(IsolationLevel.Unspecified), Times.Once); mockTransaction.Verify(tr => tr.Commit(), Times.Once); }
public void PropertyValidator_MayBeConditional() { var mockModule = new Mock <IModule>(MockBehavior.Loose); var role = MyEnum.Anonymous; var mockRoleManager = new Mock <IRoleManager>(MockBehavior.Strict); mockRoleManager .Setup(rm => rm.GetAssignedRoles(null)) .Returns <string>(sessionId => role); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); mockInjector .Setup(i => i.Get(typeof(IRoleManager), null)) .Returns(mockRoleManager.Object); Type proxyType = ProxyGenerator <IModule, ParameterValidator <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object, false); Assert.DoesNotThrow(() => module.ConditionallyValidated(new MyParameter2())); role = MyEnum.LoggedInUser; Assert.Throws <ValidationException>(() => module.ConditionallyValidated(new MyParameter2())); }
public void AggregatedPropertyValidationTest() { var mockModule = new Mock <IModule>(MockBehavior.Loose); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); mockInjector .Setup(i => i.TryGet(typeof(IRequestContext), null)) .Returns <Type, string>((iface, name) => null); Type proxyType = ProxyGenerator <IModule, ParameterValidator <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object, true) !; Assert.DoesNotThrow(() => module.DoSomethingElse(new MyParameter2 { Value2 = new MyParameter1 { Value1 = new object() }, Value3 = new object() })); AggregateException ex = Assert.Throws <AggregateException>(() => module.DoSomethingElse(new MyParameter2())); Assert.That(ex.InnerExceptions.Count, Is.EqualTo(2)); Assert.That(ex.InnerExceptions[0], Is.InstanceOf <ValidationException>()); Assert.That(((ValidationException)ex.InnerExceptions[0]).TargetName, Is.EqualTo(nameof(MyParameter2.Value2))); Assert.That(ex.InnerExceptions[1], Is.InstanceOf <ValidationException>()); Assert.That(((ValidationException)ex.InnerExceptions[1]).TargetName, Is.EqualTo(nameof(MyParameter2.Value3))); }
public void TransactionManager_ShouldNotCallCommitOnFaultyInvocation() { var mockTransaction = new Mock <IDbTransaction>(MockBehavior.Strict); mockTransaction.Setup(tr => tr.Dispose()); mockTransaction.Setup(tr => tr.Rollback()); var mockDbConnection = new Mock <IDbConnection>(MockBehavior.Strict); mockDbConnection .Setup(conn => conn.BeginTransaction(IsolationLevel.Unspecified)) .Returns(mockTransaction.Object); var mockModule = new Mock <IModule>(MockBehavior.Strict); mockModule .Setup(m => m.DoSomethingFaulty()) .Callback(() => throw new Exception()); Type proxyType = ProxyGenerator <IModule, TransactionManager <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, new Lazy <IDbConnection>(() => mockDbConnection.Object)) !; Assert.Throws <Exception>(module.DoSomethingFaulty); mockDbConnection.Verify(conn => conn.BeginTransaction(IsolationLevel.Unspecified), Times.Once); mockTransaction.Verify(tr => tr.Commit(), Times.Never); mockTransaction.Verify(tr => tr.Rollback(), Times.Once); }
public void TransactionManager_ShouldCallCommitOnSuccessfulInvocation() { var mockTransaction = new Mock <IDbTransaction>(MockBehavior.Strict); mockTransaction.Setup(tr => tr.Commit()); mockTransaction.Setup(tr => tr.Dispose()); var mockDbConnection = new Mock <IDbConnection>(MockBehavior.Strict); mockDbConnection .Setup(conn => conn.BeginTransaction(IsolationLevel.Unspecified)) .Returns(mockTransaction.Object); var mockModule = new Mock <IModule>(MockBehavior.Strict); mockModule.Setup(m => m.DoSomething(It.IsAny <object>())); Type proxyType = ProxyGenerator <IModule, TransactionManager <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, new Lazy <IDbConnection>(() => mockDbConnection.Object)) !; module.DoSomething(new object()); mockDbConnection.Verify(conn => conn.BeginTransaction(IsolationLevel.Unspecified), Times.Once); mockTransaction.Verify(tr => tr.Commit(), Times.Once); }
public void PropertyValidator_ShouldHandleNulls() { var mockModule = new Mock <IModule>(MockBehavior.Loose); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); Type proxyType = ProxyGenerator <IModule, ParameterValidator <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object) !; Assert.DoesNotThrow(() => module.DoSomething(null)); }
public void ParameterValidationTest() { var mockModule = new Mock <IModule>(MockBehavior.Loose); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); Type proxyType = ProxyGenerator <IModule, ParameterValidator <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object, false) !; Assert.DoesNotThrow(() => module.DoSomething("cica", 1)); var ex = Assert.Throws <ValidationException>(() => module.DoSomething(null, null)); Assert.That(ex.TargetName, Is.EqualTo("arg1")); Assert.That(ex.Message, Is.EqualTo(Errors.NULL_PARAM)); }
public void TransactionManager_ShouldNotCompleteUntilTheTransactionIsDone() { bool inTransaction = false; var mockTransaction = new Mock <IDbTransaction>(MockBehavior.Strict); mockTransaction .Setup(tr => tr.Commit()) .Callback(() => Thread.Sleep(10)); mockTransaction .Setup(tr => tr.Dispose()) .Callback(() => inTransaction = false); var mockDbConnection = new Mock <IDbConnection>(MockBehavior.Strict); mockDbConnection .Setup(conn => conn.BeginTransaction(IsolationLevel.Unspecified)) .Returns(() => { inTransaction = true; return(mockTransaction.Object); }); var mockModule = new Mock <IModule>(MockBehavior.Strict); mockModule .Setup(m => m.DoSomethingAsync()) .Returns(async() => { await Task.Delay(10); return(0); }); Type proxyType = ProxyGenerator <IModule, TransactionManager <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, new Lazy <IDbConnection>(() => mockDbConnection.Object)) !; for (int i = 0; i < 100; i++) { Assert.DoesNotThrowAsync(async() => { await module.DoSomethingAsync(); Assert.False(inTransaction); }); } }
public void TransactionManager_ShouldIgnoreMethodsWithoutTransactionalAttribute() { var mockTransaction = new Mock <IDbTransaction>(MockBehavior.Strict); var mockDbConnection = new Mock <IDbConnection>(MockBehavior.Strict); var mockModule = new Mock <IModule>(MockBehavior.Strict); mockModule.Setup(m => m.NonTransactional()); Type proxyType = ProxyGenerator <IModule, TransactionManager <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, new Lazy <IDbConnection>(() => mockDbConnection.Object)) !; module.NonTransactional();; mockDbConnection.Verify(conn => conn.BeginTransaction(It.IsAny <IsolationLevel>()), Times.Never); mockTransaction.Verify(tr => tr.Commit(), Times.Never); mockTransaction.Verify(tr => tr.Rollback(), Times.Never); }
public void AggregatedParameterValidationTest() { var mockModule = new Mock <IModule>(MockBehavior.Loose); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); Type proxyType = ProxyGenerator <IModule, ParameterValidator <IModule> > .GetGeneratedType(); IModule module = (IModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object, true) !; Assert.DoesNotThrow(() => module.DoSomething("cica", 1)); AggregateException ex = Assert.Throws <AggregateException>(() => module.DoSomething("kutya", null)); Assert.That(ex.InnerExceptions.Count, Is.EqualTo(2)); Assert.That(ex.InnerExceptions[0], Is.InstanceOf <ValidationException>()); Assert.That(((ValidationException)ex.InnerExceptions[0]).TargetName, Is.EqualTo("arg1")); Assert.That(((ValidationException)ex.InnerExceptions[0]).Message, Is.EqualTo("ooops")); Assert.That(ex.InnerExceptions[1], Is.InstanceOf <ValidationException>()); Assert.That(((ValidationException)ex.InnerExceptions[1]).TargetName, Is.EqualTo("arg2")); }
public void AsyncParameterValidationTest() { var mockModule = new Mock <IMyAsyncModule>(MockBehavior.Strict); mockModule .Setup(m => m.Foo(It.IsAny <string>())) .Returns(Task.CompletedTask); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); Type proxyType = ProxyGenerator <IMyAsyncModule, ParameterValidator <IMyAsyncModule> > .GetGeneratedType(); IMyAsyncModule module = (IMyAsyncModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object, false) !; Assert.DoesNotThrowAsync(() => module.Foo("cica")); var ex = Assert.ThrowsAsync <ValidationException>(() => module.Foo(null)); Assert.That(ex.Message, Is.EqualTo("ooops")); }
public void GetExtended_ShouldSupportProxyTypes() { Type proxy = ProxyGenerator <IList <IDictionary>, MyInterceptor> .GetGeneratedType(); Func <IInjector, IReadOnlyDictionary <string, object>, object> factory = ServiceActivator.GetExtended(proxy); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); mockInjector .Setup(i => i.Get(typeof(IList <IDictionary>), null)) .Returns(new List <IDictionary>()); mockInjector .Setup(i => i.TryGet(typeof(IDisposable), null)) .Returns(null); Assert.DoesNotThrow(() => factory.Invoke(mockInjector.Object, new Dictionary <string, object>())); mockInjector.Verify(i => i.Get(typeof(IList <IDictionary>), null), Times.Once); mockInjector.Verify(i => i.TryGet(typeof(IDisposable), null), Times.Once); }
public void AsyncPropertyValidationTest() { var mockModule = new Mock <IMyAsyncModule>(MockBehavior.Loose); var mockInjector = new Mock <IInjector>(MockBehavior.Strict); mockInjector .Setup(i => i.TryGet(typeof(IRequestContext), null)) .Returns <Type, string>((iface, name) => null); Type proxyType = ProxyGenerator <IMyAsyncModule, ParameterValidator <IMyAsyncModule> > .GetGeneratedType(); IMyAsyncModule module = (IMyAsyncModule)Activator.CreateInstance(proxyType, mockModule.Object, mockInjector.Object) !; Assert.DoesNotThrowAsync(() => module.Foo(new MyArg { Value = "cica" })); Assert.ThrowsAsync <ValidationException>(() => module.Foo(new MyArg())); }
private static Type GenerateProxyType <TInterface, TInterceptor>() where TInterface : class where TInterceptor : InterfaceInterceptor <TInterface> => ProxyGenerator <TInterface, TInterceptor> .GetGeneratedType();