public void DisposeNotCalledForUndisposableServicesCreatedByActivator()
{
var interceptorActivator = new DefaultGrpcInterceptorActivator <GrpcInterceptor>(Mock.Of <IServiceProvider>());
var interceptor = (GrpcInterceptor)interceptorActivator.Create();
interceptorActivator.Release(interceptor);
Assert.False(interceptor.Disposed);
}
public void Release_NullInterceptor_ThrowError()
{
// Arrange
var activator = new DefaultGrpcInterceptorActivator <GrpcInterceptor>();
// Act
var ex = Assert.Throws <ArgumentException>(() => activator.Release(new GrpcActivatorHandle <Interceptor>(null !, true, state: null)));
// Assert
Assert.AreEqual("interceptor", ex.ParamName);
}
public void Create_NotResolvedFromServiceProvider_CreatedByActivator()
{
// Arrange
var activator = new DefaultGrpcInterceptorActivator <GrpcInterceptor>();
// Act
var handle = activator.Create(Mock.Of <IServiceProvider>(), CreateRegistration <GrpcInterceptor>());
// Assert
Assert.NotNull(handle.Instance);
Assert.IsTrue(handle.Created);
}
public void Release_NonDisposableCreatedByActivator_DisposeNotCalled()
{
// Arrange
var interceptorActivator = new DefaultGrpcInterceptorActivator <GrpcInterceptor>();
var interceptorHandle = interceptorActivator.Create(Mock.Of <IServiceProvider>(), CreateRegistration <GrpcInterceptor>());
var interceptorInstance = (GrpcInterceptor)interceptorHandle.Instance;
// Act
interceptorActivator.Release(interceptorHandle);
// Assert
Assert.False(interceptorInstance.Disposed);
}
public void GrpcInterceptorCanResolveArgumentsFromArg()
{
var mutex = new Mutex();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(Mutex)))
.Returns(mutex);
var interceptor = new DefaultGrpcInterceptorActivator <GrpcInterceptor>(mockServiceProvider.Object).Create(10) as GrpcInterceptor;
Assert.AreEqual(10, interceptor.X);
}
public void GrpcInterceptorNotResolvedFromServiceProviderIfExplicitArgsGiven()
{
var interceptor = new GrpcInterceptor();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(GrpcInterceptor)))
.Returns(interceptor);
var activatedInstance = new DefaultGrpcInterceptorActivator <GrpcInterceptor>(mockServiceProvider.Object).Create(10);
Assert.AreNotSame(interceptor, activatedInstance);
Assert.AreEqual(10, ((GrpcInterceptor)activatedInstance).X);
}
public void DisposeCalledForMultipleDisposableServicesCreatedByActivator()
{
var interceptorActivator = new DefaultGrpcInterceptorActivator <DisposableGrpcInterceptor>(Mock.Of <IServiceProvider>());
var interceptor1 = (DisposableGrpcInterceptor)interceptorActivator.Create();
var interceptor2 = (DisposableGrpcInterceptor)interceptorActivator.Create();
var interceptor3 = (DisposableGrpcInterceptor)interceptorActivator.Create();
interceptorActivator.Release(interceptor3);
interceptorActivator.Release(interceptor2);
interceptorActivator.Release(interceptor1);
Assert.True(interceptor1.Disposed);
Assert.True(interceptor2.Disposed);
Assert.True(interceptor3.Disposed);
}
public void Create_ExplicitArgsAndServiceArgs_CreatedByActivatorWithServiceArgsResolved()
{
var mutex = new Mutex();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(Mutex)))
.Returns(mutex);
var handle = new DefaultGrpcInterceptorActivator <GrpcIntMutexArgumentInterceptor>().Create(
mockServiceProvider.Object,
CreateRegistration <GrpcIntMutexArgumentInterceptor>(10));
Assert.AreEqual(10, ((GrpcIntMutexArgumentInterceptor)handle.Instance).X);
Assert.AreEqual(mutex, ((GrpcIntMutexArgumentInterceptor)handle.Instance).Mutex);
Assert.IsTrue(handle.Created);
}
public void Create_ResolvedFromServiceProvider_NotCreatedByActivator()
{
// Arrange
var interceptor = new GrpcInterceptor();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(GrpcInterceptor)))
.Returns(interceptor);
var activator = new DefaultGrpcInterceptorActivator <GrpcInterceptor>();
// Act
var handle = activator.Create(mockServiceProvider.Object, CreateRegistration <GrpcInterceptor>());
// Assert
Assert.AreSame(handle.Instance, interceptor);
Assert.IsFalse(handle.Created);
}
public void DisposeNotCalledForServicesResolvedFromServiceProvider()
{
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(DisposableGrpcInterceptor)))
.Returns(() =>
{
return(new DisposableGrpcInterceptor());
});
var interceptorActivator = new DefaultGrpcInterceptorActivator <DisposableGrpcInterceptor>(mockServiceProvider.Object);
var interceptor = (DisposableGrpcInterceptor)interceptorActivator.Create();
interceptorActivator.Release(interceptor);
Assert.False(interceptor.Disposed);
}
public void Release_MultipleDisposableCreatedByActivator_DisposeCalled()
{
// Arrange
var interceptorRegistration = CreateRegistration <DisposableGrpcInterceptor>();
var interceptorActivator = new DefaultGrpcInterceptorActivator <DisposableGrpcInterceptor>();
var interceptorHandle1 = interceptorActivator.Create(Mock.Of <IServiceProvider>(), interceptorRegistration);
var interceptorHandle2 = interceptorActivator.Create(Mock.Of <IServiceProvider>(), interceptorRegistration);
var interceptorHandle3 = interceptorActivator.Create(Mock.Of <IServiceProvider>(), interceptorRegistration);
// Act
interceptorActivator.Release(interceptorHandle3);
interceptorActivator.Release(interceptorHandle2);
interceptorActivator.Release(interceptorHandle1);
// Assert
Assert.True(((DisposableGrpcInterceptor)interceptorHandle1.Instance).Disposed);
Assert.True(((DisposableGrpcInterceptor)interceptorHandle2.Instance).Disposed);
Assert.True(((DisposableGrpcInterceptor)interceptorHandle3.Instance).Disposed);
}
public void Create_ServiceRegistrationAndExplicitArgs_CreatedByActivator()
{
// Arrange
var interceptor = new GrpcIntArgumentInterceptor();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(GrpcIntArgumentInterceptor)))
.Returns(interceptor);
// Act
var handle = new DefaultGrpcInterceptorActivator <GrpcIntArgumentInterceptor>().Create(
mockServiceProvider.Object,
CreateRegistration <GrpcIntArgumentInterceptor>(10));
// Assert
Assert.AreNotSame(interceptor, handle.Instance);
Assert.AreEqual(10, ((GrpcIntArgumentInterceptor)handle.Instance).X);
Assert.IsTrue(handle.Created);
}
public void Release_ResolvedFromServiceProvider_DisposeNotCalled()
{
// Arrange
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(DisposableGrpcInterceptor)))
.Returns(() =>
{
return(new DisposableGrpcInterceptor());
});
var interceptorActivator = new DefaultGrpcInterceptorActivator <DisposableGrpcInterceptor>();
var interceptorHandle = interceptorActivator.Create(mockServiceProvider.Object, CreateRegistration <DisposableGrpcInterceptor>());
var interceptorInstance = (DisposableGrpcInterceptor)interceptorHandle.Instance;
// Act
interceptorActivator.Release(interceptorHandle);
// Assert
Assert.False(interceptorInstance.Disposed);
}
