impl/src/test/java/org/opendaylight/unimgr/impl/FcRouteActivatorServiceTest.java

   1 /*
   2  * Copyright (c) 2016 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.unimgr.impl;
   9
  10 import org.junit.Before;
  11 import org.junit.Test;
  12 import org.mockito.Mockito;
  13 import org.opendaylight.unimgr.mef.nrp.api.ActivationDriver;
  14 import org.opendaylight.unimgr.mef.nrp.api.ActivationDriverBuilder;
  15 import org.opendaylight.unimgr.mef.nrp.impl.ActivationDriverRepoServiceImpl;
  16 import org.opendaylight.unimgr.utils.ActivationDriverMocks;
  17 import org.opendaylight.yang.gen.v1.urn.onf.core.network.module.rev160630.forwarding.constructs.ForwardingConstruct;
  18 import org.opendaylight.yang.gen.v1.urn.onf.core.network.module.rev160630.g_forwardingconstruct.FcPort;
  19 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  20
  21 import java.util.Arrays;
  22 import java.util.Collections;
  23 import java.util.List;
  24 import java.util.function.Consumer;
  25
  26 import static org.mockito.Mockito.*;
  27 import static org.opendaylight.unimgr.impl.ForwardingConstructTestUtils.fcSingleNode;
  28 import static org.opendaylight.unimgr.impl.ForwardingConstructTestUtils.fcTwoNodes;
  29
  30 class TestBusinessEx extends RuntimeException {
  31     public TestBusinessEx() {
  32         super("expected exception");
  33     }
  34 }
  35
  36 /**
  37  * @author bartosz.michalik@amartus.com
  38  * @author krzysztof.bijakowski@amartus.com [modifications]
  39  */
  40 public class FcRouteActivatorServiceTest {
  41
  42     private static final TopologyId topoA = new TopologyId("a");
  43
  44     private static final TopologyId topoZ = new TopologyId("z");
  45
  46     private ForwardingConstructActivationStateTracker stateTracker;
  47
  48     public ForwardingConstructActivatorService createService(List<ActivationDriverBuilder> builders) {
  49         return new ForwardingConstructActivatorService(new ActivationDriverRepoServiceImpl(builders));
  50     }
  51
  52     @Before
  53     public void setup() {
  54         stateTracker = Mockito.mock(ForwardingConstructActivationStateTracker.class);
  55         when(stateTracker.isActivatable()).thenReturn(true);
  56         when(stateTracker.isDeactivatable()).thenReturn(true);
  57     }
  58
  59     @Test
  60     public void testActivateSingleNode() throws Exception {
  61         //having
  62         final ActivationDriver d1 = mock(ActivationDriver.class);
  63
  64         ForwardingConstructActivatorService service = createService(Arrays.asList(
  65                 ActivationDriverMocks.prepareDriver((port1, port2) -> topoA.equals(port1.getTopology()) ? d1 : null),
  66                 ActivationDriverMocks.prepareDriver((port1, port2) -> null)
  67         ));
  68
  69         //when
  70         service.activate(fcSingleNode(), stateTracker);
  71
  72         //then
  73         verify(d1).activate();
  74         verify(d1).commit();
  75         verify(stateTracker).isActivatable();
  76         verify(stateTracker).activated(Mockito.any());
  77     }
  78
  79     @Test
  80     public void testActivateTwoNodesSingleVendor() throws Exception {
  81         //having
  82         final ActivationDriver d1 = mock(ActivationDriver.class);
  83
  84         ForwardingConstructActivatorService service = createService(Collections.singletonList(
  85                 ActivationDriverMocks.prepareDriver(port -> d1)
  86         ));
  87
  88         //when
  89         service.activate(fcTwoNodes(), stateTracker);
  90
  91         //then
  92         verify(d1, times(2)).activate();
  93         verify(d1, times(2)).commit();
  94         verify(stateTracker).isActivatable();
  95         verify(stateTracker).activated(Mockito.any());
  96     }
  97
  98     @Test
  99     public void testActivateTwoNodesMultiVendor() throws Exception {
 100         //having
 101         final ActivationDriver d1 = mock(ActivationDriver.class);
 102         final ActivationDriver d2 = mock(ActivationDriver.class);
 103
 104         ForwardingConstructActivatorService service = createService(Arrays.asList(
 105                 ActivationDriverMocks.prepareDriver(port -> topoA.equals(port.getTopology()) ? d1 : null),
 106                 ActivationDriverMocks.prepareDriver(port -> topoZ.equals(port.getTopology()) ? d2 : null)
 107         ));
 108
 109         //when
 110         service.activate(fcTwoNodes(), stateTracker);
 111         //then
 112         verify(d1).activate();
 113         verify(d1).commit();
 114         verify(d2).activate();
 115         verify(d2).commit();
 116         verify(stateTracker).isActivatable();
 117         verify(stateTracker).activated(Mockito.any());
 118     }
 119
 120     @Test
 121     public void testActivateSingleNodeFailure() throws Exception {
 122         //having
 123         final ActivationDriver d1 = spy(new FailingActivationDriver(p -> { if(p.getTopology().equals(topoA)) throw new TestBusinessEx();}));
 124
 125         ForwardingConstructActivatorService service = createService(Collections.singletonList(
 126                 ActivationDriverMocks.prepareDriver((p1,p2) -> d1)
 127         ));
 128
 129         //when
 130         service.activate(fcSingleNode(), stateTracker);
 131
 132         //then
 133         verify(d1, times(1)).rollback();
 134         verify(stateTracker).isActivatable();
 135         verify(stateTracker).activationFailed(Mockito.any());
 136     }
 137
 138     @Test
 139     public void testActivateFcExists() throws Exception {
 140         //having
 141         ForwardingConstructActivationStateTracker stateTrackerFcExists = Mockito.mock(ForwardingConstructActivationStateTracker.class);
 142         when(stateTrackerFcExists.isActivatable()).thenReturn(false);
 143
 144         final ActivationDriver d1 = mock(ActivationDriver.class);
 145
 146         ForwardingConstructActivatorService service = createService(Arrays.asList(
 147                 ActivationDriverMocks.prepareDriver((port1, port2) -> topoA.equals(port1.getTopology()) ? d1 : null),
 148                 ActivationDriverMocks.prepareDriver((port1, port2) -> null)
 149         ));
 150
 151         //when
 152         service.activate(fcSingleNode(), stateTrackerFcExists);
 153
 154         //then
 155         verify(d1, never()).activate();
 156         verify(d1, never()).commit();
 157         verify(stateTrackerFcExists).isActivatable();
 158         verify(stateTrackerFcExists, never()).activated(Mockito.any());
 159         verify(stateTrackerFcExists, never()).activationFailed(Mockito.any());
 160     }
 161
 162     @Test
 163     public void testActivateMultiNodeFailure() throws Exception {
 164         //having
 165         final ActivationDriver d1 = spy(new FailingActivationDriver(p -> { if(p.getTopology().equals(topoA)) throw new TestBusinessEx();}));
 166
 167         ForwardingConstructActivatorService service = createService(Collections.singletonList(
 168                 ActivationDriverMocks.prepareDriver(p1 -> d1)
 169         ));
 170
 171         //when
 172         service.activate(fcTwoNodes(), stateTracker);
 173
 174         //then
 175         verify(d1, times(1)).activate();
 176         verify(d1, times(2)).rollback();
 177         verify(stateTracker).isActivatable();
 178         verify(stateTracker).activationFailed(Mockito.any());
 179     }
 180
 181     @Test
 182     public void testDeactivateSingleNodeFailure() throws Exception {
 183         //having
 184         final ActivationDriver d1 = spy(new FailingActivationDriver(p -> { if(p.getTopology().equals(topoA)) throw new TestBusinessEx();}));
 185
 186         ForwardingConstructActivatorService service = createService(Arrays.asList(
 187                 ActivationDriverMocks.prepareDriver((p1,p2) -> null),
 188                 ActivationDriverMocks.prepareDriver((p1,p2) -> d1)
 189         ));
 190
 191         //when
 192         service.deactivate(fcSingleNode(), stateTracker);
 193
 194         //then
 195         verify(d1, times(1)).deactivate();
 196         verify(d1, times(1)).rollback();
 197         verify(stateTracker).isDeactivatable();
 198         verify(stateTracker).deactivationFailed();
 199     }
 200
 201     @Test
 202     public void testDeactivateTwoNodesSingleVendor() throws Exception {
 203         //having
 204         final ActivationDriver d1 = mock(ActivationDriver.class);
 205
 206         ForwardingConstructActivatorService service = createService(Collections.singletonList(
 207                 ActivationDriverMocks.prepareDriver(port -> d1)
 208         ));
 209
 210         //when
 211         service.deactivate(fcTwoNodes(), stateTracker);
 212
 213         //then
 214         verify(d1, times(2)).deactivate();
 215         verify(d1, times(2)).commit();
 216         verify(stateTracker).isDeactivatable();
 217         verify(stateTracker).deactivated();
 218     }
 219
 220     @Test
 221     public void testDeactivateFcNotExists() throws Exception {
 222         //having
 223         ForwardingConstructActivationStateTracker stateTrackerFcNotExists = Mockito.mock(ForwardingConstructActivationStateTracker.class);
 224         when(stateTrackerFcNotExists.isDeactivatable()).thenReturn(false);
 225
 226         final ActivationDriver d1 = mock(ActivationDriver.class);
 227
 228         ForwardingConstructActivatorService service = createService(Collections.singletonList(
 229                 ActivationDriverMocks.prepareDriver(port -> d1)
 230         ));
 231
 232         //when
 233         service.deactivate(fcTwoNodes(), stateTrackerFcNotExists);
 234
 235         //then
 236         verify(d1, never()).deactivate();
 237         verify(d1, never()).commit();
 238         verify(stateTrackerFcNotExists).isDeactivatable();
 239         verify(stateTrackerFcNotExists, never()).deactivated();
 240         verify(stateTrackerFcNotExists, never()).deactivationFailed();
 241     }
 242
 243     private static class FailingActivationDriver implements ActivationDriver {
 244
 245         private final Consumer<FcPort> consumer;
 246
 247         private FcPort from;
 248
 249         FailingActivationDriver(Consumer<FcPort> portConsumer) {
 250             this.consumer  = portConsumer;
 251         }
 252
 253         @Override
 254         public void commit() {
 255
 256         }
 257
 258         @Override
 259         public void rollback() {
 260
 261         }
 262
 263         @Override
 264         public void initialize(FcPort from, FcPort to, ForwardingConstruct context) {
 265             if(this.from == null)
 266                 this.from = from;
 267         }
 268
 269         @Override
 270         public void activate() {
 271             consumer.accept(from);
 272         }
 273
 274         @Override
 275         public void deactivate() {
 276             consumer.accept(from);
 277         }
 278
 279         @Override
 280         public int priority() {
 281             return 0;
 282         }
 283     }
 284 }