renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/mapper/destination/DestinationMapperTest.java

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