/* * Copyright (c) 2013 Mike Heath. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package cloudeventbus.client; import org.testng.annotations.Test; import static org.testng.Assert.*; import java.util.concurrent.Executor; import java.util.concurrent.atomic.AtomicInteger; /** * @author Mike Heath <elcapo@gmail.com> */ public class DefaultSubscriptionTest { private final Executor executor = new Executor() { @Override public void execute(Runnable command) { command.run(); } }; @Test public void getters() { final String subject = "this.is.one.heck.of.a.subject"; final Integer maxMessages = 3432; final DefaultSubscription subscription = new DefaultSubscription(subject, maxMessages); assertEquals(subscription.getSubject(), subject); assertEquals(subscription.getMaxMessages(), maxMessages); } @Test public void receivedMessageCount() { final DefaultSubscription subscription = new DefaultSubscription("subject", 5); assertEquals(subscription.getReceivedMessages(), 0); subscription.onMessage("subject", null, "body", executor); assertEquals(subscription.getReceivedMessages(), 1); subscription.onMessage("subject", null, "body", executor); assertEquals(subscription.getReceivedMessages(), 2); } @Test public void closeClosesIterator() { final DefaultSubscription subscription = new DefaultSubscription("subject", 5); final MessageIterator iterator = subscription.iterator(); assertTrue(iterator.hasNext()); subscription.close(); assertFalse(iterator.hasNext()); // Calling close a second time should not throw exception subscription.close(); } @Test public void iteratorGetsMessages() { final String subject = "some.subject"; final String replySubject = "reply.subject"; final String body = "This is a nice body."; final DefaultSubscription subscription = new DefaultSubscription("subject", 5); final MessageIterator iterator = subscription.iterator(); subscription.onMessage(subject, replySubject, body, executor); final Message message = iterator.next(); assertNotNull(message); assertEquals(message.getSubject(), subject); assertEquals(message.getBody(), body); // Make sure the iterator doesn't get messages after close is called. assertTrue(iterator.hasNext()); iterator.close(); subscription.onMessage(subject, replySubject, body, executor); assertFalse(iterator.hasNext()); } @Test public void handlerGetsMessages() { final String subject = "some.subject"; final String body = "This is a nice body."; final DefaultSubscription subscription = new DefaultSubscription("subject", 5); final AtomicInteger messageCounter = new AtomicInteger(); final HandlerRegistration registration = subscription.addMessageHandler(new MessageHandler() { @Override public void onMessage(Message message) { messageCounter.incrementAndGet(); assertEquals(message.getSubject(), subject); assertEquals(message.getBody(), body); assertFalse(message.isRequest()); } }); subscription.onMessage(subject, null, body, executor); registration.remove(); subscription.onMessage(subject, null, body, executor); assertEquals(messageCounter.get(), 1); } @Test(expectedExceptions = ClientClosedException.class) public void canNotAddHandlerToClosedSubscription() { final DefaultSubscription subscription = new DefaultSubscription("subject", 5); subscription.close(); subscription.addMessageHandler(new MessageHandler() { @Override public void onMessage(Message message) { } }); } @Test(expectedExceptions = ClientClosedException.class) public void exceedingMessageCountClosesSubscription() { final DefaultSubscription subscription = new DefaultSubscription("subject", 1); // Iterator will return true if subscription is open. final MessageIterator iterator = subscription.iterator(); assertTrue(iterator.hasNext()); subscription.onMessage("subject", null, "body", executor); // Get message off iterator queue assertNotNull(iterator.next()); // Iterator should now be closed because subscription will only take one message assertFalse(iterator.hasNext()); // Make sure subscription is closed by adding handler, this will throw exception subscription.addMessageHandler(new MessageHandler() { @Override public void onMessage(Message message) { fail("Subscription is closed, exception should have been thrown."); } }); subscription.onMessage("subject", null, "body", executor); } }