renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/mapper/destination/DestinationMapperTest.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.groupbasedpolicy.renderer.ofoverlay.mapper.destination;
   9
  10
  11 import org.junit.Before;
  12 import org.junit.Test;
  13 import org.mockito.InOrder;
  14 import org.opendaylight.groupbasedpolicy.dto.EgKey;
  15 import org.opendaylight.groupbasedpolicy.dto.EpKey;
  16 import org.opendaylight.groupbasedpolicy.dto.IndexedTenant;
  17 import org.opendaylight.groupbasedpolicy.dto.PolicyInfo;
  18 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;
  19 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
  20 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.PolicyManager;
  21 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
  22 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.flow.OrdinalFactory;
  23 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.mapper.MapperUtilsTest;
  24 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3Address;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.l3.prefix.fields.EndpointL3Gateways;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.l3.prefix.fields.EndpointL3GatewaysBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3PrefixBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.ForwardingContextBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.PolicyBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomainBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomain;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomainBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3Context;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3ContextBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroup;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroupBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan;
  62
  63 import java.util.ArrayList;
  64 import java.util.Collection;
  65 import java.util.HashSet;
  66 import java.util.List;
  67 import java.util.Set;
  68
  69 import static junit.framework.TestCase.assertTrue;
  70 import static org.mockito.Mockito.*;
  71
  72 public class DestinationMapperTest extends MapperUtilsTest {
  73
  74     private DestinationMapper destinationMapper;
  75
  76     @Before
  77     public void init() {
  78         tableId = 3;
  79         endpointManager = mock(EndpointManager.class);
  80         policyManager = mock(PolicyManager.class);
  81         switchManager = mock(SwitchManager.class);
  82         policyInfo = mock(PolicyInfo.class);
  83         ctx = mock(OfContext.class);
  84         ofWriter = mock(OfWriter.class);
  85         destinationMapper = new DestinationMapper(ctx, tableId);
  86     }
  87
  88     @Test
  89     public void getTableId() {
  90         assertTrue(destinationMapper.getTableId() == tableId);
  91     }
  92
  93     @Test
  94     public void syncFlows() throws Exception {
  95         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
  96         EndpointBuilder endpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
  97
  98         when(ctx.getTenant(any(TenantId.class))).thenReturn(getTestIndexedTenant());
  99         when(ctx.getEndpointManager()).thenReturn(endpointManager);
 100         when(ctx.getPolicyManager()).thenReturn(policyManager);
 101         when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
 102
 103         destinationMapper.syncFlows(flows, endpointBuilder.build(), null, ofWriter);
 104
 105         // Verify usage
 106         verify(ctx, times(3)).getTenant(any(TenantId.class));
 107         verify(ctx, times(5)).getEndpointManager();
 108         verify(ctx, times(2)).getPolicyManager();
 109         verify(ctx, times(2)).getCurrentPolicy();
 110
 111         //Verify order
 112         InOrder order = inOrder(flows);
 113         order.verify(flows, times(1)).dropFlow(anyInt(), anyLong(), eq(ofWriter));
 114         order.verify(flows, times(1)).createBroadcastFlow(anyInt(), any(OrdinalFactory.EndpointFwdCtxOrdinals.class),
 115                 any(MacAddress.class), eq(ofWriter));
 116     }
 117
 118     @Test
 119     public void syncExternalEndpointFlows_L2Flow() {
 120         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
 121         // External ports
 122         Set<NodeConnectorId> externalPorts = new HashSet<>();
 123         externalPorts.add(CONNECTOR_0);
 124         externalPorts.add(CONNECTOR_1);
 125         // Endpoint
 126         EndpointBuilder endpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
 127         // Peer endpoint
 128         EndpointBuilder peerEndpointBuilder = buildEndpoint(IPV4_2, MAC_0, CONNECTOR_0);
 129         peerEndpointBuilder.setNetworkContainment(new SubnetId(SUBNET_1));
 130         // External Implicit groups
 131         List<ExternalImplicitGroup> externalImplicitGroups = new ArrayList<>();
 132         ExternalImplicitGroupBuilder externalImplicitGroupBuilder = new ExternalImplicitGroupBuilder();
 133         externalImplicitGroupBuilder.setId(ENDPOINT_GROUP_0);
 134         externalImplicitGroups.add(externalImplicitGroupBuilder.build());
 135         TenantBuilder peerTenantBuilder = buildTenant();
 136         peerTenantBuilder.setPolicy(new PolicyBuilder()
 137                 .setEndpointGroup(getEndpointGroups())
 138                 .setSubjectFeatureInstances(getSubjectFeatureInstances())
 139                 .setExternalImplicitGroup(externalImplicitGroups)
 140                 .build());
 141         Endpoint peerEndpoint = peerEndpointBuilder.build();
 142         Collection<Endpoint> peerEndpoints = new ArrayList<>();
 143         peerEndpoints.add(peerEndpoint);
 144
 145         when(ctx.getTenant(any(TenantId.class))).thenReturn(new IndexedTenant(peerTenantBuilder.build()));
 146         when(ctx.getEndpointManager()).thenReturn(endpointManager);
 147         when(ctx.getPolicyManager()).thenReturn(policyManager);
 148         when(ctx.getSwitchManager()).thenReturn(switchManager);
 149         when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
 150         when(endpointManager.getEndpointsForGroup(any(EgKey.class))).thenReturn(peerEndpoints);
 151         when(endpointManager.getEndpointsForNode(any(NodeId.class))).thenReturn(peerEndpoints);
 152         when(switchManager.getExternalPorts(any(NodeId.class))).thenReturn(externalPorts);
 153
 154         destinationMapper.syncEndpointFlows(flows, NODE_ID, endpointBuilder.build(), ofWriter);
 155
 156         // Verify usage
 157         verify(ctx, times(14)).getTenant(any(TenantId.class));
 158         verify(ctx, times(7)).getEndpointManager();
 159         verify(ctx, times(1)).getPolicyManager();
 160         verify(ctx, times(4)).getCurrentPolicy();
 161         verify(flows, times(1)).createExternalL2Flow(anyShort(), anyInt(), any(Endpoint.class),
 162                 anySetOf(NodeConnectorId.class), eq(ofWriter));
 163     }
 164
 165     @Test
 166     public void syncExternalEndpointFlows_L3Flow() {
 167         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
 168         // L3 Endpoint prefix
 169         Collection<EndpointL3Prefix> endpointL3PrefixCollection = new HashSet<>();
 170         List<EndpointL3Gateways> endpointL3GatewaysList = new ArrayList<>();
 171         EndpointL3PrefixBuilder endpointL3PrefixBuilder = new EndpointL3PrefixBuilder();
 172         EndpointL3GatewaysBuilder endpointL3GatewaysBuilder = new EndpointL3GatewaysBuilder();
 173         endpointL3GatewaysList.add(endpointL3GatewaysBuilder.build());
 174         endpointL3PrefixBuilder.setEndpointL3Gateways(endpointL3GatewaysList);
 175         endpointL3PrefixCollection.add(endpointL3PrefixBuilder.build());
 176         // External ports
 177         Set<NodeConnectorId> externalPorts = new HashSet<>();
 178         externalPorts.add(new NodeConnectorId(CONNECTOR_0));
 179         externalPorts.add(new NodeConnectorId(CONNECTOR_1));
 180         // Endpoint
 181         EndpointBuilder endpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
 182         endpointBuilder.setL3Address(getL3AddressList(IPV4_1, L3C_ID));
 183         Endpoint endpoint = endpointBuilder.build();
 184         // Peer
 185         EndpointBuilder peerEndpointBuilder = buildEndpoint(IPV4_2, MAC_0, CONNECTOR_0);
 186         // External implicit groups
 187         List<Subnet> subnets = new ArrayList<>();
 188         SubnetBuilder subnetBuilder = new SubnetBuilder();
 189         subnetBuilder.setId(new SubnetId(SUBNET_0));
 190         subnetBuilder.setParent(new ContextId(L3C_ID));
 191         subnetBuilder.setVirtualRouterIp(new IpAddress(new Ipv4Address(IPV4_2)));
 192         subnets.add(subnetBuilder.build());
 193         List<L3Context> l3Contexts = new ArrayList<>();
 194         L3ContextBuilder l3ContextBuilder = new L3ContextBuilder();
 195         l3ContextBuilder.setId(L3C_ID);
 196         l3Contexts.add(l3ContextBuilder.build());
 197         List<ExternalImplicitGroup> externalImplicitGroups = new ArrayList<>();
 198         ExternalImplicitGroupBuilder externalImplicitGroupBuilder = new ExternalImplicitGroupBuilder();
 199         externalImplicitGroupBuilder.setId(ENDPOINT_GROUP_0);
 200         externalImplicitGroups.add(externalImplicitGroupBuilder.build());
 201         ForwardingContextBuilder forwardingContextBuilder = new ForwardingContextBuilder();
 202         forwardingContextBuilder.setSubnet(subnets);
 203         forwardingContextBuilder.setL3Context(l3Contexts);
 204         TenantBuilder peerTenantBuilder = buildTenant();
 205         peerTenantBuilder.setForwardingContext(buildTenant().getForwardingContext());
 206         peerTenantBuilder.setPolicy(new PolicyBuilder()
 207                 .setSubjectFeatureInstances(getSubjectFeatureInstances())
 208                 .setEndpointGroup(getEndpointGroups())
 209                 .setExternalImplicitGroup(externalImplicitGroups)
 210                 .build());
 211         Tenant peerTenant = peerTenantBuilder.build();
 212         Endpoint peerEndpoint = peerEndpointBuilder.build();
 213         Collection<Endpoint> peerEndpoints = new ArrayList<>();
 214         peerEndpoints.add(peerEndpoint);
 215
 216         when(ctx.getTenant(any(TenantId.class))).thenReturn(new IndexedTenant(peerTenant));
 217         when(ctx.getEndpointManager()).thenReturn(endpointManager);
 218         when(ctx.getPolicyManager()).thenReturn(policyManager);
 219         when(ctx.getSwitchManager()).thenReturn(switchManager);
 220         when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
 221         when(endpointManager.getEndpointsForGroup(any(EgKey.class))).thenReturn(peerEndpoints);
 222         when(endpointManager.getEndpointsForNode(any(NodeId.class))).thenReturn(peerEndpoints);
 223         when(endpointManager.getEndpointsL3PrefixForTenant(any(TenantId.class))).thenReturn(endpointL3PrefixCollection);
 224         when(endpointManager.getL3Endpoint(any(L3ContextId.class), any(IpAddress.class), any(TenantId.class)))
 225                 .thenReturn(buildL3Endpoint(IPV4_1, IPV4_2, MAC_0, L2BD_ID.getValue()).build());
 226         when(endpointManager.getEndpoint(any(EpKey.class))).thenReturn(endpoint);
 227         when(switchManager.getExternalPorts(any(NodeId.class))).thenReturn(externalPorts);
 228
 229         destinationMapper.syncEndpointFlows(flows, NODE_ID, endpoint, ofWriter);
 230
 231         // Verify usage
 232         verify(ctx, times(16)).getTenant(any(TenantId.class));
 233         verify(ctx, times(9)).getEndpointManager();
 234         verify(ctx, times(1)).getPolicyManager();
 235         verify(ctx, times(4)).getCurrentPolicy();
 236         verify(flows, times(1)).createExternalL3RoutedFlow(anyShort(), anyInt(), any(Endpoint.class), any(Endpoint.class),
 237                 any(L3Address.class), anySetOf(NodeConnectorId.class), eq(ofWriter));
 238     }
 239
 240     @Test
 241     public void syncLocalEndpointFlows() {
 242         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
 243         // Endpoint
 244         EndpointBuilder endpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
 245         endpointBuilder.setNetworkContainment(SUBNET_0);
 246         // Peer
 247         EndpointBuilder peerEndpointBuilder = buildEndpoint(IPV4_2, MAC_0, CONNECTOR_0);
 248         peerEndpointBuilder.setNetworkContainment(new NetworkDomainId(SUBNET_0));
 249         // Subnets, l3Context and forwarding context
 250         List<L3Context> l3Contexts = new ArrayList<>();
 251         L3ContextBuilder l3ContextBuilder = new L3ContextBuilder();
 252         l3ContextBuilder.setId(L3C_ID);
 253         l3Contexts.add(l3ContextBuilder.build());
 254
 255         List<L2BridgeDomain> l2BDomains = new ArrayList<>();
 256         L2BridgeDomainBuilder l2bdBuilder = new L2BridgeDomainBuilder();
 257         l2bdBuilder.setId(L2BD_ID);
 258         l2bdBuilder.setParent(L3C_ID);
 259         l2BDomains.add(l2bdBuilder.build());
 260
 261         List<L2FloodDomain> l2FDomains = new ArrayList<>();
 262         L2FloodDomainBuilder l2fdBuilder = new L2FloodDomainBuilder();
 263         l2fdBuilder.setId(L2FD_ID);
 264         l2fdBuilder.setParent(L2BD_ID);
 265         l2FDomains.add(l2fdBuilder.build());
 266
 267         List<Subnet> subnets = new ArrayList<>();
 268         SubnetBuilder subnetBuilder = new SubnetBuilder();
 269         subnetBuilder.setId(SUBNET_0);
 270         subnetBuilder.setParent(L2FD_ID);
 271         subnetBuilder.setVirtualRouterIp(new IpAddress(IPV4_2));
 272         subnets.add(subnetBuilder.build());
 273
 274         ForwardingContextBuilder forwardingContextBuilder = new ForwardingContextBuilder();
 275         forwardingContextBuilder.setSubnet(subnets);
 276         forwardingContextBuilder.setL3Context(l3Contexts);
 277         forwardingContextBuilder.setL2BridgeDomain(l2BDomains);
 278         forwardingContextBuilder.setL2FloodDomain(l2FDomains);
 279         TenantBuilder peerTenantBuilder = new TenantBuilder(getTestIndexedTenant().getTenant());
 280         peerTenantBuilder.setForwardingContext(buildTenant().getForwardingContext());
 281         Tenant peerTenant = peerTenantBuilder.build();
 282         Endpoint peerEndpoint = peerEndpointBuilder.build();
 283         Collection<Endpoint> peerEndpoints = new ArrayList<>();
 284         peerEndpoints.add(peerEndpoint);
 285
 286         when(ctx.getTenant(any(TenantId.class))).thenReturn(new IndexedTenant(peerTenant));
 287         when(ctx.getEndpointManager()).thenReturn(endpointManager);
 288         when(ctx.getPolicyManager()).thenReturn(policyManager);
 289         when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
 290         when(endpointManager.getEndpointsForGroup(any(EgKey.class))).thenReturn(peerEndpoints);
 291         when(endpointManager.getEndpointsForNode(any(NodeId.class))).thenReturn(peerEndpoints);
 292
 293         destinationMapper.syncFlows(flows, endpointBuilder.build(), NODE_ID, ofWriter);
 294
 295         // Verify usage
 296         verify(ctx, times(24)).getTenant(any(TenantId.class));
 297         verify(ctx, times(9)).getEndpointManager();
 298         verify(ctx, times(2)).getPolicyManager();
 299         verify(ctx, times(4)).getCurrentPolicy();
 300
 301         // Verify order
 302         InOrder order = inOrder(flows);
 303         order.verify(flows, times(1)).createLocalL2Flow(anyShort(), anyInt(), any(Endpoint.class), eq(ofWriter));
 304         order.verify(flows, times(1)).createLocalL3RoutedFlow(anyShort(), anyInt(), any(Endpoint.class),
 305                 any(L3Address.class), any(Subnet.class), any(Subnet.class), eq(ofWriter));
 306     }
 307
 308     @Test
 309     public void syncRemoteEndpointFlows() {
 310         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
 311         // Endpoint
 312         EndpointBuilder endpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
 313         // Peer
 314         EndpointBuilder peerEndpointBuilder = buildEndpoint(IPV4_2, MAC_0, CONNECTOR_0);
 315         // Subnets, l3Context and forwarding context
 316
 317         List<L3Context> l3Contexts = new ArrayList<>();
 318         L3ContextBuilder l3ContextBuilder = new L3ContextBuilder();
 319         l3ContextBuilder.setId(L3C_ID);
 320         l3Contexts.add(l3ContextBuilder.build());
 321         List<L2BridgeDomain> l2BDomains = new ArrayList<>();
 322         L2BridgeDomainBuilder l2bdBuilder = new L2BridgeDomainBuilder();
 323         l2bdBuilder.setId(L2BD_ID);
 324         l2bdBuilder.setParent(L3C_ID);
 325         l2BDomains.add(l2bdBuilder.build());
 326         List<L2FloodDomain> l2FDomains = new ArrayList<>();
 327         L2FloodDomainBuilder l2fdBuilder = new L2FloodDomainBuilder();
 328         l2fdBuilder.setId(L2FD_ID);
 329         l2fdBuilder.setParent(L2BD_ID);
 330         l2FDomains.add(l2fdBuilder.build());
 331         List<Subnet> subnets = new ArrayList<>();
 332         SubnetBuilder subnetBuilder = new SubnetBuilder();
 333         subnetBuilder.setId(SUBNET_0);
 334         subnetBuilder.setParent(L2FD_ID);
 335         subnetBuilder.setVirtualRouterIp(new IpAddress(IPV4_2));
 336         subnets.add(subnetBuilder.build());
 337         ForwardingContextBuilder forwardingContextBuilder = new ForwardingContextBuilder();
 338         forwardingContextBuilder.setSubnet(subnets);
 339         forwardingContextBuilder.setL3Context(l3Contexts);
 340         forwardingContextBuilder.setL2BridgeDomain(l2BDomains);
 341         forwardingContextBuilder.setL2FloodDomain(l2FDomains);
 342         TenantBuilder peerTenantBuilder = buildTenant();
 343         peerTenantBuilder.setForwardingContext(forwardingContextBuilder.build());
 344         Tenant peerTenant = peerTenantBuilder.build();
 345         // Augmentation
 346         OfOverlayContextBuilder ofOverlayContextBuilder = new OfOverlayContextBuilder();
 347         ofOverlayContextBuilder.setNodeConnectorId(new NodeConnectorId(CONNECTOR_0));
 348         ofOverlayContextBuilder.setNodeId(new NodeId("remoteNodeID"));
 349         peerEndpointBuilder.setNetworkContainment(SUBNET_0);
 350         endpointBuilder.setNetworkContainment(SUBNET_0);
 351         peerEndpointBuilder.addAugmentation(OfOverlayContext.class, ofOverlayContextBuilder.build());
 352         Endpoint peerEndpoint = peerEndpointBuilder.build();
 353         Collection<Endpoint> peerEndpoints = new ArrayList<>();
 354         peerEndpoints.add(peerEndpoint);
 355
 356         when(ctx.getTenant(any(TenantId.class))).thenReturn(new IndexedTenant(peerTenant));
 357         when(ctx.getEndpointManager()).thenReturn(endpointManager);
 358         when(ctx.getPolicyManager()).thenReturn(policyManager);
 359         when(ctx.getSwitchManager()).thenReturn(switchManager);
 360         when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
 361         when(endpointManager.getEndpointsForGroup(any(EgKey.class))).thenReturn(peerEndpoints);
 362         when(endpointManager.getEndpointsForNode(any(NodeId.class))).thenReturn(peerEndpoints);
 363         when(switchManager.getTunnelIP(any(NodeId.class), eq(TunnelTypeVxlan.class)))
 364                 .thenReturn(new IpAddress(new Ipv4Address(IPV4_2)));
 365         when(switchManager.getTunnelPort(any(NodeId.class), eq(TunnelTypeVxlan.class)))
 366                 .thenReturn(new NodeConnectorId(CONNECTOR_2));
 367
 368         destinationMapper.syncEndpointFlows(flows, NODE_ID, endpointBuilder.build(), ofWriter);
 369
 370         // Verify usage
 371         verify(ctx, times(15)).getTenant(any(TenantId.class));
 372         verify(ctx, times(6)).getEndpointManager();
 373         verify(ctx, times(1)).getPolicyManager();
 374         verify(ctx, times(3)).getCurrentPolicy();
 375
 376         // Verify order
 377         InOrder order = inOrder(flows);
 378         order.verify(flows, times(1)).createRemoteL2Flow(anyShort(), anyInt(), any(Endpoint.class), any(Endpoint.class),
 379                 any(IpAddress.class), any(NodeConnectorId.class), eq(ofWriter));
 380         order.verify(flows, times(1)).createRemoteL3RoutedFlow(anyShort(), anyInt(), any(Endpoint.class),
 381                 any(L3Address.class), any(Subnet.class), any(IpAddress.class), any(NodeConnectorId.class),
 382                 any(Subnet.class), eq(ofWriter));
 383     }
 384
 385     @Test
 386     public void syncArpFlow() throws Exception {
 387         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
 388         // Subnets, l3Context and forwarding context
 389         List<L3Context> l3Contexts = new ArrayList<>();
 390         L3ContextBuilder l3ContextBuilder = new L3ContextBuilder();
 391         l3ContextBuilder.setId(L3C_ID);
 392         l3Contexts.add(l3ContextBuilder.build());
 393         HashSet<Subnet> subnets = new HashSet<>();
 394         List<L2BridgeDomain> l2BDomains = new ArrayList<>();
 395         L2BridgeDomainBuilder l2bdBuilder = new L2BridgeDomainBuilder();
 396         l2bdBuilder.setId(L2BD_ID);
 397         l2bdBuilder.setParent(L3C_ID);
 398         l2BDomains.add(l2bdBuilder.build());
 399         List<L2FloodDomain> l2FDomains = new ArrayList<>();
 400         L2FloodDomainBuilder l2fdBuilder = new L2FloodDomainBuilder();
 401         l2fdBuilder.setId(L2FD_ID);
 402         l2fdBuilder.setParent(L2BD_ID);
 403         l2FDomains.add(l2fdBuilder.build());
 404         SubnetBuilder subnetBuilder = new SubnetBuilder();
 405         subnetBuilder.setId(SUBNET_0);
 406         subnetBuilder.setParent(L2FD_ID);
 407         subnetBuilder.setVirtualRouterIp(new IpAddress(IPV4_2));
 408         subnets.add(subnetBuilder.build());
 409         ForwardingContextBuilder forwardingContextBuilder = new ForwardingContextBuilder();
 410         forwardingContextBuilder.setSubnet(new ArrayList<>(subnets));
 411         forwardingContextBuilder.setL3Context(l3Contexts);
 412         forwardingContextBuilder.setL2BridgeDomain(l2BDomains);
 413         forwardingContextBuilder.setL2FloodDomain(l2FDomains);
 414         TenantBuilder tenantBuilder = buildTenant();
 415         tenantBuilder.setForwardingContext(forwardingContextBuilder.build());
 416         Tenant tenant = tenantBuilder.build();
 417         destinationMapper.subnetsByTenant.put(tenant.getId(), subnets);
 418
 419         when(ctx.getTenant(any(TenantId.class))).thenReturn(new IndexedTenant(tenant));
 420
 421         destinationMapper.syncArpFlow(flows, tenant.getId(), ofWriter);
 422
 423         verify(ctx, times(1)).getTenant(any(TenantId.class));
 424         verify(flows, times(1)).createRouterArpFlow(anyInt(), any(IndexedTenant.class), any(Subnet.class), eq(ofWriter));
 425     }
 426
 427     @Test
 428     public void syncL3PrefixFlow() {
 429         DestinationMapperFlows flows = mock(DestinationMapperFlows.class);
 430         // Subnets, l3Context and forwarding context
 431         List<L3Context> l3Contexts = new ArrayList<>();
 432         L3ContextBuilder l3ContextBuilder = new L3ContextBuilder();
 433         l3ContextBuilder.setId(L3C_ID);
 434         l3Contexts.add(l3ContextBuilder.build());
 435         List<L2BridgeDomain> l2BDomains = new ArrayList<>();
 436         L2BridgeDomainBuilder l2bdBuilder = new L2BridgeDomainBuilder();
 437         l2bdBuilder.setId(L2BD_ID);
 438         l2bdBuilder.setParent(L3C_ID);
 439         l2BDomains.add(l2bdBuilder.build());
 440         List<L2FloodDomain> l2FDomains = new ArrayList<>();
 441         L2FloodDomainBuilder l2fdBuilder = new L2FloodDomainBuilder();
 442         l2fdBuilder.setId(L2FD_ID);
 443         l2fdBuilder.setParent(L2BD_ID);
 444         l2FDomains.add(l2fdBuilder.build());
 445         HashSet<Subnet> subnets = new HashSet<>();
 446         SubnetBuilder subnetBuilder = new SubnetBuilder();
 447         subnetBuilder.setId(SUBNET_0);
 448         subnetBuilder.setParent(L2FD_ID);
 449         subnetBuilder.setVirtualRouterIp(new IpAddress(IPV4_2));
 450         subnets.add(subnetBuilder.build());
 451
 452         ForwardingContextBuilder forwardingContextBuilder = new ForwardingContextBuilder();
 453         forwardingContextBuilder.setL3Context(l3Contexts);
 454         forwardingContextBuilder.setSubnet(new ArrayList<>(subnets));
 455         forwardingContextBuilder.setL2BridgeDomain(l2BDomains);
 456         forwardingContextBuilder.setL2FloodDomain(l2FDomains);
 457         TenantBuilder tenantBuilder = buildTenant();
 458         tenantBuilder.setForwardingContext(forwardingContextBuilder.build());
 459         Tenant tenant = tenantBuilder.build();
 460         Collection<Endpoint> endpoints = new ArrayList<>();
 461         EndpointBuilder endpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
 462         endpointBuilder.setNetworkContainment(SUBNET_0);
 463         Endpoint endpoint = endpointBuilder.build();
 464         endpoints.add(endpoint);
 465
 466         ArrayList<EndpointL3Prefix> l3Prefixes = new ArrayList<>();
 467         EndpointL3PrefixBuilder prefixBuilder = new EndpointL3PrefixBuilder();
 468         List<EndpointL3Gateways> endpointL3GatewaysList = new ArrayList<>();
 469         EndpointL3GatewaysBuilder endpointL3GatewaysBuilder = new EndpointL3GatewaysBuilder();
 470         endpointL3GatewaysBuilder.setIpAddress(new IpAddress(new Ipv4Address(IPV4_1)));
 471         endpointL3GatewaysBuilder.setL3Context(L3C_ID);
 472         endpointL3GatewaysList.add(endpointL3GatewaysBuilder.build());
 473         prefixBuilder.setEndpointL3Gateways(endpointL3GatewaysList);
 474         l3Prefixes.add(prefixBuilder.build());
 475
 476         EndpointL3 endpointL3 = buildL3Endpoint(IPV4_0, IPV4_2, MAC_2, L2).build();
 477
 478         when(ctx.getTenant(any(TenantId.class))).thenReturn(new IndexedTenant(tenant));
 479         when(ctx.getEndpointManager()).thenReturn(endpointManager);
 480         when(ctx.getSwitchManager()).thenReturn(switchManager);
 481         when(ctx.getPolicyManager()).thenReturn(policyManager);
 482         when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
 483         when(endpointManager.getEndpointsForNode(any(NodeId.class))).thenReturn(endpoints);
 484         when(endpointManager.getL3Endpoint(any(L3ContextId.class), any(IpAddress.class), any(TenantId.class)))
 485                 .thenReturn(endpointL3);
 486         when(endpointManager.getL2EndpointFromL3(any(EndpointL3.class))).thenReturn(endpoint);
 487
 488         destinationMapper.syncL3PrefixFlow(flows, l3Prefixes, null, NODE_ID, ofWriter);
 489
 490         verify(ctx, times(6)).getTenant(any(TenantId.class));
 491         verify(ctx, times(4)).getEndpointManager();
 492         verify(ctx, times(1)).getSwitchManager();
 493         verify(ctx, times(1)).getPolicyManager();
 494         verify(ctx, times(1)).getCurrentPolicy();
 495         verify(flows, times(1)).createL3PrefixFlow(anyShort(), anyInt(), any(Endpoint.class), any(EndpointL3Prefix.class),
 496                 any(IndexedTenant.class), any(Subnet.class), anySetOf(NodeConnectorId.class), eq(ofWriter));
 497     }
 498
 499 }