Add Route Servlet and Log Servlet Tests

Change-Id: Iaf62fd4ccedddac1ec664465c0ccc851c66b8c0b
Issue-ID: DMAAP-101
Signed-off-by: Kyle Stewart <kyle.stewart@ericsson.com>

7 files changed, 974 insertions, 67 deletions

diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/BaseServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/BaseServletTest.java
index 757852aa..61d030d9 100644..100755
--- a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/BaseServletTest.java
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/BaseServletTest.java
@@ -28,18 +28,27 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
+import org.onap.dmaap.datarouter.provisioning.beans.Feed;
+import org.onap.dmaap.datarouter.provisioning.beans.FeedAuthorization;
+import org.onap.dmaap.datarouter.provisioning.beans.Group;
+import org.onap.dmaap.datarouter.provisioning.beans.Subscription;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
+import org.powermock.modules.junit4.PowerMockRunner;
 import javax.servlet.http.HttpServletRequest;
 import java.util.HashSet;
 import java.util.Set;
-
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.nullValue;
 import static org.junit.Assert.assertThat;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@SuppressStaticInitializationFor({"org.onap.dmaap.datarouter.provisioning.beans.Feed",
+        "org.onap.dmaap.datarouter.provisioning.beans.Subscription",
+        "org.onap.dmaap.datarouter.provisioning.beans.Group"})
 public class BaseServletTest extends DrServletTestBase {
 
     private BaseServlet baseServlet;
@@ -69,14 +78,118 @@ public class BaseServletTest extends DrServletTestBase {
     }
 
     @Test
-    public void Given_Request_Path_Info_Is_Not_Valid_Then_Minus_One_Is() throws Exception {
+    public void Given_Remote_Address_Is_Known_And_RequireCerts_Is_True() throws Exception {
         when(request.isSecure()).thenReturn(true);
         Set<String> authAddressesAndNetworks = new HashSet<String>();
         authAddressesAndNetworks.add(("127.0.0.1"));
-        FieldUtils
-            .writeDeclaredStaticField(BaseServlet.class, "authorizedAddressesAndNetworks", authAddressesAndNetworks,
-                true);
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "requireCert", false, true);
-        assertThat(baseServlet.isAuthorizedForProvisioning(request), is(nullValue()));
+        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "authorizedAddressesAndNetworks", authAddressesAndNetworks, true);
+        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "requireCert", true, true);
+        assertThat(baseServlet.isAuthorizedForProvisioning(request), is("Client certificate is missing."));
+    }
+
+    @Test
+    public void Given_Request_Is_GetFeedOwner_And_Feed_Exists() throws Exception {
+        PowerMockito.mockStatic(Feed.class);
+        Feed feed = mock(Feed.class);
+        PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(feed);
+        when(feed.getPublisher()).thenReturn("stub_publisher");
+        assertThat(baseServlet.getFeedOwner("3"), is("stub_publisher"));
+    }
+
+    @Test
+    public void Given_Request_Is_GetFeedOwner_And_Feed_Does_Not_Exist() throws Exception {
+        PowerMockito.mockStatic(Feed.class);
+        PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(null);
+        assertThat(baseServlet.getFeedOwner("3"), is(nullValue()));
+    }
+
+    @Test
+    public void Given_Request_Is_GetFeedClassification_And_Feed_Exists() throws Exception {
+        PowerMockito.mockStatic(Feed.class);
+        Feed feed = mock(Feed.class);
+        PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(feed);
+        FeedAuthorization fAuth = mock(FeedAuthorization.class);
+        when(feed.getAuthorization()).thenReturn(fAuth);
+        when(fAuth.getClassification()).thenReturn("stub_classification");
+        assertThat(baseServlet.getFeedClassification("3"), is("stub_classification"));
+    }
+
+    @Test
+    public void Given_Request_Is_GetFeedClassification_And_Feed_Does_Not_Exist() throws Exception {
+        PowerMockito.mockStatic(Feed.class);
+        PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(null);
+        assertThat(baseServlet.getFeedClassification("3"), is(nullValue()));
+    }
+
+    @Test
+    public void Given_Request_Is_GetSubscriptionOwner_And_Subscription_Exists() throws Exception {
+        PowerMockito.mockStatic(Subscription.class);
+        Subscription subscription = mock(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(subscription);
+        when(subscription.getSubscriber()).thenReturn("stub_subscriber");
+        assertThat(baseServlet.getSubscriptionOwner("3"), is("stub_subscriber"));
+    }
+
+    @Test
+    public void Given_Request_Is_GetSubscriptionOwner_And_Subscription_Does_Not_Exist() throws Exception {
+        PowerMockito.mockStatic(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(null);
+        assertThat(baseServlet.getSubscriptionOwner("3"), is(nullValue()));
+    }
+
+    @Test
+    public void Given_Request_Is_GetGroupByFeedGroupId_And_User_Is_A_Member_Of_Group() throws Exception {
+        PowerMockito.mockStatic(Feed.class);
+        Feed feed = mock(Feed.class);
+        PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(feed);
+        when(feed.getGroupid()).thenReturn(3);
+        PowerMockito.mockStatic(Group.class);
+        Group group = mock(Group.class);
+        when(group.getMembers()).thenReturn("{id: stub_user}");
+        PowerMockito.when(Group.getGroupById(anyInt())).thenReturn(group);
+        when(group.getAuthid()).thenReturn("stub_authID");
+        assertThat(baseServlet.getGroupByFeedGroupId("stub_user", "3"), is("stub_authID"));
+    }
+
+    @Test
+    public void Given_Request_Is_GetGroupByFeedGroupId_And_User_Is_Not_A_Member_Of_Group() throws Exception {
+        PowerMockito.mockStatic(Feed.class);
+        Feed feed = mock(Feed.class);
+        PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(feed);
+        when(feed.getGroupid()).thenReturn(3);
+        PowerMockito.mockStatic(Group.class);
+        Group group = mock(Group.class);
+        when(group.getMembers()).thenReturn("{id: stub_otherUser}");
+        PowerMockito.when(Group.getGroupById(anyInt())).thenReturn(group);
+        when(group.getAuthid()).thenReturn("stub_authID");
+        assertThat(baseServlet.getGroupByFeedGroupId("stub_user", "3"), is(nullValue()));
+    }
+
+    @Test
+    public void Given_Request_Is_GetGroupBySubGroupId_And_User_Is_A_Member_Of_Group() throws Exception {
+        PowerMockito.mockStatic(Subscription.class);
+        Subscription subscription = mock(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(subscription);
+        when(subscription.getGroupid()).thenReturn(3);
+        PowerMockito.mockStatic(Group.class);
+        Group group = mock(Group.class);
+        when(group.getMembers()).thenReturn("{id: stub_user}");
+        PowerMockito.when(Group.getGroupById(anyInt())).thenReturn(group);
+        when(group.getAuthid()).thenReturn("stub_authID");
+        assertThat(baseServlet.getGroupBySubGroupId("stub_user", "3"), is("stub_authID"));
+    }
+
+    @Test
+    public void Given_Request_Is_GetGroupBySubGroupId_And_User_Is_Not_A_Member_Of_Group() throws Exception {
+        PowerMockito.mockStatic(Subscription.class);
+        Subscription subscription = mock(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(subscription);
+        when(subscription.getGroupid()).thenReturn(3);
+        PowerMockito.mockStatic(Group.class);
+        Group group = mock(Group.class);
+        when(group.getMembers()).thenReturn("{id: stub_otherUser}");
+        PowerMockito.when(Group.getGroupById(anyInt())).thenReturn(group);
+        when(group.getAuthid()).thenReturn("stub_authID");
+        assertThat(baseServlet.getGroupBySubGroupId("stub_user", "3"), is(nullValue()));
     }
 }
diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/DRFeedsServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/DRFeedsServletTest.java
index 206ce912..35bc85d8 100644
--- a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/DRFeedsServletTest.java
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/DRFeedsServletTest.java
@@ -1,4 +1,3 @@
-
 /*******************************************************************************
  * ============LICENSE_START==================================================
  * * org.onap.dmaap
@@ -213,7 +212,7 @@ public class DRFeedsServletTest extends DrServletTestBase {
                 return jo;
             }
         };
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxFeeds", 10, true);
+
         drfeedsServlet.doPost(request, response);
         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
     }
@@ -231,7 +230,6 @@ public class DRFeedsServletTest extends DrServletTestBase {
                 return jo;
             }
         };
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxFeeds", 10, true);
         drfeedsServlet.doPost(request, response);
         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
     }
@@ -253,7 +251,6 @@ public class DRFeedsServletTest extends DrServletTestBase {
                 return false;
             }
         };
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxFeeds", 10, true);
         drfeedsServlet.doPost(request, response);
         verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
     }
@@ -263,7 +260,6 @@ public class DRFeedsServletTest extends DrServletTestBase {
     public void Given_Request_Is_HTTP_POST_And_Change_On_Feeds_Succeeds_A_STATUS_OK_Response_Is_Generated() throws Exception {
         ServletOutputStream outStream = mock(ServletOutputStream.class);
         when(response.getOutputStream()).thenReturn(outStream);
-
         JSONObject JSObject = buildRequestJsonObject();
         DRFeedsServlet drfeedsServlet = new DRFeedsServlet() {
             protected JSONObject getJSONfromInput(HttpServletRequest req) {
@@ -279,7 +275,6 @@ public class DRFeedsServletTest extends DrServletTestBase {
                 return true;
             }
         };
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxFeeds", 10, true);
         drfeedsServlet.doPost(request, response);
         verify(response).setStatus(eq(HttpServletResponse.SC_CREATED));
     }
@@ -302,22 +297,13 @@ public class DRFeedsServletTest extends DrServletTestBase {
         return JSObject;
     }
 
-
-
-    private void initialiseBaseServletToBypassRetreiviingInitialisationParametersFromDatabase() throws IllegalAccessException {
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "startmsgFlag", false, true);
-        SynchronizerTask synchronizerTask = mock(SynchronizerTask.class);
-        when(synchronizerTask.getState()).thenReturn(SynchronizerTask.UNKNOWN);
-        FieldUtils.writeDeclaredStaticField(SynchronizerTask.class, "synctask", synchronizerTask, true);
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "max_feeds", 10, true);
-    }
-
     private void setUpValidSecurityOnHttpRequest() throws Exception {
         when(request.isSecure()).thenReturn(true);
         Set<String> authAddressesAndNetworks = new HashSet<String>();
         authAddressesAndNetworks.add(("127.0.0.1"));
         FieldUtils.writeDeclaredStaticField(BaseServlet.class, "authorizedAddressesAndNetworks", authAddressesAndNetworks, true);
         FieldUtils.writeDeclaredStaticField(BaseServlet.class, "requireCert", false, true);
+        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxFeeds", 100, true);
     }
 
     private void setBehalfHeader(String headerValue) {
@@ -380,5 +366,4 @@ public class DRFeedsServletTest extends DrServletTestBase {
         when(request.getHeader("X-ATT-DR-ON-BEHALF-OF-GROUP")).thenReturn("stub_subjectGroup");
 
     }
-
-}
\ No newline at end of file
+}
diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/FeedServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/FeedServletTest.java
index d65b1f97..f5302cb9 100644..100755
--- a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/FeedServletTest.java
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/FeedServletTest.java
@@ -23,6 +23,8 @@
 package org.onap.dmaap.datarouter.provisioning;
 
 import org.apache.commons.lang3.reflect.FieldUtils;
+import org.jetbrains.annotations.NotNull;
+import org.json.JSONArray;
 import org.json.JSONObject;
 import org.junit.Before;
 import org.junit.Test;
@@ -67,6 +69,7 @@ public class FeedServletTest extends DrServletTestBase {
         setPokerToNotCreateTimersWhenDeleteFeedIsCalled();
         setUpValidAuthorisedRequest();
         setUpValidSecurityOnHttpRequest();
+        setUpValidContentHeadersAndJSONOnHttpRequest();
     }
 
     @Test
@@ -230,6 +233,7 @@ public class FeedServletTest extends DrServletTestBase {
     @Test
     public void Given_Request_Is_HTTP_PUT_And_Content_Header_Is_Not_Supported_Type_Then_Unsupported_Media_Type_Response_Is_Generated()
         throws Exception {
+        when(request.getHeader("Content-Type")).thenReturn("application/vnd.att-dr.feed-fail; version=2.0");
         when(request.getContentType()).thenReturn("stub_contentType");
         feedServlet.doPut(request, response);
         verify(response)
@@ -239,13 +243,161 @@ public class FeedServletTest extends DrServletTestBase {
     @Test
     public void Given_Request_Is_HTTP_PUT_And_Request_Contains_Badly_Formed_JSON_Then_Bad_Request_Response_Is_Generated()
         throws Exception {
-        when(request.getHeader("Content-Type")).thenReturn("application/vnd.att-dr.feed; version=1.0");
         ServletInputStream inStream = mock(ServletInputStream.class);
         when(request.getInputStream()).thenReturn(inStream);
         feedServlet.doPut(request, response);
         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
     }
 
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Request_Contains_Invalid_JSON_Then_Bad_Request_Response_Is_Generated() throws Exception {
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                return new JSONObject();
+            }
+        };
+        feedServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Feed_Change_Is_Not_Publisher_Who_Requested_Feed_Bad_Request_Response_Is_Generated() throws Exception {
+        when(request.getHeader("X-ATT-DR-ON-BEHALF-OF-GROUP")).thenReturn(null);
+        JSONObject JSObject = buildRequestJsonObject();
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                JSONObject jo = new JSONObject();
+                jo.put("name", "stub_name");
+                jo.put("version", "1.0");
+                jo.put("authorization", JSObject);
+                return jo;
+            }
+        };
+
+        feedServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Feed_Name_Change_is_Requested_Bad_Request_Response_Is_Generated() throws Exception {
+        JSONObject JSObject = buildRequestJsonObject();
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                JSONObject jo = new JSONObject();
+                jo.put("name", "not_stub_name");
+                jo.put("version", "1.0");
+                jo.put("authorization", JSObject);
+                return jo;
+            }
+        };
+        feedServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Feed_Version_Change_is_Requested_Bad_Request_Response_Is_Generated() throws Exception {
+        JSONObject JSObject = buildRequestJsonObject();
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                JSONObject jo = new JSONObject();
+                jo.put("name", "stub_name");
+                jo.put("version", "2.0");
+                jo.put("authorization", JSObject);
+                return jo;
+            }
+        };
+        feedServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Request_Is_Not_Authorized_Then_Forbidden_Response_Is_Generated() throws Exception {
+        JSONObject JSObject = buildRequestJsonObject();
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                JSONObject jo = new JSONObject();
+                jo.put("name", "stub_name");
+                jo.put("version", "1.0");
+                jo.put("authorization", JSObject);
+                return jo;
+            }
+        };
+        setAuthoriserToReturnRequestNotAuthorized();
+        feedServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Change_On_Feeds_Fails_A_STATUS_OK_Response_Is_Generated() throws Exception {
+        ServletOutputStream outStream = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(outStream);
+
+        JSONObject JSObject = buildRequestJsonObject();
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                JSONObject jo = new JSONObject();
+                jo.put("name", "stub_name");
+                jo.put("version", "1.0");
+                jo.put("authorization", JSObject);
+                return jo;
+            }
+
+            @Override
+            protected boolean doUpdate(Updateable bean) {
+                return false;
+            }
+        };
+        feedServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Change_On_Feeds_Suceeds_A_STATUS_OK_Response_Is_Generated() throws Exception {
+        ServletOutputStream outStream = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(outStream);
+        JSONObject JSObject = buildRequestJsonObject();
+        FeedServlet feedServlet = new FeedServlet() {
+            protected JSONObject getJSONfromInput(HttpServletRequest req) {
+                JSONObject jo = new JSONObject();
+                jo.put("name", "stub_name");
+                jo.put("version", "1.0");
+                jo.put("authorization", JSObject);
+                return jo;
+            }
+
+            @Override
+            protected boolean doUpdate(Updateable bean) {
+                return true;
+            }
+        };
+        feedServlet.doPut(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_SC_METHOD_NOT_ALLOWED_Response_Is_Generated() throws Exception {
+        feedServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_METHOD_NOT_ALLOWED), argThat(notNullValue(String.class)));
+    }
+
+    @NotNull
+    private JSONObject buildRequestJsonObject() {
+        JSONObject JSObject = new JSONObject();
+        JSONArray endpointIDs = new JSONArray();
+        JSONObject JOEndpointIDs = new JSONObject();
+        JOEndpointIDs.put("id", "stub_endpoint_id");
+        JOEndpointIDs.put("password", "stub_endpoint_password");
+        endpointIDs.put(JOEndpointIDs);
+
+        JSONArray endpointAddresses = new JSONArray();
+        endpointAddresses.put("127.0.0.1");
+
+        JSObject.put("classification", "stub_classification");
+        JSObject.put("endpoint_ids", endpointIDs);
+        JSObject.put("endpoint_addrs", endpointAddresses);
+        return JSObject;
+    }
+
     private void setUpValidSecurityOnHttpRequest() throws Exception {
         when(request.isSecure()).thenReturn(true);
         Set<String> authAddressesAndNetworks = new HashSet<String>();
@@ -275,6 +427,10 @@ public class FeedServletTest extends DrServletTestBase {
         PowerMockito.when(Feed.getFeedById(anyInt())).thenReturn(feed);
         when(feed.isDeleted()).thenReturn(false);
         when(feed.asJSONObject(true)).thenReturn(mock(JSONObject.class));
+        when(feed.getPublisher()).thenReturn("Stub_Value");
+        when(feed.getName()).thenReturn("stub_name");
+        when(feed.getVersion()).thenReturn("1.0");
+        when(feed.asLimitedJSONObject()).thenReturn(mock(JSONObject.class));
     }
 
     private void setAuthoriserToReturnRequestNotAuthorized() throws IllegalAccessException {
@@ -304,4 +460,9 @@ public class FeedServletTest extends DrServletTestBase {
         setValidPathInfoInHttpHeader();
         setFeedToReturnValidFeedForSuppliedId();
     }
+
+    private void setUpValidContentHeadersAndJSONOnHttpRequest() {
+        when(request.getHeader("Content-Type")).thenReturn("application/vnd.att-dr.feed; version=1.0");
+        when(request.getHeader("X-ATT-DR-ON-BEHALF-OF-GROUP")).thenReturn("stub_subjectGroup");
+    }
 }
\ No newline at end of file
diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/LogServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/LogServletTest.java
new file mode 100755
index 00000000..9a550593
--- /dev/null
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/LogServletTest.java
@@ -0,0 +1,226 @@
+/*******************************************************************************
+ * ============LICENSE_START==================================================
+ * * org.onap.dmaap
+ * * ===========================================================================
+ * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+ * * ===========================================================================
+ * * 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.
+ * * ============LICENSE_END====================================================
+ * *
+ * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
+ * *
+ ******************************************************************************/
+package org.onap.dmaap.datarouter.provisioning;
+
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.onap.dmaap.datarouter.provisioning.beans.Subscription;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+@RunWith(PowerMockRunner.class)
+@SuppressStaticInitializationFor({"org.onap.dmaap.datarouter.provisioning.beans.Subscription"})
+public class LogServletTest extends DrServletTestBase {
+
+    private static LogServlet logServlet;
+
+    @Mock
+    private HttpServletRequest request;
+    @Mock
+    private HttpServletResponse response;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        logServlet = new LogServlet(true);
+        setUpValidParameterValuesForMap();
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Is_Not_Allowed_Then_Forbidden_Response_Is_Generated()
+            throws Exception {
+        logServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_METHOD_NOT_ALLOWED), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_FeedID_Is_Invalid_Then_Bad_Request_Response_Is_Generated()
+            throws Exception {
+        when(request.getPathInfo()).thenReturn(null);
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Has_Bad_Type()
+            throws Exception {
+        when(request.getParameter("type")).thenReturn("bad_type");
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Has_Bad_PublishID()
+            throws Exception {
+        when(request.getParameter("publishId")).thenReturn("bad_PublishID'");
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Has_Bad_StatusCode()
+            throws Exception {
+        when(request.getParameter("statusCode")).thenReturn("1'");
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Has_Bad_ExpiryReason()
+            throws Exception {
+        when(request.getParameter("expiryReason")).thenReturn("bad_ExpiryReason");
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Has_Bad_Start()
+            throws Exception {
+        when(request.getParameter("start")).thenReturn("bad_startTime");
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Has_Bad_End()
+            throws Exception {
+        when(request.getParameter("end")).thenReturn("bad_endTime");
+        logServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Is_FeedLog()
+            throws Exception {
+        logServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Is_Not_FeedLog()
+            throws Exception {
+        LogServlet logServletNotFeedlog = new LogServlet(false);
+        PowerMockito.mockStatic(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(mock(Subscription.class));
+        logServletNotFeedlog.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Is_Not_Allowed_Then_Forbidden_Response_Is_Generated()
+            throws Exception {
+        logServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_METHOD_NOT_ALLOWED), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Is_Not_Allowed_Then_Forbidden_Response_Is_Generated()
+            throws Exception {
+        logServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_METHOD_NOT_ALLOWED), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_GetPublishRecordsForFeed_And_Type_Is_Publish()
+            throws Exception {
+        when(request.getParameter("type")).thenReturn("pub");
+        when(request.getParameter("expiryReason")).thenReturn(null);
+        logServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_getDeliveryRecordsForFeed_And_Type_Is_Delivery()
+            throws Exception {
+        when(request.getParameter("type")).thenReturn("del");
+        when(request.getParameter("expiryReason")).thenReturn(null);
+        logServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_getExpiryRecordsForFeed_And_Type_Is_Expire()
+            throws Exception {
+        when(request.getParameter("type")).thenReturn("exp");
+        when(request.getParameter("statusCode")).thenReturn(null);
+        when(request.getParameter("expiryReason")).thenReturn(null);
+        ServletOutputStream s = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(s);
+        logServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_getDeliveryRecordsForSubscription_And_Type_Is_Delivery()
+            throws Exception {
+        LogServlet logServletNotFeedlog = new LogServlet(false);
+        when(request.getParameter("type")).thenReturn("del");
+        when(request.getParameter("statusCode")).thenReturn(null);
+        when(request.getParameter("expiryReason")).thenReturn(null);
+        PowerMockito.mockStatic(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(mock(Subscription.class));
+        logServletNotFeedlog.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_getExpiryRecordsForSubscription_And_Type_Is_Expiry()
+            throws Exception {
+        LogServlet logServletNotFeedlog = new LogServlet(false);
+        when(request.getParameter("type")).thenReturn("exp");
+        when(request.getParameter("statusCode")).thenReturn(null);
+        when(request.getParameter("expiryReason")).thenReturn(null);
+        PowerMockito.mockStatic(Subscription.class);
+        PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(mock(Subscription.class));
+        logServletNotFeedlog.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    private void setUpValidParameterValuesForMap() throws Exception {
+        when(request.getPathInfo()).thenReturn("123");
+        when(request.getParameter("type")).thenReturn("exp");
+        when(request.getParameter("publishId")).thenReturn("bad_PublishID");
+        when(request.getParameter("statusCode")).thenReturn("-1");
+        when(request.getParameter("expiryReason")).thenReturn("other");
+        when(request.getParameter("start")).thenReturn(null);
+        when(request.getParameter("end")).thenReturn(null);
+        ServletOutputStream s = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(s);
+    }
+}
\ No newline at end of file
diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/RouteServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/RouteServletTest.java
new file mode 100755
index 00000000..63715804
--- /dev/null
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/RouteServletTest.java
@@ -0,0 +1,450 @@
+/*******************************************************************************
+ * ============LICENSE_START==================================================
+ * * org.onap.dmaap
+ * * ===========================================================================
+ * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+ * * ===========================================================================
+ * * 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.
+ * * ============LICENSE_END====================================================
+ * *
+ * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
+ * *
+ ******************************************************************************/
+
+package org.onap.dmaap.datarouter.provisioning;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.json.JSONObject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.onap.dmaap.datarouter.provisioning.beans.*;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
+import org.powermock.modules.junit4.PowerMockRunner;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(PowerMockRunner.class)
+@SuppressStaticInitializationFor({"org.onap.dmaap.datarouter.provisioning.beans.IngressRoute",
+        "org.onap.dmaap.datarouter.provisioning.beans.EgressRoute",
+        "org.onap.dmaap.datarouter.provisioning.beans.NodeClass",
+        "org.onap.dmaap.datarouter.provisioning.beans.NetworkRoute"})
+public class RouteServletTest extends DrServletTestBase
+{
+    private RouteServlet routeServlet;
+
+    @Mock
+    private HttpServletRequest request;
+
+    @Mock
+    private HttpServletResponse response;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        setPokerToNotCreateTimersWhenDeleteFeedIsCalled();
+        setRouteToReturnValid();
+        routeServlet = new RouteServlet();
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Is_Not_Authorized() throws Exception {
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Ingress_Route_Does_Not_Exist_In_Path() throws Exception {
+        when(request.getPathInfo()).thenReturn("/ingress/3/internal/route/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Ingress_Path_Contains_Invalid_FeedID() throws Exception {
+        when(request.getPathInfo()).thenReturn("/ingress/feedID/internal/route/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Ingress_Path_Contains_Invalid_Sequence_Number() throws Exception {
+        when(request.getPathInfo()).thenReturn("/ingress/feedID/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Ingress_Path_Contains_Invalid_Number_Of_Arguments() throws Exception {
+        when(request.getPathInfo()).thenReturn("/ingress/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Egress_Route_Does_Not_Exist_In_Path() throws Exception {
+        when(request.getPathInfo()).thenReturn("/egress/3");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Egress_Path_Contains_Invalid_SubID() throws Exception {
+        when(request.getPathInfo()).thenReturn("/egress/subID");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Egress_Path_Contains_Invalid_Number_Of_Arguments() throws Exception {
+        when(request.getPathInfo()).thenReturn("/egress/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Network_Path_Contains_Invalid_Number_Of_Arguments() throws Exception {
+        when(request.getPathInfo()).thenReturn("/network/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Deletable_Is_Null() throws Exception {
+        when(request.getPathInfo()).thenReturn("/route/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+
+            @Override
+            protected boolean doDelete(Deleteable bean) {
+                return true;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_DELETE_And_Fails() throws Exception {
+        when(request.getPathInfo()).thenReturn("/network/subID/route");
+        PowerMockito.mockStatic(NodeClass.class);
+        PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+
+            @Override
+            protected boolean doDelete(Deleteable bean) {
+                return false;
+            }
+        };
+        routeServlet.doDelete(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Is_Not_Authorized() throws Exception {
+        routeServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Path_Does_Not_Start_With_Valid_Route() throws Exception {
+        when(request.getPathInfo()).thenReturn("/route/");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doGet(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Path_Equals_Ingress_And_Get_Succeeds() throws Exception {
+        when(request.getPathInfo()).thenReturn("/ingress/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        ServletOutputStream outStream = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(outStream);
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Path_Equals_Egress_And_Get_Succeeds() throws Exception {
+        when(request.getPathInfo()).thenReturn("/egress/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        ServletOutputStream outStream = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(outStream);
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_GET_And_Ingress_Path_Equals_Network_And_Get_Succeeds() throws Exception {
+        when(request.getPathInfo()).thenReturn("/network/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        ServletOutputStream outStream = mock(ServletOutputStream.class);
+        when(response.getOutputStream()).thenReturn(outStream);
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doGet(request, response);
+        verify(response).setStatus(eq(HttpServletResponse.SC_OK));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Is_Not_Authorized() throws Exception {
+        routeServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_PUT_And_Contains_Bad_URL() throws Exception {
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPut(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Is_Not_Authorized() throws Exception {
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Ingress_Path_Starts_With_Ingress_And_Contains_Invalid_Arguments() throws Exception {
+        when(request.getPathInfo()).thenReturn("/ingress/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        when(request.getParameter("feed")).thenReturn("3");
+        when(request.getParameter("user")).thenReturn(null);
+        when(request.getParameter("subnet")).thenReturn(null);
+        when(request.getParameter("nodepatt")).thenReturn(null);
+        when(request.getParameter("seq")).thenReturn(null);
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Egress_And_EgressRoute_Already_Exists() throws Exception {
+        when(request.getPathInfo()).thenReturn("/egress/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        when(request.getParameter("sub")).thenReturn("3");
+        EgressRoute e = mock(EgressRoute.class);
+        PowerMockito.when(EgressRoute.getEgressRoute(anyInt())).thenReturn(e);
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Egress_And_Contains_Invalid_Arguments() throws Exception {
+        when(request.getPathInfo()).thenReturn("/egress/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        when(request.getParameter("sub")).thenReturn("3");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Network_And_Is_Missing_Arguments() throws Exception {
+        when(request.getPathInfo()).thenReturn("/network/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Network_And_Route_Already_Exists() throws Exception {
+        when(request.getPathInfo()).thenReturn("/network/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        when(request.getParameter("from")).thenReturn("stub_from");
+        when(request.getParameter("to")).thenReturn("stub_to");
+        when(request.getParameter("via")).thenReturn("stub_via");
+        PowerMockito.mockStatic(NodeClass.class);
+        PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
+        SortedSet<NetworkRoute> networkSet = new TreeSet();
+        networkSet.add(mock(NetworkRoute.class));
+        PowerMockito.when(NetworkRoute.getAllNetworkRoutes()).thenReturn(networkSet);
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Path_URL_Is_Null() throws Exception {
+        when(request.getPathInfo()).thenReturn("/route/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        when(request.getParameter("from")).thenReturn("stub_from");
+        when(request.getParameter("to")).thenReturn("stub_to");
+        when(request.getParameter("via")).thenReturn("stub_via");
+        PowerMockito.mockStatic(NodeClass.class);
+        PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
+    }
+
+    @Test
+    public void Given_Request_Is_HTTP_POST_And_Fails() throws Exception {
+        when(request.getPathInfo()).thenReturn("/network/");
+        when(request.getRemoteAddr()).thenReturn("stub_addr");
+        when(request.getParameter("from")).thenReturn("stub_from");
+        when(request.getParameter("to")).thenReturn("stub_to");
+        when(request.getParameter("via")).thenReturn("stub_via");
+        PowerMockito.mockStatic(NodeClass.class);
+        PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
+        RouteServlet routeServlet = new RouteServlet() {
+            protected boolean isAuthorizedForInternal(HttpServletRequest req) {
+                return true;
+            }
+
+            @Override
+            protected boolean doInsert(Insertable bean) {
+                return false;
+            }
+        };
+        routeServlet.doPost(request, response);
+        verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
+    }
+
+    private void setRouteToReturnValid() throws IllegalAccessException {
+        PowerMockito.mockStatic(IngressRoute.class);
+        PowerMockito.when(IngressRoute.getIngressRoute(anyInt(), anyString(), anyString())).thenReturn(null);
+        SortedSet<IngressRoute> ingressSet = new TreeSet();
+        IngressRoute ingressRoute = mock(IngressRoute.class);
+        JSONObject joIngress = mock(JSONObject.class);
+        when(joIngress.toString()).thenReturn("{}");
+        when(ingressRoute.asJSONObject()).thenReturn(joIngress);
+        ingressSet.add(ingressRoute);
+        PowerMockito.when(IngressRoute.getAllIngressRoutes()).thenReturn(ingressSet);
+
+        PowerMockito.mockStatic(EgressRoute.class);
+        PowerMockito.when(EgressRoute.getEgressRoute(anyInt())).thenReturn(null);
+        SortedSet<EgressRoute> egressSet = new TreeSet();
+        EgressRoute egressRoute = mock(EgressRoute.class);
+        JSONObject joEgress = mock(JSONObject.class);
+        when(joEgress.toString()).thenReturn("{}");
+        when(egressRoute.asJSONObject()).thenReturn(joEgress);
+        egressSet.add(egressRoute);
+        PowerMockito.when(EgressRoute.getAllEgressRoutes()).thenReturn(egressSet);
+
+        PowerMockito.mockStatic(NetworkRoute.class);
+        SortedSet<NetworkRoute> networkSet = new TreeSet();
+        PowerMockito.when(NetworkRoute.getAllNetworkRoutes()).thenReturn(networkSet);
+
+    }
+
+    private void setPokerToNotCreateTimersWhenDeleteFeedIsCalled() throws Exception {
+        Poker poker = mock(Poker.class);
+        FieldUtils.writeDeclaredStaticField(Poker.class, "poker", poker, true);
+    }
+}
diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscribeServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscribeServletTest.java
index 2d89b5ea..c663451b 100644
--- a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscribeServletTest.java
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscribeServletTest.java
@@ -24,7 +24,6 @@ package org.onap.dmaap.datarouter.provisioning;
 
 import org.apache.commons.lang3.reflect.FieldUtils;
 import org.jetbrains.annotations.NotNull;
-import org.json.JSONArray;
 import org.json.JSONObject;
 import org.junit.Before;
 import org.junit.Test;
@@ -54,7 +53,7 @@ import static org.onap.dmaap.datarouter.provisioning.BaseServlet.BEHALF_HEADER;
 
 @RunWith(PowerMockRunner.class)
 @SuppressStaticInitializationFor({"org.onap.dmaap.datarouter.provisioning.beans.Feed", "org.onap.dmaap.datarouter.provisioning.beans.Subscription"})
-public class SubscribeServletTest extends DrServletTestBase{
+public class SubscribeServletTest extends DrServletTestBase {
     private static SubscribeServlet subscribeServlet;
 
     @Mock
@@ -211,6 +210,7 @@ public class SubscribeServletTest extends DrServletTestBase{
                 jo.put("metadataOnly", true);
                 jo.put("suspend", true);
                 jo.put("delivery", JSObject);
+                jo.put("sync", false);
                 return jo;
             }
 
@@ -219,7 +219,6 @@ public class SubscribeServletTest extends DrServletTestBase{
                 return false;
             }
         };
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxSubs", 10, true);
         subscribeServlet.doPost(request, response);
         verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
     }
@@ -240,6 +239,7 @@ public class SubscribeServletTest extends DrServletTestBase{
                 jo.put("metadataOnly", true);
                 jo.put("suspend", true);
                 jo.put("delivery", JSObject);
+                jo.put("sync", true);
                 return jo;
             }
 
@@ -248,7 +248,6 @@ public class SubscribeServletTest extends DrServletTestBase{
                 return true;
             }
         };
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxSubs", 10, true);
         subscribeServlet.doPost(request, response);
         verify(response).setStatus(eq(HttpServletResponse.SC_CREATED));
     }
@@ -257,18 +256,6 @@ public class SubscribeServletTest extends DrServletTestBase{
     @NotNull
     private JSONObject buildRequestJsonObject() {
         JSONObject JSObject = new JSONObject();
-        JSONArray endpointIDs = new JSONArray();
-        JSONObject JOEndpointIDs = new JSONObject();
-        JOEndpointIDs.put("id", "stub_endpoint_id");
-        JOEndpointIDs.put("password", "stub_endpoint_password");
-        endpointIDs.put(JOEndpointIDs);
-
-        JSONArray endpointAddresses = new JSONArray();
-        endpointAddresses.put("127.0.0.1");
-
-        JSObject.put("classification", "stub_classification");
-        JSObject.put("endpoint_ids", endpointIDs);
-        JSObject.put("endpoint_addrs", endpointAddresses);
         JSObject.put("url", "https://stub_address");
         JSObject.put("use100", "true");
         JSObject.put("password", "stub_password");
@@ -276,22 +263,13 @@ public class SubscribeServletTest extends DrServletTestBase{
         return JSObject;
     }
 
-
-
-    private void initialiseBaseServletToBypassRetreiviingInitialisationParametersFromDatabase() throws IllegalAccessException {
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "startmsgFlag", false, true);
-        SynchronizerTask synchronizerTask = mock(SynchronizerTask.class);
-        when(synchronizerTask.getState()).thenReturn(SynchronizerTask.UNKNOWN);
-        FieldUtils.writeDeclaredStaticField(SynchronizerTask.class, "synctask", synchronizerTask, true);
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "max_subs", 10, true);
-    }
-
     private void setUpValidSecurityOnHttpRequest() throws Exception {
         when(request.isSecure()).thenReturn(true);
         Set<String> authAddressesAndNetworks = new HashSet<String>();
         authAddressesAndNetworks.add(("127.0.0.1"));
         FieldUtils.writeDeclaredStaticField(BaseServlet.class, "authorizedAddressesAndNetworks", authAddressesAndNetworks, true);
         FieldUtils.writeDeclaredStaticField(BaseServlet.class, "requireCert", false, true);
+        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxSubs", 1, true);
     }
 
     private void setBehalfHeader(String headerValue) {
@@ -352,5 +330,4 @@ public class SubscribeServletTest extends DrServletTestBase{
         when(request.getHeader("X-ATT-DR-ON-BEHALF-OF-GROUP")).thenReturn("stub_subjectGroup");
 
     }
-
-}
\ No newline at end of file
+}
diff --git a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscriptionServletTest.java b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscriptionServletTest.java
index a0514a69..b42e3a76 100644
--- a/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscriptionServletTest.java
+++ b/datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/SubscriptionServletTest.java
@@ -24,7 +24,6 @@ package org.onap.dmaap.datarouter.provisioning;
 
 import org.apache.commons.lang3.reflect.FieldUtils;
 import org.jetbrains.annotations.NotNull;
-import org.json.JSONArray;
 import org.json.JSONObject;
 import org.junit.Before;
 import org.junit.Test;
@@ -33,7 +32,6 @@ import org.mockito.Mock;
 import org.onap.dmaap.datarouter.authz.AuthorizationResponse;
 import org.onap.dmaap.datarouter.authz.Authorizer;
 import org.onap.dmaap.datarouter.provisioning.beans.Deleteable;
-import org.onap.dmaap.datarouter.provisioning.beans.Insertable;
 import org.onap.dmaap.datarouter.provisioning.beans.Subscription;
 import org.onap.dmaap.datarouter.provisioning.beans.Updateable;
 import org.powermock.api.mockito.PowerMockito;
@@ -54,7 +52,7 @@ import static org.onap.dmaap.datarouter.provisioning.BaseServlet.BEHALF_HEADER;
 
 @RunWith(PowerMockRunner.class)
 @SuppressStaticInitializationFor("org.onap.dmaap.datarouter.provisioning.beans.Subscription")
-public class SubscriptionServletTest extends DrServletTestBase{
+public class SubscriptionServletTest extends DrServletTestBase {
     private SubscriptionServlet subscriptionServlet;
 
     @Mock
@@ -173,6 +171,7 @@ public class SubscriptionServletTest extends DrServletTestBase{
         jo.put("metadataOnly", true);
         jo.put("suspend", true);
         jo.put("delivery", JSObject);
+        jo.put("sync", true);
         Subscription sub = new Subscription(jo);
         PowerMockito.mockStatic(Subscription.class);
         PowerMockito.when(Subscription.getSubscriptionById(anyInt())).thenReturn(sub);
@@ -259,6 +258,7 @@ public class SubscriptionServletTest extends DrServletTestBase{
                 jo.put("metadataOnly", true);
                 jo.put("suspend", true);
                 jo.put("delivery", JSObject);
+                jo.put("sync", true);
                 return jo;
             }
         };
@@ -279,6 +279,7 @@ public class SubscriptionServletTest extends DrServletTestBase{
                 jo.put("metadataOnly", true);
                 jo.put("suspend", true);
                 jo.put("delivery", JSObject);
+                jo.put("sync", true);
                 return jo;
             }
 
@@ -306,6 +307,7 @@ public class SubscriptionServletTest extends DrServletTestBase{
                 jo.put("metadataOnly", true);
                 jo.put("suspend", true);
                 jo.put("delivery", JSObject);
+                jo.put("sync", true);
                 return jo;
             }
 
@@ -423,13 +425,6 @@ public class SubscriptionServletTest extends DrServletTestBase{
         return JSObject;
     }
 
-    private void initialiseBaseServletToBypassRetreiviingInitialisationParametersFromDatabase() throws IllegalAccessException {
-        FieldUtils.writeDeclaredStaticField(BaseServlet.class, "startmsgFlag", false, true);
-        SynchronizerTask synchronizerTask = mock(SynchronizerTask.class);
-        when(synchronizerTask.getState()).thenReturn(SynchronizerTask.UNKNOWN);
-        FieldUtils.writeDeclaredStaticField(SynchronizerTask.class, "synctask", synchronizerTask, true);
-    }
-
     private void setUpValidSecurityOnHttpRequest() throws Exception {
         when(request.isSecure()).thenReturn(true);
         Set<String> authAddressesAndNetworks = new HashSet<String>();