protected override void Given()
{
_ioDispatcher = new IODispatcher(_node.Node.MainQueue, new PublishEnvelope(_node.Node.MainQueue));
_node.Node.MainBus.Subscribe(_ioDispatcher.BackwardReader);
_node.Node.MainBus.Subscribe(_ioDispatcher.ForwardReader);
_node.Node.MainBus.Subscribe(_ioDispatcher.Writer);
_node.Node.MainBus.Subscribe(_ioDispatcher.StreamDeleter);
_node.Node.MainBus.Subscribe(_ioDispatcher.Awaker);
_node.Node.MainBus.Subscribe(_ioDispatcher);
_projectionNamesBuilder = ProjectionNamesBuilder.CreateForTest(_projectionName);
_emittedStreamsTracker = new EmittedStreamsTracker(_ioDispatcher, new ProjectionConfig(null, 1000, 1000 * 1000, 100, 500, true, true, false, false, false, _trackEmittedStreams), _projectionNamesBuilder);
_emittedStreamsDeleter = new EmittedStreamsDeleter(_ioDispatcher, _projectionNamesBuilder.GetEmittedStreamsName(), _projectionNamesBuilder.GetEmittedStreamsCheckpointName());
}
public override IProjectionProcessingPhase[] CreateProcessingPhases(
IPublisher publisher,
IPublisher inputQueue,
Guid projectionCorrelationId,
PartitionStateCache partitionStateCache,
Action updateStatistics,
CoreProjection coreProjection,
ProjectionNamesBuilder namingBuilder,
ITimeProvider timeProvider,
IODispatcher ioDispatcher,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
{
return(new IProjectionProcessingPhase[] { _phase1, _phase2 });
}
private void DeleteCheckpointStream()
{
//delete checkpoint stream
var correlationId = Guid.NewGuid();
var checkpointStreamName = new ProjectionNamesBuilder(_name, _persistedState.SourceDefinition).MakeCheckpointStreamName();
_streamDispatcher.Publish(new ClientMessage.DeleteStream(
correlationId,
correlationId,
_writeDispatcher.Envelope,
true,
checkpointStreamName,
ExpectedVersion.Any,
false,
SystemAccount.Principal), m => StreamDeleted(m, checkpointStreamName));
}
protected virtual void SetUp()
{
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus), true);
_projectionNamesBuilder = ProjectionNamesBuilder.CreateForTest(_projectionName);
_checkpointName = _projectionNamesBuilder.GetEmittedStreamsCheckpointName();
_deleter = new EmittedStreamsDeleter(_ioDispatcher,
_projectionNamesBuilder.GetEmittedStreamsName(),
_checkpointName);
IODispatcherTestHelpers.SubscribeIODispatcher(_ioDispatcher, _bus);
_bus.Subscribe <ClientMessage.ReadStreamEventsForward>(this);
_bus.Subscribe <ClientMessage.ReadStreamEventsBackward>(this);
_bus.Subscribe <ClientMessage.DeleteStream>(this);
When();
}
protected override IEnumerable <WhenStep> PreWhen()
{
_uniqueStreamId = Guid.NewGuid();
var startCore = new ProjectionCoreServiceMessage.StartCore(_uniqueStreamId);
var startReader = CreateWriteEvent(ProjectionNamesBuilder.BuildControlStreamName(_uniqueStreamId), "$response-reader-started", "{}");
yield return(new WhenStep(startCore, startReader));
List <EventRecord> stream;
_streams.TryGetValue("$projections-$master", out stream);
Assume.That(stream != null);
var lastEvent = stream.Last();
var parsed = lastEvent.Data.ParseJson <JObject>();
_serviceId = (string)((JValue)parsed.GetValue("id")).Value;
Assume.That(!string.IsNullOrEmpty(_serviceId));
}
protected override Task Given()
{
_ioDispatcher = new IODispatcher(_node.Node.MainQueue, new PublishEnvelope(_node.Node.MainQueue), true);
_node.Node.MainBus.Subscribe(_ioDispatcher.BackwardReader);
_node.Node.MainBus.Subscribe(_ioDispatcher.ForwardReader);
_node.Node.MainBus.Subscribe(_ioDispatcher.Writer);
_node.Node.MainBus.Subscribe(_ioDispatcher.StreamDeleter);
_node.Node.MainBus.Subscribe(_ioDispatcher.Awaker);
_node.Node.MainBus.Subscribe <IODispatcherDelayedMessage>(_ioDispatcher);
_node.Node.MainBus.Subscribe <ClientMessage.NotHandled>(_ioDispatcher);
_projectionNamesBuilder = ProjectionNamesBuilder.CreateForTest(_projectionName);
_emittedStreamsTracker = new EmittedStreamsTracker(_ioDispatcher,
new ProjectionConfig(null, 1000, 1000 * 1000, 100, 500, true, true, false, false,
_trackEmittedStreams, 10000, 1), _projectionNamesBuilder);
_emittedStreamsDeleter = new EmittedStreamsDeleter(_ioDispatcher,
_projectionNamesBuilder.GetEmittedStreamsName(),
_projectionNamesBuilder.GetEmittedStreamsCheckpointName());
return(Task.CompletedTask);
}
protected override void Given()
{
_numberOfWorkers = 1;
var controlStream = ProjectionNamesBuilder.BuildControlStreamName(_epochId);
TimeOutReadToStreamOnce(controlStream);
int timeoutCount = 0;
_bus.Subscribe(new AdHocHandler <TimerMessage.Schedule>(msg => {
if (msg.ReplyMessage is IODispatcherDelayedMessage && timeoutCount <= 1)
{
// Only the second read should time out as the first is of the control stream
if (timeoutCount == 1)
{
msg.Reply();
}
timeoutCount++;
}
}));
base.Given();
}
public void TestFixtureSetUp()
{
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_projectionVersion = new ProjectionVersion(3, 1, 2);
_projectionConfig = new ProjectionConfig(SystemAccount.Principal, 10, 1000, 1000, 10, true, true, true, false,
false, false, 5000, 10);
_positionTagger = new MultiStreamPositionTagger(3, _streams);
_positionTagger.AdjustTag(CheckpointTag.FromStreamPositions(3, new Dictionary <string, long> {
{ "a", 0 }, { "b", 0 }, { "c", 0 }
}));
_namingBuilder = ProjectionNamesBuilder.CreateForTest("projection");
IODispatcherTestHelpers.SubscribeIODispatcher(_ioDispatcher, _bus);
_bus.Subscribe <ClientMessage.ReadStreamEventsBackward>(this);
_coreProjectionCheckpointWriter = new CoreProjectionCheckpointWriter(_namingBuilder.MakeCheckpointStreamName(), _ioDispatcher,
_projectionVersion, _projectionName);
_checkpointManager = new MultiStreamMultiOutputCheckpointManager(_bus, _projectionId, _projectionVersion, SystemAccount.Principal,
_ioDispatcher, _projectionConfig, _projectionName, _positionTagger, _namingBuilder, true, true, false,
_coreProjectionCheckpointWriter);
When();
}
public void setup()
{
_updateManager = new PartitionStateUpdateManager(ProjectionNamesBuilder.CreateForTest("projection"));
_updateManager.StateUpdated("partition", new PartitionState("{\"state\":1}", null, _one), _zero);
_updateManager.StateUpdated("partition", new PartitionState("{\"state\":2}", null, _two), _one);
}
public void setup()
{
_namesBuilder = ProjectionNamesBuilder.CreateForTest("projection");
}
public void setup()
{
_updateManager = new PartitionStateUpdateManager(ProjectionNamesBuilder.CreateForTest("projection"));
}
public void no_exceptions_are_thrown()
{
new PartitionStateUpdateManager(ProjectionNamesBuilder.CreateForTest("projection"));
}
protected override void When()
{
// do not create
_namingBuilder = ProjectionNamesBuilder.CreateForTest("projection");
}
