pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/FiniteStateMachineTest.java

   1 /*
   2  * Copyright (c) 2013 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 package org.opendaylight.protocol.pcep.impl;
   9
  10 import org.opendaylight.protocol.pcep.PCEPErrors;
  11 import org.opendaylight.protocol.pcep.PCEPMessage;
  12 import org.opendaylight.protocol.pcep.message.PCEPErrorMessage;
  13 import org.opendaylight.protocol.pcep.message.PCEPKeepAliveMessage;
  14 import org.opendaylight.protocol.pcep.message.PCEPNotificationMessage;
  15 import org.opendaylight.protocol.pcep.message.PCEPOpenMessage;
  16 import org.opendaylight.protocol.pcep.object.CompositeNotifyObject;
  17 import org.opendaylight.protocol.pcep.object.PCEPErrorObject;
  18 import org.opendaylight.protocol.pcep.object.PCEPNotificationObject;
  19 import org.opendaylight.protocol.pcep.object.PCEPOpenObject;
  20 import org.junit.After;
  21 import org.junit.Before;
  22 import org.junit.Ignore;
  23 import org.junit.Test;
  24
  25 import java.util.ArrayList;
  26
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertTrue;
  29
  30 public class FiniteStateMachineTest {
  31
  32         private ServerSessionMock serverSession;
  33
  34         private final SimpleSessionListener serverListener = new SimpleSessionListener();
  35
  36         private MockPCE client;
  37
  38         @Before
  39         public void setUp() {
  40                 this.client = new MockPCE();
  41                 this.serverSession = new ServerSessionMock(this.serverListener, this.client);
  42                 this.client.addSession(this.serverSession);
  43         }
  44
  45         /**
  46          * Both PCEs accept session characteristics. Also tests KeepAliveTimer and
  47          * error message and when pce attempts to establish pce session for the 2nd
  48          * time.
  49          *
  50          * @throws InterruptedException
  51          */
  52         @Test
  53         public void testSessionCharsAccBoth() throws InterruptedException {
  54                 this.serverSession.startSession();
  55                 assertEquals(1, this.client.getListMsg().size());
  56                 assertTrue(this.client.getListMsg().get(0) instanceof PCEPOpenMessage);
  57                 this.client.sendMessage(new PCEPOpenMessage(new PCEPOpenObject(3, 9, 2)));
  58                 assertEquals(2, this.client.getListMsg().size());
  59                 assertTrue(this.client.getListMsg().get(1) instanceof PCEPKeepAliveMessage);
  60                 this.client.sendMessage(new PCEPKeepAliveMessage());
  61                 synchronized (this.serverListener) {
  62                         while (!this.serverListener.up)
  63                                 try {
  64                                         this.serverListener.wait();
  65                                 } catch (final InterruptedException e) {
  66                                         e.printStackTrace();
  67                                 }
  68                 }
  69                 assertTrue(this.serverListener.up);
  70 //              Thread.sleep(PCEPSessionImpl.KEEP_ALIVE_TIMER_VALUE * 1000);
  71 //              assertEquals(3, this.client.getListMsg().size());
  72 //              assertTrue(this.client.getListMsg().get(2) instanceof PCEPKeepAliveMessage); // test of keepalive timer
  73                 this.client.sendMessage(new PCEPOpenMessage(new PCEPOpenObject(1, 1, 1)));
  74                 assertEquals(3, this.client.getListMsg().size());
  75                 assertTrue(this.client.getListMsg().get(2) instanceof PCEPErrorMessage);
  76                 for (final PCEPMessage m : this.client.getListMsg()) {
  77                         if (m instanceof PCEPErrorMessage) {
  78                                 final PCEPErrorObject obj = ((PCEPErrorMessage) m).getErrorObjects().get(0);
  79                                 assertEquals(PCEPErrors.ATTEMPT_2ND_SESSION, obj.getError()); // test of error type 9
  80                         }
  81                 }
  82         }
  83
  84         /**
  85          * Mock PCE does not accept session characteristics the first time.
  86          *
  87          * @throws InterruptedException
  88          */
  89         @Test
  90         public void testSessionCharsAccMe() throws InterruptedException {
  91                 this.serverSession.startSession();
  92                 this.client.sendMessage(new PCEPOpenMessage(new PCEPOpenObject(4, 9, 2)));
  93                 assertEquals(2, this.client.getListMsg().size());
  94                 assertTrue(this.client.getListMsg().get(0) instanceof PCEPOpenMessage);
  95                 assertTrue(this.client.getListMsg().get(1) instanceof PCEPKeepAliveMessage);
  96                 this.client.sendErrorMessage(PCEPErrors.NON_ACC_NEG_SESSION_CHAR, new PCEPOpenObject(3, 7, 2, null));
  97                 assertEquals(3, this.client.getListMsg().size());
  98                 assertTrue(this.client.getListMsg().get(2) instanceof PCEPOpenMessage);
  99                 this.client.sendMessage(new PCEPKeepAliveMessage());
 100                 synchronized (this.serverListener) {
 101                         while (!this.serverListener.up)
 102                                 try {
 103                                         this.serverListener.wait();
 104                                 } catch (final InterruptedException e) {
 105                                         e.printStackTrace();
 106                                 }
 107                 }
 108                 assertTrue(this.serverListener.up);
 109         }
 110
 111         /**
 112          * Sending different PCEP Message than Open in session establishment phase.
 113          *
 114          * @throws InterruptedException
 115          */
 116         @Test
 117         public void testErrorOneOne() throws InterruptedException {
 118                 this.serverSession.startSession();
 119                 assertEquals(1, this.client.getListMsg().size());
 120                 assertTrue(this.client.getListMsg().get(0) instanceof PCEPOpenMessage);
 121                 this.client.sendMessage(new PCEPNotificationMessage(new ArrayList<CompositeNotifyObject>() {
 122                         private static final long serialVersionUID = 1L;
 123
 124                         {
 125                                 this.add(new CompositeNotifyObject(new ArrayList<PCEPNotificationObject>() {
 126                                         private static final long serialVersionUID = 1L;
 127
 128                                         {
 129                                                 this.add(new PCEPNotificationObject((short) 1, (short) 1));
 130                                         }
 131                                 }));
 132                         }
 133                 }));
 134                 for (final PCEPMessage m : this.client.getListMsg()) {
 135                         if (m instanceof PCEPErrorMessage) {
 136                                 final PCEPErrorObject obj = ((PCEPErrorMessage) m).getErrorObjects().get(0);
 137                                 assertEquals(PCEPErrors.NON_OR_INVALID_OPEN_MSG, obj.getError());
 138                         }
 139                 }
 140         }
 141
 142         /************* Tests commented because of their long duration (tested timers) **************/
 143
 144         /**
 145          * OpenWait timer expired.
 146          *
 147          * @throws InterruptedException
 148          */
 149         @Test
 150         @Ignore
 151         public void testErrorOneTwo() throws InterruptedException {
 152                 this.serverSession.startSession();
 153                 assertEquals(1, this.client.getListMsg().size());
 154                 assertTrue(this.client.getListMsg().get(0) instanceof PCEPOpenMessage);
 155                 Thread.sleep(PCEPSessionImpl.OPEN_WAIT_TIMER_VALUE * 1000);
 156                 for (final PCEPMessage m : this.client.getListMsg()) {
 157                         if (m instanceof PCEPErrorMessage) {
 158                                 final PCEPErrorObject obj = ((PCEPErrorMessage) m).getErrorObjects().get(0);
 159                                 assertEquals(PCEPErrors.NO_OPEN_BEFORE_EXP_OPENWAIT, obj.getError());
 160                         }
 161                 }
 162         }
 163
 164         /**
 165          * KeepWaitTimer expired.
 166          *
 167          * @throws InterruptedException
 168          */
 169         @Test
 170         @Ignore
 171         public void testErrorOneSeven() throws InterruptedException {
 172                 this.serverSession.startSession();
 173                 assertEquals(1, this.client.getListMsg().size());
 174                 assertTrue(this.client.getListMsg().get(0) instanceof PCEPOpenMessage);
 175                 this.client.sendMessage(new PCEPOpenMessage(new PCEPOpenObject(3, 9, 2)));
 176                 Thread.sleep(PCEPSessionImpl.KEEP_WAIT_TIMER_VALUE * 1000);
 177                 for (final PCEPMessage m : this.client.getListMsg()) {
 178                         if (m instanceof PCEPErrorMessage) {
 179                                 final PCEPErrorObject obj = ((PCEPErrorMessage) m).getErrorObjects().get(0);
 180                                 assertEquals(PCEPErrors.NO_MSG_BEFORE_EXP_KEEPWAIT, obj.getError());
 181                         }
 182                 }
 183         }
 184
 185         @Test
 186         @Ignore
 187         public void testUnknownMessage() throws InterruptedException {
 188                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 189                 assertEquals(1, this.serverSession.unknownMessagesTimes.size());
 190                 Thread.sleep(10000);
 191                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 192                 assertEquals(2, this.serverSession.unknownMessagesTimes.size());
 193                 Thread.sleep(10000);
 194                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 195                 assertEquals(3, this.serverSession.unknownMessagesTimes.size());
 196                 Thread.sleep(20000);
 197                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 198                 assertEquals(4, this.serverSession.unknownMessagesTimes.size());
 199                 Thread.sleep(30000);
 200                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 201                 assertEquals(3, this.serverSession.unknownMessagesTimes.size());
 202                 Thread.sleep(10000);
 203                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 204                 assertEquals(3, this.serverSession.unknownMessagesTimes.size());
 205                 Thread.sleep(5000);
 206                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 207                 assertEquals(4, this.serverSession.unknownMessagesTimes.size());
 208                 Thread.sleep(1000);
 209                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 210                 assertEquals(5, this.serverSession.unknownMessagesTimes.size());
 211                 Thread.sleep(1000);
 212                 this.serverSession.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
 213                 synchronized (this.client) {
 214                         while (!this.client.down)
 215                                 try {
 216                                         this.client.wait();
 217                                 } catch (final InterruptedException e) {
 218                                         e.printStackTrace();
 219                                 }
 220                 }
 221                 assertTrue(this.client.down);
 222         }
 223
 224         @After
 225         public void tearDown() {
 226                 this.serverSession.close();
 227         }
 228 }