Exemplo n.º 1
0
        public async Task IfAsync_RekeepIncrementsStoreCountAndSetsLastStoreTime()
        {
            // ARRANGE
            var messageKeeper = MessageKeeperFactory.GetMessageKeeper(ConnectionString);

            // ACT
            var order = CreateOrder();
            await messageKeeper.KeepAsync("Orders", order);

            var storedOrder = await messageKeeper.RetrieveMessageAsync <Order>("Orders");

            var storeCount1    = storedOrder.StoreCount;
            var lastStoreTime1 = storedOrder.LastStoreTime;

            await Task.Delay(100);

            messageKeeper.Rekeep("Orders", storedOrder);
            storedOrder = await messageKeeper.RetrieveMessageAsync <Order>("Orders");

            var storeCount2    = storedOrder.StoreCount;
            var lastStoreTime2 = storedOrder.LastStoreTime;

            // ASSERT
            Assert.AreEqual(storeCount1 + 1, storeCount2);
            Assert.IsTrue(lastStoreTime2 > lastStoreTime1);
        }
Exemplo n.º 2
0
        private async Task KeepRetrieveRekeepLoopAsync(int iterations, ConcurrentDictionary <string, int> items)
        {
            var messageKeeper = MessageKeeperFactory.GetMessageKeeper(ConnectionString);

            // create a number of different orders concurrently (with other running tasks)
            for (int i = 0; i < iterations; i++)
            {
                var order = CreateOrder();
                await messageKeeper.KeepAsync("Orders", order);
            }

            // then retrieve and rekeep from all running tasks concurrently
            for (int i = 0; i < iterations; i++)
            {
                var storedOrder = await messageKeeper.RetrieveMessageAsync <Order>("Orders");

                if (storedOrder != null)
                {
                    var key = storedOrder.Payload.OrderId + ":" + storedOrder.StoreCount;
                    if (items.ContainsKey(key))
                    {
                        items[key]++;
                    }
                    else
                    {
                        items.TryAdd(key, 1);
                    }
                    await messageKeeper.RekeepAsync("Orders", storedOrder);
                }
            }

            // finally Retrieve all the orders to empty the keep
            IStoredMessage <Order> storedMessage = await messageKeeper.RetrieveMessageAsync <Order>("Orders");

            while (storedMessage != null)
            {
                var key = storedMessage.Payload.OrderId + ":" + storedMessage.StoreCount;
                if (items.ContainsKey(key))
                {
                    items[key]++;
                }
                else
                {
                    items.TryAdd(key, 1);
                }

                storedMessage = await messageKeeper.RetrieveMessageAsync <Order>("Orders");
            }
        }
Exemplo n.º 3
0
        public void IfSync_IsFifoInSingleThreadedScenario()
        {
            // ARRANGE
            var messageKeeper = MessageKeeperFactory.GetMessageKeeper(ConnectionString);

            // ACT
            for (int i = 0; i < 10; i++)
            {
                var order = CreateOrder(i);
                messageKeeper.Keep("Orders", order);
            }

            // ASSERT
            for (int i = 0; i < 10; i++)
            {
                var order = messageKeeper.RetrieveMessage <Order>("Orders");
                Assert.AreEqual(order.Payload.OrderId, i);
            }
        }