Unit tets for instruction JSON codecs

Fixed several bugs in codecs turned up by unit tests

Change-Id: Icddb31aa3d2cb58612a0578772d24ff5f113d073

@@ -43,6 +43,13 @@
             <artifactId>easymock</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-api</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+            <classifier>tests</classifier>
+        </dependency>
     </dependencies>
 
     <properties>

@@ -20,8 +20,10 @@ import org.onosproject.codec.JsonCodec;
 import org.onosproject.net.flow.TrafficSelector;
 import org.onosproject.net.flow.TrafficTreatment;
 import org.onosproject.net.intent.ConnectivityIntent;
+import org.onosproject.net.intent.Constraint;
 import org.onosproject.net.intent.Intent;
 
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -50,6 +52,17 @@ public class ConnectivityIntentCodec extends JsonCodec<ConnectivityIntent> {
             result.set("treatment", treatmentCodec.encode(intent.treatment(), context));
         }
 
+        if (intent.constraints() != null) {
+            final ArrayNode jsonConstraints = result.putArray("constraints");
+
+            if (intent.constraints() != null) {
+                for (final Constraint constraint : intent.constraints()) {
+                    // TODO: constraint should have its own codec
+                    jsonConstraints.add(constraint.toString());
+                }
+            }
+        }
+
         return result;
     }
 }

@@ -50,6 +50,7 @@ public class CriterionCodec extends JsonCodec<Criterion> {
             case ETH_SRC:
             case ETH_DST:
                 final Criteria.EthCriterion ethCriterion = (Criteria.EthCriterion) criterion;
+                result.put("mac", ethCriterion.mac().toString());
                 break;
 
             case ETH_TYPE:
@@ -60,6 +61,8 @@ public class CriterionCodec extends JsonCodec<Criterion> {
 
             case IPV4_SRC:
             case IPV6_SRC:
+            case IPV4_DST:
+            case IPV6_DST:
                 final Criteria.IPCriterion iPCriterion = (Criteria.IPCriterion) criterion;
                 result.put("ip", iPCriterion.ip().toString());
                 break;

+/*
+ * 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.codec.impl;
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.onosproject.net.ConnectPoint;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * Hamcrest matcher for connect points.
+ */
+
+public final class ConnectPointJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
+
+    private final ConnectPoint connectPoint;
+
+    private ConnectPointJsonMatcher(ConnectPoint connectPointValue) {
+        connectPoint = connectPointValue;
+    }
+
+    @Override
+    public boolean matchesSafely(JsonNode jsonConnectPoint, Description description) {
+        // check device
+        final String jsonDevice = jsonConnectPoint.get("device").asText();
+        final String device = connectPoint.deviceId().toString();
+        if (!jsonDevice.equals(device)) {
+            description.appendText("device was " + jsonDevice);
+            return false;
+        }
+
+        // check port
+        final String jsonPort = jsonConnectPoint.get("port").asText();
+        final String port = connectPoint.port().toString();
+        if (!jsonPort.equals(port)) {
+            description.appendText("port was " + jsonPort);
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendText(connectPoint.toString());
+    }
+
+    /**
+     * Factory to allocate an connect point matcher.
+     *
+     * @param connectPoint connect point object we are looking for
+     * @return matcher
+     */
+    public static ConnectPointJsonMatcher matchesConnectPoint(ConnectPoint connectPoint) {
+        return new ConnectPointJsonMatcher(connectPoint);
+    }
+}

+/*
+ * 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.codec.impl;
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.onosproject.net.flow.criteria.Criteria;
+import org.onosproject.net.flow.criteria.Criterion;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * Hamcrest matcher for criterion objects.
+ */
+public final class CriterionJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
+
+    final Criterion criterion;
+
+    private CriterionJsonMatcher(Criterion criterionValue) {
+        criterion = criterionValue;
+    }
+
+    @Override
+    public boolean matchesSafely(JsonNode jsonCriterion, Description description) {
+        final String type = criterion.type().name();
+        final String jsonType = jsonCriterion.get("type").asText();
+        if (!type.equals(jsonType)) {
+            description.appendText("type was " + type);
+            return false;
+        }
+
+        switch (criterion.type()) {
+
+            case IN_PORT:
+                final Criteria.PortCriterion portCriterion = (Criteria.PortCriterion) criterion;
+                final long port = portCriterion.port().toLong();
+                final long jsonPort = jsonCriterion.get("port").asLong();
+                if (port != jsonPort) {
+                    description.appendText("port was " + Long.toString(jsonPort));
+                    return false;
+                }
+                break;
+
+            case ETH_SRC:
+            case ETH_DST:
+                final Criteria.EthCriterion ethCriterion = (Criteria.EthCriterion) criterion;
+                final String mac = ethCriterion.mac().toString();
+                final String jsonMac = jsonCriterion.get("mac").textValue();
+                if (!mac.equals(jsonMac)) {
+                    description.appendText("mac was " + jsonMac);
+                    return false;
+                }
+                break;
+
+            case ETH_TYPE:
+                final Criteria.EthTypeCriterion ethTypeCriterion =
+                        (Criteria.EthTypeCriterion) criterion;
+                final String ethType = ethTypeCriterion.ethType().toString();
+                final String jsonEthType = jsonCriterion.get("ethType").textValue();
+                if (!ethType.equals(jsonEthType)) {
+                    description.appendText("ethType was " + jsonEthType);
+                    return false;
+                }
+                break;
+
+            case IPV4_SRC:
+            case IPV6_SRC:
+            case IPV4_DST:
+            case IPV6_DST:
+                final Criteria.IPCriterion ipCriterion = (Criteria.IPCriterion) criterion;
+                final String ip = ipCriterion.ip().toString();
+                final String jsonIp = jsonCriterion.get("ip").textValue();
+                if (!ip.equals(jsonIp)) {
+                    description.appendText("ip was " + jsonIp);
+                    return false;
+                }
+                break;
+
+            case IP_PROTO:
+                final Criteria.IPProtocolCriterion iPProtocolCriterion =
+                        (Criteria.IPProtocolCriterion) criterion;
+                final byte protocol = iPProtocolCriterion.protocol();
+                final byte jsonProtocol = (byte) jsonCriterion.get("protocol").shortValue();
+                if (protocol != jsonProtocol) {
+                    description.appendText("protocol was " + Byte.toString(jsonProtocol));
+                    return false;
+                }
+                break;
+
+            case VLAN_PCP:
+                final Criteria.VlanPcpCriterion vlanPcpCriterion =
+                        (Criteria.VlanPcpCriterion) criterion;
+                final byte priority = vlanPcpCriterion.priority();
+                final byte jsonPriority = (byte) jsonCriterion.get("protocol").shortValue();
+                if (priority != jsonPriority) {
+                    description.appendText("priority was " + Byte.toString(jsonPriority));
+                    return false;
+                }
+                break;
+
+            case VLAN_VID:
+                final Criteria.VlanIdCriterion vlanIdCriterion =
+                        (Criteria.VlanIdCriterion) criterion;
+                final short vlanId = vlanIdCriterion.vlanId().toShort();
+                final short jsonvlanId = jsonCriterion.get("vlanId").shortValue();
+                if (vlanId != jsonvlanId) {
+                    description.appendText("vlanId was " + Short.toString(jsonvlanId));
+                    return false;
+                }
+                break;
+
+            case TCP_SRC:
+            case TCP_DST:
+                final Criteria.TcpPortCriterion tcpPortCriterion =
+                        (Criteria.TcpPortCriterion) criterion;
+                final byte tcpPort = tcpPortCriterion.tcpPort().byteValue();
+                final byte jsonTcpPort = (byte) jsonCriterion.get("tcpPort").shortValue();
+                if (tcpPort != jsonTcpPort) {
+                    description.appendText("tcp port was " + Byte.toString(jsonTcpPort));
+                    return false;
+                }
+                break;
+
+            case MPLS_LABEL:
+                final Criteria.MplsCriterion mplsCriterion =
+                        (Criteria.MplsCriterion) criterion;
+                final int label = mplsCriterion.label();
+                final int jsonLabel = jsonCriterion.get("label").intValue();
+                if (label != jsonLabel) {
+                    description.appendText("label was " + Integer.toString(jsonLabel));
+                    return false;
+                }
+                break;
+
+            case OCH_SIGID:
+                final Criteria.LambdaCriterion lambdaCriterion =
+                        (Criteria.LambdaCriterion) criterion;
+                final short lambda = lambdaCriterion.lambda();
+                final short jsonLambda = jsonCriterion.get("lambda").shortValue();
+                if (lambda != jsonLambda) {
+                    description.appendText("lambda was " + Short.toString(lambda));
+                    return false;
+                }
+                break;
+
+            case OCH_SIGTYPE:
+                final Criteria.OpticalSignalTypeCriterion opticalSignalTypeCriterion =
+                        (Criteria.OpticalSignalTypeCriterion) criterion;
+                final short signalType = opticalSignalTypeCriterion.signalType();
+                final short jsonSignalType = jsonCriterion.get("signalType").shortValue();
+                if (signalType != jsonSignalType) {
+                    description.appendText("signal type was " + Short.toString(signalType));
+                    return false;
+                }
+                break;
+
+            default:
+                // Don't know how to format this type
+                description.appendText("unknown criterion type " +
+                        criterion.type());
+                return false;
+        }
+        return true;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendText(criterion.toString());
+    }
+
+    /**
+     * Factory to allocate an criterion matcher.
+     *
+     * @param criterion criterion object we are looking for
+     * @return matcher
+     */
+    public static CriterionJsonMatcher matchesCriterion(Criterion criterion) {
+        return new CriterionJsonMatcher(criterion);
+    }
+}

@@ -24,12 +24,12 @@ import com.fasterxml.jackson.databind.JsonNode;
 /**
  * Hamcrest matcher for ethernet objects.
  */
-public class EthernetJsonMatcher extends TypeSafeMatcher<JsonNode> {
+public final class EthernetJsonMatcher extends TypeSafeMatcher<JsonNode> {
 
     private final Ethernet ethernet;
     private String reason = "";
 
-    public EthernetJsonMatcher(Ethernet ethernetValue) {
+    private EthernetJsonMatcher(Ethernet ethernetValue) {
         ethernet = ethernetValue;
     }
 

@@ -44,7 +44,7 @@ public class InstructionCodecTest {
     JsonCodec<Instruction> instructionCodec;
 
     /**
-     * Sets up for each tests.  Creates a context and fetches the instruction
+     * Sets up for each test.  Creates a context and fetches the instruction
      * codec.
      */
     @Before

@@ -31,11 +31,11 @@ import static org.onosproject.net.flow.instructions.L3ModificationInstruction.*;
 /**
  * Hamcrest matcher for instructions.
  */
-public class InstructionJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
+public final class InstructionJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
 
     private final Instruction instruction;
 
-    public InstructionJsonMatcher(Instruction instructionValue) {
+    private InstructionJsonMatcher(Instruction instructionValue) {
         instruction = instructionValue;
     }
 
@@ -134,7 +134,7 @@ public class InstructionJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode>
     }
 
     /**
-     * Matches the contents of a mod lambda instruction.
+     * Matches the contents of a mod Ethernet instruction.
      *
      * @param instructionJson JSON instruction to match
      * @return true if contents match, false otherwise
@@ -262,7 +262,7 @@ public class InstructionJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode>
     }
 
     /**
-     * Matches the contents of a mod ip instruction.
+     * Matches the contents of a mod MPLS label instruction.
      *
      * @param instructionJson JSON instruction to match
      * @return true if contents match, false otherwise

+/*
+ * 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.codec.impl;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.DefaultApplicationId;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.HostId;
+import org.onosproject.net.NetTestTools;
+import org.onosproject.net.PortNumber;
+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.intent.Constraint;
+import org.onosproject.net.intent.HostToHostIntent;
+import org.onosproject.net.intent.AbstractIntentTest;
+import org.onosproject.net.intent.PointToPointIntent;
+import org.onosproject.net.intent.constraint.BandwidthConstraint;
+import org.onosproject.net.intent.constraint.LambdaConstraint;
+import org.onosproject.net.resource.Bandwidth;
+import org.onosproject.net.resource.Lambda;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.ImmutableList;
+
+import static org.onosproject.codec.impl.IntentJsonMatcher.matchesIntent;
+import static org.onosproject.net.NetTestTools.hid;
+
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.notNullValue;
+
+/**
+ * Unit tests for the host to host intent class codec.
+ */
+public class IntentCodecTest extends AbstractIntentTest {
+
+    private final HostId id1 = hid("12:34:56:78:91:ab/1");
+    private final HostId id2 = hid("12:34:56:78:92:ab/1");
+    private final ApplicationId appId =
+            new DefaultApplicationId((short) 3, "test");
+    final TrafficSelector emptySelector =
+            DefaultTrafficSelector.builder().build();
+    final TrafficTreatment emptyTreatment =
+            DefaultTrafficTreatment.builder().build();
+    private final CodecContext context = new MockCodecContext();
+
+    /**
+     * Tests the encoding of a host to host intent.
+     */
+    @Test
+    public void hostToHostIntent() {
+        final HostToHostIntent intent =
+                new HostToHostIntent(appId, id1, id2);
+
+        final JsonCodec<HostToHostIntent> intentCodec =
+                context.codec(HostToHostIntent.class);
+        assertThat(intentCodec, notNullValue());
+
+        final ObjectNode intentJson = intentCodec.encode(intent, context);
+        assertThat(intentJson, matchesIntent(intent));
+    }
+
+    /**
+     * Tests the encoding of a point to point intent.
+     */
+    @Test
+    public void pointToPointIntent() {
+        ConnectPoint ingress = NetTestTools.connectPoint("ingress", 1);
+        ConnectPoint egress = NetTestTools.connectPoint("egress", 2);
+
+        final PointToPointIntent intent =
+                new PointToPointIntent(appId, emptySelector,
+                        emptyTreatment, ingress, egress);
+
+        final CodecContext context = new MockCodecContext();
+        final JsonCodec<PointToPointIntent> intentCodec =
+                context.codec(PointToPointIntent.class);
+        assertThat(intentCodec, notNullValue());
+
+        final ObjectNode intentJson = intentCodec.encode(intent, context);
+        assertThat(intentJson, matchesIntent(intent));
+    }
+
+    /**
+     * Tests the encoding of an intent with treatment, selector and constraints
+     * specified.
+     */
+    @Test
+    public void intentWithTreatmentSelectorAndConstraints() {
+        ConnectPoint ingress = NetTestTools.connectPoint("ingress", 1);
+        ConnectPoint egress = NetTestTools.connectPoint("egress", 2);
+        final TrafficSelector selector = DefaultTrafficSelector.builder()
+                .matchIPProtocol((byte) 3)
+                .matchMplsLabel(4)
+                .matchOpticalSignalType((short) 5)
+                .matchLambda((short) 6)
+                .matchEthDst(MacAddress.BROADCAST)
+                .matchIPDst(IpPrefix.valueOf("1.2.3.4/24"))
+                .build();
+        final TrafficTreatment treatment = DefaultTrafficTreatment.builder()
+                .setLambda((short) 33)
+                .setMpls(44)
+                .setOutput(PortNumber.CONTROLLER)
+                .setEthDst(MacAddress.BROADCAST)
+                .build();
+        final Constraint constraint1 = new BandwidthConstraint(Bandwidth.valueOf(1.0));
+        final Constraint constraint2 = new LambdaConstraint(Lambda.valueOf(3));
+        final List<Constraint> constraints = ImmutableList.of(constraint1, constraint2);
+
+        final PointToPointIntent intent =
+                new PointToPointIntent(appId, selector, treatment,
+                                       ingress, egress, constraints);
+
+        final CodecContext context = new MockCodecContext();
+        final JsonCodec<PointToPointIntent> intentCodec =
+                context.codec(PointToPointIntent.class);
+        assertThat(intentCodec, notNullValue());
+
+        final ObjectNode intentJson = intentCodec.encode(intent, context);
+        assertThat(intentJson, matchesIntent(intent));
+
+    }
+}

@@ -28,6 +28,9 @@ public final class MockCodecContext implements CodecContext {
     private ObjectMapper mapper = new ObjectMapper();
     private CodecManager manager = new CodecManager();
 
+    /**
+     * Constructs a new mock codec context.
+     */
     public MockCodecContext() {
         manager.activate();
     }