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