Esempio n. 1
0
/** Tests for the {@link Vpls} class. */
public class VplsTest {

  private static final int NUM_DEVICES = 7;

  private static final MacAddress MAC1 = MacAddress.valueOf("00:00:00:00:00:01");
  private static final MacAddress MAC2 = MacAddress.valueOf("00:00:00:00:00:02");
  private static final MacAddress MAC3 = MacAddress.valueOf("00:00:00:00:00:03");
  private static final MacAddress MAC4 = MacAddress.valueOf("00:00:00:00:00:04");
  private static final MacAddress MAC5 = MacAddress.valueOf("00:00:00:00:00:05");
  private static final MacAddress MAC6 = MacAddress.valueOf("00:00:00:00:00:06");
  private static final MacAddress MAC7 = MacAddress.valueOf("00:00:00:00:00:07");

  private static final Ip4Address IP1 = Ip4Address.valueOf("192.168.1.1");
  private static final Ip4Address IP2 = Ip4Address.valueOf("192.168.1.2");

  private static final PortNumber P1 = PortNumber.portNumber(1);

  private static final VlanId VLAN1 = VlanId.vlanId((short) 1);
  private static final VlanId VLAN2 = VlanId.vlanId((short) 2);

  private static final int PRIORITY_OFFSET = 1000;
  private static final String PREFIX_BROADCAST = "brc";
  private static final String PREFIX_UNICAST = "uni";

  private static final DeviceId DID1 = getDeviceId(1);
  private static final DeviceId DID2 = getDeviceId(2);
  private static final DeviceId DID3 = getDeviceId(3);
  private static final DeviceId DID4 = getDeviceId(4);
  private static final DeviceId DID5 = getDeviceId(5);
  private static final DeviceId DID6 = getDeviceId(6);

  private static final ConnectPoint C1 = new ConnectPoint(DID1, P1);
  private static final ConnectPoint C2 = new ConnectPoint(DID2, P1);
  private static final ConnectPoint C3 = new ConnectPoint(DID3, P1);
  private static final ConnectPoint C4 = new ConnectPoint(DID4, P1);
  private static final ConnectPoint C5 = new ConnectPoint(DID5, P1);
  private static final ConnectPoint C6 = new ConnectPoint(DID6, P1);

  private static final HostId HID1 = HostId.hostId(MAC1, VLAN1);
  private static final HostId HID2 = HostId.hostId(MAC2, VLAN1);
  private static final HostId HID3 = HostId.hostId(MAC3, VLAN1);
  private static final HostId HID4 = HostId.hostId(MAC4, VLAN2);
  private static final HostId HID5 = HostId.hostId(MAC5, VLAN2);
  private static final HostId HID6 = HostId.hostId(MAC6, VLAN2);
  private static final HostId HID7 = HostId.hostId(MAC7, VlanId.NONE);

  private ApplicationService applicationService;
  private CoreService coreService;
  private HostListener hostListener;
  private Set<Host> hostsAvailable;
  private HostService hostService;
  private IntentService intentService;
  private InterfaceService interfaceService;
  private Vpls vpls;

  private static final String APP_NAME = "org.onosproject.vpls";
  private static final ApplicationId APPID = TestApplicationId.create(APP_NAME);

  private static final ProviderId PID = new ProviderId("of", "foo");

  private static IdGenerator idGenerator;

  @Before
  public void setUp() throws Exception {
    idGenerator = new TestIdGenerator();
    Intent.bindIdGenerator(idGenerator);

    applicationService = createMock(ApplicationService.class);

    coreService = createMock(CoreService.class);
    expect(coreService.registerApplication(APP_NAME)).andReturn(APPID);
    replay(coreService);

    hostsAvailable = Sets.newHashSet();
    hostService = new TestHostService(hostsAvailable);

    intentService = new TestIntentService();

    TestIntentSynchronizer intentSynchronizer = new TestIntentSynchronizer(intentService);

    interfaceService = createMock(InterfaceService.class);
    interfaceService.addListener(anyObject(InterfaceListener.class));
    expectLastCall().anyTimes();
    addIntfConfig();

    vpls = new Vpls();
    vpls.applicationService = applicationService;
    vpls.coreService = coreService;
    vpls.hostService = hostService;
    vpls.intentService = intentService;
    vpls.interfaceService = interfaceService;
    vpls.intentSynchronizer = intentSynchronizer;
  }

  @After
  public void tearDown() {
    Intent.unbindIdGenerator(idGenerator);
  }

  /**
   * Creates the interface configuration. On devices 1, 2 and 3 is configured an interface on port 1
   * with vlan 1. On devices 4, 5 and 6 is configured an interface on port 1 with vlan 2. On device
   * 5 no interfaces are configured.
   */
  private void addIntfConfig() {
    Set<Interface> interfaces = Sets.newHashSet();
    Set<Interface> vlanOneSet = Sets.newHashSet();
    Set<Interface> vlanTwoSet = Sets.newHashSet();

    for (int i = 1; i <= NUM_DEVICES - 1; i++) {
      ConnectPoint cp = new ConnectPoint(getDeviceId(i), P1);

      Interface intf = new Interface("intfOne", cp, Collections.emptyList(), null, VlanId.NONE);

      if (i <= 3) {
        intf = new Interface("intfTwo", cp, Collections.emptyList(), null, VLAN1);
        interfaces.add(intf);
        vlanOneSet.add(intf);
      } else if (i > 3 && i <= 6) {
        intf = new Interface("intfThree", cp, Collections.emptyList(), null, VLAN2);
        interfaces.add(intf);
        vlanTwoSet.add(intf);
      }
      expect(interfaceService.getInterfacesByPort(cp)).andReturn(Sets.newHashSet(intf)).anyTimes();
    }
    expect(interfaceService.getInterfacesByVlan(VLAN1)).andReturn(vlanOneSet).anyTimes();
    expect(interfaceService.getInterfacesByVlan(VLAN2)).andReturn(vlanTwoSet).anyTimes();
    expect(interfaceService.getInterfaces()).andReturn(interfaces).anyTimes();

    replay(interfaceService);
  }

  /**
   * Checks the case in which six ports are configured with VLANs but no hosts are registered by the
   * HostService. The first three ports have an interface configured on VLAN1, the other three on
   * VLAN2. The number of intents expected is six: three for VLAN1, three for VLAN2. three sp2mp
   * intents, three mp2sp intents.
   */
  @Test
  public void testActivateNoHosts() {
    vpls.activate();

    List<Intent> expectedIntents = Lists.newArrayList();
    expectedIntents.addAll(generateVlanOneBrc());
    expectedIntents.addAll(generateVlanTwoBrc());

    checkIntents(expectedIntents);
  }

  /**
   * Checks the case in which six ports are configured with VLANs and four hosts are registered by
   * the HostService. The first three ports have an interface configured on VLAN1, the other three
   * on VLAN2. The number of intents expected is twelve: six for VLAN1, six for VLAN2. six sp2mp
   * intents, six mp2sp intents. For VLAN1 IPs are added to demonstrate it doesn't influence the
   * number of intents created.
   */
  @Test
  public void testFourInterfacesConfiguredHostsPresent() {
    Host h1 = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(1), Collections.singleton(IP1));
    Host h2 = new DefaultHost(PID, HID2, MAC2, VLAN1, getLocation(2), Collections.singleton(IP2));
    Host h3 = new DefaultHost(PID, HID3, MAC3, VLAN1, getLocation(3), Collections.EMPTY_SET);
    Host h4 = new DefaultHost(PID, HID4, MAC4, VLAN2, getLocation(4), Collections.EMPTY_SET);
    Host h5 = new DefaultHost(PID, HID5, MAC5, VLAN2, getLocation(5), Collections.EMPTY_SET);
    Host h6 = new DefaultHost(PID, HID6, MAC6, VLAN2, getLocation(6), Collections.EMPTY_SET);
    hostsAvailable.addAll(Sets.newHashSet(h1, h2, h3, h4, h5, h6));

    vpls.activate();

    List<Intent> expectedIntents = Lists.newArrayList();
    expectedIntents.addAll(generateVlanOneBrc());
    expectedIntents.addAll(generateVlanOneUni());
    expectedIntents.addAll(generateVlanTwoBrc());
    expectedIntents.addAll(generateVlanTwoUni());

    checkIntents(expectedIntents);
  }

  /**
   * Checks the case in which six ports are configured with VLANs and initially no hosts are
   * registered by the HostService. The first three ports have an interface configured on VLAN1, the
   * other three have an interface configured on VLAN2. When the module starts up, three hosts - on
   * device one, two and three - port 1 (both on VLAN1), are registered by the HostService and
   * events are sent to the application. sp2mp intents are created for all interfaces configured and
   * mp2sp intents are created only for the hosts attached. The number of intents expected is nine:
   * six for VLAN1, three for VLAN2. Six sp2mp intents, three mp2sp intents. IPs are added on the
   * first two hosts only to demonstrate it doesn't influence the number of intents created. An
   * additional host is added on device seven, port one to demonstrate that, even if it's on the
   * same VLAN of other interfaces configured in the system, it doesn't let the application generate
   * intents, since it's not connected to the interface configured.
   */
  @Test
  public void testFourInterfacesThreeHostEventsSameVlan() {
    vpls.activate();

    Host h1 = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(1), Collections.singleton(IP1));
    Host h2 = new DefaultHost(PID, HID2, MAC2, VLAN1, getLocation(2), Collections.singleton(IP2));
    Host h3 = new DefaultHost(PID, HID3, MAC3, VLAN1, getLocation(3), Collections.EMPTY_SET);
    Host h7 = new DefaultHost(PID, HID7, MAC7, VLAN1, getLocation(7), Collections.EMPTY_SET);
    hostsAvailable.addAll(Sets.newHashSet(h1, h2, h3, h7));

    hostsAvailable.forEach(
        host -> hostListener.event(new HostEvent(HostEvent.Type.HOST_ADDED, host)));

    List<Intent> expectedIntents = Lists.newArrayList();
    expectedIntents.addAll(generateVlanOneBrc());
    expectedIntents.addAll(generateVlanOneUni());
    expectedIntents.addAll(generateVlanTwoBrc());

    checkIntents(expectedIntents);
  }

  /**
   * Checks the case in which six ports are configured with VLANs and initially no hosts are
   * registered by the HostService. The first three ports have an interface configured on VLAN1, the
   * other three have an interface configured on VLAN2. When the module starts up, two hosts - on
   * device one and four - port 1 (VLAN 1 and VLAN 2), are registered by the HostService and events
   * are sent to the application. sp2mp intents are created for all interfaces configured and no
   * mp2sp intents are created at all, since the minimum number of hosts needed on the same vlan to
   * create mp2sp intents is 2. The number of intents expected is six: three for VLAN1, three for
   * VLAN2. six sp2mp intents, zero mp2sp intents. IPs are added on the first host only to
   * demonstrate it doesn't influence the number of intents created.
   */
  @Test
  public void testFourInterfacesTwoHostEventsDifferentVlan() {
    vpls.activate();

    Host h1 = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(1), Collections.singleton(IP1));
    Host h4 = new DefaultHost(PID, HID4, MAC4, VLAN2, getLocation(4), Collections.EMPTY_SET);
    hostsAvailable.addAll(Sets.newHashSet(h1, h4));

    hostsAvailable.forEach(
        host -> {
          hostListener.event(new HostEvent(HostEvent.Type.HOST_ADDED, host));
        });

    List<Intent> expectedIntents = Lists.newArrayList();
    expectedIntents.addAll(generateVlanOneBrc());
    expectedIntents.addAll(generateVlanTwoBrc());

    checkIntents(expectedIntents);
  }

  /**
   * Checks both that the number of intents in submitted in the intent framework it's equal to the
   * number of intents expected and that all intents are equivalent.
   *
   * @param intents the list of intents expected
   */
  private void checkIntents(List<Intent> intents) {
    assertEquals(intents.size(), intentService.getIntentCount());

    for (Intent intentOne : intents) {
      boolean found = false;
      for (Intent intentTwo : intentService.getIntents()) {
        if (intentOne.key().equals(intentTwo.key())) {
          found = true;
          assertTrue(
              format("Comparing %s and %s", intentOne, intentTwo),
              IntentUtils.intentsAreEqual(intentOne, intentTwo));
          break;
        }
      }
      assertTrue(found);
    }
  }

  /**
   * Generates the list of the expected sp2mp intents for VLAN 1.
   *
   * @return the list of expected sp2mp intents for VLAN 1
   */
  private List<SinglePointToMultiPointIntent> generateVlanOneBrc() {
    Key key = null;

    List<SinglePointToMultiPointIntent> intents = Lists.newArrayList();

    // Building sp2mp intent for H1 - VLAN1
    key = Key.of((PREFIX_BROADCAST + "-" + DID1 + "-" + P1 + "-" + VLAN1), APPID);
    intents.add(buildBrcIntent(key, C1, Sets.newHashSet(C2, C3), VLAN1));

    // Building sp2mp intent for H2 - VLAN1
    key = Key.of((PREFIX_BROADCAST + "-" + DID2 + "-" + P1 + "-" + VLAN1), APPID);
    intents.add(buildBrcIntent(key, C2, Sets.newHashSet(C1, C3), VLAN1));

    // Building sp2mp intent for H3 - VLAN1
    key = Key.of((PREFIX_BROADCAST + "-" + DID3 + "-" + P1 + "-" + VLAN1), APPID);
    intents.add(buildBrcIntent(key, C3, Sets.newHashSet(C1, C2), VLAN1));

    return intents;
  }

  /**
   * Generates the list of the expected mp2sp intents for VLAN 1.
   *
   * @return the list of expected mp2sp intents for VLAN 1
   */
  private List<MultiPointToSinglePointIntent> generateVlanOneUni() {
    Key key = null;

    List<MultiPointToSinglePointIntent> intents = Lists.newArrayList();

    // Building mp2sp intent for H1 - VLAN1
    key = Key.of((PREFIX_UNICAST + "-" + DID1 + "-" + P1 + "-" + VLAN1), APPID);
    intents.add(buildUniIntent(key, Sets.newHashSet(C2, C3), C1, VLAN1, MAC1));

    // Building mp2sp intent for H2 - VLAN1
    key = Key.of((PREFIX_UNICAST + "-" + DID2 + "-" + P1 + "-" + VLAN1), APPID);
    intents.add(buildUniIntent(key, Sets.newHashSet(C1, C3), C2, VLAN1, MAC2));

    // Building mp2sp intent for H3 - VLAN1
    key = Key.of((PREFIX_UNICAST + "-" + DID3 + "-" + P1 + "-" + VLAN1), APPID);
    intents.add(buildUniIntent(key, Sets.newHashSet(C1, C2), C3, VLAN1, MAC3));

    return intents;
  }

  /**
   * Generates the list of the expected sp2mp intents for VLAN 2.
   *
   * @return the list of expected sp2mp intents for VLAN 2
   */
  private List<SinglePointToMultiPointIntent> generateVlanTwoBrc() {
    Key key = null;

    List<SinglePointToMultiPointIntent> intents = Lists.newArrayList();

    // Building sp2mp intent for H4 - VLAN2
    key = Key.of((PREFIX_BROADCAST + "-" + DID4 + "-" + P1 + "-" + VLAN2), APPID);
    intents.add(buildBrcIntent(key, C4, Sets.newHashSet(C5, C6), VLAN2));

    // Building sp2mp intent for H5 - VLAN2
    key = Key.of((PREFIX_BROADCAST + "-" + DID5 + "-" + P1 + "-" + VLAN2), APPID);
    intents.add(buildBrcIntent(key, C5, Sets.newHashSet(C4, C6), VLAN2));

    // Building sp2mp intent for H6 - VLAN2
    key = Key.of((PREFIX_BROADCAST + "-" + DID6 + "-" + P1 + "-" + VLAN2), APPID);
    intents.add(buildBrcIntent(key, C6, Sets.newHashSet(C4, C5), VLAN2));

    return intents;
  }

  /**
   * Generates the list of the expected mp2sp intents for VLAN 2.
   *
   * @return the list of expected mp2sp intents for VLAN 2
   */
  private List<MultiPointToSinglePointIntent> generateVlanTwoUni() {
    Key key = null;

    List<MultiPointToSinglePointIntent> intents = Lists.newArrayList();

    // Building mp2sp intent for H4 - VLAN2
    key = Key.of((PREFIX_UNICAST + "-" + DID4 + "-" + P1 + "-" + VLAN2), APPID);
    intents.add(buildUniIntent(key, Sets.newHashSet(C5, C6), C4, VLAN2, MAC4));

    // Building mp2sp intent for H5 - VLAN2
    key = Key.of((PREFIX_UNICAST + "-" + DID5 + "-" + P1 + "-" + VLAN2), APPID);
    intents.add(buildUniIntent(key, Sets.newHashSet(C4, C6), C5, VLAN2, MAC5));

    // Building mp2sp intent for H6 - VLAN2
    key = Key.of((PREFIX_UNICAST + "-" + DID6 + "-" + P1 + "-" + VLAN2), APPID);
    intents.add(buildUniIntent(key, Sets.newHashSet(C4, C5), C6, VLAN2, MAC6));

    return intents;
  }

  /**
   * Builds a Single Point to Multi Point intent.
   *
   * @param key The intent key
   * @param src The source Connect Point
   * @param dsts The destination Connect Points
   * @return Single Point to Multi Point intent generated.
   */
  private SinglePointToMultiPointIntent buildBrcIntent(
      Key key, ConnectPoint src, Set<ConnectPoint> dsts, VlanId vlanId) {
    SinglePointToMultiPointIntent intent;

    TrafficTreatment treatment = DefaultTrafficTreatment.emptyTreatment();

    TrafficSelector selector =
        DefaultTrafficSelector.builder()
            .matchEthDst(MacAddress.BROADCAST)
            .matchVlanId(vlanId)
            .build();

    intent =
        SinglePointToMultiPointIntent.builder()
            .appId(APPID)
            .key(key)
            .selector(selector)
            .treatment(treatment)
            .ingressPoint(src)
            .egressPoints(dsts)
            .priority(PRIORITY_OFFSET)
            .build();
    return intent;
  }

  /**
   * Builds a Multi Point to Single Point intent.
   *
   * @param key The intent key
   * @param srcs The source Connect Points
   * @param dst The destination Connect Point
   * @return Multi Point to Single Point intent generated.
   */
  private MultiPointToSinglePointIntent buildUniIntent(
      Key key, Set<ConnectPoint> srcs, ConnectPoint dst, VlanId vlanId, MacAddress mac) {
    MultiPointToSinglePointIntent intent;

    TrafficTreatment treatment = DefaultTrafficTreatment.emptyTreatment();

    TrafficSelector.Builder builder =
        DefaultTrafficSelector.builder().matchEthDst(mac).matchVlanId(vlanId);

    TrafficSelector selector = builder.build();

    intent =
        MultiPointToSinglePointIntent.builder()
            .appId(APPID)
            .key(key)
            .selector(selector)
            .treatment(treatment)
            .ingressPoints(srcs)
            .egressPoint(dst)
            .priority(PRIORITY_OFFSET)
            .build();
    return intent;
  }

  /**
   * Returns the device ID of the ith device.
   *
   * @param i device to get the ID of
   * @return the device ID
   */
  private static DeviceId getDeviceId(int i) {
    return DeviceId.deviceId("" + i);
  }

  private static HostLocation getLocation(int i) {
    return new HostLocation(new ConnectPoint(getDeviceId(i), P1), 123L);
  }

  /**
   * Represents a fake IntentService class that easily allows to store and retrieve intents without
   * implementing the IntentService logic.
   */
  private class TestIntentService extends IntentServiceAdapter {

    private Set<Intent> intents;

    public TestIntentService() {
      intents = Sets.newHashSet();
    }

    @Override
    public void submit(Intent intent) {
      intents.add(intent);
    }

    @Override
    public long getIntentCount() {
      return intents.size();
    }

    @Override
    public Iterable<Intent> getIntents() {
      return intents;
    }

    @Override
    public Intent getIntent(Key intentKey) {
      for (Intent intent : intents) {
        if (intent.key().equals(intentKey)) {
          return intent;
        }
      }
      return null;
    }
  }

  /**
   * Represents a fake HostService class which allows to add hosts manually in each test, when
   * needed.
   */
  private class TestHostService extends HostServiceAdapter {

    private Set<Host> hosts;

    public TestHostService(Set<Host> hosts) {
      this.hosts = hosts;
    }

    @Override
    public void addListener(HostListener listener) {
      VplsTest.this.hostListener = listener;
    }

    @Override
    public Set<Host> getConnectedHosts(ConnectPoint connectPoint) {
      return hosts
          .stream()
          .filter(
              h ->
                  h.location().elementId().equals(connectPoint.elementId())
                      && h.location().port().equals(connectPoint.port()))
          .collect(Collectors.toSet());
    }
  }

  private static class TestIdGenerator implements IdGenerator {

    private final AtomicLong id = new AtomicLong(0);

    @Override
    public long getNewId() {
      return id.getAndIncrement();
    }
  }

  /** Test IntentSynchronizer that passes all intents straight through to the intent service. */
  private class TestIntentSynchronizer
      implements IntentSynchronizationService, IntentSynchronizationAdminService {

    private final IntentService intentService;

    /**
     * Creates a new test intent synchronizer.
     *
     * @param intentService intent service
     */
    public TestIntentSynchronizer(IntentService intentService) {
      this.intentService = intentService;
    }

    @Override
    public void submit(Intent intent) {
      intentService.submit(intent);
    }

    @Override
    public void withdraw(Intent intent) {
      intentService.withdraw(intent);
    }

    @Override
    public void modifyPrimary(boolean isPrimary) {}

    @Override
    public void removeIntents() {}

    @Override
    public void removeIntentsByAppId(ApplicationId applicationId) {}
  }
}
/** Unit tests for PeerConnectivityManager. */
public class PeerConnectivityManagerTest extends AbstractIntentTest {

  private static final ApplicationId APPID = TestApplicationId.create("foo");

  private static final ApplicationId CONFIG_APP_ID = APPID;

  private PeerConnectivityManager peerConnectivityManager;
  private IntentSynchronizationService intentSynchronizer;
  private InterfaceService interfaceService;
  private NetworkConfigService networkConfigService;

  private Set<BgpConfig.BgpSpeakerConfig> bgpSpeakers;
  private Map<String, Interface> interfaces;

  private BgpConfig bgpConfig;

  private List<PointToPointIntent> intentList;

  private final DeviceId deviceId1 = DeviceId.deviceId("of:0000000000000001");
  private final DeviceId deviceId2 = DeviceId.deviceId("of:0000000000000002");
  private final DeviceId deviceId3 = DeviceId.deviceId("of:0000000000000003");

  // Interfaces connected to BGP speakers
  private final ConnectPoint s1Eth100 = new ConnectPoint(deviceId1, PortNumber.portNumber(100));
  private final ConnectPoint s2Eth100 = new ConnectPoint(deviceId2, PortNumber.portNumber(100));
  private final ConnectPoint s3Eth100 = new ConnectPoint(deviceId3, PortNumber.portNumber(100));

  // Interfaces connected to BGP peers
  private final ConnectPoint s1Eth1 = new ConnectPoint(deviceId1, PortNumber.portNumber(1));
  private final ConnectPoint s2Eth1 = new ConnectPoint(deviceId2, PortNumber.portNumber(1));
  private final ConnectPoint s3Eth1 = new ConnectPoint(deviceId3, PortNumber.portNumber(1));

  private static final VlanId NO_VLAN = VlanId.NONE;
  private static final VlanId VLAN10 = VlanId.vlanId(Short.valueOf("10"));
  private static final VlanId VLAN20 = VlanId.vlanId(Short.valueOf("20"));
  private static final VlanId VLAN30 = VlanId.vlanId(Short.valueOf("30"));

  @Before
  public void setUp() throws Exception {
    super.setUp();

    interfaceService = createMock(InterfaceService.class);
    interfaceService.addListener(anyObject(InterfaceListener.class));
    expectLastCall().anyTimes();
    networkConfigService = createMock(NetworkConfigService.class);
    networkConfigService.addListener(anyObject(NetworkConfigListener.class));
    expectLastCall().anyTimes();
    bgpConfig = createMock(BgpConfig.class);

    // These will set expectations on routingConfig and interfaceService
    bgpSpeakers = setUpBgpSpeakers();
    interfaces = Collections.unmodifiableMap(setUpInterfaces());

    initPeerConnectivity();
    intentList = setUpIntentList();
  }

  /**
   * Sets up BGP speakers.
   *
   * @return configured BGP speakers as a map from speaker name to speaker
   */
  private Set<BgpConfig.BgpSpeakerConfig> setUpBgpSpeakers() {

    BgpConfig.BgpSpeakerConfig speaker1 =
        new BgpConfig.BgpSpeakerConfig(
            Optional.empty(),
            NO_VLAN,
            s1Eth100,
            Collections.singleton(IpAddress.valueOf("192.168.10.1")));

    BgpConfig.BgpSpeakerConfig speaker2 =
        new BgpConfig.BgpSpeakerConfig(
            Optional.empty(),
            NO_VLAN,
            s1Eth100,
            Sets.newHashSet(IpAddress.valueOf("192.168.20.1"), IpAddress.valueOf("192.168.30.1")));

    BgpConfig.BgpSpeakerConfig speaker3 =
        new BgpConfig.BgpSpeakerConfig(
            Optional.empty(),
            VLAN30,
            s3Eth100,
            Sets.newHashSet(IpAddress.valueOf("192.168.40.1"), IpAddress.valueOf("192.168.50.1")));

    Set<BgpConfig.BgpSpeakerConfig> bgpSpeakers = Sets.newHashSet();
    bgpSpeakers.add(speaker1);
    bgpSpeakers.add(speaker2);
    bgpSpeakers.add(speaker3);

    return bgpSpeakers;
  }

  /**
   * Sets up logical interfaces, which emulate the configured interfaces in SDN-IP application.
   *
   * @return configured interfaces as a map from interface name to Interface
   */
  private Map<String, Interface> setUpInterfaces() {

    Map<String, Interface> configuredInterfaces = new HashMap<>();

    String interfaceSw1Eth1 = "s1-eth1";
    InterfaceIpAddress ia1 =
        new InterfaceIpAddress(
            IpAddress.valueOf("192.168.10.101"), IpPrefix.valueOf("192.168.10.0/24"));
    Interface intfsw1eth1 =
        new Interface(
            interfaceSw1Eth1,
            s1Eth1,
            Collections.singletonList(ia1),
            MacAddress.valueOf("00:00:00:00:00:01"),
            VlanId.NONE);

    configuredInterfaces.put(interfaceSw1Eth1, intfsw1eth1);

    String interfaceSw2Eth1 = "s2-eth1";
    InterfaceIpAddress ia2 =
        new InterfaceIpAddress(
            IpAddress.valueOf("192.168.20.101"), IpPrefix.valueOf("192.168.20.0/24"));
    Interface intfsw2eth1 =
        new Interface(
            interfaceSw2Eth1,
            s2Eth1,
            Collections.singletonList(ia2),
            MacAddress.valueOf("00:00:00:00:00:02"),
            VlanId.NONE);

    configuredInterfaces.put(interfaceSw2Eth1, intfsw2eth1);

    String interfaceSw2Eth1intf2 = "s2-eth1_2";
    InterfaceIpAddress ia3 =
        new InterfaceIpAddress(
            IpAddress.valueOf("192.168.30.101"), IpPrefix.valueOf("192.168.30.0/24"));
    Interface intfsw2eth1intf2 =
        new Interface(
            interfaceSw2Eth1intf2,
            s2Eth1,
            Collections.singletonList(ia3),
            MacAddress.valueOf("00:00:00:00:00:03"),
            VlanId.NONE);

    configuredInterfaces.put(interfaceSw2Eth1intf2, intfsw2eth1intf2);

    String interfaceSw3Eth1 = "s3-eth1";
    InterfaceIpAddress ia4 =
        new InterfaceIpAddress(
            IpAddress.valueOf("192.168.40.101"), IpPrefix.valueOf("192.168.40.0/24"));
    Interface intfsw3eth1 =
        new Interface(
            Interface.NO_INTERFACE_NAME,
            s3Eth1,
            ImmutableList.of(ia4),
            MacAddress.valueOf("00:00:00:00:00:04"),
            VLAN10);

    configuredInterfaces.put(interfaceSw3Eth1, intfsw3eth1);

    String interfaceSw3Eth1intf2 = "s3-eth1_2";
    InterfaceIpAddress ia5 =
        new InterfaceIpAddress(
            IpAddress.valueOf("192.168.50.101"), IpPrefix.valueOf("192.168.50.0/24"));
    Interface intfsw3eth1intf2 =
        new Interface(
            Interface.NO_INTERFACE_NAME,
            s3Eth1,
            ImmutableList.of(ia5),
            MacAddress.valueOf("00:00:00:00:00:05"),
            VLAN20);

    configuredInterfaces.put(interfaceSw3Eth1intf2, intfsw3eth1intf2);

    expect(interfaceService.getInterfacesByPort(s1Eth1))
        .andReturn(Collections.singleton(intfsw1eth1))
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.10.101")))
        .andReturn(Collections.singleton(intfsw1eth1))
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.10.1")))
        .andReturn(intfsw1eth1)
        .anyTimes();

    expect(interfaceService.getInterfacesByPort(s2Eth1))
        .andReturn(Collections.singleton(intfsw2eth1))
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.20.101")))
        .andReturn(Collections.singleton(intfsw2eth1))
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.20.1")))
        .andReturn(intfsw2eth1)
        .anyTimes();

    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.30.101")))
        .andReturn(Collections.singleton(intfsw2eth1intf2))
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.30.1")))
        .andReturn(intfsw2eth1intf2)
        .anyTimes();

    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.40.101")))
        .andReturn(Collections.singleton(intfsw3eth1))
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.40.1")))
        .andReturn(intfsw3eth1)
        .anyTimes();

    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.50.101")))
        .andReturn(Collections.singleton(intfsw3eth1intf2))
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.50.1")))
        .andReturn(intfsw3eth1intf2)
        .anyTimes();

    // Non-existent interface used during one of the tests
    expect(
            interfaceService.getInterfacesByPort(
                new ConnectPoint(
                    DeviceId.deviceId("of:0000000000000100"), PortNumber.portNumber(1))))
        .andReturn(null)
        .anyTimes();

    expect(interfaceService.getInterfaces())
        .andReturn(Sets.newHashSet(configuredInterfaces.values()))
        .anyTimes();

    return configuredInterfaces;
  }

  /**
   * Sets up expected point to point intent list.
   *
   * @return point to point intent list
   */
  private List<PointToPointIntent> setUpIntentList() {
    intentList = new ArrayList<>();

    setUpBgpIntents();
    setUpIcmpIntents();

    return intentList;
  }

  /**
   * Constructs a BGP intent and put it into the intentList.
   *
   * <p>The purpose of this method is too simplify the setUpBgpIntents() method, and to make the
   * setUpBgpIntents() easy to read.
   *
   * @param srcVlanId ingress VlanId
   * @param dstVlanId egress VlanId
   * @param srcPrefix source IP prefix to match
   * @param dstPrefix destination IP prefix to match
   * @param srcTcpPort source TCP port to match
   * @param dstTcpPort destination TCP port to match
   * @param srcConnectPoint source connect point for PointToPointIntent
   * @param dstConnectPoint destination connect point for PointToPointIntent
   */
  private void bgpPathintentConstructor(
      VlanId srcVlanId,
      VlanId dstVlanId,
      String srcPrefix,
      String dstPrefix,
      Short srcTcpPort,
      Short dstTcpPort,
      ConnectPoint srcConnectPoint,
      ConnectPoint dstConnectPoint) {

    TrafficSelector.Builder builder =
        DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4)
            .matchIPProtocol(IPv4.PROTOCOL_TCP)
            .matchIPSrc(IpPrefix.valueOf(srcPrefix))
            .matchIPDst(IpPrefix.valueOf(dstPrefix));

    if (!srcVlanId.equals(VlanId.NONE)) {
      builder.matchVlanId(srcVlanId);
    }

    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();

    if (!dstVlanId.equals(VlanId.NONE)) {
      treatment.setVlanId(dstVlanId);
    }

    if (srcTcpPort != null) {
      builder.matchTcpSrc(TpPort.tpPort(srcTcpPort));
    }
    if (dstTcpPort != null) {
      builder.matchTcpDst(TpPort.tpPort(dstTcpPort));
    }

    Key key =
        Key.of(
            srcPrefix.split("/")[0]
                + "-"
                + dstPrefix.split("/")[0]
                + "-"
                + ((srcTcpPort == null) ? "dst" : "src"),
            APPID);

    PointToPointIntent intent =
        PointToPointIntent.builder()
            .appId(APPID)
            .key(key)
            .selector(builder.build())
            .treatment(treatment.build())
            .ingressPoint(srcConnectPoint)
            .egressPoint(dstConnectPoint)
            .build();

    intentList.add(intent);
  }

  /** Sets up intents for BGP paths. */
  private void setUpBgpIntents() {

    Short bgpPort = 179;

    // Start to build intents between BGP speaker1 and BGP peer1
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.10.101/32", "192.168.10.1/32", null, bgpPort, s1Eth100, s1Eth1);
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.10.101/32", "192.168.10.1/32", bgpPort, null, s1Eth100, s1Eth1);

    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.10.1/32", "192.168.10.101/32", null, bgpPort, s1Eth1, s1Eth100);
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.10.1/32", "192.168.10.101/32", bgpPort, null, s1Eth1, s1Eth100);

    // Start to build intents between BGP speaker1 and BGP peer2
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.20.101/32", "192.168.20.1/32", null, bgpPort, s1Eth100, s2Eth1);
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.20.101/32", "192.168.20.1/32", bgpPort, null, s1Eth100, s2Eth1);

    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.20.1/32", "192.168.20.101/32", null, bgpPort, s2Eth1, s1Eth100);
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.20.1/32", "192.168.20.101/32", bgpPort, null, s2Eth1, s1Eth100);

    // Start to build intents between BGP speaker2 and BGP peer1
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.30.101/32", "192.168.30.1/32", null, bgpPort, s1Eth100, s2Eth1);
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.30.101/32", "192.168.30.1/32", bgpPort, null, s1Eth100, s2Eth1);

    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.30.1/32", "192.168.30.101/32", null, bgpPort, s2Eth1, s1Eth100);
    bgpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.30.1/32", "192.168.30.101/32", bgpPort, null, s2Eth1, s1Eth100);

    // Start to build intents between BGP speaker3 and BGP peer4
    bgpPathintentConstructor(
        VLAN30, VLAN10, "192.168.40.101/32", "192.168.40.1/32", null, bgpPort, s3Eth100, s3Eth1);
    bgpPathintentConstructor(
        VLAN30, VLAN10, "192.168.40.101/32", "192.168.40.1/32", bgpPort, null, s3Eth100, s3Eth1);

    bgpPathintentConstructor(
        VLAN10, VLAN30, "192.168.40.1/32", "192.168.40.101/32", null, bgpPort, s3Eth1, s3Eth100);
    bgpPathintentConstructor(
        VLAN10, VLAN30, "192.168.40.1/32", "192.168.40.101/32", bgpPort, null, s3Eth1, s3Eth100);

    // Start to build intents between BGP speaker3 and BGP peer5
    bgpPathintentConstructor(
        VLAN30, VLAN20, "192.168.50.101/32", "192.168.50.1/32", null, bgpPort, s3Eth100, s3Eth1);
    bgpPathintentConstructor(
        VLAN30, VLAN20, "192.168.50.101/32", "192.168.50.1/32", bgpPort, null, s3Eth100, s3Eth1);

    bgpPathintentConstructor(
        VLAN20, VLAN30, "192.168.50.1/32", "192.168.50.101/32", null, bgpPort, s3Eth1, s3Eth100);
    bgpPathintentConstructor(
        VLAN20, VLAN30, "192.168.50.1/32", "192.168.50.101/32", bgpPort, null, s3Eth1, s3Eth100);
  }

  /**
   * Constructs a BGP intent and put it into the intentList.
   *
   * <p>The purpose of this method is too simplify the setUpBgpIntents() method, and to make the
   * setUpBgpIntents() easy to read.
   *
   * @param srcVlanId ingress VlanId
   * @param dstVlanId egress VlanId
   * @param srcPrefix source IP prefix to match
   * @param dstPrefix destination IP prefix to match
   * @param srcConnectPoint source connect point for PointToPointIntent
   * @param dstConnectPoint destination connect point for PointToPointIntent
   */
  private void icmpPathintentConstructor(
      VlanId srcVlanId,
      VlanId dstVlanId,
      String srcPrefix,
      String dstPrefix,
      ConnectPoint srcConnectPoint,
      ConnectPoint dstConnectPoint) {

    TrafficSelector.Builder builder =
        DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4)
            .matchIPProtocol(IPv4.PROTOCOL_ICMP)
            .matchIPSrc(IpPrefix.valueOf(srcPrefix))
            .matchIPDst(IpPrefix.valueOf(dstPrefix));

    if (!srcVlanId.equals(VlanId.NONE)) {
      builder.matchVlanId(srcVlanId);
    }

    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();

    if (!dstVlanId.equals(VlanId.NONE)) {
      treatment.setVlanId(dstVlanId);
    }

    Key key = Key.of(srcPrefix.split("/")[0] + "-" + dstPrefix.split("/")[0] + "-" + "icmp", APPID);

    PointToPointIntent intent =
        PointToPointIntent.builder()
            .appId(APPID)
            .key(key)
            .selector(builder.build())
            .treatment(treatment.build())
            .ingressPoint(srcConnectPoint)
            .egressPoint(dstConnectPoint)
            .build();

    intentList.add(intent);
  }

  /** Sets up intents for ICMP paths. */
  private void setUpIcmpIntents() {
    // Start to build intents between BGP speaker1 and BGP peer1
    icmpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.10.101/32", "192.168.10.1/32", s1Eth100, s1Eth1);
    icmpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.10.1/32", "192.168.10.101/32", s1Eth1, s1Eth100);

    // Start to build intents between BGP speaker1 and BGP peer2
    icmpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.20.101/32", "192.168.20.1/32", s1Eth100, s2Eth1);
    icmpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.20.1/32", "192.168.20.101/32", s2Eth1, s1Eth100);

    icmpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.30.101/32", "192.168.30.1/32", s1Eth100, s2Eth1);
    icmpPathintentConstructor(
        NO_VLAN, NO_VLAN, "192.168.30.1/32", "192.168.30.101/32", s2Eth1, s1Eth100);

    // Start to build intents between BGP speaker3 and BGP peer 4
    icmpPathintentConstructor(
        VLAN10, VLAN30, "192.168.40.1/32", "192.168.40.101/32", s3Eth1, s3Eth100);
    icmpPathintentConstructor(
        VLAN30, VLAN10, "192.168.40.101/32", "192.168.40.1/32", s3Eth100, s3Eth1);

    // Start to build intents between BGP speaker3 and BGP peer 5
    icmpPathintentConstructor(
        VLAN20, VLAN30, "192.168.50.1/32", "192.168.50.101/32", s3Eth1, s3Eth100);
    icmpPathintentConstructor(
        VLAN30, VLAN20, "192.168.50.101/32", "192.168.50.1/32", s3Eth100, s3Eth1);
  }

  /** Initializes peer connectivity testing environment. */
  private void initPeerConnectivity() {
    expect(bgpConfig.bgpSpeakers()).andReturn(bgpSpeakers).anyTimes();
    replay(bgpConfig);
    expect(networkConfigService.getConfig(APPID, BgpConfig.class)).andReturn(bgpConfig).anyTimes();
    replay(networkConfigService);
    replay(interfaceService);

    intentSynchronizer = createMock(IntentSynchronizationService.class);
    replay(intentSynchronizer);

    peerConnectivityManager =
        new PeerConnectivityManager(
            APPID, intentSynchronizer, networkConfigService, CONFIG_APP_ID, interfaceService);
  }

  /**
   * Tests whether peer connectivity manager can set up correct BGP and ICMP intents according to
   * specific configuration.
   *
   * <p>Two tricky cases included in the configuration are: 2 peers on a same switch port, peer on
   * the same switch with BGPd.
   */
  @Test
  public void testConnectionSetup() {
    reset(intentSynchronizer);

    // Setup the expected intents
    for (Intent intent : intentList) {
      intentSynchronizer.submit(eqExceptId(intent));
    }
    replay(intentSynchronizer);

    // Running the interface to be tested.
    peerConnectivityManager.start();

    verify(intentSynchronizer);
  }

  /** Tests a corner case, when there are no interfaces in the configuration. */
  @Test
  public void testNullInterfaces() {
    reset(interfaceService);
    interfaceService.addListener(anyObject(InterfaceListener.class));
    expectLastCall().anyTimes();

    expect(interfaceService.getInterfaces()).andReturn(Sets.newHashSet()).anyTimes();
    expect(interfaceService.getInterfacesByPort(s2Eth1))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getInterfacesByPort(s1Eth1))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.10.101")))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.10.1")))
        .andReturn(null)
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.20.101")))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.20.1")))
        .andReturn(null)
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.30.101")))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.30.1")))
        .andReturn(null)
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.40.101")))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.40.1")))
        .andReturn(null)
        .anyTimes();
    expect(interfaceService.getInterfacesByIp(IpAddress.valueOf("192.168.50.101")))
        .andReturn(Collections.emptySet())
        .anyTimes();
    expect(interfaceService.getMatchingInterface(IpAddress.valueOf("192.168.50.1")))
        .andReturn(null)
        .anyTimes();

    replay(interfaceService);

    reset(intentSynchronizer);
    replay(intentSynchronizer);
    peerConnectivityManager.start();
    verify(intentSynchronizer);
  }

  /** Tests a corner case, when there is no BGP speakers in the configuration. */
  @Test
  public void testNullBgpSpeakers() {
    reset(bgpConfig);
    expect(bgpConfig.bgpSpeakers()).andReturn(Collections.emptySet()).anyTimes();
    replay(bgpConfig);

    // We don't expect any intents in this case
    reset(intentSynchronizer);
    replay(intentSynchronizer);
    peerConnectivityManager.start();
    verify(intentSynchronizer);
  }

  /** Tests a corner case, when there is no Interface configured for one BGP peer. */
  @Test
  public void testNoPeerInterface() {
    IpAddress ip = IpAddress.valueOf("1.1.1.1");
    bgpSpeakers.clear();
    bgpSpeakers.add(
        new BgpConfig.BgpSpeakerConfig(
            Optional.of("foo"), VlanId.NONE, s1Eth100, Collections.singleton(ip)));
    reset(interfaceService);
    interfaceService.addListener(anyObject(InterfaceListener.class));
    expect(interfaceService.getMatchingInterface(ip)).andReturn(null).anyTimes();
    replay(interfaceService);

    // We don't expect any intents in this case
    reset(intentSynchronizer);
    replay(intentSynchronizer);
    peerConnectivityManager.start();
    verify(intentSynchronizer);
  }
}