view-by-distance-mklink-console/Tests/UnitTestCalculations.cs

using Microsoft.Extensions.Configuration;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Phares.Shared;
using Serilog;
using System.Diagnostics;
using System.Reflection;
using View_by_Distance.Shared.Models.Stateless.Methods;
using View_by_Distance.Tests.Models;

namespace View_by_Distance.Tests;

[TestClass]
public class UnitTestCalculations
{

    private readonly ILogger _Logger;
    private readonly AppSettings _AppSettings;
    private readonly string _WorkingDirectory;
    private readonly Configuration _Configuration;
    private readonly IsEnvironment _IsEnvironment;
    private readonly IConfigurationRoot _ConfigurationRoot;
    private readonly Property.Models.Configuration _PropertyConfiguration;

    public UnitTestCalculations()
    {
        ILogger logger;
        AppSettings appSettings;
        string workingDirectory;
        Configuration configuration;
        IsEnvironment isEnvironment;
        IConfigurationRoot configurationRoot;
        LoggerConfiguration loggerConfiguration = new();
        Property.Models.Configuration propertyConfiguration;
        Assembly assembly = Assembly.GetExecutingAssembly();
        bool debuggerWasAttachedAtLineZero = Debugger.IsAttached || assembly.Location.Contains(@"\bin\Debug");
        isEnvironment = new(processesCount: null, nullASPNetCoreEnvironmentIsDevelopment: debuggerWasAttachedAtLineZero, nullASPNetCoreEnvironmentIsProduction: !debuggerWasAttachedAtLineZero);
        IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
            .AddEnvironmentVariables()
            .AddJsonFile(isEnvironment.AppSettingsFileName);
        configurationRoot = configurationBuilder.Build();
        appSettings = Models.Binder.AppSettings.Get(configurationRoot);
        workingDirectory = IWorkingDirectory.GetWorkingDirectory(assembly.GetName().Name, appSettings.WorkingDirectoryName);
        Environment.SetEnvironmentVariable(nameof(workingDirectory), workingDirectory);
        _ = ConfigurationLoggerConfigurationExtensions.Configuration(loggerConfiguration.ReadFrom, configurationRoot);
        Log.Logger = loggerConfiguration.CreateLogger();
        logger = Log.ForContext<UnitTestCalculations>();
        propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
        configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
        logger.Information("Complete");
        _Logger = logger;
        _AppSettings = appSettings;
        _Configuration = configuration;
        _IsEnvironment = isEnvironment;
        _WorkingDirectory = workingDirectory;
        _ConfigurationRoot = configurationRoot;
        _PropertyConfiguration = propertyConfiguration;
    }

    [TestMethod]
    public void TestMethodNull()
    {
        Assert.IsFalse(_Logger is null);
        Assert.IsFalse(_AppSettings is null);
        Assert.IsFalse(_Configuration is null);
        Assert.IsFalse(_IsEnvironment is null);
        Assert.IsFalse(_WorkingDirectory is null);
        Assert.IsFalse(_ConfigurationRoot is null);
        Assert.IsFalse(_PropertyConfiguration is null);
    }

    [TestMethod]
    public void TestMethodGetSort() => Assert.IsTrue(new bool[] { true, false }.OrderByDescending(l => l).First());

    [TestMethod]
    public void TestMethodGetAge()
    {
        Shared.Models.PersonBirthday personBirthday = new(new(1980, 1, 17));
        double? age = IPersonBirthday.GetAge(personBirthday);
        Assert.IsNotNull(age);
        Assert.IsTrue(age.Value > 42.6092);
    }

    [TestMethod]
    public void TestMethodRound()
    {
        Assert.IsTrue(Shared.Models.Stateless.ILocation.Digits == 6);
        Assert.IsTrue(Shared.Models.Stateless.ILocation.Factor == 1000000);
        double valueA = 0.00001d;
        int checkA = (int)(Math.Round(valueA, Shared.Models.Stateless.ILocation.Digits) * Shared.Models.Stateless.ILocation.Factor);
        Assert.IsTrue(checkA == 10);
        double valueB = 0.01d;
        int checkB = (int)(Math.Round(valueB, Shared.Models.Stateless.ILocation.Digits) * Shared.Models.Stateless.ILocation.Factor);
        Assert.IsTrue(checkB == 10000);
        Assert.IsTrue(checkB > checkA);
    }

    [TestMethod]
    public void TestMethodRoundB()
    {
        const int DistanceDigits = 3;
        const int DistanceFactor = 1000;
        const int ToleranceAfterFactor = 600;
        Assert.IsTrue(DistanceDigits == 3);
        Assert.IsTrue(DistanceFactor == 1000);
        Assert.IsTrue(Shared.Models.Stateless.IFaceDistance.Tolerance == 0.6d);
        Assert.IsTrue(ToleranceAfterFactor == 600);
        double valueA = 0.00001d;
        int checkA = (int)(Math.Round(valueA, Shared.Models.Stateless.ILocation.Digits) * Shared.Models.Stateless.ILocation.Factor);
        Assert.IsTrue(checkA == 10);
        double valueB = 0.01d;
        int checkB = (int)(Math.Round(valueB, Shared.Models.Stateless.ILocation.Digits) * Shared.Models.Stateless.ILocation.Factor);
        Assert.IsTrue(checkB == 10000);
        Assert.IsTrue(checkB > checkA);
        int checkC = (int)(Shared.Models.Stateless.IFaceDistance.Tolerance * DistanceFactor);
        Assert.IsTrue(checkC == ToleranceAfterFactor);
    }

}