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);
}
