public async Task should_be_invoke_chain_workers()
{
var result = await Chain.RunAsync();
DispatcherToken.WaitCompleted();
MockActionInvoker.Verify(p => p.Invoke(It.IsAny <CancellationToken>()), Times.Exactly(2));
}
public void should_be_invoke_sync_success()
{
var result = Chain.RunSync();
Assert.IsNotNull(result);
Assert.IsNotNull(result.Results);
Assert.IsTrue(result.Results.All(p => !p.IsError));
DispatcherToken.WaitCompleted();
}
public async Task should_be_invoke_async_success()
{
var result = await Chain.RunAsync();
Assert.IsNotNull(result);
Assert.IsNotNull(result.Results);
Assert.IsTrue(result.Results.All(p => !p.IsError));
Assert.IsTrue(result.Results.All(p => p.Result != null));
DispatcherToken.WaitCompleted();
}
public void should_be_invoke_sync_item_error()
{
var result = Chain.RunSync();
Assert.IsNotNull(result);
Assert.IsNotNull(result.Results);
Assert.NotNull(result.Results.Single(p => p.IsError && p.Error != null));
Assert.IsTrue(result.Results.Any(p => !p.IsError));
DispatcherToken.WaitCompleted();
}
public void Initalize()
{
MockActionInvoker.Reset();
MockWorkerHandler.Reset();
DispatcherToken = Factory.Start(new ActionDispatcherSettings
{
Timeout = TimeSpan.FromSeconds(0.1)
});
DispatcherToken.Post(t => Task.Delay(10000, t));
}
public void Initalize()
{
DispatcherToken = Factory.Start(new ActionDispatcherSettings
{
Timeout = TimeSpan.FromSeconds(1000)
});
MockActionInvoker.Invocations.Clear();
Chain = DispatcherToken.Chain()
.Post(MockActionInvoker.Object)
.Post(MockActionInvoker.Object);
}
public void Initalize()
{
MockWorkerHandler.Invocations.Clear();
MockActionInvoker.Invocations.Clear();
DispatcherToken = Factory.Start(new ActionDispatcherSettings
{
Timeout = TimeSpan.FromSeconds(1)
});
DispatcherToken.Post(MockActionInvoker.Object);
DispatcherToken.Post(p => throw new ArgumentException());
DispatcherToken.Post(MockActionInvoker.Object);
}
public void Initalize()
{
DispatcherToken = Factory.Start(new ActionDispatcherSettings
{
Timeout = TimeSpan.FromSeconds(1000)
});
MockActionInvoker.Invocations.Clear();
MockActionInvokerError.Setup(p => p.Invoke(It.IsAny <CancellationToken>())).ThrowsAsync(new ArgumentException("test"));
Chain = DispatcherToken.Chain()
.Post(MockActionInvoker.Object)
.Post(MockActionInvoker.Object)
.Post(MockActionInvokerError.Object);
}
public void should_be_invoke_batch_count_success(int count)
{
BatchActionInvoker.Invocations.Clear();
Enumerable.Range(0, count).ToList().ForEach(p =>
{
var data = new SomeBatchData();
_batchToken.Send(data);
});
_batchToken.Stop();
_batchToken.Dispose();
DispatcherToken.WaitCompleted();
BatchActionInvoker.Verify(p => p.Invoke(It.Is <SomeBatchData[]>(x => x.Length == count), It.IsAny <CancellationToken>()), Times.Once);
}
public void Initalize()
{
Callback = (WorkerCompletedData p) => MockCompleted.Object.Invoke(p, CancellationToken.None);
MockCompleted.Setup(p => p.Invoke(It.IsAny <WorkerCompletedData>(), It.IsAny <CancellationToken>()));
DispatcherToken = Factory.Start(new ActionDispatcherSettings
{
Timeout = TimeSpan.FromSeconds(1000)
});
MockActionInvoker.Invocations.Clear();
MockCompleted.Invocations.Clear();
DispatcherToken.Chain()
.Post(MockActionInvoker.Object)
.Post(MockActionInvoker.Object)
.Run(Callback);
}
public void execute_batch_count_exceeded()
{
var countExceeded = MAX_COUNT_ITEMS + 1;
BatchActionInvoker.Invocations.Clear();
Enumerable.Range(0, countExceeded).ToList().ForEach(p =>
{
var data = new SomeBatchData();
_batchToken.Send(data);
});
_batchToken.Stop();
_batchToken.Dispose();
DispatcherToken.WaitCompleted();
BatchActionInvoker.Verify(p => p.Invoke(It.Is <SomeBatchData[]>(x => x.Length == MAX_COUNT_ITEMS), It.IsAny <CancellationToken>()), Times.Once);
}
public void should_be_invoke_callback()
{
DispatcherToken.WaitCompleted();
MockCompleted.Verify(p => p.Invoke(It.IsAny <WorkerCompletedData>(), It.IsAny <CancellationToken>()), Times.Once);
}
public void should_be_invoke_chain_workers()
{
DispatcherToken.WaitCompleted();
MockActionInvoker.Verify(p => p.Invoke(It.IsAny <CancellationToken>()), Times.Exactly(8));
}
public void should_be_from_all_worker_one_error()
{
DispatcherToken.WaitCompleted();
MockWorkerHandler.Verify(p => p.HandleError(It.IsAny <Exception>(), It.IsAny <decimal>(), It.IsAny <bool>()), Times.Once);
}
public void should_be_data_fault_execute()
{
Assert.Throws <ArgumentNullException>(() => DispatcherToken.Post(default(IActionInvoker <object>), default(object)));
}
public void should_be_fn_fault_execute()
{
Assert.Throws <ArgumentNullException>(() => DispatcherToken.Post(default(Func <CancellationToken, Task>)));
}
public void Initalize()
{
DispatcherToken.Post(MockActionDataInvoker.Object, ExpectData);
}
public void should_action_execute()
{
DispatcherToken.WaitCompleted();
MockActionDataInvoker.Verify(p => p.Invoke(It.Is <string>(s => s == ExpectData), It.IsAny <CancellationToken>()), Times.Exactly(1));
}
public void Initalize()
{
DispatcherToken.Post(MockActionInvoker.Object);
DispatcherToken.Post(MockActionInvoker.Object);
DispatcherToken.Post(p => Task.Delay(100, p));
}
public void should_be_two_worker_from_all_success()
{
DispatcherToken.WaitCompleted();
MockActionInvoker.Verify(p => p.Invoke(It.IsAny <CancellationToken>()), Times.Exactly(2));
}
public void should_be_cancelled_work()
{
DispatcherToken.WaitCompleted();
MockWorkerHandler.Verify(p => p.HandleError(null, It.IsAny <decimal>(), true), Times.Once);
}
public void should_be_two_action_execute()
{
DispatcherToken.WaitCompleted();
MockActionInvoker.Verify(p => p.Invoke(It.IsAny <CancellationToken>()), Times.Exactly(2));
}
