FCC/Test/Applications/Application.ATG_Classic_App_Test/ATG_Config_Test.cs

using Application.ATG_Classic_App;
using Application.ATG_Classic_App.Model;
using AutoMapper;
using Edge.Core.Processor;
using Edge.Core.IndustryStandardInterface.Pump;
using Edge.Core.IndustryStandardInterface.ATG;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.Json;
using System.Threading.Tasks;
using Edge.Core.UniversalApi;

namespace Application.ATG_Classic_App_Test
{
    [TestClass]
    public class ATG_Config_Test
    {
        static int TankCount = 6;
        //ServiceProvider serviceProvider;
        static List<MockProbeHandler> probeHandlers;
        static ATG_Classic_App.App atg;
        static List<TankProfileData> sharedTankProfileDatas;
        static IEnumerable<TankConfig> tankConfigs;
        static TankOverallConfig tankOverallConfig;

        [ClassInitialize]
        public static void ClassInit(TestContext context)
        {
            var services = new ServiceCollection();
            services.AddSingleton<ILoggerFactory>(NullLoggerFactory.Instance);

            #region AutoMapper, resolve all assemblies under entry folder.

            var applicationAssFileInfos = new DirectoryInfo(Directory.GetCurrentDirectory())
                        .GetFiles().Where(f => //f.Name.ToLower().StartsWith("application") &&
                            f.Extension != null
                            && (f.Extension.ToLower() == ".dll" || f.Extension.ToLower() == ".exe"));
            var assembliesWithAutoMapperProfileDefined = new List<Assembly>();
            foreach (var ai in applicationAssFileInfos)
            {
                try
                {
                    var ass = Assembly.LoadFrom(ai.FullName);
                    if (ass.GetTypes().Any(t => typeof(Profile).IsAssignableFrom(t)))
                        assembliesWithAutoMapperProfileDefined.Add(ass);
                }
                catch
                { }
            }

            services.AddAutoMapper(assembliesWithAutoMapperProfileDefined);

            services.AddSingleton(new UniversalApiHub(null, null));

            #endregion

            var serviceProvider = services.BuildServiceProvider();

            probeHandlers = Enumerable.Range(1, TankCount).Select(i => new MockProbeHandler(i, i * 1000)).ToList();
            sharedTankProfileDatas = Enumerable.Range(0, 2001).Select(i =>
                new TankProfileData()
                {
                    BatchLabel = "shitday",
                    Height = i,
                    Volume = i * 2
                }).ToList();
            tankConfigs = Enumerable.Range(1, TankCount).Select(i => new TankConfig()
            {
                TankNumber = (byte)i,
                Label = "I'm Tank with Number " + i,
                Diameter = i * 1000,
                ProbeConfig = new ProbeConfig() { DeviceId = i },
                ProductConfig = new ProductConfig() { ProductCode = (i + 90).ToString(), ProductLabel = (i + 90).ToString() + "#" },
                TankLimitConfig = new TankLimitConfig() { FullVolume = 1200 * i, MaxVolume = 1100 * i },
                //TankProfileDatas = sharedTankProfileDatas
            });
            tankOverallConfig = new TankOverallConfig() { TcReference = 25 };
            var dbContextFactory = new DefaultDbContextFactory();
            dbContextFactory.AddProvider(new InMemoryDbContextProvider());

            atg = new ATG_Classic_App.App(serviceProvider, 1, true);
            atg.DbContextFactory = dbContextFactory;
            atg.Init(probeHandlers.Cast<IProcessor>());

            var _ = atg.UpsertConfigAsync(tankOverallConfig).Result;
            foreach (var tc in tankConfigs)
            {
                var xx = atg.UpsertConfigAsync(tc).Result;
            }
        }

        class InMemoryDbContextProvider : IDbContextProvider
        {
            public T CreateDbContext<T>() where T : DbContext
            {
                //var options = new DbContextOptionsBuilder<InMemoryDbContext>()
                //   .UseInMemoryDatabase(databaseName: "Test")
                //   .Options;
                return new InMemoryDbContext() as T;
            }

            public void Dispose()
            {
                //throw new NotImplementedException();
            }
        }

        [TestInitialize]
        public void TestMethodInit()
        {

        }

        [TestMethod]
        public async Task Get_Config_TestMethod1()
        {
            var queriedConfigResult = await atg.GetConfigAsync();
            Assert.AreEqual(true, queriedConfigResult != null);
            Assert.AreEqual(true, queriedConfigResult.Item1 != null);
            Assert.AreEqual(true, queriedConfigResult.Item1.TcReference == tankOverallConfig.TcReference);

            Assert.AreEqual(true, queriedConfigResult.Item2 != null);
            Assert.AreEqual(true, queriedConfigResult.Item2.Count() == tankConfigs.Count());
            var joined = queriedConfigResult.Item2.Join(tankConfigs, (inner) => inner.TankNumber, (outer) => outer.TankNumber, (tc, inner) => tc);
            Assert.AreEqual(true, joined.Count() == tankConfigs.Count());
        }

        [TestMethod]
        public async Task OverallConfig_Insert_TestMethod1()
        {
            BaseConfig insertedConfigResult = await atg.UpsertConfigAsync(null);
            Assert.AreEqual(true, insertedConfigResult != null);
            var insertedTankOverallConfig = insertedConfigResult as TankOverallConfig;
            Assert.AreEqual(true, insertedTankOverallConfig != null);
            Assert.AreEqual(true, insertedTankOverallConfig.TcReference == 12.01);

            var queriedConfigResult = await atg.GetConfigAsync();
            Assert.AreEqual(true, queriedConfigResult != null);
            Assert.AreEqual(true, queriedConfigResult.Item1 != null);
            Assert.AreEqual(true, queriedConfigResult.Item1.TcReference == 12.01);

            Assert.AreEqual(true, queriedConfigResult.Item2.Any());
        }

        [TestMethod]
        public async Task OverallConfig_Insert_TestMethod2()
        {
            BaseConfig insertedConfigResult = await atg.UpsertConfigAsync(null);
            Assert.AreEqual(true, insertedConfigResult != null);
            var insertedTankOverallConfig = insertedConfigResult as TankOverallConfig;
            Assert.AreEqual(true, insertedTankOverallConfig != null);
            Assert.AreEqual(true, insertedTankOverallConfig.TcReference == 12.01);

            var queriedConfigResult = await atg.GetConfigAsync();
            Assert.AreEqual(true, queriedConfigResult != null);
            Assert.AreEqual(true, queriedConfigResult.Item1 != null);
            Assert.AreEqual(true, queriedConfigResult.Item1.TcReference == 12.01);

            Assert.AreEqual(true, queriedConfigResult.Item2.Any());
        }
    }
}