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}"); }