RPC gate set/delete/info and Patch operation support
[packetcable.git] / packetcable-policy-server / src / test / java / org / opendaylight / controller / packetcable / provider / PCMMServiceTest.java
index 936fdeb4b809aa7d09f6c426ad9468b3db9c192f..650903ea507e1a0007594d4eceb04cc2c45e909e 100644 (file)
@@ -1,45 +1,82 @@
+/*
+ * (c) 2015 Cable Television Laboratories, Inc.  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.controller.packetcable.provider;
 
+import static junit.framework.TestCase.assertEquals;
+
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.Mockito;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ServiceClassName;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ServiceFlowDirection;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.TosByte;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.TpProtocol;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.Ccaps;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.attributes.AmId;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.attributes.Connection;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.classifier.Classifier;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.gate.spec.GateSpec;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.gates.apps.subs.Gates;
-import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.traffic.profile.TrafficProfile;
+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.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.ServiceClassName;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.ServiceFlowDirection;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.TosByte;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.TpProtocol;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.ccap.attributes.AmId;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.ccap.attributes.Connection;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.ccaps.Ccap;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.classifier.attributes.Classifiers;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.classifier.attributes.classifiers.ClassifierContainer;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.classifier.attributes.classifiers.classifier.container.classifier.choice.QosClassifierChoice;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.flow.spec.profile.FlowSpecProfile;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.classifier.Classifier;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.gate.spec.GateSpec;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.gate.spec.GateSpecBuilder;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.gates.apps.app.subscribers.subscriber.gates.Gate;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.TrafficProfile;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.TrafficProfileBuilder;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.traffic.profile.TrafficProfileChoice;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.traffic.profile.traffic.profile.choice.FlowSpecChoice;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.traffic.profile.traffic.profile.choice.FlowSpecChoiceBuilder;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.traffic.profile.traffic.profile.choice.ServiceClassNameChoice;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.qos.traffic.profile.traffic.profile.traffic.profile.choice.ServiceClassNameChoiceBuilder;
+import org.opendaylight.yang.gen.v1.urn.packetcable.rev170224.pcmm.serviceclass.name.profile.ServiceClassNameProfile;
+import org.pcmm.PCMMPdpAgent;
 import org.pcmm.gates.IPCMMGate;
 import org.pcmm.rcd.IPCMMClient;
 import org.pcmm.rcd.impl.CMTS;
-import org.umu.cops.stack.*;
+import org.pcmm.rcd.impl.CMTSConfig;
+import org.umu.cops.stack.COPSClientSI;
 import org.umu.cops.stack.COPSContext.RType;
+import org.umu.cops.stack.COPSContext;
+import org.umu.cops.stack.COPSData;
 import org.umu.cops.stack.COPSDecision.Command;
 import org.umu.cops.stack.COPSDecision.DecisionFlag;
+import org.umu.cops.stack.COPSDecision;
+import org.umu.cops.stack.COPSDecisionMsg;
+import org.umu.cops.stack.COPSHandle;
+import org.umu.cops.stack.COPSMsg;
+import org.umu.cops.stack.COPSMsgParser;
 import org.umu.cops.stack.COPSObjHeader.CNum;
 import org.umu.cops.stack.COPSObjHeader.CType;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.InetAddress;
-import java.net.Socket;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
 /**
  * Tests the PCMMService's ability to connect to a CMTS. Gate additions will not properly work as there is currently
  * not any other means to receive acknowledgements. This functionality must be tested by the PCMMService's client
@@ -47,86 +84,207 @@ import java.util.Set;
  */
 public class PCMMServiceTest {
 
+    private static final String ccapId = "ccap-1";
+    private static final String gatePath = "testGatePath";
+
+    /**
+     * Denotes whether or not a real CMTS is being tested against.
+     * Ensure the checked-in value is always false else tests will most likely fail.
+     */
+    private static final boolean realCmts = false;
+
+
+    // The test objects/values to use that will be instantiated in @Before
+
     /**
      * The mock CMTS running on localhost with a dynamic port assigned.
      */
     private CMTS icmts;
 
     /**
-     * Represents the IP address of the CM the gate should be set against.
+     * The IP address object for the CMTS to test against
      */
-    private byte[] cmAddr = new byte[4];
+    private Ipv4Address cmtsAddr;
+
+    /**
+     * The gate classifier's srcIp value, any valid IP should work.
+     */
+    private Ipv4Address srcAddr;
+
+    /**
+     * The gate classifier's dstIp value, any valid IP should work.
+     */
+    private Ipv4Address dstAddr;
+
+    /**
+     * Defines the CMTS to add to the PCMMService
+     */
+    private Ccap ccap;
+
+    /**
+     * The class under test
+     */
+    private PCMMService service;
+
+    /**
+     * The cable modem IP address to which a gate should be set
+     */
+    private InetAddress cmAddrInet;
+    private InetAddress invalidCmAddrInet;
 
     @Before
-    public void setup() {
-        icmts = new CMTS();
-        icmts.startServer();
-
-        cmAddr[0] = 10;
-        cmAddr[1] = 32;
-        cmAddr[2] = 110;
-        cmAddr[3] = (byte)180;
+    public void setup() throws IOException {
+        srcAddr = new Ipv4Address("10.10.10.0");
+        dstAddr = new Ipv4Address("10.32.99.99");
+        invalidCmAddrInet = InetAddress.getByAddress(new byte[] {99, 99, 99, 99});
+
+        if (realCmts) {
+            cmAddrInet = InetAddress.getByAddress(new byte[] {10, 32, 110, (byte)172});
+
+
+            // Use me when testing against a CMTS or emulator not running in the same JVM
+            cmtsAddr = new Ipv4Address("10.32.10.3");
+            ccap = makeCcapObj(PCMMPdpAgent.WELL_KNOWN_PDP_PORT, cmtsAddr, ccapId);
+        } else {
+            cmAddrInet = InetAddress.getByAddress(new byte[] {10, 32, 110, (byte)180});
+
+            // Use me for automated testing and the CMTS emulator running in the same JVM
+            cmtsAddr = new Ipv4Address("127.0.0.1");
+
+            final Set<String> upSCN = new HashSet<>();
+            upSCN.add("extrm_up");
+            final Set<String> dnSCN = new HashSet<>();
+            dnSCN.add("extrm_dn");
+
+            final Map<String, Boolean> cmStatus = new HashMap<>();
+            cmStatus.put(cmAddrInet.getHostAddress(), true);
+            cmStatus.put(invalidCmAddrInet.getHostAddress(), false);
+
+            CMTSConfig config = new CMTSConfig(0, (short)4, upSCN, dnSCN, cmStatus);
+
+            icmts = new CMTS(config);
+            icmts.startServer();
+
+            ccap = makeCcapObj(icmts.getPort(), cmtsAddr, ccapId);
+        }
+
+        service = new PCMMService(IPCMMClient.CLIENT_TYPE, ccap);
     }
 
     @After
     public void tearDown() {
         if (icmts != null) icmts.stopServer();
+        service.disconect();
     }
 
     @Test
     public void testAddCcap() {
+        connectToCmts(service);
+    }
 
-        // TODO - comment out for testing
-        //        final Ipv4Address cmtsAddr = new Ipv4Address("10.32.10.3");
-//        final Ccaps ccap = makeCcapsObj(PCMMPdpAgent.WELL_KNOWN_PDP_PORT, cmtsAddr.getValue(), "ccap-1");
-
-        // TODO - Use this instead for automated testing
-        final Ipv4Address cmtsAddr = new Ipv4Address("127.0.0.1");
-        final Ccaps ccap = makeCcapsObj(icmts.getPort(), cmtsAddr.getValue(), "ccap-1");
-
-        final PCMMService service = new PCMMService(IPCMMClient.CLIENT_TYPE, ccap);
+    @Test
+    public void testAddInvalidCcapBadPort() {
+        final int port;
+        if (icmts != null) port = icmts.getPort() + 1;
+        else port = PCMMPdpAgent.WELL_KNOWN_PDP_PORT + 1;
+        ccap = makeCcapObj(port, cmtsAddr, ccapId);
+        service = new PCMMService(IPCMMClient.CLIENT_TYPE, ccap);
         final String message = service.addCcap();
         Assert.assertNotNull(message);
-        Assert.assertTrue(message, message.startsWith("200"));
-        Assert.assertNotNull(service.ccapClient.pcmmPdp.getClientHandle());
-        service.disconect();
+        final String expectedMsg = "404 Not Found - CCAP " + ccapId + " failed to connect @ " + cmtsAddr.getValue()
+                + ':' + port + " - ";
+        Assert.assertTrue(expectedMsg, message.startsWith(expectedMsg));
     }
 
-//    @Test
-    public void testAddAndRemoveUpGate() throws Exception {
+    @Test
+    public void testAddValidUpGateTwice() throws Exception {
+        connectToCmts(service);
+        final String expectedMsg1 = "200 OK - sendGateSet for " + ccapId + '/' + gatePath + " returned GateId";
+        addAndValidateGate(service, "extrm_up", srcAddr, dstAddr, ServiceFlowDirection.Us, cmAddrInet, gatePath,
+                expectedMsg1);
 
-        // TODO - Use this block to test against a real CMTS
-//        final Ipv4Address cmtsAddr = new Ipv4Address("10.32.10.3");
-//        final Ccaps ccap = makeCcapsObj(PCMMPdpAgent.WELL_KNOWN_PDP_PORT, cmtsAddr.getValue(), "ccap-1");
+        final String expectedMsg2 = "404 Not Found - sendGateSet for " + ccapId + '/' + gatePath + " already exists";
+        addAndValidateGate(service, "extrm_up", srcAddr, dstAddr, ServiceFlowDirection.Us, cmAddrInet, gatePath,
+                expectedMsg2);
 
-        // TODO - Use this block for automated testing
-        final Ipv4Address cmtsAddr = new Ipv4Address("127.0.0.1");
-        final Ccaps ccap = makeCcapsObj(icmts.getPort(), cmtsAddr.getValue(), "ccap-1");
+        Assert.assertTrue(deleteGate(service, gatePath));
+    }
 
-        final PCMMService service = new PCMMService(IPCMMClient.CLIENT_TYPE, ccap);
-        service.addCcap();
+    @Test
+    public void testAddTwoValidUpGates() throws Exception {
+        connectToCmts(service);
 
-        final Gates gate = makeGateObj("extrm_up", cmtsAddr, ServiceFlowDirection.Us);
-        final String gatePath = "testGatePath";
+        final String gatePath1 = "gatePath1";
+        final String expectedMsg1 = "200 OK - sendGateSet for " + ccapId + '/' + gatePath1 + " returned GateId";
+        addAndValidateGate(service, "extrm_up", srcAddr, dstAddr, ServiceFlowDirection.Us, cmAddrInet, gatePath1,
+                expectedMsg1);
 
-        // Add gate
-        final String msg = service.sendGateSet(gatePath, InetAddress.getByAddress(cmAddr), gate,
-                ServiceFlowDirection.Us);
-        Assert.assertTrue(msg, msg.startsWith("200"));
+        final String gatePath2 = "gatePath2";
+        final String expectedMsg2 = "200 OK - sendGateSet for " + ccapId + '/' + gatePath2 + " returned GateId";
+        addAndValidateGate(service, "extrm_up", srcAddr, dstAddr, ServiceFlowDirection.Us, cmAddrInet, gatePath2,
+                expectedMsg2);
 
-        // TODO - add validation to the PCMMGateReq contained within the map
-        Assert.assertEquals(1, service.gateRequests.size());
+        Assert.assertTrue(deleteGate(service, gatePath1));
+        Assert.assertTrue(deleteGate(service, gatePath2));
+    }
 
-        // Remove gate
-        service.sendGateDelete(gatePath);
+    @Test
+    public void testAddValidDownGateTwice() throws Exception {
+        connectToCmts(service);
+        final String expectedMsg1 = "200 OK - sendGateSet for " + ccapId + '/' + gatePath + " returned GateId";
+        addAndValidateGate(service, "extrm_dn", srcAddr, dstAddr, ServiceFlowDirection.Ds, cmAddrInet, gatePath,
+                expectedMsg1);
 
-        // Wait up to 1 sec for response to be processed
-        final long start = System.currentTimeMillis();
-        while (1000 < System.currentTimeMillis() - start) {
-            if (service.gateRequests.size() == 0) break;
-        }
-        Assert.assertEquals(0, service.gateRequests.size());
-        service.disconect();
+        final String expectedMsg2 = "404 Not Found - sendGateSet for " + ccapId + '/' + gatePath + " already exists";
+        addAndValidateGate(service, "extrm_dn", srcAddr, dstAddr, ServiceFlowDirection.Ds, cmAddrInet, gatePath,
+                expectedMsg2);
+
+        Assert.assertTrue(deleteGate(service, gatePath));
+    }
+
+    @Test
+    public void testDeleteNonExistentGate() throws Exception {
+        connectToCmts(service);
+        Assert.assertFalse(deleteGate(service, gatePath));
+    }
+
+    @Test
+    public void testAddAndRemoveValidUpGate() throws Exception {
+        final String expectedMsgStart = "200 OK - sendGateSet for " + ccapId + '/' + gatePath + " returned GateId";
+        addRemoveValidateGate(service, "extrm_up", srcAddr, dstAddr, ServiceFlowDirection.Us, cmAddrInet, gatePath,
+                expectedMsgStart);
+    }
+
+    @Test
+    public void testAddAndRemoveValidDownGate() throws Exception {
+        final String expectedMsgStart = "200 OK - sendGateSet for " + ccapId + '/' + gatePath + " returned GateId";
+        addRemoveValidateGate(service, "extrm_dn", srcAddr, dstAddr, ServiceFlowDirection.Ds, cmAddrInet, gatePath,
+                expectedMsgStart);
+    }
+
+    @Test
+    public void testAddAndRemoveInvalidCmAddrUpGate() throws Exception {
+        // TODO - fix cmts emulator
+        final String expectedMsgStart = "404 Not Found - sendGateSet for " + ccapId + '/' + gatePath
+                + " returned error - Error Code: 13 Subcode: 0  Invalid SubscriberID";
+        addInvalidGate(service, "extrm_up", srcAddr, dstAddr, ServiceFlowDirection.Us, invalidCmAddrInet, gatePath,
+                expectedMsgStart);
+    }
+
+    @Test
+    public void testAddInvalidScnUpGate() throws Exception {
+        final String expectedMsgStart = "404 Not Found - sendGateSet for " + ccapId + '/' + gatePath
+                + " returned error - Error Code: 11 Subcode: 0  Undefined Service Class Name";
+        addInvalidGate(service, "extrm_up_invalid", srcAddr, dstAddr, ServiceFlowDirection.Us, cmAddrInet, gatePath,
+                expectedMsgStart);
+    }
+
+    @Test
+    public void testAddInvalidScnDownGate() throws Exception {
+        final String expectedMsgStart = "404 Not Found - sendGateSet for " + ccapId + '/' + gatePath
+                + " returned error - Error Code: 11 Subcode: 0  Undefined Service Class Name";
+        addInvalidGate(service, "extrm_dn_invalid", srcAddr, dstAddr, ServiceFlowDirection.Ds, cmAddrInet, gatePath,
+                expectedMsgStart);
     }
 
     /**
@@ -138,11 +296,10 @@ public class PCMMServiceTest {
     @Test
     public void testGateRequestDecisionMsg() throws Exception {
         final Socket socket = new MockSocket();
-        final Ccaps ccap = makeCcapsObj(icmts.getPort(), "127.0.0.1", "ccap-1");
-        final Ipv4Address cmtsAddr = new Ipv4Address("127.0.0.1");
-        final Gates gate = makeGateObj("extrm_up", cmtsAddr, ServiceFlowDirection.Us);
-        final IPCMMGate gateReq = makeGateRequest(ccap, gate, InetAddress.getByName("localhost"),
-                ServiceFlowDirection.Us);
+
+        final ServiceFlowDirection direction = ServiceFlowDirection.Us;
+        final Gate gate = makeGateObj("extrm_up", cmtsAddr, direction, new Ipv4Address("127.0.0.1"));
+        final IPCMMGate gateReq = makeGateRequest(ccap, gate, InetAddress.getByName("localhost"), direction);
         final byte[] data = gateReq.getData();
 
         final Set<COPSDecision> decisionSet = new HashSet<>();
@@ -161,104 +318,213 @@ public class PCMMServiceTest {
     }
 
     /**
-     * Creates a mock Ccaps object that can be used for connecting to a CMTS
+     * Attempts to create a gate against a CMTS, validates the results then attempts to delete it.
+     * @param service - the service used to connect to a CMTS for issuing requests
+     * @param scnName - the service class name (aka. gate name)
+     * @param srcAddr - the address to the CMTS subnet?
+     * @param dstAddr - the destination address
+     * @param direction - the gate direction
+     * @param cmAddrInet - the address to the cable modem to which the gate will be assigned
+     * @param gatePath - the path to the gate
+     * @param expGateSetMsgStart - the expected start of the gate set return message to be validated against
+     */
+    private void addRemoveValidateGate(final PCMMService service, final String scnName, final Ipv4Address srcAddr,
+                                       final Ipv4Address dstAddr, final ServiceFlowDirection direction,
+                                       final InetAddress cmAddrInet, final String gatePath,
+                                       final String expGateSetMsgStart) {
+        connectToCmts(service);
+        addAndValidateGate(service, scnName, srcAddr, dstAddr, direction, cmAddrInet, gatePath, expGateSetMsgStart);
+        deleteGate(service, gatePath);
+    }
+
+    private void addInvalidGate(final PCMMService service, final String scnName, final Ipv4Address srcAddr,
+            final Ipv4Address dstAddr, final ServiceFlowDirection direction,
+            final InetAddress cmAddrInet, final String gatePath,
+            final String expGateSetMsgStart) {
+        connectToCmts(service);
+        final int numRequestsBefore = service.gateRequests.size();
+        addAndValidateGate(service, scnName, srcAddr, dstAddr, direction, cmAddrInet, gatePath, expGateSetMsgStart);
+        assertEquals(numRequestsBefore, service.gateRequests.size());
+    }
+
+    private void connectToCmts(final PCMMService service) {
+        final String message = service.addCcap();
+        Assert.assertNotNull(message);
+        final String expectedMsg = "200 OK - CCAP " + ccapId + " connected @ "
+                + ccap.getConnection().getIpAddress().getIpv4Address().getValue()
+                + ":" + ccap.getConnection().getPort().getValue();
+        Assert.assertEquals(expectedMsg, message);
+        Assert.assertNotNull(service.ccapClient.pcmmPdp.getClientHandle());
+    }
+
+    /**
+     * Attempts to create a gate against a CMTS and validates the results.
+     * @param service - the service used to connect to a CMTS for issuing requests
+     * @param scnName - the service class name (aka. gate name)
+     * @param srcAddr - the address to the CMTS subnet?
+     * @param dstAddr - the destination address
+     * @param direction - the gate direction
+     * @param cmAddrInet - the address to the cable modem to which the gate will be assigned
+     * @param gatePath - the path to the gate
+     * @param expGateSetMsgStart - the expected start of the gate set return message to be validated against
+     */
+    private void addAndValidateGate(final PCMMService service, final String scnName, final Ipv4Address srcAddr,
+                                    final Ipv4Address dstAddr, final ServiceFlowDirection direction,
+                                    final InetAddress cmAddrInet, final String gatePath,
+                                    final String expGateSetMsgStart) {
+        final Gate gate = makeGateObj(scnName, srcAddr, direction, dstAddr);
+
+//        final String gateSetMsg = service.sendGateSet(gatePath, cmAddrInet, gate, direction);
+//        Assert.assertNotNull(gateSetMsg);
+//        Assert.assertTrue(gateSetMsg, gateSetMsg.startsWith(expGateSetMsgStart));
+
+        // TODO update this method for the new GateSendStatus object
+        PCMMService.GateSendStatus status = service.sendGateSet(gatePath, cmAddrInet, gate);
+        Assert.assertNotNull(status);
+        assertThat(status.getMessage(), startsWith(expGateSetMsgStart));
+
+
+        // TODO - add validation to the PCMMGateReq contained within the map
+        if (status.didSucceed()) {
+            Assert.assertTrue((service.gateRequests.containsKey(gatePath)));
+            Assert.assertNotNull(service.gateRequests.get(gatePath));
+        }
+    }
+
+    /**
+     * Attempts to delete a gate
+     * @param service - the service used to connect to a CMTS for issuing requests
+     * @param gatePath - the path to the gate
+     */
+    private boolean deleteGate(final PCMMService service, final String gatePath) {
+        final boolean out = service.sendGateDelete(gatePath);
+
+        // Wait up to 1 sec for response to be processed
+        final long start = System.currentTimeMillis();
+        while (1000 < System.currentTimeMillis() - start) {
+            if (service.gateRequests.size() == 0) break;
+        }
+        Assert.assertNull(service.gateRequests.get(gatePath));
+        return out;
+    }
+
+    /**
+     * Creates a mock Ccap object that can be used for connecting to a CMTS
      * @param inPort - the CMTS port number
      * @param ipAddr - the CMTS IPv4 address string
      * @param ccapId - the ID of the CCAP
-     * @return - the mock Ccaps object
+     * @return - the mock Ccap object
      */
-    private Ccaps makeCcapsObj(final int inPort, final String ipAddr, final String ccapId) {
-        final Ccaps ccap = Mockito.mock(Ccaps.class);
-        final Connection conn = Mockito.mock(Connection.class);
-        Mockito.when(ccap.getConnection()).thenReturn(conn);
-        final PortNumber port = Mockito.mock(PortNumber.class);
-        Mockito.when(conn.getPort()).thenReturn(port);
-        Mockito.when(port.getValue()).thenReturn(inPort);
-
-        final IpAddress addr = Mockito.mock(IpAddress.class);
-        Mockito.when(conn.getIpAddress()).thenReturn(addr);
-        final Ipv4Address ipv4 = new Ipv4Address(ipAddr);
-        Mockito.when(addr.getIpv4Address()).thenReturn(ipv4);
-
-        Mockito.when(ccap.getCcapId()).thenReturn(ccapId);
-        final AmId amid = Mockito.mock(AmId.class);
-        Mockito.when(ccap.getAmId()).thenReturn(amid);
-        Mockito.when(amid.getAmTag()).thenReturn(0xcada);
-        Mockito.when(amid.getAmType()).thenReturn(1);
+    private Ccap makeCcapObj(final int inPort, final Ipv4Address ipAddr, final String ccapId) {
+        final Ccap ccap = mock(Ccap.class);
+        final Connection conn = mock(Connection.class);
+        when(ccap.getConnection()).thenReturn(conn);
+        final PortNumber port = mock(PortNumber.class);
+        when(conn.getPort()).thenReturn(port);
+        when(port.getValue()).thenReturn(inPort);
+
+        final IpAddress addr = mock(IpAddress.class);
+        when(conn.getIpAddress()).thenReturn(addr);
+        when(addr.getIpv4Address()).thenReturn(ipAddr);
+
+        when(ccap.getCcapId()).thenReturn(ccapId);
+        final AmId amid = mock(AmId.class);
+        when(ccap.getAmId()).thenReturn(amid);
+        when(amid.getAmTag()).thenReturn(0xcada);
+        when(amid.getAmType()).thenReturn(1);
 
         return ccap;
     }
 
     /**
-     * Creates a mock Gates object
+     * Creates a mock Gate object
      * @param scnValue - the service class name defined on the CMTS
      * @param dstAddr - the CM address this gate should be set against
      * @return - the gate request
      */
-    private Gates makeGateObj(final String scnValue, final Ipv4Address dstAddr, final ServiceFlowDirection direction) {
-        final Gates gate = Mockito.mock(Gates.class);
-        final GateSpec gateSpec = Mockito.mock(GateSpec.class);
-        Mockito.when(gate.getGateSpec()).thenReturn(gateSpec);
-        Mockito.when(gateSpec.getDirection()).thenReturn(direction);
+    private Gate makeGateObj(final String scnValue, final Ipv4Address srcAddr, final ServiceFlowDirection direction,
+                              final Ipv4Address dstAddr) {
+        final Gate gate = mock(Gate.class);
+        final GateSpec gateSpec = mock(GateSpec.class);
+        when(gate.getGateSpec()).thenReturn(gateSpec);
+        when(gateSpec.getDirection()).thenReturn(direction);
         // TODO - make sure to write a test when this value is not null
-        Mockito.when(gateSpec.getDscpTosOverwrite()).thenReturn(null);
-        final TrafficProfile trafficProfile = Mockito.mock(TrafficProfile.class);
-        final ServiceClassName scn = Mockito.mock(ServiceClassName.class);
-        Mockito.when(scn.getValue()).thenReturn(scnValue);
-        Mockito.when(trafficProfile.getServiceClassName()).thenReturn(scn);
-        Mockito.when(gate.getTrafficProfile()).thenReturn(trafficProfile);
+        when(gateSpec.getDscpTosOverwrite()).thenReturn(null);
+
+        // TODO - refactor to add flowspec profile testing as well
+        final TrafficProfile trafficProfile = mock(TrafficProfile.class);
+        final ServiceClassNameChoice serviceClassNameChoice = mock(ServiceClassNameChoice.class);
+        final ServiceClassNameProfile serviceClassNameProfile = mock(ServiceClassNameProfile.class);
+        final ServiceClassName serviceClassName = mock(ServiceClassName.class);
+        when(serviceClassName.getValue()).thenReturn(scnValue);
+        when(serviceClassNameProfile.getServiceClassName()).thenReturn(serviceClassName);
+        when(serviceClassNameChoice.getServiceClassNameProfile()).thenReturn(serviceClassNameProfile);
+        when(trafficProfile.getTrafficProfileChoice()).thenReturn(serviceClassNameChoice);
+        when(gate.getTrafficProfile()).thenReturn(trafficProfile);
 
         // TODO - write tests when this is null and ExtClassifier or Ipv6Classifier objects are not null
-        final Classifier classifier = Mockito.mock(Classifier.class);
+        final Classifier classifier = mock(Classifier.class);
 
         // This is the address of the CM
-        Mockito.when(classifier.getDstIp()).thenReturn(dstAddr);
+        when(classifier.getDstIp()).thenReturn(dstAddr);
 
         final PortNumber dstPort = new PortNumber(4321);
-        Mockito.when(classifier.getDstPort()).thenReturn(dstPort);
+        when(classifier.getDstPort()).thenReturn(dstPort);
         final TpProtocol protocol = new TpProtocol(0);
-        Mockito.when(classifier.getProtocol()).thenReturn(protocol);
-        final Ipv4Address srcAddr = new Ipv4Address("127.0.0.1");
-        Mockito.when(classifier.getSrcIp()).thenReturn(srcAddr);
+        when(classifier.getProtocol()).thenReturn(protocol);
+        when(classifier.getSrcIp()).thenReturn(srcAddr);
         final PortNumber srcPort = new PortNumber(1234);
-        Mockito.when(classifier.getSrcPort()).thenReturn(srcPort);
-        final TosByte tosByte = new TosByte((short)160);
-        Mockito.when(classifier.getTosByte()).thenReturn(tosByte);
+        when(classifier.getSrcPort()).thenReturn(srcPort);
+
+        // TODO - Can this value be any other value than 0 or 1 (See TosByte enumeration)
+        final TosByte tosByte = new TosByte((short)0);
+        when(classifier.getTosByte()).thenReturn(tosByte);
         final TosByte tosMask = new TosByte((short)224);
-        Mockito.when(classifier.getTosMask()).thenReturn(tosMask);
+        when(classifier.getTosMask()).thenReturn(tosMask);
+
+        final QosClassifierChoice classifierChoice = mock(QosClassifierChoice.class);
+        when(classifierChoice.getClassifier()).thenReturn(classifier);
+
+        ClassifierContainer classifierContainer = mock(ClassifierContainer.class);
+        when(classifierContainer.getClassifierChoice()).thenReturn(classifierChoice);
+
+        final List<ClassifierContainer> containerList = Collections.singletonList(classifierContainer);
+
+        Classifiers classifiers = mock(Classifiers.class);
+        when(classifiers.getClassifierContainer()).thenReturn(containerList);
+
+        when(gate.getClassifiers()).thenReturn(classifiers);
 
-        // TODO - enhance to test support of the other classifier types
-        Mockito.when(gate.getClassifier()).thenReturn(classifier);
-        Mockito.when(gate.getExtClassifier()).thenReturn(null);
-        Mockito.when(gate.getIpv6Classifier()).thenReturn(null);
         return gate;
     }
 
-    private IPCMMGate makeGateRequest(final Ccaps ccap, final Gates gateReq, final InetAddress addrSubId,
+    private IPCMMGate makeGateRequest(final Ccap ccap, final Gate gateReq, final InetAddress addrSubId,
                                      final ServiceFlowDirection direction) {
         final PCMMGateReqBuilder gateBuilder = new PCMMGateReqBuilder();
-        gateBuilder.build(ccap.getAmId());
-        gateBuilder.build(addrSubId);
+        gateBuilder.setAmId(ccap.getAmId());
+        gateBuilder.setSubscriberId(addrSubId);
         // force gateSpec.Direction to align with SCN direction
-        final ServiceClassName scn = gateReq.getTrafficProfile().getServiceClassName();
+        final ServiceClassName scn =
+            ((ServiceClassNameChoice)gateReq.getTrafficProfile().getTrafficProfileChoice()).getServiceClassNameProfile().getServiceClassName();
         if (scn != null) {
-            gateBuilder.build(gateReq.getGateSpec(), direction);
+            final GateSpecBuilder gateSpecBuilder = new GateSpecBuilder();
+            gateSpecBuilder.setDirection(direction);
+            gateSpecBuilder.setDscpTosMask(gateReq.getGateSpec().getDscpTosMask());
+            gateSpecBuilder.setDscpTosOverwrite(gateReq.getGateSpec().getDscpTosOverwrite());
+            gateSpecBuilder.setSessionClassId(gateReq.getGateSpec().getSessionClassId());
+            gateSpecBuilder.setInactivityTimer(gateReq.getGateSpec().getInactivityTimer());
+            final GateSpec gateSpec = gateSpecBuilder.build();
+            gateBuilder.setGateSpec(gateSpec);
         } else {
             // not an SCN gate
-            gateBuilder.build(gateReq.getGateSpec(), null);
-        }
-        gateBuilder.build(gateReq.getTrafficProfile());
-
-        // pick a classifier type (only one for now)
-        if (gateReq.getClassifier() != null) {
-            gateBuilder.build(gateReq.getClassifier());
-        } else if (gateReq.getExtClassifier() != null) {
-            gateBuilder.build(gateReq.getExtClassifier());
-        } else if (gateReq.getIpv6Classifier() != null) {
-            gateBuilder.build(gateReq.getIpv6Classifier());
+            gateBuilder.setGateSpec(gateReq.getGateSpec());
         }
+        gateBuilder.setTrafficProfile(gateReq.getTrafficProfile());
+
+        gateBuilder.setClassifiers(gateReq.getClassifiers().getClassifierContainer());
+
         // assemble the final gate request
-        return gateBuilder.getGateReq();
+        return gateBuilder.build();
     }
 
     private class MockSocket extends Socket {