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;
 
+import org.onlab.onos.TestApplicationId;
+import org.onlab.onos.core.ApplicationId;
 import org.onlab.onos.net.provider.ProviderId;
 import org.onlab.packet.ChassisId;
 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 ApplicationId APP_ID = new TestApplicationId("foo");
 
     // Short-hand for producing a device id from a string
     public static DeviceId did(String id) {

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

@@ -16,23 +16,39 @@
 package org.onlab.onos.net.intent;
 
 import static org.onlab.onos.net.NetTestTools.createPath;
+import static org.onlab.onos.net.NetTestTools.link;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
 
+import org.onlab.onos.net.DeviceId;
 import org.onlab.onos.net.ElementId;
+import org.onlab.onos.net.Link;
 import org.onlab.onos.net.Path;
 import org.onlab.onos.net.flow.TrafficSelector;
 import org.onlab.onos.net.flow.TrafficTreatment;
 import org.onlab.onos.net.flow.criteria.Criterion;
 import org.onlab.onos.net.flow.criteria.Criterion.Type;
 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.PathService;
+import org.onlab.onos.net.topology.TopologyVertex;
 
 /**
  * Common mocks used by the intent framework tests.
@@ -101,7 +117,158 @@ public class IntentTestsMocks {
 
         @Override
         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;
         }
     }
+
 }