public void DisposeNotCalledForUndisposableServicesCreatedByActivator()
{
var serviceActivator = new DefaultGrpcServiceActivator <GrpcService>(Mock.Of <IServiceProvider>());
var service = serviceActivator.Create();
serviceActivator.Release(service);
Assert.False(service.Disposed);
}
public void Release_NullService_ThrowError()
{
// Arrange
var activator = new DefaultGrpcServiceActivator <GrpcService>();
// Act
var ex = Assert.Throws <ArgumentException>(() => activator.Release(new GrpcActivatorHandle <GrpcService>(null !, created: true, state: null)));
// Assert
Assert.AreEqual("service", ex.ParamName);
}
public void Create_NotResolvedFromServiceProvider_CreatedByActivator()
{
// Arrange
var activator = new DefaultGrpcServiceActivator <GrpcService>();
// Act
var handle = activator.Create(Mock.Of <IServiceProvider>());
// Assert
Assert.NotNull(handle.Instance);
Assert.IsTrue(handle.Created);
}
public void Release_NonDisposableCreatedByActivator_DisposeNotCalled()
{
// Arrange
var serviceActivator = new DefaultGrpcServiceActivator <GrpcService>();
var service = serviceActivator.Create(Mock.Of <IServiceProvider>());
// Act
serviceActivator.Release(service);
// Assert
Assert.False(service.Instance.Disposed);
}
public static IEndpointConventionBuilder MapGrpcService <TService>(this IEndpointRouteBuilder builder) where TService : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
ValidateServicesRegistered(builder.ServiceProvider);
var service = typeof(TService);
try
{
// TService is an implementation of the gRPC service. It ultimately derives from Foo.TServiceBase base class.
// We need to access the static BindService method on Foo which implicitly derives from Object.
var baseType = service.BaseType;
while (baseType?.BaseType?.BaseType != null)
{
baseType = baseType.BaseType;
}
// We need to call Foo.BindService from the declaring type.
var declaringType = baseType?.DeclaringType;
// The method we want to call is public static void BindService(ServiceBinderBase serviceBinder)
var bindService = declaringType?.GetMethod("BindService", new[] { typeof(ServiceBinderBase), baseType });
if (bindService == null)
{
throw new InvalidOperationException($"Cannot locate BindService(ServiceBinderBase, ServiceBase) method for the current service type: {service.FullName}. The type must be an implementation of a gRPC service.");
}
var serviceBinder = new GrpcServiceBinder <TService>(builder);
// Create dummy service instance for the call to BindService.
// This will fail for services that resolve Scoped services in the constructor.
// This restriction will be fixed by https://github.com/grpc/grpc-dotnet/issues/21
var dummy = new DefaultGrpcServiceActivator <TService>(builder.ServiceProvider).Create();
// Invoke
bindService.Invoke(null, new object[] { serviceBinder, dummy });
return(new CompositeEndpointConventionBuilder(serviceBinder.EndpointConventionBuilders));
}
catch (Exception ex)
{
throw new InvalidOperationException($"Unable to map gRPC service '{service.Name}'.", ex);
}
}
public void Create_ResolvedFromServiceProvider_NotCreatedByActivator()
{
// Arrange
var service = new GrpcService();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(GrpcService)))
.Returns(service);
// Act
var handle = new DefaultGrpcServiceActivator <GrpcService>().Create(mockServiceProvider.Object);
// Assert
Assert.AreSame(service, handle.Instance);
Assert.IsFalse(handle.Created);
}
public void DisposeNotCalledForServicesResolvedFromServiceProvider()
{
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(DisposableGrpcService)))
.Returns(() =>
{
return(new DisposableGrpcService());
});
var serviceActivator = new DefaultGrpcServiceActivator <DisposableGrpcService>(mockServiceProvider.Object);
var service = serviceActivator.Create();
serviceActivator.Release(service);
Assert.False(service.Disposed);
}
public void Release_ResolvedFromServiceProvider_DisposeNotCalled()
{
// Arrange
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider
.Setup(sp => sp.GetService(typeof(DisposableGrpcService)))
.Returns(() =>
{
return(new DisposableGrpcService());
});
var serviceActivator = new DefaultGrpcServiceActivator <DisposableGrpcService>();
var service = serviceActivator.Create(mockServiceProvider.Object);
// Act
serviceActivator.Release(service);
// Assert
Assert.False(service.Instance.Disposed);
}
