openstack/net-virt-providers/src/test/java/org/opendaylight/ovsdb/openstack/netvirt/providers/openflow13/services/L2FowardingServiceTest.java

   1 /*
   2  * Copyright (c) 2015 Inocybe 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
   9 package org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.services;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Matchers.anyBoolean;
  13 import static org.mockito.Mockito.mock;
  14 import static org.mockito.Mockito.times;
  15 import static org.mockito.Mockito.verify;
  16 import static org.mockito.Mockito.when;
  17
  18 import org.junit.Before;
  19 import org.junit.Ignore;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.InjectMocks;
  23 import org.mockito.Mock;
  24 import org.mockito.runners.MockitoJUnitRunner;
  25 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  26 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  27 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  28 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  30 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  31 import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.PipelineOrchestrator;
  32 import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  36
  37 import com.google.common.base.Optional;
  38 import com.google.common.util.concurrent.CheckedFuture;
  39
  40 /**
  41  * Unit test fort {@link L2ForwardingService}
  42  */
  43 @Ignore // TODO SB_MIGRATION
  44 @RunWith(MockitoJUnitRunner.class)
  45 public class L2FowardingServiceTest {
  46
  47     @InjectMocks private L2ForwardingService l2ForwardingService = new L2ForwardingService(Service.ARP_RESPONDER);
  48
  49     //@Mock private MdsalConsumer mdsalConsumer;
  50     @Mock private PipelineOrchestrator orchestrator;
  51
  52     @Mock private ReadWriteTransaction readWriteTransaction;
  53     @Mock private WriteTransaction writeTransaction;
  54     @Mock private ReadOnlyTransaction readOnlyTransaction;
  55     @Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
  56
  57     private static final String SEGMENTATION_ID = "2";
  58     private static final String MAC_ADDRESS = "87:1D:5E:02:40:B8";
  59     private static final Long DPID = Long.valueOf(122);
  60     private static final Long LOCAL_PORT = Long.valueOf(451);
  61     private static final Long ETH_PORT = Long.valueOf(564);
  62     private static final Long OF_PORT_OUT = Long.valueOf(5698);
  63
  64     @Before
  65     public void setUp() throws Exception {
  66         when(readWriteTransaction.submit()).thenReturn(commitFuture);
  67         when(writeTransaction.submit()).thenReturn(commitFuture);
  68
  69         DataBroker dataBroker = mock(DataBroker.class);
  70         when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
  71         when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
  72         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
  73
  74         CheckedFuture future = mock(CheckedFuture.class);
  75         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(future);
  76
  77         Optional<Flow> data = mock(Optional.class);
  78         when(future.get()).thenReturn(data);
  79
  80         //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
  81
  82         when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
  83     }
  84
  85     /**
  86      * Test method {@link L2ForwardingService#programLocalUcastOut(Long, String, Long, String, boolean)}
  87      */
  88     @Test
  89     public void testProgramLoacalUcastOut() throws Exception {
  90         l2ForwardingService.programLocalUcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, MAC_ADDRESS, true);
  91         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
  92         verify(readWriteTransaction, times(1)).submit();
  93         verify(commitFuture, times(1)).get();
  94
  95         l2ForwardingService.programLocalUcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, MAC_ADDRESS, false);
  96         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
  97         verify(readWriteTransaction, times(1)).submit();
  98         verify(commitFuture, times(2)).get(); // 1 + 1 above
  99     }
 100
 101     /**
 102      * Test method {@link L2ForwardingService#programLocalVlanUcastOut(Long, String, Long, String, boolean)}
 103      */
 104     @Test
 105     public void testProgramLocalVlanUcastOut() throws Exception {
 106         l2ForwardingService.programLocalVlanUcastOut(DPID, SEGMENTATION_ID, Long.valueOf(124), MAC_ADDRESS, true);
 107         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 108         verify(readWriteTransaction, times(1)).submit();
 109         verify(commitFuture, times(1)).get();
 110
 111         l2ForwardingService.programLocalVlanUcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, MAC_ADDRESS, false);
 112         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 113         verify(readWriteTransaction, times(1)).submit();
 114         verify(commitFuture, times(2)).get(); // 1 + 1 above
 115     }
 116
 117     /**
 118      * Test method {@link L2ForwardingService#programLocalBcastOut(Long, String, Long, boolean)}
 119      */
 120     @Test
 121     public void testProgramLocalBcastOut() throws Exception {
 122         l2ForwardingService.programLocalBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, true);
 123         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 124         verify(readWriteTransaction, times(1)).submit();
 125         verify(commitFuture, times(1)).get();
 126
 127         l2ForwardingService.programLocalBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, false);
 128         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 129         verify(readWriteTransaction, times(1)).submit();
 130         verify(commitFuture, times(2)).get(); // 1 + 1 above
 131     }
 132
 133     /**--------------------------------- TODO go deeper in test
 134      * Test method {@link L2ForwardingService#programLocalVlanBcastOut(Long, String, Long, Long, boolean)}
 135      */
 136     @Test
 137     public void testProgramLocalVlanBcastOut() throws Exception {
 138         l2ForwardingService.programLocalVlanBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, ETH_PORT, true);
 139         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 140         verify(readWriteTransaction, times(1)).submit();
 141         verify(commitFuture, times(1)).get();
 142
 143         l2ForwardingService.programLocalVlanBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, ETH_PORT, false);
 144         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 145         verify(readWriteTransaction, times(1)).submit();
 146         verify(commitFuture, times(2)).get(); // 1 + 1 above
 147     }
 148
 149     /**
 150      * Test method {@link L2ForwardingService#programLocalTableMiss(Long, String, boolean)}
 151      */
 152     @Test
 153     public void testProgramLocalTableMiss() throws Exception {
 154         l2ForwardingService.programLocalTableMiss(DPID, SEGMENTATION_ID, true);
 155         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 156         verify(readWriteTransaction, times(1)).submit();
 157         verify(commitFuture, times(1)).get();
 158
 159         l2ForwardingService.programLocalTableMiss(DPID, SEGMENTATION_ID, false);
 160         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 161         verify(readWriteTransaction, times(1)).submit();
 162         verify(commitFuture, times(2)).get(); // 1 + 1 above
 163     }
 164
 165     /**
 166      * Test method {@link L2ForwardingService#programLocalVlanTableMiss(Long, String, boolean)}
 167      */
 168     @Test
 169     public void testProgramLocalVlanTableMiss() throws Exception {
 170         l2ForwardingService.programLocalVlanTableMiss(DPID, SEGMENTATION_ID, true);
 171         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 172         verify(readWriteTransaction, times(1)).submit();
 173         verify(commitFuture, times(1)).get();
 174
 175         l2ForwardingService.programLocalVlanTableMiss(DPID, SEGMENTATION_ID, false);
 176         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 177         verify(readWriteTransaction, times(1)).submit();
 178         verify(commitFuture, times(2)).get(); // 1 + 1 above
 179     }
 180
 181     /**
 182      * Test method {@link L2ForwardingService#programTunnelOut(Long, String, Long, String, boolean)}
 183      */
 184     @Test
 185     public void testProgramTunnelOut() throws Exception {
 186         l2ForwardingService.programTunnelOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, MAC_ADDRESS, true);
 187         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 188         verify(readWriteTransaction, times(1)).submit();
 189         verify(commitFuture, times(1)).get();
 190
 191         l2ForwardingService.programTunnelOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, MAC_ADDRESS, false);
 192         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 193         verify(readWriteTransaction, times(1)).submit();
 194         verify(commitFuture, times(2)).get(); // 1 + 1 above
 195     }
 196
 197     /**
 198      * Test method {@link L2ForwardingService#programVlanOut(Long, String, Long, String, boolean)}
 199      */
 200     @Test
 201     public void testProgramVlanOut() throws Exception {
 202         l2ForwardingService.programVlanOut(DPID, SEGMENTATION_ID, ETH_PORT, MAC_ADDRESS, true);
 203         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 204         verify(readWriteTransaction, times(1)).submit();
 205         verify(commitFuture, times(1)).get();
 206
 207         l2ForwardingService.programVlanOut(DPID, SEGMENTATION_ID, ETH_PORT, MAC_ADDRESS, false);
 208         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 209         verify(readWriteTransaction, times(1)).submit();
 210         verify(commitFuture, times(2)).get(); // 1 + 1 above
 211     }
 212
 213     /**--------------------------------- TODO go deeper in test
 214      * Test method {@link L2ForwardingService#programTunnelFloodOut(Long, String, Long, boolean)}
 215      */
 216     @Test
 217     public void testProgramTunnelFloodOut() throws Exception {
 218         l2ForwardingService.programTunnelFloodOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, true);
 219         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 220         verify(readWriteTransaction, times(1)).submit();
 221         verify(commitFuture, times(1)).get();
 222
 223         l2ForwardingService.programTunnelFloodOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, false);
 224         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 225         verify(readWriteTransaction, times(1)).submit();
 226         verify(commitFuture, times(2)).get(); // 1 + 1 above
 227     }
 228
 229     /**
 230      * Test method {@link L2ForwardingService#programVlanFloodOut(Long, String, Long, boolean)}
 231      */
 232     @Test
 233     public void testProgramVlanFloodOut() throws Exception {
 234         l2ForwardingService.programVlanFloodOut(DPID, SEGMENTATION_ID, ETH_PORT, true);
 235         verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 236         verify(readWriteTransaction, times(1)).submit();
 237         verify(commitFuture, times(1)).get();
 238
 239         l2ForwardingService.programVlanFloodOut(DPID, SEGMENTATION_ID, ETH_PORT, false);
 240         verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 241         verify(readWriteTransaction, times(1)).submit();
 242         verify(commitFuture, times(2)).get(); // 1 + 1 above
 243     }
 244
 245     /**
 246     * Test method {@link L2ForwardingService#programTunnelMiss(Long, String, boolean)}
 247     */
 248    @Test
 249    public void testProgramTunnelMiss() throws Exception {
 250        l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, true);
 251        verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 252        verify(readWriteTransaction, times(1)).submit();
 253        verify(commitFuture, times(1)).get();
 254
 255        l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, false);
 256        verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 257        verify(readWriteTransaction, times(1)).submit();
 258        verify(commitFuture, times(2)).get(); // 1 + 1 above
 259    }
 260
 261    /**
 262     * Test method {@link L2ForwardingService#programVlanMiss(Long, String, Long, boolean)}
 263     */
 264    @Test
 265    public void testProgramVlanMiss() throws Exception {
 266        l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, true);
 267        verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
 268        verify(readWriteTransaction, times(1)).submit();
 269        verify(commitFuture, times(1)).get();
 270
 271        l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, false);
 272        verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 273        verify(readWriteTransaction, times(1)).submit();
 274        verify(commitFuture, times(2)).get(); // 1 + 1 above
 275    }
 276 }