public async Task TestItemTransfer()
{
var processorNodeGuid = Guid.NewGuid();
var processor = GrainClient.GrainFactory.GetGrain <IStreamProcessorSelectNodeGrain <int, int> >(processorNodeGuid);
await processor.SetFunction(new SerializableFunc <int, int>(_ => _));
var itemsToSend = new List <int> {
-1, 5, 30
};
var provider = GrainClient.GetStreamProvider(StreamProvider);
var testProvider = new StreamMessageSenderComposite <int>(provider, 1);
await processor.SubscribeToStreams(await testProvider.GetOutputStreams());
var testConsumer = new TransactionalStreamListConsumer <int>(provider);
await SubscribeConsumer(processor, testConsumer);
var tid = TransactionGenerator.GenerateTransactionId();
await testProvider.StartTransaction(tid);
await testProvider.SendMessage(new ItemMessage <int>(itemsToSend));
await testProvider.EndTransaction(tid);
CollectionAssert.AreEquivalent(itemsToSend, testConsumer.Items);
await testProvider.TearDown();
}
public async Task <Guid> EnumerateToSubscribers(Guid?transactionId = null)
{
var tId = TransactionGenerator.GenerateTransactionId(transactionId);
await OutputProducer.StartTransaction(tId);
await OutputProducer.SendMessage(new ItemMessage <ContainerElement <T> >(Elements));
await OutputProducer.EndTransaction(tId);
return(tId);
}
public async Task TestOneLevelSelectManyDataPass()
{
var inputChunks = new List <int>()
{
5, 213, 23, -21, 23, 99
}.BatchIEnumerable(2).ToList();
var outputChunks = inputChunks.SelectMany(i => i).Select(i => (i > 0) ? Enumerable.Range(0, i).ToList() : i.SingleValueToList()).ToList();
var source = new StreamMessageSenderComposite <int>(_provider, 2);
var factory = new DefaultStreamProcessorAggregateFactory(GrainFactory);
var query = await source.SimpleSelectMany(i => (i > 0)?Enumerable.Range(0, i) : i.SingleValueToList(), factory);
var queryOutputStreams = await query.GetOutputStreams();
var resultConsumer = new TestTransactionalTransactionalStreamConsumerAggregate <int>(_provider);
await resultConsumer.SetInput(queryOutputStreams);
Assert.AreEqual(2, queryOutputStreams.Count);
Assert.AreEqual(0, resultConsumer.Items.Count);
for (int i = 0; i < inputChunks.Count; i++)
{
var input = inputChunks[i];
var expectedOutput = new List <int>();
expectedOutput.AddRange(outputChunks[2 * i]);
expectedOutput.AddRange(outputChunks[2 * i + 1]);
var tid = TransactionGenerator.GenerateTransactionId();
await source.StartTransaction(tid);
await source.SendMessage(new ItemMessage <int>(input));
await source.EndTransaction(tid);
CollectionAssert.AreEquivalent(expectedOutput, resultConsumer.Items);
resultConsumer.Items.Clear();
}
await query.TearDown();
await resultConsumer.TearDown();
}
private async Task TestMultiLevelDataPass <TIn, TOut>(
Func <StreamMessageSenderComposite <TIn>, DefaultStreamProcessorAggregateFactory, Task <IStreamProcessorChain <TOut, DefaultStreamProcessorAggregateFactory> > >
createStreamProcessingChainFunc, List <List <TIn> > inputChunks, List <List <TOut> > outputChunks,
Action <List <TOut>, List <TOut> > resultAssertion)
{
if (inputChunks.Count != outputChunks.Count)
{
throw new ArgumentException();
}
var source = new StreamMessageSenderComposite <TIn>(_provider, 2);
var query = await createStreamProcessingChainFunc(source, _factory);
var queryOutputStreams = await query.GetOutputStreams();
var resultConsumer = new TestTransactionalTransactionalStreamConsumerAggregate <TOut>(_provider);
await resultConsumer.SetInput(queryOutputStreams);
Assert.AreEqual(2, queryOutputStreams.Count);
Assert.AreEqual(0, resultConsumer.Items.Count);
for (int i = 0; i < inputChunks.Count; i++)
{
var input = inputChunks[i];
var expectedOutput = outputChunks[i];
var tid = TransactionGenerator.GenerateTransactionId();
await source.StartTransaction(tid);
await source.SendMessage(new ItemMessage <TIn>(input));
await source.EndTransaction(tid);
resultAssertion(expectedOutput, resultConsumer.Items);
resultConsumer.Items.Clear();
}
await query.TearDown();
await resultConsumer.TearDown();
}
public async Task TestItemAggregation()
{
var aggregate = GrainClient.GrainFactory.GetGrain <IStreamProcessorSelectAggregate <int, int> >(Guid.NewGuid());
await aggregate.SetFunction(new SerializableFunc <int, int>(_ => _));
var itemsToSend = new List <int> {
1, 5, 32, -12
};
var provider = GrainClient.GetStreamProvider(StreamProvider);
var inputAggregate = new StreamMessageSenderComposite <int>(provider, 2);
await aggregate.SetInput(await inputAggregate.GetOutputStreams());
Assert.AreEqual(2, (await aggregate.GetOutputStreams()).Count);
var consumerAggregate = new TestTransactionalTransactionalStreamConsumerAggregate <int>(provider);
await consumerAggregate.SetInput(await aggregate.GetOutputStreams());
var tid = TransactionGenerator.GenerateTransactionId();
await inputAggregate.StartTransaction(tid);
await inputAggregate.SendMessage(new ItemMessage <int>(itemsToSend));
await inputAggregate.EndTransaction(tid);
var resultItems = consumerAggregate.Items;
Assert.AreEqual(4, resultItems.Count);
CollectionAssert.AreEquivalent(itemsToSend, resultItems);
Assert.IsFalse(await consumerAggregate.AllConsumersTearDownCalled());
await inputAggregate.TearDown();
Assert.IsTrue(await consumerAggregate.AllConsumersTearDownCalled());
}
