Ejemplo n.º 1
0
        public async Task CheckAsync_RunsAllChecksAndAggregatesResultsAsync()
        {
            const string DataKey          = "Foo";
            const string DataValue        = "Bar";
            const string DegradedMessage  = "I'm not feeling so good";
            const string UnhealthyMessage = "Halp!";
            const string HealthyMessage   = "Everything is A-OK";
            var          exception        = new Exception("Things are pretty bad!");

            // Arrange
            var data = new Dictionary <string, object>()
            {
                { DataKey, DataValue }
            };

            var healthyCheck   = new HealthCheck("HealthyCheck", _ => Task.FromResult(HealthCheckResult.Healthy(HealthyMessage, data)));
            var degradedCheck  = new HealthCheck("DegradedCheck", _ => Task.FromResult(HealthCheckResult.Degraded(DegradedMessage)));
            var unhealthyCheck = new HealthCheck("UnhealthyCheck", _ => Task.FromResult(HealthCheckResult.Unhealthy(UnhealthyMessage, exception)));

            var service = new HealthCheckService(new[]
            {
                healthyCheck,
                degradedCheck,
                unhealthyCheck,
            });

            // Act
            var results = await service.CheckHealthAsync();

            // Assert
            Assert.Collection(results.Results,
                              actual =>
            {
                Assert.Equal(healthyCheck.Name, actual.Key);
                Assert.Equal(HealthyMessage, actual.Value.Description);
                Assert.Equal(HealthCheckStatus.Healthy, actual.Value.Status);
                Assert.Null(actual.Value.Exception);
                Assert.Collection(actual.Value.Data, item =>
                {
                    Assert.Equal(DataKey, item.Key);
                    Assert.Equal(DataValue, item.Value);
                });
            },
                              actual =>
            {
                Assert.Equal(degradedCheck.Name, actual.Key);
                Assert.Equal(DegradedMessage, actual.Value.Description);
                Assert.Equal(HealthCheckStatus.Degraded, actual.Value.Status);
                Assert.Null(actual.Value.Exception);
                Assert.Empty(actual.Value.Data);
            },
                              actual =>
            {
                Assert.Equal(unhealthyCheck.Name, actual.Key);
                Assert.Equal(UnhealthyMessage, actual.Value.Description);
                Assert.Equal(HealthCheckStatus.Unhealthy, actual.Value.Status);
                Assert.Same(exception, actual.Value.Exception);
                Assert.Empty(actual.Value.Data);
            });
        }
        public HealthCheckPublisherHostedService(
            HealthCheckService healthCheckService,
            IOptions <HealthCheckPublisherOptions> options,
            ILogger <HealthCheckPublisherHostedService> logger,
            IEnumerable <IHealthCheckPublisher> publishers)
        {
            if (healthCheckService == null)
            {
                throw new ArgumentNullException(nameof(healthCheckService));
            }

            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            if (logger == null)
            {
                throw new ArgumentNullException(nameof(logger));
            }

            if (publishers == null)
            {
                throw new ArgumentNullException(nameof(publishers));
            }

            _healthCheckService = healthCheckService;
            _options            = options;
            _logger             = logger;
            _publishers         = publishers.ToArray();

            _stopping = new CancellationTokenSource();
        }
Ejemplo n.º 3
0
        public void Constructor_BuildsDictionaryOfChecks()
        {
            // Arrange
            var fooCheck = new HealthCheck("Foo", _ => Task.FromResult(HealthCheckResult.Healthy()));
            var barCheck = new HealthCheck("Bar", _ => Task.FromResult(HealthCheckResult.Healthy()));
            var bazCheck = new HealthCheck("Baz", _ => Task.FromResult(HealthCheckResult.Healthy()));
            var checks   = new[] { fooCheck, barCheck, bazCheck };

            // Act
            var service = new HealthCheckService(checks);

            // Assert
            Assert.Same(fooCheck, service.Checks["Foo"]);
            Assert.Same(barCheck, service.Checks["Bar"]);
            Assert.Same(bazCheck, service.Checks["Baz"]);
            Assert.Equal(3, service.Checks.Count);
        }