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 java.util.List;
  16 import org.junit.Assert;
  17 import org.junit.Before;
  18 import org.junit.Test;
  19 import org.slf4j.Logger;
  20 import org.slf4j.LoggerFactory;
  21
  22 public class MessageTrackerTest {
  23     private static final class Foo {
  24         // Intentionally empty
  25     }
  26
  27     private static final Logger LOG = LoggerFactory.getLogger(MessageTrackerTest.class);
  28
  29     private TestTicker ticker;
  30     private MessageTracker messageTracker;
  31
  32     @Before
  33     public void setup() {
  34         ticker = new TestTicker();
  35         messageTracker = new MessageTracker(Foo.class, 10, ticker);
  36     }
  37
  38     @Test
  39     public void testNoTracking() {
  40         MessageTracker.Context context1 = messageTracker.received(new Foo());
  41         context1.close();
  42
  43         ticker.increment(MILLISECONDS.toNanos(20));
  44         MessageTracker.Context context2 = messageTracker.received(new Foo());
  45         context2.close();
  46     }
  47
  48     @Test
  49     public void testFailedExpectationOnTracking() {
  50         messageTracker.begin();
  51
  52         MessageTracker.Context context1 = messageTracker.received(new Foo());
  53         context1.close();
  54
  55         ticker.increment(MILLISECONDS.toNanos(20));
  56
  57         MessageTracker.Context context2 = messageTracker.received(new Foo());
  58         Assert.assertEquals(true, context2.error().isPresent());
  59         Assert.assertEquals(0, context2.error().get().getMessageProcessingTimesSinceLastExpectedMessage().size());
  60
  61     }
  62
  63     @Test
  64     public void testFailedExpectationOnTrackingWithMessagesInBetween() {
  65         messageTracker.begin();
  66
  67         MessageTracker.Context context1 = messageTracker.received(new Foo());
  68         context1.close();
  69
  70         messageTracker.received("A").close();
  71         messageTracker.received(10L).close();
  72         MessageTracker.Context context = messageTracker.received(100);
  73
  74         ticker.increment(MILLISECONDS.toNanos(20));
  75
  76         context.close();
  77
  78         MessageTracker.Context context2 = messageTracker.received(new Foo());
  79
  80         Assert.assertEquals(true, context2.error().isPresent());
  81
  82         MessageTracker.Error error = context2.error().get();
  83
  84         List<MessageTracker.MessageProcessingTime> messageProcessingTimes =
  85                 error.getMessageProcessingTimesSinceLastExpectedMessage();
  86
  87         Assert.assertEquals(3, messageProcessingTimes.size());
  88
  89         Assert.assertEquals(String.class, messageProcessingTimes.get(0).getMessageClass());
  90         Assert.assertEquals(Long.class, messageProcessingTimes.get(1).getMessageClass());
  91         Assert.assertEquals(Integer.class, messageProcessingTimes.get(2).getMessageClass());
  92         Assert.assertTrue(messageProcessingTimes.get(2).getElapsedTimeInNanos() > MILLISECONDS.toNanos(10));
  93         Assert.assertEquals(Foo.class, error.getLastExpectedMessage().getClass());
  94         Assert.assertEquals(Foo.class, error.getCurrentExpectedMessage().getClass());
  95
  96         LOG.error("An error occurred : {}" , error);
  97     }
  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.increment(MILLISECONDS.toNanos(1));
 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.increment(MILLISECONDS.toNanos(20));
 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.increment(MILLISECONDS.toNanos(20));
 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 }