private async Task <(MockClient, HealthCheckResult)> RunHealthCheckAsync(HttpHealthCheckParameters parameters, HttpResponseMessage response)
{
Accessor <ServiceContext> accessor = new Accessor <ServiceContext>();
Mock <IHttpClientFactory> factoryMock = new Mock <IHttpClientFactory>();
MockClient clientMock = new MockClient(response);
factoryMock.Setup(f => f.CreateClient(HttpEndpointHealthCheck.HttpClientLogicalName))
.Returns(clientMock);
HttpEndpointHealthCheck healthCheck = new HttpEndpointHealthCheck(
parameters,
factoryMock.Object,
accessor,
new NullLogger <HttpEndpointHealthCheck>(),
new SimpleScopeProvider());
HealthCheckContext checkContext = HealthCheckContextHelper.CreateCheckContext();
HealthCheckResult uninitializedResult = await healthCheck.CheckHealthAsync(checkContext);
Assert.AreEqual(HealthStatus.Degraded, uninitializedResult.Status,
FormattableString.Invariant($"Should return {HealthStatus.Degraded} if accessor not set"));
Mock <ICodePackageActivationContext> mock = new Mock <ICodePackageActivationContext>();
mock.Setup(c => c.GetEndpoint(parameters.EndpointName)).Returns(new System.Fabric.Description.EndpointResourceDescription());
ServiceContext context = MockStatelessServiceContextFactory.Create(mock.Object, "", new Uri("http://localhost"), Guid.Empty, 0);
(accessor as IAccessorSetter <ServiceContext>).SetValue(context);
HealthCheckResult result = await healthCheck.CheckHealthAsync(checkContext);
return(clientMock, result);
}
public void AddSimulationSettings_ValidContent_ReturnsCorrectly()
{
// Initialize config
var configSections = new ConfigurationSectionCollection();
var configSettings = CreateConfigurationSettings(configSections);
ConfigurationSection configSection = CreateConfigurationSection(nameof(configSection.Name));
configSections.Add(configSection);
ConfigurationProperty parameter = CreateConfigurationSectionParameters(nameof(parameter.Name), nameof(parameter.Value));
configSection.Parameters.Add(parameter);
ConfigurationPackage configPackage = CreateConfigurationPackage(configSettings, nameof(configPackage.Path));
var codePackageContext = new Mock <ICodePackageActivationContext>(MockBehavior.Loose);
codePackageContext.Setup(cp => cp.GetConfigurationPackageObject("Config"))
.Returns(configPackage);
// Initialize service context
var newUri = new Uri("fabric:/MockApp/OtherMockStatelessService");
var serviceTypeName = "OtherMockServiceType";
var partitionId = Guid.NewGuid();
var replicaId = long.MaxValue;
var serviceContext = MockStatelessServiceContextFactory.Create(
codePackageContext.Object, serviceTypeName, newUri, partitionId, replicaId);
var services = new ServiceCollection();
// Act
IServiceCollection collection = services.AddSimulationSettings(serviceContext);
// Verify
Assert.IsNotNull(collection);
Assert.AreEqual(2, collection.Count);
}
public Task RegisterAsync(
string serviceTypeName,
Func <StatelessServiceContext, StatelessService> serviceFactory,
CancellationToken cancellationToken)
{
var context = MockStatelessServiceContextFactory.Create(
MockCodePackageActivationContext.Default,
serviceTypeName,
new Uri(MockStatelessServiceContextFactory.ServiceName),
Guid.Empty,
default);
this.serviceInstance = new MockStatelessServiceInstance(serviceFactory(context));
return(this.serviceInstance.InitiateStartupSequenceAsync());
}
public void TestCustom()
{
var newUri = new Uri("fabric:/MockApp/OtherMockStatelessService");
var serviceTypeName = "OtherMockServiceType";
var partitionId = Guid.NewGuid();
var replicaId = long.MaxValue;
var context = new MockCodePackageActivationContext("fabric:/MyApp", "MyAppType", "Code", "Ver", "Context", "Log", "Temp", "Work", "Man", "ManVer");
var instance = MockStatelessServiceContextFactory.Create(context, serviceTypeName, newUri, partitionId, replicaId);
Assert.IsInstanceOfType(instance, typeof(StatelessServiceContext));
Assert.AreEqual(context, instance.CodePackageActivationContext);
Assert.AreEqual(newUri, instance.ServiceName);
Assert.AreEqual(serviceTypeName, instance.ServiceTypeName);
Assert.AreEqual(partitionId, instance.PartitionId);
Assert.AreEqual(replicaId, instance.InstanceId);
Assert.AreEqual(replicaId, instance.ReplicaOrInstanceId);
}
public static void Should_invoke_packages_events_On_stateless_service_package_activation_events()
{
// Arrange
var actualCallStack = new ConcurrentQueue <string>();
var mockCodePackageActivationContext = new Mock <ICodePackageActivationContext>();
mockCodePackageActivationContext
.Setup(instance => instance.ApplicationName)
.Returns("Application");
mockCodePackageActivationContext
.Setup(instance => instance.ApplicationTypeName)
.Returns("ApplicationType");
var mockDelegateCodePackageAdded = new Mock <Action>();
mockDelegateCodePackageAdded
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("codepackage.added"))
.Verifiable();
var mockDelegateCodePackageModified = new Mock <Action>();
mockDelegateCodePackageModified
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("codepackage.modified"))
.Verifiable();
var mockDelegateCodePackageRemoved = new Mock <Action>();
mockDelegateCodePackageRemoved
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("codepackage.removed"))
.Verifiable();
var mockDelegateConfigPackageAdded = new Mock <Action>();
mockDelegateConfigPackageAdded
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("configpackage.added"))
.Verifiable();
var mockDelegateConfigPackageModified = new Mock <Action>();
mockDelegateConfigPackageModified
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("configpackage.modified"))
.Verifiable();
var mockDelegateConfigPackageRemoved = new Mock <Action>();
mockDelegateConfigPackageRemoved
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("configpackage.removed"))
.Verifiable();
var mockDelegateDataPackageAdded = new Mock <Action>();
mockDelegateDataPackageAdded
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("datapackage.added"))
.Verifiable();
var mockDelegateDataPackageModified = new Mock <Action>();
mockDelegateDataPackageModified
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("datapackage.modified"))
.Verifiable();
var mockDelegateDataPackageRemoved = new Mock <Action>();
mockDelegateDataPackageRemoved
.Setup(instance => instance())
.Callback(() => actualCallStack.Enqueue("datapackage.removed"))
.Verifiable();
var mockEventSourceReplicator = MockStatefulServiceHostEventSourceReplicator();
var mockDelegateReplicators = new[]
{
MockDelegateReplicatorForEvent(
mockDelegateCodePackageAdded.Object,
StatelessServiceLifecycleEvent.OnCodePackageAdded),
MockDelegateReplicatorForEvent(
mockDelegateCodePackageModified.Object,
StatelessServiceLifecycleEvent.OnCodePackageModified),
MockDelegateReplicatorForEvent(
mockDelegateCodePackageRemoved.Object,
StatelessServiceLifecycleEvent.OnCodePackageRemoved),
MockDelegateReplicatorForEvent(
mockDelegateConfigPackageAdded.Object,
StatelessServiceLifecycleEvent.OnConfigPackageAdded),
MockDelegateReplicatorForEvent(
mockDelegateConfigPackageModified.Object,
StatelessServiceLifecycleEvent.OnConfigPackageModified),
MockDelegateReplicatorForEvent(
mockDelegateConfigPackageRemoved.Object,
StatelessServiceLifecycleEvent.OnConfigPackageRemoved),
MockDelegateReplicatorForEvent(
mockDelegateDataPackageAdded.Object,
StatelessServiceLifecycleEvent.OnDataPackageAdded),
MockDelegateReplicatorForEvent(
mockDelegateDataPackageModified.Object,
StatelessServiceLifecycleEvent.OnDataPackageModified),
MockDelegateReplicatorForEvent(
mockDelegateDataPackageRemoved.Object,
StatelessServiceLifecycleEvent.OnDataPackageRemoved)
};
var statelessContext = MockStatelessServiceContextFactory.Create(
mockCodePackageActivationContext.Object,
"Mock",
new Uri("fabric:/mock"),
Guid.NewGuid(),
0);
var statelessInstance = new StatelessService(
statelessContext,
mockEventSourceReplicator,
mockDelegateReplicators,
Array.Empty <IStatelessServiceHostListenerReplicator>());
// Act
mockCodePackageActivationContext
.Raise(instance => instance.CodePackageAddedEvent -= null, new PackageAddedEventArgs <CodePackage>());
mockCodePackageActivationContext
.Raise(instance => instance.CodePackageModifiedEvent -= null, new PackageModifiedEventArgs <CodePackage>());
mockCodePackageActivationContext
.Raise(instance => instance.CodePackageRemovedEvent -= null, new PackageRemovedEventArgs <CodePackage>());
mockCodePackageActivationContext
.Raise(instance => instance.ConfigurationPackageAddedEvent -= null, new PackageAddedEventArgs <ConfigurationPackage>());
mockCodePackageActivationContext
.Raise(instance => instance.ConfigurationPackageModifiedEvent -= null, new PackageModifiedEventArgs <ConfigurationPackage>());
mockCodePackageActivationContext
.Raise(instance => instance.ConfigurationPackageRemovedEvent -= null, new PackageRemovedEventArgs <ConfigurationPackage>());
mockCodePackageActivationContext
.Raise(instance => instance.DataPackageAddedEvent -= null, new PackageAddedEventArgs <DataPackage>());
mockCodePackageActivationContext
.Raise(instance => instance.DataPackageModifiedEvent -= null, new PackageModifiedEventArgs <DataPackage>());
mockCodePackageActivationContext
.Raise(instance => instance.DataPackageRemovedEvent -= null, new PackageRemovedEventArgs <DataPackage>());
// Assert
mockDelegateCodePackageAdded.Verify();
mockDelegateCodePackageModified.Verify();
mockDelegateCodePackageRemoved.Verify();
mockDelegateConfigPackageAdded.Verify();
mockDelegateConfigPackageModified.Verify();
mockDelegateConfigPackageRemoved.Verify();
mockDelegateDataPackageAdded.Verify();
mockDelegateDataPackageModified.Verify();
mockDelegateDataPackageRemoved.Verify();
Assert.Equal(9, actualCallStack.Count);
Assert.Equal(
"codepackage.added",
actualCallStack.TryDequeue(out var result)
? result
: null);
Assert.Equal(
"codepackage.modified",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"codepackage.removed",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"configpackage.added",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"configpackage.modified",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"configpackage.removed",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"datapackage.added",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"datapackage.modified",
actualCallStack.TryDequeue(out result)
? result
: null);
Assert.Equal(
"datapackage.removed",
actualCallStack.TryDequeue(out result)
? result
: null);
}