public async Task VerifyEvents()
{
var listener = new TestListener();
var observer = new TestObserver(listener);
using (DiagnosticListener.AllListeners.Subscribe(observer))
{
// arrange
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, FetchDataAsync);
var errorLoader = new DataLoader <string, string>(
batchScheduler,
(keys, cancellationToken) =>
throw new Exception("BatchError: Foo"));
// act
var tasks = new Task[]
{
Catch(() => loader.LoadAsync("Foo")),
Catch(() => loader.LoadAsync("Foo", "Bar")),
Catch(() => loader.LoadAsync("Bar", "Baz")),
Catch(() => loader.LoadAsync("Qux")),
Catch(() => errorLoader.LoadAsync("Foo"))
};
batchScheduler.Dispatch();
await Task.WhenAll(tasks).ConfigureAwait(false);
// assert
listener.MatchSnapshot();
}
}
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 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 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);
}
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 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 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 async Task LoadSingleResultTwice()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>("Bar");
var batchScheduler = new DelayDispatcher();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var key = "Foo";
// first load.
(await loader.LoadAsync(key)).MatchSnapshot();
// act
var result = await loader.LoadAsync(key);
// assert
result.MatchSnapshot();
}
public async Task LoadCollectionResultTwice()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>("Bar");
var batchScheduler = new DelayDispatcher();
var loader = new DataLoader <string, string>(
fetch,
batchScheduler);
var keys = new List <string> {
"Foo"
};
(await loader.LoadAsync(keys, CancellationToken.None)).MatchSnapshot();
// act
IReadOnlyList <string> result = await loader.LoadAsync(keys, CancellationToken.None);
// assert
result.MatchSnapshot();
}
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 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 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 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 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 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 async Task ExecuteBatchRequest()
{
var listener = new DispatchingListener();
var observer = new DispatchingObserver(listener);
using (DiagnosticListener.AllListeners.Subscribe(observer))
{
// arrange
FetchDataDelegate <string, string> fetch = async keys =>
{
var error = new Exception("Quux");
return(await Task.FromResult(new[]
{
Result <string> .Reject(error)
}).ConfigureAwait(false));
};
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
// act
try
{
await loader.LoadAsync("Foo").ConfigureAwait(false);
}
catch
{
}
// assert
Assert.Collection(listener.Keys,
(key) => Assert.Equal("Foo", key));
Assert.Collection(listener.Values,
(item) =>
{
Assert.Equal("Foo", item.Key);
Assert.True(item.Value.IsError);
Assert.Equal("Quux", item.Value.Error.Message);
});
Assert.Collection(listener.Errors,
(item) =>
{
Assert.Equal("Foo", item.Key);
Assert.Equal("Quux", item.Value.Message);
});
}
}
public void IDataLoaderLoadSingleNoException()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>("Bar");
var options = new DataLoaderOptions <string>();
IDataLoader loader = new DataLoader <string, string>(
options,
fetch);
var key = "Foo";
// act
Action verify = () => loader.LoadAsync(key);
// assert
Assert.Null(Record.Exception(verify));
}
public async Task LoadCollectionZeroKeys()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
var keys = new List <string>();
// act
Task <IReadOnlyList <string> > loadResult = loader.LoadAsync(keys);
// assert
await Task.Delay(25);
batchScheduler.Dispatch();
Assert.Empty(await loadResult);
}
public async Task SetNewCacheEntry()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var key = "Foo";
var value = "Bar";
// act
loader.Set(key, value);
// assert
var loadResult = await loader.LoadAsync(key).ConfigureAwait(false);
Assert.Equal(value, loadResult);
}
public async Task LoadSingleResult()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>("Bar");
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var key = "Foo";
// act
Task <string> loadResult = loader.LoadAsync(key);
// assert
await Task.Delay(25);
batchScheduler.Dispatch();
(await loadResult).MatchSnapshot();
}
public async Task LoadSingleKeyNull()
{
// arrange
FetchDataDelegate <string, string> fetch = async keys =>
await Task.FromResult(new IResult <string> [0])
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
string key = null;
// act
Func <Task <string> > verify = () => loader.LoadAsync(key);
// assert
await Assert.ThrowsAsync <ArgumentNullException>("key", verify)
.ConfigureAwait(false);
}
public async Task IDataLoaderLoadParamsResult()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>("Bar");
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
var keys = new object[] { "Foo" };
// act
Task <IReadOnlyList <object> > loadResult = loader.LoadAsync(keys);
// assert
await Task.Delay(25);
batchScheduler.Dispatch();
(await loadResult).MatchSnapshot();
}
public async Task IDataLoaderLoadSingleResult()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>("Bar");
var batchScheduler = new ManualBatchScheduler();
IDataLoader loader = new DataLoader <string, string>(batchScheduler, fetch);
object key = "Foo";
// act
Task <object> loadResult = loader.LoadAsync(key);
// assert
await Task.Delay(25);
batchScheduler.Dispatch();
(await loadResult).MatchSnapshot();
}
public async Task LoadCollectionResult()
{
// arrange
FetchDataDelegate <string, string> fetch = CreateFetch <string, string>("Bar");
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var keys = new List <string> {
"Foo"
};
// act
Task <IReadOnlyList <string> > loadResult = loader.LoadAsync(keys, CancellationToken.None);
batchScheduler.Dispatch();
// assert
(await loadResult).MatchSnapshot();
}
public async Task LoadAutoDispatching()
{
// arrange
var expectedResult = Result <string> .Resolve("Bar");
var repository = new Dictionary <string, string>
{
{ "Foo", "Bar" },
{ "Bar", "Baz" },
{ "Baz", "Foo" }
};
FetchDataDelegate <string, string> fetch = async k =>
{
var values = new List <IResult <string> >();
foreach (var key in k)
{
if (repository.ContainsKey(key))
{
values.Add(Result <string> .Resolve(repository[key]));
}
else
{
var error = new Exception($"Value for key \"{key}\" " +
"not found");
values.Add(Result <string> .Reject(error));
}
}
return(await Task.FromResult(values).ConfigureAwait(false));
};
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
var keys = new List <string> {
"Foo", "Bar", "Baz", "Qux"
};
// act
Func <Task> verify = () => loader.LoadAsync(keys);
// assert
await Assert.ThrowsAsync <Exception>(verify).ConfigureAwait(false);
}
public async Task LoadKeyAndValueCountNotEquel()
{
// arrange
InvalidOperationException expectedException = Errors
.CreateKeysAndValuesMustMatch(4, 3);
Result <string> expectedResult = "Bar";
var repository = new Dictionary <string, string>
{
{ "Foo", "Bar" },
{ "Bar", "Baz" },
{ "Baz", "Foo" }
};
FetchDataDelegate <string, string> fetch =
async(keys, cancellationToken) =>
{
var values = new List <Result <string> >();
foreach (var key in keys)
{
if (repository.ContainsKey(key))
{
values.Add(repository[key]);
}
}
return(await Task.FromResult(values));
};
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(batchScheduler, fetch);
var requestKeys = new [] { "Foo", "Bar", "Baz", "Qux" };
// act
Func <Task> verify = () => loader.LoadAsync(requestKeys);
// assert
Task <InvalidOperationException> task = Assert
.ThrowsAsync <InvalidOperationException>(verify);
batchScheduler.Dispatch();
InvalidOperationException actualException = await task;
Assert.Equal(expectedException.Message, actualException.Message);
}
public async Task LoadCollectionZeroKeys()
{
// arrange
FetchDataDelegate <string, string> fetch = async k =>
await Task.FromResult(new IResult <string> [0])
.ConfigureAwait(false);
var options = new DataLoaderOptions <string>();
var loader = new DataLoader <string, string>(options, fetch);
var keys = new List <string>();
// act
Func <Task <IReadOnlyList <string> > > verify = () =>
loader.LoadAsync(keys);
// assert
await Assert.ThrowsAsync <ArgumentOutOfRangeException>("keys",
verify).ConfigureAwait(false);
}
public async Task SetTwice()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers.CreateFetch <string, string>();
var batchScheduler = new ManualBatchScheduler();
var loader = new DataLoader <string, string>(fetch, batchScheduler);
var key = "Foo";
var first = "Bar";
var second = "Baz";
// act
loader.Set(key, first);
loader.Set(key, second);
// assert
var loadResult = await loader.LoadAsync(key).ConfigureAwait(false);
Assert.Equal(first, loadResult);
}
public async Task IDataLoaderSetNewCacheEntry()
{
// arrange
FetchDataDelegate <string, string> fetch = TestHelpers
.CreateFetch <string, string>();
var options = new DataLoaderOptions <string>();
IDataLoader loader = new DataLoader <string, string>(
options,
fetch);
var key = "Foo";
var value = "Bar";
// act
loader.Set(key, value);
// assert
var loadResult = await loader.LoadAsync(key).ConfigureAwait(false);
Assert.Equal(value, loadResult);
}
public async Task IDataLoaderLoadSingleErrorResult()
{
// 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
Func <Task <object> > verify = () => loader.LoadAsync(key);
// assert
Task <InvalidOperationException> task = Assert
.ThrowsAsync <InvalidOperationException>(verify);
await Task.Delay(25);
batchScheduler.Dispatch();
await task;
}
