public async Task ShouldGetByIdFoundation(bool isFoundation)
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName(_solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.Build()
.InsertAsync();
await SolutionDetailEntityBuilder.Create()
.WithSolutionId(_solution1Id)
.Build()
.InsertAndSetCurrentForSolutionAsync();
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(_solution1Id)
.WithFoundation(isFoundation)
.Build()
.InsertAsync();
var solution = await _solutionRepository.ByIdAsync(_solution1Id, new CancellationToken());
solution.Id.Should().Be(_solution1Id);
solution.IsFoundation.Should().Be(isFoundation);
}
public async Task Setup()
{
await Database.ClearAsync().ConfigureAwait(false);
await OrganisationEntityBuilder.Create()
.WithId(_org1Id)
.Build()
.InsertAsync()
.ConfigureAwait(false);
await SupplierEntityBuilder.Create()
.WithId(_supplierId)
.WithOrganisation(_org1Id)
.Build()
.InsertAsync()
.ConfigureAwait(false);
await SolutionEntityBuilder.Create()
.WithId(_solutionId1)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
_testContext = new TestContext();
_marketingContactRepository = _testContext.MarketingContactRepository;
}
private static async Task InsertSupplier(PublishedStatus solutionPublicationStatus = PublishedStatus.Published)
{
await SupplierEntityBuilder.Create()
.WithId(SupplierId)
.WithName(SupplierName)
.WithSummary(Description)
.WithSupplierUrl(Link)
.WithAddress(SupplierAddress)
.Build()
.InsertAsync();
await SupplierContactEntityBuilder.Create()
.WithId(Guid.NewGuid())
.WithSupplierId(SupplierId)
.WithFirstName(SupplierContactFirstName)
.WithLastName(SupplierContactLastName)
.WithEmail(SupplierContactEmail)
.WithPhoneNumber(SupplierContactPhoneNumber)
.Build()
.InsertAsync();
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(SolutionId)
.WithName(SolutionId)
.WithSupplierId(SupplierId)
.WithPublishedStatusId((int)solutionPublicationStatus)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(SolutionId)
.Build()
.InsertAsync();
}
public async Task Setup()
{
await Database.ClearAsync().ConfigureAwait(false);
await OrganisationEntityBuilder.Create()
.WithId(_org1Id)
.Build()
.InsertAsync()
.ConfigureAwait(false);
await SupplierEntityBuilder.Create()
.WithOrganisation(_org1Id)
.WithId(SupplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.WithOrganisationId(_org1Id)
.WithSupplierId(SupplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
TestContext testContext = new TestContext();
_solutionCapabilityRepository = testContext.SolutionCapabilityRepository;
}
public async Task ShouldUpdateSupplierStatus()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName(_solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.WithOnLastUpdated(_lastUpdated)
.Build()
.InsertAsync();
var mockUpdateSolutionSupplierStatusRequest = new Mock <IUpdateSolutionSupplierStatusRequest>();
mockUpdateSolutionSupplierStatusRequest.Setup(m => m.Id).Returns(_solution1Id);
mockUpdateSolutionSupplierStatusRequest.Setup(m => m.SupplierStatusId).Returns(2);
_solutionRepository.CheckExists(_solution1Id, new CancellationToken()).Result.Should().BeTrue();
await _solutionRepository.UpdateSupplierStatusAsync(mockUpdateSolutionSupplierStatusRequest.Object, new CancellationToken());
var solution = await SolutionEntity.GetByIdAsync(_solution1Id);
solution.Id.Should().Be(_solution1Id);
(await solution.LastUpdated.SecondsFromNow()).Should().BeLessOrEqualTo(5);
}
public async Task SetUp()
{
await Database.ClearAsync();
await SupplierEntityBuilder.Create()
.WithId(_supplierId)
.Build()
.InsertAsync();
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solutionId)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solutionId)
.Build()
.InsertAsync();
_priceId = await InsertPriceAsync(_solutionId);
TestContext testContext = new TestContext();
_priceRepository = testContext.PriceRepository;
}
public async Task OneContactPerSolutionShouldOnlyReturnRelevantContact()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solutionId2)
.WithName(_solutionId2)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solutionId2)
.Build()
.InsertAsync();
var expected1 = await InsertContact(_solutionId1);
var expected2 = await InsertContact(_solutionId2);
var result = (await _marketingContactRepository.BySolutionIdAsync(_solutionId1, new CancellationToken())).ToList();
result.Count.Should().Be(1);
AssertEquivalent(expected1, result.First());
result = (await _marketingContactRepository.BySolutionIdAsync(_solutionId2, new CancellationToken())).ToList();
result.Count.Should().Be(1);
AssertEquivalent(expected2, result.First());
}
public async Task ShouldListSingleSolutionWithMultipleCapability()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName("Solution1")
.WithSupplierId(SupplierId)
.WithPublishedStatusId(3)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.WithSummary("Sln1Summary")
.Build()
.InsertAsync();
await SolutionCapabilityEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithCapabilityId(cap1Id)
.Build()
.InsertAsync();
await SolutionCapabilityEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithCapabilityId(cap2Id)
.Build()
.InsertAsync();
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithFrameworkId("NHSDGP001")
.Build()
.InsertAsync();
var solutions = (await solutionListRepository.ListAsync(false, null, null, CancellationToken.None)).ToList();
solutions.Should().HaveCount(2);
var solution = solutions.Should().ContainSingle(s => s.CapabilityReference == CapabilityReference1).Subject;
solution.SolutionId.Should().Be(Solution1Id);
solution.SolutionName.Should().Be("Solution1");
solution.SolutionSummary.Should().Be("Sln1Summary");
solution.SupplierId.Should().Be(SupplierId);
solution.SupplierName.Should().Be(SupplierName);
solution.CapabilityReference.Should().Be(CapabilityReference1);
solution.CapabilityName.Should().Be("Cap1");
solution.CapabilityDescription.Should().Be("Cap1Desc");
solution = solutions.Should().ContainSingle(s => s.CapabilityReference == CapabilityReference2).Subject;
solution.SolutionId.Should().Be(Solution1Id);
solution.SolutionName.Should().Be("Solution1");
solution.SolutionSummary.Should().Be("Sln1Summary");
solution.SupplierId.Should().Be(SupplierId);
solution.SupplierName.Should().Be(SupplierName);
solution.CapabilityReference.Should().Be(CapabilityReference2);
solution.CapabilityName.Should().Be("Cap2");
solution.CapabilityDescription.Should().Be("Cap2Desc");
}
public async Task ShouldGetByIdFoundation(bool isFoundation)
{
await SolutionEntityBuilder.Create()
.WithName("Solution1")
.WithId(_solution1Id)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
await SolutionDetailEntityBuilder.Create()
.WithSolutionId(_solution1Id)
.Build()
.InsertAndSetCurrentForSolutionAsync()
.ConfigureAwait(false);
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(_solution1Id)
.WithFoundation(isFoundation)
.Build()
.InsertAsync()
.ConfigureAwait(false);
var solution = await _solutionRepository.ByIdAsync(_solution1Id, new CancellationToken()).ConfigureAwait(false);
solution.Id.Should().Be(_solution1Id);
solution.IsFoundation.Should().Be(isFoundation);
}
public static async Task GivenSolutionsExist(Table table)
{
foreach (var solutionTable in table.CreateSet <SolutionTable>())
{
await CatalogueItemEntityBuilder.Create()
.WithCatalogueItemId(solutionTable.SolutionId)
.WithName(solutionTable.SolutionName ?? "SomeName")
.WithSupplierId(solutionTable.SupplierId ?? "Sup 1")
.WithPublishedStatusId((int)solutionTable.PublishedStatus)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(solutionTable.SolutionId)
.WithFeatures(solutionTable.Features)
.WithSummary(solutionTable.SummaryDescription)
.WithFullDescription(solutionTable.FullDescription)
.WithAboutUrl(solutionTable.AboutUrl)
.WithClientApplication(solutionTable.ClientApplication)
.WithHosting(solutionTable.Hosting)
.WithRoadMap(solutionTable.RoadMap)
.WithIntegrationsUrl(solutionTable.IntegrationsUrl)
.WithOnLastUpdated(solutionTable.LastUpdated != DateTime.MinValue ? solutionTable.LastUpdated : DateTime.UtcNow)
.WithImplementationTimescales(solutionTable.ImplementationDetail)
.Build()
.InsertAsync();
}
}
public async Task ShouldRetrieveRoadmapWhenPresent()
{
const string expectedRoadmapString = "I am the roadmap string";
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName(_solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.Build()
.InsertAsync();
await SolutionDetailEntityBuilder.Create()
.WithRoadMap(expectedRoadmapString)
.Build()
.InsertAndSetCurrentForSolutionAsync();
var result = await _solutionDetailRepository.GetRoadMapBySolutionIdAsync(_solution1Id, new CancellationToken());
result.Summary.Should().Be(expectedRoadmapString);
}
public async Task ShouldRetrieveImplementationTimescalesWhenPresent()
{
const string expectedImplementationTimescalesString = "I am the integrations timescales description";
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName(_solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.Build()
.InsertAsync();
await SolutionDetailEntityBuilder.Create()
.WithImplementationTimescales(expectedImplementationTimescalesString)
.Build()
.InsertAndSetCurrentForSolutionAsync();
var result = await _solutionDetailRepository.GetImplementationTimescalesBySolutionIdAsync(_solution1Id, new CancellationToken());
result.Description.Should().Be(expectedImplementationTimescalesString);
}
public async Task ShouldRetrieveClientApplicationDetailsWhenPresent()
{
const string expectedClientApplication = "I am the client application string";
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName(_solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.Build()
.InsertAsync();
await SolutionDetailEntityBuilder.Create()
.WithClientApplication(expectedClientApplication)
.Build()
.InsertAndSetCurrentForSolutionAsync();
var result = await _solutionDetailRepository.GetClientApplicationBySolutionIdAsync(_solution1Id, new CancellationToken());
result.ClientApplication.Should().Be(expectedClientApplication);
}
public async Task ShouldThrowOnUpdateSummarySolutionDetailNotPresent()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName(_solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.Build()
.InsertAsync();
var mockUpdateSolutionSummaryRequest = new Mock <IUpdateSolutionSummaryRequest>();
mockUpdateSolutionSummaryRequest.Setup(m => m.SolutionId).Returns(_solution1Id);
mockUpdateSolutionSummaryRequest.Setup(m => m.Summary).Returns("Sln4Summary");
mockUpdateSolutionSummaryRequest.Setup(m => m.Description).Returns("Sln4Description");
mockUpdateSolutionSummaryRequest.Setup(m => m.AboutUrl).Returns("AboutUrl4");
Assert.ThrowsAsync <SqlException>(() => _solutionDetailRepository.UpdateSummaryAsync(mockUpdateSolutionSummaryRequest.Object, new CancellationToken()));
}
public async Task ShouldRetrieveHostingDetailsWhenPresent()
{
const string expectedHostingString = "I am the hosting string";
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName(Solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(SupplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.WithHosting(expectedHostingString)
.Build()
.InsertAsync();
var result = await solutionRepository.GetHostingBySolutionIdAsync(
Solution1Id,
CancellationToken.None);
result.Hosting.Should().Be(expectedHostingString);
}
public async Task ShouldGetByIdSolutionDetailNotPresent()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName("Solution1")
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(SupplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.WithOnLastUpdated(lastUpdated)
.Build()
.InsertAsync();
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithFrameworkId("NHSDGP001")
.WithFoundation(false)
.Build()
.InsertAsync();
var solution = await solutionRepository.ByIdAsync(Solution1Id, CancellationToken.None);
solution.Id.Should().Be(Solution1Id);
solution.Name.Should().Be("Solution1");
solution.LastUpdated.Should().Be(lastUpdated);
solution.Summary.Should().BeNull();
solution.Description.Should().BeNull();
solution.AboutUrl.Should().BeNull();
solution.Features.Should().BeNull();
solution.ClientApplication.Should().BeNull();
}
public async Task ShouldGetByIdSolutionDetailNotPresent()
{
await SolutionEntityBuilder.Create()
.WithName("Solution1")
.WithId(_solution1Id)
.WithOnLastUpdated(_lastUpdated)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
var solution = await _solutionRepository.ByIdAsync(_solution1Id, new CancellationToken())
.ConfigureAwait(false);
solution.Id.Should().Be(_solution1Id);
solution.Name.Should().Be("Solution1");
solution.LastUpdated.Should().Be(_lastUpdated);
solution.Summary.Should().BeNull();
solution.Description.Should().BeNull();
solution.OrganisationName.Should().Be(_orgName);
solution.AboutUrl.Should().BeNull();
solution.Features.Should().BeNull();
solution.ClientApplication.Should().BeNull();
}
public async Task ShouldListSingleSolutionAsFoundation(bool isFoundation)
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName("Solution1")
.WithSupplierId(_supplierId)
.WithPublishedStatusId(3)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.WithSummary("Sln1Summary")
.Build()
.InsertAsync();
await SolutionCapabilityEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithCapabilityId(_cap1Id)
.Build()
.InsertAsync();
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithFoundation(isFoundation)
.Build().InsertAsync();
var solutions = await _solutionListRepository.ListAsync(false, null, new CancellationToken());
var solution = solutions.Should().ContainSingle().Subject;
solution.SolutionId.Should().Be(Solution1Id);
solution.IsFoundation.Should().Be(isFoundation);
}
public async Task ShouldUpdateSupplierStatus()
{
await SolutionEntityBuilder.Create()
.WithName("Solution1")
.WithId(_solution1Id)
.WithOnLastUpdated(_lastUpdated)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.WithSupplierStatusId(1)
.Build()
.InsertAsync()
.ConfigureAwait(false);
var mockUpdateSolutionSupplierStatusRequest = new Mock <IUpdateSolutionSupplierStatusRequest>();
mockUpdateSolutionSupplierStatusRequest.Setup(m => m.Id).Returns(_solution1Id);
mockUpdateSolutionSupplierStatusRequest.Setup(m => m.SupplierStatusId).Returns(2);
_solutionRepository.CheckExists(_solution1Id, new CancellationToken()).Result.Should().BeTrue();
await _solutionRepository.UpdateSupplierStatusAsync(mockUpdateSolutionSupplierStatusRequest.Object, new CancellationToken()).ConfigureAwait(false);
var solution = await SolutionEntity.GetByIdAsync(_solution1Id)
.ConfigureAwait(false);
solution.Id.Should().Be(_solution1Id);
(await solution.LastUpdated.SecondsFromNow().ConfigureAwait(false)).Should().BeLessOrEqualTo(5);
solution.SupplierStatusId.Should().Be(2);
}
public async Task Setup()
{
await Database.ClearAsync();
await SupplierEntityBuilder.Create()
.WithId(_supplierId)
.Build()
.InsertAsync();
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solutionId1)
.WithName(_solutionId1)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solutionId1)
.Build()
.InsertAsync();
_testContext = new TestContext();
_marketingContactRepository = _testContext.MarketingContactRepository;
}
public async Task ShouldGetByIdSolutionDetailNotPresent()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName("Solution1")
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.WithOnLastUpdated(_lastUpdated)
.Build()
.InsertAsync();
var solution = await _solutionRepository.ByIdAsync(_solution1Id, new CancellationToken());
solution.Id.Should().Be(_solution1Id);
solution.Name.Should().Be("Solution1");
solution.LastUpdated.Should().Be(_lastUpdated);
solution.Summary.Should().BeNull();
solution.Description.Should().BeNull();
solution.AboutUrl.Should().BeNull();
solution.Features.Should().BeNull();
solution.ClientApplication.Should().BeNull();
}
public async Task Setup()
{
await Database.ClearAsync();
await SupplierEntityBuilder.Create()
.WithId(SupplierId)
.Build()
.InsertAsync();
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName(Solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(SupplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.Build()
.InsertAsync();
TestContext testContext = new TestContext();
_solutionCapabilityRepository = testContext.SolutionCapabilityRepository;
}
public async Task ShouldGetByIdFoundation(bool isFoundation)
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName(Solution1Id)
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(SupplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.Build()
.InsertAsync();
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithFoundation(isFoundation)
.Build()
.InsertAsync();
var solution = await solutionRepository.ByIdAsync(Solution1Id, CancellationToken.None);
solution.Id.Should().Be(Solution1Id);
solution.IsFoundation.Should().Be(isFoundation);
}
public async Task ShouldListSingleSolutionWithMultipleCapability()
{
await SolutionEntityBuilder.Create()
.WithName("Solution1")
.WithId(Solution1Id)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.WithPublishedStatusId(3)
.Build()
.InsertAsync().ConfigureAwait(false);
await SolutionDetailEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithSummary("Sln1Summary")
.Build()
.InsertAndSetCurrentForSolutionAsync().ConfigureAwait(false);
await SolutionCapabilityEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithCapabilityId(_cap1Id)
.Build()
.InsertAsync().ConfigureAwait(false);
await SolutionCapabilityEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithCapabilityId(_cap2Id)
.Build()
.InsertAsync().ConfigureAwait(false);
var solutions =
(await _solutionListRepository.ListAsync(false, new CancellationToken()).ConfigureAwait(false)).ToList();
solutions.Should().HaveCount(2);
var solution = solutions.Should().ContainSingle(s => s.CapabilityId == _cap1Id).Subject;
solution.SolutionId.Should().Be(Solution1Id);
solution.SolutionName.Should().Be("Solution1");
solution.SolutionSummary.Should().Be("Sln1Summary");
solution.OrganisationId.Should().Be(_org1Id);
solution.OrganisationName.Should().Be(_orgName);
solution.CapabilityId.Should().Be(_cap1Id);
solution.CapabilityName.Should().Be("Cap1");
solution.CapabilityDescription.Should().Be("Cap1Desc");
solution = solutions.Should().ContainSingle(s => s.CapabilityId == _cap2Id).Subject;
solution.SolutionId.Should().Be(Solution1Id);
solution.SolutionName.Should().Be("Solution1");
solution.SolutionSummary.Should().Be("Sln1Summary");
solution.OrganisationId.Should().Be(_org1Id);
solution.OrganisationName.Should().Be(_orgName);
solution.CapabilityId.Should().Be(_cap2Id);
solution.CapabilityName.Should().Be("Cap2");
solution.CapabilityDescription.Should().Be("Cap2Desc");
}
public async Task ShouldRetrieveNullClientApplicationWhenSolutionDetailDoesNotExist()
{
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
var result = await _solutionDetailRepository.GetClientApplicationBySolutionIdAsync(_solution1Id, new CancellationToken())
.ConfigureAwait(false);
result.ClientApplication.Should().BeNull();
}
public async Task ShouldListSingleSolution()
{
await SolutionEntityBuilder.Create()
.WithName("Solution1")
.WithId(Solution1Id)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.WithPublishedStatusId(3)
.Build()
.InsertAsync().ConfigureAwait(false);
var solutions = await _solutionListRepository.ListAsync(false, new CancellationToken()).ConfigureAwait(false);
solutions.Should().BeEmpty();
}
private static async Task <CatalogueItemEntity> CreateSolution(string solutionId)
{
var solutionCatalogueEntity = CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(solutionId)
.WithSupplierId(SupplierId)
.Build();
await solutionCatalogueEntity.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(solutionId)
.Build()
.InsertAsync();
return(solutionCatalogueEntity);
}
public async Task ShouldThrowOnUpdateClientApplicationSolutionDetailNotPresent()
{
await SolutionEntityBuilder.Create()
.WithName("Solution1")
.WithId(_solution1Id)
.WithOrganisationId(_org1Id)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync()
.ConfigureAwait(false);
var mockUpdateSolutionClientApplicationRequest = new Mock <IUpdateSolutionClientApplicationRequest>();
mockUpdateSolutionClientApplicationRequest.Setup(m => m.SolutionId).Returns(_solution1Id);
mockUpdateSolutionClientApplicationRequest.Setup(m => m.ClientApplication).Returns("Browser-based");
Assert.ThrowsAsync <SqlException>(() => _solutionDetailRepository.UpdateClientApplicationAsync(mockUpdateSolutionClientApplicationRequest.Object, new CancellationToken()));
}
public async Task ShouldGetById()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(Solution1Id)
.WithName("Solution1")
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(SupplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(Solution1Id)
.WithSummary("Sln1Summary")
.WithFullDescription("Sln1Description")
.WithAboutUrl("AboutUrl")
.WithFeatures("Features")
.WithClientApplication("Browser-based")
.WithHosting("Hosting")
.WithLastUpdated(lastUpdated)
.Build()
.InsertAsync();
await FrameworkSolutionEntityBuilder.Create()
.WithSolutionId(Solution1Id)
.WithFrameworkId("NHSDGP001")
.WithFoundation(false)
.Build()
.InsertAsync();
var solution = await solutionRepository.ByIdAsync(Solution1Id, CancellationToken.None);
solution.Id.Should().Be(Solution1Id);
solution.Name.Should().Be("Solution1");
solution.LastUpdated.Should().Be(lastUpdated);
solution.Summary.Should().Be("Sln1Summary");
solution.Description.Should().Be("Sln1Description");
solution.AboutUrl.Should().Be("AboutUrl");
solution.Features.Should().Be("Features");
solution.ClientApplication.Should().Be("Browser-based");
solution.Hosting.Should().Be("Hosting");
solution.IsFoundation.Should().BeFalse();
solution.PublishedStatus.Should().Be(PublishedStatus.Published);
}
public async Task ShouldGetById()
{
await CatalogueItemEntityBuilder
.Create()
.WithCatalogueItemId(_solution1Id)
.WithName("Solution1")
.WithPublishedStatusId((int)PublishedStatus.Published)
.WithSupplierId(_supplierId)
.Build()
.InsertAsync();
await SolutionEntityBuilder.Create()
.WithId(_solution1Id)
.WithOnLastUpdated(_lastUpdated)
.Build()
.InsertAsync();
await SolutionDetailEntityBuilder.Create()
.WithSolutionId(_solution1Id)
.WithSummary("Sln1Summary")
.WithFullDescription("Sln1Description")
.WithAboutUrl("AboutUrl")
.WithFeatures("Features")
.WithClientApplication("Browser-based")
.WithHosting("Hosting")
.WithLastUpdated(_lastUpdated)
.Build()
.InsertAndSetCurrentForSolutionAsync();
var solution = await _solutionRepository.ByIdAsync(_solution1Id, new CancellationToken());
solution.Id.Should().Be(_solution1Id);
solution.Name.Should().Be("Solution1");
solution.LastUpdated.Should().Be(_lastUpdated);
solution.Summary.Should().Be("Sln1Summary");
solution.Description.Should().Be("Sln1Description");
solution.AboutUrl.Should().Be("AboutUrl");
solution.Features.Should().Be("Features");
solution.ClientApplication.Should().Be("Browser-based");
solution.Hosting.Should().Be("Hosting");
solution.IsFoundation.Should().BeFalse();
solution.PublishedStatus.Should().Be(PublishedStatus.Published);
}
