A Programmer with Microsoft tools

Now it is time to see a test application. For this I create a new .NET Core 3.1 ASP.NET application, add Xabaril ( to see the end result ) and add reference to my project. The Startup is:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using HCVersion;
using HealthChecks.UI.Client;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace NetCore31HC
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            string name = Assembly.GetExecutingAssembly().GetName().Name;
            services.AddControllers();
            services.AddHealthChecks()
                .AddCheck<HealthCheckVersion>(name);
            services
                .AddHealthChecksUI(setup =>
                 {
                     setup.AddHealthCheckEndpoint("All", $"/hc");
                 })
                .AddInMemoryStorage()
                ;
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
                endpoints.MapHealthChecks("/hc",new HealthCheckOptions()
                {
                    Predicate= _=> true,
                    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
                });
                endpoints.MapHealthChecksUI();
            });
        }
    }
}

And so I figure out the fact that I should not hardcode the name of the HealthCheck , but to put dinamically.  So I change also the readme file to acknowledge that.

Code at https://github.com/ignatandrei/HealthCheckVersion/releases/tag/testApp

HealthCheckVersion

Now it is time to write some code .  However, the implementation should be in a different class than the health check itself – to can be tested.

The code is as follows:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("TestHealthCheckVersion")]

namespace HCVersion
{
    internal class HCV
    {
        static Version versionEntry;
        static Version versionHCV;
        static HCV()
        {
            var ass = Assembly.GetEntryAssembly();
            versionEntry = ass.GetName().Version;
            versionHCV = Assembly.GetExecutingAssembly().GetName().Version;

        }
        public string GetStartingAssemblyInformation()
        {
            return versionEntry.ToString();
        }
        public string GetHCVAssemblyInformation()
        {
            return versionHCV.ToString();
        }
    }
}

The internals visible to is for running tests successfully.

The code for getting the real Health Check is

using Microsoft.Extensions.Diagnostics.HealthChecks;
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Threading;
using System.Threading.Tasks;

namespace HCVersion
{
    public class HealthCheckVersion : IHealthCheck
    {
        public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
        {
            var hcv = new HCV();
            var res = HealthCheckResult.Healthy(hcv.GetStartingAssemblyInformation(),
                new Dictionary<string, object>()
                {
                    {"Entry",hcv.GetStartingAssemblyInformation() },
                    {"HCV",hcv.GetHCVAssemblyInformation() }
                });

            return Task.FromResult( res);
        }
    }
}

You will find the code at https://github.com/ignatandrei/HealthCheckVersion/releases/tag/testWorks

HealthCheckVersion

Now it is time to add tests . Even if will not compile, the tests should show how the application behaves. Here are the tests:

using System;
using Xunit;

namespace TestHealthCheckVersion
{
    public class TestHCV
    {
        [Fact]
        public void TestStartAssemblyVersion()
        {
            #region Arrange
            var hcv = new HCV();
            #endregion
            #region Act
            string v = hcv.GetStartingAssemblyInformation();
            #endregion
            #region Assert
            Assert.Equal("1.0.0.0", v);
            #endregion
        }
        [Fact]
        public void TestHCVAssemblyVersion()
        {
            #region Arrange
            var hcv = new HCV();
            #endregion
            #region Act
            string v = hcv.GetHCVAssemblyInformation();
            #endregion
            #region Assert
            Assert.Equal("1.0.0.0", v);
            #endregion
        }
    }
}

The code ( again, even if not compile ) it is at https://github.com/ignatandrei/HealthCheckVersion/releases/tag/addingTests

HealthCheckVersion

Written the documentation at https://github.com/ignatandrei/HealthCheckVersion . Put also here to have it.

HealthCheckVersion

What it is

This NuGet package will report via Health Check the version of the starting assembly . Also, it should report his own version – but not direct .

It will be easy to demo via Xabaril

Why

To know from first hand if the application works and , if it does, to see fast his versin

How to use

Add the NuGet package HealthCheckVersion.

In the Startup.cs

services.AddHealthChecks()
    .AddCheck<HealthCheckVersion>("HealthCheckVersion");

Navigate to the HealthCheck JSON and see the reporting of the version of the starting assembly and of the own HealthCheckVersion assembly.

And that will be all!

(Maybe later I will think about a configuration for this – in order to customize the reporting)

Tests

The application has also tests to see if it works. I will test just the obtaining the version of the starting assembly and HealthCheckVersion own assembly.

The first test will test the functions

GetStartingAssemblyInformation

GetHCVAssemblyInformation

HealthCheckVersion

The health Check from Microsoft ( https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks ) and from Xabaril ( https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks ) are pretty impressive. ( I have done this before with a simple ping action  – but this is better)

I was thinking about making a simple HealthCheck – that reports the version of executing  starting assembly ( And his own version – to know if it is outdated )

I will try to make it first Documentation  , then Test, then Implementation, then CI , then CD – and that will be all

It is a simple application.- just curious how it will take to have it done.

The first step is to create a repository for my application –  it is at https://github.com/ignatandrei/HealthCheckVersion – and can be downloaded from https://github.com/ignatandrei/HealthCheckVersion/releases/tag/firstVersion

HealthCheckVersion