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