X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-akka-raft%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fraft%2Futils%2FMessageCollectorActor.java;h=68d6b619cd43bc6aa2d1ce582e32b2eb0bb03d4e;hp=62f163fb7d0270a2415e934d193136d610e01ca3;hb=97542f208267cb5392fc8c8d9baf6c1d3ee4ae32;hpb=686d381ea589ebf33bcfb0bbc7048ffe242749c4 diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/MessageCollectorActor.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/MessageCollectorActor.java index 62f163fb7d..68d6b619cd 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/MessageCollectorActor.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/MessageCollectorActor.java @@ -13,9 +13,14 @@ import akka.actor.Props; import akka.actor.UntypedActor; import akka.pattern.Patterns; import akka.util.Timeout; +import com.google.common.base.Predicate; +import com.google.common.base.Predicates; +import com.google.common.base.Throwables; +import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.util.concurrent.Uninterruptibles; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; @@ -25,23 +30,21 @@ import scala.concurrent.Future; import scala.concurrent.duration.Duration; import scala.concurrent.duration.FiniteDuration; - public class MessageCollectorActor extends UntypedActor { private static final String ARE_YOU_READY = "ARE_YOU_READY"; + public static final String GET_ALL_MESSAGES = "messages"; + private static final String CLEAR_MESSAGES = "clear-messages"; private final List messages = new ArrayList<>(); @Override public void onReceive(Object message) throws Exception { - if(message.equals(ARE_YOU_READY)) { + if (ARE_YOU_READY.equals(message)) { getSender().tell("yes", getSelf()); - return; - } - - if(message instanceof String){ - if("get-all-messages".equals(message)){ - getSender().tell(new ArrayList<>(messages), getSelf()); - } - } else if(message != null) { + } else if (GET_ALL_MESSAGES.equals(message)) { + getSender().tell(new ArrayList<>(messages), getSelf()); + } else if (CLEAR_MESSAGES.equals(message)) { + clear(); + } else if (message != null) { messages.add(message); } } @@ -50,61 +53,163 @@ public class MessageCollectorActor extends UntypedActor { messages.clear(); } - public static List getAllMessages(ActorRef actor) throws Exception { + @SuppressWarnings("unchecked") + private static List getAllMessages(ActorRef actor) throws Exception { FiniteDuration operationDuration = Duration.create(5, TimeUnit.SECONDS); Timeout operationTimeout = new Timeout(operationDuration); - Future future = Patterns.ask(actor, "get-all-messages", operationTimeout); + Future future = Patterns.ask(actor, GET_ALL_MESSAGES, operationTimeout); return (List) Await.result(future, operationDuration); } + public static void clearMessages(ActorRef actor) { + actor.tell(CLEAR_MESSAGES, ActorRef.noSender()); + } + /** - * Get the first message that matches the specified class - * @param actor - * @param clazz - * @return + * Get the first message that matches the specified class. + * + * @param actor the MessageCollectorActor reference + * @param clazz the class to match + * @return the first matching message */ public static T getFirstMatching(ActorRef actor, Class clazz) throws Exception { List allMessages = getAllMessages(actor); - for(Object message : allMessages){ - if(message.getClass().equals(clazz)){ - return (T) message; + for (Object message : allMessages) { + if (message.getClass().equals(clazz)) { + return clazz.cast(message); } } return null; } + @SuppressWarnings("checkstyle:IllegalCatch") + public static List expectMatching(ActorRef actor, Class clazz, int count) { + return expectMatching(actor, clazz, count, msg -> true); + } + + @SuppressWarnings("checkstyle:IllegalCatch") + public static List expectMatching(ActorRef actor, Class clazz, int count, + Predicate matcher) { + int timeout = 5000; + Exception lastEx = null; + List messages = Collections.emptyList(); + for (int i = 0; i < timeout / 50; i++) { + try { + messages = getAllMatching(actor, clazz); + Iterables.removeIf(messages, Predicates.not(matcher)); + if (messages.size() >= count) { + return messages; + } + + lastEx = null; + } catch (Exception e) { + lastEx = e; + } + + Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS); + } + + throw new AssertionError(String.format("Expected %d messages of type %s. Actual received was %d: %s", count, + clazz, messages.size(), messages), lastEx); + } + public static T expectFirstMatching(ActorRef actor, Class clazz) { return expectFirstMatching(actor, clazz, 5000); } + @SuppressWarnings("checkstyle:IllegalCatch") public static T expectFirstMatching(ActorRef actor, Class clazz, long timeout) { + Exception lastEx = null; int count = (int) (timeout / 50); - for(int i = 0; i < count; i++) { + for (int i = 0; i < count; i++) { try { T message = getFirstMatching(actor, clazz); - if(message != null) { + if (message != null) { return message; } - } catch (Exception e) {} + + lastEx = null; + } catch (Exception e) { + lastEx = e; + } Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS); } - Assert.fail("Did not receive message of type " + clazz); - return null; + throw new AssertionError("Did not receive message of type " + clazz, lastEx); } + @SuppressWarnings("checkstyle:IllegalCatch") + public static T expectFirstMatching(ActorRef actor, Class clazz, Predicate matcher) { + int timeout = 5000; + Exception lastEx = null; + T lastMessage = null; + for (int i = 0; i < timeout / 50; i++) { + try { + List messages = getAllMatching(actor, clazz); + for (T msg : messages) { + if (matcher.apply(msg)) { + return msg; + } + + lastMessage = msg; + } + + lastEx = null; + } catch (Exception e) { + lastEx = e; + } + + Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS); + } + + throw new AssertionError(String.format("Expected specific message of type %s. Last message received was: %s", + clazz, lastMessage), lastEx); + } + + public static void assertNoneMatching(ActorRef actor, Class clazz) { + assertNoneMatching(actor, clazz, 5000); + } + + @SuppressWarnings("checkstyle:IllegalCatch") + public static void assertNoneMatching(ActorRef actor, Class clazz, long timeout) { + Exception lastEx = null; + int count = (int) (timeout / 50); + for (int i = 0; i < count; i++) { + try { + T message = getFirstMatching(actor, clazz); + if (message != null) { + Assert.fail("Unexpected message received" + message.toString()); + return; + } + + lastEx = null; + } catch (Exception e) { + lastEx = e; + } + + Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS); + } + + if (lastEx != null) { + Throwables.propagate(lastEx); + } + + return; + } + + public static List getAllMatching(ActorRef actor, Class clazz) throws Exception { List allMessages = getAllMessages(actor); List output = Lists.newArrayList(); - for(Object message : allMessages){ - if(message.getClass().equals(clazz)){ - output.add((T) message); + for (Object message : allMessages) { + if (message.getClass().equals(clazz)) { + output.add(clazz.cast(message)); } } @@ -114,11 +219,12 @@ public class MessageCollectorActor extends UntypedActor { public static void waitUntilReady(ActorRef actor) throws Exception { long timeout = 500; FiniteDuration duration = Duration.create(timeout, TimeUnit.MILLISECONDS); - for(int i = 0; i < 10; i++) { + for (int i = 0; i < 10; i++) { try { Await.ready(Patterns.ask(actor, ARE_YOU_READY, timeout), duration); return; } catch (TimeoutException e) { + // will fall through below } }