Ejemplo n.º 1
0
 public void AskToIntegrateFailsIfUnableToLock()
 {
     var project = new ProjectStub();
     var queue = new TestQueue();
     var context = new IntegrationContext(project);
     queue.Lock();
     Assert.Throws<Exception>(() => queue.AskToIntegrate(context));
 }
Ejemplo n.º 2
0
 public void CompletingAnIntegrationFailsIfUnableToLock()
 {
     var project = new ProjectStub();
     var queue = new TestQueue();
     var context = new IntegrationContext(project);
     queue.AskToIntegrate(context);
     queue.Lock();
     Assert.Throws<Exception>(context.Complete);
 }
Ejemplo n.º 3
0
        public void TestArrayResize()
        {
            const int initCapacity = DataStructures.Queue <int?> .InitCapacity;

            Assert.Equal(initCapacity, TestQueue.Capacity);

            TestQueue.Enqueue(1);
            TestQueue.Enqueue(2);
            TestQueue.Enqueue(3);
            TestQueue.Enqueue(4);
            Assert.Equal(initCapacity, TestQueue.Capacity);

            TestQueue.Enqueue(5);
            Assert.Equal(initCapacity * 2, TestQueue.Capacity);
        }
Ejemplo n.º 4
0
        public void can_wait_for_a_specific_message()
        {
            using (var tq = new TestQueue(_dispatcher))
            {
                var evt  = new TestEvent();
                var evt2 = new TestEvent();
                _dispatcher.Publish(evt);
                _dispatcher.Publish(evt2);

                tq.WaitForMsgId(evt2.MsgId, TimeSpan.FromMilliseconds(200));

                tq.AssertNext <TestEvent>(evt.CorrelationId)
                .AssertNext <TestEvent>(evt2.CorrelationId)
                .AssertEmpty();
            }
        }
        private void CreateTestStorageEntities()
        {
            string connectionString            = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage);
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);

            CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();

            TestQueue = queueClient.GetQueueReference("test-input");
            TestQueue.CreateIfNotExists();
            TestQueue.Clear();

            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

            TestContainer = blobClient.GetContainerReference("test-output");
            TestContainer.CreateIfNotExists();
        }
Ejemplo n.º 6
0
        public void TestEnqueue()
        {
            PopulateTestQueue();
            Assert.Equal(SampleSize, TestQueue.Count);

            int currentValue = 2;

            do
            {
                Assert.Equal(currentValue, TestQueue.Dequeue());
                currentValue++;
            } while (TestQueue.Count > 0);

            TestQueue.Enqueue(null);
            Assert.Null(TestQueue.Dequeue());
        }
Ejemplo n.º 7
0
        public void can_wait_for_multiple_messages_of_a_type()
        {
            using (var tq = new TestQueue(_dispatcher))
            {
                var evt  = new TestEvent();
                var evt2 = new TestEvent();
                _dispatcher.Publish(evt);
                _dispatcher.Publish(evt2);

                tq.WaitForMultiple <TestEvent>(2, TimeSpan.FromMilliseconds(100));
                Assert.Throws <TimeoutException>(() => tq.WaitForMultiple <TestEvent>(3, TimeSpan.FromMilliseconds(100)));
                tq.AssertNext <TestEvent>(evt.CorrelationId)
                .AssertNext <TestEvent>(evt2.CorrelationId)
                .AssertEmpty();
            }
        }
 public void will_not_cross_cancel()
 {
     TestQueue.WaitFor <TestTokenCancellableCmd>(TimeSpan.FromSeconds(2));
     TokenSource1.Cancel();
     Handler.ParkedMessages[Cmd1.MsgId].Set();
     TestQueue.WaitFor <Canceled>(TimeSpan.FromSeconds(2));
     Handler.ParkedMessages[Cmd2.MsgId].Set();
     TestQueue.WaitFor <Success>(TimeSpan.FromSeconds(3));
     TestQueue.Commands
     .AssertNext <TestTokenCancellableCmd>(_ => true)
     .AssertNext <TestTokenCancellableCmd>(_ => true)
     .AssertEmpty();
     TestQueue.Responses
     .AssertNext <Canceled>(msg => msg.SourceCommand.MsgId == Cmd1.MsgId)
     .AssertNext <Success>(msg => msg.SourceCommand.MsgId == Cmd2.MsgId)
     .AssertEmpty();
 }
Ejemplo n.º 9
0
        public void can_wait_for_a_specific_message_twice()
        {
            using (var tq = new TestQueue(_dispatcher))
            {
                var evt = new TestEvent();
                Task.Delay(50)
                .ContinueWith(_ => _dispatcher.Publish(evt));

                Parallel.Invoke(
                    () => tq.WaitForMsgId(evt.MsgId, TimeSpan.FromMilliseconds(200)),
                    () => tq.WaitForMsgId(evt.MsgId, TimeSpan.FromMilliseconds(200))
                    );

                tq.AssertNext <TestEvent>(evt.CorrelationId)
                .AssertEmpty();
            }
        }
Ejemplo n.º 10
0
        public void slow_commands_should_throw_timeout()
        {
            Assert.Throws <CommandTimedOutException>(
                () => Bus.Fire(new TestCommands.TimeoutTestCommand(Guid.NewGuid(), null))
                );

            Assert.IsOrBecomesTrue(() => Interlocked.Read(ref gotCmd1) == 1, msg: "Expected Cmd1 handled");

            TestQueue.WaitFor <TestCommands.TimeoutTestCommand>(TimeSpan.FromMilliseconds(2000));
            TestQueue.WaitFor <Canceled>(TimeSpan.FromMilliseconds(2000));
            TestQueue.Commands
            .AssertNext <TestCommands.TimeoutTestCommand>(_ => true)
            .AssertEmpty();
            TestQueue.Responses
            .AssertNext <Canceled>(msg =>
                                   msg.Exception is CommandCanceledException)
            .AssertEmpty();
        }
Ejemplo n.º 11
0
        public void TestDequeue()
        {
            PopulateTestQueue();
            Assert.Equal(SampleSize, TestQueue.Count);

            int currentValue = 2;
            int queueCount   = SampleSize;

            do
            {
                Assert.Equal(currentValue, TestQueue.Dequeue());
                currentValue++;

                queueCount--;
                Assert.Equal(queueCount, TestQueue.Count);
            } while (TestQueue.Count > 0);
            Assert.Empty(TestQueue);
        }
Ejemplo n.º 12
0
        public void grand_child_invokes_all_handlers_four_times()
        {
            //n.b. the number of duplications matched the number of times we have subscribed to the hierarchy
            //see the next test where we do not subscribe to Message
            // the subscription to Test Event does not matter because it tis outside the heirarchy
            using (var sub = new TestInheritedMessageSubscriber(Bus, false))
            {
                var subscriber = sub;
                subscriber.Subscribe <Message>(subscriber);

                TestQueue.Clear();
                Bus.Publish(new GrandChildTestDomainEvent(TestCorrelationId, ChildMsgId));

                BusMessages
                .AssertNext <GrandChildTestDomainEvent>(TestCorrelationId)
                .AssertEmpty();

                Assert.IsOrBecomesTrue(() => subscriber.Starving, 3000);

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.TestDomainEventHandleCount) == 0,
                    1000,
                    $"Expected 0 Test Domain Event Handled, found {subscriber.TestDomainEventHandleCount}");

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.GrandChildTestDomainEventHandleCount) == 4,
                    3000,
                    $"Expected 4 GrandChildTestDomainEvent handled , found {subscriber.ChildTestDomainEventHandleCount}");

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.ChildTestDomainEventHandleCount) == 4,
                    3000,
                    $"Expected 4 ChildTestDomainEvent handled , found {subscriber.ChildTestDomainEventHandleCount}");

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.ParentTestDomainEventHandleCount) == 4,
                    3000,
                    $"Expected 4 Parent Test Domain Event handled, found {subscriber.ParentTestDomainEventHandleCount}");
                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.MessageHandleCount) == 4,
                    3000,
                    $"Expected 4 Message Test Domain Event handled, found {subscriber.MessageHandleCount}");
            }
        }
Ejemplo n.º 13
0
        public void TestCopyTo()
        {
            PopulateTestQueue();
            int?[] copyArray = new int?[SampleSize + 1];
            TestQueue.CopyTo(copyArray, 1);

            for (int i = 1; i < copyArray.Length; i++)
            {
                Assert.Equal(TestQueue.Dequeue(), copyArray[i]);
            }

            PopulateTestQueue();
            int?[] smallList = new int?[TestQueue.Count / 2];
            int?[] largeList = new int?[TestQueue.Count * 2];

            Assert.Throws <IndexOutOfRangeException>(() => TestQueue.CopyTo(largeList, -1));
            Assert.Throws <ArgumentOutOfRangeException>(() => TestQueue.CopyTo(smallList, 0));
            Assert.Throws <ArgumentOutOfRangeException>(() => TestQueue.CopyTo(largeList, largeList.Length - 2));
        }
Ejemplo n.º 14
0
        public async Task Refresh_Works_NoEvent(FFXIVRole role)
        {
            var queue        = new TestQueue();
            var enqueuedSlot = new QueueSlot(UserId, "", new List <ulong>())
            {
                QueueTime = DateTime.UtcNow.AddHours(-4).AddMinutes(-45),
            };

            queue.AddSlot(enqueuedSlot, role);
            await Task.Delay(1000);

            var now = DateTime.UtcNow;

            queue.Refresh(UserId);
            var dequeuedSlot = queue.GetAllSlots().First();

            Assert.AreEqual(now.Hour, dequeuedSlot.QueueTime.Hour);
            Assert.AreEqual(now.Minute, dequeuedSlot.QueueTime.Minute);
        }
Ejemplo n.º 15
0
        public void can_get_all_messages_from_queue()
        {
            using (var tq = new TestQueue(_dispatcher))
            {
                var evt = new TestEvent();
                var cmd = new TestCommands.Command1();
                _dispatcher.Publish(evt);
                _dispatcher.Send(cmd);

                tq.WaitFor <CommandResponse>(TimeSpan.FromMilliseconds(100));
                tq.WaitFor <Success>(TimeSpan.FromMilliseconds(100));
                Assert.Throws <TimeoutException>(() => tq.WaitFor <Fail>(TimeSpan.FromMilliseconds(10)));
                tq.AssertNext <TestEvent>(evt.CorrelationId)
                .AssertNext <AckCommand>(cmd.CorrelationId)
                .AssertNext <Success>(cmd.CorrelationId)
                .AssertNext <TestCommands.Command1>(cmd.CorrelationId)
                .AssertEmpty();
            }
        }
Ejemplo n.º 16
0
        public void commands_are_not_logged()
        {
            TestQueue.WaitFor <TestCommands.TestCommand3>(TimeSpan.FromSeconds(5));
            // Wait  for last command to be queued

            //    // Wait  for last event to be queued
            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _multiFireCount > 0,
                                              1000,
                                              $"Commands logged to ES when logging should be disabled - {_multiFireCount}"));

            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _testCommandCount == 1,
                                              1000,
                                              $"Last command logged to ES when logging should be disabled"));

            Assert.False(_multiFireCount == _maxCountedCommands, $"Command count {_multiFireCount} doesn't match expected index {_maxCountedCommands}");
            Assert.False(_testCommandCount == 1, $"Last event count {_testCommandCount} doesn't match expected value {1}");
        }
Ejemplo n.º 17
0
        public static void ExampleTestQueue()
        {
            ITestProvider testProvider = new TestProvider();

            testProvider.Model  = "7482-5194-2849-1943-2448";
            testProvider.Method = "com.example.test.Demo.typeString";

            TestQueue queue = testProvider.QueueNWise();

            Console.WriteLine(queue); // DEBUG
            Thread.Sleep(2000);       // DEBUG
            Console.WriteLine(queue); // DEBUG

            foreach (TestCaseData element in queue)
            {
                Console.WriteLine("HANDLER: [{0}]", string.Join(", ", element.Arguments));
            }

            Console.WriteLine(queue); // DEBUG
        }
        public void events_are_not_logged()
        {
            // wait for all events to be queued
            TestQueue.WaitFor <TestDomainEvent>(TimeSpan.FromSeconds(5));

            //// Need the "is or becomes" here because if the handler (see below) is executed, it takes time.
            // see the enabled test

            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _countedEventCount > 0,
                                              1000,
                                              $"Found {_countedEventCount} CountedEvents on log"));
            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _testDomainEventCount > 0,
                                              1000,
                                              $"Found {_testDomainEventCount} TestDomainEvents on log"));

            // counters are never incremented because they are not logged, therefore not "heard" by the repo listener
            Assert.False(_countedEventCount == _maxCountedEvents, $"{_countedEventCount} CountedEvents found on Log");
            Assert.True(_testDomainEventCount == 0, $"Last event count {_testDomainEventCount} is not 0");
        }
Ejemplo n.º 19
0
    public async Task QueueOnExitCalledEvenIfNextErrors()
    {
        var flag = false;

        var testQueue = new TestQueue(
            onTryEnter: (_) => true,
            onExit: () => { flag = true; });

        var middleware = TestUtils.CreateTestMiddleware(
            queue: testQueue,
            next: httpContext =>
        {
            throw new DivideByZeroException();
        });

        Assert.Equal(0, testQueue.QueuedRequests);
        await Assert.ThrowsAsync <DivideByZeroException>(() => middleware.Invoke(new DefaultHttpContext())).DefaultTimeout();

        Assert.Equal(0, testQueue.QueuedRequests);
        Assert.True(flag);
    }
Ejemplo n.º 20
0
        public void can_wait_for_multiple_messages_not_yet_recieved()
        {
            using (var tq = new TestQueue(_dispatcher))
            {
                var evt  = new TestEvent();
                var evt2 = new TestEvent();
                Task.Delay(50)
                .ContinueWith(_ =>
                {
                    _dispatcher.Publish(evt);
                    _dispatcher.Publish(evt2);
                });

                tq.WaitForMsgId(evt.MsgId, TimeSpan.FromMilliseconds(200));
                tq.WaitForMsgId(evt2.MsgId, TimeSpan.FromMilliseconds(200));

                tq.AssertNext <TestEvent>(evt.CorrelationId)
                .AssertNext <TestEvent>(evt2.CorrelationId)
                .AssertEmpty();
            }
        }
        public void can_subscribe_to_all()
        {
            foreach (var repo in _repos)
            {
                var r = repo as MockEventStoreRepository;
                if (r == null)
                {
                    continue;
                }
                var q = new TestQueue();
                r.Subscribe(q);

                var id   = Guid.NewGuid();
                var tAgg = new TestAggregate(id);
                tAgg.RaiseBy(1);
                tAgg.RaiseBy(1);
                tAgg.RaiseBy(1);
                repo.Save(tAgg, Guid.NewGuid(), h => { });

                Assert.Equal(4, q.Messages.Count);
            }
        }
Ejemplo n.º 22
0
        public async Task DequeueThings(CancellationToken cancel)
        {
            Debug.WriteLine("DEQUEUE cancel? " + cancel.IsCancellationRequested);

            while (cancel.IsCancellationRequested == false)
            {
                string thingy = "";
                if (TestQueue.TryPeekAwait(out thingy))
                {
                    await Task.Delay(50);

                    TestQueue.TryDequeue(out thingy);
                    OutputText = "dequeued: " + thingy + "             queue count: " + TestQueue.Count();
                    Debug.WriteLine("dequeued: " + thingy);
                }
                if (TestQueue.Count() == 0)
                {
                    Debug.WriteLine("cancel");
                    source2.Cancel();
                }
            }
        }
Ejemplo n.º 23
0
    public void EventCountersTrackQueuedRequests()
    {
        var blocker = new TaskCompletionSource <bool>();

        var testQueue = new TestQueue(
            onTryEnter: async(_) =>
        {
            return(await blocker.Task);
        });
        var middleware = TestUtils.CreateTestMiddleware(testQueue);

        Assert.Equal(0, testQueue.QueuedRequests);

        var task1 = middleware.Invoke(new DefaultHttpContext());

        Assert.False(task1.IsCompleted);
        Assert.Equal(1, testQueue.QueuedRequests);

        blocker.SetResult(true);

        Assert.Equal(0, testQueue.QueuedRequests);
    }
Ejemplo n.º 24
0
        public void can_handle_all_messages()
        {
            TestQueue.Clear();

            var cmdHandler = new TestCommandSubscriber(Bus);

            // this is just an example command - choice to fire this one was random
            var cmd = new TestCommands.TestCommand2(
                Guid.NewGuid(),
                null);

            Bus.Fire(cmd,
                     "exception message",
                     TimeSpan.FromSeconds(5));

            Assert.IsOrBecomesTrue(
                () => BusMessages.Count == 3,
                1000,
                $"Expected 3 bus messages for TestCommand2, found {BusMessages.Count}");


            Message deQdMsg;

            if (BusMessages.TryDequeue(out deQdMsg))
            {
                Assert.IsAssignableFrom <Message>(deQdMsg);
            }

            if (BusMessages.TryDequeue(out deQdMsg))
            {
                Assert.IsAssignableFrom <Message>(deQdMsg);
            }

            if (BusMessages.TryDequeue(out deQdMsg))
            {
                Assert.IsAssignableFrom <Message>(deQdMsg);
            }
        }
Ejemplo n.º 25
0
        public void Enqueue_IsThreadSafe()
        {
            var rand    = new Random(1234);
            var queue   = new TestQueue();
            var threads = new List <Thread>();

            for (ulong i = 0; i < 1000; i++)
            {
                var curI     = i;
                var nextRole = rand.Next(0, 3) switch
                {
                    0 => FFXIVRole.DPS,
                    1 => FFXIVRole.Healer,
                    2 => FFXIVRole.Tank,
                    _ => throw new NotImplementedException(),
                };
                var thread = new Thread(() =>
                {
                    Thread.Sleep(rand.Next(0, 1001));
                    queue.Enqueue(curI, nextRole, "");
                });
                thread.Start();
                threads.Add(thread);
            }

            foreach (var thread in threads)
            {
                thread.Join();
            }

            var slots = queue.GetAllSlots().ToList();

            slots.Sort((a, b) => (int)a.Id - (int)b.Id);
            for (ulong i = 0; i < 1000; i++)
            {
                Assert.That(slots[(int)i].Id == i);
            }
        }
Ejemplo n.º 26
0
        public void mixed_messages_are_not_logged()
        {
            // all events published, commands fired
            TestQueue.WaitFor <TestCommands.TestCommand3>(TimeSpan.FromSeconds(5));

            // Wait  for last CountedEvent to be "heard" from logger/repo - times out because events not logged
            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _countedEventCount > 0,
                                              1000,
                                              $"Found {_countedEventCount} CountedEvents on log"));

            Assert.True(_countedEventCount == 0,
                        $"{_countedEventCount} CountedEvents found on Log");

            // Wait  for last command to be queued - times out because events not logged
            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _multiFireCount > 0,
                                              9000,
                                              $"Found {_multiFireCount} TestCommand2s on log - expected 0"));

            Assert.True(_multiFireCount == 0, $"Command count {_multiFireCount}  expected 0");


            // Wait  for last TestDomainEvent to be "heard" from logger/repo - times out because events not logged
            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _testDomainEventCount > 0,
                                              1000,
                                              $"Found {_testDomainEventCount} TestDomainEvents on log, expected 0"));

            Assert.True(_testDomainEventCount == 0, $"Last event count {_testDomainEventCount} doesn't match expected value {1}");

            Assert.Throws <TrueException>(() => Assert.IsOrBecomesTrue(
                                              () => _testCommandCount == 1,
                                              1000,
                                              $"Found {_testCommandCount} TestCommand3s on log - expected 0"));

            Assert.True(_testCommandCount == 0, $"Last event count {_testCommandCount} is not 0");
        }
Ejemplo n.º 27
0
        public IAsyncResult BeginOpenLink(AmqpLink link, TimeSpan timeout, AsyncCallback callback, object state)
        {
            if (link.IsReceiver && link.Settings.Target is Coordinator)
            {
                this.txnManager.AddCoordinator((ReceivingAmqpLink)link);
            }
            else
            {
                Address address = link.IsReceiver ?
                                  ((Target)link.Settings.Target).Address :
                                  ((Source)link.Settings.Source).Address;

                if (address == null)
                {
                    throw new AmqpException(AmqpErrorCode.InvalidField, "Address not set");
                }

                string    node = address.ToString();
                TestQueue queue;
                lock (this.queues)
                {
                    if (!this.queues.TryGetValue(node, out queue))
                    {
                        if (!this.implicitQueue)
                        {
                            throw new AmqpException(AmqpErrorCode.NotFound, string.Format("Node '{0}' not found", address));
                        }

                        queue = new TestQueue(this);
                        this.queues.Add(node, queue);
                    }
                }

                queue.CreateClient(link);
            }

            return(new CompletedAsyncResult(callback, state));
        }
Ejemplo n.º 28
0
        public void ExpireEvent_Works_Event()
        {
            var rand  = new Random(1234);
            var queue = new TestQueue();

            for (ulong i = 0; i < 1000; i++)
            {
                var nextRole = rand.Next(0, 3) switch
                {
                    0 => FFXIVRole.DPS,
                    1 => FFXIVRole.Healer,
                    2 => FFXIVRole.Tank,
                    _ => throw new NotImplementedException(),
                };
                queue.Enqueue(i, nextRole, EventId);
            }

            queue.ExpireEvent(EventId);

            var slots = queue.GetAllSlots();

            Assert.That(!slots.Any());
        }
Ejemplo n.º 29
0
        public void QueryTimeout_NoIncludeEvents_Works()
        {
            var rand   = new Random(1234);
            var queue  = new TestQueue();
            var counts = new Dictionary <FFXIVRole, int>
            {
                { FFXIVRole.DPS, 0 },
                { FFXIVRole.Healer, 0 },
                { FFXIVRole.Tank, 0 },
            };

            for (ulong i = 0; i < 1000; i++)
            {
                var nextRole = rand.Next(0, 3) switch
                {
                    0 => FFXIVRole.DPS,
                    1 => FFXIVRole.Healer,
                    2 => FFXIVRole.Tank,
                    _ => throw new NotImplementedException(),
                };
                counts[nextRole]++;
                queue.AddSlot(new QueueSlot(i, EventId)
                {
                    QueueTime = DateTime.UtcNow.AddHours(-5),
                }, nextRole);
            }

            var roles    = new[] { FFXIVRole.DPS, FFXIVRole.Healer, FFXIVRole.Tank };
            var timeouts = new Dictionary <FFXIVRole, IEnumerable <ulong> >();

            foreach (var role in roles)
            {
                timeouts[role] = queue.TryQueryTimeout(role, 4 * Time.Hour);
            }
            Assert.That(timeouts[FFXIVRole.DPS].Concat(timeouts[FFXIVRole.Healer]).Concat(timeouts[FFXIVRole.Tank]).Count() == 1000);
            Assert.That(!queue.GetAllSlots().Any());
        }
Ejemplo n.º 30
0
        public void RunNextTest(string directory)
        {
            CurrentTest = TestQueue.Dequeue();
            NetworkStream stream = clientSocket.GetStream();

            Console.WriteLine("Running " + CurrentTest.TestName + " ...");
            SocketUtil.SendMessage(stream, "start;" + CurrentTest.TestName);
            SQLResponse response = RunQuerySync(CurrentTest.Query);

            if (response == null)
            {
                Console.WriteLine("Test " + CurrentTest.TestName + " failed :(");
                SocketUtil.SendMessage(stream, "reset;failed");
            }
            else
            {
                Console.WriteLine("Test " + CurrentTest.TestName + " Passed! Execution Time: " + response.ExecutionTime + " ms");

                SocketUtil.SendMessage(stream, "reset");

                string jsonData = GetOrderedResult(stream);
                HandleResult(directory, jsonData, response);
            }
        }
        public void parent_invokes_only_parent_handler_once()
        {
            using (var sub = new TestInheritedMessageSubscriber(Bus))
            {
                var subscriber = sub;
                TestQueue.Clear();

                Bus.Publish(new ParentTestDomainEvent(TestCorrelationId, ChildMsgId));

                BusMessages
                .AssertNext <ParentTestDomainEvent>(TestCorrelationId)
                .AssertEmpty();

                Assert.IsOrBecomesTrue(() => subscriber.Starving, 3000);

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.TestDomainEventHandleCount) == 0,
                    1000,
                    $"Expected 0 Test Domain Event Handled, found {subscriber.TestDomainEventHandleCount}");

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.GrandChildTestDomainEventHandleCount) == 0,
                    1000,
                    $"Expected 0 GrandChildTestDomainEvent handled , found {subscriber.ChildTestDomainEventHandleCount}");

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.ChildTestDomainEventHandleCount) == 0,
                    1000,
                    $"Expected 0 ChildTestDomainEvent handled , found {subscriber.ChildTestDomainEventHandleCount}");

                Assert.IsOrBecomesTrue(
                    () => Interlocked.Read(ref subscriber.ParentTestDomainEventHandleCount) == 1,
                    1000,
                    $"Expected 1 Parent Test Domain Event handled, found {subscriber.ParentTestDomainEventHandleCount}");
            }
        }
Ejemplo n.º 32
0
        bool IContainer.AttachLink(ListenerConnection connection, ListenerSession session, Link link, Attach attach)
        {
            Source source  = attach.Source as Source;
            Target target  = attach.Target as Target;
            bool   dynamic = false;
            string address = null;

            if (attach.Role)
            {
                address = source.Address;
                dynamic = source.Dynamic;
            }
            else
            {
                if (target != null)
                {
                    address = target.Address;
                    dynamic = target.Dynamic;
                }
                else if (attach.Target is Coordinator)
                {
                    this.txnManager.AddCoordinator((ListenerLink)link);
                    return(true);
                }
            }

            if (dynamic)
            {
                address = string.Format("$dynamic.{0}", Interlocked.Increment(ref this.dynamidId));
                if (attach.Role)
                {
                    source.Dynamic = false;
                    source.Address = address;
                }
                else
                {
                    target.Address = address;
                    target.Dynamic = false;
                }
            }

            TestQueue queue;

            lock (this.queues)
            {
                if (!this.queues.TryGetValue(address, out queue))
                {
                    if (dynamic || (this.implicitQueue && !link.Name.StartsWith("$explicit:")))
                    {
                        queue = new TestQueue(this);
                        this.queues.Add(address, queue);
                        connection.Closed += (o, e) => this.RemoveQueue(address);
                    }
                    else
                    {
                        throw new AmqpException(ErrorCode.NotFound, string.Format("Node '{0}' not found", address));
                    }
                }
            }

            if (attach.Role)
            {
                queue.CreateConsumer((ListenerLink)link);
            }
            else
            {
                queue.CreatePublisher((ListenerLink)link);
            }

            return(true);
        }
Ejemplo n.º 33
0
 public void GetPendingRequestsFailsIfUnableToLock()
 {
     var queue = new TestQueue();
     queue.Lock();
     Assert.Throws<Exception>(() => queue.GetPendingRequests());
 }
Ejemplo n.º 34
0
                public Consumer(TestQueue queue, ListenerLink link, int id)
                {
                    this.queue = queue;
                    this.link = link;
                    this.id = id;

                    link.Closed += this.OnLinkClosed;
                    link.InitializeSender(onCredit, onDispose, this);
                }
Ejemplo n.º 35
0
                public Publisher(TestQueue queue, ListenerLink link, int id)
                {
                    this.queue = queue;
                    this.link = link;
                    this.id = id;

                    link.Closed += this.OnLinkClosed;
                    link.InitializeReceiver(200, onMessage, this);
                }
Ejemplo n.º 36
0
        bool IContainer.AttachLink(ListenerConnection connection, ListenerSession session, Link link, Attach attach)
        {
            Source source = attach.Source as Source;
            Target target = attach.Target as Target;
            bool dynamic = false;
            string address = null;
            if (attach.Role)
            {
                address = source.Address;
                dynamic = source.Dynamic;
            }
            else
            {
                if (target != null)
                {
                    address = target.Address;
                    dynamic = target.Dynamic;
                }
                else if (attach.Target is Coordinator)
                {
                    this.txnManager.AddCoordinator((ListenerLink)link);
                    return true;
                }
            }

            if (dynamic)
            {
                address = string.Format("$dynamic.{0}", Interlocked.Increment(ref this.dynamidId));
                if (attach.Role)
                {
                    source.Dynamic = false;
                    source.Address = address;
                }
                else
                {
                    target.Address = address;
                    target.Dynamic = false;
                }
            }

            TestQueue queue;
            lock (this.queues)
            {
                if (!this.queues.TryGetValue(address, out queue))
                {
                    if (dynamic || this.implicitQueue)
                    {
                        queue = new TestQueue(this);
                        this.queues.Add(address, queue);
                        connection.Closed += (o, e) => this.RemoveQueue(address);
                    }
                    else
                    {
                        throw new AmqpException(ErrorCode.NotFound, string.Format("Node '{0}' not found", address));
                    }
                }
            }

            if (attach.Role)
            {
                queue.CreateConsumer((ListenerLink)link);
            }
            else
            {
                queue.CreatePublisher((ListenerLink)link);
            }

            return true;
        }
Ejemplo n.º 37
0
        public IAsyncResult BeginOpenLink(AmqpLink link, TimeSpan timeout, AsyncCallback callback, object state)
        {
            if (link.IsReceiver && link.Settings.Target is Coordinator)
            {
                this.txnManager.AddCoordinator((ReceivingAmqpLink)link);
            }
            else
            {
                string address = link.IsReceiver ?
                    ((Target)link.Settings.Target).Address.ToString() :
                    ((Source)link.Settings.Source).Address.ToString();

                TestQueue queue;
                if (!this.queues.TryGetValue(address, out queue))
                {
                    if (!this.implicitQueue)
                    {
                        throw new AmqpException(AmqpErrorCode.NotFound, string.Format("Node '{0}' not found", address));
                    }

                    queue = new TestQueue(this);
                    this.queues.Add(address, queue);
                    link.Closed += (s, e) => this.queues.Remove(address);
                }

                queue.CreateClient(link);
            }

            return new CompletedAsyncResult(callback, state);
        }
Ejemplo n.º 38
0
 public Publisher(TestQueue queue, ReceivingAmqpLink link, int id)
 {
     this.queue = queue;
     this.link = link;
     this.id = id;
     this.link.RegisterMessageListener(this.OnMessage);
     this.link.Closed += new EventHandler(link_Closed);
 }
Ejemplo n.º 39
0
 public Consumer(TestQueue queue, SendingAmqpLink link, int id)
 {
     this.queue = queue;
     this.link = link;
     this.id = id;
     this.link.Closed += new EventHandler(link_Closed);
     this.link.RegisterCreditListener(this.OnCredit);
     this.link.RegisterDispositionListener(this.OnDispose);
 }