public void UseInitialPositionProviderTest()
{
TestState state = new TestState();
state.Initialize("UseInitialPositionProvider", 1, 0);
const long firstSequenceNumber = 3456L;
state.Options.InitialPositionProvider = (partitionId) => { return EventPosition.FromSequenceNumber(firstSequenceNumber); };
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. Sequence number of first event processed should match that
// supplied in the InitialPositionProvider.
Assert.True(state.Processor.FirstEvent.SystemProperties.SequenceNumber == (firstSequenceNumber + 1L),
$"Got unexpected first sequence number {state.Processor.FirstEvent.SystemProperties.SequenceNumber}");
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
}
public void SmokeTest()
{
TestState state = new TestState();
state.Initialize("smoke", 1, 0);
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing.
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
}
public void RuntimeInformationTest()
{
TestState state = new TestState();
state.Initialize("RuntimeInformation", 1, 0);
state.Options.EnableReceiverRuntimeMetric = true;
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. Verify that the RuntimeInformation property of the partition
// context is updated.
Assert.True(state.Processor.LatestContext.RuntimeInformation.LastSequenceNumber == state.Processor.LastEvent.SystemProperties.SequenceNumber);
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
}
public void IgnoreInitialPositionProviderTest()
{
TestState state = new TestState();
state.Initialize("IgnoreInitialPositionProvider", 1, 0);
const long ippSequenceNumber = 3456L;
state.Options.InitialPositionProvider = (partitionId) => { return(EventPosition.FromSequenceNumber(ippSequenceNumber)); };
// Fake up a checkpoint using code borrowed from ReliableDictionaryCheckpointManager
IReliableDictionary <string, Dictionary <string, object> > store =
state.StateManager.GetOrAddAsync <IReliableDictionary <string, Dictionary <string, object> > >("EventProcessorCheckpointDictionary").Result;
const long checkpointSequenceNumber = 8888L;
Checkpoint fake = new Checkpoint((checkpointSequenceNumber * 100L).ToString(), checkpointSequenceNumber);
using (ITransaction tx = state.StateManager.CreateTransaction())
{
store.SetAsync(tx, "0", fake.ToDictionary(), TimeSpan.FromSeconds(5.0), CancellationToken.None).Wait();
tx.CommitAsync().Wait();
}
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. Sequence number of first event processed should match that
// supplied in the checkpoint, NOT the InitialPositionProvider.
Assert.True(state.Processor.FirstEvent.SystemProperties.SequenceNumber == (checkpointSequenceNumber + 1L),
$"Got unexpected first sequence number {state.Processor.FirstEvent.SystemProperties.SequenceNumber}");
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
}
public void ErrorException()
{
TestState state = new TestState();
state.Initialize("EventException", 1, 0);
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
// have to inject errors in events to cause error handler to be called
List <TestProcessor.ErrorLocation> locations =
new List <TestProcessor.ErrorLocation>()
{
TestProcessor.ErrorLocation.OnEvents, TestProcessor.ErrorLocation.OnError
};
state.Processor.Injector = new TestProcessor.ErrorInjector(locations, new NotImplementedException("ErrorInjector"));
state.StartRun(sfp);
state.RunForNBatches(20, 10);
// EXPECTED RESULT: Errors from ProcessEventsAsync are reported to ProcessErrorsAsync, but the
// errors in ProcessErrorsAsync are ignored. The test implementation of ProcessErrorsAsync increments
// the error count before throwing, so we can verify that ProcessErrorsAsync was called.
state.WaitRun();
Assert.True(state.Processor.TotalErrors == state.Processor.TotalBatches,
$"Unexpected error count got {state.Processor.TotalErrors} expected {state.Processor.TotalBatches}");
Assert.True(state.Processor.LastError is NotImplementedException,
$"Unexpected exception type {state.Processor.LastError.GetType().Name}");
Assert.Null(state.ShutdownException);
}
public void EventException()
{
TestState state = new TestState();
state.Initialize("EventException", 1, 0);
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.Processor.Injector =
new TestProcessor.ErrorInjector(TestProcessor.ErrorLocation.OnEvents, new NotImplementedException("ErrorInjector"));
state.StartRun(sfp);
state.RunForNBatches(20, 10);
// EXPECTED RESULT: Errors are reported to IEventProcessor.ProcessErrorsAsync but processing
// continues normally. There should be one error per batch.
state.WaitRun();
Assert.True(state.Processor.TotalErrors == state.Processor.TotalBatches,
$"Unexpected error count {state.Processor.TotalErrors}. Expected { state.Processor.TotalBatches }");
Assert.True(state.Processor.LastError is NotImplementedException,
$"Unexpected exception type {state.Processor.LastError.GetType().Name}. Expected { nameof(NotImplementedException) }");
Assert.Null(state.ShutdownException);
}
private void NoFailures(string name, EHErrorInjector injector)
{
TestState state = new TestState();
state.Initialize(name, 1, 0);
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new InjectorEventHubClientFactoryMock(1, injector);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
// EXPECTED RESULT: Processing should happen normally with no errors reported.
//
// 1) The error is transient, so it should be retried, and for "soft" errors the
// test harness only throws on the first call, so the retry will succeed.
//
// 2) Errors during shutdown are traced but ignored.
state.WaitRun();
Assert.True(state.Processor.TotalBatches >= 20, $"Run ended at {state.Processor.TotalBatches} batches");
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
}
public void CheckpointEventTest()
{
TestState state = new TestState();
state.Initialize("checkpointing", 1, 0);
const long checkpointAt = 57L;
state.Processor = new CheckpointingProcessor(state.Options, checkpointAt);
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. This case checkpoints specific events. Validate that the
// last event processed has a higher sequence number than the checkpointed event.
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
EventData checkpointedEvent = ((CheckpointingProcessor)state.Processor).CheckpointedEvent;
Assert.NotNull(checkpointedEvent);
Assert.True(checkpointedEvent.SystemProperties.SequenceNumber == checkpointAt,
$"Checkpointed event has seq {checkpointedEvent.SystemProperties.SequenceNumber}, expected {checkpointAt}");
EventData lastEvent = state.Processor.LastEvent;
Assert.NotNull(lastEvent);
Assert.True(lastEvent.SystemProperties.SequenceNumber > checkpointedEvent.SystemProperties.SequenceNumber,
$"Unexpected sequence number {lastEvent.SystemProperties.SequenceNumber}");
state.Processor = new CheckpointingProcessor(state.Options);
sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(1, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. The sequence number of the first event processed in
// this stage should be one higher than the sequence number of the event checkpointed in
// the previous stage.
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
EventData restartEvent = ((CheckpointingProcessor)state.Processor).FirstEvent;
Assert.NotNull(restartEvent);
Assert.True((restartEvent.SystemProperties.SequenceNumber - checkpointedEvent.SystemProperties.SequenceNumber) == 1,
$"Unexpected change in sequence number from {checkpointedEvent.SystemProperties.SequenceNumber} to {restartEvent.SystemProperties.SequenceNumber}");
}
public void CheckpointBatchTest()
{
TestState state = new TestState();
state.Initialize("checkpointing", 1, 0);
state.Processor = new CheckpointingProcessor(state.Options);
ServiceFabricProcessor sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(20, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. Last event processed is also the end of the batch
// and hence the final checkpoint. Save for next stage validaiton.
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
EventData checkpointedEvent = state.Processor.LastEvent;
Assert.NotNull(checkpointedEvent);
Assert.True(checkpointedEvent.SystemProperties.SequenceNumber > 0L,
$"Unexpected sequence number {checkpointedEvent.SystemProperties.SequenceNumber}");
state.Processor = new CheckpointingProcessor(state.Options);
sfp = new ServiceFabricProcessor(
state.ServiceUri,
state.ServicePartitionId,
state.StateManager,
state.StatefulServicePartition,
state.Processor,
state.ConnectionString,
"$Default",
state.Options);
sfp.MockMode = state.PartitionLister;
sfp.EventHubClientFactory = new EventHubMocks.EventHubClientFactoryMock(1);
state.PrepareToRun();
state.StartRun(sfp);
state.RunForNBatches(1, 10);
state.WaitRun();
// EXPECTED RESULT: Normal processing. The sequence number of the first event processed in
// this stage should be one higher than the sequence number of the last event processed in
// the previous stage.
Assert.True(state.Processor.TotalErrors == 0, $"Errors found {state.Processor.TotalErrors}");
Assert.Null(state.ShutdownException);
EventData restartEvent = ((CheckpointingProcessor)state.Processor).FirstEvent;
Assert.NotNull(restartEvent);
Assert.True((restartEvent.SystemProperties.SequenceNumber - checkpointedEvent.SystemProperties.SequenceNumber) == 1,
$"Unexpected change in sequence number from {checkpointedEvent.SystemProperties.SequenceNumber} to {restartEvent.SystemProperties.SequenceNumber}");
}
