Esempio n. 1
0
 public override async Task OnActivateAsync()
 {
     Collection      = new List <T>();
     StreamProvider  = new SingleStreamProvider <ContainerHostedElement <T> >(GetStreamProvider(StreamProviderName), this.GetPrimaryKey());
     _streamConsumer = new SingleStreamConsumer <T>(GetStreamProvider(StreamProviderName), this, TearDown);
     await base.OnActivateAsync();
 }
        public async Task TestItemTransfer()
        {
            var processorNodeGuid = Guid.NewGuid();
            var processor         = GrainClient.GrainFactory.GetGrain <IStreamProcessorSelectNodeGrain <int, int> >(processorNodeGuid);
            await processor.SetFunction(_ => _);

            var itemsToSend = new List <int> {
                -1, 5, 30
            };


            var provider     = GrainClient.GetStreamProvider(StreamProvider);
            var testProvider = new SingleStreamProvider <int>(provider);

            await SubscribeConsumer(testProvider, processor);

            var testConsumer = new MultiStreamListConsumer <int>(provider);

            await SubscribeConsumer(processor, testConsumer);

            var waitForTransaction = testConsumer.TransactionComplete(1);
            await testProvider.SendItems(itemsToSend, true, 1);

            await waitForTransaction;

            CollectionAssert.AreEquivalent(itemsToSend, testConsumer.Items);

            await testProvider.TearDown();
        }
 public override Task OnActivateAsync()
 {
     base.OnActivateAsync();
     StreamProvider  = new SingleStreamProvider <TOut>(GetStreamProvider(StreamProviderNamespace), this.GetPrimaryKey());
     _streamConsumer = new SingleStreamConsumer <TIn>(GetStreamProvider(StreamProviderNamespace), this,
                                                      TearDown);
     return(TaskDone.Done);
 }
        public virtual async Task TearDown()
        {
            if (_streamConsumer != null)
            {
                await _streamConsumer.TearDown();

                _streamConsumer = null;
            }

            if (StreamProvider != null)
            {
                await StreamProvider.TearDown();

                StreamProvider = null;
            }
        }
        public async Task TestTransactionNoItems()
        {
            var processorNodeGuid = Guid.NewGuid();

            var processor = GrainClient.GrainFactory.GetGrain <IStreamProcessorSelectNodeGrain <int, int> >(processorNodeGuid);

            await processor.SetFunction(_ => _);

            var provider     = GrainClient.GetStreamProvider(StreamProvider);
            var testProvider = new SingleStreamProvider <int>(provider);

            await SubscribeConsumer(testProvider, processor);

            var testConsumer = new MultiStreamListConsumer <int>(provider);

            await SubscribeConsumer(processor, testConsumer);

            Task waitForTransaction = testConsumer.TransactionComplete(1);
            await testProvider.SendItems(new List <int>(), true, 1);

            await waitForTransaction;

            await testProvider.TearDown();
        }