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

Package org.apache.qpid.server.subscription

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

org.apache.qpid.server.subscription.MockSubscription

     *
     * @return Subscription that performed the aquire
     */
    private Subscription createSubscriptionAndAquireMessages(LinkedList<QueueEntry> messageList)
    {
        Subscription subscription = new MockSubscription();


        // Aquire messages in subscription
        for (QueueEntry entry : messageList)
        {
            entry.acquire(subscription);

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);
            }
        };


        ServerMessage messageA = createMessage(new Long(24));
        ServerMessage 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

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


        MockSubscription mockSubscription = new MockSubscription();


        mockSubscription.setQueue(BrokerTestHelper.createQueue(getName(), getVirtualHost()), false);


        setAmqpActor(new SubscriptionActor(getRootLogger(), mockSubscription));
    }

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", 1l,
                (messages.get(0).getMessage()).getMessageNumber());
        assertEquals("ID of second message should be 3", 3l,
                (messages.get(1).getMessage()).getMessageNumber());

View Full Code Here

    {
        final SimpleAMQQueue queue = new SimpleAMQQueue(UUIDGenerator.generateRandomUUID(), "testActiveConsumerCount", false,
                "testOwner", false, false, _virtualHost, new SimpleQueueEntryList.Factory(), null);


        //verify adding an active subscription increases the count
        final MockSubscription subscription1 = new MockSubscription();
        subscription1.setActive(true);
        assertEquals("Unexpected active consumer count", 0, queue.getActiveConsumerCount());
        queue.registerSubscription(subscription1, false);
        assertEquals("Unexpected active consumer count", 1, queue.getActiveConsumerCount());


        //verify adding an inactive subscription doesn't increase the count
        final MockSubscription subscription2 = new MockSubscription();
        subscription2.setActive(false);
        assertEquals("Unexpected active consumer count", 1, queue.getActiveConsumerCount());
        queue.registerSubscription(subscription2, false);
        assertEquals("Unexpected active consumer count", 1, queue.getActiveConsumerCount());


        //verify behaviour in face of expected state changes:

View Full Code Here

    /**
     * A helper method to put tested entry into acquired state and assert the sate
     */
    private void acquire()
    {
        _queueEntry.acquire(new MockSubscription());
        assertTrue("Queue entry should be in ACQUIRED state after invoking of acquire method",
                _queueEntry.isAcquired());
    }

View Full Code Here

     * Tests rejecting a queue entry records the Subscription ID
     * for later verification by isRejectedBy(subscriptionId).
     */
    public void testRejectAndRejectedBy()
    {
        Subscription sub = new MockSubscription();
        long subId = sub.getSubscriptionID();


        assertFalse("Queue entry should not yet have been rejected by the subscription", _queueEntry.isRejectedBy(subId));
        assertFalse("Queue entry should not yet have been acquired by a subscription", _queueEntry.isAcquired());


        //acquire, reject, and release the message using the subscription
        assertTrue("Queue entry should have been able to be acquired", _queueEntry.acquire(sub));
        _queueEntry.reject();
        _queueEntry.release();


        //verify the rejection is recorded
        assertTrue("Queue entry should have been rejected by the subscription", _queueEntry.isRejectedBy(subId));


        //repeat rejection using a second subscription
        Subscription sub2 = new MockSubscription();
        long sub2Id = sub2.getSubscriptionID();


        assertFalse("Queue entry should not yet have been rejected by the subscription", _queueEntry.isRejectedBy(sub2Id));
        assertTrue("Queue entry should have been able to be acquired", _queueEntry.acquire(sub2));
        _queueEntry.reject();

View Full Code Here

0 1 2 3 4 5

TOP

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

org.apache.qpid.server.ExtractResendAndRequeueTest

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

org.apache.qpid.server.model.ConfiguredObjectFactory

org.apache.qpid.server.model.ConfiguredObjectFactoryImpl

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.