public async Task StreamTest_02_OneProducerGrainOneConsumerClient() { Heading("StreamTest_02_OneProducerGrainOneConsumerClient"); Guid streamId = Guid.NewGuid(); consumer = await ConsumerProxy.NewConsumerClientObjectsAsync(streamId, streamProviderName, logger); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); await BasicTestAsync(); await StopProxies(); streamId = Guid.NewGuid(); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); consumer = await ConsumerProxy.NewConsumerClientObjectsAsync(streamId, streamProviderName, logger); await BasicTestAsync(); await StopProxies(); }
//------------------------ One to One ----------------------// public async Task StreamTest_01_OneProducerGrainOneConsumerGrain() { Heading("StreamTest_01_ConsumerJoinsFirstProducerLater"); Guid streamId = Guid.NewGuid(); // consumer joins first, producer later consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); await BasicTestAsync(); await StopProxies(); streamId = Guid.NewGuid(); // produce joins first, consumer later producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); await BasicTestAsync(); await StopProxies(); }
private async Task<bool> CheckGrainsDeactivated(ProducerProxy producer, ConsumerProxy consumer, bool assertAreEqual = true) { var activationCount = 0; string str = ""; if (producer != null) { str = "Producer"; activationCount = await producer.GetNumActivations(); } else if (consumer != null) { str = "Consumer"; activationCount = await consumer.GetNumActivations(); } var expectActivationCount = 0; logger.Info("Test {0} CheckGrainsDeactivated: {1}ActivationCount = {2}, Expected{1}ActivationCount = {3}", testNumber, str, activationCount, expectActivationCount); if (assertAreEqual) { Assert.AreEqual(expectActivationCount, activationCount, String.Format("Expected{0}ActivationCount = {1}, {0}ActivationCount = {2}", str, expectActivationCount, activationCount)); } return expectActivationCount == activationCount; }
private async Task<bool> CheckCounters(ProducerProxy producer, ConsumerProxy consumer, bool assertAreEqual = true) { var consumerCount = await consumer.ConsumerCount; Assert.AreNotEqual(0, consumerCount, "no consumers were detected."); var producerCount = await producer.ProducerCount; var numProduced = await producer.ExpectedItemsProduced; var expectConsumed = numProduced * consumerCount; var numConsumed = await consumer.ItemsConsumed; logger.Info("Test {0} CheckCounters: numProduced = {1}, expectConsumed = {2}, numConsumed = {3}", testNumber, numProduced, expectConsumed, numConsumed); if (assertAreEqual) { Assert.AreEqual(expectConsumed, numConsumed, String.Format("expectConsumed = {0}, numConsumed = {1}", expectConsumed, numConsumed)); return true; } else { return expectConsumed == numConsumed; } }
//public async Task StreamTest_17_Persistence_OneProducerGrainOneConsumerGrain() //{ // Heading("StreamTest_17_Persistence_OneProducerGrainOneConsumerGrain"); // StreamId streamId = StreamId.NewRandomStreamId(); // // consumer joins first, producer later // consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); // producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, logger); // await BasicTestAsync(false); // await consumer.DeactivateOnIdle(); // await producer.DeactivateOnIdle(); // await UnitTestBase.WaitUntilAsync(() => CheckGrainsDeactivated(null, consumer, assertAreEqual: false), _timeout); // await UnitTestBase.WaitUntilAsync(() => CheckGrainsDeactivated(producer, null, assertAreEqual: false), _timeout); // logger.Info("*******************************************************************"); // //await BasicTestAsync(false); // //await StopProxies(); //} public async Task StreamTest_19_ConsumerImplicitlySubscribedToProducerClient() { Heading("StreamTest_19_ConsumerImplicitlySubscribedToProducerClient"); string consumerTypeName = typeof(Streaming_ImplicitlySubscribedConsumerGrain).FullName; Guid streamGuid = Guid.NewGuid(); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamGuid, streamProviderName, "TestNamespace1", logger); consumer = ConsumerProxy.NewConsumerGrainAsync_WithoutBecomeConsumer(streamGuid, logger, consumerTypeName); logger.Info("\n** Starting Test {0}.\n", testNumber); var producerCount = await producer.ProducerCount; logger.Info("\n** Test {0} BasicTestAsync: producerCount={1}.\n", testNumber, producerCount); Func<bool, Task<bool>> waitUntilFunc = async lastTry => 0 < await TestUtils.GetActivationCount(consumerTypeName) && await CheckCounters(producer, consumer, false); await producer.ProduceSequentialSeries(ItemCount); await TestingUtils.WaitUntilAsync(waitUntilFunc, _timeout); await CheckCounters(producer, consumer); await StopProxies(); }
public async Task StreamTest_21_GenericConsumerImplicitlySubscribedToProducerGrain() { Heading("StreamTest_21_GenericConsumerImplicitlySubscribedToProducerGrain"); //ToDo in migrate: the following consumer grain is not implemented in VSO and all tests depend on it fail. string consumerTypeName = "UnitTests.Grains.Streaming_ImplicitlySubscribedGenericConsumerGrain";//typeof(Streaming_ImplicitlySubscribedGenericConsumerGrain).FullName; Guid streamGuid = Guid.NewGuid(); producer = await ProducerProxy.NewProducerGrainsAsync(streamGuid, streamProviderName, "TestNamespace1", logger); consumer = ConsumerProxy.NewConsumerGrainAsync_WithoutBecomeConsumer(streamGuid, logger, consumerTypeName); logger.Info("\n** Starting Test {0}.\n", testNumber); var producerCount = await producer.ProducerCount; logger.Info("\n** Test {0} BasicTestAsync: producerCount={1}.\n", testNumber, producerCount); Func<bool, Task<bool>> waitUntilFunc = async lastTry => 0 < await TestUtils.GetActivationCount(consumerTypeName) && await CheckCounters(producer, consumer, false); await producer.ProduceSequentialSeries(ItemCount); await TestingUtils.WaitUntilAsync(waitUntilFunc, _timeout); await CheckCounters(producer, consumer); await StopProxies(); }
internal async Task StreamTest_Create_OneProducerGrainOneConsumerGrain() { Guid streamId = Guid.NewGuid(); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); }
public async Task StreamTest_16_Deactivation_OneProducerGrainOneConsumerGrain() { Heading("StreamTest_16_Deactivation_OneProducerGrainOneConsumerGrain"); Guid streamId = Guid.NewGuid(); Guid[] consumerGrainIds = { Guid.NewGuid() }; Guid[] producerGrainIds = { Guid.NewGuid() }; // consumer joins first, producer later consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger, producerGrainIds); await BasicTestAsync(false); //await consumer.StopBeingConsumer(); await StopProxies(); await consumer.DeactivateOnIdle(); await producer.DeactivateOnIdle(); await TestingUtils.WaitUntilAsync(lastTry => CheckGrainsDeactivated(null, consumer, false), _timeout); await TestingUtils.WaitUntilAsync(lastTry => CheckGrainsDeactivated(producer, null, false), _timeout); logger.Info("\n\n\n*******************************************************************\n\n\n"); consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger, producerGrainIds); await BasicTestAsync(false); await StopProxies(); }
//----------------------------------------------// public async Task StreamTest_15_ConsumeAtProducersRequest() { Heading("StreamTest_15_ConsumeAtProducersRequest"); Guid streamId = Guid.NewGuid(); // this reproduces a scenario was discovered to not work (deadlock) by the Halo team. the scenario is that // where a producer calls a consumer, which subscribes to the calling producer. producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger); Guid consumerGrainId = await producer.AddNewConsumerGrain(); consumer = ConsumerProxy.NewConsumerGrainAsync_WithoutBecomeConsumer(consumerGrainId, logger); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_14_SameGrain_ProducerFirstConsumerLater(bool useReentrantGrain) { Heading("StreamTest_14_SameGrain_ProducerFirstConsumerLater"); Guid streamId = Guid.NewGuid(); int grain1 = random.Next(); int[] grainIds = new int[] { grain1 }; // produce joins first, consumer later producer = await ProducerProxy.NewProducerConsumerGrainsAsync(streamId, streamProviderName, logger, grainIds, useReentrantGrain); consumer = await ConsumerProxy.NewProducerConsumerGrainsAsync(streamId, streamProviderName, logger, grainIds, useReentrantGrain); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_12_ManySame_ManyProducerClientsManyConsumerGrains() { Heading("StreamTest_12_ManySame_ManyProducerClientsManyConsumerGrains"); Guid streamId = Guid.NewGuid(); Guid grain1 = Guid.NewGuid(); Guid[] consumerGrainIds = new Guid[] { grain1, grain1, grain1 }; consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamId, streamProviderName, null, logger, Many); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_10_ManySame_ManyConsumerGrainsManyProducerGrains() { Heading("StreamTest_10_ManySame_ManyConsumerGrainsManyProducerGrains"); Guid streamId = Guid.NewGuid(); Guid grain1 = Guid.NewGuid(); Guid grain2 = Guid.NewGuid(); Guid[] consumerGrainIds = new Guid[] { grain1, grain1, grain1 }; Guid[] producerGrainIds = new Guid[] { grain2, grain2, grain2 }; // consumer joins first, producer later consumer = await ConsumerProxy.NewConsumerGrainsAsync(streamId, streamProviderName, logger, consumerGrainIds); producer = await ProducerProxy.NewProducerGrainsAsync(streamId, streamProviderName, null, logger, producerGrainIds); await BasicTestAsync(); await StopProxies(); }
public async Task StreamTest_08_ManyDifferent_ManyProducerClientsManyConsumerClients() { Heading("StreamTest_08_ManyDifferent_ManyProducerClientsManyConsumerClients"); Guid streamId = Guid.NewGuid(); consumer = await ConsumerProxy.NewConsumerClientObjectsAsync(streamId, streamProviderName, logger, Many); producer = await ProducerProxy.NewProducerClientObjectsAsync(streamId, streamProviderName, null, logger, Many); await BasicTestAsync(); await StopProxies(); }