public async Task QueryAsync_WhenExportDataWasReturned_ReturnsCsvContentInByteArray()
{
int numberOfColumns = _random.Next(5, 10);
IQueryHandler <IExportQuery, byte[]> sut = CreateSut(numberOfColumns: numberOfColumns);
byte[] result = await sut.QueryAsync(CreateExportQuery());
Regex allowCsvContentRegularExpression = GetAllowCsvContentRegularExpression(numberOfColumns);
await using MemoryStream memoryStream = new MemoryStream(result);
using StreamReader streamReader = new StreamReader(memoryStream, Encoding.UTF8);
string headerContent = await streamReader.ReadLineAsync();
Assert.That(allowCsvContentRegularExpression.IsMatch(headerContent ?? string.Empty), Is.True);
while (streamReader.EndOfStream == false)
{
string dataContent = await streamReader.ReadLineAsync();
Assert.That(allowCsvContentRegularExpression.IsMatch(dataContent ?? string.Empty), Is.True);
}
streamReader.Close();
}
public Task <TResult> QueryAsync <TQuery, TResult>(TQuery query) where TQuery : IQuery
{
NullGuard.NotNull(query, nameof(query));
return(Task.Run(async() =>
{
try
{
IQueryHandler <TQuery, TResult> queryHandler = _queryHandlers.OfType <IQueryHandler <TQuery, TResult> >().SingleOrDefault();
if (queryHandler == null)
{
throw new IntranetExceptionBuilder(ErrorCode.NoQueryHandlerSupportingQuery, query.GetType().Name, typeof(TResult).Name).Build();
}
return await queryHandler.QueryAsync(query);
}
catch (IntranetExceptionBase)
{
throw;
}
catch (AggregateException aggregateException)
{
throw Handle(aggregateException, innerException => new IntranetExceptionBuilder(ErrorCode.ErrorWhileQueryingQuery, query.GetType().Name, typeof(TResult).Name, innerException.Message).WithInnerException(innerException));
}
catch (Exception ex)
{
throw new IntranetExceptionBuilder(ErrorCode.ErrorWhileQueryingQuery, query.GetType().Name, typeof(TResult).Name, ex.Message)
.WithInnerException(ex)
.Build();
}
}));
}
public async Task QueryAsync_WhenExportDataWasReturned_AssertDisposeWasNotCalledOnExportDataContentBuilder()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
await sut.QueryAsync(CreateExportQuery());
_exportDataContentBuilderMock.Verify(m => m.Dispose(), Times.Once);
}
public async Task QueryAsync_WhenExportDataWasReturned_ReturnsNotNull()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
byte[] result = await sut.QueryAsync(CreateExportQuery());
Assert.That(result, Is.Not.Null);
}
public async Task QueryAsync_WhenNoExportDataWasReturned_AssertWithContentAsyncWasNotCalledOnExportDataContentBuilder()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut(false);
await sut.QueryAsync(CreateExportQuery());
_exportDataContentBuilderMock.Verify(m => m.WithContentAsync(It.IsAny <IExportQuery>(), It.IsAny <string>()), Times.Never);
}
public async Task QueryAsync_WhenCalled_AssertGetExportDataAsyncWasCalledOnExportToCsvQueryHandlerBase()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
await sut.QueryAsync(CreateExportQuery());
Assert.That(((MyExportToCsvQueryHandler)sut).GetExportDataAsyncWasCalled, Is.True);
}
public async Task QueryAsync_WhenNoExportDataWasReturned_ReturnsEmptyByteArray()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut(false);
byte[] result = await sut.QueryAsync(CreateExportQuery());
Assert.That(result.Length, Is.EqualTo(0));
}
public async Task QueryAsync_WhenExportDataWasReturned_ReturnsNonEmptyByteArray()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
byte[] result = await sut.QueryAsync(CreateExportQuery());
Assert.That(result.Length, Is.GreaterThan(0));
}
public async Task QueryAsync_WhenNoExportDataWasReturned_AssertCreateExportDataContentBuilderAsyncWasNotCalledOnExportQueryHandlerBaseWithExportQuery()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut(false);
await sut.QueryAsync(CreateExportQuery());
Assert.That(((MyExportQueryHandler)sut).CreateExportDataContentBuilderAsyncWasCalled, Is.False);
}
public async Task QueryAsync_WhenExportDataWasReturned_ReturnsByteArray()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
byte[] result = await sut.QueryAsync(CreateExportQuery());
Assert.That(result, Is.TypeOf <byte[]>());
}
public async Task QueryAsync_WhenExportDataWasReturned_AssertWithFooterAsyncWasCalledOnExportDataContentBuilder()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
IExportQuery query = CreateExportQuery();
await sut.QueryAsync(query);
_exportDataContentBuilderMock.Verify(m => m.WithFooterAsync(It.Is <IExportQuery>(value => value != null && value == query)), Times.Once);
}
public async Task QueryAsync_WhenExportDataWasReturned_ReturnsBuildAsyncResultFromExportDataContentBuilder()
{
byte[] exportDataContent = _fixture.CreateMany <byte>(_random.Next(1024, 4096)).ToArray();
IQueryHandler <IExportQuery, byte[]> sut = CreateSut(exportDataContent: exportDataContent);
byte[] result = await sut.QueryAsync(CreateExportQuery());
Assert.That(result, Is.EqualTo(exportDataContent));
}
public async Task QueryAsync_WhenCalled_AssertGetExportDataAsyncWasCalledOnExportToCsvQueryHandlerBaseWithExportQuery()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
IExportQuery query = CreateExportQuery();
await sut.QueryAsync(query);
Assert.That(((MyExportToCsvQueryHandler)sut).GetExportDataAsyncExportQuery, Is.EqualTo(query));
}
public async Task QueryAsync_WhenExportDataWasReturned_AssertWithContentAsyncWasCalledOnExportDataContentBuilder()
{
string exportData = _fixture.Create <string>();
IQueryHandler <IExportQuery, byte[]> sut = CreateSut(exportData: exportData);
IExportQuery query = CreateExportQuery();
await sut.QueryAsync(query);
_exportDataContentBuilderMock.Verify(m => m.WithContentAsync(
It.Is <IExportQuery>(value => value != null && value == query),
It.Is <string>(value => string.CompareOrdinal(value, exportData) == 0)),
Times.Once);
}
public async Task <IReadOnlyList <Epic> > QueryAsync(GetEpicsQuery query)
{
var results = await GetRequestAsync($"/rest/agile/1.0/board/{query.BoardId}/epic");
var epics = _epicResultsResolver.Resolve(results);
foreach (var epic in epics)
{
var userStoryResults = await _userStoriesQueryHandler.QueryAsync(new GetUserStoriesQuery { EpicId = epic.Id });
epic.SubEntities = userStoryResults;
}
return(epics);
}
protected override Task <IEnumerable <IContact> > GetExportDataAsync(IExportContactCollectionQuery query)
{
NullGuard.NotNull(query, nameof(query));
return(_getContactCollectionQueryHandler.QueryAsync(query.ToGetContactCollectionQuery()));
}
public async Task <IQueryResult <CompanyQueryModel> > QueryAsync(
IQueryOptions options) =>
await _queryHandler.QueryAsync(options ?? new QueryOptions());
QueryLocationsAsync(int companyId, IQueryOptions options) =>
await _locationQueryHandler.QueryAsync(
options, l => l.CompanyId == companyId);
QueryEmployeesAsync(int companyId, IQueryOptions options) =>
await _employeeQueryHandler.QueryAsync(
options, e => e.Location.CompanyId == companyId);
public void QueryAsync_WhenQueryIsNull_ThrowsArgumentNullException()
{
IQueryHandler <IExportQuery, byte[]> sut = CreateSut();
ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.QueryAsync(null));
Assert.That(result.ParamName, Is.EqualTo("query"));
}
public async Task <IQueryResult <EmployeeQueryModel> > QueryAsync(
IQueryOptions options) =>
await _queryHandler.QueryAsync(options);
QueryEmployeesAsync(int locationId, IQueryOptions options) =>
await _employeeQueryHandler.QueryAsync(
options, e => e.LocationId == locationId);
