datarouter-prov/src/test/java/org/onap/dmaap/datarouter/provisioning/RouteServletTest.java

   1 /*******************************************************************************
   2  * ============LICENSE_START==================================================
   3  * * org.onap.dmaap
   4  * * ===========================================================================
   5  * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * * ===========================================================================
   7  * * Licensed under the Apache License, Version 2.0 (the "License");
   8  * * you may not use this file except in compliance with the License.
   9  * * You may obtain a copy of the License at
  10  * *
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0
  12  * *
  13  *  * Unless required by applicable law or agreed to in writing, software
  14  * * distributed under the License is distributed on an "AS IS" BASIS,
  15  * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * * See the License for the specific language governing permissions and
  17  * * limitations under the License.
  18  * * ============LICENSE_END====================================================
  19  * *
  20  * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  * *
  22  ******************************************************************************/
  23
  24 package org.onap.dmaap.datarouter.provisioning;
  25
  26 import org.apache.commons.lang3.reflect.FieldUtils;
  27 import org.json.JSONObject;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.mockito.Mock;
  32 import org.onap.dmaap.datarouter.provisioning.beans.*;
  33 import org.powermock.api.mockito.PowerMockito;
  34 import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
  35 import org.powermock.modules.junit4.PowerMockRunner;
  36 import javax.servlet.ServletOutputStream;
  37 import javax.servlet.http.HttpServletRequest;
  38 import javax.servlet.http.HttpServletResponse;
  39 import java.util.SortedSet;
  40 import java.util.TreeSet;
  41 import static org.hamcrest.Matchers.notNullValue;
  42 import static org.mockito.Matchers.*;
  43 import static org.mockito.Mockito.mock;
  44 import static org.mockito.Mockito.verify;
  45 import static org.mockito.Mockito.when;
  46
  47 @RunWith(PowerMockRunner.class)
  48 @SuppressStaticInitializationFor({"org.onap.dmaap.datarouter.provisioning.beans.IngressRoute",
  49         "org.onap.dmaap.datarouter.provisioning.beans.EgressRoute",
  50         "org.onap.dmaap.datarouter.provisioning.beans.NodeClass",
  51         "org.onap.dmaap.datarouter.provisioning.beans.NetworkRoute"})
  52 public class RouteServletTest extends DrServletTestBase
  53 {
  54     private RouteServlet routeServlet;
  55
  56     @Mock
  57     private HttpServletRequest request;
  58
  59     @Mock
  60     private HttpServletResponse response;
  61
  62     @Before
  63     public void setUp() throws Exception {
  64         super.setUp();
  65         setPokerToNotCreateTimersWhenDeleteFeedIsCalled();
  66         setRouteToReturnValid();
  67         routeServlet = new RouteServlet();
  68     }
  69
  70     @Test
  71     public void Given_Request_Is_HTTP_DELETE_And_Is_Not_Authorized() throws Exception {
  72         routeServlet.doDelete(request, response);
  73         verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
  74     }
  75
  76     @Test
  77     public void Given_Request_Is_HTTP_DELETE_And_Ingress_Route_Does_Not_Exist_In_Path() throws Exception {
  78         when(request.getPathInfo()).thenReturn("/ingress/3/internal/route/");
  79         RouteServlet routeServlet = new RouteServlet() {
  80             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
  81                 return true;
  82             }
  83         };
  84         routeServlet.doDelete(request, response);
  85         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
  86     }
  87
  88     @Test
  89     public void Given_Request_Is_HTTP_DELETE_And_Ingress_Path_Contains_Invalid_FeedID() throws Exception {
  90         when(request.getPathInfo()).thenReturn("/ingress/feedID/internal/route/");
  91         RouteServlet routeServlet = new RouteServlet() {
  92             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
  93                 return true;
  94             }
  95         };
  96         routeServlet.doDelete(request, response);
  97         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
  98     }
  99
 100     @Test
 101     public void Given_Request_Is_HTTP_DELETE_And_Ingress_Path_Contains_Invalid_Sequence_Number() throws Exception {
 102         when(request.getPathInfo()).thenReturn("/ingress/feedID/");
 103         RouteServlet routeServlet = new RouteServlet() {
 104             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 105                 return true;
 106             }
 107         };
 108         routeServlet.doDelete(request, response);
 109         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 110     }
 111
 112     @Test
 113     public void Given_Request_Is_HTTP_DELETE_And_Ingress_Path_Contains_Invalid_Number_Of_Arguments() throws Exception {
 114         when(request.getPathInfo()).thenReturn("/ingress/");
 115         RouteServlet routeServlet = new RouteServlet() {
 116             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 117                 return true;
 118             }
 119         };
 120         routeServlet.doDelete(request, response);
 121         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 122     }
 123
 124     @Test
 125     public void Given_Request_Is_HTTP_DELETE_And_Egress_Route_Does_Not_Exist_In_Path() throws Exception {
 126         when(request.getPathInfo()).thenReturn("/egress/3");
 127         RouteServlet routeServlet = new RouteServlet() {
 128             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 129                 return true;
 130             }
 131         };
 132         routeServlet.doDelete(request, response);
 133         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 134     }
 135
 136     @Test
 137     public void Given_Request_Is_HTTP_DELETE_And_Egress_Path_Contains_Invalid_SubID() throws Exception {
 138         when(request.getPathInfo()).thenReturn("/egress/subID");
 139         RouteServlet routeServlet = new RouteServlet() {
 140             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 141                 return true;
 142             }
 143         };
 144         routeServlet.doDelete(request, response);
 145         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 146     }
 147
 148     @Test
 149     public void Given_Request_Is_HTTP_DELETE_And_Egress_Path_Contains_Invalid_Number_Of_Arguments() throws Exception {
 150         when(request.getPathInfo()).thenReturn("/egress/");
 151         RouteServlet routeServlet = new RouteServlet() {
 152             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 153                 return true;
 154             }
 155         };
 156         routeServlet.doDelete(request, response);
 157         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 158     }
 159
 160     @Test
 161     public void Given_Request_Is_HTTP_DELETE_And_Network_Path_Contains_Invalid_Number_Of_Arguments() throws Exception {
 162         when(request.getPathInfo()).thenReturn("/network/");
 163         RouteServlet routeServlet = new RouteServlet() {
 164             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 165                 return true;
 166             }
 167         };
 168         routeServlet.doDelete(request, response);
 169         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 170     }
 171
 172     @Test
 173     public void Given_Request_Is_HTTP_DELETE_And_Deletable_Is_Null() throws Exception {
 174         when(request.getPathInfo()).thenReturn("/route/");
 175         RouteServlet routeServlet = new RouteServlet() {
 176             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 177                 return true;
 178             }
 179
 180             @Override
 181             protected boolean doDelete(Deleteable bean) {
 182                 return true;
 183             }
 184         };
 185         routeServlet.doDelete(request, response);
 186         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 187     }
 188
 189     @Test
 190     public void Given_Request_Is_HTTP_DELETE_And_Fails() throws Exception {
 191         when(request.getPathInfo()).thenReturn("/network/subID/route");
 192         PowerMockito.mockStatic(NodeClass.class);
 193         PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
 194         RouteServlet routeServlet = new RouteServlet() {
 195             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 196                 return true;
 197             }
 198
 199             @Override
 200             protected boolean doDelete(Deleteable bean) {
 201                 return false;
 202             }
 203         };
 204         routeServlet.doDelete(request, response);
 205         verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
 206     }
 207
 208     @Test
 209     public void Given_Request_Is_HTTP_GET_And_Is_Not_Authorized() throws Exception {
 210         routeServlet.doGet(request, response);
 211         verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
 212     }
 213
 214     @Test
 215     public void Given_Request_Is_HTTP_GET_And_Path_Does_Not_Start_With_Valid_Route() throws Exception {
 216         when(request.getPathInfo()).thenReturn("/route/");
 217         RouteServlet routeServlet = new RouteServlet() {
 218             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 219                 return true;
 220             }
 221         };
 222         routeServlet.doGet(request, response);
 223         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 224     }
 225
 226
 227     @Test
 228     public void Given_Request_Is_HTTP_GET_And_Path_Equals_Ingress_And_Get_Succeeds() throws Exception {
 229         when(request.getPathInfo()).thenReturn("/ingress/");
 230         when(request.getRemoteAddr()).thenReturn("stub_addr");
 231         ServletOutputStream outStream = mock(ServletOutputStream.class);
 232         when(response.getOutputStream()).thenReturn(outStream);
 233         RouteServlet routeServlet = new RouteServlet() {
 234             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 235                 return true;
 236             }
 237         };
 238         routeServlet.doGet(request, response);
 239         verify(response).setStatus(eq(HttpServletResponse.SC_OK));
 240     }
 241
 242     @Test
 243     public void Given_Request_Is_HTTP_GET_And_Path_Equals_Egress_And_Get_Succeeds() throws Exception {
 244         when(request.getPathInfo()).thenReturn("/egress/");
 245         when(request.getRemoteAddr()).thenReturn("stub_addr");
 246         ServletOutputStream outStream = mock(ServletOutputStream.class);
 247         when(response.getOutputStream()).thenReturn(outStream);
 248         RouteServlet routeServlet = new RouteServlet() {
 249             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 250                 return true;
 251             }
 252         };
 253         routeServlet.doGet(request, response);
 254         verify(response).setStatus(eq(HttpServletResponse.SC_OK));
 255     }
 256
 257     @Test
 258     public void Given_Request_Is_HTTP_GET_And_Ingress_Path_Equals_Network_And_Get_Succeeds() throws Exception {
 259         when(request.getPathInfo()).thenReturn("/network/");
 260         when(request.getRemoteAddr()).thenReturn("stub_addr");
 261         ServletOutputStream outStream = mock(ServletOutputStream.class);
 262         when(response.getOutputStream()).thenReturn(outStream);
 263         RouteServlet routeServlet = new RouteServlet() {
 264             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 265                 return true;
 266             }
 267         };
 268         routeServlet.doGet(request, response);
 269         verify(response).setStatus(eq(HttpServletResponse.SC_OK));
 270     }
 271
 272     @Test
 273     public void Given_Request_Is_HTTP_PUT_And_Is_Not_Authorized() throws Exception {
 274         routeServlet.doPut(request, response);
 275         verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
 276     }
 277
 278     @Test
 279     public void Given_Request_Is_HTTP_PUT_And_Contains_Bad_URL() throws Exception {
 280         RouteServlet routeServlet = new RouteServlet() {
 281             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 282                 return true;
 283             }
 284         };
 285         routeServlet.doPut(request, response);
 286         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 287     }
 288
 289
 290     @Test
 291     public void Given_Request_Is_HTTP_POST_And_Is_Not_Authorized() throws Exception {
 292         routeServlet.doPost(request, response);
 293         verify(response).sendError(eq(HttpServletResponse.SC_FORBIDDEN), argThat(notNullValue(String.class)));
 294     }
 295
 296     @Test
 297     public void Given_Request_Is_HTTP_POST_And_Ingress_Path_Starts_With_Ingress_And_Contains_Invalid_Arguments() throws Exception {
 298         when(request.getPathInfo()).thenReturn("/ingress/");
 299         when(request.getRemoteAddr()).thenReturn("stub_addr");
 300         when(request.getParameter("feed")).thenReturn("3");
 301         when(request.getParameter("user")).thenReturn(null);
 302         when(request.getParameter("subnet")).thenReturn(null);
 303         when(request.getParameter("nodepatt")).thenReturn(null);
 304         when(request.getParameter("seq")).thenReturn(null);
 305         RouteServlet routeServlet = new RouteServlet() {
 306             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 307                 return true;
 308             }
 309         };
 310         routeServlet.doPost(request, response);
 311         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
 312     }
 313
 314     @Test
 315     public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Egress_And_EgressRoute_Already_Exists() throws Exception {
 316         when(request.getPathInfo()).thenReturn("/egress/");
 317         when(request.getRemoteAddr()).thenReturn("stub_addr");
 318         when(request.getParameter("sub")).thenReturn("3");
 319         EgressRoute e = mock(EgressRoute.class);
 320         PowerMockito.when(EgressRoute.getEgressRoute(anyInt())).thenReturn(e);
 321         RouteServlet routeServlet = new RouteServlet() {
 322             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 323                 return true;
 324             }
 325         };
 326         routeServlet.doPost(request, response);
 327         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
 328     }
 329
 330     @Test
 331     public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Egress_And_Contains_Invalid_Arguments() throws Exception {
 332         when(request.getPathInfo()).thenReturn("/egress/");
 333         when(request.getRemoteAddr()).thenReturn("stub_addr");
 334         when(request.getParameter("sub")).thenReturn("3");
 335         RouteServlet routeServlet = new RouteServlet() {
 336             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 337                 return true;
 338             }
 339         };
 340         routeServlet.doPost(request, response);
 341         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
 342     }
 343
 344     @Test
 345     public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Network_And_Is_Missing_Arguments() throws Exception {
 346         when(request.getPathInfo()).thenReturn("/network/");
 347         when(request.getRemoteAddr()).thenReturn("stub_addr");
 348         RouteServlet routeServlet = new RouteServlet() {
 349             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 350                 return true;
 351             }
 352         };
 353         routeServlet.doPost(request, response);
 354         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
 355     }
 356
 357     @Test
 358     public void Given_Request_Is_HTTP_POST_And_Path_Starts_With_Network_And_Route_Already_Exists() throws Exception {
 359         when(request.getPathInfo()).thenReturn("/network/");
 360         when(request.getRemoteAddr()).thenReturn("stub_addr");
 361         when(request.getParameter("from")).thenReturn("stub_from");
 362         when(request.getParameter("to")).thenReturn("stub_to");
 363         when(request.getParameter("via")).thenReturn("stub_via");
 364         PowerMockito.mockStatic(NodeClass.class);
 365         PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
 366         SortedSet<NetworkRoute> networkSet = new TreeSet();
 367         networkSet.add(mock(NetworkRoute.class));
 368         PowerMockito.when(NetworkRoute.getAllNetworkRoutes()).thenReturn(networkSet);
 369         RouteServlet routeServlet = new RouteServlet() {
 370             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 371                 return true;
 372             }
 373         };
 374         routeServlet.doPost(request, response);
 375         verify(response).sendError(eq(HttpServletResponse.SC_BAD_REQUEST), argThat(notNullValue(String.class)));
 376     }
 377
 378     @Test
 379     public void Given_Request_Is_HTTP_POST_And_Path_URL_Is_Null() throws Exception {
 380         when(request.getPathInfo()).thenReturn("/route/");
 381         when(request.getRemoteAddr()).thenReturn("stub_addr");
 382         when(request.getParameter("from")).thenReturn("stub_from");
 383         when(request.getParameter("to")).thenReturn("stub_to");
 384         when(request.getParameter("via")).thenReturn("stub_via");
 385         PowerMockito.mockStatic(NodeClass.class);
 386         PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
 387         RouteServlet routeServlet = new RouteServlet() {
 388             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 389                 return true;
 390             }
 391         };
 392         routeServlet.doPost(request, response);
 393         verify(response).sendError(eq(HttpServletResponse.SC_NOT_FOUND), argThat(notNullValue(String.class)));
 394     }
 395
 396     @Test
 397     public void Given_Request_Is_HTTP_POST_And_Fails() throws Exception {
 398         when(request.getPathInfo()).thenReturn("/network/");
 399         when(request.getRemoteAddr()).thenReturn("stub_addr");
 400         when(request.getParameter("from")).thenReturn("stub_from");
 401         when(request.getParameter("to")).thenReturn("stub_to");
 402         when(request.getParameter("via")).thenReturn("stub_via");
 403         PowerMockito.mockStatic(NodeClass.class);
 404         PowerMockito.when(NodeClass.normalizeNodename(anyString())).thenReturn("stub_val");
 405         RouteServlet routeServlet = new RouteServlet() {
 406             protected boolean isAuthorizedForInternal(HttpServletRequest req) {
 407                 return true;
 408             }
 409
 410             @Override
 411             protected boolean doInsert(Insertable bean) {
 412                 return false;
 413             }
 414         };
 415         routeServlet.doPost(request, response);
 416         verify(response).sendError(eq(HttpServletResponse.SC_INTERNAL_SERVER_ERROR), argThat(notNullValue(String.class)));
 417     }
 418
 419     private void setRouteToReturnValid() throws IllegalAccessException {
 420         PowerMockito.mockStatic(IngressRoute.class);
 421         PowerMockito.when(IngressRoute.getIngressRoute(anyInt(), anyString(), anyString())).thenReturn(null);
 422         SortedSet<IngressRoute> ingressSet = new TreeSet();
 423         IngressRoute ingressRoute = mock(IngressRoute.class);
 424         JSONObject joIngress = mock(JSONObject.class);
 425         when(joIngress.toString()).thenReturn("{}");
 426         when(ingressRoute.asJSONObject()).thenReturn(joIngress);
 427         ingressSet.add(ingressRoute);
 428         PowerMockito.when(IngressRoute.getAllIngressRoutes()).thenReturn(ingressSet);
 429
 430         PowerMockito.mockStatic(EgressRoute.class);
 431         PowerMockito.when(EgressRoute.getEgressRoute(anyInt())).thenReturn(null);
 432         SortedSet<EgressRoute> egressSet = new TreeSet();
 433         EgressRoute egressRoute = mock(EgressRoute.class);
 434         JSONObject joEgress = mock(JSONObject.class);
 435         when(joEgress.toString()).thenReturn("{}");
 436         when(egressRoute.asJSONObject()).thenReturn(joEgress);
 437         egressSet.add(egressRoute);
 438         PowerMockito.when(EgressRoute.getAllEgressRoutes()).thenReturn(egressSet);
 439
 440         PowerMockito.mockStatic(NetworkRoute.class);
 441         SortedSet<NetworkRoute> networkSet = new TreeSet();
 442         PowerMockito.when(NetworkRoute.getAllNetworkRoutes()).thenReturn(networkSet);
 443
 444     }
 445
 446     private void setPokerToNotCreateTimersWhenDeleteFeedIsCalled() throws Exception {
 447         Poker poker = mock(Poker.class);
 448         FieldUtils.writeDeclaredStaticField(Poker.class, "poker", poker, true);
 449     }
 450 }