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