Example #1
0
        public void Batch_Persistance_Is_Triggered_By_Entries_Amount()
        {
            var shouldSucceed = false;

            Task failure(object[] items)
            {
                Assert.AreEqual(100, items.Length);
                shouldSucceed = true;
                return(Task.CompletedTask);
            }

            using (var submitter = new BatchSubmitter <object>(TimeSpan.FromHours(1), 100, failure))
            {
                var data = _fixture.CreateMany <object>(100);

                foreach (var obj in data)
                {
                    submitter.Enqueue(obj);
                }

                Task.Delay(50).Wait();

                Assert.IsTrue(shouldSucceed);
            }
        }
Example #2
0
        public void Batch_Persistance_Is_Triggered_By_Time_Expiration()
        {
            var shouldSucceed = false;

            Task write(DateTime[] times)
            {
                Assert.AreEqual(1, times.Length);

                foreach (var time in times)
                {
                    Assert.That(DateTimeOffset.UtcNow - time, Is.InRange(TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(1300)));
                }

                shouldSucceed = true;
                return(Task.CompletedTask);
            }

            using (var submitter = new BatchSubmitter <DateTime>(TimeSpan.FromSeconds(1), 100, write))
            {
                submitter.Enqueue(DateTime.UtcNow);

                Task.Delay(TimeSpan.FromSeconds(2)).Wait();
            }

            Assert.IsTrue(shouldSucceed);
        }
Example #3
0
        public void Batch_Persistance_Is_Not_Triggered_If_There_Are_No_Entries()
        {
            Task failure(object[] items)
            {
                Assert.Fail();
                return(Task.CompletedTask);
            }

            using (var submitter = new BatchSubmitter <object>(TimeSpan.FromMilliseconds(100), 1, failure))
            {
                Task.Delay(200).Wait();
            }
        }
Example #4
0
        public void Batch_Persistance_Is_Triggered_By_Disposing()
        {
            var shouldSucceed = false;

            Task write(object[] data)
            {
                Assert.AreEqual(1, data.Length);

                shouldSucceed = true;
                return(Task.CompletedTask);
            }

            using (var submitter = new BatchSubmitter <object>(TimeSpan.FromHours(1), 10, write))
            {
                submitter.Enqueue(new object());
            }

            Assert.IsTrue(shouldSucceed);
        }
Example #5
0
        public void Batch_Persistence_Is_Triggered_By_Entries_Amount_Extends_Batch_Lifetime()
        {
            var batchTimes  = new List <DateTime>();
            var batchCounts = new List <int>();

            Task write(object[] items)
            {
                batchTimes.Add(DateTime.UtcNow);
                batchCounts.Add(items.Length);

                return(Task.CompletedTask);
            }

            using (var submitter = new BatchSubmitter <object>(TimeSpan.FromSeconds(1), 10, write))
            {
                var data = _fixture.CreateMany <object>(9);

                foreach (var userLogRequest in data)
                {
                    submitter.Enqueue(userLogRequest);
                }

                //Wait half of a batch lifetime
                Task.Delay(500).Wait();

                //Complete batch
                submitter.Enqueue(new object());

                //Perform a batch
                Task.Delay(50).Wait();

                //Fill new batch
                submitter.Enqueue(new object());

                //Let batch time elapse
                Task.Delay(2000).Wait();

                Assert.AreEqual(2, batchTimes.Count);
                Assert.AreEqual(10, batchCounts.First());
                Assert.AreEqual(1, batchCounts.Last());
            }
        }
Example #6
0
    static async Task Main()
    {
        Console.Title = "UserApplication";

        var batchSubmitter = new BatchSubmitter(ServerInfo.UserApplicationWebBackendBaseAddress);

        using (var hubConnection = new HubConnection(ServerInfo.UserApplicationWebBackendBaseAddress))
        {
            var hubProxy = hubConnection.CreateHubProxy("UserApplicationHub");

            hubProxy.On <string>("PushStatusUpdate", Console.WriteLine);

            await hubConnection.Start()
            .ConfigureAwait(false);

            Console.WriteLine("Press 'S' to send a batch request.");
            Console.WriteLine("Press the escape key to exit");

            while (true)
            {
                var key = Console.ReadKey();
                Console.WriteLine();

                if (key.Key == ConsoleKey.S)
                {
                    Console.WriteLine("Input a batch id and press enter.");
                    Console.Write("Batch id: ");
                    var batchId = Console.ReadLine().Replace("Batch id: ", "");

                    await batchSubmitter.Submit(batchId, BatchData.Generate()).ConfigureAwait(false);
                }
                else if (key.Key == ConsoleKey.Escape)
                {
                    break;
                }
            }

            hubConnection.Stop();
        }
    }
Example #7
0
        public void Batch_Persistance_Is_Not_Triggered_If_Entries_Amount_Not_Reached_And_Batch_Lifetime_Is_Expired()
        {
            var shouldSucceed = false;

            Task failure(object[] items)
            {
                Assert.IsTrue(shouldSucceed);
                return(Task.CompletedTask);
            }

            using (var submitter = new BatchSubmitter <object>(TimeSpan.FromHours(1), 100, failure))
            {
                var data = _fixture.CreateMany <object>(90);

                foreach (var obj in data)
                {
                    submitter.Enqueue(obj);
                }

                Task.Delay(50);

                shouldSucceed = true;
            }
        }