public async Task DispatchAsyncNoBatching()
{
// arrange
IResult <string> expectedResult = Result <string> .Resolve("Bar");
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new[] { expectedResult })
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>
{
Batching = false
};
var loader = new DataLoader <string, string>(options, fetch);
// this would block if batching would be enabled
var loadResult = await loader.LoadAsync("Foo")
.ConfigureAwait(false);
// act
await loader.DispatchAsync().ConfigureAwait(false);
// assert
Assert.Equal(expectedResult.Value, loadResult);
}
public async Task DispatchAsyncAuto()
{
// arrange
IResult <string> expectedResult = Result <string> .Resolve("Bar");
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new[] { expectedResult })
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>
{
BatchRequestDelay = TimeSpan.FromMinutes(10)
};
var loader = new DataLoader <string, string>(options, fetch);
await Task.Delay(10);
Task <string> loadResult = loader.LoadAsync("Foo");
// act
await loader.DispatchAsync().ConfigureAwait(false);
// assert
Assert.Equal(expectedResult.Value,
await loadResult.ConfigureAwait(false));
}
public async Task LoadCollectionResult()
{
// arrange
var expectedResult = Result <string> .Resolve("Bar");
FetchDataDelegate <string, string> fetch = async k =>
await Task.FromResult(new[] { expectedResult })
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>
{
Batching = false
};
var loader = new DataLoader <string, string>(options, fetch);
var keys = new List <string> {
"Foo"
};
// act
IReadOnlyList <string> loadResult = await loader
.LoadAsync(keys)
.ConfigureAwait(false);
// assert
Assert.Collection(loadResult,
v => Assert.Equal(expectedResult.Value, v));
}
public async Task ClearAllEntries()
{
// arrange
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new IResult <string> [0])
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>
{
Batching = false
};
var loader = new DataLoader <string, string>(options, fetch);
loader.Set("Foo", Task.FromResult("Bar"));
loader.Set("Bar", Task.FromResult("Baz"));
// act
IDataLoader <string, string> result = loader.Clear();
// assert
Func <Task> verify = () => loader.LoadAsync("Foo", "Bar");
Assert.Equal(loader, result);
await Assert.ThrowsAsync <InvalidOperationException>(verify)
.ConfigureAwait(false);
}
public void RemoveEntry()
{
// arrange
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new IResult <string> [0])
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>
{
Batching = false
};
var loader = new DataLoader <string, string>(options, fetch);
var key = "Foo";
loader.Set(key, Task.FromResult("Bar"));
// act
IDataLoader <string, string> result = loader.Remove(key);
// assert
Task <string> loadResult = loader.LoadAsync(key);
if (loadResult is IAsyncResult asyncResult)
{
asyncResult.AsyncWaitHandle.WaitOne();
}
Assert.Equal(loader, result);
Assert.NotNull(loadResult.Exception);
}
public async Task DispatchAsyncKeysValuesNotMatching()
{
// arrange
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new IResult <string> [0])
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>
{
BatchRequestDelay = TimeSpan.FromMinutes(10)
};
var loader = new DataLoader <string, string>(options, fetch);
await Task.Delay(10);
Task <IReadOnlyList <string> > loadResult = loader.LoadAsync("Foo", "Bar");
await loader.DispatchAsync().ConfigureAwait(false);
// act
Func <Task> verify = () => loadResult;
// assert
await Assert.ThrowsAsync <InvalidOperationException>(verify)
.ConfigureAwait(false);
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="DataLoader{TKey, TValue}"/> class.
/// </summary>
/// <param name="options">
/// An options object to configure the behavior of this particular
/// <see cref="DataLoader{TKey, TValue}"/>.
/// </param>
/// <param name="fetch">
/// A delegate to fetch data batches which will be invoked every time
/// when trying to setup a new batch request.
/// </param>
/// <exception cref="ArgumentNullException">
/// Throws if <paramref name="options"/> is <c>null</c>.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Throws if <paramref name="fetch"/> is <c>null</c>.
/// </exception>
public DataLoader(
DataLoaderOptions <TKey> options,
FetchDataDelegate <TKey, TValue> fetch)
: base(options)
{
_fetch = fetch ?? throw new ArgumentNullException(nameof(fetch));
}
public DataLoader(
FetchDataDelegate <TKey, TValue> fetch,
IBatchScheduler batchScheduler,
DataLoaderOptions?options = null)
: base(batchScheduler, options)
{
_fetch = fetch ?? throw new ArgumentNullException(nameof(fetch));
}
public void ConstructorAFetchNull()
{
// arrange
FetchDataDelegate <string, string> fetch = null;
// act
Action verify = () => new DataLoader <string, string>(fetch);
// assert
Assert.Throws <ArgumentNullException>("fetch", verify);
}
public void ConstructorA()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>();
// act
Action verify = () => new EmptyConstructor();
// assert
Assert.Null(Record.Exception(verify));
}
public void ConstructorA()
{
// arrange
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new IResult <string> [0])
.ConfigureAwait(false);
// act
Action verify = () => new EmptyConstructor();
// assert
Assert.Null(Record.Exception(verify));
}
public void DisposeNoExceptionNobatchingAndCaching()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
// act
Action verify = () => loader.Dispose();
// assert
Assert.Null(Record.Exception(verify));
}
public async Task LoadSingleKeyNull()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
// act
Task <string> Verify() => loader.LoadAsync(default(string) !, CancellationToken.None);
// assert
await Assert.ThrowsAsync <ArgumentNullException>("key", Verify);
}
public void DisposeNoExceptionNoBatchingAndCaching()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
// act
void Verify() => loader.Dispose();
// assert
Assert.Null(Record.Exception(Verify));
}
public async Task LoadParamsKeysNull()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
// act
Task <IReadOnlyList <string> > Verify() => loader.LoadAsync(default(string[]) !);
// assert
await Assert.ThrowsAsync <ArgumentNullException>("keys", (Func <Task <IReadOnlyList <string> > >) Verify);
}
public async Task IDataLoaderLoadCollectionZeroKeys()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
var keys = new List <object>();
// act
IReadOnlyList <object> loadResult = await loader.LoadAsync(keys);
// assert
Assert.Empty(loadResult);
}
public async Task LoadSingleKeyNull()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
string key = null;
// act
Func <Task <string> > verify = () => loader.LoadAsync(key);
// assert
await Assert.ThrowsAsync <ArgumentNullException>("key", verify);
}
public void IDataLoaderLoadCollectionNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>("Bar");
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
// act
Action verify = () => loader.LoadAsync(new List <object>());
// assert
Assert.Null(Record.Exception(verify));
}
public void SetNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var key = "Foo";
// act
void Verify() => loader.Set(key, null !);
// assert
Assert.Throws <ArgumentNullException>(Verify);
}
public void SetKeyNull()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var value = "Bar";
// act
void Verify() => loader.Set(null !, value);
// assert
Assert.Throws <ArgumentNullException>("key", (Action)Verify);
}
public void IDataLoaderRemoveNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
object key = "Foo";
// act
Action verify = () => loader.Remove(key);
// assert
Assert.Null(Record.Exception(verify));
}
public async Task IDataLoaderLoadCollectionKeysNull()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
List <object> keys = null;
// act
Func <Task <IReadOnlyList <object> > > verify = () => loader.LoadAsync(keys);
// assert
await Assert.ThrowsAsync <ArgumentNullException>("keys", verify);
}
public void DispatchAsyncNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>();
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
// act
Action verify = () => loader.DispatchAsync();
// assert
Assert.Null(Record.Exception(verify));
}
public void LoadCollectionNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>("Bar");
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
// act
Action verify = () => loader.LoadAsync(new List <string>());
// assert
Assert.Null(Record.Exception(verify));
}
public void LoadSingleNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>("Bar");
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
var key = "Foo";
// act
Action verify = () => loader.LoadAsync(key);
// assert
Assert.Null(Record.Exception(verify));
}
public void SetKeyNull()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
string key = null;
var value = Task.FromResult("Foo");
// act
Action verify = () => loader.Set(key, value);
// assert
Assert.Throws <ArgumentNullException>("key", verify);
}
public void SetNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
var key = "Foo";
string value = null;
// act
Action verify = () => loader.Set(key, value);
// assert
Assert.Null(Record.Exception(verify));
}
public void IDataLoaderSetNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
object key = "Foo";
Task <object> value = Task.FromResult <object>("Bar");
// act
Action verify = () => loader.Set(key, value);
// assert
Assert.Null(Record.Exception(verify));
}
public void IDataLoaderSetValueNull()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
object key = "Foo";
Task <object> value = null;
// act
Action verify = () => loader.Set(key, value);
// assert
Assert.Throws <ArgumentNullException>("value", verify);
}
public void SetKeyNull()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>();
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
string key = null;
var value = "Bar";
// act
Action verify = () => loader.Set(key, value);
// assert
Assert.Throws <ArgumentNullException>("key", verify);
}
