opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/common/actor/MessageTrackerTest.java

   1 /*
   2  * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.cluster.common.actor;
  10
  11 import static java.util.concurrent.TimeUnit.MILLISECONDS;
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.fail;
  14
  15 import com.google.common.testing.FakeTicker;
  16 import java.util.List;
  17 import org.junit.Assert;
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 public class MessageTrackerTest {
  24     private static final class Foo {
  25         // Intentionally empty
  26     }
  27
  28     private static final Logger LOG = LoggerFactory.getLogger(MessageTrackerTest.class);
  29
  30     private FakeTicker ticker;
  31     private MessageTracker messageTracker;
  32
  33     @Before
  34     public void setup() {
  35         ticker = new FakeTicker();
  36         messageTracker = new MessageTracker(Foo.class, 10, ticker);
  37     }
  38
  39     @Test
  40     public void testNoTracking() {
  41         MessageTracker.Context context1 = messageTracker.received(new Foo());
  42         context1.close();
  43
  44         ticker.advance(20, MILLISECONDS);
  45         MessageTracker.Context context2 = messageTracker.received(new Foo());
  46         context2.close();
  47     }
  48
  49     @Test
  50     public void testFailedExpectationOnTracking() {
  51         messageTracker.begin();
  52
  53         MessageTracker.Context context1 = messageTracker.received(new Foo());
  54         context1.close();
  55
  56         ticker.advance(20, MILLISECONDS);
  57
  58         MessageTracker.Context context2 = messageTracker.received(new Foo());
  59         Assert.assertEquals(true, context2.error().isPresent());
  60         Assert.assertEquals(0, context2.error().get().getMessageProcessingTimesSinceLastExpectedMessage().size());
  61
  62     }
  63
  64     @Test
  65     public void testFailedExpectationOnTrackingWithMessagesInBetween() {
  66         messageTracker.begin();
  67
  68         MessageTracker.Context context1 = messageTracker.received(new Foo());
  69         context1.close();
  70
  71         messageTracker.received("A").close();
  72         messageTracker.received(10L).close();
  73         MessageTracker.Context context = messageTracker.received(100);
  74
  75         ticker.advance(20, MILLISECONDS);
  76
  77         context.close();
  78
  79         MessageTracker.Context context2 = messageTracker.received(new Foo());
  80
  81         Assert.assertEquals(true, context2.error().isPresent());
  82
  83         MessageTracker.Error error = context2.error().get();
  84
  85         List<MessageTracker.MessageProcessingTime> messageProcessingTimes =
  86                 error.getMessageProcessingTimesSinceLastExpectedMessage();
  87
  88         Assert.assertEquals(3, messageProcessingTimes.size());
  89
  90         Assert.assertEquals(String.class, messageProcessingTimes.get(0).getMessageClass());
  91         Assert.assertEquals(Long.class, messageProcessingTimes.get(1).getMessageClass());
  92         Assert.assertEquals(Integer.class, messageProcessingTimes.get(2).getMessageClass());
  93         Assert.assertTrue(messageProcessingTimes.get(2).getElapsedTimeInNanos() > MILLISECONDS.toNanos(10));
  94         Assert.assertEquals(Foo.class, error.getLastExpectedMessage().getClass());
  95         Assert.assertEquals(Foo.class, error.getCurrentExpectedMessage().getClass());
  96
  97         LOG.error("An error occurred : {}" , error);
  98     }
  99
 100     @Test
 101     public void testMetExpectationOnTracking() {
 102         messageTracker.begin();
 103
 104         MessageTracker.Context context1 = messageTracker.received(new Foo());
 105         context1.close();
 106
 107         ticker.advance(1, MILLISECONDS);
 108
 109         MessageTracker.Context context2 = messageTracker.received(new Foo());
 110         Assert.assertEquals(false, context2.error().isPresent());
 111
 112     }
 113
 114     @Test
 115     public void testIllegalStateExceptionWhenDoneIsNotCalledWhileTracking() {
 116         messageTracker.begin();
 117
 118         messageTracker.received(new Foo());
 119
 120         try {
 121             messageTracker.received(new Foo());
 122             fail("Expected an IllegalStateException");
 123         } catch (IllegalStateException e) {
 124             // expected
 125         }
 126     }
 127
 128     @Test
 129     public void testNoIllegalStateExceptionWhenDoneIsNotCalledWhileNotTracking() {
 130         messageTracker.received(new Foo());
 131         messageTracker.received(new Foo());
 132     }
 133
 134     @Test
 135     public void testDelayInFirstExpectedMessageArrival() {
 136         messageTracker.begin();
 137
 138         ticker.advance(20, MILLISECONDS);
 139
 140         MessageTracker.Context context = messageTracker.received(new Foo());
 141
 142         Assert.assertEquals(true, context.error().isPresent());
 143
 144         MessageTracker.Error error = context.error().get();
 145
 146         Assert.assertEquals(null, error.getLastExpectedMessage());
 147         Assert.assertEquals(Foo.class, error.getCurrentExpectedMessage().getClass());
 148
 149         String errorString = error.toString();
 150         Assert.assertTrue(errorString.contains("Last Expected Message = null"));
 151
 152         LOG.error("An error occurred : {}", error);
 153     }
 154
 155     @Test
 156     public void testCallingBeginDoesNotResetWatch() {
 157         messageTracker.begin();
 158
 159         ticker.advance(20, MILLISECONDS);
 160
 161         messageTracker.begin();
 162
 163         MessageTracker.Context context = messageTracker.received(new Foo());
 164
 165         Assert.assertEquals(true, context.error().isPresent());
 166
 167     }
 168
 169     @Test
 170     public void testMessagesSinceLastExpectedMessage() {
 171
 172         messageTracker.begin();
 173
 174         try (MessageTracker.Context ctx = messageTracker.received(45)) {
 175             Assert.assertEquals(false, ctx.error().isPresent());
 176         }
 177         try (MessageTracker.Context ctx = messageTracker.received(45L)) {
 178             Assert.assertEquals(false, ctx.error().isPresent());
 179         }
 180
 181         List<MessageTracker.MessageProcessingTime> processingTimeList =
 182                 messageTracker.getMessagesSinceLastExpectedMessage();
 183
 184         Assert.assertEquals(2, processingTimeList.size());
 185
 186         assertEquals(Integer.class, processingTimeList.get(0).getMessageClass());
 187         assertEquals(Long.class, processingTimeList.get(1).getMessageClass());
 188
 189     }
 190
 191 }