Examples of org.apache.qpid.server.subscription.MockSubscription

Package org.apache.qpid.server.subscription

Examples of org.apache.qpid.server.subscription.MockSubscription

org.apache.qpid.server.subscription.MockSubscription

        AMQMessage messageA = createMessage(new Long(24));
        _queue.enqueue(null, messageA);
        assertEquals(messageA, _subscription.getLastSeenEntry().getMessage());
        
        // Check we cannot add a second subscriber to the queue
        Subscription subB = new MockSubscription();
        Exception ex = null;
        try
        {
            _queue.registerSubscription(subB, false);
        }

View Full Code Here

     * Tests a requeue for a queue with multiple subscriptions.  Verifies that a
     * requeue resends a message to a <i>single</i> subscriber.
     */
    public void testRequeueForQueueWithMultipleSubscriptions() throws Exception
    {
        MockSubscription subscription1 = new MockSubscription();
        MockSubscription subscription2 = new MockSubscription();


        _queue.registerSubscription(subscription1, false);
        _queue.registerSubscription(subscription2, false);


        final ArrayList<QueueEntry> queueEntries = new ArrayList<QueueEntry>();
        PostEnqueueAction postEnqueueAction = new PostEnqueueAction()
        {
            public void onEnqueue(QueueEntry entry)
            {
                queueEntries.add(entry);
            }
        };


        AMQMessage messageA = createMessage(new Long(24));
        AMQMessage messageB = createMessage(new Long(25));


        /* Enqueue two messages */


        _queue.enqueue(messageA, postEnqueueAction);
        _queue.enqueue(messageB, postEnqueueAction);


        Thread.sleep(150);  // Work done by SubFlushRunner Thread


        assertEquals("Unexpected total number of messages sent to subscription1 after enqueue", 1, subscription1.getMessages().size());
        assertEquals("Unexpected total number of messages sent to subscription2 after enqueue", 1, subscription2.getMessages().size());


        /* Now requeue a message (for any subscription) */


        queueEntries.get(0).release();
        _queue.requeue((QueueEntryImpl)queueEntries.get(0));


        Thread.sleep(150); // Work done by SubFlushRunner Thread


        assertEquals("Unexpected total number of messages sent to all subscriptions after requeue", 3, subscription1.getMessages().size() + subscription2.getMessages().size());
        assertNull("releasedEntry should be cleared after requeue processed", ((QueueContext)subscription1.getQueueContext())._releasedEntry);
        assertNull("releasedEntry should be cleared after requeue processed", ((QueueContext)subscription2.getQueueContext())._releasedEntry);
    }

View Full Code Here

     * Tests a requeue for a queue with multiple subscriptions.  Verifies that a
     * subscriber specific requeue resends the message to <i>that</i> subscriber.
     */
    public void testSubscriptionSpecificRequeueForQueueWithMultipleSubscriptions() throws Exception
    {
        MockSubscription subscription1 = new MockSubscription();
        MockSubscription subscription2 = new MockSubscription();


        _queue.registerSubscription(subscription1, false);
        _queue.registerSubscription(subscription2, false);


        final ArrayList<QueueEntry> queueEntries = new ArrayList<QueueEntry>();
        PostEnqueueAction postEnqueueAction = new PostEnqueueAction()
        {
            public void onEnqueue(QueueEntry entry)
            {
                queueEntries.add(entry);
            }
        };


        AMQMessage messageA = createMessage(new Long(24));
        AMQMessage messageB = createMessage(new Long(25));


        /* Enqueue two messages */


        _queue.enqueue(messageA, postEnqueueAction);
        _queue.enqueue(messageB, postEnqueueAction);


        Thread.sleep(150);  // Work done by SubFlushRunner Thread


        assertEquals("Unexpected total number of messages sent to subscription1 after enqueue", 1, subscription1.getMessages().size());
        assertEquals("Unexpected total number of messages sent to subscription2 after enqueue", 1, subscription2.getMessages().size());


        /* Now requeue a message (for first subscription) */


        queueEntries.get(0).release();
        _queue.requeue((QueueEntryImpl)queueEntries.get(0), subscription1);


        Thread.sleep(150); // Work done by SubFlushRunner Thread


        assertEquals("Unexpected total number of messages sent to subscription1 after requeue", 2, subscription1.getMessages().size());
        assertEquals("Unexpected total number of messages sent to subscription2 after requeue", 1, subscription2.getMessages().size());
        assertNull("releasedEntry should be cleared after requeue processed", ((QueueContext)subscription1.getQueueContext())._releasedEntry);
        assertNull("releasedEntry should be cleared after requeue processed", ((QueueContext)subscription2.getQueueContext())._releasedEntry);
    }

View Full Code Here

        AMQMessage messageA = createMessage(new Long(24));
        _queue.enqueue(messageA);
        assertEquals(messageA, _subscription.getQueueContext().getLastSeenEntry().getMessage());


        // Check we cannot add a second subscriber to the queue
        Subscription subB = new MockSubscription();
        Exception ex = null;
        try
        {
            _queue.registerSubscription(subB, false);
        }

View Full Code Here

    @Override
    public void createBroker() throws Exception
    {
        super.createBroker();


        MockSubscription mockSubscription = new MockSubscription();


        mockSubscription.setQueue(getQueue(), false);


        _amqpActor = new SubscriptionActor(_rootLogger, mockSubscription);
    }

View Full Code Here

     * Tests that a release requeues an entry for a queue with multiple subscriptions.  Verifies that a
     * requeue resends a message to a <i>single</i> subscriber.
     */
    public void testReleaseForQueueWithMultipleSubscriptions() throws Exception
    {
        MockSubscription subscription1 = new MockSubscription();
        MockSubscription subscription2 = new MockSubscription();


        _queue.registerSubscription(subscription1, false);
        _queue.registerSubscription(subscription2, false);


        final ArrayList<QueueEntry> queueEntries = new ArrayList<QueueEntry>();
        PostEnqueueAction postEnqueueAction = new PostEnqueueAction()
        {
            public void onEnqueue(QueueEntry entry)
            {
                queueEntries.add(entry);
            }
        };


        AMQMessage messageA = createMessage(new Long(24));
        AMQMessage messageB = createMessage(new Long(25));


        /* Enqueue two messages */


        _queue.enqueue(messageA, postEnqueueAction);
        _queue.enqueue(messageB, postEnqueueAction);


        Thread.sleep(150);  // Work done by SubFlushRunner/QueueRunner Threads


        assertEquals("Unexpected total number of messages sent to both after enqueue", 2, subscription1.getMessages().size() + subscription2.getMessages().size());


        /* Now release the first message only, causing it to be requeued */
        queueEntries.get(0).release();  


        Thread.sleep(150); // Work done by SubFlushRunner/QueueRunner Threads


        assertEquals("Unexpected total number of messages sent to both subscriptions after release", 3, subscription1.getMessages().size() + subscription2.getMessages().size());
        assertNull("releasedEntry should be cleared after requeue processed", ((QueueContext)subscription1.getQueueContext()).getReleasedEntry());
        assertNull("releasedEntry should be cleared after requeue processed", ((QueueContext)subscription2.getQueueContext()).getReleasedEntry());
    }

View Full Code Here

        {
        }
        assertEquals(messageA, _subscription.getQueueContext().getLastSeenEntry().getMessage());


        // Check we cannot add a second subscriber to the queue
        Subscription subB = new MockSubscription();
        Exception ex = null;
        try
        {
            _queue.registerSubscription(subB, false);
        }

View Full Code Here

        // the first subscription as the processQueue method proceeds.
        List<QueueEntry> msgListSub1 = createEntriesList(msg1, msg2, msg3);
        List<QueueEntry> msgListSub2 = createEntriesList(msg4);
        List<QueueEntry> msgListSub3 = createEntriesList(msg5);


        MockSubscription sub1 = new MockSubscription(msgListSub1);
        MockSubscription sub2 = new MockSubscription(msgListSub2);
        MockSubscription sub3 = new MockSubscription(msgListSub3);


        // register the subscriptions
        testQueue.registerSubscription(sub1, false);
        testQueue.registerSubscription(sub2, false);
        testQueue.registerSubscription(sub3, false);


        //check that no messages have been delivered to the
        //subscriptions during registration
        assertEquals("No messages should have been delivered yet", 0, sub1.getMessages().size());
        assertEquals("No messages should have been delivered yet", 0, sub2.getMessages().size());
        assertEquals("No messages should have been delivered yet", 0, sub3.getMessages().size());


        // call processQueue to deliver the messages
        testQueue.processQueue(new QueueRunner(testQueue)
        {
            @Override
            public void run()
            {
                // we dont actually want/need this runner to do any work
                // because we we are already doing it!
            }
        });


        // check expected messages delivered to correct consumers
        verifyRecievedMessages(msgListSub1, sub1.getMessages());
        verifyRecievedMessages(msgListSub2, sub2.getMessages());
        verifyRecievedMessages(msgListSub3, sub3.getMessages());
    }

View Full Code Here


        // latch to wait for message receipt
        final CountDownLatch latch = new CountDownLatch(messageNumber -1);


        // create a subscription
        MockSubscription subscription = new MockSubscription()
        {
            /**
             * Send a message and decrement latch
             * @param entry
             * @param batch
             */
            public void send(QueueEntry entry, boolean batch) throws AMQException
            {
                super.send(entry, batch);
                latch.countDown();
            }
        };


        try
        {
            // subscribe
            testQueue.registerSubscription(subscription, false);


            // process queue
            testQueue.processQueue(new QueueRunner(testQueue)
            {
                public void run()
                {
                    // do nothing
                }
            });
        }
        catch (AMQException e)
        {
            fail("Failure to process queue:" + e.getMessage());
        }
        // wait up to 1 minute for message receipt
        try
        {
            latch.await(1, TimeUnit.MINUTES);
        }
        catch (InterruptedException e1)
        {
            Thread.currentThread().interrupt();
        }
        List<QueueEntry> expected = createEntriesList(entries.get(0), entries.get(2), entries.get(3));
        verifyRecievedMessages(expected, subscription.getMessages());
    }

View Full Code Here

                            }
                        };
                    }
                }, null);
        // create a subscription
        MockSubscription subscription = new MockSubscription();


        // register subscription
        try
        {
            queue.registerSubscription(subscription, false);
        }
        catch (AMQException e)
        {
            fail("Failure to register subscription:" + e.getMessage());
        }


        // put test messages into a queue
        putGivenNumberOfMessages(queue, 4);


        // assert received messages
        List<QueueEntry> messages = subscription.getMessages();
        assertEquals("Only 2 messages should be returned", 2, messages.size());
        assertEquals("ID of first message should be 1", new Long(1),
                ((AMQMessage) messages.get(0).getMessage()).getMessageId());
        assertEquals("ID of second message should be 3", new Long(3),
                ((AMQMessage) messages.get(1).getMessage()).getMessageId());

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of org.apache.qpid.server.subscription.MockSubscription

org.apache.qpid.server.ExtractResendAndRequeueTest

org.apache.qpid.server.logging.actors.SubscriptionActorTest

org.apache.qpid.server.protocol.v0_8.ExtractResendAndRequeueTest

org.apache.qpid.server.queue.QueueEntryImplTest

org.apache.qpid.server.queue.QueueEntryImplTestBase

org.apache.qpid.server.queue.SimpleAMQQueueTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.