public async Task UploadFile(FilePayload filePayload)
{
await dataStoreService.UploadFile(filePayload);
fileDownloadDatabaseService.FileDownloadFinished(filePayload);
try
{
fileDownloadDatabaseService.FileValidationStarted(filePayload);
fileValidationService.ValidateFile(filePayload);
fileDownloadDatabaseService.FileValidated(filePayload);
}
catch (FileDownloadFailedDecompressionException)
{
throw;
}
catch (InvalidStatsFileException)
{
throw;
}
catch (Exception exception)
{
throw new UnexpectedValidationException(exception);
}
}
public void Cleanup(FileDownloadResult fileDownloadResult)
{
FilePayload filePayload = fileDownloadResult.FilePayload;
string downloadFilePath = filePayload.DownloadFilePath;
string decompressedDownloadFilePath = filePayload.DecompressedDownloadFilePath;
string failedDownloadFilePath = filePayload.FailedDownloadFilePath;
LogVerbose($"{nameof(Cleanup)} Invoked");
if (Exists(decompressedDownloadFilePath))
{
LogVerbose($"Deleting: {decompressedDownloadFilePath}");
Delete(decompressedDownloadFilePath);
}
if (Exists(downloadFilePath))
{
if (fileDownloadResult.FailedReason == FailedReason.FileDownloadFailedDecompression)
{
LogVerbose($"Moving: {downloadFilePath} to {failedDownloadFilePath}");
Move(downloadFilePath, failedDownloadFilePath);
}
else
{
LogVerbose($"Deleting: {downloadFilePath}");
Delete(downloadFilePath);
}
}
}
private void SetDownloadFileDetails(FilePayload filePayload, DateTime dateTime, string downloadDirectory)
{
filePayload.DownloadDirectory = downloadDirectory;
filePayload.DownloadFileName = GetDownloadFileName(dateTime);
filePayload.DownloadFileExtension = Constants.FilePayload.FileExtension;
filePayload.DownloadFilePath = Path.Combine(downloadDirectory, GetDownloadFileNameWithExtension(dateTime));
}
private void SetFailedDownloadFileDetails(FilePayload filePayload, DateTime dateTime, string downloadDirectory)
{
string downloadFileName = GetDownloadFileNameWithExtension(dateTime);
filePayload.FailedDownloadFilePath =
Path.Combine(downloadDirectory, "FileDownloadFailed", downloadFileName);
}
private void FileValidated(IDatabaseConnectionService databaseConnection, FilePayload filePayload)
{
DbParameter downloadId = CreateDownloadIdParameter(databaseConnection, filePayload.DownloadId);
DbParameter fileUtcDateTime =
databaseConnection.CreateParameter("@FileUtcDateTime", DbType.DateTime, ParameterDirection.Input);
fileUtcDateTime.Value = filePayload.FileUtcDateTime;
DbParameter filePath = databaseConnection.CreateParameter("@FilePath", DbType.String,
ParameterDirection.Input);
filePath.Value = filePayload.UploadPath;
DbParameter fileName = databaseConnection.CreateParameter("@FileName", DbType.String,
ParameterDirection.Input);
fileName.Value = filePayload.DownloadFileName;
DbParameter fileExtension = databaseConnection.CreateParameter("@FileExtension", DbType.String,
ParameterDirection.Input);
fileExtension.Value = filePayload.DownloadFileExtension;
databaseConnection.ExecuteStoredProcedure(Constants.FileDownloadDatabase.FileValidatedProcedureName,
new List <DbParameter>
{
downloadId,
fileUtcDateTime,
filePath,
fileName,
fileExtension
});
}
private string WriteMsBuildItemToDisk(FilePayload payload)
{
var path = _provider.GetTemporarySystemPath();
_provider.WriteFile(path, payload.Bytes);
return(path);
}
public void SetUp()
{
filePayload = new FilePayload();
loggingServiceMock = Substitute.For <ILoggingService>();
systemUnderTest = NewSecureHttpFilePayloadProvider(loggingServiceMock);
}
public void FileDownloadStarted(FilePayload filePayload)
{
loggingService.LogMethodInvoked();
int downloadId = default;
CreateDatabaseConnectionAndExecuteAction(service => { downloadId = FileDownloadStarted(service); });
filePayload.DownloadId = downloadId;
}
private void ReadDecompressedFile(FilePayload filePayload)
{
loggingService.LogVerbose($"Attempting to read file contents: {dateTimeService.DateTimeNow()}");
filePayload.DecompressedDownloadFileData = File.ReadAllText(filePayload.DecompressedDownloadFilePath);
loggingService.LogVerbose($"Reading file complete: {dateTimeService.DateTimeNow()}");
}
public void EnableSecureFilePayload(FilePayload filePayload)
{
if (testHarnessSettingsService.IsSecureFilePayloadDisabled())
{
return;
}
secureFilePayloadService.EnableSecureFilePayload(filePayload);
}
public async Task UploadFile(FilePayload filePayload)
{
await GetContainerAndExecute(async container =>
{
CloudBlockBlob cloudBlockBlob = container.GetBlockBlobReference(filePayload.UploadPath);
await cloudBlockBlob.UploadFromFileAsync(filePayload.DownloadFilePath);
return(true);
});
}
public async Task DownloadFile(FilePayload filePayload, ValidatedFile validatedFile)
{
await GetContainerAndExecute(async container =>
{
CloudBlockBlob cloudBlockBlob = container.GetBlockBlobReference(validatedFile.FilePath);
await cloudBlockBlob.DownloadToFileAsync(filePayload.DownloadFilePath, FileMode.CreateNew);
return(true);
});
}
public void SetFilePayloadDownloadDetails_WhenInvoked_UploadDetailsAreSet()
{
var filePayload = new FilePayload();
systemUnderTest.SetFilePayloadDownloadDetails(filePayload);
Assert.That(filePayload.UploadPath,
Is.EqualTo($"UploadDirectory\\{dateTime.ToFileTime()}.daily_user_summary.txt.bz2"));
}
public DbParameter CreateErrorMessageParameter(IDatabaseConnectionService databaseConnection,
FileDownloadResult fileDownloadResult)
{
FilePayload filePayload = fileDownloadResult.FilePayload;
string message = errorMessageService.GetErrorMessage(fileDownloadResult.FailedReason, filePayload,
StatsDownloadService.FileDownload);
return(CreateErrorMessageParameter(databaseConnection, message));
}
public MsBuildSolutionPrimitive GetSolutionFromFileBytes(FilePayload localPath)
{
Console.WriteLine($"Caching {localPath.Name}");
var solutionPath = WriteMsBuildItemToDisk(localPath);
var solution = GetSolutionFromLocalPath(solutionPath, localPath.Name);
DeleteMsBuildItemFromDisk(solutionPath);
solution.Name = localPath.Name;
return(solution);
}
public MsBuildProjectPrimitive GetProjectFromFileBytes(FilePayload localPath)
{
Console.WriteLine($"Caching {localPath.Name}");
var projectPath = WriteMsBuildItemToDisk(localPath);
var project = GetProjectFromLocalPath(projectPath, localPath.Name);
DeleteMsBuildItemFromDisk(projectPath);
project.Name = localPath.Name;
return(project);
}
public ParseResults ValidateFile(FilePayload filePayload)
{
fileCompressionService.DecompressFile(filePayload.DownloadFilePath,
filePayload.DecompressedDownloadFilePath);
fileReaderService.ReadFile(filePayload);
ParseResults parseResults = statsFileParserService.Parse(filePayload);
filePayload.FileUtcDateTime = parseResults.DownloadDateTime;
return(parseResults);
}
private FilePayload GenerateFilePayload()
{
var payload = new FilePayload();
payload.TimeoutSeconds = 42;
payload.DownloadUri = new Uri("https://somesite/somefile.ext");
payload.DownloadFilePath = "c:\\path\\to\\file.ext";
payload.AcceptAnySslCert = false;
return(payload);
}
public MsBuildPublishProfilePrimitive GetPublishProfileFromFileBytes(FilePayload localPath)
{
Console.WriteLine($"Caching {localPath.Name}");
var publishProfilePath = WriteMsBuildItemToDisk(localPath);
var publishProfile = GetPublishProfileFromLocalPath(publishProfilePath, localPath.Name);
DeleteMsBuildItemFromDisk(publishProfilePath);
publishProfile.Name = localPath.Name;
return(publishProfile);
}
private void SetDecompressedDownloadFileDetails(FilePayload filePayload, DateTime dateTime,
string downloadDirectory)
{
string decompressedFileName = $"{dateTime.ToFileTime()}.{Constants.FilePayload.DecompressedFileName}";
filePayload.DecompressedDownloadDirectory = downloadDirectory;
filePayload.DecompressedDownloadFileName = decompressedFileName;
filePayload.DecompressedDownloadFileExtension = Constants.FilePayload.DecompressedFileExtension;
filePayload.DecompressedDownloadFilePath = Path.Combine(downloadDirectory,
$"{decompressedFileName}.{Constants.FilePayload.DecompressedFileExtension}");
}
public ParseResults Parse(FilePayload filePayload)
{
ParseResults results = innerService.Parse(filePayload);
if (settingsService.IsOneHundredUsersFilterEnabled())
{
return(new ParseResults(results.DownloadDateTime, results.UsersData.Take(100), results.FailedUsersData));
}
return(results);
}
private bool IsFileDownloadReadyToRun(FilePayload filePayload, out FailedReason failedReason)
{
if (IsMinimumWaitTimeNotMet(filePayload))
{
failedReason = FailedReason.MinimumWaitTimeNotMet;
return(false);
}
failedReason = FailedReason.None;
return(true);
}
public string GetErrorMessage(FailedReason failedReason, FilePayload filePayload, StatsDownloadService service)
{
if (failedReason == FailedReason.MinimumWaitTimeNotMet)
{
TimeSpan minimumWaitTimeSpan = MinimumWait.TimeSpan;
TimeSpan configuredWaitTime = filePayload.MinimumWaitTimeSpan;
return(string.Format(ErrorMessages.MinimumWaitTimeNotMet, minimumWaitTimeSpan, configuredWaitTime));
}
return(GetErrorMessage(failedReason, service));
}
public void SetFilePayloadDownloadDetails_WhenInvoked_DownloadDetailsAreSet()
{
var filePayload = new FilePayload();
systemUnderTest.SetFilePayloadDownloadDetails(filePayload);
Assert.That(filePayload.DownloadUri.AbsoluteUri, Is.EqualTo("http://localhost/"));
Assert.That(filePayload.TimeoutSeconds, Is.EqualTo(123));
Assert.That(filePayload.AcceptAnySslCert, Is.EqualTo(true));
Assert.That(filePayload.MinimumWaitTimeSpan, Is.EqualTo(timeSpan));
}
private FileDownloadResult HandleException(Exception exception, FilePayload filePayload)
{
FileDownloadResult exceptionResult = NewFailedFileDownloadResult(exception, filePayload);
LogResult(exceptionResult);
LogException(exception);
UpdateToError(exceptionResult);
Cleanup(exceptionResult);
SendEmail(exceptionResult);
return(exceptionResult);
}
private async Task <FileDownloadResult> HandleSuccessAndUpload(FilePayload filePayload)
{
LogVerbose($"Stats file download completed: {DateTimeNow()}");
await UploadFile(filePayload);
FileDownloadResult successResult = NewSuccessFileDownloadResult(filePayload);
Cleanup(successResult);
LogResult(successResult);
return(successResult);
}
public void SendEmail_WhenInvokedWithFileDownloadResult_SendsEmail()
{
var filePayload = new FilePayload();
errorMessageServiceMock.GetErrorMessage(FailedReason.UnexpectedException, filePayload,
StatsDownloadService.FileDownload).Returns("ErrorMessage");
systemUnderTest.SendEmail(new FileDownloadResult(FailedReason.UnexpectedException, filePayload));
emailServiceMock.Received().SendEmail("DisplayName - File Download Failed", "ErrorMessage");
}
public void SetUp()
{
databaseConnectionServiceMock = Substitute.For <IDatabaseConnectionService>();
statsDownloadDatabaseServiceMock = Substitute.For <IStatsDownloadDatabaseService>();
statsDownloadDatabaseServiceMock.When(service =>
service.CreateDatabaseConnectionAndExecuteAction(
Arg.Any <Action <IDatabaseConnectionService> >())).Do(callInfo =>
{
var service = callInfo.Arg <Action <IDatabaseConnectionService> >();
service.Invoke(databaseConnectionServiceMock);
});
statsDownloadDatabaseParameterServiceMock = Substitute.For <IStatsDownloadDatabaseParameterService>();
loggingServiceMock = Substitute.For <ILoggingService>();
systemUnderTest = NewFileDownloadDatabaseProvider(statsDownloadDatabaseServiceMock,
statsDownloadDatabaseParameterServiceMock, loggingServiceMock);
DatabaseProviderTestingHelper.SetUpDatabaseConnectionServiceReturns(databaseConnectionServiceMock);
filePayload = new FilePayload
{
DownloadId = 100,
UploadPath = "UploadPath",
DownloadFileName = "DownloadFileName",
DownloadFileExtension = "DownloadFileExtension",
FileUtcDateTime = DateTime.Today
};
fileDownloadResult = new FileDownloadResult(filePayload);
dbDataReaderMock = Substitute.For <DbDataReader>();
dbDataReaderMock.Read().Returns(true, true, true, false);
dbDataReaderMock.GetInt32(0).Returns(100, 200, 300);
databaseConnectionServiceMock
.ExecuteReader("SELECT DownloadId FROM [FoldingCoin].[DownloadsReadyForUpload]")
.Returns(dbDataReaderMock);
downloadIdParameterMock = Substitute.For <DbParameter>();
downloadIdParameterMock.Value.Returns(100);
statsDownloadDatabaseParameterServiceMock.CreateDownloadIdParameter(databaseConnectionServiceMock, 100)
.Returns(downloadIdParameterMock);
statsDownloadDatabaseParameterServiceMock.CreateDownloadIdParameter(databaseConnectionServiceMock)
.Returns(downloadIdParameterMock);
statsDownloadDatabaseParameterServiceMock
.CreateDownloadIdParameter(databaseConnectionServiceMock, ParameterDirection.Output)
.Returns(downloadIdParameterMock);
errorMessageParameterMock = Substitute.For <DbParameter>();
}
SetFilePayloadDownloadDetails_WhenDownloadDirectoryDoesNotExist_ThrowsFileDownloadArgumentException()
{
downloadSettingsValidatorServiceMock.IsValidDownloadDirectory("DownloadDirectory").Returns(false);
var filePayload = new FilePayload();
var actual =
Assert.Throws <FileDownloadArgumentException>(() => InvokeSetFilePayloadDownloadDetails(filePayload));
Assert.That(actual.Message, Is.EqualTo("Download directory is invalid"));
}
public ParseResults Parse(FilePayload filePayload)
{
ParseResults results = innerService.Parse(filePayload);
if (settings.Enabled)
{
return(new ParseResults(results.DownloadDateTime,
results.UsersData.Where(data => !string.IsNullOrWhiteSpace(data.Name)), results.FailedUsersData));
}
return(results);
}
