changes for cord-485 using device id in variable

Change-Id: Ied52ff808841397698c49fa13d4937868c14749d

@@ -39,6 +39,14 @@
 
 
         <dependency>
         <dependency>
             <groupId>org.onosproject</groupId>
             <groupId>org.onosproject</groupId>
+            <artifactId>onos-app-routing-api</artifactId>
+            <scope>test</scope>
+            <classifier>tests</classifier>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.onosproject</groupId>
             <artifactId>onos-cli</artifactId>
             <artifactId>onos-cli</artifactId>
             <version>${project.version}</version>
             <version>${project.version}</version>
         </dependency>
         </dependency>

+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.routing.impl;
+
+import static org.easymock.EasyMock.anyObject;
+import  static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.reset;
+import static org.easymock.EasyMock.verify;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Dictionary;
+import java.util.List;
+import java.util.Set;
+
+import org.easymock.EasyMock;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.Ip4Prefix;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.TestApplicationId;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.core.CoreServiceAdapter;
+import org.osgi.service.component.ComponentContext;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.device.DeviceServiceAdapter;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flowobjective.DefaultForwardingObjective;
+import org.onosproject.net.flowobjective.DefaultNextObjective;
+import org.onosproject.net.flowobjective.FlowObjectiveService;
+import org.onosproject.net.flowobjective.ForwardingObjective;
+import org.onosproject.net.flowobjective.NextObjective;
+import org.onosproject.net.host.InterfaceIpAddress;
+import org.onosproject.net.intent.AbstractIntentTest;
+import org.onosproject.routing.FibEntry;
+import org.onosproject.routing.FibListener;
+import org.onosproject.routing.FibUpdate;
+import org.onosproject.routing.RoutingService;
+import org.onosproject.routing.RoutingServiceAdapter;
+import org.onosproject.routing.config.RouterConfig;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+
+/**
+ * Unit tests for SingleSwitchFibInstaller.
+ */
+public class SingleSwitchFibInstallerTest extends AbstractIntentTest {
+
+    //for interface service setup
+    private static final ConnectPoint SW1_ETH1 = new ConnectPoint(
+            DeviceId.deviceId("of:0000000000000001"),
+            PortNumber.portNumber(1));
+
+    private static final ConnectPoint SW2_ETH1 = new ConnectPoint(
+            DeviceId.deviceId("of:0000000000000002"),
+            PortNumber.portNumber(1));
+
+    private static final ConnectPoint SW3_ETH1 = new ConnectPoint(
+            DeviceId.deviceId("of:0000000000000003"),
+            PortNumber.portNumber(1));
+
+    private static final ConnectPoint SW4_ETH1 = new ConnectPoint(
+            DeviceId.deviceId("of:0000000000000004"),
+            PortNumber.portNumber(1));
+
+    private DeviceId deviceId = DeviceId.deviceId("of:0000000000000001");
+    private final Set<Interface> interfaces = Sets.newHashSet();
+    private InterfaceService interfaceService;
+    private NetworkConfigService networkConfigService;
+    private FlowObjectiveService flowObjectiveService;
+    private DeviceService deviceService;
+    private static final ApplicationId APPID = TestApplicationId.create("update fib");
+    private FibListener fibListener;
+    private DeviceListener deviceListener;
+    private CoreService coreService;
+    private RouterConfig routerConfig;
+    private RoutingService routingService;
+    SingleSwitchFibInstaller sSfibInstaller;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        sSfibInstaller = new SingleSwitchFibInstaller();
+
+        //component config service
+        ComponentConfigService mockComponenetConfigServ = EasyMock.createMock(ComponentConfigService.class);
+        expect(mockComponenetConfigServ.getProperties(anyObject())).andReturn(ImmutableSet.of());
+        mockComponenetConfigServ.registerProperties(sSfibInstaller.getClass());
+        EasyMock.expectLastCall();
+        mockComponenetConfigServ.unregisterProperties(sSfibInstaller.getClass(), false);
+        EasyMock.expectLastCall();
+        expect(mockComponenetConfigServ.getProperties(anyObject())).andReturn(ImmutableSet.of());
+        sSfibInstaller.componentConfigService = mockComponenetConfigServ;
+        replay(mockComponenetConfigServ);
+
+        //component context
+        ComponentContext mockContext = EasyMock.createMock(ComponentContext.class);
+        Dictionary<String, Boolean> properties = null;
+        expect(mockContext.getProperties()).andReturn(properties);
+        replay(mockContext);
+
+        coreService = new TestCoreService();
+        routingService = new TestRoutingService();
+        routerConfig = new TestRouterConfig();
+        interfaceService = createMock(InterfaceService.class);
+        networkConfigService = createMock(NetworkConfigService.class);
+        flowObjectiveService = createMock(FlowObjectiveService.class);
+        deviceService = new TestDeviceService();
+
+        sSfibInstaller.networkConfigService = networkConfigService;
+        sSfibInstaller.interfaceService = interfaceService;
+        sSfibInstaller.flowObjectiveService = flowObjectiveService;
+        sSfibInstaller.coreService = coreService;
+        sSfibInstaller.routingService = new TestRoutingService();
+        sSfibInstaller.deviceService = deviceService;
+
+        setUpNetworkConfigService();
+        setUpInterfaceService();
+        sSfibInstaller.activate(mockContext);
+    }
+
+    /**
+     * Sets up InterfaceService.
+     */
+    private void setUpInterfaceService() {
+        Set<InterfaceIpAddress> interfaceIpAddresses1 = Sets.newHashSet();
+        interfaceIpAddresses1.add(new InterfaceIpAddress(
+                IpAddress.valueOf("192.168.10.101"),
+                IpPrefix.valueOf("192.168.10.0/24")));
+        Interface sw1Eth1 = new Interface(SW1_ETH1.deviceId().toString(), SW1_ETH1,
+                  interfaceIpAddresses1, MacAddress.valueOf("00:00:00:00:00:01"),
+                  VlanId.NONE);
+        interfaces.add(sw1Eth1);
+
+        Set<InterfaceIpAddress> interfaceIpAddresses2 = Sets.newHashSet();
+        interfaceIpAddresses2.add(new InterfaceIpAddress(IpAddress.valueOf("192.168.20.101"),
+           IpPrefix.valueOf("192.168.20.0/24")));
+        Interface sw2Eth1 = new Interface(SW2_ETH1.deviceId().toString(), SW2_ETH1,
+           interfaceIpAddresses2, MacAddress.valueOf("00:00:00:00:00:02"),
+           VlanId.NONE);
+        interfaces.add(sw2Eth1);
+
+        Set<InterfaceIpAddress> interfaceIpAddresses3 = Sets.newHashSet();
+        interfaceIpAddresses3.add(
+                new InterfaceIpAddress(IpAddress.valueOf("192.168.30.101"),
+                IpPrefix.valueOf("192.168.30.0/24")));
+        Interface sw3Eth1 = new Interface(SW3_ETH1.deviceId().toString(), SW3_ETH1,
+           interfaceIpAddresses3, MacAddress.valueOf("00:00:00:00:00:03"), VlanId.NONE);
+        interfaces.add(sw3Eth1);
+
+        InterfaceIpAddress interfaceIpAddress4 =
+           new InterfaceIpAddress(IpAddress.valueOf("192.168.40.101"),
+           IpPrefix.valueOf("192.168.40.0/24"));
+
+        Interface sw4Eth1 = new Interface(SW4_ETH1.deviceId().toString(), SW4_ETH1,
+           Sets.newHashSet(interfaceIpAddress4),
+           MacAddress.valueOf("00:00:00:00:00:04"),
+           VlanId.vlanId((short) 1));
+
+        expect(interfaceService.getInterfacesByPort(SW4_ETH1)).andReturn(
+                Collections.singleton(sw4Eth1)).anyTimes();
+        expect(interfaceService.getMatchingInterface(Ip4Address.valueOf("192.168.40.1")))
+                .andReturn(sw4Eth1).anyTimes();
+
+        interfaces.add(sw4Eth1);
+
+        expect(interfaceService.getInterfacesByPort(SW1_ETH1)).andReturn(
+                Collections.singleton(sw1Eth1)).anyTimes();
+        expect(interfaceService.getMatchingInterface(Ip4Address.valueOf("192.168.10.1")))
+                .andReturn(sw1Eth1).anyTimes();
+        expect(interfaceService.getInterfacesByPort(SW2_ETH1)).andReturn(
+                Collections.singleton(sw2Eth1)).anyTimes();
+        expect(interfaceService.getMatchingInterface(Ip4Address.valueOf("192.168.20.1")))
+                .andReturn(sw2Eth1).anyTimes();
+        expect(interfaceService.getInterfacesByPort(SW3_ETH1)).andReturn(
+                Collections.singleton(sw3Eth1)).anyTimes();
+        expect(interfaceService.getMatchingInterface(Ip4Address.valueOf("192.168.30.1")))
+                .andReturn(sw3Eth1).anyTimes();
+        expect(interfaceService.getInterfaces()).andReturn(interfaces).anyTimes();
+        replay(interfaceService);
+    }
+
+    /*
+     * Sets up NetworkConfigService.
+    */
+    private void setUpNetworkConfigService() {
+        ApplicationId routerAppId = coreService.registerApplication(RoutingService.ROUTER_APP_ID);
+        expect(networkConfigService.getConfig(routerAppId, RoutingService.ROUTER_CONFIG_CLASS)).
+        andReturn(routerConfig);
+        replay(networkConfigService);
+    }
+
+    /**
+     * Sets up FlowObjectiveService.
+     */
+    private void setUpFlowObjectiveService() {
+        expect(flowObjectiveService.allocateNextId()).andReturn(11);
+        replay(flowObjectiveService);
+    }
+
+    /**
+     * Tests adding a FIB entry to the flowObjectiveService.
+     *
+     * We verify that the flowObjectiveService records the correct state and that the
+     * correct flow is submitted to the flowObjectiveService.
+     */
+    @Test
+    public void testFibAdd() {
+        IpPrefix prefix = Ip4Prefix.valueOf("1.1.1.0/24");
+        FibEntry fibEntry = new FibEntry(prefix,
+                Ip4Address.valueOf("192.168.10.1"),
+                MacAddress.valueOf("00:00:00:00:00:01"));
+
+        //create the next Objective
+        Interface egressIntf = interfaceService.getMatchingInterface(fibEntry.nextHopIp());
+        TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder()
+                .setEthSrc(MacAddress.valueOf("00:00:00:00:00:01"))
+                .setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));
+        TrafficSelector.Builder metabuilder = null;
+        if (!egressIntf.vlan().equals(VlanId.NONE)) {
+            treatment.pushVlan()
+                    .setVlanId(egressIntf.vlan())
+                    .setVlanPcp((byte) 0);
+        } else {
+            metabuilder = DefaultTrafficSelector.builder();
+            metabuilder.matchVlanId(VlanId.vlanId(SingleSwitchFibInstaller.ASSIGNED_VLAN));
+        }
+        treatment.setOutput(PortNumber.portNumber(1));
+        int nextId = 11;
+        NextObjective.Builder nextBuilder = DefaultNextObjective.builder()
+                .withId(nextId)
+                .addTreatment(treatment.build())
+                .withType(NextObjective.Type.SIMPLE)
+                .fromApp(APPID);
+        if (metabuilder != null) {
+            nextBuilder.withMeta(metabuilder.build());
+        }
+
+        NextObjective nextObjective = nextBuilder.add();
+        flowObjectiveService.next(deviceId, nextObjective);
+
+        //set up the flowObjective
+        TrafficSelector selector = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPDst(prefix)
+                .build();
+
+        int priority = prefix.prefixLength() * 5 + 100;
+        ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
+                .fromApp(APPID)
+                .makePermanent()
+                .withSelector(selector)
+                .withPriority(priority)
+                .withFlag(ForwardingObjective.Flag.SPECIFIC);
+
+        Integer nextId1 = 11;
+        fwdBuilder.nextStep(nextId1);
+        flowObjectiveService.forward(deviceId, fwdBuilder.add());
+        EasyMock.expectLastCall().once();
+        setUpFlowObjectiveService();
+
+        // Send in the UPDATE FibUpdate
+        FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE, fibEntry);
+        fibListener.update(Collections.singleton(fibUpdate), Collections.emptyList());
+        verify(flowObjectiveService);
+    }
+
+    /**
+     * Tests adding a FIB entry with to a next hop in a VLAN.
+     *
+     * We verify that the flowObjectiveService records the correct state and that the
+     * correct flowObjectiveService is submitted to the flowObjectiveService.
+     */
+    @Test
+    public void testFibAddWithVlan() {
+        IpPrefix prefix = Ip4Prefix.valueOf("3.3.3.0/24");
+        FibEntry fibEntry = new FibEntry(prefix,
+                Ip4Address.valueOf("192.168.40.1"),
+                MacAddress.valueOf("00:00:00:00:00:04"));
+
+        //create the next Objective
+        Interface egressIntf = interfaceService.getMatchingInterface(fibEntry.nextHopIp());
+        TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder()
+                .setEthSrc(MacAddress.valueOf("00:00:00:00:00:04"))
+                .setEthDst(MacAddress.valueOf("00:00:00:00:00:04"));
+        TrafficSelector.Builder metabuilder = null;
+        if (!egressIntf.vlan().equals(VlanId.NONE)) {
+            treatment.pushVlan()
+                    .setVlanId(egressIntf.vlan())
+                    .setVlanPcp((byte) 0);
+        } else {
+            metabuilder = DefaultTrafficSelector.builder();
+            metabuilder.matchVlanId(VlanId.vlanId(SingleSwitchFibInstaller.ASSIGNED_VLAN));
+        }
+        treatment.setOutput(PortNumber.portNumber(1));
+        int nextId = 11;
+        NextObjective.Builder nextBuilder = DefaultNextObjective.builder()
+                .withId(nextId)
+                .addTreatment(treatment.build())
+                .withType(NextObjective.Type.SIMPLE)
+                .fromApp(APPID);
+        if (metabuilder != null) {
+            nextBuilder.withMeta(metabuilder.build());
+        }
+
+        NextObjective nextObjective = nextBuilder.add();
+        flowObjectiveService.next(deviceId, nextObjective);
+
+        //set up the flowObjective
+        TrafficSelector selector = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPDst(prefix)
+                .build();
+
+        int priority = prefix.prefixLength() * 5 + 100;
+        ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
+                .fromApp(APPID)
+                .makePermanent()
+                .withSelector(selector)
+                .withPriority(priority)
+                .withFlag(ForwardingObjective.Flag.SPECIFIC);
+
+        Integer nextId1 = 11;
+        fwdBuilder.nextStep(nextId1);
+        flowObjectiveService.forward(deviceId, fwdBuilder.add());
+        EasyMock.expectLastCall().once();
+        setUpFlowObjectiveService();
+
+        // Send in the UPDATE FibUpdate
+        FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE, fibEntry);
+        fibListener.update(Collections.singleton(fibUpdate), Collections.emptyList());
+
+        verify(flowObjectiveService);
+    }
+
+    /**
+     * Tests updating a FIB entry.
+     *
+     * We verify that the flowObjectiveService records the correct state and that the
+     * correct flow is submitted to the flowObjectiveService.
+     */
+    @Test
+    public void testFibUpdate() {
+        // Firstly add a route
+        testFibAdd();
+        reset(flowObjectiveService);
+        IpPrefix prefix = Ip4Prefix.valueOf("1.1.1.0/24");
+        // Start to construct a new route entry and new intent
+        FibEntry fibEntryUpdate = new FibEntry(prefix,
+                Ip4Address.valueOf("192.168.20.1"),
+                MacAddress.valueOf("00:00:00:00:00:02"));
+
+        //create the next Objective
+        Interface egressIntf = interfaceService.getMatchingInterface(fibEntryUpdate.nextHopIp());
+        TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder()
+                .setEthSrc(MacAddress.valueOf("00:00:00:00:00:02"))
+                .setEthDst(MacAddress.valueOf("00:00:00:00:00:02"));
+        TrafficSelector.Builder metabuilder = null;
+        if (!egressIntf.vlan().equals(VlanId.NONE)) {
+            treatment.pushVlan()
+                    .setVlanId(egressIntf.vlan())
+                    .setVlanPcp((byte) 0);
+        } else {
+            metabuilder = DefaultTrafficSelector.builder();
+            metabuilder.matchVlanId(VlanId.vlanId(SingleSwitchFibInstaller.ASSIGNED_VLAN));
+        }
+        treatment.setOutput(PortNumber.portNumber(1));
+        int nextId = 11;
+        NextObjective.Builder nextBuilder = DefaultNextObjective.builder()
+                .withId(nextId)
+                .addTreatment(treatment.build())
+                .withType(NextObjective.Type.SIMPLE)
+                .fromApp(APPID);
+        if (metabuilder != null) {
+            nextBuilder.withMeta(metabuilder.build());
+        }
+
+        NextObjective nextObjective = nextBuilder.add();
+        flowObjectiveService.next(deviceId, nextObjective);
+
+        //set up the flowObjective
+        TrafficSelector selector = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPDst(prefix)
+                .build();
+
+        int priority = prefix.prefixLength() * 5 + 100;
+        ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
+                .fromApp(APPID)
+                .makePermanent()
+                .withSelector(selector)
+                .withPriority(priority)
+                .withFlag(ForwardingObjective.Flag.SPECIFIC);
+
+        Integer nextId1 = 11;
+        fwdBuilder.nextStep(nextId1);
+        flowObjectiveService.forward(deviceId, fwdBuilder.add());
+        EasyMock.expectLastCall().once();
+        setUpFlowObjectiveService();
+
+        // Send in the UPDATE FibUpdate
+        FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.UPDATE,
+                fibEntryUpdate);
+        fibListener.update(Collections.singletonList(fibUpdate),
+                Collections.emptyList());
+
+        verify(flowObjectiveService);
+    }
+
+     /**
+     * Tests deleting a FIB entry.
+     *
+     * We verify that the flowObjectiveService records the correct state and that the
+     * correct flow is withdrawn from the flowObjectiveService.
+     */
+
+    @Test
+    public void testFibDelete() {
+        // Firstly add a route
+        testFibAdd();
+        IpPrefix prefix = Ip4Prefix.valueOf("1.1.1.0/24");
+
+        // Construct the existing route entry
+        FibEntry fibEntry = new FibEntry(prefix, null, null);
+
+        //set up the flowObjective
+        TrafficSelector selector = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPDst(prefix)
+                .build();
+
+        int priority = prefix.prefixLength() * 5 + 100;
+
+        ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
+                .fromApp(APPID)
+                .makePermanent()
+                .withSelector(selector)
+                .withPriority(priority)
+                .withFlag(ForwardingObjective.Flag.SPECIFIC);
+        fwdBuilder.withTreatment(DefaultTrafficTreatment.builder().build());
+        reset(flowObjectiveService);
+        flowObjectiveService.forward(deviceId, fwdBuilder.remove());
+        replay(flowObjectiveService);
+
+        // Send in the DELETE FibUpdate
+        FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.DELETE, fibEntry);
+        fibListener.update(Collections.emptyList(), Collections.singletonList(fibUpdate));
+
+        verify(flowObjectiveService);
+    }
+
+    private class TestCoreService extends CoreServiceAdapter {
+
+        @Override
+        public ApplicationId getAppId(String name) {
+            return APPID;
+        }
+
+        @Override
+        public ApplicationId registerApplication(String name) {
+            return APPID;
+        }
+    }
+
+    private class TestRoutingService extends RoutingServiceAdapter {
+
+        @Override
+        public void addFibListener(FibListener fibListener) {
+            SingleSwitchFibInstallerTest.this.fibListener = fibListener;
+        }
+    }
+
+    private class TestRouterConfig extends RouterConfig {
+
+        @Override
+        public List<String> getInterfaces() {
+            ArrayList<String> interfaces = new ArrayList<>();
+            interfaces.add("of:0000000000000001/1");
+            interfaces.add("of:0000000000000002/1");
+            interfaces.add("of:0000000000000003/1");
+            interfaces.add("of:0000000000000004/1");
+            return interfaces;
+        }
+
+        @Override
+        public ConnectPoint getControlPlaneConnectPoint() {
+            return SW1_ETH1;
+        }
+
+        @Override
+        public boolean getOspfEnabled() {
+            return true;
+        }
+    }
+
+    private class TestDeviceService  extends DeviceServiceAdapter {
+
+        @Override
+        public boolean isAvailable(DeviceId deviceId) {
+            return true;
+        }
+
+        @Override
+        public void addListener(DeviceListener listener) {
+            SingleSwitchFibInstallerTest.this.deviceListener = listener;
+        }
+    }
+}