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.assertThrows;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import com.google.common.testing.FakeTicker;
  17 import java.util.List;
  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         assertEquals(true, context2.error().isPresent());
  60         assertEquals(0, context2.error().orElseThrow().getMessageProcessingTimesSinceLastExpectedMessage().size());
  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.advance(20, MILLISECONDS);
  75
  76         context.close();
  77
  78         MessageTracker.Context context2 = messageTracker.received(new Foo());
  79
  80         assertEquals(true, context2.error().isPresent());
  81
  82         MessageTracker.Error error = context2.error().orElseThrow();
  83
  84         List<MessageTracker.MessageProcessingTime> messageProcessingTimes =
  85                 error.getMessageProcessingTimesSinceLastExpectedMessage();
  86
  87         assertEquals(3, messageProcessingTimes.size());
  88
  89         assertEquals(String.class, messageProcessingTimes.get(0).getMessageClass());
  90         assertEquals(Long.class, messageProcessingTimes.get(1).getMessageClass());
  91         assertEquals(Integer.class, messageProcessingTimes.get(2).getMessageClass());
  92         assertTrue(messageProcessingTimes.get(2).getElapsedTimeInNanos() > MILLISECONDS.toNanos(10));
  93         assertEquals(Foo.class, error.getLastExpectedMessage().getClass());
  94         assertEquals(Foo.class, error.getCurrentExpectedMessage().getClass());
  95
  96         LOG.error("An error occurred : {}" , error);
  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.advance(1, MILLISECONDS);
 107
 108         MessageTracker.Context context2 = messageTracker.received(new Foo());
 109         assertEquals(false, context2.error().isPresent());
 110     }
 111
 112     @Test
 113     public void testIllegalStateExceptionWhenDoneIsNotCalledWhileTracking() {
 114         messageTracker.begin();
 115
 116         messageTracker.received(new Foo());
 117
 118         assertThrows(IllegalStateException.class, () -> messageTracker.received(new Foo()));
 119     }
 120
 121     @Test
 122     public void testNoIllegalStateExceptionWhenDoneIsNotCalledWhileNotTracking() {
 123         messageTracker.received(new Foo());
 124         messageTracker.received(new Foo());
 125     }
 126
 127     @Test
 128     public void testDelayInFirstExpectedMessageArrival() {
 129         messageTracker.begin();
 130
 131         ticker.advance(20, MILLISECONDS);
 132
 133         MessageTracker.Context context = messageTracker.received(new Foo());
 134
 135         assertEquals(true, context.error().isPresent());
 136
 137         MessageTracker.Error error = context.error().orElseThrow();
 138
 139         assertEquals(null, error.getLastExpectedMessage());
 140         assertEquals(Foo.class, error.getCurrentExpectedMessage().getClass());
 141
 142         String errorString = error.toString();
 143         assertTrue(errorString.contains("Last Expected Message = null"));
 144
 145         LOG.error("An error occurred : {}", error);
 146     }
 147
 148     @Test
 149     public void testCallingBeginDoesNotResetWatch() {
 150         messageTracker.begin();
 151
 152         ticker.advance(20, MILLISECONDS);
 153
 154         messageTracker.begin();
 155
 156         MessageTracker.Context context = messageTracker.received(new Foo());
 157
 158         assertEquals(true, context.error().isPresent());
 159     }
 160
 161     @Test
 162     public void testMessagesSinceLastExpectedMessage() {
 163
 164         messageTracker.begin();
 165
 166         try (MessageTracker.Context ctx = messageTracker.received(45)) {
 167             assertEquals(false, ctx.error().isPresent());
 168         }
 169         try (MessageTracker.Context ctx = messageTracker.received(45L)) {
 170             assertEquals(false, ctx.error().isPresent());
 171         }
 172
 173         List<MessageTracker.MessageProcessingTime> processingTimeList =
 174                 messageTracker.getMessagesSinceLastExpectedMessage();
 175
 176         assertEquals(2, processingTimeList.size());
 177
 178         assertEquals(Integer.class, processingTimeList.get(0).getMessageClass());
 179         assertEquals(Long.class, processingTimeList.get(1).getMessageClass());
 180     }
 181 }