/// <inheritdoc cref="Track(ITrackingScope, Guid, Action{ITrackingScope, CancellationToken}, CancellationToken)"/>
public static void Track(this ITrackingScope scope, Action <ITrackingScope, CancellationToken> workload, CancellationToken cancellationToken = default)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
scope.CreateAutoTracker(Guid.NewGuid()).Track(workload, cancellationToken);
}
/// <inheritdoc cref="Track(ITrackingScope, Guid, Action{ITrackingScope, CancellationToken}, CancellationToken)"/>
public static void Track(this ITrackingScope scope, Action workload)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
scope.CreateAutoTracker(Guid.NewGuid()).Track(workload);
}
/// <summary>
/// Creates a new manual tracker under this scope with an automatic id.
/// </summary>
/// <param name="scope">The scope under which to create the new tracker.</param>
/// <returns>The new tracker in a stopped state.</returns>
public static IManualTracker CreateManualTracker(this ITrackingScope scope)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
return(scope.CreateManualTracker(Guid.NewGuid()));
}
/// <inheritdoc cref="TrackAsync(ITrackingScope, Guid, Func{ITrackingScope, CancellationToken, Task}, CancellationToken)"/>
public static Task <TResult> TrackAsync <TResult>(this ITrackingScope scope, Guid id, Func <ITrackingScope, CancellationToken, Task <TResult> > workload, CancellationToken cancellationToken = default)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
return(scope.CreateAutoTracker(id).TrackAsync(workload, cancellationToken));
}
/// <inheritdoc cref="TrackAsync(ITrackingScope, Guid, Func{ITrackingScope, CancellationToken, Task}, CancellationToken)"/>
public static Task <TResult> TrackAsync <TResult>(this ITrackingScope scope, Func <Task <TResult> > workload)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
return(scope.CreateAutoTracker(Guid.NewGuid()).TrackAsync(workload));
}
/// <inheritdoc cref="IAutoTracker.Track{TResult}(Func{ITrackingScope, CancellationToken, TResult}, CancellationToken)"/>
public static TResult Track <TResult>(this ITrackingScope scope, Func <ITrackingScope, CancellationToken, TResult> workload, CancellationToken cancellationToken = default)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
return(scope.CreateAutoTracker(Guid.NewGuid()).Track(workload, cancellationToken));
}
/// <inheritdoc cref="TrackAsync(ITrackingScope, Guid, Func{ITrackingScope, CancellationToken, Task}, CancellationToken)"/>
public static Task TrackAsync(this ITrackingScope scope, Guid id, Func <Task> workload)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
return(scope.CreateAutoTracker(id).TrackAsync(workload));
}
/// <inheritdoc cref="IAutoTracker.Track{TResult}(Func{ITrackingScope, CancellationToken, TResult}, CancellationToken)"/>
public static TResult Track <TResult>(this ITrackingScope scope, Guid id, Func <ITrackingScope, TResult> workload)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
return(scope.CreateAutoTracker(id).Track(workload));
}
public void CreateManualTrackerThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
// act
var ex = Assert.Throws <ArgumentNullException>(() => scope.CreateManualTracker());
// assert
Assert.Equal(nameof(scope), ex.ParamName);
}
public void VoidTrackWithScopeAndTokenThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
Action <ITrackingScope, CancellationToken> workload = null;
// act
var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(workload, CancellationToken.None));
// assert
Assert.Equal(nameof(scope), ex.ParamName);
}
public void ResultTrackWithIdAndScopeThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
Func <ITrackingScope, int> workload = null;
// act
var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(Guid.NewGuid(), workload));
// assert
Assert.Equal(nameof(scope), ex.ParamName);
}
public void VoidTrackThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
Action workload = null;
// act
var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(workload));
// assert
Assert.Equal(nameof(scope), ex.ParamName);
}
/// <inheritdoc cref="StartManualTracker(ITrackingScope, Guid)"/>
public static IManualTracker StartManualTracker(this ITrackingScope scope)
{
if (scope is null)
{
throw new ArgumentNullException(nameof(scope));
}
var tracker = scope.CreateManualTracker();
tracker.Start();
return(tracker);
}
public void StartManualTrackerWithIdThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
var id = Guid.NewGuid();
// act
var ex = Assert.Throws <ArgumentNullException>(() => scope.StartManualTracker(id));
// assert
Assert.Equal(nameof(scope), ex.ParamName);
}
public void VoidTrackWithIdAndScopeThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
var id = Guid.NewGuid();
Action <ITrackingScope> workload = null;
// act
var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(id, workload));
// assert
Assert.Equal(nameof(scope), ex.ParamName);
}
public void VoidTrackWithIdAndScopeAndTokenWorks()
{
// arrange
var id = Guid.NewGuid();
var tracker = Mock.Of <IAutoTracker>();
ITrackingScope scope = Mock.Of <ITrackingScope>(x => x.CreateAutoTracker(id) == tracker);
Action <ITrackingScope, CancellationToken> workload = null;
var token = CancellationToken.None;
// act
scope.Track(id, workload, token);
// assert
Mock.Get(scope).VerifyAll();
Mock.Get(tracker).Verify(x => x.Track(workload, token));
}
public IAutoTracker CreateAutoSyncTracker(Guid id, ITrackingScope scope)
{
var context = _provider.GetRequiredService <IChronoscopeContext>();
return(new AutoTracker(context, id, scope));
}
public void ResultTrackWithIdThrowsOnNullScope()
{
// arrange
ITrackingScope scope = null;
public void Push(ITrackingScope scope)
{
_stack.Value = _stack.Value.Push(scope);
}
static int workload(ITrackingScope scope)
{
return(123);
}
public AutoTracker(IChronoscopeContext context, Guid id, ITrackingScope scope)
: base(context, id, scope.Id)
{
_scope = scope;
}
static void workload(ITrackingScope scope, CancellationToken token)
{
throw new InvalidOperationException("Test");
}
