renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManagerTest.java

   1 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
   2
   3 import java.util.Arrays;
   4 import java.util.Collection;
   5
   6 import org.junit.Assert;
   7 import org.junit.Before;
   8 import org.junit.Test;
   9 import org.junit.runner.RunWith;
  10 import org.mockito.Matchers;
  11 import org.mockito.Mock;
  12 import org.mockito.Mockito;
  13 import org.mockito.runners.MockitoJUnitRunner;
  14 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.groupbasedpolicy.renderer.vpp.DtoFactory;
  17 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
  18 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
  19 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
  20 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.NetworkTypeBase;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomain;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.BridgeDomainBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanVni;
  35 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37
  38 import com.google.common.base.Optional;
  39 import com.google.common.collect.ImmutableSetMultimap;
  40 import com.google.common.collect.SetMultimap;
  41 import com.google.common.util.concurrent.Futures;
  42
  43 @RunWith(MockitoJUnitRunner.class)
  44 public class ForwardingManagerTest extends CustomDataBrokerTest {
  45
  46     private static final String BD_1 = "bd1";
  47     private static final NodeId NODE_1 = new NodeId("node1");
  48     private static final VlanId VLAN_1 = new VlanId(1);
  49     @Mock
  50     private InterfaceManager ifaceManager;
  51     @Mock
  52     private BridgeDomainManager bdManager;
  53
  54     private ForwardingManager fwdManager;
  55
  56     @Before
  57     public void init() {
  58         fwdManager = new ForwardingManager(ifaceManager, bdManager, getDataBroker());
  59     }
  60
  61     @Override
  62     public Collection<Class<?>> getClassesFromModules() {
  63         return Arrays.asList(BridgeDomain.class);
  64     }
  65
  66     @Test
  67     public void testReadBridgeDomainConfig() throws Exception {
  68         BridgeDomain bd = new BridgeDomainBuilder().setId(BD_1).setType(NetworkTypeBase.class).build();
  69         InstanceIdentifier<BridgeDomain> bdIid =
  70                 InstanceIdentifier.builder(Config.class).child(BridgeDomain.class, bd.getKey()).build();
  71         Optional<BridgeDomain> bdOptional = fwdManager.readBridgeDomainConfig(bd.getId());
  72         Assert.assertFalse(bdOptional.isPresent());
  73
  74         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
  75         wTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, bd);
  76         wTx.submit().get();
  77
  78         bdOptional = fwdManager.readBridgeDomainConfig(bd.getId());
  79         Assert.assertTrue(bdOptional.isPresent());
  80         Assert.assertEquals(bd, bdOptional.get());
  81     }
  82
  83     @Test
  84     public void testCreateBridgeDomainOnNodes_vxlan() throws Exception {
  85         Mockito.when(bdManager.createVxlanBridgeDomainOnVppNode(Mockito.eq(BD_1), Mockito.any(VxlanVni.class),
  86                 Mockito.eq(NODE_1)))
  87             .thenReturn(Futures.immediateFuture(null));
  88         SetMultimap<String, NodeId> vppNodesByBd = ImmutableSetMultimap.of(BD_1, NODE_1);
  89
  90         fwdManager.createBridgeDomainOnNodes(vppNodesByBd);
  91         Mockito.verify(bdManager).createVxlanBridgeDomainOnVppNode(Matchers.eq(BD_1), Matchers.any(VxlanVni.class),
  92                 Matchers.eq(NODE_1));
  93     }
  94
  95     @Test
  96     public void testCreateBridgeDomainOnNodes_vlan() throws Exception {
  97         Mockito.when(bdManager.createVlanBridgeDomainOnVppNode(Mockito.eq(BD_1), Mockito.any(VlanId.class),
  98                 Mockito.eq(NODE_1)))
  99             .thenReturn(Futures.immediateFuture(null));
 100         BridgeDomain bd = new BridgeDomainBuilder().setId(BD_1).setType(VlanNetwork.class).setVlan(VLAN_1).build();
 101         InstanceIdentifier<BridgeDomain> bdIid =
 102                 InstanceIdentifier.builder(Config.class).child(BridgeDomain.class, bd.getKey()).build();
 103         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 104         wTx.put(LogicalDatastoreType.CONFIGURATION, bdIid, bd);
 105         wTx.submit().get();
 106         SetMultimap<String, NodeId> vppNodesByBd = ImmutableSetMultimap.of(BD_1, NODE_1);
 107
 108         fwdManager.createBridgeDomainOnNodes(vppNodesByBd);
 109         Mockito.verify(bdManager).createVlanBridgeDomainOnVppNode(Matchers.eq(BD_1), Matchers.eq(VLAN_1),
 110                 Matchers.eq(NODE_1));
 111     }
 112
 113     @Test
 114     public void testRemoveBridgeDomainOnNodes() throws Exception {
 115         Mockito.when(bdManager.removeBridgeDomainFromVppNode(Mockito.eq(BD_1), Mockito.eq(NODE_1)))
 116             .thenReturn(Futures.immediateFuture(null));
 117         SetMultimap<String, NodeId> vppNodesByBd = ImmutableSetMultimap.of(BD_1, NODE_1);
 118
 119         bdManager.removeBridgeDomainFromVppNode(BD_1, NODE_1);
 120         Mockito.verify(bdManager).removeBridgeDomainFromVppNode(Matchers.eq(BD_1), Matchers.eq(NODE_1));
 121     }
 122
 123     @Test
 124     public void testCreateForwardingForEndpoint() throws Exception {
 125         String clientIp = "1.1.1.1";
 126         String clientIfaceName = "client1";
 127         AbsoluteLocation clientLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, clientIfaceName);
 128         AddressEndpointWithLocation clientEp =
 129                 DtoFactory.createEndpoint(clientIp, DtoFactory.L2FD_CTX.getValue(), clientLocation);
 130         String webIp = "2.2.2.2";
 131         String webIfaceName = "web1";
 132         AbsoluteLocation webLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, webIfaceName);
 133         AddressEndpointWithLocation webEp =
 134                 DtoFactory.createEndpoint(webIp, DtoFactory.L2FD_CTX.getValue(), webLocation);
 135         Configuration configuration = DtoFactory.createConfiguration(Arrays.asList(clientEp), Arrays.asList(webEp));
 136         RendererPolicy rendererPolicy =
 137                 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
 138         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
 139         RendererEndpoint firstRendererEp = configuration.getRendererEndpoints().getRendererEndpoint().get(0);
 140         AddressEndpointWithLocation firstAddrEpWithLoc =
 141                 policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(firstRendererEp.getKey()));
 142         Mockito.when(ifaceManager.addBridgeDomainToInterface(Mockito.eq(DtoFactory.L2FD_CTX.getValue()),
 143                 Mockito.eq(firstAddrEpWithLoc)))
 144             .thenReturn(Futures.immediateFuture(null));
 145
 146         fwdManager.createForwardingForEndpoint(firstRendererEp.getKey(), policyCtx);
 147         Mockito.verify(ifaceManager).addBridgeDomainToInterface(Matchers.eq(DtoFactory.L2FD_CTX.getValue()),
 148                 Matchers.eq(firstAddrEpWithLoc));
 149     }
 150
 151     @Test
 152     public void testRemoveForwardingForEndpoint() throws Exception {
 153         String clientIp = "1.1.1.1";
 154         String clientIfaceName = "client1";
 155         String bdNameOnVpp = "bdRed";
 156         AbsoluteLocation clientLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, bdNameOnVpp, clientIfaceName);
 157         AddressEndpointWithLocation clientEp =
 158                 DtoFactory.createEndpoint(clientIp, DtoFactory.L2FD_CTX.getValue(), clientLocation);
 159         String webIp = "2.2.2.2";
 160         String webIfaceName = "web1";
 161         AbsoluteLocation webLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, bdNameOnVpp, webIfaceName);
 162         AddressEndpointWithLocation webEp =
 163                 DtoFactory.createEndpoint(webIp, DtoFactory.L2FD_CTX.getValue(), webLocation);
 164         Configuration configuration = DtoFactory.createConfiguration(Arrays.asList(clientEp), Arrays.asList(webEp));
 165         RendererPolicy rendererPolicy =
 166                 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
 167         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
 168         RendererEndpoint firstRendererEp = configuration.getRendererEndpoints().getRendererEndpoint().get(0);
 169         AddressEndpointWithLocation firstAddrEpWithLoc =
 170                 policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(firstRendererEp.getKey()));
 171         Mockito.when(ifaceManager.deleteBridgeDomainFromInterface(
 172                 Mockito.eq(firstAddrEpWithLoc)))
 173             .thenReturn(Futures.immediateFuture(null));
 174
 175         fwdManager.removeForwardingForEndpoint(firstRendererEp.getKey(), policyCtx);
 176         Mockito.verify(ifaceManager).deleteBridgeDomainFromInterface(Matchers.eq(firstAddrEpWithLoc));
 177     }
 178
 179 }