chore: deploy initial code base

2026-05-12 10:34:30 -05:00
parent cce2961782
commit a81300a571
1829 changed files with 248331 additions and 1 deletions
@@ -0,0 +1,93 @@
+using Snowflake.Data.Client;
+using Strata.DecisionSupport.Biz.Encounters;
+using Strata.DecisionSupport.Biz.Parameters;
+using Strata.DecisionSupport.Biz.Services;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Strata.DecisionSupport.Biz.Test.Integration.IntegrationTests
+{
+    [ExcludeFromCodeCoverage]
+    [TestFixture, Category("Integration"), Category("DSS")]
+    public class TestEncounterChargeQuery : IntegrationTestBase
+    {
+
+        [TestCaseSource(nameof(EncounterChargeQueryTestCases))]
+        public async Task EncounterChargeQueryTest(EncounterChargeQueryInfo queryInfo)
+        {
+            var query = EncounterQueries.EncounterChargeQuery(queryInfo.First, queryInfo.Rows, queryInfo.Args());
+            try
+            {
+                var result = ((IEnumerable<EncounterChargeInfo>)(await _databaseContext
+                    .QueryAsync<EncounterChargeInfo>(query, nameof(EncounterChargeQueryTest), queryInfo.Parameters())));
+                await Verifier.Verify(query, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(query)));
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                // ILB
+            }
+            catch (Exception)
+            {
+
+                throw;
+            }
+        }
+
+        [TestCaseSource(nameof(EncounterChargeQueryTestCases))]
+        public async Task EncounterChargeQueryServiceTest(EncounterChargeQueryInfo queryInfo)
+        {
+            try
+            {
+                var result = await _encounterQueryService.RunEncounterChargeQuery(queryInfo, CancellationToken.None);
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                // ILB
+            }
+            catch (Exception)
+            {
+
+                throw;
+            }
+        }
+
+        public static IEnumerable<TestCaseData> EncounterChargeQueryTestCases()
+        {
+            yield return new TestCaseData(new EncounterChargeQueryInfo(
+                false,
+                false,
+                false,
+                false,
+                false,
+                true,
+                Guid.NewGuid(),
+                [1]))
+                .SetName("{m}");
+            yield return new TestCaseData(new EncounterChargeQueryInfo(
+                true,
+                false,
+                true,
+                false,
+                true,
+                true,
+                Guid.NewGuid(),
+                [1]))
+                .SetName("{m} hasManufacturer hasSupply usingCustomDimension");
+            yield return new TestCaseData(new EncounterChargeQueryInfo(
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                Guid.NewGuid(),
+                [1]))
+                .SetName("{m} hasManufacturer Inferred hasSupply Inferred usingCustomDimension");
+
+        }
+    }
+}
@@ -0,0 +1,60 @@
+using Snowflake.Data.Client;
+using Strata.DecisionSupport.Biz.Parameters;
+using Strata.DecisionSupport.Biz.Services;
+using Strata.DecisionSupport.Models.Encounters;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Strata.DecisionSupport.Biz.Test.Integration.IntegrationTests
+{
+    [ExcludeFromCodeCoverage]
+    [TestFixture, Category("Integration"), Category("DSS")]
+    public class TestEncounterUnitOfServiceQuery : IntegrationTestBase
+    {
+        [TestCaseSource(nameof(TestCases))]
+        public async Task QueryTest(EncounterUnitOfServiceQueryInfo queryInfo)
+            => await base.QueryTest<EncounterUnitOfService, EncounterUnitOfServiceQueryInfo>(queryInfo);
+
+        protected override string Query<EnounterUnitOfServiceQueryInfo>(EnounterUnitOfServiceQueryInfo queryInfo)
+            => (queryInfo is IWithArgs args)
+                ? EncounterQueries.EncounterUnitOfServiceQuery(args)
+                : EncounterQueries.EncounterUnitOfServiceQuery();
+
+        [TestCaseSource(nameof(ServiceTestCases))]
+        public async Task EncounterUnitOfServiceQueryServiceTest(EncounterUnitOfServiceQueryInfo queryInfo)
+        {
+            try
+            {
+                var result = await _encounterQueryService.RunEncounterUnitOfServiceQuery(queryInfo, CancellationToken.None);
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                // ILB
+            }
+            catch (Exception ex)
+            {
+
+                throw;
+            }
+        }
+
+        public static IEnumerable<TestCaseData> ServiceTestCases()
+        {
+            yield return new TestCaseData(new EncounterUnitOfServiceQueryInfo(
+                24,
+                [1L, 2L]
+                ))
+                .SetName("{m}");
+        }
+
+        public static IEnumerable<TestCaseData> TestCases()
+        {
+            yield return new TestCaseData(new EncounterUnitOfServiceQueryInfo(
+                24,
+                [1L, 2L]
+                ))
+                .SetName("{c} {m}");
+        }
+    }
+}
@@ -0,0 +1,38 @@
+using Snowflake.Data.Client;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Strata.DecisionSupport.Biz.Test.Integration.IntegrationTests
+{
+    [ExcludeFromCodeCoverage]
+    [TestFixture, Category("Integration"), Category("DSS")]
+    public class TestException : IntegrationTestBase
+    {
+
+        [Test]
+        public async Task ExceptionTest()
+        {
+            var query = "select ISNULL(null, 0) id\r\n";
+            try
+            {
+                var result = await _databaseContext.QueryAsync<TestClass>(query, nameof(ExceptionTest));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                await Verifier.Verify(dbex.Message, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName());
+            }
+            catch (Exception)
+            {
+
+                throw;
+            }
+        }
+
+        public class TestClass
+        {
+            public int Id { get; set; }
+        }
+
+    }
+
+}
@@ -0,0 +1,63 @@
+using Snowflake.Data.Client;
+using Strata.DecisionSupport.Biz.Encounters;
+using Strata.DecisionSupport.Biz.Parameters;
+using Strata.DecisionSupport.Biz.Services;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Strata.DecisionSupport.Biz.Test.Integration.IntegrationTests
+{
+    [ExcludeFromCodeCoverage]
+    [TestFixture, Category("Integration"), Category("DSS")]
+
+    public class TestLOSOpportunityInfoQuery : IntegrationTestBase
+    {
+        [TestCaseSource(nameof(LOSOpportunityInfoQueryTestCases))]
+        public async Task LOSOpportunityInfoQueryTest(LOSOpportunityQueryInfo queryInfo)
+        {
+            var query = EncounterQueries.LOSOpportunityInfoQuery(LOSOpportunityQueryInfo.Args());
+            try
+            {
+                var result = ((IEnumerable<LOSOpportunityInfo>)await _databaseContext
+                    .QueryAsync<LOSOpportunityInfo>(query, nameof(LOSOpportunityInfoQueryTest), queryInfo.Parameters()));
+                await Verifier.Verify(query, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(query)));
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                // ILB
+            }
+            catch (Exception ex)
+            {
+
+                throw;
+            }
+        }
+
+        [TestCaseSource(nameof(LOSOpportunityInfoQueryTestCases))]
+        public async Task LOSOpportunityInfoQueryServiceTest(LOSOpportunityQueryInfo queryInfo)
+        {
+            try
+            {
+                var result = await _encounterQueryService.RunLOSOpportunityInfoQuery(queryInfo, CancellationToken.None);
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (Exception)
+            {
+
+                throw;
+            }
+        }
+
+        public static IEnumerable<TestCaseData> LOSOpportunityInfoQueryTestCases()
+        {
+            yield return new TestCaseData(new LOSOpportunityQueryInfo(
+                Guid.NewGuid(),
+                24,
+                2))
+                .SetName("{m}");
+        }
+    }
+}
@@ -0,0 +1,56 @@
+using Snowflake.Data.Client;
+using Strata.DecisionSupport.Biz.Parameters;
+using Strata.DecisionSupport.Biz.Test.Unit;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Strata.DecisionSupport.Biz.Test.Integration.IntegrationTests
+{
+    [ExcludeFromCodeCoverage]
+    [TestFixture, Category("Integration"), Category("DSS")]
+    public class TestSnowflakeQueries : IntegrationTestBase
+    {
+        [TestCaseSource(typeof(SnowflakeTestCases), nameof(SnowflakeTestCases.TestCases))]
+        public async Task VerifyQuery<TI, T>(TI obj, T queryInfo, Func<IEnumerable<TI>, IEnumerable<TI>> orderby) where TI : class where T : class
+        {
+            var query = Query(queryInfo);
+            var lineReader = query.LineReader();
+            await Verifier.Verify(lineReader, verifySettings)
+                .UseDirectory("snapshotQueries")
+                .UseFileName(TestContext.CurrentContext.TestName());
+            var parameters = queryInfo is IWithParameters hasParameters ? hasParameters.Parameters() : null;
+            if (string.IsNullOrEmpty(query)) { return; }
+            try
+            {
+                IEnumerable<TI> result;
+                result = parameters != null
+                    ? await _databaseContext.QueryAsync<TI>(query, typeof(T).Name, parameters)
+                    : await _databaseContext.QueryAsync<TI>(query, typeof(T).Name);
+                if (orderby != null)
+                {
+                    result = orderby(result);
+                }
+                await Verify(result, verifySettings)
+                    .UseDirectory("snapshotResults")
+                    .UseFileName(TestContext.CurrentContext.TestName());
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                var result = dbex.Message + Environment.NewLine + "".PadLeft(40, '-') + Environment.NewLine + lineReader;
+                await Verifier.Verify(query, verifySettings)
+                    .UseDirectory("errorQueries")
+                    .UseFileName(TestContext.CurrentContext.TestName());
+                await Verifier.Verify(result, verifyErrorSettings)
+                    .UseFileName(TestContext.CurrentContext.TestName());
+            }
+            catch (Exception ex)
+            {
+
+                throw;
+            }
+        }
+
+        protected override string Query<T>(T queryInfo) where T : class
+            => SnowflakeTestCases.Query(queryInfo);
+
+    }
+}
@@ -0,0 +1,70 @@
+using Dapper;
+using Snowflake.Data.Client;
+using Strata.DecisionSupport.Biz.Encounters;
+using Strata.DecisionSupport.Biz.Parameters;
+using Strata.DecisionSupport.Biz.Services;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Strata.DecisionSupport.Biz.Test.Integration.IntegrationTests
+{
+    [ExcludeFromCodeCoverage]
+    [TestFixture, Category("Integration"), Category("DSS")]
+    public class TestVariationEncounterChargeQuery : IntegrationTestBase
+    {
+        [TestCaseSource(nameof(VariationEncounterChargeQueryTestCases))]
+        public async Task VariationEncounterChargeQueryTest(VariationEncounterChargeQueryInfo queryInfo)
+        {
+
+            var query = EncounterQueries.VariationEncounterChargeQuery(queryInfo.First, queryInfo.Rows, queryInfo.Args());
+
+            try
+            {
+                var result = ((IEnumerable<VariationEncounterChargeInfo>)(await _databaseContext
+                    .QueryAsync<VariationEncounterChargeInfo>(query, nameof(VariationEncounterChargeQueryTest), queryInfo.Parameters())));
+                await Verifier.Verify(query, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(query)));
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                // ILB
+            }
+            catch (Exception ex)
+            {
+
+                throw;
+            }
+        }
+
+        [TestCaseSource(nameof(VariationEncounterChargeQueryTestCases))]
+        public async Task VariationEncounterChargeInfoServiceTest(VariationEncounterChargeQueryInfo queryInfo)
+        {
+            try
+            {
+                var result = await _encounterQueryService.RunVariationEncounterChargeQuery(queryInfo, CancellationToken.None);
+                await Verifier.Verify(result, verifySettings)
+                    .UseFileName(TestContext.CurrentContext.TestName(nameof(result)));
+            }
+            catch (SnowflakeDbException dbex)
+            {
+                // ILB
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+
+        public static IEnumerable<TestCaseData> VariationEncounterChargeQueryTestCases()
+        {
+            yield return new TestCaseData(new VariationEncounterChargeQueryInfo(false, false, false, false, false, true,
+                new Guid[] { Guid.NewGuid() },
+                new int[] { 1, 2 }, 1, 1000))
+                .SetName("{m}");
+        }
+
+
+    }
+
+}