Unit Tests for Bandwidth and Lambda allocations

These tests are for checking the valid path calculation logic
in the intent compilers and the PathIntent installer.

Change-Id: I2986729ae27202a2f42a71e64a53026383ddfb0b

@@ -15,6 +15,8 @@
  */
  */
 package org.onlab.onos.net;
 package org.onlab.onos.net;
 
 
+import org.onlab.onos.TestApplicationId;
+import org.onlab.onos.core.ApplicationId;
 import org.onlab.onos.net.provider.ProviderId;
 import org.onlab.onos.net.provider.ProviderId;
 import org.onlab.packet.ChassisId;
 import org.onlab.packet.ChassisId;
 import org.onlab.packet.IpAddress;
 import org.onlab.packet.IpAddress;
@@ -39,6 +41,7 @@ public final class NetTestTools {
     }
     }
 
 
     public static final ProviderId PID = new ProviderId("of", "foo");
     public static final ProviderId PID = new ProviderId("of", "foo");
+    public static final ApplicationId APP_ID = new TestApplicationId("foo");
 
 
     // Short-hand for producing a device id from a string
     // Short-hand for producing a device id from a string
     public static DeviceId did(String id) {
     public static DeviceId did(String id) {

@@ -67,7 +67,7 @@ public class PathIntentInstaller implements IntentInstaller<PathIntent> {
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected LinkResourceService resourceService;
     protected LinkResourceService resourceService;
 
 
-    private ApplicationId appId;
+    protected ApplicationId appId;
 
 
     @Activate
     @Activate
     public void activate() {
     public void activate() {

@@ -16,23 +16,39 @@
 package org.onlab.onos.net.intent;
 package org.onlab.onos.net.intent;
 
 
 import static org.onlab.onos.net.NetTestTools.createPath;
 import static org.onlab.onos.net.NetTestTools.createPath;
+import static org.onlab.onos.net.NetTestTools.link;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.List;
 import java.util.Set;
 import java.util.Set;
 
 
+import org.onlab.onos.net.DeviceId;
 import org.onlab.onos.net.ElementId;
 import org.onlab.onos.net.ElementId;
+import org.onlab.onos.net.Link;
 import org.onlab.onos.net.Path;
 import org.onlab.onos.net.Path;
 import org.onlab.onos.net.flow.TrafficSelector;
 import org.onlab.onos.net.flow.TrafficSelector;
 import org.onlab.onos.net.flow.TrafficTreatment;
 import org.onlab.onos.net.flow.TrafficTreatment;
 import org.onlab.onos.net.flow.criteria.Criterion;
 import org.onlab.onos.net.flow.criteria.Criterion;
 import org.onlab.onos.net.flow.criteria.Criterion.Type;
 import org.onlab.onos.net.flow.criteria.Criterion.Type;
 import org.onlab.onos.net.flow.instructions.Instruction;
 import org.onlab.onos.net.flow.instructions.Instruction;
+import org.onlab.onos.net.resource.BandwidthResourceRequest;
+import org.onlab.onos.net.resource.LambdaResourceRequest;
+import org.onlab.onos.net.resource.LinkResourceAllocations;
+import org.onlab.onos.net.resource.LinkResourceRequest;
+import org.onlab.onos.net.resource.LinkResourceService;
+import org.onlab.onos.net.resource.ResourceAllocation;
+import org.onlab.onos.net.resource.ResourceRequest;
+import org.onlab.onos.net.resource.ResourceType;
+import org.onlab.onos.net.topology.DefaultTopologyEdge;
+import org.onlab.onos.net.topology.DefaultTopologyVertex;
 import org.onlab.onos.net.topology.LinkWeight;
 import org.onlab.onos.net.topology.LinkWeight;
 import org.onlab.onos.net.topology.PathService;
 import org.onlab.onos.net.topology.PathService;
+import org.onlab.onos.net.topology.TopologyVertex;
 
 
 /**
 /**
  * Common mocks used by the intent framework tests.
  * Common mocks used by the intent framework tests.
@@ -101,7 +117,158 @@ public class IntentTestsMocks {
 
 
         @Override
         @Override
         public Set<Path> getPaths(ElementId src, ElementId dst, LinkWeight weight) {
         public Set<Path> getPaths(ElementId src, ElementId dst, LinkWeight weight) {
-            return getPaths(src, dst);
+            final Set<Path> paths = getPaths(src, dst);
+
+            for (Path path : paths) {
+                final DeviceId srcDevice = path.src().deviceId();
+                final DeviceId dstDevice = path.dst().deviceId();
+                final TopologyVertex srcVertex = new DefaultTopologyVertex(srcDevice);
+                final TopologyVertex dstVertex = new DefaultTopologyVertex(dstDevice);
+                final Link link = link(src.toString(), 1, dst.toString(), 1);
+
+                final double weightValue = weight.weight(new DefaultTopologyEdge(srcVertex, dstVertex, link));
+                if (weightValue < 0) {
+                    return new HashSet<>();
+                }
+            }
+            return paths;
+        }
+    }
+
+    public static class MockLinkResourceAllocations implements LinkResourceAllocations {
+        @Override
+        public Set<ResourceAllocation> getResourceAllocation(Link link) {
+            return null;
+        }
+
+        @Override
+        public IntentId intendId() {
+            return null;
+        }
+
+        @Override
+        public Collection<Link> links() {
+            return null;
+        }
+
+        @Override
+        public Set<ResourceRequest> resources() {
+            return null;
         }
         }
+
+        @Override
+        public ResourceType type() {
+            return null;
+        }
+    }
+
+    public static class MockedAllocationFailure extends RuntimeException { }
+
+    public static class MockResourceService implements LinkResourceService {
+
+        double availableBandwidth = -1.0;
+        int availableLambda = -1;
+
+        /**
+         * Allocates a resource service that will allow bandwidth allocations
+         * up to a limit.
+         *
+         * @param bandwidth available bandwidth limit
+         * @return resource manager for bandwidth requests
+         */
+        public static MockResourceService makeBandwidthResourceService(double bandwidth) {
+            final MockResourceService result = new MockResourceService();
+            result.availableBandwidth = bandwidth;
+            return result;
         }
         }
+
+        /**
+         * Allocates a resource service that will allow lambda allocations.
+         *
+         * @param lambda Lambda to return for allocation requests. Currently unused
+         * @return resource manager for lambda requests
+         */
+        public static MockResourceService makeLambdaResourceService(int lambda) {
+            final MockResourceService result = new MockResourceService();
+            result.availableLambda = lambda;
+            return result;
+        }
+
+        public void setAvailableBandwidth(double availableBandwidth) {
+            this.availableBandwidth = availableBandwidth;
+        }
+
+        public void setAvailableLambda(int availableLambda) {
+            this.availableLambda = availableLambda;
+        }
+
+
+        @Override
+        public LinkResourceAllocations requestResources(LinkResourceRequest req) {
+            int lambda = -1;
+            double bandwidth = -1.0;
+
+            for (ResourceRequest resourceRequest : req.resources()) {
+                if (resourceRequest.type() == ResourceType.BANDWIDTH) {
+                    final BandwidthResourceRequest brr = (BandwidthResourceRequest) resourceRequest;
+                    bandwidth = brr.bandwidth().toDouble();
+                } else if (resourceRequest.type() == ResourceType.LAMBDA) {
+                    lambda = 1;
+                }
+            }
+
+            if (availableBandwidth < bandwidth) {
+                throw new MockedAllocationFailure();
+            }
+            if (lambda > 0 && availableLambda == 0) {
+                throw new MockedAllocationFailure();
+            }
+
+            return new IntentTestsMocks.MockLinkResourceAllocations();
+        }
+
+        @Override
+        public void releaseResources(LinkResourceAllocations allocations) {
+            // Mock
+        }
+
+        @Override
+        public LinkResourceAllocations updateResources(LinkResourceRequest req,
+                                                       LinkResourceAllocations oldAllocations) {
+            return null;
+        }
+
+        @Override
+        public Iterable<LinkResourceAllocations> getAllocations() {
+            return null;
+        }
+
+        @Override
+        public Iterable<LinkResourceAllocations> getAllocations(Link link) {
+            return null;
+        }
+
+        @Override
+        public LinkResourceAllocations getAllocations(IntentId intentId) {
+            return null;
+        }
+
+        @Override
+        public Iterable<ResourceRequest> getAvailableResources(Link link) {
+            final List<ResourceRequest> result = new LinkedList<>();
+            if (availableBandwidth > 0.0) {
+                result.add(new BandwidthResourceRequest(availableBandwidth));
+            }
+            if (availableLambda > 0) {
+                result.add(new LambdaResourceRequest());
+            }
+            return result;
+        }
+
+        @Override
+        public ResourceRequest getAvailableResources(Link link, LinkResourceAllocations allocations) {
+            return null;
+        }
+    }
+
 }
 }

+/*
+ * Copyright 2014 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.onlab.onos.net.intent.impl;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+import org.onlab.onos.net.flow.FlowRuleBatchOperation;
+import org.onlab.onos.net.flow.TrafficSelector;
+import org.onlab.onos.net.flow.TrafficTreatment;
+import org.onlab.onos.net.intent.Constraint;
+import org.onlab.onos.net.intent.Intent;
+import org.onlab.onos.net.intent.IntentTestsMocks;
+import org.onlab.onos.net.intent.PathIntent;
+import org.onlab.onos.net.intent.PointToPointIntent;
+import org.onlab.onos.net.intent.constraint.BandwidthConstraint;
+import org.onlab.onos.net.intent.constraint.LambdaConstraint;
+import org.onlab.onos.net.resource.Bandwidth;
+import org.onlab.onos.net.resource.Lambda;
+import org.onlab.onos.net.resource.LinkResourceService;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.Assert.fail;
+import static org.onlab.onos.net.NetTestTools.APP_ID;
+import static org.onlab.onos.net.NetTestTools.connectPoint;
+
+/**
+ * Unit tests for calculating paths for intents with constraints.
+ */
+
+public class PathConstraintCalculationTest {
+
+    /**
+     * Creates a point to point intent compiler for a three switch linear
+     * topology.
+     *
+     * @param resourceService service to use for resource allocation requests
+     * @return point to point compiler
+     */
+    private PointToPointIntentCompiler makeCompiler(LinkResourceService resourceService) {
+        final String[] hops = {"s1", "s2", "s3"};
+        final PointToPointIntentCompiler compiler = new PointToPointIntentCompiler();
+        compiler.resourceService = resourceService;
+        compiler.pathService = new IntentTestsMocks.MockPathService(hops);
+        return compiler;
+    }
+
+    /**
+     * Creates an intent with a given constraint and compiles it. The compiler
+     * will throw PathNotFoundException if the allocations cannot be satisfied.
+     *
+     * @param constraint constraint to apply to the created intent
+     * @param resourceService service to use for resource allocation requests
+     * @return List of compiled intents
+     */
+    private List<Intent> compileIntent(Constraint constraint,
+                                       LinkResourceService resourceService) {
+        final List<Constraint> constraints = new LinkedList<>();
+        constraints.add(constraint);
+        final TrafficSelector selector = new IntentTestsMocks.MockSelector();
+        final TrafficTreatment treatment = new IntentTestsMocks.MockTreatment();
+
+        final PointToPointIntent intent =
+                new PointToPointIntent(APP_ID,
+                                       selector,
+                                       treatment,
+                                       connectPoint("s1", 1),
+                                       connectPoint("s3", 1),
+                                       constraints);
+        final PointToPointIntentCompiler compiler = makeCompiler(resourceService);
+
+        return compiler.compile(intent);
+    }
+
+    /**
+     * Installs a compiled path intent and returns the flow rules it generates.
+     *
+     * @param compiledIntents list of compiled intents
+     * @param resourceService service to use for resource allocation requests
+     * @return
+     */
+    private List<FlowRuleBatchOperation> installIntents(List<Intent> compiledIntents,
+                                                        LinkResourceService resourceService) {
+        final PathIntent path = (PathIntent) compiledIntents.get(0);
+
+        final PathIntentInstaller installer = new PathIntentInstaller();
+        installer.resourceService = resourceService;
+        installer.appId = APP_ID;
+        return installer.install(path);
+    }
+
+    /**
+     * Tests that requests with sufficient available bandwidth succeed.
+     */
+    @Test
+    public void testBandwidthConstrainedIntentSuccess() {
+
+        final LinkResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeBandwidthResourceService(1000.0);
+        final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+        final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+        assertThat(compiledIntents, notNullValue());
+        assertThat(compiledIntents, hasSize(1));
+    }
+
+    /**
+     * Tests that requests with insufficient available bandwidth fail.
+     */
+    @Test
+    public void testBandwidthConstrainedIntentFailure() {
+
+        final LinkResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeBandwidthResourceService(10.0);
+        final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+        try {
+            compileIntent(constraint, resourceService);
+            fail("Point to Point compilation with insufficient bandwidth does "
+                    + "not throw exception.");
+        } catch (PathNotFoundException noPath) {
+            assertThat(noPath.getMessage(), containsString("No packet path"));
+        }
+    }
+
+    /**
+     * Tests that requests for available lambdas are successful.
+     */
+    @Test
+    public void testLambdaConstrainedIntentSuccess() {
+
+        final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+        final LinkResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeLambdaResourceService(1);
+
+        final List<Intent> compiledIntents =
+                compileIntent(constraint, resourceService);
+        assertThat(compiledIntents, notNullValue());
+        assertThat(compiledIntents, hasSize(1));
+    }
+
+    /**
+     * Tests that requests for lambdas when there are no available lambdas
+     * fail.
+     */
+    @Test
+    public void testLambdaConstrainedIntentFailure() {
+
+        final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+        final LinkResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeBandwidthResourceService(10.0);
+        try {
+            compileIntent(constraint, resourceService);
+            fail("Point to Point compilation with no available lambda does "
+                    + "not throw exception.");
+        } catch (PathNotFoundException noPath) {
+            assertThat(noPath.getMessage(), containsString("No packet path"));
+        }
+    }
+
+    /**
+     * Tests that installation of bandwidth constrained path intents are
+     * successful.
+     */
+    @Test
+    public void testInstallBandwidthConstrainedIntentSuccess() {
+
+        final IntentTestsMocks.MockResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeBandwidthResourceService(1000.0);
+        final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+        final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+        assertThat(compiledIntents, notNullValue());
+        assertThat(compiledIntents, hasSize(1));
+
+        final List<FlowRuleBatchOperation> flowOperations =
+                installIntents(compiledIntents, resourceService);
+
+        assertThat(flowOperations, notNullValue());
+        assertThat(flowOperations, hasSize(1));
+    }
+
+    /**
+     * Tests that installation of bandwidth constrained path intents fail
+     * if there are no available resources.
+     */
+    @Test
+    public void testInstallBandwidthConstrainedIntentFailure() {
+
+        final IntentTestsMocks.MockResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeBandwidthResourceService(1000.0);
+        final Constraint constraint = new BandwidthConstraint(Bandwidth.valueOf(100.0));
+
+        final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+        assertThat(compiledIntents, notNullValue());
+        assertThat(compiledIntents, hasSize(1));
+
+        // Make it look like the available bandwidth was consumed
+        resourceService.setAvailableBandwidth(1.0);
+
+        try {
+            installIntents(compiledIntents, resourceService);
+            fail("Bandwidth request with no available bandwidth did not fail.");
+        } catch (IntentTestsMocks.MockedAllocationFailure failure) {
+            assertThat(failure,
+                       instanceOf(IntentTestsMocks.MockedAllocationFailure.class));
+        }
+    }
+
+    /**
+     * Tests that installation of lambda constrained path intents are
+     * successful.
+     */
+    @Test
+    public void testInstallLambdaConstrainedIntentSuccess() {
+
+        final IntentTestsMocks.MockResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeLambdaResourceService(1);
+        final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+
+        final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+        assertThat(compiledIntents, notNullValue());
+        assertThat(compiledIntents, hasSize(1));
+
+        final List<FlowRuleBatchOperation> flowOperations =
+                installIntents(compiledIntents, resourceService);
+
+        assertThat(flowOperations, notNullValue());
+        assertThat(flowOperations, hasSize(1));
+    }
+
+    /**
+     * Tests that installation of lambda constrained path intents fail
+     * if there are no available resources.
+     */
+    @Test
+    public void testInstallLambdaConstrainedIntentFailure() {
+
+        final IntentTestsMocks.MockResourceService resourceService =
+                IntentTestsMocks.MockResourceService.makeLambdaResourceService(1);
+        final Constraint constraint = new LambdaConstraint(Lambda.valueOf(1));
+
+        final List<Intent> compiledIntents = compileIntent(constraint, resourceService);
+        assertThat(compiledIntents, notNullValue());
+        assertThat(compiledIntents, hasSize(1));
+
+        // Make it look like the available lambda was consumed
+        resourceService.setAvailableLambda(0);
+
+        try {
+            installIntents(compiledIntents, resourceService);
+            fail("Lambda request with no available lambda did not fail.");
+        } catch (IntentTestsMocks.MockedAllocationFailure failure) {
+            assertThat(failure,
+                       instanceOf(IntentTestsMocks.MockedAllocationFailure.class));
+        }
+    }
+
+}