public static IServiceCollection AddQuery <TQuery, TResult, TQueryHandler>(this IServiceCollection source)
where TQuery : IQuery <TResult>
where TQueryHandler : class, IQueryHandler <TQuery, TResult>
{
AssertArguments.NotNull(source, nameof(source));
return(source.AddScoped <IQueryHandler <TQuery, TResult>, TQueryHandler>());
}
public virtual void ArgumentNullConstructorTest()
{
AssertArguments.ThrowsWhenNullConstructor(
this.client.GetType(),
new[] { typeof(IConnection), typeof(IGw2Client) },
new object[] { new Connection(), new Gw2Client() },
new[] { true, true });
}
public override void ArgumentNullConstructorTest()
{
AssertArguments.ThrowsWhenNullConstructor(
this.Client.GetType(),
new[] { typeof(IConnection), typeof(IGw2Client), typeof(Guid) },
new object[] { new Connection(), new Gw2Client(), Guid.Parse("11111111-2222-3333-4444-abcdeffedcba") },
new[] { true, true, false });
}
public override void ArgumentNullConstructorTest()
{
AssertArguments.ThrowsWhenNullConstructor(
this.Client.GetType(),
new[] { typeof(IConnection), typeof(IGw2Client), typeof(int) },
new object[] { new Connection(), new Gw2Client(), 1 },
new[] { true, true, false });
}
public virtual void ArgumentNullConstructorTest()
{
AssertArguments.ThrowsWhenNullConstructor(
typeof(DefaultEndpointClientImplementation <TestBaseObject>),
new[] { typeof(IEndpointClient), typeof(IConnection), typeof(IGw2Client) },
new object[] { Substitute.For <IEndpointClient>(), new Connection(), new Gw2Client() },
new[] { true, true, true });
}
public void ArgumentNullConstructorTest()
{
AssertArguments.ThrowsWhenNull(
() => new CacheItem("test category", "test id", "test item", DateTime.Now),
new[] { true, true, true, false });
AssertArguments.ThrowsWhenNull(
() => new CacheItem <string>("test category", "test id", "test item", DateTime.Now),
new[] { true, true, true, false });
}
public async Task ArgumentNullSetTest()
{
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.SetAsync(new CacheItem <object>("Test category", "test", new object(), DateTime.Now)),
new[] { true });
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.SetAsync("Test category", "test", new object(), DateTime.Now),
new[] { true, true, false, false });
}
public virtual async Task <PaginatedResult <TResult> > ExecuteAsync(TQuery query)
{
AssertArguments.NotNull(query, nameof(query));
var unfilteredQuery = ExecuteCore(query);
var filteredQuery = unfilteredQuery
.Skip(query.Skip)
.Take(query.Limit);
return(new PaginatedResult <TResult>(
query.Skip,
query.Limit,
await unfilteredQuery.CountAsync(),
await filteredQuery.ToArrayAsync()
));
}
public virtual async Task <TResult> ProcessAsync <TResult>(IQuery <TResult> query)
{
AssertArguments.NotNull(query, nameof(query));
// finding the query handler by using query type. we will
// throw argument exception when no handler registered for
// specified query type.
var handlerType = typeof(IQueryHandler <,>).MakeGenericType(query.GetType(), typeof(TResult));
// TODO: using service provider to resolve query handler dependencies.
var handler = ServiceProvider.GetService(handlerType) as IQueryHandler <TResult>;
AssertArguments.IsTrue(
handler != null,
$"'{handlerType.Name}' is not a valid query handler type.",
"query"
);
return(await handler.ExecuteAsync(query));
}
public async Task ArgumentNullGetOrUpdateTest() =>
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.GetOrUpdateAsync("Test category", "test", DateTime.Now, () => Task.FromResult(new object())),
new[] { true, true, false, true });
public async Task ArgumentNullSetManyTest() =>
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.SetManyAsync(new List <CacheItem <object> >()),
new[] { true });
public async Task ArgumentNullGetManyTest() =>
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.GetManyAsync <object>("Test category", Array.Empty <string>()),
new[] { true, true });
public async Task ArgumentNullGetTest() =>
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.TryGetAsync <object>("Test category", "test"),
new[] { true, true });
public SalesUnitQueryHandler(DreamlinesContext context)
{
AssertArguments.NotNull(context, nameof(context));
Context = context;
}
public async Task ArgumentNullGetOrUpdateManyTest() =>
await AssertArguments.ThrowsWhenNullAsync(
() => this.cacheMethod.GetOrUpdateManyAsync("Test category", new List <string>(), DateTime.Now, obj => Task.FromResult((IDictionary <string, object>) new Dictionary <string, object>())),
new[] { true, true, false, true });
public BookingQueryHandler(DreamlinesContext dbContext)
{
AssertArguments.NotNull(dbContext, nameof(dbContext));
Context = dbContext;
}
public DefaultQueryProcessor(IServiceProvider serviceProvider)
{
AssertArguments.NotNull(serviceProvider, nameof(serviceProvider));
ServiceProvider = serviceProvider;
}
public void ConstructorEmptyStringFileNameTest()
{
AssertArguments.ThrowsWhenEmptyStringConstructor(typeof(ArchiveCacheMethod), new[] { typeof(string) }, new[] { "test" }, new[] { true });
}
public void ArgumentNullConstructorTest()
{
AssertArguments.ThrowsWhenNull(
() => new CacheItem("test category", "test id", "test item", HttpStatusCode.OK, DateTime.Now, CacheItemStatus.New, null),
new[] { true, true, true, false, false, false, false });
}
