public async Task SegmentServiceSegmentsHealthCheckAsyncReturnsSuccess()
        {
            // arrange
            var segmentService = new SegmentService(
                logService,
                overviewBannerSegmentService,
                howToBecomeSegmentService,
                whatItTakesSegmentService,
                whatYouWillDoSegmentService,
                careerPathSegmentService,
                currentOpportunitiesSegmentService,
                relatedCareersSegmentService);

            var expectedResult = new HealthCheckItems
            {
                Source      = new Uri("http://somewhere.com"),
                HealthItems = new List <HealthCheckItem>
                {
                    new HealthCheckItem
                    {
                        Service = "Unit test",
                        Message = "All ok",
                    },
                },
            };

            A.CallTo(() => careerPathSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));
            A.CallTo(() => currentOpportunitiesSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));
            A.CallTo(() => howToBecomeSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));
            A.CallTo(() => overviewBannerSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));
            A.CallTo(() => relatedCareersSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));
            A.CallTo(() => whatItTakesSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));
            A.CallTo(() => whatYouWillDoSegmentService.HealthCheckAsync()).Returns(Task.FromResult(expectedResult));

            // act
            var results = await segmentService.SegmentsHealthCheckAsync().ConfigureAwait(false);

            // assert
            A.CallTo(() => careerPathSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => currentOpportunitiesSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => howToBecomeSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => overviewBannerSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => relatedCareersSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => whatItTakesSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => whatYouWillDoSegmentService.HealthCheckAsync()).MustHaveHappenedOnceExactly();

            results.Count.Should().Be(NumberOfSegmentServices);
            results[0].Service.Should().Be(expectedResult.HealthItems[0].Service);
            results[0].Message.Should().Be(expectedResult.HealthItems[0].Message);
        }
Example #2
0
        public virtual async Task <HealthCheckItems> HealthCheckAsync()
        {
            var url = $"{SegmentClientOptions.BaseAddress}health";

            logService.LogInformation($"{nameof(HealthCheckAsync)}: Checking health for {url}");

            try
            {
                var request = new HttpRequestMessage(HttpMethod.Get, url);

                request.Headers.Accept.Clear();
                request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
                ConfigureHttpClient();

                var response = await httpClient.SendAsync(request).ConfigureAwait(false);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    var responseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

                    var result = JsonConvert.DeserializeObject <HealthCheckItems>(responseString);

                    result.Source = SegmentClientOptions.BaseAddress;

                    logService.LogInformation($"{nameof(HealthCheckAsync)}: Checked health for {url}");

                    return(result);
                }
                else
                {
                    logService.LogError($"{nameof(HealthCheckAsync)}: Error loading health data from {url}: {response.StatusCode}");

                    var aa = SegmentClientOptions.BaseAddress;

                    var result = new HealthCheckItems
                    {
                        Source      = SegmentClientOptions.BaseAddress,
                        HealthItems = new List <HealthCheckItem>
                        {
                            new HealthCheckItem
                            {
                                Service = SegmentClientOptions.Name,
                                Message = $"No health response from {SegmentClientOptions.BaseAddress.ToString()} app",
                            },
                        },
                    };

                    return(result);
                }
            }
            catch (Exception ex)
            {
                logService.LogError($"{nameof(HealthCheckAsync)}: {ex.Message}");

                var result = new HealthCheckItems
                {
                    Source      = SegmentClientOptions.BaseAddress,
                    HealthItems = new List <HealthCheckItem>
                    {
                        new HealthCheckItem
                        {
                            Service = SegmentClientOptions.Name,
                            Message = $"{ex.GetType().Name}: {ex.Message}",
                        },
                    },
                };

                return(result);
            }
        }