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