public static void Should_use_custom_generic_communication_listener_For_communication_listener(
Theories.Case @case)
{
// Arrange
Mock <ICommunicationListener> mockListener = null;
ICommunicationListener ArrangeListenerFactory(
ServiceContext context,
string endpointName,
IServiceProvider provider)
{
mockListener = new Mock <ICommunicationListener>();
mockListener
.As <ICommunicationListener>()
.Setup(instance => instance.OpenAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(string.Empty));
return(mockListener.Object);
}
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseGenericListenerCommunicationListenerTheoryExtension().Setup(ArrangeListenerFactory));
theoryItem.Try();
// Assert
mockListener.Verify();
}
public static void Should_inject_remoting_handler_dependencies_When_remoting_handler_type_is_set(
Theories.Case @case)
{
// Arrange
var arrangeDependency = new TestDependency();
var arrangeCollection = new ServiceCollection();
arrangeCollection.AddSingleton <ITestDependency>(arrangeDependency);
object expectedDependency = arrangeDependency;
object actualDependency = null;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseDependenciesTheoryExtension().Setup(() => arrangeCollection));
theoryItem.SetupExtension(new UseRemotingListenerHandlerTheoryExtension().Setup <TestRemotingHandlerWithParameters>());
theoryItem.SetupExtension(
new PickRemotingListenerHandlerTheoryExtension().Setup(
s =>
{
var impl = (TestRemotingHandlerWithParameters)s;
actualDependency = impl.Dependency;
}));
theoryItem.Try();
// Assert
Assert.Same(expectedDependency, actualDependency);
}
public static void Should_use_custom_remoting_communication_listener_For_communication_listener(
Theories.Case @case)
{
// Arrange
Mock <FabricTransportServiceRemotingListener> mockListener = null;
FabricTransportServiceRemotingListener ArrangeListenerFactory(
ServiceContext context,
ServiceHostRemotingCommunicationListenerComponentsFactory build)
{
var options = build(context);
mockListener = new Mock <FabricTransportServiceRemotingListener>(
context,
options.MessageHandler,
options.ListenerSettings,
options.MessageSerializationProvider);
mockListener
.As <ICommunicationListener>()
.Setup(instance => instance.OpenAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(string.Empty));
return(mockListener.Object);
}
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseRemotingListenerCommunicationListenerTheoryExtension().Setup(ArrangeListenerFactory));
theoryItem.Try();
// Assert
mockListener.Verify();
}
public static void Should_use_custom_aspnetcore_communication_listener_For_communication_listener(
Theories.Case @case)
{
// Arrange
Mock <AspNetCoreCommunicationListener> mockListener = null;
AspNetCoreCommunicationListener ArrangeListenerFactory(
ServiceContext context,
string s,
Func <string, AspNetCoreCommunicationListener, IWebHost> arg3)
{
var action = new Mock <Func <string, AspNetCoreCommunicationListener, IWebHost> >();
mockListener = new Mock <AspNetCoreCommunicationListener>(context, action.Object);
mockListener.Setup(instance => instance.OpenAsync(It.IsAny <CancellationToken>()))
.Callback(() => arg3(string.Empty, mockListener.Object))
.Returns(Task.FromResult(string.Empty));
return(mockListener.Object);
}
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseAspNetCoreListenerCommunicationListenerTheoryExtension().Setup(ArrangeListenerFactory));
theoryItem.Try();
// Assert
mockListener.Verify();
}
public static void Should_use_custom_remoting_settings_For_communication_listener(
Theories.Case @case)
{
// Arrange
var arrangeSettings = new FabricTransportRemotingListenerSettings();
object expectedSettings = arrangeSettings;
object actualSettings = null;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseRemotingListenerSettingsTheoryExtension().Setup(() => arrangeSettings));
theoryItem.SetupExtension(new PickRemotingListenerSettingsTheoryExtension().Setup(s => actualSettings = s));
theoryItem.Try();
// Assert
Assert.Same(expectedSettings, actualSettings);
}
public static void Should_use_custom_remoting_implementation_For_communication_listener(
Theories.Case @case)
{
// Arrange
var arrangeImplementation = new TestRemotingImplementation();
object expectedImplementation = arrangeImplementation;
object actualImplementation = null;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseRemotingListenerImplementationTheoryExtension().Setup(provider => arrangeImplementation));
theoryItem.SetupExtension(new PickRemotingListenerImplementationTheoryExtension().Setup(s => actualImplementation = s));
theoryItem.Try();
// Assert
Assert.Same(expectedImplementation, actualImplementation);
}
public static void Should_use_endpoint_name_For_communication_listener(
Theories.Case @case)
{
// Arrange
const string ArrangeEndpoint = "Endpoint";
object expectedEndpoint = ArrangeEndpoint;
object actualEndpoint = null;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseListenerEndpointTheoryExtension().Setup(ArrangeEndpoint));
theoryItem.SetupExtension(new PickListenerEndpointTheoryExtension().Setup(s => actualEndpoint = s));
theoryItem.Try();
// Assert
Assert.Same(expectedEndpoint, actualEndpoint);
}
public static void Should_use_custom_remoting_handler_For_communication_listener(
Theories.Case @case)
{
// Arrange
var mockHandler = new Mock <IServiceRemotingMessageHandler>();
var arrangeHandler = mockHandler.Object;
object expectedHandler = arrangeHandler;
object actualHandler = null;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseRemotingListenerHandlerTheoryExtension().Setup(provider => arrangeHandler));
theoryItem.SetupExtension(new PickRemotingListenerHandlerTheoryExtension().Setup(s => actualHandler = s));
theoryItem.Try();
// Assert
Assert.Same(expectedHandler, actualHandler);
}
public static void Should_invoke_delegate_On_default_service_lifecycle_event(
Theories.Case @case)
{
// Arrange
var mockDelegate = new Mock <Action>();
mockDelegate
.Setup(instance => instance())
.Verifiable();
var arrangeDelegate = mockDelegate.Object;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseDelegateTheoryExtension().Setup(arrangeDelegate));
theoryItem.Try();
// Assert
mockDelegate.Verify();
}
public static void Should_use_custom_web_host_builder_For_web_server(
Theories.Case @case)
{
// Arrange
var mockWebHost = new Mock <IWebHost>();
var mockWebHostBuilder = new Mock <IWebHostBuilder>();
mockWebHostBuilder
.Setup(instance => instance.Build())
.Returns(mockWebHost.Object)
.Verifiable();
var arrangeWebHostBuilder = mockWebHostBuilder.Object;
var theoryItem = @case.Promise.Resolve();
// Act
theoryItem.SetupExtension(new UseAspNetCoreListenerWebHostBuilderTheoryExtension().Setup(() => arrangeWebHostBuilder));
theoryItem.Try();
// Assert
mockWebHostBuilder.Verify();
}
