public async Task ExecuteAsync_CanceledDuringExit_RunsEnterAndExitActionsAndThrowsOperationCanceledException()
{
var tracker = new TestTracker();
using (var cts = new CancellationTokenSource())
{
var state = A.Fake <RuntimeStateBase>(builder =>
builder
.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
new Func <string, Task>(async s =>
{
await tracker.StateExitAction(s);
cts.Cancel();
}),
tracker.StateCanceledAction,
})
.CallsBaseMethods());
await Assert.ThrowsAsync <OperationCanceledException>(async() => await state.ExecuteAsync(cts.Token));
}
Assert.Equal(">test;<test;", tracker.ToString());
}
public async Task CompositeRuntimeState_WithoutCancellationAndEventTransitions_ExecutesAllSubStates()
{
var tracker = new TestTracker();
var tcs2 = new TaskCompletionSource <object>();
var state1 = new SimpleRuntimeState(
"state1",
tracker.StateEnterAction,
tracker.StateExecutionAction,
tracker.StateExitAction,
tracker.StateCanceledAction);
var state2 = new SimpleRuntimeState(
"state2",
tracker.StateEnterAction,
async s =>
{
await tracker.StateExecutionAction(s);
tcs2.SetResult(null);
},
tracker.StateExitAction,
tracker.StateCanceledAction);
var state3 = new SimpleRuntimeState(
"state3",
tracker.StateEnterAction,
tracker.StateExecutionAction,
tracker.StateExitAction,
tracker.StateCanceledAction);
var compositeState = new CompositeRuntimeState(
"composite",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
new RuntimeTransition("T1", state1, tracker.TransitionAction, null));
state1.AddEventTransition("E1", new RuntimeTransition("T2", state2, tracker.TransitionAction, null));
state2.AddEventTransition("E2", new RuntimeTransition("T3", state3, tracker.TransitionAction, null));
var task = compositeState.ExecuteAsync(CancellationToken.None);
Assert.False(task.IsCompleted);
var handled = await compositeState.PublishEventAsync("E1");
Assert.True(handled);
Assert.False(task.IsCompleted);
await tcs2.Task;
handled = await compositeState.PublishEventAsync("E2");
Assert.True(handled);
await task;
Assert.Equal(">composite;@composite->state1;>state1;*state1;!state1;@state1->state2;>state2;*state2;!state2;@state2->state3;>state3;*state3;<state3;<composite;", tracker.ToString());
}
public async Task ExecuteAsync_WhenSelectorReturnsExistingOption_ReturnsTransitionForOption()
{
var tracker = new TestTracker();
var selectedTransition = new RuntimeTransition("1", A.Fake <ITransitionTarget>(), null, null);
var elseTransition = new RuntimeTransition("False", A.Fake <ITransitionTarget>(), null, null);
var state = new SwitchRuntimeState <int>(
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
elseTransition,
new Dictionary <int, RuntimeTransition>
{
{ 0, new RuntimeTransition("0", null, null, null) },
{ 1, selectedTransition },
{ 2, new RuntimeTransition("2", null, null, null) },
},
() => 1);
var actual = await state.ExecuteAsync(CancellationToken.None);
Assert.Equal(selectedTransition, actual);
}
public void Unsub()
{
var internalTrackers = new Dictionary <string, TestTracker>();
var snapshotRequests = new List <string>();
var tracker = new SyncDictDelegator <TestTracker>(
(s, i) =>
{
var internalTracker = new TestTracker(s, i);
internalTrackers[s] = internalTracker;
return(internalTracker);
}
);
tracker.RaiseSnapshotRequest += (_, pair) => snapshotRequests.Add(pair);
var snapshot = TrackerTests.InitialSnapshot();
tracker.NewSnapshot(in snapshot);
var xbtTracker = internalTrackers["XBT/USDT"];
tracker.NewUnsubscribe("XBT/USDT");
var update = TrackerTests.AskUpdate(false);
tracker.NewUpdate(in update);
Assert.Empty(xbtTracker.MisMatches);
Assert.Single(snapshotRequests);
Assert.Single(xbtTracker.AskSides);
Assert.Single(xbtTracker.BidSides);
Assert.Single(xbtTracker.Timstamps);
}
private static void CheckFirstOrLast(TestTracker result, int a, int b, bool leftOrderDefined)
{
if (leftOrderDefined)
{
result.MustEqual(a, b);
}
}
public async Task ExecuteAsync_WithSelectedTransitionAndCanceled_RunsCanceledActionAndThrowsOperationCanceledException()
{
var tracker = new TestTracker();
using (var cts = new CancellationTokenSource())
{
var selectedTransition = new RuntimeTransition("Selected", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var elseTransition = new RuntimeTransition("Else", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var state = A.Fake <ChoiceRuntimeStateBase>(builder =>
builder
.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
elseTransition,
})
.CallsBaseMethods());
A.CallTo(state)
.Where(call => call.Method.Name == "SelectTransition")
.WithReturnType <RuntimeTransition>()
.ReturnsLazily(() =>
{
cts.Cancel();
return(selectedTransition);
});
await Assert.ThrowsAsync <OperationCanceledException>(async() => await state.ExecuteAsync(cts.Token));
}
Assert.Equal(">test;!test;", tracker.ToString());
}
public async Task ExecuteAsync_WithCancellationWithoutTransitions_CompletesImmediatellyAndRunsCanceledActionAndThrowsOperationCanceledException()
{
using (var cts = new CancellationTokenSource())
{
var tcs = new TaskCompletionSource <object>();
var tracker = new TestTracker();
var state = new SimpleRuntimeState(
"test",
tracker.StateEnterAction,
async s =>
{
await tracker.StateExecutionAction(s);
await tcs.Task;
},
tracker.StateExitAction,
tracker.StateCanceledAction);
var task = state.ExecuteAsync(cts.Token);
cts.Cancel();
tcs.SetResult(null);
await Assert.ThrowsAsync <OperationCanceledException>(async() => await task);
Assert.Equal(">test;*test;!test;", tracker.ToString());
}
}
public async Task ExecuteAsync_WithoutCancellationAndNonTargettedTransitions_RunsEnterAndExecutesTransitionsUntilTargettedTransitionAndExitActionsAndReturnsTargettedTransitionWithoutExecuting()
{
var tracker = new TestTracker();
var targetedTransition = new RuntimeTransition("Targeted", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var nonTargetedTransition = new RuntimeTransition("NonTargeted", null, tracker.TransitionAction, null);
var state = A.Fake <RuntimeStateBase>(builder =>
builder
.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
})
.CallsBaseMethods());
A.CallTo(state)
.Where(call => call.Method.Name == "ExecuteStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.ReturnsNextFromSequence(nonTargetedTransition, nonTargetedTransition, targetedTransition);
var actual = await state.ExecuteAsync(CancellationToken.None);
Assert.Equal(targetedTransition, actual);
Assert.Equal(">test;@test;@test;<test;", tracker.ToString());
}
public async Task ExecuteAsync_WithoutSelectedTransitionAndNotCanceled_ReturnElseTransitionAndRunsEnterAndExitActions()
{
var tracker = new TestTracker();
var elseTransition = new RuntimeTransition("Else", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var state = A.Fake <ChoiceRuntimeStateBase>(builder =>
builder
.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
elseTransition,
})
.CallsBaseMethods());
A.CallTo(state)
.Where(call => call.Method.Name == "SelectTransition")
.WithReturnType <RuntimeTransition>()
.Returns(null);
var actual = await state.ExecuteAsync(CancellationToken.None);
Assert.Equal(elseTransition, actual);
Assert.Equal(">test;<test;", tracker.ToString());
}
public async Task ExecuteAsync_ExecutingState_ThrowsInvalidOperationExceptionAsync()
{
var tracker = new TestTracker();
var tcs = new TaskCompletionSource <RuntimeTransition>();
var state = A.Fake <RuntimeStateBase>(builder =>
builder
.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
})
.CallsBaseMethods());
A.CallTo(state)
.Where(call => call.Method.Name == "ExecuteStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.Returns(tcs.Task);
var task = state.ExecuteAsync(CancellationToken.None);
await Assert.ThrowsAsync <InvalidOperationException>(() => state.ExecuteAsync(CancellationToken.None));
tcs.SetResult(null);
await task;
}
public async Task ExecuteAsync_WithCancellationDuringExecute_RunsEnterAndExitActionsAndThrowsOperationCanceledException()
{
var tracker = new TestTracker();
using (var cts = new CancellationTokenSource())
{
var state = A.Fake <RuntimeStateBase>(builder =>
builder
.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
})
.CallsBaseMethods());
A.CallTo(state)
.Where(call => call.Method.Name == "ExecuteStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.Invokes(() => cts.Cancel());
await Assert.ThrowsAsync <OperationCanceledException>(async() => await state.ExecuteAsync(cts.Token));
}
Assert.Equal(">test;!test;", tracker.ToString());
}
public async Task ExecuteAsync_WithSelectedTransitionAndCanceled_RunsCanceledActionAndThrowsOperationCanceledException()
{
var tracker = new TestTracker();
using (var cts = new CancellationTokenSource())
{
var state = new SwitchRuntimeState <int>(
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
new RuntimeTransition("False", A.Fake <ITransitionTarget>(), null, null),
new Dictionary <int, RuntimeTransition>
{
{ 0, new RuntimeTransition("0", null, null, null) },
{ 1, new RuntimeTransition("1", A.Fake <ITransitionTarget>(), null, null) },
{ 2, new RuntimeTransition("2", null, null, null) },
},
() =>
{
cts.Cancel();
return(1);
});
await Assert.ThrowsAsync <OperationCanceledException>(async() => await state.ExecuteAsync(cts.Token));
}
Assert.Equal(">test;!test;", tracker.ToString());
}
public Startup(TestTracker testTracker)
{
_testTracker = testTracker;
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
}
public async Task IfElseState_WithExistingTransitionToStates_BuildRuntimeStateAndExecute()
{
var tracker = new TestTracker();
var predicateValue = false;
var state = new IfElseState("test")
{
OnEnterAction = tracker.StateEnterAction,
OnExitAction = tracker.StateExitAction,
OnCanceledAction = tracker.StateCanceledAction,
Predicate = () => predicateValue,
ElseTransition = new Transition("else")
{
Action = tracker.TransitionAction,
Target = new StateTarget("state1"),
},
TrueTransition = new Transition("true")
{
Action = tracker.TransitionAction,
Target = new StateTarget("state2"),
},
};
var states = new RuntimeStateBase[]
{
new SimpleState("state1")
{
OnEnterAction = tracker.StateEnterAction,
OnExecuteAction = tracker.StateExecutionAction,
OnExitAction = tracker.StateExitAction,
OnCanceledAction = tracker.StateCanceledAction,
}.BuildRuntimeState(),
new SimpleState("state2")
{
OnEnterAction = tracker.StateEnterAction,
OnExecuteAction = tracker.StateExecutionAction,
OnExitAction = tracker.StateExitAction,
OnCanceledAction = tracker.StateCanceledAction,
}.BuildRuntimeState(),
};
var runtimeState = state.BuildRuntimeState(states);
var runtimeTransition = await runtimeState.ExecuteAsync(CancellationToken.None);
Assert.Equal(state.ElseTransition.Target.Name, runtimeTransition.Target.Name);
Assert.Equal(">test;<test;", tracker.ToString());
predicateValue = true;
tracker.Clear();
runtimeTransition = await runtimeState.ExecuteAsync(CancellationToken.None);
Assert.Equal(state.TrueTransition.Target.Name, runtimeTransition.Target.Name);
Assert.Equal(">test;<test;", tracker.ToString());
}
public async Task ValidatesCorrectly()
{
//Arrange
var logEvents = new List <LogEvent>();
Log.Logger = new LoggerConfiguration()
.WriteTo.Observers(e => e.Subscribe(x => logEvents.Add(x)))
.CreateLogger();
var test1 = new Test
{
Route = "/testRoute",
RequestUri = "/testRoute",
Service = "goodservice",
Method = "GET",
Headers = null
};
var test2 = new Test
{
Route = "/testRoute",
RequestUri = "/testRoute",
Service = "badservice",
Method = "PUT",
Headers = null
};
var testList = new Dictionary <string, Test> {
{ "test1", test1 }, { "test2", test2 },
};
var resultList = new Dictionary <string, TaskCompletionSource <Test> >
{
{ "test1", new TaskCompletionSource <Test>() },
{ "test2", new TaskCompletionSource <Test>() }
};
resultList["test1"].SetResult(test1);
resultList["test2"].SetResult(test1);
var testTracker = new TestTracker
{
TestList = testList,
TestResultTasks = resultList
};
var sut = GenerateTestHelper(testTracker);
//Act
await sut.Validate();
//Assert
Assert.Equal("goodservice matched expectations", logEvents[0].MessageTemplate.Text);
Assert.Equal(LogEventLevel.Information, logEvents[0].Level);
Assert.Contains("badservice failed expectations", logEvents[1].MessageTemplate.Text);
Assert.Equal(LogEventLevel.Error, logEvents[1].Level);
}
public async Task ExecuteAsync_WithEventTransitionsNotCanceledWithTriggeredEventTransition_ReturnsEventTransitionAndAcknowledgesHandledEvent()
{
var tracker = new TestTracker();
var eventName = "event";
var eventTransition = new RuntimeTransition("Targeted", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var stateTransition = new RuntimeTransition("State", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var state = A.Fake <EventRuntimeStateBase>(
x =>
{
x.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
});
x.CallsBaseMethods();
});
A.CallTo(state)
.Where(call => call.Method.Name == "EnterStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.CallsBaseMethod();
A.CallTo(state)
.Where(call => call.Method.Name == "ExitStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.CallsBaseMethod();
A.CallTo(state)
.Where(call => call.Method.Name == "ExecuteEventStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.Returns(Task.FromResult <RuntimeTransition>(null))
.Once();
state.AddEventTransition(eventName, eventTransition);
var executeTask = state.ExecuteAsync(CancellationToken.None);
Assert.True(await state.PublishEventAsync(eventName));
var actual = await executeTask;
A.CallTo(state)
.Where(call => call.Method.Name == "ExecuteEventStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.MustHaveHappened(Repeated.Exactly.Once);
Assert.Equal(eventTransition, actual);
Assert.Equal(">test;!test;", tracker.ToString());
}
public static void RunTests()
{
LeftOperator[] leftOps = new LeftOperator[] {
new LeftOperator("MakeCast", MakeCast, true),
new LeftOperator("MakeConcat", MakeConcat, true),
new LeftOperator("MakeDefaultIfEmpty", MakeDefaultIfEmpty, true),
new LeftOperator("MakeDistinct", MakeDistinct, false),
new LeftOperator("MakeExcept", MakeExcept, false),
new LeftOperator("MakeGroupBy", MakeGroupBy, false),
new LeftOperator("MakeGroupJoin", MakeGroupJoin, false),
new LeftOperator("MakeIntersect", MakeIntersect, false),
new LeftOperator("MakeJoin", MakeJoin, false),
new LeftOperator("MakeOfType", MakeOfType, true),
new LeftOperator("MakeOrderBy", MakeOrderBy, true),
new LeftOperator("MakeOrderByThenBy", MakeOrderByThenBy, true),
new LeftOperator("MakeReverse", MakeReverse, true),
new LeftOperator("MakeSelect", MakeSelect, true),
new LeftOperator("MakeSelectMany", MakeSelectMany, false),
new LeftOperator("MakeSkip", MakeSkip, true),
new LeftOperator("MakeSkipWhile", MakeSkipWhile, true),
new LeftOperator("MakeSkipWhileIndexed", MakeSkipWhileIndexed, true),
new LeftOperator("MakeTakeWhile", MakeTakeWhile, true),
new LeftOperator("MakeTakeWhileIndexed", MakeTakeWhileIndexed, true),
new LeftOperator("MakeUnion", MakeUnion, false),
new LeftOperator("MakeWhere", MakeWhere, true),
new LeftOperator("MakeWhereIndexed", MakeWhereIndexed, true),
new LeftOperator("MakeZip", MakeZip, true)
};
TestTracker result = new TestTracker();
List <Exception> all_ex = new List <Exception>();
foreach (bool orderPreserved in new bool[] { true, false })
{
foreach (LeftOperator leftOp in leftOps)
{
String operatorName = leftOp.OperatorName;
Console.WriteLine("Left Operator={0}, Options={1}", operatorName, orderPreserved);
ParallelQuery <int> q = leftOp.LeftOperatorFactory(orderPreserved);
try
{
RunAllTests(result, q, orderPreserved, operatorName, leftOp.OrderDefined);
}
catch (Exception ex)
{
all_ex.Add(ex);
}
}
}
if (all_ex.Count > 0)
{
throw new AggregateException(all_ex);
}
}
public void Ask()
{
var internalTrackers = new Dictionary <string, TestTracker>();
var snapshotRequests = new List <string>();
var tracker = new SyncDictDelegator <TestTracker>(
(s, i) =>
{
var internalTracker = new TestTracker(s, i);
internalTrackers[s] = internalTracker;
return(internalTracker);
}
);
tracker.RaiseSnapshotRequest += (_, pair) => snapshotRequests.Add(pair);
// all snapshots
var snapshot = TrackerTests.InitialSnapshot();
var initialSnapshot = TrackerTests.InitialSnapshot("ETH/USDT");
tracker.NewSnapshot(in snapshot);
tracker.NewSnapshot(in initialSnapshot);
var xbtTracker = internalTrackers["XBT/USDT"];
var ethTracker = internalTrackers["ETH/USDT"];
// snapshots processed
Assert.Single(xbtTracker.AskSides);
Assert.Single(xbtTracker.BidSides);
Assert.Single(xbtTracker.Timstamps);
Assert.Single(ethTracker.AskSides);
Assert.Single(ethTracker.BidSides);
Assert.Single(ethTracker.Timstamps);
// all updates
var update = TrackerTests.AskUpdate(true);
tracker.NewUpdate(in update);
var ethUpdate = TrackerTests.AskUpdate(true, "ETH/USDT");
tracker.NewUpdate(in ethUpdate);
// updates processed
foreach (var cTracker in new[] { xbtTracker, ethTracker })
{
Assert.Empty(cTracker.MisMatches);
Assert.Equal(2, cTracker.AskSides.Count);
Assert.Equal(2, cTracker.BidSides.Count);
Assert.Equal(2, cTracker.Timstamps.Count);
Assert.Equal("1700000001.000000", cTracker.Timstamps[1]);
var updatedAsks = cTracker.AskSides[1];
Assert.Equal(new ExactFloat("2.0"), updatedAsks[new ExactFloat("61100.40000")]);
Assert.Equal(new ExactFloat("1.0"), updatedAsks[new ExactFloat("61102.50000")]);
}
Assert.Empty(snapshotRequests);
}
public async Task ExecuteAsync_WithEventTransitionsNotCanceledWithoutTriggeredEventTransitionAndStateExecutionReturningNull_DoesntCompleteExecution()
{
var tracker = new TestTracker();
var eventName = "event";
var eventTransition = new RuntimeTransition("Event", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var stateMock = A.Fake <EventRuntimeStateBase>(
x =>
{
x.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
});
x.CallsBaseMethods();
});
A.CallTo(stateMock)
.Where(call => call.Method.Name == "EnterStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.CallsBaseMethod();
A.CallTo(stateMock)
.Where(call => call.Method.Name == "ExitStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.CallsBaseMethod();
A.CallTo(stateMock)
.Where(call => call.Method.Name == "ExecuteEventStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.Returns(Task.FromResult <RuntimeTransition>(null))
.Once();
stateMock.AddEventTransition(eventName, eventTransition);
var executeTask = stateMock.ExecuteAsync(CancellationToken.None);
A.CallTo(stateMock)
.Where(call => call.Method.Name == "ExecuteEventStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.MustHaveHappened(Repeated.Exactly.Once);
Assert.False(executeTask.IsCompleted);
Assert.Equal(">test;", tracker.ToString());
}
public void BidMismatch()
{
var tracker = new TestTracker("name", 10);
var snapshot = InitialSnapshot();
tracker.NewSnapshot(in snapshot);
var update = BidUpdate(false);
tracker.NewUpdate(in update);
Assert.Single(tracker.MisMatches);
Assert.Single(tracker.AskSides);
Assert.Single(tracker.BidSides);
Assert.Single(tracker.Timstamps);
}
public TestHelper GenerateTestHelper(TestTracker testTracker = null)
{
if (testTracker == null)
{
testTracker = new TestTracker();
}
var testFileHelper = new Mock <ITestFileHelper>();
var config = new Settings {
KongHost = "localhost"
};
var settings = Options.Create(config);
return(new TestHelper(testTracker, testFileHelper.Object, settings));
}
public void AskMismatchMultiplePairs()
{
var internalTrackers = new Dictionary <string, TestTracker>();
var snapshotRequests = new List <string>();
var tracker = new SyncDictDelegator <TestTracker>(
(s, i) =>
{
var internalTracker = new TestTracker(s, i);
internalTrackers[s] = internalTracker;
return(internalTracker);
}
);
tracker.RaiseSnapshotRequest += (_, pair) => snapshotRequests.Add(pair);
// all snapshots
var snapshot = TrackerTests.InitialSnapshot();
var initialSnapshot = TrackerTests.InitialSnapshot("ETH/USDT");
tracker.NewSnapshot(in snapshot);
tracker.NewSnapshot(in initialSnapshot);
var xbtTracker = internalTrackers["XBT/USDT"];
var ethTracker = internalTrackers["ETH/USDT"];
// snapshots processed
Assert.Single(xbtTracker.AskSides);
Assert.Single(xbtTracker.BidSides);
Assert.Single(xbtTracker.Timstamps);
Assert.Single(ethTracker.AskSides);
Assert.Single(ethTracker.BidSides);
Assert.Single(ethTracker.Timstamps);
// all updates
var update = TrackerTests.AskUpdate(false);
tracker.NewUpdate(in update);
var ethUpdate = TrackerTests.AskUpdate(false, "ETH/USDT");
tracker.NewUpdate(in ethUpdate);
// updates processed
Assert.Single(xbtTracker.MisMatches);
Assert.Single(ethTracker.MisMatches);
Assert.Equal("XBT/USDT", snapshotRequests[0]);
Assert.Equal("ETH/USDT", snapshotRequests[1]);
Assert.Equal(2, snapshotRequests.Count);
}
public void Snapshot()
{
var tracker = new TestTracker("name", 10);
var snapshot = InitialSnapshot();
tracker.NewSnapshot(snapshot);
Assert.Single(tracker.AskSides);
Assert.Single(tracker.BidSides);
Assert.Single(tracker.Timstamps);
Assert.Empty(tracker.MisMatches);
var expectedAsks = new OrderbookSide(new ExactFloatComparer());
var expectedBids = new OrderbookSide(new ExactFloatComparer());
foreach (LevelTuple tup in snapshot.Asks.Tuples)
{
expectedAsks.Add(new ExactFloat(tup.PriceLevel), new ExactFloat(tup.Volume));
}
foreach (LevelTuple tup in snapshot.Bids.Tuples)
{
expectedBids.Add(new ExactFloat(tup.PriceLevel), new ExactFloat(tup.Volume));
}
Assert.Equal(expectedAsks.Count, tracker.AskSides[0].Count);
Assert.Equal(expectedBids.Count, tracker.BidSides[0].Count);
foreach (KeyValuePair <ExactFloat, ExactFloat> pair in expectedAsks)
{
Assert.Equal(tracker.AskSides[0][pair.Key], pair.Value);
}
foreach (KeyValuePair <ExactFloat, ExactFloat> pair in expectedBids)
{
Assert.Equal(tracker.BidSides[0][pair.Key], pair.Value);
}
// max timestamp
string maxA = snapshot.Asks.Tuples.Max(x => x.Timestamp) ??
throw new ArgumentNullException(nameof(snapshot));
string maxB = snapshot.Asks.Tuples.Max(x => x.Timestamp) ??
throw new ArgumentNullException(nameof(snapshot));
var em = string.Compare(maxA, maxB, StringComparison.Ordinal) >= 0 ? maxA : maxB;
Assert.Equal(em, tracker.Timstamps[0]);
Assert.Equal(em, tracker.Timstamps[0]);
}
public async Task ExecuteAsync_WithoutTransitions_CompletesImmediatelly()
{
var tracker = new TestTracker();
var state = new SimpleRuntimeState(
"test",
tracker.StateEnterAction,
tracker.StateExecutionAction,
tracker.StateExitAction,
tracker.StateCanceledAction);
await state.ExecuteAsync(CancellationToken.None);
Assert.Equal(">test;*test;<test;", tracker.ToString());
}
public async Task ExecuteAsync_WithoutEventTransitionsNotCanceled_ReturnsReturnValueOfExecuteEventStepAsync()
{
var tracker = new TestTracker();
var stateTransition = new RuntimeTransition("Targeted", A.Fake <ITransitionTarget>(), tracker.TransitionAction, null);
var stateMock = A.Fake <EventRuntimeStateBase>(
x =>
{
x.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
});
x.CallsBaseMethods();
});
A.CallTo(stateMock)
.Where(call => call.Method.Name == "EnterStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.CallsBaseMethod();
A.CallTo(stateMock)
.Where(call => call.Method.Name == "ExitStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.CallsBaseMethod();
A.CallTo(stateMock)
.Where(call => call.Method.Name == "ExecuteEventStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.Returns(Task.FromResult <RuntimeTransition>(stateTransition))
.Once();
var actual = await stateMock.ExecuteAsync(CancellationToken.None);
A.CallTo(stateMock)
.Where(call => call.Method.Name == "ExecuteEventStepAsync")
.WithReturnType <Task <RuntimeTransition> >()
.MustHaveHappened(Repeated.Exactly.Once);
Assert.Equal(stateTransition, actual);
Assert.Equal(">test;<test;", tracker.ToString());
}
private static void CheckTakeSkip(TestTracker result, IEnumerable <int> q1, IEnumerable <int> q2, bool leftOrderDefined)
{
if (leftOrderDefined)
{
result.MustSequenceEqual(q1, q2, true);
}
else
{
// Just run the queries, but don't compare the answer because it is not unique.
foreach (var x in q1)
{
}
foreach (var x in q2)
{
}
}
}
public async Task ExecuteAsync_WithoutCancellation_RunsEnterAndExitActions()
{
var tracker = new TestTracker();
var state = A.Fake <RuntimeStateBase>(builder =>
builder.WithArgumentsForConstructor(new object[]
{
"test",
tracker.StateEnterAction,
tracker.StateExitAction,
tracker.StateCanceledAction,
})
.CallsBaseMethods());
await state.ExecuteAsync(CancellationToken.None);
Assert.Equal(">test;<test;", tracker.ToString());
}
public async Task SimpleState_BuildRuntimeStateAndExecute()
{
var tracker = new TestTracker();
var state = new SimpleState("test")
{
OnEnterAction = tracker.StateEnterAction,
OnExecuteAction = tracker.StateExecutionAction,
OnExitAction = tracker.StateExitAction,
OnCanceledAction = tracker.StateCanceledAction,
};
await state
.BuildRuntimeState()
.ExecuteAsync(CancellationToken.None);
Assert.Equal(">test;*test;<test;", tracker.ToString());
}
public void AskDelete()
{
var tracker = new TestTracker("name", 10);
var snapshot = InitialSnapshot();
tracker.NewSnapshot(in snapshot);
var update = AskDeleteUpdate();
tracker.NewUpdate(in update);
Assert.Empty(tracker.MisMatches);
Assert.Equal(2, tracker.AskSides.Count);
Assert.Equal(2, tracker.BidSides.Count);
Assert.Equal(2, tracker.Timstamps.Count);
Assert.Equal("1700000000.000000", tracker.Timstamps[1]);
var updatedAsks = tracker.AskSides[1];
Assert.False(updatedAsks.ContainsKey(new ExactFloat("61102.50000")));
}
internal static bool RunTests()
{
LeftOperator[] leftOps = new LeftOperator[] {
new LeftOperator(MakeCast, true),
new LeftOperator(MakeConcat, true),
new LeftOperator(MakeDefaultIfEmpty, true),
new LeftOperator(MakeDistinct, false),
new LeftOperator(MakeExcept, false),
new LeftOperator(MakeGroupBy, false),
new LeftOperator(MakeGroupJoin, false),
new LeftOperator(MakeIntersect, false),
new LeftOperator(MakeJoin, false),
new LeftOperator(MakeOfType, true),
new LeftOperator(MakeOrderBy, true),
new LeftOperator(MakeOrderByThenBy, true),
new LeftOperator(MakeReverse, true),
new LeftOperator(MakeSelect, true),
new LeftOperator(MakeSelectMany, false),
new LeftOperator(MakeSkip, true),
new LeftOperator(MakeSkipWhile, true),
new LeftOperator(MakeSkipWhileIndexed, true),
new LeftOperator(MakeTakeWhile, true),
new LeftOperator(MakeTakeWhileIndexed, true),
new LeftOperator(MakeUnion, false),
new LeftOperator(MakeWhere, true),
new LeftOperator(MakeWhereIndexed, true),
new LeftOperator(MakeZip, true)
};
TestTracker result = new TestTracker();
foreach (bool orderPreserved in new bool[] { true, false })
{
foreach (LeftOperator leftOp in leftOps)
{
String operatorName = leftOp.OperatorName;
TestHarness.TestLog("Left Operator={0}, Options={1}", operatorName, orderPreserved);
ParallelQuery <int> q = leftOp.LeftOperatorFactory(orderPreserved);
RunAllTests(result, q, orderPreserved, operatorName, leftOp.OrderDefined);
}
}
return(result.Passed);
}
private static Container BuildContainer()
{
_testTracker = new TestTracker();
var container = new Container(cfg =>
{
cfg.Scan(scanner =>
{
scanner.AssemblyContainingType<TestRequest>();
scanner.AssemblyContainingType<IMediator>();
scanner.AddAllTypesOf(typeof(IRequestHandler<,>));
scanner.AddAllTypesOf(typeof(IEventHandler<>));
scanner.AddAllTypesOf(typeof(IPreRequestHandler<>));
scanner.AddAllTypesOf(typeof(IPostRequestHandler<,>));
scanner.WithDefaultConventions();
});
cfg.For(typeof(IRequestHandler<,>))
.DecorateAllWith(typeof(MediatorPipeline<,>));
cfg.For<TestTracker>().Use(_testTracker);
});
return container;
}
