public async Task PublishMethodologyFilesIfApplicableForRelease_ReleaseHasNoRelatedMethodologies() { var releaseId = Guid.NewGuid(); var methodologyService = new Mock <IMethodologyService>(MockBehavior.Strict); var publicBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var privateBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var publicationService = new Mock <IPublicationService>(MockBehavior.Strict); var releaseService = new Mock <IReleaseService>(MockBehavior.Strict); methodologyService.Setup(mock => mock.GetLatestByRelease(releaseId)) .ReturnsAsync(new List <MethodologyVersion>()); // No other invocations on the services expected because the release has no related methodologies var service = BuildPublishingService(methodologyService: methodologyService.Object, publicBlobStorageService: publicBlobStorageService.Object, privateBlobStorageService: privateBlobStorageService.Object, publicationService: publicationService.Object, releaseService: releaseService.Object); await service.PublishMethodologyFilesIfApplicableForRelease(releaseId); MockUtils.VerifyAllMocks(methodologyService, publicBlobStorageService, privateBlobStorageService, publicationService, releaseService); }
public async Task Stream_ReleaseFileNotFound() { var release = new Release(); var contentDbContextId = Guid.NewGuid().ToString(); await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId)) { await contentDbContext.Releases.AddAsync(release); await contentDbContext.SaveChangesAsync(); } var blobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); await using (var contentDbContext = InMemoryApplicationDbContext()) { var service = SetupReleaseImageService(contentDbContext: contentDbContext, blobStorageService: blobStorageService.Object); var result = await service.Stream(release.Id, Guid.NewGuid()); result.AssertNotFound(); } MockUtils.VerifyAllMocks(blobStorageService); }
public async Task QueryForDataBlock() { var tableBuilderService = new Mock <ITableBuilderService>(); tableBuilderService .Setup( s => s.Query( _releaseId, It.Is <ObservationQueryContext>( q => q.SubjectId == _query.SubjectId ) ) ) .ReturnsAsync( new TableBuilderResultViewModel { Results = new List <ObservationViewModel> { new ObservationViewModel() } } ); var contentPersistenceHelper = MockUtils.MockPersistenceHelper <ContentDbContext, ReleaseContentBlock>( new ReleaseContentBlock { ReleaseId = _releaseId, Release = new Release { Id = _releaseId, }, ContentBlockId = _dataBlockId, ContentBlock = new DataBlock { Id = _dataBlockId, Query = _query, Charts = new List <IChart>() } } ); var controller = BuildTableBuilderController( tableBuilderService: tableBuilderService.Object, contentPersistenceHelper: contentPersistenceHelper.Object ); controller.ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() }; var result = await controller.QueryForDataBlock(_releaseId, _dataBlockId); Assert.IsType <TableBuilderResultViewModel>(result.Value); Assert.Single(result.Value.Results); MockUtils.VerifyAllMocks(tableBuilderService, contentPersistenceHelper); }
public async Task Create_LatestPublishedReleaseForSubjectNotFound() { var request = new PermalinkCreateViewModel { Query = { SubjectId = Guid.NewGuid() } }; var releaseRepository = new Mock <IReleaseRepository>(MockBehavior.Strict); var subjectRepository = new Mock <ISubjectRepository>(MockBehavior.Strict); releaseRepository .Setup(s => s.GetLatestPublishedRelease(_publicationId)) .Returns((Release?)null); subjectRepository .Setup(s => s.GetPublicationIdForSubject(request.Query.SubjectId)) .ReturnsAsync(_publicationId); var service = BuildService(releaseRepository: releaseRepository.Object, subjectRepository: subjectRepository.Object); var result = await service.Create(request); MockUtils.VerifyAllMocks( releaseRepository, subjectRepository); result.AssertNotFound(); }
public async Task CheckComplete_SingleDataFileCompleted_AlreadyFinished() { await FinishedStatuses.ForEachAsync(async finishedStatus => { var message = new ImportObservationsMessage { ReleaseId = Guid.NewGuid(), NumBatches = 1, DataFileName = "my_data_file.csv", TotalRows = 2, SubjectId = Guid.NewGuid() }; var importStatusService = new Mock <IImportStatusService>(Strict); var service = BuildFileImportService( importStatusService: importStatusService.Object); importStatusService .Setup(s => s.GetImportStatus(message.ReleaseId, message.DataFileName)) .ReturnsAsync(new ImportStatus { Status = finishedStatus }); var dbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(); await using (dbContext) { await service.CheckComplete(message.ReleaseId, message, dbContext); } MockUtils.VerifyAllMocks(importStatusService); }); }
public async Task PublishStagedReleaseContent() { var releaseId = Guid.NewGuid(); var publicBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var publicBlobCacheService = new Mock <IBlobCacheService>(MockBehavior.Strict); var releaseService = new Mock <IReleaseService>(MockBehavior.Strict); publicBlobStorageService.Setup(mock => mock.MoveDirectory(PublicContent, PublicContentStagingPath(), PublicContent, string.Empty, null)) .Returns(Task.CompletedTask); publicBlobCacheService.Setup(mock => mock.DeleteItem(It.IsAny <PublicationCacheKey>())) .Returns(Task.CompletedTask); releaseService.Setup(mock => mock.SetPublishedDates(releaseId, It.IsAny <DateTime>())) .Returns(Task.CompletedTask); var service = BuildPublishingService(publicBlobStorageService: publicBlobStorageService.Object, publicBlobCacheService: publicBlobCacheService.Object, releaseService: releaseService.Object); await service.PublishStagedReleaseContent(releaseId, "publication-slug"); MockUtils.VerifyAllMocks(publicBlobStorageService, publicBlobCacheService, releaseService); }
public async Task Stream_MethodologyFileNotFound() { var methodologyVersion = new MethodologyVersion(); var contentDbContextId = Guid.NewGuid().ToString(); await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId)) { await contentDbContext.MethodologyVersions.AddAsync(methodologyVersion); await contentDbContext.SaveChangesAsync(); } var blobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId)) { var service = SetupMethodologyImageService(contentDbContext: contentDbContext, blobStorageService: blobStorageService.Object); var result = await service.Stream(methodologyVersion.Id, Guid.NewGuid()); result.AssertNotFound(); } MockUtils.VerifyAllMocks(blobStorageService); }
public async Task GetLatestByRelease() { var release = new Release { Publication = new Publication { Title = "Publication", Slug = "publication-slug" }, ReleaseName = "2018", TimePeriodCoverage = AcademicYearQ1 }; var methodologies = AsList( new MethodologyVersion { Id = Guid.NewGuid(), PreviousVersionId = null, PublishingStrategy = Immediately, Status = Approved, Version = 0 }, new MethodologyVersion { Id = Guid.NewGuid(), PreviousVersionId = null, PublishingStrategy = Immediately, Status = Approved, Version = 0 }); var contentDbContextId = Guid.NewGuid().ToString(); await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId)) { await contentDbContext.Releases.AddAsync(release); await contentDbContext.SaveChangesAsync(); } var methodologyVersionRepository = new Mock <IMethodologyVersionRepository>(MockBehavior.Strict); methodologyVersionRepository.Setup(mock => mock.GetLatestVersionByPublication(release.PublicationId)) .ReturnsAsync(methodologies); await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId)) { var service = SetupMethodologyService(contentDbContext, methodologyVersionRepository.Object); var result = await service.GetLatestByRelease(release.Id); Assert.Equal(methodologies, result); } MockUtils.VerifyAllMocks(methodologyVersionRepository); }
public async Task CheckComplete_LastBatchFileCompleted_HasErrors() { var message = new ImportObservationsMessage { ReleaseId = Guid.NewGuid(), NumBatches = 2, DataFileName = "my_data_file.csv", TotalRows = 2, SubjectId = Guid.NewGuid() }; var importStatusService = new Mock <IImportStatusService>(Strict); var fileStorageService = new Mock <IFileStorageService>(); var service = BuildFileImportService( importStatusService: importStatusService.Object, fileStorageService: fileStorageService.Object); importStatusService .Setup(s => s.GetImportStatus(message.ReleaseId, message.DataFileName)) .ReturnsAsync(new ImportStatus { Status = STAGE_4, Errors = "an error" }); fileStorageService .Setup(s => s.GetNumBatchesRemaining(message.ReleaseId, message.DataFileName)) .ReturnsAsync(0); importStatusService .Setup(s => s.UpdateStatus( message.ReleaseId, message.DataFileName, FAILED, 100)) .Returns(Task.CompletedTask); var dbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(); await using (dbContext) { await dbContext.Observation.AddRangeAsync( new Observation { SubjectId = message.SubjectId }, new Observation { SubjectId = message.SubjectId }); await dbContext.SaveChangesAsync(); await service.CheckComplete(message.ReleaseId, message, dbContext); } MockUtils.VerifyAllMocks(importStatusService, fileStorageService); }
public async Task CheckComplete_SingleDataFileCompleted_HasIncorrectObservationCount() { var message = new ImportObservationsMessage { ReleaseId = Guid.NewGuid(), NumBatches = 1, DataFileName = "my_data_file.csv", TotalRows = 3, SubjectId = Guid.NewGuid() }; var importStatusService = new Mock <IImportStatusService>(Strict); var batchService = new Mock <IBatchService>(Strict); var service = BuildFileImportService( importStatusService: importStatusService.Object, batchService: batchService.Object); importStatusService .Setup(s => s.GetImportStatus(message.ReleaseId, message.DataFileName)) .ReturnsAsync(new ImportStatus { Status = STAGE_4, }); batchService .Setup(s => s.FailImport(message.ReleaseId, message.DataFileName, new List <ValidationError> { new ValidationError( $"Number of observations inserted (2) " + $"does not equal that expected ({message.TotalRows}) : Please delete & retry" ) })) .Returns(Task.CompletedTask); var dbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(); await using (dbContext) { await dbContext.Observation.AddRangeAsync( new Observation { SubjectId = message.SubjectId }, new Observation { SubjectId = message.SubjectId }); await dbContext.SaveChangesAsync(); await service.CheckComplete(message.ReleaseId, message, dbContext); } MockUtils.VerifyAllMocks(importStatusService, batchService); }
public async Task DeleteAllReleaseSubjects() { var release = new Release(); var releaseSubject1 = new ReleaseSubject { Release = release, Subject = new Subject(), }; var releaseSubject2 = new ReleaseSubject { Release = release, Subject = new Subject(), }; var contextId = Guid.NewGuid().ToString(); await using (var statisticsDbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(contextId)) { await statisticsDbContext.AddRangeAsync(releaseSubject1, releaseSubject2); await statisticsDbContext.SaveChangesAsync(); } await using (var statisticsDbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(contextId)) { var subjectDeleter = new Mock <ReleaseSubjectRepository.SubjectDeleter>(); subjectDeleter .Setup( s => s.Delete( It.Is <Subject>(subject => subject.Id == releaseSubject1.SubjectId), It.IsAny <StatisticsDbContext>() ) ); subjectDeleter .Setup( s => s.Delete( It.Is <Subject>(subject => subject.Id == releaseSubject2.SubjectId), It.IsAny <StatisticsDbContext>() ) ); var service = BuildReleaseSubjectService(statisticsDbContext, subjectDeleter: subjectDeleter.Object); await service.DeleteAllReleaseSubjects(release.Id); MockUtils.VerifyAllMocks(subjectDeleter); } await using (var statisticsDbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(contextId)) { Assert.Empty(statisticsDbContext.ReleaseSubject.ToList()); } }
public void ProcessUploadsUnpackArchive() { var mocks = Mocks(); var(processorService, importService, fileImportService) = mocks; var importStagesMessageQueue = new Mock <ICollector <ImportMessage> >(); var datafileProcessingMessageQueue = new Mock <ICollector <ImportObservationsMessage> >(); var import = new DataImport { Id = Guid.NewGuid(), File = new File { Filename = "my_data_file.csv" }, ZipFile = new File { Filename = "my_data_file.zip" }, Status = QUEUED }; var processor = new Processor.Functions.Processor( fileImportService.Object, importService.Object, processorService.Object, new Mock <ILogger <Processor.Functions.Processor> >().Object); processorService .Setup(s => s.ProcessUnpackingArchive(import.Id)) .Returns(Task.CompletedTask); importService .Setup(s => s.GetImport(import.Id)) .ReturnsAsync(import); importService .Setup(s => s.UpdateStatus(import.Id, STAGE_1, 0)) .Returns(Task.CompletedTask); var message = new ImportMessage(import.Id); importStagesMessageQueue .Setup(s => s.Add(message)); processor.ProcessUploads( message, null, importStagesMessageQueue.Object, datafileProcessingMessageQueue.Object ); MockUtils.VerifyAllMocks(processorService, importService, fileImportService, importStagesMessageQueue, datafileProcessingMessageQueue); }
public async Task CancelImport() { var release = new Release(); var file = new File { Type = FileType.Data }; var import = new DataImport { File = file }; var contentDbContextId = Guid.NewGuid().ToString(); await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId)) { await contentDbContext.ReleaseFiles.AddAsync(new ReleaseFile { Release = release, File = file }); await contentDbContext.DataImports.AddAsync(import); await contentDbContext.SaveChangesAsync(); } var userService = new Mock <IUserService>(MockBehavior.Strict); var queueService = new Mock <IStorageQueueService>(MockBehavior.Strict); userService .Setup(s => s.MatchesPolicy(It.Is <File>(f => f.Id == file.Id), SecurityPolicies.CanCancelOngoingImports)) .ReturnsAsync(true); queueService .Setup(s => s.AddMessageAsync(ImportsCancellingQueue, It.Is <CancelImportMessage>(m => m.Id == import.Id))) .Returns(Task.CompletedTask); await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId)) { var service = BuildDataImportService(contentDbContext: contentDbContext, queueService: queueService.Object, userService: userService.Object); var result = await service.CancelImport(release.Id, file.Id); Assert.True(result.IsRight); } MockUtils.VerifyAllMocks(userService, queueService); }
public void ProcessUploadsStage1() { var mocks = Mocks(); var(processorService, importStatusService, batchService, fileImportService) = mocks; var importStagesMessageQueue = new Mock <ICollector <ImportMessage> >(); var datafileProcessingMessageQueue = new Mock <ICollector <ImportObservationsMessage> >(); var message = new ImportMessage { ArchiveFileName = "", Release = new Release { Id = Guid.NewGuid() }, DataFileName = "my_data_file", }; var executionContext = new ExecutionContext(); var processor = new Processor.Functions.Processor( fileImportService.Object, batchService.Object, importStatusService.Object, processorService.Object, new Mock <ILogger <Processor.Functions.Processor> >().Object); importStatusService .Setup(s => s.GetImportStatus(message.Release.Id, message.DataFileName)) .ReturnsAsync(new ImportStatus { Status = IStatus.STAGE_1 }); processorService .Setup(s => s.ProcessStage1(message, executionContext)) .Returns(Task.CompletedTask); importStatusService .Setup(s => s.UpdateStatus(message.Release.Id, message.DataFileName, IStatus.STAGE_2, 0)) .Returns(Task.CompletedTask); importStagesMessageQueue .Setup(s => s.Add(message)); processor.ProcessUploads( message, executionContext, importStagesMessageQueue.Object, datafileProcessingMessageQueue.Object ); MockUtils.VerifyAllMocks(processorService, importStatusService, batchService, fileImportService, importStagesMessageQueue, datafileProcessingMessageQueue); }
public async Task CheckComplete_BatchedFilesStillProcessing() { var file = new File { Id = Guid.NewGuid(), Filename = "my_data_file.csv" }; var import = new DataImport { Id = Guid.NewGuid(), Errors = new List <DataImportError>(), FileId = file.Id, File = file, SubjectId = Guid.NewGuid(), Status = STAGE_4, NumBatches = 2, TotalRows = 2 }; var batchService = new Mock <IBatchService>(Strict); var dataImportService = new Mock <IDataImportService>(Strict); batchService .Setup(s => s.GetNumBatchesRemaining(import.File)) .ReturnsAsync(1); dataImportService .Setup(s => s.GetImport(import.Id)) .ReturnsAsync(import); dataImportService .Setup(s => s.UpdateStatus( import.Id, STAGE_4, 50)) .Returns(Task.CompletedTask); var statisticsDbContextId = Guid.NewGuid().ToString(); await using (var statisticsDbContext = InMemoryStatisticsDbContext(statisticsDbContextId)) { var service = BuildFileImportService(batchService: batchService.Object, dataImportService: dataImportService.Object); var message = new ImportObservationsMessage { Id = import.Id }; await service.CheckComplete(message, statisticsDbContext); } MockUtils.VerifyAllMocks(batchService, dataImportService); }
public async Task CheckComplete_LastBatchFileCompleted_Aborting() { await AbortingStatuses .ToAsyncEnumerable() .ForEachAwaitAsync(async abortingStatus => { var file = new File { Id = Guid.NewGuid(), Filename = "my_data_file.csv" }; var import = new DataImport { Id = Guid.NewGuid(), Errors = new List <DataImportError>(), FileId = file.Id, File = file, SubjectId = Guid.NewGuid(), Status = abortingStatus, NumBatches = 2, TotalRows = 2 }; var dataImportService = new Mock <IDataImportService>(Strict); dataImportService .Setup(s => s.GetImport(import.Id)) .ReturnsAsync(import); dataImportService .Setup(s => s.UpdateStatus( import.Id, abortingStatus.GetFinishingStateOfAbortProcess(), 100)) .Returns(Task.CompletedTask); var statisticsDbContextId = Guid.NewGuid().ToString(); await using (var statisticsDbContext = InMemoryStatisticsDbContext(statisticsDbContextId)) { var service = BuildFileImportService(dataImportService: dataImportService.Object); var message = new ImportObservationsMessage { Id = import.Id }; await service.CheckComplete(message, statisticsDbContext); } MockUtils.VerifyAllMocks(dataImportService); }); }
public void ProcessUploadsButImportIsFinished() { var finishedStates = EnumUtil .GetEnumValues <IStatus>() .Where(ImportStatus.IsFinishedState) .ToList(); finishedStates.ForEach(currentState => { var mocks = Mocks(); var(processorService, importStatusService, batchService, fileImportService) = mocks; var importStagesMessageQueue = new Mock <ICollector <ImportMessage> >(); var datafileProcessingMessageQueue = new Mock <ICollector <ImportObservationsMessage> >(); var message = new ImportMessage { ArchiveFileName = "an_archive", Release = new Release { Id = Guid.NewGuid() }, DataFileName = "my_data_file", }; var processor = new Processor.Functions.Processor( fileImportService.Object, batchService.Object, importStatusService.Object, processorService.Object, new Mock <ILogger <Processor.Functions.Processor> >().Object); importStatusService .Setup(s => s.GetImportStatus(message.Release.Id, message.DataFileName)) .ReturnsAsync(new ImportStatus { Status = currentState }); processor.ProcessUploads( message, null, importStagesMessageQueue.Object, datafileProcessingMessageQueue.Object ); // Verify that no Status updates occurred and that no further attempt to add further processing // messages to queues occurred. MockUtils.VerifyAllMocks(processorService, importStatusService, batchService, fileImportService, importStagesMessageQueue, datafileProcessingMessageQueue); }); }
public async Task QueryForDataBlock_NotModified() { var contentPersistenceHelper = MockUtils.MockPersistenceHelper <ContentDbContext, ReleaseContentBlock>( new ReleaseContentBlock { ReleaseId = _releaseId, Release = new Release { Id = _releaseId, Published = DateTime.Parse("2019-11-11T12:00:00Z") }, ContentBlockId = _dataBlockId, ContentBlock = new DataBlock { Id = _dataBlockId, Query = _query } } ); var controller = BuildTableBuilderController( contentPersistenceHelper: contentPersistenceHelper.Object ); controller.ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() { Request = { Headers = { { HeaderNames.IfModifiedSince, DateTime.Parse("2019-11-11T12:00:00Z").ToUniversalTime().ToString("R") } } } } }; var result = await controller.QueryForDataBlock(_releaseId, _dataBlockId); var statusCodeResult = Assert.IsType <StatusCodeResult>(result.Result); Assert.Equal(StatusCodes.Status304NotModified, statusCodeResult.StatusCode); MockUtils.VerifyAllMocks(contentPersistenceHelper); }
public async Task ReleaseChanged() { var release = new Release(); var releaseStatus = new ReleaseStatus { Release = release }; var contentDbContextId = Guid.NewGuid().ToString(); await using (var context = InMemoryApplicationDbContext(contentDbContextId)) { await context.Releases.AddAsync(release); await context.ReleaseStatus.AddAsync(releaseStatus); await context.SaveChangesAsync(); } var storageQueueService = new Mock <IStorageQueueService>(MockBehavior.Strict); storageQueueService.Setup( mock => mock.AddMessageAsync(NotifyChangeQueue, It.Is <NotifyChangeMessage>(message => message.ReleaseId == release.Id && message.ReleaseStatusId == releaseStatus.Id && message.Immediate))) .Returns(Task.CompletedTask); await using (var context = InMemoryApplicationDbContext(contentDbContextId)) { var publishingService = BuildPublishingService(contentDbContext: context, storageQueueService: storageQueueService.Object); var result = await publishingService .ReleaseChanged(release.Id, releaseStatus.Id, true); storageQueueService.Verify( mock => mock.AddMessageAsync(NotifyChangeQueue, It.Is <NotifyChangeMessage>(message => message.ReleaseId == release.Id && message.ReleaseStatusId == releaseStatus.Id && message.Immediate)), Times.Once()); result.AssertRight(); } MockUtils.VerifyAllMocks(storageQueueService); }
public void ProcessUploadsButImportIsFinished() { var finishedStates = EnumUtil .GetEnumValues <DataImportStatus>() .Where(status => status.IsFinished()) .ToList(); finishedStates.ForEach(currentState => { var mocks = Mocks(); var(processorService, importService, fileImportService) = mocks; var importStagesMessageQueue = new Mock <ICollector <ImportMessage> >(); var datafileProcessingMessageQueue = new Mock <ICollector <ImportObservationsMessage> >(); var import = new DataImport { Id = Guid.NewGuid(), File = new File { Filename = "my_data_file.csv" }, Status = currentState }; var processor = new Processor.Functions.Processor( fileImportService.Object, importService.Object, processorService.Object, new Mock <ILogger <Processor.Functions.Processor> >().Object); importService .Setup(s => s.GetImport(import.Id)) .ReturnsAsync(import); var message = new ImportMessage(import.Id); processor.ProcessUploads( message, null, importStagesMessageQueue.Object, datafileProcessingMessageQueue.Object ); // Verify that no Status updates occurred and that no further attempt to add further processing // messages to queues occurred. MockUtils.VerifyAllMocks(processorService, importService, fileImportService, importStagesMessageQueue, datafileProcessingMessageQueue); }); }
public async Task GetLatestMethodologyBySlug_NotFound() { var methodologyService = new Mock <IMethodologyService>(MockBehavior.Strict); methodologyService.Setup(mock => mock.GetLatestMethodologyBySlug(It.IsAny <string>())) .ReturnsAsync(new NotFoundResult()); var controller = new MethodologyController(methodologyService.Object); var result = await controller.GetLatestMethodologyBySlug("unknown-slug"); Assert.IsType <NotFoundResult>(result.Result); MockUtils.VerifyAllMocks(methodologyService); }
public async Task GetRelease_NotFound() { var releaseService = new Mock <IReleaseService>(MockBehavior.Strict); releaseService.Setup(mock => mock.Get( "publication-a", "2000")) .ReturnsAsync(new NotFoundResult()); var controller = BuildReleaseController(releaseService.Object); var result = await controller.GetRelease("publication-a", "2000"); Assert.IsType <NotFoundResult>(result.Result); MockUtils.VerifyAllMocks(releaseService); }
public async Task GetPublicationTitle_NotFound() { var publicationService = new Mock <IPublicationService>(MockBehavior.Strict); publicationService.Setup(mock => mock.Get("missing-publication")) .ReturnsAsync(new NotFoundResult()); var controller = BuildPublicationController(publicationService.Object); var result = await controller.GetPublicationTitle("missing-publication"); Assert.IsType <NotFoundResult>(result.Result); MockUtils.VerifyAllMocks(publicationService); }
public async Task Stream_BlobDoesNotExist() { var methodologyVersion = new MethodologyVersion(); var methodologyFile = new MethodologyFile { MethodologyVersion = methodologyVersion, File = new File { RootPath = Guid.NewGuid(), Filename = "image.png", Type = Image } }; var contentDbContextId = Guid.NewGuid().ToString(); await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId)) { await contentDbContext.MethodologyVersions.AddAsync(methodologyVersion); await contentDbContext.MethodologyFiles.AddAsync(methodologyFile); await contentDbContext.SaveChangesAsync(); } var blobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); blobStorageService.Setup(mock => mock.CheckBlobExists(PublicMethodologyFiles, It.IsAny <string>())) .ReturnsAsync(false); await using (var contentDbContext = InMemoryContentDbContext(contentDbContextId)) { var service = SetupMethodologyImageService(contentDbContext: contentDbContext, blobStorageService: blobStorageService.Object); var result = await service.Stream(methodologyVersion.Id, methodologyFile.File.Id); result.AssertNotFound(); blobStorageService.Verify( mock => mock.CheckBlobExists(PublicMethodologyFiles, methodologyFile.Path()), Times.Once()); } MockUtils.VerifyAllMocks(blobStorageService); }
public async Task PublishMethodologyFilesIfApplicableForRelease_NotFirstPublicReleaseHasMethodologyScheduledImmediately() { var release = new Release { Id = Guid.NewGuid(), PublicationId = Guid.NewGuid() }; var methodologyVersion = new MethodologyVersion { Id = Guid.NewGuid(), PublishingStrategy = Immediately, Status = Approved }; var methodologyService = new Mock <IMethodologyService>(MockBehavior.Strict); var publicBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var privateBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var publicationService = new Mock <IPublicationService>(MockBehavior.Strict); var releaseService = new Mock <IReleaseService>(MockBehavior.Strict); methodologyService.Setup(mock => mock.GetLatestByRelease(release.Id)) .ReturnsAsync(ListOf(methodologyVersion)); publicationService.Setup(mock => mock.IsPublicationPublished(release.PublicationId)) .ReturnsAsync(true); releaseService.Setup(mock => mock.Get(release.Id)) .ReturnsAsync(release); // No invocations on the storage services expected because the publication already has published releases. // Files for this methodology will be published independently of this release var service = BuildPublishingService(publicStorageConnectionString: PublicStorageConnectionString, methodologyService: methodologyService.Object, publicBlobStorageService: publicBlobStorageService.Object, privateBlobStorageService: privateBlobStorageService.Object, publicationService: publicationService.Object, releaseService: releaseService.Object); await service.PublishMethodologyFilesIfApplicableForRelease(release.Id); MockUtils.VerifyAllMocks(methodologyService, publicBlobStorageService, privateBlobStorageService, publicationService, releaseService); }
public void ProcessUploadsButImportIsBeingCancelled() { var mocks = Mocks(); var(processorService, importStatusService, batchService, fileImportService) = mocks; var importStagesMessageQueue = new Mock <ICollector <ImportMessage> >(); var datafileProcessingMessageQueue = new Mock <ICollector <ImportObservationsMessage> >(); var message = new ImportMessage { ArchiveFileName = "an_archive", Release = new Release { Id = Guid.NewGuid() }, DataFileName = "my_data_file", }; var processor = new Processor.Functions.Processor( fileImportService.Object, batchService.Object, importStatusService.Object, processorService.Object, new Mock <ILogger <Processor.Functions.Processor> >().Object); importStatusService .Setup(s => s.GetImportStatus(message.Release.Id, message.DataFileName)) .ReturnsAsync(new ImportStatus { Status = IStatus.CANCELLING }); importStatusService .Setup(s => s.UpdateStatus(message.Release.Id, message.DataFileName, IStatus.CANCELLED, 100)) .Returns(Task.CompletedTask); processor.ProcessUploads( message, null, importStagesMessageQueue.Object, datafileProcessingMessageQueue.Object ); // Verify that an import with the current Status of CANCELLING will be updated to be CANCELLED, and that // no further processing messages are added to any queues. MockUtils.VerifyAllMocks(processorService, importStatusService, batchService, fileImportService, importStagesMessageQueue, datafileProcessingMessageQueue); }
public async Task RetryReleaseStage_ReleaseNotFound() { var storageQueueService = new Mock <IStorageQueueService>(MockBehavior.Strict); await using (var context = InMemoryApplicationDbContext()) { var publishingService = BuildPublishingService(contentDbContext: context, storageQueueService: storageQueueService.Object); var result = await publishingService.RetryReleaseStage(Guid.NewGuid(), ContentAndPublishing); result.AssertNotFound(); } MockUtils.VerifyAllMocks(storageQueueService); }
public async Task Get_SubjectIsNotFromLatestPublishedRelease() { var subject = new Subject { Id = Guid.NewGuid() }; var permalink = new Permalink( new TableBuilderConfiguration(), new PermalinkTableBuilderResult { SubjectMeta = new PermalinkResultSubjectMeta() }, new ObservationQueryContext { SubjectId = subject.Id }); var blobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var subjectRepository = new Mock <ISubjectRepository>(MockBehavior.Strict); blobStorageService.SetupDownloadBlobText( container: Permalinks, path: permalink.Id.ToString(), blobText: JsonConvert.SerializeObject(permalink)); subjectRepository .Setup(s => s.Get(subject.Id)) .ReturnsAsync(subject); subjectRepository .Setup(s => s.IsSubjectForLatestPublishedRelease(subject.Id)) .ReturnsAsync(false); var service = BuildService(blobStorageService: blobStorageService.Object, subjectRepository: subjectRepository.Object); var result = (await service.Get(permalink.Id)).AssertRight(); MockUtils.VerifyAllMocks( blobStorageService, subjectRepository); Assert.Equal(permalink.Id, result.Id); // Expect invalidated Permalink Assert.True(result.Invalidated); }
public async Task Query_LatestRelease_SubjectNotFound() { var publication = new Publication { Id = Guid.NewGuid(), }; var release = new Release { PublicationId = publication.Id, Publication = publication, }; var query = new ObservationQueryContext { SubjectId = Guid.NewGuid(), }; var contextId = Guid.NewGuid().ToString(); await using (var statisticsDbContext = StatisticsDbUtils.InMemoryStatisticsDbContext(contextId)) { var subjectService = new Mock <ISubjectService>(); subjectService .Setup(s => s.GetPublicationForSubject(query.SubjectId)) .ReturnsAsync(publication); var releaseService = new Mock <IReleaseService>(); releaseService .Setup(s => s.GetLatestPublishedRelease(publication.Id)) .Returns(release); var service = BuildTableBuilderService( statisticsDbContext, subjectService: subjectService.Object, releaseService: releaseService.Object ); var result = await service.Query(query); Assert.True(result.IsLeft); Assert.IsType <NotFoundResult>(result.Left); MockUtils.VerifyAllMocks(subjectService, releaseService); } }
public async Task PublishMethodologyFilesIfApplicableForRelease_ReleaseHasMethodologyScheduledWithOtherRelease() { var release = new Release { Id = Guid.NewGuid(), PublicationId = Guid.NewGuid() }; var methodologyVersion = new MethodologyVersion { Id = Guid.NewGuid(), PublishingStrategy = WithRelease, ScheduledWithReleaseId = Guid.NewGuid(), Status = Approved }; var methodologyService = new Mock <IMethodologyService>(MockBehavior.Strict); var publicBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var privateBlobStorageService = new Mock <IBlobStorageService>(MockBehavior.Strict); var publicationService = new Mock <IPublicationService>(MockBehavior.Strict); var releaseService = new Mock <IReleaseService>(MockBehavior.Strict); methodologyService.Setup(mock => mock.GetLatestByRelease(release.Id)) .ReturnsAsync(ListOf(methodologyVersion)); publicationService.Setup(mock => mock.IsPublicationPublished(release.PublicationId)) .ReturnsAsync(true); releaseService.Setup(mock => mock.Get(release.Id)) .ReturnsAsync(release); // No invocations on the storage services expected because the methodology is scheduled with another release var service = BuildPublishingService(methodologyService: methodologyService.Object, publicBlobStorageService: publicBlobStorageService.Object, privateBlobStorageService: privateBlobStorageService.Object, publicationService: publicationService.Object, releaseService: releaseService.Object); await service.PublishMethodologyFilesIfApplicableForRelease(release.Id); MockUtils.VerifyAllMocks(methodologyService, publicBlobStorageService, privateBlobStorageService, publicationService, releaseService); }