public async Task ThenReturnTheCreatedAssets(string input)
{
var createAssetResponse = new CreateAssetResponse
{
Asset = new AssetOutputModel
{
Address = input
}
};
_mockBulkCreateAssetUseCase
.Setup(s => s.ExecuteAsync(It.IsAny <IList <CreateAssetRequest> >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <CreateAssetResponse> {
createAssetResponse
});
var request = new ImportAssetsRequest
{
AssetLines = new List <string> {
input
}
};
var results = await _classUnderTest.ExecuteAsync(request, CancellationToken.None).ConfigureAwait(false);
var createdAsset = results.AssetsImported[0];
createdAsset.Address.Should().BeEquivalentTo(input);
}
public async Task <ImportAssetsResponse> ExecuteAsync(ImportAssetsRequest requests, CancellationToken cancellationToken)
{
Console.WriteLine($"{DateTime.UtcNow.TimeOfDay.ToString("g")}: Start Creating asset Requests");
List <CreateAssetRequest> createAssetRequests = new List <CreateAssetRequest>();
for (int i = 0; i < requests.AssetLines.Count; i++)
{
var requestAssetLine = requests.AssetLines.ElementAtOrDefault(i);
var createAssetRequest = CreateAssetForLine(requests, cancellationToken, requestAssetLine);
createAssetRequests.Add(createAssetRequest);
Console.WriteLine($"{DateTime.UtcNow.TimeOfDay.ToString("g")}: Creating asset Request: {i} of {requests.AssetLines.Count}");
}
Console.WriteLine($"{DateTime.UtcNow.TimeOfDay.ToString("g")}: Finished Creating asset Requests");
Console.WriteLine($"{DateTime.UtcNow.TimeOfDay.ToString("g")}: Start Creating AssetRegisterVersion");
var responses = await _createAssetRegisterVersionUseCase.ExecuteAsync(createAssetRequests, cancellationToken).ConfigureAwait(false);
Console.WriteLine($"{DateTime.UtcNow.TimeOfDay.ToString("g")}: Finished Creating AssetRegisterVersion");
ImportAssetsResponse response = new ImportAssetsResponse
{
AssetsImported = responses.Select(s => s.Asset).ToList()
};
return(response);
}
private CreateAssetRequest CreateAssetForLine(ImportAssetsRequest request, CancellationToken cancellationToken, string requestAssetLine)
{
CsvAsset csvAsset = new CsvAsset
{
CsvLine = requestAssetLine,
Delimiter = request.Delimiter
};
CreateAssetRequest createAssetRequest = _createAssetRequestFactory.Create(csvAsset);
return(createAssetRequest);
}
public async Task ThenCallTheFactoryWithTheCorrectInput(string input)
{
StubCreateAssetUseCase();
var request = new ImportAssetsRequest
{
AssetLines = new List <string> {
input
}
};
await _classUnderTest.ExecuteAsync(request, CancellationToken.None).ConfigureAwait(false);
_mockCreateAssetFactory.Verify(v => v.Create(It.Is <CsvAsset>(req => req.CsvLine == input)));
}
private async Task <ImportAssetsRequest> CreateSaveAssetRegisterFileRequest(IList <IFormFile> files)
{
var memoryStream = new MemoryStream();
await files[0].CopyToAsync(memoryStream, _backgroundProcessor.GetCancellationToken()).ConfigureAwait(false);
var text = Encoding.UTF8.GetString(memoryStream.GetBuffer());
var assetLines = _textSplitter.SplitIntoLines(text);
var importAssetsRequest = new ImportAssetsRequest
{
Delimiter = ";",
AssetLines = assetLines,
FileName = files[0]?.FileName
};
return(importAssetsRequest);
}
public void GivenValidInput_ThenIsValidIsTrue(string csvLines, string delimiter)
{
//arrange
var request = new ImportAssetsRequest
{
Delimiter = delimiter,
AssetLines = new List <string> {
csvLines
}
};
//act
var response = _classUnderTest.Validate(request);
//assert
response.Should().NotBeNull();
response.IsValid.Should().BeTrue();
}
public async Task ThenCallTheCreateAssetUseCaseWithTheResultFromTheFactory(string input)
{
StubCreateAssetUseCase();
StubFactoryWithAddress(input, input);
var request = new ImportAssetsRequest
{
AssetLines = new List <string> {
input
}
};
await _classUnderTest.ExecuteAsync(request, CancellationToken.None).ConfigureAwait(false);
_mockBulkCreateAssetUseCase.Verify(v =>
v.ExecuteAsync(It.Is <IList <CreateAssetRequest> >(req => req[0].Address.Equals(input)),
It.IsAny <CancellationToken>()));
}
public async Task ThenWeReturnAListOfTheCreatedAssets(string inputOne, string inputTwo)
{
StubCreateAssetUseCaseWithAddress(inputOne, inputTwo);
StubFactoryWithAddress(inputOne, inputOne);
StubFactoryWithAddress(inputTwo, inputTwo);
var request = new ImportAssetsRequest
{
AssetLines = new List <string> {
inputOne, inputTwo
}
};
var response = await _classUnderTest.ExecuteAsync(request, CancellationToken.None).ConfigureAwait(false);
var createdAssets = response.AssetsImported;
createdAssets[0].Address.Should().BeEquivalentTo(inputOne);
createdAssets[1].Address.Should().BeEquivalentTo(inputTwo);
}
public async Task <IList <AssetOutputModel> > ProcessAsync(string[] args)
{
ValidateConsoleInput(args);
var parsedInput = _inputParser.Parse(args);
var cancellationTokenSource = new CancellationTokenSource();
var text = await _fileReader.ReadAsync(parsedInput.FilePath, cancellationTokenSource.Token).ConfigureAwait(false);
var csvLines = _textSplitter.SplitIntoLines(text);
var importAssetsRequest = new ImportAssetsRequest
{
Delimiter = parsedInput.Delimiter,
AssetLines = csvLines
};
var response = await _importAssetsUseCase.ExecuteAsync(importAssetsRequest, cancellationTokenSource.Token).ConfigureAwait(false);
return(response?.AssetsImported);
}
public void GivenInValidRequest_ThenIsValidIsFalse(string csvLines, string delimiter)
{
//arrange
IList <string> csvLinesList = null;
if (!string.IsNullOrEmpty(csvLines))
{
csvLinesList = new List <string>();
}
var request = new ImportAssetsRequest
{
Delimiter = delimiter,
AssetLines = csvLinesList
};
//act
var response = _classUnderTest.Validate(request);
//assert
response.Should().NotBeNull();
response.IsValid.Should().BeFalse();
response.Errors.Should().NotBeNullOrEmpty();
}
