impl/src/test/java/org/opendaylight/unimgr/impl/ForwardingConstructActivationStateTrackerTest.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 com.google.common.base.Optional;
  11 import com.google.common.util.concurrent.CheckedFuture;
  12 import org.junit.Before;
  13 import org.junit.Test;
  14 import org.mockito.Mockito;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  17 import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  20 import org.opendaylight.yang.gen.v1.urn.mef.unimgr.ext.rev160725.ActivationStatus;
  21 import org.opendaylight.yang.gen.v1.urn.onf.core.network.module.rev160630.forwarding.constructs.ForwardingConstruct;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23
  24 import static org.junit.Assert.*;
  25 import static org.mockito.Matchers.any;
  26 import static org.mockito.Mockito.mock;
  27 import static org.mockito.Mockito.when;
  28 import static org.opendaylight.unimgr.impl.ForwardingConstructTestUtils.fcIid;
  29 import static org.opendaylight.unimgr.impl.ForwardingConstructTestUtils.fcSingleNode;
  30
  31 /**
  32  * @author krzysztof.bijakowski@amartus.com
  33  */
  34 public class ForwardingConstructActivationStateTrackerTest extends AbstractDataBrokerTest {
  35
  36     private InstanceIdentifier fcIid;
  37
  38     @Before
  39     public void setUp() {
  40         fcIid = fcIid();
  41     }
  42
  43     @Test
  44     public void testIsActivatablePositive() {
  45         //given
  46         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(mockDataBroker(false));
  47
  48         //when
  49         boolean result = stateTracker.isActivatable();
  50
  51         //then
  52         assertTrue(result);
  53     }
  54
  55     @Test
  56     public void testIsActivatableNegative() {
  57         //given
  58         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(mockDataBroker(true));
  59
  60         //when
  61         boolean result = stateTracker.isActivatable();
  62
  63         //then
  64         assertFalse(result);
  65     }
  66
  67     @Test
  68     public void testIsDeactivatablePositive() {
  69         //given
  70         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(mockDataBroker(true));
  71
  72         //when
  73         boolean result = stateTracker.isDeactivatable();
  74
  75         //then
  76         assertTrue(result);
  77     }
  78
  79     @Test
  80     public void testIsDeactivatableNegative() {
  81         //given
  82         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(mockDataBroker(false));
  83
  84         //when
  85         boolean result = stateTracker.isDeactivatable();
  86
  87         //then
  88         assertFalse(result);
  89     }
  90
  91     @Test
  92     public void testActivated() {
  93         //given
  94         DataBroker dataBroker = getDataBroker();
  95         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(dataBroker);
  96         ForwardingConstruct exceptedFc = fcSingleNode();
  97
  98         //when
  99         stateTracker.activated(exceptedFc);
 100
 101         //then
 102         ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
 103         CheckedFuture<Optional<ForwardingConstruct>, ReadFailedException> result =
 104                 transaction.read(LogicalDatastoreType.OPERATIONAL, fcIid);
 105         Optional<ForwardingConstruct> fcOptional = Optional.absent();
 106
 107         try {
 108             fcOptional = result.checkedGet();
 109         } catch (ReadFailedException e) {
 110             fail("Error during test result verification - cannot read data : " + e.getMessage());
 111         }
 112
 113         assertTrue(fcOptional.isPresent());
 114         ForwardingConstruct actualFc = fcOptional.get();
 115         ForwardingConstructTestUtils.assertEquals(exceptedFc, actualFc);
 116         ForwardingConstructTestUtils.assertActivationState(actualFc, ActivationStatus.ACTIVE);
 117     }
 118
 119     @Test
 120     public void testActivationFailed() {
 121         //given
 122         DataBroker dataBroker = getDataBroker();
 123         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(dataBroker);
 124         ForwardingConstruct exceptedFc = fcSingleNode();
 125
 126         //when
 127         stateTracker.activationFailed(exceptedFc);
 128
 129         //then
 130         ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
 131         CheckedFuture<Optional<ForwardingConstruct>, ReadFailedException> result =
 132                 transaction.read(LogicalDatastoreType.OPERATIONAL, fcIid);
 133         Optional<ForwardingConstruct> fcOptional = Optional.absent();
 134
 135         try {
 136             fcOptional = result.checkedGet();
 137         } catch (ReadFailedException e) {
 138             fail("Error during test result verification - cannot read data : " + e.getMessage());
 139         }
 140
 141         assertTrue(fcOptional.isPresent());
 142         ForwardingConstruct actualFc = fcOptional.get();
 143         ForwardingConstructTestUtils.assertEquals(exceptedFc, actualFc);
 144         ForwardingConstructTestUtils.assertActivationState(actualFc, ActivationStatus.FAILED);
 145     }
 146
 147     @Test
 148     public void testDeactivated() {
 149         //given
 150         DataBroker dataBroker = getDataBroker();
 151         ForwardingConstructActivationStateTracker stateTracker = createStateTracker(dataBroker);
 152         ForwardingConstruct fc = fcSingleNode();
 153         stateTracker.activated(fc);
 154
 155         //when
 156         stateTracker.deactivated();
 157
 158         //then
 159         ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
 160         CheckedFuture<Optional<ForwardingConstruct>, ReadFailedException> result =
 161                 transaction.read(LogicalDatastoreType.OPERATIONAL, fcIid);
 162         Optional<ForwardingConstruct> fcOptional = Optional.absent();
 163
 164         try {
 165             fcOptional = result.checkedGet();
 166         } catch (ReadFailedException e) {
 167             fail("Error during test result verification - cannot read data : " + e.getMessage());
 168         }
 169
 170         assertFalse(fcOptional.isPresent());
 171     }
 172
 173     @Test
 174     public void testDeactivationFailed() {
 175         //TODO write test when implemented
 176     }
 177
 178     private DataBroker mockDataBroker(boolean fcExists) {
 179         DataBroker dataBroker = mock(DataBroker.class);
 180         final ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
 181         final CheckedFuture transactionResult = mock(CheckedFuture.class);
 182         final ForwardingConstruct forwardingConstruct = Mockito.mock(ForwardingConstruct.class);
 183         final Optional<ForwardingConstruct> optionalForwardingConstruct;
 184
 185         if(fcExists) {
 186             optionalForwardingConstruct = Optional.of(forwardingConstruct);
 187         } else {
 188             optionalForwardingConstruct = Optional.absent();
 189         }
 190
 191         try {
 192             when(transactionResult.checkedGet()).thenReturn(optionalForwardingConstruct);
 193         } catch (Exception e) {
 194             fail("Cannot create mocks : " + e.getMessage());
 195         }
 196         when(transaction.read(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class)))
 197                 .thenReturn(transactionResult);
 198         when(dataBroker.newReadOnlyTransaction()).thenReturn(transaction);
 199
 200         return dataBroker;
 201     }
 202
 203     private ForwardingConstructActivationStateTracker createStateTracker(DataBroker dataBroker) {
 204         return new ForwardingConstructActivationStateTracker(dataBroker, fcIid);
 205     }
 206 }