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;
}
@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()));
}
}
-
/*******************************************************************************
* ============LICENSE_START==================================================
* * org.onap.dmaap
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)));
}
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)));
}
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)));
}
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) {
return true;
}
};
- FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxFeeds", 10, true);
drfeedsServlet.doPost(request, response);
verify(response).setStatus(eq(HttpServletResponse.SC_CREATED));
}
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) {
when(request.getHeader("X-ATT-DR-ON-BEHALF-OF-GROUP")).thenReturn("stub_subjectGroup");
}
-
-}
\ No newline at end of file
+}
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;
setPokerToNotCreateTimersWhenDeleteFeedIsCalled();
setUpValidAuthorisedRequest();
setUpValidSecurityOnHttpRequest();
+ setUpValidContentHeadersAndJSONOnHttpRequest();
}
@Test
@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)
@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>();
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 {
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
--- /dev/null
+/*******************************************************************************
+ * ============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
--- /dev/null
+/*******************************************************************************
+ * ============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);
+ }
+}
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;
@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
jo.put("metadataOnly", true);
jo.put("suspend", true);
jo.put("delivery", JSObject);
+ jo.put("sync", false);
return jo;
}
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)));
}
jo.put("metadataOnly", true);
jo.put("suspend", true);
jo.put("delivery", JSObject);
+ jo.put("sync", true);
return jo;
}
return true;
}
};
- FieldUtils.writeDeclaredStaticField(BaseServlet.class, "maxSubs", 10, true);
subscribeServlet.doPost(request, response);
verify(response).setStatus(eq(HttpServletResponse.SC_CREATED));
}
@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");
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) {
when(request.getHeader("X-ATT-DR-ON-BEHALF-OF-GROUP")).thenReturn("stub_subjectGroup");
}
-
-}
\ No newline at end of file
+}
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;
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;
@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
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);
jo.put("metadataOnly", true);
jo.put("suspend", true);
jo.put("delivery", JSObject);
+ jo.put("sync", true);
return jo;
}
};
jo.put("metadataOnly", true);
jo.put("suspend", true);
jo.put("delivery", JSObject);
+ jo.put("sync", true);
return jo;
}
jo.put("metadataOnly", true);
jo.put("suspend", true);
jo.put("delivery", JSObject);
+ jo.put("sync", true);
return jo;
}
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>();
Code Review / dmaap / datarouter.git / commitdiff