chore: deploy initial code base

This commit is contained in:
Thom Lamb
2026-05-12 10:34:30 -05:00
parent cce2961782
commit a81300a571
1829 changed files with 248331 additions and 1 deletions
@@ -0,0 +1,183 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Moq;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.OpportunityTypeWorkbooks;
using Strata.ContinuousImprovement.Biz.OpportunityWorkbooks;
using Strata.ContinuousImprovement.Client.Test.Integration.Models;
using Strata.ContinuousImprovement.Client.Test.Integration.Setup;
using Strata.CoreLib.Claims;
using Strata.CoreLib.Claims.Extensions;
using System.IdentityModel.Tokens.Jwt;
using System.Net.Http.Headers;
using System.Security.Claims;
using System.Text.Json;
namespace Strata.ContinuousImprovement.Client.Test.Integration.Tests
{
public class ClientServiceBase
{
protected StrataTokenInfo StrataTokenInfo { get; set; }
protected string AccessToken { get; set; }
protected IEnumerable<Claim> Claims { get; set; }
protected long ExpiresIn { get; set; }
protected ClaimsIdentity ClaimsIdentity { get; set; }
protected ClaimsPrincipal ClaimsPrincipal { get; set; }
internal IClaimsPrincipalAccessor ClaimsPrincipalAccessor { get; set; }
internal int StrataId { get; set; }
internal Guid DatabaseGuid { get; set; }
protected readonly string BaseAddress = "https://continuousimprovement-api.dev.stratanetwork.net/";
public IContinuousImprovementService ContinuousImprovementService { get; set; }
public JazzDbContext JazzDbContext { get; set; }
public CentralDbContext CentralDbContext { get; set; }
public IOpportunityWorkbookService OpportunityWorkbookService { get; set; }
#pragma warning disable NUnit1032 // An IDisposable field/property should be Disposed in a TearDown method
public IServiceProvider ServiceProvider { get; set; }
#pragma warning restore NUnit1032 // An IDisposable field/property should be Disposed in a TearDown method
public OpportunityWorkbook OpportunityWorkbook { get; set; }
public OpportunityTypeWorkbook OpportunityTypeWorkbook { get; set; }
[OneTimeSetUp]
public async Task TestSetup()
{
ServiceProvider = ServiceProperties.ServiceProvider;
await ClientValidation();
var httpClient = new HttpClient
{
BaseAddress = new Uri(BaseAddress)
};
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
ContinuousImprovementService = new ContinuousImprovementService(httpClient);
ServiceProperties.ContinuousImprovementService = ContinuousImprovementService;
CentralDbContext = (CentralDbContext)ServiceProperties.CentralDbContext;
JazzDbContext = (JazzDbContext)ServiceProperties.JazzDbContext;
await ReplaceOpportunitWorkbookService();
}
[OneTimeTearDown]
public async Task TestTearDown()
{
((ServiceProvider)ServiceProvider).Dispose();
}
private async Task ReplaceOpportunitWorkbookService()
{
var claimsAccessor = Mock.Of<IClaimsPrincipalAccessor>();
Mock.Get(claimsAccessor)
.Setup(s => s.GetCurrentClaimsPrincipal())
.Returns(ClaimsPrincipal);
var analyticsService = ServiceProperties.AnalyticsService;
OpportunityWorkbookService = new OpportunityWorkbookService(CentralDbContext, analyticsService, claimsAccessor, Mock.Of<ILogger<OpportunityWorkbookService>>());
var services = ServiceProperties.Services;
var descriptor = services.FirstOrDefault(d => d.ServiceType == typeof(IOpportunityWorkbookService));
if (descriptor != null)
{
services.Remove(descriptor);
services.AddScoped<IOpportunityWorkbookService, OpportunityWorkbookService>();
ServiceProvider = services.BuildServiceProvider();
}
OpportunityWorkbook = await CentralDbContext.OpportunityWorkbooks.FirstOrDefaultAsync(CancellationToken.None);
OpportunityTypeWorkbook = await CentralDbContext.OpportunityTypeWorkbooks.FirstOrDefaultAsync(CancellationToken.None);
}
#region Client Claims Validation
public async Task<string> ClientValidation()
{
var UserInfo = new
{
vaultUserName = "ccicostleader", // vault ccicostleader is same as jazz ccicostleader
userName = "ccicostleader",
fullName = "Administrator, CCI"
};
var vaultPassword = await GetUserPassword(UserInfo.vaultUserName);
var bearerToken = await GetBearerToken(UserInfo.userName, vaultPassword);
ClaimsIdentity = new ClaimsIdentity(Claims);
ClaimsPrincipal = new ClaimsPrincipal(ClaimsIdentity);
StrataId = ClaimsPrincipal.GetStrataId();
DatabaseGuid = ClaimsPrincipal.GetDatabaseGuid();
BuildClaimsPrincipalAccessor();
return bearerToken;
}
internal async Task<string> GetUserPassword(string vaultUserName)
{
var client = new HttpClient
{
BaseAddress = new Uri("https://vault.sdt.local/")
};
client.DefaultRequestHeaders.Add("apiKey", "a69d2e478c3f5b395b687ecdf34a3239");
client.DefaultRequestHeaders.Add("ignoreHTTPSErrors", "true");
var vaultResponse = await client.GetAsync($"api/searchpasswords/122?title={vaultUserName}");
vaultResponse.EnsureSuccessStatusCode();
string responseString = await vaultResponse.Content.ReadAsStringAsync();
if (string.IsNullOrEmpty(responseString)) { return string.Empty; }
var jsonResponse = JsonSerializer.Deserialize<IEnumerable<VaultResponse>>(responseString);
if (jsonResponse == null) { return string.Empty; }
var vaultUserInfo = jsonResponse.First();
client.Dispose();
return vaultUserInfo.Password;
}
internal async Task<string> GetBearerToken(string userName, string password)
{
var form = BuildTokenRequest(userName, password);
var client = new HttpClient();
var response = await client.PostAsync("https://identity.dev.stratanetwork.net/connect/token", form);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
if (string.IsNullOrEmpty(responseString)) { return string.Empty; }
var strataTokenInfo = JsonSerializer.Deserialize<StrataTokenInfo>(responseString);
if (strataTokenInfo == null) { return string.Empty; }
StrataTokenInfo = strataTokenInfo;
AccessToken = strataTokenInfo.AccessToken;
ExpiresIn = strataTokenInfo.ExpiresIn;
var handler = new JwtSecurityTokenHandler();
var jwtToken = handler.ReadJwtToken(AccessToken);
Claims = jwtToken.Claims;
client.Dispose();
return AccessToken;
}
internal FormUrlEncodedContent BuildTokenRequest(string userName, string password)
{
var form = new FormUrlEncodedContent(
[
new KeyValuePair<string, string>("database_guid", ServiceProperties.DatabaseGuid.ToString()),
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", userName),
new KeyValuePair<string, string>("password", password),
new KeyValuePair<string, string>("scope", "strata.api.external offline_access"),
new KeyValuePair<string, string>("client_id", "IntegrationTest"),
new KeyValuePair<string, string>("client_secret", "UhAEQsGByTCrwPdHPLmaet_DmLEfcJVbZqGBxArdeRup_TPLrYKNpUNRHejjdnhd")
]);
return form;
}
internal void BuildClaimsPrincipalAccessor()
{
var claimsAccessor = Mock.Of<IClaimsPrincipalAccessor>();
Mock.Get(claimsAccessor)
.Setup(s => s.GetCurrentClaimsPrincipal())
.Returns(ClaimsPrincipal);
ClaimsPrincipalAccessor = claimsAccessor;
}
#endregion
#region Helper Methods
protected async Task<IEnumerable<ConfigurationInfo>> GetConfigurationsAsync(CancellationToken cancellationToken)
{
var configurations = await JazzDbContext.Configurations.ToListAsync(cancellationToken);
return configurations.Select(c => c.Mapped());
}
#endregion
}
}
@@ -0,0 +1,16 @@
using System.Text.Json.Serialization;
namespace Strata.ContinuousImprovement.Client.Test.Integration.Tests
{
public class StrataTokenInfo
{
[JsonPropertyName("access_token")]
public required string AccessToken { get; set; }
[JsonPropertyName("token_type")]
public required string TokenType { get; set; }
[JsonPropertyName("expires_in")]
public required long ExpiresIn { get; set; }
[JsonPropertyName("refresh_token")]
public required string RefreshToken { get; set; }
}
}
@@ -0,0 +1,334 @@
using Microsoft.EntityFrameworkCore;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.Generics;
using Strata.ContinuousImprovement.Biz.OpportunityWorkbooks;
using Strata.ContinuousImprovement.Client.Test.Integration.Models;
using Strata.ContinuousImprovement.Client.Test.Integration.Setup;
using Strata.DecisionSupport.Biz.Utilities;
using Strata.DecisionSupport.Models.Jazz;
using Strata.DecisionSupport.Models.Queries;
using System.Diagnostics.CodeAnalysis;
namespace Strata.ContinuousImprovement.Client.Test.Integration.Tests
{
[ExcludeFromCodeCoverage]
[TestFixture(Category = "Integration")]
public class TestContinuousImprovementClient : ClientServiceBase
{
private const string MSDRGCaseTypeFamilyIdQuery = @"select ctf.casetypefamilyid Value
FROM dss.CaseTypeFamily ctf
WHERE ctf.Name = 'Acute Kidney Failure'
AND EXISTS (SELECT TOP (1) 1 FROM dss.CaseTypeFamilyMappingICD10 msdrg WHERE msdrg.CaseTypeFamilyID = ctf.CaseTypeFamilyID)";
private const string APRDRGCaseTypeFamilyIdQuery = @"SELECT ctf.CaseTypeFamilyID Value
FROM dss.CaseTypeFamily ctf
WHERE ctf.Name = 'Acute Kidney Injury'
AND EXISTS(SELECT TOP (1) 1 FROM dss.CaseTypeFamilyMappingAPRDRG aprdrg WHERE aprdrg.CaseTypeFamilyID = ctf.CaseTypeFamilyID)";
private const string CptCodeCaseTypeFamilyIdQuery = @"SELECT ctf.CaseTypeFamilyID Value
FROM dss.CaseTypeFamily ctf
WHERE ctf.Name = 'Acupuncture Procedures'
AND EXISTS(SELECT TOP (1) 1 FROM dss.CaseTypeFamilyMappingCPT cpt WHERE cpt.CaseTypeFamilyID = ctf.CaseTypeFamilyID)";
private const string PatientPopClinicalIndicatorIdQuery = @"SELECT ci.ClinicalIndicatorID Value
FROM dss.CaseTypeFamily ctf
INNER JOIN dss.DimCaseType ct ON ct.CaseTypeFamilyID = ctf.CaseTypeFamilyID
INNER JOIN dss.DimClinicalIndicator ci ON ci.ClinicalIndicatorID = ct.ClinicalIndicatorID
WHERE ct.CaseTypeCategory = 2
AND ci.Name = 'BPCI Major Joint Replacement - Knee'";
[Test, Order(1)]
public async Task TestGetConfigurations()
{
// arrange
// act
var configurations = await GetConfigurationsAsync(CancellationToken.None);
// assert
Assert.That(configurations, Is.Not.Empty);
}
[Test, Order(1)]
[Ignore("Test database needs to be rolled over to the new year")]
public async Task TestGetDfltConfiguration()
{
// arrange
// act
var configurations = await GetConfigurationsAsync(CancellationToken.None);
var dftlConfiguration = configurations.OrderBy(c => c.DisplayOrder).FirstOrDefault();
// assert
Assert.Multiple(() =>
{
Assert.That(configurations, Is.Not.Empty);
Assert.That(dftlConfiguration, Is.Not.Null);
var expectedFiscalYearId = DateTime.Now.Year;
Assert.That(dftlConfiguration.FiscalYearId, Is.InRange(expectedFiscalYearId - 1, expectedFiscalYearId), "Fiscal year configuration needs to be updated for the current year.");
Assert.That(dftlConfiguration.OrgDefinedEndDate, Is.EqualTo(new DateTime(dftlConfiguration.FiscalYearId, 1, 1).AddDays(-1)));
});
}
[Test, Order(1)]
public async Task TestGetEntityConfiguration()
{
// arrange
// act
var configurations = await GetConfigurationsAsync(CancellationToken.None);
var configuration = configurations.OrderBy(c => c.DisplayOrder).FirstOrDefault(c => c.EntityIdsCsv != "" && !c.IsUsingCustomEntityDimension);
// assert
Assert.Multiple(() =>
{
Assert.That(configurations, Is.Not.Empty);
Assert.That(configuration, Is.Not.Null);
Assert.That(configuration.IsUsingCustomEntityDimension, Is.False);
Assert.That(configuration.EntityIdsCsv, Is.Not.Empty);
});
}
[Test]
public async Task TestDecisionSupportMsdrgEncounterInfo()
{
// arrange
var configurations = await GetConfigurationsAsync(CancellationToken.None);
var configuration = configurations.OrderBy(c => c.DisplayOrder).First(c => c.EntityIdsCsv != "" && !c.IsUsingCustomEntityDimension);
var entityIdValues = configuration.EntityIdsCsv?.Split(',') ?? [];
if (entityIdValues.IsEmpty())
{
entityIdValues = configuration.CustomEntityIdsCsv?.Split(',') ?? ["2"];
}
var entityIds = entityIdValues.Select(entityId => int.TryParse(entityId, out var r) ? r : 0).Distinct();
var caseTypeFamilyId = await GetCaseTypeFamilyId(MSDRGCaseTypeFamilyIdQuery, CancellationToken.None);
var encounterInfo = EncounterInfo(CaseTypeCategory.MSDRG, caseTypeFamilyId, configuration, entityIds);
// act
var result = Enumerable.Empty<MSDRGEncounterInfo>();
Assert.DoesNotThrowAsync(async () =>
result = await ContinuousImprovementService.DecisionSupportMsdrgEncounterInfo(encounterInfo, CancellationToken.None));
// assert
Assert.Multiple(() =>
{
Assert.That(result, Is.AssignableTo<IEnumerable<MSDRGEncounterInfo>>());
Assert.That(result, Is.Not.Null.And.Not.Empty);
});
}
[Test]
public async Task TestDecisionSupportAprdrgEncounterInfo()
{
// arrange
var configurations = await GetConfigurationsAsync(CancellationToken.None);
var configuration = configurations.OrderBy(c => c.DisplayOrder).First(c => c.EntityIdsCsv != "" && !c.IsUsingCustomEntityDimension);
var entityIdValues = configuration.EntityIdsCsv?.Split(',') ?? [];
if (entityIdValues.IsEmpty())
{
entityIdValues = configuration.CustomEntityIdsCsv?.Split(',') ?? ["2"];
}
var entityIds = entityIdValues.Select(entityId => int.TryParse(entityId, out var r) ? r : 0).Distinct();
var caseTypeFamilyId = await GetCaseTypeFamilyId(APRDRGCaseTypeFamilyIdQuery, CancellationToken.None);
var encounterInfo = EncounterInfo(CaseTypeCategory.APRDRG, caseTypeFamilyId, configuration, entityIds);
// act
var result = Enumerable.Empty<APRDRGEncounterInfo>();
Assert.DoesNotThrowAsync(async () =>
result = await ContinuousImprovementService.DecisionSupportAprdrgEncounterInfo(encounterInfo, CancellationToken.None));
// assert
Assert.Multiple(() =>
{
Assert.That(result, Is.AssignableTo<IEnumerable<APRDRGEncounterInfo>>());
Assert.That(result, Is.Not.Null.And.Not.Empty);
});
}
[Test]
public async Task TestDecisionSupportCptCodeDrgEncounterInfo()
{
// arrange
var configurations = await GetConfigurationsAsync(CancellationToken.None);
var configuration = configurations.OrderBy(c => c.DisplayOrder).First(c => c.EntityIdsCsv != "" && !c.IsUsingCustomEntityDimension);
var entityIdValues = configuration.EntityIdsCsv?.Split(',') ?? [];
if (entityIdValues.IsEmpty())
{
entityIdValues = configuration.CustomEntityIdsCsv?.Split(',') ?? ["2"];
}
var entityIds = entityIdValues.Select(entityId => int.TryParse(entityId, out var r) ? r : 0).Distinct();
var caseTypeFamilyId = await GetCaseTypeFamilyId(CptCodeCaseTypeFamilyIdQuery, CancellationToken.None);
var encounterInfo = EncounterInfo(CaseTypeCategory.CPTCode, caseTypeFamilyId, configuration, entityIds);
// act
var result = Enumerable.Empty<CPTCodeEncounterInfo>();
Assert.DoesNotThrowAsync(async () =>
result = await ContinuousImprovementService.DecisionSupportCptCodeEncounterInfo(encounterInfo, CancellationToken.None));
// assert
Assert.That(result, Is.AssignableTo<IEnumerable<CPTCodeEncounterInfo>>());
}
[Test]
public async Task TestDecisionSupportPatientPopulationEncounterInfo()
{
// arrange
var configurations = await GetConfigurationsAsync(CancellationToken.None);
var configuration = configurations.OrderBy(c => c.DisplayOrder).First(c => c.EntityIdsCsv != "" && !c.IsUsingCustomEntityDimension);
var entityIdValues = configuration.EntityIdsCsv?.Split(',') ?? [];
if (entityIdValues.IsEmpty())
{
entityIdValues = configuration.CustomEntityIdsCsv?.Split(',') ?? ["2"];
}
var entityIds = entityIdValues.Select(entityId => int.TryParse(entityId, out var r) ? r : 0).Distinct();
var clinicalIndicatorId = await GetCaseTypeFamilyId(PatientPopClinicalIndicatorIdQuery, CancellationToken.None);
var encounterInfo = EncounterInfo(CaseTypeCategory.PatientPopulation, clinicalIndicatorId, configuration, entityIds);
// act
var result = Enumerable.Empty<PatientPopulationEncounterInfo>();
Assert.DoesNotThrowAsync(async () =>
result = await ContinuousImprovementService.DecisionSupportPatientPopulationEncounterInfo(encounterInfo, CancellationToken.None));
// assert
Assert.Multiple(() =>
{
Assert.That(result, Is.AssignableTo<IEnumerable<PatientPopulationEncounterInfo>>());
Assert.That(result, Is.Not.Null.And.Not.Empty);
});
}
[Test]
public async Task TestGetAllWorkbooks()
{
// arrange
// act
var workbooks = await ContinuousImprovementService.GetAllWorkbooks(CancellationToken.None);
// assert
Assert.Multiple(() =>
{
Assert.That(workbooks, Is.AssignableTo<IEnumerable<WorkbookClientInfo>>());
Assert.That(workbooks.Count, Is.GreaterThanOrEqualTo(1));
var workbook = workbooks.FirstOrDefault();
if (workbook == null) { return; }
Assert.Multiple(() =>
{
Assert.That(OpportunityWorkbook.WorkbookId, Is.GreaterThan(0));
Assert.That(OpportunityWorkbook.StrataId, Is.EqualTo(workbook.StrataId));
});
});
}
[Test]
public async Task TestGetOpportunityWorkbooks()
{
// arrange
// act
var workbooks = await ContinuousImprovementService.GetOpportunityWorkbooks(Guid.NewGuid(), CancellationToken.None);
// assert
Assert.Multiple(() =>
{
Assert.That(workbooks, Is.AssignableTo<IEnumerable<OpportunityWorkbookClientInfo>>());
Assert.That(workbooks.Count, Is.GreaterThanOrEqualTo(0));
var workbook = workbooks.FirstOrDefault();
if (workbook == null) { return; }
Assert.Multiple(() =>
{
Assert.That(OpportunityWorkbook.WorkbookId, Is.GreaterThan(0));
Assert.That(OpportunityWorkbook.StrataId, Is.EqualTo(workbook.StrataId));
});
});
}
[Test]
public async Task TestGetOpportunityTypeWorkbooks()
{
// arrange
// act
var workbooks = await ContinuousImprovementService.GetOpportunityTypeWorkbooks((int)OpportunityTypes.Encounter, CancellationToken.None);
// assert
Assert.Multiple(() =>
{
Assert.That(workbooks, Is.AssignableTo<IEnumerable<OpportunityTypeWorkbookClientInfo>>());
Assert.That(workbooks.Count, Is.GreaterThanOrEqualTo(0));
var workbook = workbooks.FirstOrDefault();
if (workbook == null) { return; }
Assert.Multiple(() =>
{
Assert.That(OpportunityWorkbook.WorkbookId, Is.GreaterThan(0));
Assert.That(OpportunityWorkbook.StrataId, Is.EqualTo(workbook.StrataId));
});
});
}
[Test, Ignore("WIP")]
public async Task TestCreateAndDeleteOpportunityWorkbooks()
{
// arrange
var jazzDbContext = (JazzDbContext)ServiceProperties.JazzDbContext;
var uvOpps = jazzDbContext.VariationOpportunities.Take(10).ToList();
var opportunityWorkbooks = uvOpps.Select(uv => new OpportunityWorkbookClientInfo
{
Name = uv.OpportunityKey,
OpportunityGuid = uv.OpportunityGuid,
StrataId = StrataId,
});
// act
var workbooks = await ContinuousImprovementService.CreateOpportunityWorkbooks(opportunityWorkbooks, CancellationToken.None);
// assert
Assert.Multiple(() =>
{
Assert.That(workbooks, Is.AssignableTo<IEnumerable<OpportunityWorkbookClientInfo>>());
Assert.That(workbooks.Count, Is.GreaterThanOrEqualTo(0));
var workbook = workbooks.FirstOrDefault();
if (workbook == null) { return; }
Assert.Multiple(() =>
{
Assert.That(OpportunityWorkbook.WorkbookId, Is.GreaterThan(0));
Assert.That(OpportunityWorkbook.StrataId, Is.EqualTo(workbook.StrataId));
});
});
foreach (var workbook in workbooks)
{
// act
var response = await ContinuousImprovementService.DeleteOpportunityWorkbook(workbook.OpportunityGuid, workbook.WorkbookId, CancellationToken.None);
//assert
response.EnsureSuccessStatusCode();
}
}
#region Helper Methods
private async Task<int> GetCaseTypeFamilyId(string query, CancellationToken cancellationToken)
=> await ((JazzDbContext)ServiceProperties.JazzDbContext).Database
.SqlQueryRaw<int>(query)
.SingleOrDefaultAsync(CancellationToken.None);
private EncounterQueryInfo EncounterInfo(CaseTypeCategory caseTypeCategory, int caseTypeFamilyId,
ConfigurationInfo configuration,
IEnumerable<int> entityIds)
=> new EncounterQueryInfo
{
CaseTypeCategory = caseTypeCategory,
CaseTypeFamilyId = caseTypeFamilyId,
StartDate = configuration.OrgDefinedEndDate.AddDays(1).AddYears(-1),
EndDate = configuration.OrgDefinedEndDate,
DepartmentRollupGlobalId = "",
ServiceLineGuid = configuration.ServiceLineDimensionGuid,
EntityIDs = entityIds,
ObservationUnitsDivisor = 0.5
};
#endregion
}
}
@@ -0,0 +1,48 @@
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.DbContexts.Snowflake;
using Strata.ContinuousImprovement.Client.Test.Integration.Setup;
using System.Diagnostics.CodeAnalysis;
namespace Strata.ContinuousImprovement.Client.Test.Integration.Tests
{
[ExcludeFromCodeCoverage]
[TestFixture(Category = "Integration")]
public class TestFixtureSetup : ClientServiceBase
{
[Test]
public async Task TestBearerToken()
{
var bearerToken = AccessToken;
Assert.That(bearerToken, Is.Not.Null.And.Not.Empty);
}
[Test]
public async Task TestCentralDbContext()
{
var centralDbContext = ServiceProperties.CentralDbContext as CentralDbContext;
Assert.That(centralDbContext, Is.Not.Null);
}
[Test]
public async Task TestJazzDbContext()
{
var jazzDbContext = ServiceProperties.JazzDbContext as JazzDbContext;
Assert.That(jazzDbContext, Is.Not.Null);
}
[Test]
public async Task TestSnowflakeDbContext()
{
var snowflakeDbContext = ServiceProperties.SnowflakeDatabaseContext as SnowflakeDatabaseContext;
Assert.That(snowflakeDbContext, Is.Not.Null);
}
[Test]
public async Task TestClientService()
{
var clientService = ContinuousImprovementService;
Assert.That(clientService, Is.Not.Null);
}
}
}
@@ -0,0 +1,37 @@
using Microsoft.Extensions.Logging;
using Moq;
using Strata.ContinuousImprovement.Biz.OpportunityWorkbooks;
using Strata.ContinuousImprovement.Client.Test.Integration.Setup;
using Strata.CoreLib.Claims;
using System.Diagnostics.CodeAnalysis;
namespace Strata.ContinuousImprovement.Client.Test.Integration.Tests
{
[ExcludeFromCodeCoverage]
[TestFixture(Category = "Integration")]
public class TestValidateServiceConnection : ClientServiceBase
{
[Test]
public async Task TestGetOpportunityWorkbooksAsync()
{
// arrange
var claimsAccessor = Mock.Of<IClaimsPrincipalAccessor>();
Mock.Get(claimsAccessor)
.Setup(s => s.GetCurrentClaimsPrincipal())
.Returns(ClaimsPrincipal);
var analyticsService = ServiceProperties.AnalyticsService;
var opportunityWorkbookService = new OpportunityWorkbookService(CentralDbContext, analyticsService, claimsAccessor, Mock.Of<ILogger<OpportunityWorkbookService>>());
// act
var workbooks = await opportunityWorkbookService.GetOpportunityWorkbooksAsync(OpportunityWorkbook.OpportunityGuid, CancellationToken.None);
// assert
Assert.That(workbooks.Count, Is.GreaterThanOrEqualTo(1));
var workbook = workbooks.First();
Assert.That(OpportunityWorkbook.WorkbookId, Is.EqualTo(workbook.WorkbookId));
Assert.That(OpportunityWorkbook.StrataId, Is.EqualTo(workbook.StrataId));
}
}
}