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