SwitchManagerTest.java

/*
 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
 * 
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */

package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node;

import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager.SwitchState;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager.SwitchStatus;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.Tunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.TunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlanGpe;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;

public class SwitchManagerTest {

    private SwitchManager switchManager;

    private DataBroker dataProvider;
    private NodeId nodeId;
    private SwitchState switchState;
    private FlowCapableNode fcNode;
    private TunnelBuilder tunnelBuilder;
    private IpAddress ipAddress;
    private NodeConnectorId nodeConnectorId;
    private OfOverlayNodeConfig ofOverlayNodeConfig;

    private InstanceIdentifier<NodeConnector> ncIid;
    private FlowCapableNodeConnector fcnc;
    private FlowCapableNodeConnector fcncOld;

    private SwitchListener listener;

    @Before
    public void initialise() {
        dataProvider = mock(DataBroker.class);
        nodeId = mock(NodeId.class);

        switchState = new SwitchState(nodeId);
        SwitchManager.switches.put(nodeId, switchState);

        fcNode = mock(FlowCapableNode.class);
        tunnelBuilder = mock(TunnelBuilder.class);
        ipAddress = mock(IpAddress.class);
        nodeConnectorId = mock(NodeConnectorId.class);
        when(tunnelBuilder.getIp()).thenReturn(ipAddress);
        when(tunnelBuilder.getNodeConnectorId()).thenReturn(nodeConnectorId);
        switchState.tunnelBuilderByType.put(TunnelTypeVxlan.class, tunnelBuilder);
        ofOverlayNodeConfig = mock(OfOverlayNodeConfig.class);

        ncIid = InstanceIdentifier.builder(Nodes.class)
            .child(Node.class, new NodeKey(nodeId))
            .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("value")))
            .build();
        fcnc = mock(FlowCapableNodeConnector.class);
        fcncOld = mock(FlowCapableNodeConnector.class);

        switchManager = spy(new SwitchManager(dataProvider));

        listener = mock(SwitchListener.class);
        switchManager.registerListener(listener);
    }

    @Test
    public void constructorTest() throws Exception {
        Field fNodeListener = SwitchManager.class.getDeclaredField("nodeListener");
        Field fOfOverlayNodeListener = SwitchManager.class.getDeclaredField("ofOverlayNodeListener");
        Field fNodeConnectorListener = SwitchManager.class.getDeclaredField("nodeConnectorListener");
        fNodeListener.setAccessible(true);
        fOfOverlayNodeListener.setAccessible(true);
        fNodeConnectorListener.setAccessible(true);

        Assert.assertNotNull(fNodeListener.get(switchManager));
        Assert.assertNotNull(fOfOverlayNodeListener.get(switchManager));
        Assert.assertNotNull(fNodeConnectorListener.get(switchManager));
        switchManager.close();

        switchManager = new SwitchManager(null);
        Assert.assertNull(fNodeListener.get(switchManager));
        Assert.assertNull(fOfOverlayNodeListener.get(switchManager));
        Assert.assertNull(fNodeConnectorListener.get(switchManager));
        // switchManager.close();
    }

    @Test
    public void activatingSwitchTest() {
        NodeId nodeId = mock(NodeId.class);
        SwitchState switchState;

        switchState = SwitchManager.switches.get(nodeId);
        Assert.assertNull(switchState);

        SwitchManager.activatingSwitch(nodeId);
        switchState = SwitchManager.switches.get(nodeId);
        Assert.assertNotNull(switchState);
        Assert.assertTrue(switchState.isHasEndpoints());

        SwitchManager.activatingSwitch(nodeId);
        Assert.assertEquals(switchState, SwitchManager.switches.get(nodeId));
        Assert.assertTrue(switchState.isHasEndpoints());

        SwitchManager.deactivatingSwitch(nodeId);
        Assert.assertFalse(switchState.isHasEndpoints());
    }

    @Test
    public void deactivatingSwitchTest() {
        NodeId nodeId = mock(NodeId.class);
        SwitchManager.switches.put(nodeId, null);

        SwitchManager.deactivatingSwitch(nodeId);
        Assert.assertNull(SwitchManager.switches.get(nodeId));
    }

    @Test
    public void getReadySwitchesTest() {
        NodeId nIdDisconected = mock(NodeId.class);
        NodeId nIdReady = mock(NodeId.class);
        SwitchState sDisconected = new SwitchState(nIdDisconected);
        sDisconected.status = SwitchStatus.DISCONNECTED;
        SwitchState sReady = new SwitchState(nIdReady);
        sReady.status = SwitchStatus.READY;
        SwitchManager.switches.put(nIdDisconected, sDisconected);
        SwitchManager.switches.put(nIdReady, sReady);

        Collection<NodeId> readySwitches = switchManager.getReadySwitches();
        Assert.assertFalse(readySwitches.contains(nIdDisconected));
        Assert.assertTrue(readySwitches.contains(nIdReady));
    }

    @Test
    public void getExternalPortsTest() {
        NodeId nodeId = mock(NodeId.class);
        SwitchState switchState = new SwitchState(nodeId);
        Set<NodeConnectorId> externalPorts = Collections.emptySet();
        switchState.externalPorts = externalPorts;

        SwitchManager.switches.put(nodeId, null);
        Assert.assertTrue(switchManager.getExternalPorts(nodeId).isEmpty());
        SwitchManager.switches.put(nodeId, switchState);
        Assert.assertEquals(externalPorts, switchManager.getExternalPorts(nodeId));
    }

    @Test
    public void getTunnelPortsTest1arg() {
        NodeId nodeId = mock(NodeId.class);
        Assert.assertTrue(switchManager.getTunnelPorts(nodeId).isEmpty());

        SwitchManager.switches.put(nodeId, switchState);
        Assert.assertFalse(switchManager.getTunnelPorts(nodeId).isEmpty());
    }

    @Test
    public void getTunnelPortTest() {
        NodeId nodeId = mock(NodeId.class);
        Assert.assertNull(switchManager.getTunnelPort(nodeId, TunnelTypeVxlan.class));

        SwitchState switchState = new SwitchState(nodeId);
        SwitchManager.switches.put(nodeId, switchState);
        Assert.assertNull(switchManager.getTunnelPort(nodeId, TunnelTypeVxlan.class));

        NodeConnectorId nodeConnectorId = mock(NodeConnectorId.class);
        TunnelBuilder tunnelBuilder = mock(TunnelBuilder.class);
        when(tunnelBuilder.getNodeConnectorId()).thenReturn(nodeConnectorId);
        switchState.tunnelBuilderByType.put(TunnelTypeVxlan.class, tunnelBuilder);
        Assert.assertEquals(nodeConnectorId, switchManager.getTunnelPort(nodeId, TunnelTypeVxlan.class));
    }

    @Test
    public void getTunnelIPTest() {
        NodeId nodeId = mock(NodeId.class);
        Assert.assertNull(switchManager.getTunnelIP(nodeId, TunnelTypeVxlan.class));

        SwitchState switchState = new SwitchState(nodeId);
        SwitchManager.switches.put(nodeId, switchState);
        Assert.assertNull(switchManager.getTunnelIP(nodeId, TunnelTypeVxlan.class));

        IpAddress ipAddress = mock(IpAddress.class);
        TunnelBuilder tunnelBuilder = mock(TunnelBuilder.class);
        when(tunnelBuilder.getIp()).thenReturn(ipAddress);
        switchState.tunnelBuilderByType.put(TunnelTypeVxlan.class, tunnelBuilder);
        Assert.assertEquals(ipAddress, switchManager.getTunnelIP(nodeId, TunnelTypeVxlan.class));
    }

     @Test
    public void updateSwitchTestStateNull() {
        NodeId nodeId = mock(NodeId.class);
        FlowCapableNode fcNode = mock(FlowCapableNode.class);

        switchManager.updateSwitch(nodeId, fcNode);
        verifyZeroInteractions(listener);
    }

     @Test
    public void updateSwitchTestReadyReady() {
        switchState.status = SwitchStatus.READY;
        switchState.setHasEndpoints(true);

        switchManager.updateSwitch(nodeId, fcNode);
        verify(listener).switchUpdated(nodeId);
    }

     @Test
    public void updateSwitchTestReadyDisconnected() {
        switchState.status = SwitchStatus.DISCONNECTED;
        switchState.setHasEndpoints(true);

        switchManager.updateSwitch(nodeId, fcNode);
        verify(listener).switchReady(nodeId);
    }

     @Test
    public void updateSwitchTestPreparingReady() {
        switchState.status = SwitchStatus.READY;
        switchState.setHasEndpoints(false);

        switchManager.updateSwitch(nodeId, fcNode);
        verify(listener).switchRemoved(nodeId);
    }

     @Test
    public void updateSwitchTestDisconnectedReady() {
        switchState.status = SwitchStatus.READY;
        switchState.setHasEndpoints(true);

        switchManager.updateSwitch(nodeId, null);
        Assert.assertFalse(SwitchManager.switches.containsKey(nodeId));
    }

    @SuppressWarnings("unchecked")
     @Test
    public void updateSwitchNodeConnectorConfigTestPutDisconectedNull() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        fcncByNcIid.put(ncIid, fcncOld);

        switchManager.updateSwitchNodeConnectorConfig(ncIid, fcnc);

        Assert.assertTrue(fcncByNcIid.containsKey(ncIid));
        Assert.assertEquals(fcnc, fcncByNcIid.get(ncIid));
        verifyZeroInteractions(listener);
    }

    @SuppressWarnings("unchecked")
     @Test
    public void updateSwitchNodeConnectorConfigTestPutSwitchRemoved() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        fcncByNcIid.put(ncIid, fcncOld);
        switchState.setHasEndpoints(true);
        switchState.setFlowCapableNode(fcNode);

        switchManager.updateSwitchNodeConnectorConfig(ncIid, fcnc);

        Assert.assertTrue(fcncByNcIid.containsKey(ncIid));
        Assert.assertEquals(fcnc, fcncByNcIid.get(ncIid));
        verify(listener).switchRemoved(any(NodeId.class));
    }

    @SuppressWarnings("unchecked")
     @Test
    public void updateSwitchNodeConnectorConfigTestRemoveDisconectedNull() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        fcncByNcIid.put(ncIid, fcncOld);

        switchManager.updateSwitchNodeConnectorConfig(ncIid, null);

        Assert.assertFalse(fcncByNcIid.containsKey(ncIid));
        verifyZeroInteractions(listener);
    }

    @SuppressWarnings("unchecked")
     @Test
    public void updateSwitchNodeConnectorConfigTestRemoveSwitchRemoved() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        fcncByNcIid.put(ncIid, fcncOld);
        switchState.setHasEndpoints(true);
        switchState.setFlowCapableNode(fcNode);

        switchManager.updateSwitchNodeConnectorConfig(ncIid, null);

        Assert.assertFalse(fcncByNcIid.containsKey(ncIid));
        verify(listener).switchRemoved(any(NodeId.class));
    }

     @Test
    public void updateSwitchConfigTestStateNull() {
        NodeId nodeId = mock(NodeId.class);
        switchManager.updateSwitchConfig(nodeId, ofOverlayNodeConfig);
        verifyZeroInteractions(listener);
    }

     @Test
    public void updateSwitchConfigTestRemoved() {
        switchState.status = SwitchStatus.READY;
        switchManager.updateSwitchConfig(nodeId, ofOverlayNodeConfig);
    }

     @Test
    @SuppressWarnings({"unchecked", "rawtypes"})
    public void updateSwitchConfigTestReady() {
        FlowCapableNode fcNode = mock(FlowCapableNode.class);
        switchState.setFlowCapableNode(fcNode);
        switchState.status = SwitchStatus.DISCONNECTED;
        switchState.setHasEndpoints(true);
        Tunnel tunnel = mock(Tunnel.class);
        List<Tunnel> tunnels = Arrays.asList(tunnel);
        when(ofOverlayNodeConfig.getTunnel()).thenReturn(tunnels);
        when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
        IpAddress tAddress = mock(IpAddress.class);
        when(tunnel.getIp()).thenReturn(tAddress);
        NodeConnectorId tConnector = mock(NodeConnectorId.class);
        when(tunnel.getNodeConnectorId()).thenReturn(tConnector);
        PortNumber tPort = mock(PortNumber.class);
        when(tunnel.getPort()).thenReturn(tPort);

        switchManager.updateSwitchConfig(nodeId, ofOverlayNodeConfig);
    }

     @Test
    @SuppressWarnings({"unchecked", "rawtypes"})
    public void updateSwitchConfigTestUpdated() {
        FlowCapableNode fcNode = mock(FlowCapableNode.class);
        switchState.setFlowCapableNode(fcNode);
        switchState.status = SwitchStatus.READY;
        switchState.setHasEndpoints(true);
        Tunnel tunnel = mock(Tunnel.class);
        List<Tunnel> tunnels = Arrays.asList(tunnel);
        when(ofOverlayNodeConfig.getTunnel()).thenReturn(tunnels);
        when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
        IpAddress tAddress = mock(IpAddress.class);
        when(tunnel.getIp()).thenReturn(tAddress);
        NodeConnectorId tConnector = mock(NodeConnectorId.class);
        when(tunnel.getNodeConnectorId()).thenReturn(tConnector);
        PortNumber tPort = mock(PortNumber.class);
        when(tunnel.getPort()).thenReturn(tPort);

        switchManager.updateSwitchConfig(nodeId, ofOverlayNodeConfig);
    }

    @Test
    public void updateSwitchConfigTestDisconnected() {
        switchState.status = SwitchStatus.DISCONNECTED;
        switchState.setHasEndpoints(true);
        switchState.setConfig(mock(OfOverlayNodeConfig.class));

        switchManager.updateSwitchConfig(nodeId, null);
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
     @Test
    public void SwitchStateUpdateTest() throws Exception {
        NodeConnectorId externalPort = mock(NodeConnectorId.class);
        Set<NodeConnectorId> externalPorts = new HashSet(Arrays.asList(externalPort));

        ExternalInterfaces nc = mock(ExternalInterfaces.class);
        List<ExternalInterfaces> externalInterfaces = Arrays.asList(nc);
        when(ofOverlayNodeConfig.getExternalInterfaces()).thenReturn(externalInterfaces);
        when(nc.getNodeConnectorId()).thenReturn(externalPort);

        Tunnel tunnel = mock(Tunnel.class);
        List<Tunnel> tunnels = Arrays.asList(tunnel);
        when(ofOverlayNodeConfig.getTunnel()).thenReturn(tunnels);
        when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
        IpAddress tAddress = mock(IpAddress.class);
        when(tunnel.getIp()).thenReturn(tAddress);
        NodeConnectorId tConnector = mock(NodeConnectorId.class);
        when(tunnel.getNodeConnectorId()).thenReturn(tConnector);
        PortNumber tPort = mock(PortNumber.class);
        when(tunnel.getPort()).thenReturn(tPort);

        SwitchState switchState = new SwitchState(nodeId, nodeConnectorId, externalPorts, ofOverlayNodeConfig);

        Field field;
        field = SwitchState.class.getDeclaredField("externalPorts");
        field.setAccessible(true);
        externalPorts = (Set<NodeConnectorId>) field.get(switchState);
        Assert.assertTrue(externalPorts.contains(externalPort));

        field = SwitchState.class.getDeclaredField("tunnelBuilderByType");
        field.setAccessible(true);
        Map<Class<? extends TunnelTypeBase>, TunnelBuilder> tunnelBuilderByType = (Map<Class<? extends TunnelTypeBase>, TunnelBuilder>) field.get(switchState);
        Assert.assertNotNull(tunnelBuilderByType.get(TunnelTypeVxlan.class));
    }

    @SuppressWarnings("unchecked")
    @Test
    public void isConfigurationEmptyTest() throws Exception {
        Assert.assertTrue(switchState.isConfigurationEmpty());

        FlowCapableNode fcNode = mock(FlowCapableNode.class);
        switchState.setFlowCapableNode(fcNode);
        Assert.assertFalse(switchState.isConfigurationEmpty());

        switchState.setFlowCapableNode(null);
        switchState.setConfig(mock(OfOverlayNodeConfig.class));
        Assert.assertFalse(switchState.isConfigurationEmpty());

        switchState.setConfig(null);
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        fcncByNcIid.put(ncIid, fcnc);
        Assert.assertFalse(switchState.isConfigurationEmpty());
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Test
    public void setNodeConfigTest() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        field = SwitchState.class.getDeclaredField("nodeConfig");
        field.setAccessible(true);
        field.set(switchState, ofOverlayNodeConfig);

        ExternalInterfaces nc = mock(ExternalInterfaces.class);
        List<ExternalInterfaces> externalInterfaces = Arrays.asList(nc);
        when(ofOverlayNodeConfig.getExternalInterfaces()).thenReturn(externalInterfaces);

        Tunnel tunnel = mock(Tunnel.class);
        List<Tunnel> tunnels = Arrays.asList(tunnel);
        when(ofOverlayNodeConfig.getTunnel()).thenReturn(tunnels);
        when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
        IpAddress tAddress = mock(IpAddress.class);
        when(tunnel.getIp()).thenReturn(tAddress);
        NodeConnectorId tConnector = mock(NodeConnectorId.class);
        when(tunnel.getNodeConnectorId()).thenReturn(tConnector);
        PortNumber tPort = mock(PortNumber.class);
        when(tunnel.getPort()).thenReturn(tPort);

        switchState.setNodeConnectorConfig(ncIid, fcnc);
        Assert.assertTrue(fcncByNcIid.containsKey(ncIid));
        Assert.assertEquals(fcnc, fcncByNcIid.get(ncIid));

        TunnelBuilder tunnelBuilder = switchState.tunnelBuilderByType.get(TunnelTypeVxlan.class);
        Assert.assertNotNull(tunnelBuilder);
        Assert.assertEquals(tAddress, tunnelBuilder.getIp());
        Assert.assertEquals(tConnector, tunnelBuilder.getNodeConnectorId());
        Assert.assertEquals(tPort, tunnelBuilder.getPort());

        switchState.setNodeConnectorConfig(ncIid, null);
        Assert.assertFalse(fcncByNcIid.containsKey(ncIid));
    }

    @SuppressWarnings("unchecked")
    @Test
    public void setNodeConfigTestPutVxlan() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        field = SwitchState.class.getDeclaredField("nodeConfig");
        field.setAccessible(true);
        field.set(switchState, ofOverlayNodeConfig);

        ExternalInterfaces nc = mock(ExternalInterfaces.class);
        List<ExternalInterfaces> externalInterfaces = Arrays.asList(nc);
        when(ofOverlayNodeConfig.getExternalInterfaces()).thenReturn(externalInterfaces);

        when(fcnc.getName()).thenReturn("vxlan-fcncName");
        switchState.setNodeConnectorConfig(ncIid, fcnc);

        Assert.assertTrue(fcncByNcIid.containsKey(ncIid));
        Assert.assertEquals(fcnc, fcncByNcIid.get(ncIid));
        Assert.assertNotNull(switchState.tunnelBuilderByType.get(TunnelTypeVxlan.class));

        switchState.setNodeConnectorConfig(ncIid, null);
        Assert.assertFalse(fcncByNcIid.containsKey(ncIid));
    }

    @SuppressWarnings("unchecked")
    @Test
    public void setNodeConfigTestPutVxlangpe() throws Exception {
        Field field = SwitchState.class.getDeclaredField("fcncByNcIid");
        field.setAccessible(true);
        Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIid = (Map<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector>) field.get(switchState);
        field = SwitchState.class.getDeclaredField("nodeConfig");
        field.setAccessible(true);
        field.set(switchState, ofOverlayNodeConfig);

        ExternalInterfaces nc = mock(ExternalInterfaces.class);
        List<ExternalInterfaces> externalInterfaces = Arrays.asList(nc);
        when(ofOverlayNodeConfig.getExternalInterfaces()).thenReturn(externalInterfaces);

        when(fcnc.getName()).thenReturn("vxlangpe-fcncName");
        switchState.setNodeConnectorConfig(ncIid, fcnc);

        Assert.assertTrue(fcncByNcIid.containsKey(ncIid));
        Assert.assertEquals(fcnc, fcncByNcIid.get(ncIid));
        Assert.assertNotNull(switchState.tunnelBuilderByType.get(TunnelTypeVxlanGpe.class));

        switchState.setNodeConnectorConfig(ncIid, null);
        Assert.assertFalse(fcncByNcIid.containsKey(ncIid));
    }
}