src/test/java/org/onap/aai/sa/rest/DocumentTest.java

   1 /**\r
   2  * ============LICENSE_START=======================================================\r
   3  * org.onap.aai\r
   4  * ================================================================================\r
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.\r
   6  * Copyright © 2017-2018 Amdocs\r
   7  * ================================================================================\r
   8  * Licensed under the Apache License, Version 2.0 (the "License");\r
   9  * you may not use this file except in compliance with the License.\r
  10  * You may obtain a copy of the License at\r
  11  *\r
  12  *       http://www.apache.org/licenses/LICENSE-2.0\r
  13  *\r
  14  * Unless required by applicable law or agreed to in writing, software\r
  15  * distributed under the License is distributed on an "AS IS" BASIS,\r
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17  * See the License for the specific language governing permissions and\r
  18  * limitations under the License.\r
  19  * ============LICENSE_END=========================================================\r
  20  */\r
  21 package org.onap.aai.sa.rest;\r
  22 \r
  23 import com.fasterxml.jackson.core.JsonProcessingException;\r
  24 import javax.servlet.http.HttpServletRequest;\r
  25 import javax.servlet.http.HttpServletResponse;\r
  26 // import javax.ws.rs.core.HttpHeaders;\r
  27 import javax.ws.rs.core.MultivaluedMap;\r
  28 import org.junit.Assert;\r
  29 import org.junit.Before;\r
  30 import org.junit.Ignore;\r
  31 import org.junit.Test;\r
  32 import org.mockito.InjectMocks;\r
  33 import org.mockito.Mock;\r
  34 import org.mockito.Mockito;\r
  35 import org.mockito.MockitoAnnotations;\r
  36 import org.onap.aai.sa.searchdbabstraction.elasticsearch.dao.DocumentStoreDataEntity;\r
  37 import org.onap.aai.sa.searchdbabstraction.elasticsearch.dao.DocumentStoreInterface;\r
  38 import org.onap.aai.sa.searchdbabstraction.elasticsearch.exception.DocumentStoreOperationException;\r
  39 import org.onap.aai.sa.searchdbabstraction.entity.DocumentOperationResult;\r
  40 import org.onap.aai.sa.searchdbabstraction.entity.ErrorResult;\r
  41 import org.onap.aai.sa.searchdbabstraction.entity.SearchHits;\r
  42 import org.onap.aai.sa.searchdbabstraction.entity.SearchOperationResult;\r
  43 import org.springframework.http.HttpHeaders;\r
  44 import org.springframework.http.HttpStatus;\r
  45 import org.springframework.http.ResponseEntity;\r
  46 \r
  47 \r
  48 public class DocumentTest {\r
  49 \r
  50     @Mock\r
  51     SearchServiceApi searchServiceApi;\r
  52 \r
  53     @Mock\r
  54     HttpServletRequest request;\r
  55 \r
  56     @Mock\r
  57     HttpHeaders headers;\r
  58 \r
  59     @Mock\r
  60     HttpServletResponse httpResponse;\r
  61 \r
  62     @Mock\r
  63     DocumentStoreInterface documentStore;\r
  64 \r
  65     @Mock\r
  66     MultivaluedMap<String, String> multivaluedMap;\r
  67 \r
  68     @InjectMocks\r
  69     IndexApi indexApi;\r
  70 \r
  71     DocumentApi documentApi;\r
  72 \r
  73     @Before\r
  74     public void setUp() {\r
  75         MockitoAnnotations.initMocks(this);\r
  76         documentApi = new DocumentApi(searchServiceApi);\r
  77     }\r
  78 \r
  79     @Test\r
  80     public void testDocumentClass_AllMethods() throws JsonProcessingException {\r
  81         Document doc = new Document();\r
  82         doc.setField("name-1", "value-1");\r
  83         Assert.assertTrue(doc.getFields().size() == 1);\r
  84         Assert.assertTrue(doc.toJson().contains("value-1"));\r
  85         Assert.assertNotNull(doc.toString());\r
  86         Assert.assertTrue(doc.toString().contains("name-1"));\r
  87     }\r
  88 \r
  89     @Test\r
  90     public void testProcessPost_NullContent() {\r
  91         String transactionId = "transactionId-1";\r
  92         String remoteAddr = "http://127.0.0.1";\r
  93         String content = null;\r
  94         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);\r
  95         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
  96         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
  97         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
  98         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
  99         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 100         ResponseEntity<String> response =\r
 101                 documentApi.processPost(content, request, headers, httpResponse, "index", documentStore);\r
 102         Assert.assertNotNull(response);\r
 103         Assert.assertTrue(HttpStatus.BAD_REQUEST.value() == response.getStatusCodeValue());\r
 104     }\r
 105 \r
 106     @SuppressWarnings("unchecked")\r
 107     @Test\r
 108     public void testProcessPost_NotNullContent() throws Exception {\r
 109         String transactionId = "transactionId-1";\r
 110         String remoteAddr = "http://127.0.0.1";\r
 111         String content = "content";\r
 112         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);\r
 113         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 114         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 115         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 116         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 117         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 118         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 119                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 120                 .thenThrow(IllegalArgumentException.class);\r
 121         ResponseEntity<?> response =\r
 122                 documentApi.processPost(content, request, headers, httpResponse, "index", documentStore);\r
 123         Assert.assertNotNull(response);\r
 124         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 125     }\r
 126 \r
 127     //\r
 128     @Test\r
 129     public void testProcessPost_ValidRequest() throws Exception {\r
 130         String transactionId = "transactionId-1";\r
 131         String remoteAddr = "http://127.0.0.1";\r
 132         String content = "content";\r
 133         DocumentOperationResult result = new DocumentOperationResult();\r
 134         result.setResultCode(150);\r
 135         result.setError(new ErrorResult("type-1", "reason-1"));\r
 136         result.setFailureCause("test-failure");\r
 137         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);\r
 138         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 139         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 140         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 141         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 142         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 143         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 144                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 145                 .thenReturn(true);\r
 146         Mockito.when(documentStore.createDocument(Mockito.anyString(), Mockito.any(DocumentStoreDataEntity.class),\r
 147                 Mockito.anyBoolean())).thenReturn(result);\r
 148         Mockito.doNothing().when(httpResponse).setHeader(Mockito.anyString(), Mockito.anyString());\r
 149         ResponseEntity<String> response =\r
 150                 documentApi.processPost(content, request, headers, httpResponse, "index", documentStore);\r
 151         Assert.assertNotNull(response);\r
 152         Assert.assertTrue(HttpStatus.INTERNAL_SERVER_ERROR.value() == response.getStatusCodeValue());\r
 153     }\r
 154 \r
 155     //\r
 156     @Test\r
 157     public void testProcessSearchWithGet_Created() throws Exception {\r
 158         String transactionId = "transactionId-1";\r
 159         String remoteAddr = "http://127.0.0.1";\r
 160         String content = "content";\r
 161         SearchOperationResult result = new SearchOperationResult();\r
 162         result.setResultCode(201);\r
 163         SearchHits hits = new SearchHits();\r
 164         hits.setTotalHits("2");\r
 165         result.setSearchResult(hits);\r
 166         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);\r
 167         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 168         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 169         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 170         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 171         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 172         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 173                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 174                 .thenReturn(true);\r
 175         Mockito.when(documentStore.search(Mockito.anyString(), Mockito.anyString())).thenReturn(result);\r
 176         ResponseEntity<String> response =\r
 177                 documentApi.processSearchWithGet(content, request, headers, "index-1", "query-text", documentStore);\r
 178         Assert.assertNotNull(response);\r
 179         Assert.assertTrue(HttpStatus.CREATED.value() == response.getStatusCodeValue());\r
 180 \r
 181     }\r
 182 \r
 183     @SuppressWarnings("unchecked")\r
 184     @Test\r
 185     public void testProcessSearchWithGet_ValidateThrowsException() throws Exception {\r
 186         String transactionId = "transactionId-1";\r
 187         String remoteAddr = "http://127.0.0.1";\r
 188         String content = "content";\r
 189         SearchOperationResult result = new SearchOperationResult();\r
 190         result.setResultCode(201);\r
 191         SearchHits hits = new SearchHits();\r
 192         hits.setTotalHits("2");\r
 193         result.setSearchResult(hits);\r
 194         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);\r
 195         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 196         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 197         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 198         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 199         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 200         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 201                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 202                 .thenThrow(IllegalArgumentException.class);\r
 203         Mockito.when(documentStore.search(Mockito.anyString(), Mockito.anyString())).thenReturn(result);\r
 204         ResponseEntity<String> response =\r
 205                 documentApi.processSearchWithGet(content, request, headers, "index-1", "query-text", documentStore);\r
 206         Assert.assertNotNull(response);\r
 207         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 208 \r
 209     }\r
 210 \r
 211     @Test\r
 212     public void testProcessSearchWithGet_ValidateIsFalse() throws Exception {\r
 213         String transactionId = "transactionId-1";\r
 214         String remoteAddr = "http://127.0.0.1";\r
 215         String content = "content";\r
 216         SearchOperationResult result = new SearchOperationResult();\r
 217         result.setResultCode(201);\r
 218         SearchHits hits = new SearchHits();\r
 219         hits.setTotalHits("2");\r
 220         result.setSearchResult(hits);\r
 221         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);\r
 222         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 223         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 224         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 225         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 226         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 227         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 228                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 229                 .thenReturn(false);\r
 230         Mockito.when(documentStore.search(Mockito.anyString(), Mockito.anyString())).thenReturn(result);\r
 231         ResponseEntity<String> response =\r
 232                 documentApi.processSearchWithGet(content, request, headers, "index-1", "query-text", documentStore);\r
 233         Assert.assertNotNull(response);\r
 234         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 235 \r
 236     }\r
 237 \r
 238     @Test\r
 239     public void testProcessSearchWithGet_InvalidResult() throws Exception {\r
 240         String transactionId = "transactionId-1";\r
 241         String remoteAddr = "http://127.0.0.1";\r
 242         String content = "content";\r
 243         SearchOperationResult result = new SearchOperationResult();\r
 244         result.setResultCode(302);\r
 245         SearchHits hits = new SearchHits();\r
 246         hits.setTotalHits("2");\r
 247         result.setSearchResult(hits);\r
 248         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 249         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 250         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 251         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 252         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 253         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 254         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 255                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 256                 .thenReturn(true);\r
 257         Mockito.when(documentStore.search(Mockito.anyString(), Mockito.anyString())).thenReturn(result);\r
 258         ResponseEntity<String> response =\r
 259                 documentApi.processSearchWithGet(content, request, headers, "index-1", "query-text", documentStore);\r
 260         Assert.assertNotNull(response);\r
 261         Assert.assertTrue(HttpStatus.FOUND.value() == response.getStatusCodeValue());\r
 262 \r
 263     }\r
 264 \r
 265     @Test\r
 266     public void testProcessPut_NullContent() {\r
 267         String transactionId = "transactionId-1";\r
 268         String remoteAddr = "http://127.0.0.1";\r
 269         String content = null;\r
 270         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 271         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 272         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 273         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 274         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 275         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 276         ResponseEntity<String> response =\r
 277                 documentApi.processPut(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 278         Assert.assertNotNull(response);\r
 279         Assert.assertTrue(HttpStatus.BAD_REQUEST.value() == response.getStatusCodeValue());\r
 280     }\r
 281 \r
 282     @SuppressWarnings("unchecked")\r
 283     @Test\r
 284     public void testProcessPut_RequestThrowsException() throws Exception {\r
 285         String transactionId = "transactionId-1";\r
 286         String remoteAddr = "http://127.0.0.1";\r
 287         String content = "content";\r
 288         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 289         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 290         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 291         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 292         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 293         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 294         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 295                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 296                 .thenThrow(IllegalArgumentException.class);\r
 297         ResponseEntity<String> response =\r
 298                 documentApi.processPut(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 299         Assert.assertNotNull(response);\r
 300         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 301     }\r
 302 \r
 303     @Test\r
 304     public void testProcessPut_RequestInvalid() throws Exception {\r
 305         String transactionId = "transactionId-1";\r
 306         String remoteAddr = "http://127.0.0.1";\r
 307         String content = "content";\r
 308         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 309         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 310         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 311         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 312         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 313         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 314         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 315                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 316                 .thenReturn(false);\r
 317         ResponseEntity<String> response =\r
 318                 documentApi.processPut(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 319         Assert.assertNotNull(response);\r
 320         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 321     }\r
 322 \r
 323     @Test\r
 324     public void testProcessPut_ResultInvalid() throws Exception {\r
 325         String transactionId = "transactionId-1";\r
 326         String remoteAddr = "http://127.0.0.1";\r
 327         String content = "content";\r
 328         DocumentOperationResult result = new DocumentOperationResult();\r
 329         result.setResultCode(302);\r
 330         result.setError(new ErrorResult("type-1", "reason-1"));\r
 331         result.setFailureCause("test-failure");\r
 332         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 333         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 334         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 335         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 336         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 337         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 338         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 339                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 340                 .thenReturn(true);\r
 341         Mockito.when(documentStore.createDocument(Mockito.anyString(), Mockito.any(DocumentStoreDataEntity.class),\r
 342                 Mockito.anyBoolean())).thenReturn(result);\r
 343         ResponseEntity<String> response =\r
 344                 documentApi.processPut(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 345         Assert.assertNotNull(response);\r
 346         Assert.assertTrue(HttpStatus.FOUND.value() == response.getStatusCodeValue());\r
 347     }\r
 348 \r
 349     @SuppressWarnings("unchecked")\r
 350     @Test\r
 351     public void testProcessDelete_RequestThrowsException() throws Exception {\r
 352         String transactionId = "transactionId-1";\r
 353         String remoteAddr = "http://127.0.0.1";\r
 354         String content = "content";\r
 355         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 356         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 357         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 358         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 359         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 360         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 361         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 362                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 363                 .thenThrow(IllegalArgumentException.class);\r
 364         ResponseEntity<String> response =\r
 365                 documentApi.processDelete(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 366         Assert.assertNotNull(response);\r
 367         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 368     }\r
 369 \r
 370     @Test\r
 371     public void testProcessDelete_RequestInvalid() throws Exception {\r
 372         String transactionId = "transactionId-1";\r
 373         String remoteAddr = "http://127.0.0.1";\r
 374         String content = "content";\r
 375         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 376         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 377         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 378         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 379         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 380         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 381         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 382                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 383                 .thenReturn(false);\r
 384         ResponseEntity<String> response =\r
 385                 documentApi.processDelete(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 386         Assert.assertNotNull(response);\r
 387         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 388     }\r
 389 \r
 390     @Ignore\r
 391     @Test\r
 392     public void testProcessDelete_ResultInvalid() throws Exception {\r
 393         String transactionId = "transactionId-1";\r
 394         String remoteAddr = "http://127.0.0.1";\r
 395         String content = "content";\r
 396         DocumentOperationResult result = new DocumentOperationResult();\r
 397         result.setResultCode(302);\r
 398         result.setError(new ErrorResult("type-1", "reason-1"));\r
 399         result.setFailureCause("test-failure");\r
 400         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 401         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 402         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 403         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 404         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 405         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 406         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 407                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 408                 .thenReturn(true);\r
 409         Mockito.when(documentStore.deleteDocument(Mockito.anyString(), Mockito.any(DocumentStoreDataEntity.class)))\r
 410                 .thenReturn(result);\r
 411         ResponseEntity<String> response =\r
 412                 documentApi.processDelete(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 413         Assert.assertNotNull(response);\r
 414         Assert.assertTrue(HttpStatus.FOUND.value() == response.getStatusCodeValue());\r
 415     }\r
 416 \r
 417     @SuppressWarnings("unchecked")\r
 418     @Test\r
 419     public void testProcessGet_RequestThrowsException() throws Exception {\r
 420         String transactionId = "transactionId-1";\r
 421         String remoteAddr = "http://127.0.0.1";\r
 422         String content = "content";\r
 423         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 424         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 425         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 426         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 427         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 428         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 429         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 430                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 431                 .thenThrow(IllegalArgumentException.class);\r
 432         ResponseEntity<String> response =\r
 433                 documentApi.processGet(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 434         Assert.assertNotNull(response);\r
 435         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 436     }\r
 437 \r
 438     @Test\r
 439     public void testProcessGet_RequestInvalid() throws Exception {\r
 440         String transactionId = "transactionId-1";\r
 441         String remoteAddr = "http://127.0.0.1";\r
 442         String content = "content";\r
 443         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 444         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 445         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 446         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 447         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 448         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 449         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 450                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 451                 .thenReturn(false);\r
 452         ResponseEntity<String> response =\r
 453                 documentApi.processGet(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 454         Assert.assertNotNull(response);\r
 455         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 456     }\r
 457 \r
 458     @Test\r
 459     public void testProcessGet_ResultInvalid() throws Exception {\r
 460         String transactionId = "transactionId-1";\r
 461         String remoteAddr = "http://127.0.0.1";\r
 462         String content = "content";\r
 463         DocumentOperationResult result = new DocumentOperationResult();\r
 464         result.setResultCode(302);\r
 465         result.setError(new ErrorResult("type-1", "reason-1"));\r
 466         result.setFailureCause("test-failure");\r
 467         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 468         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 469         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 470         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 471         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 472         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 473         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 474                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 475                 .thenReturn(true);\r
 476         Mockito.when(documentStore.getDocument(Mockito.anyString(), Mockito.any(DocumentStoreDataEntity.class)))\r
 477                 .thenReturn(result);\r
 478         ResponseEntity<String> response =\r
 479                 documentApi.processGet(content, request, headers, httpResponse, "index", "id-1", documentStore);\r
 480         Assert.assertNotNull(response);\r
 481         Assert.assertTrue(HttpStatus.FOUND.value() == response.getStatusCodeValue());\r
 482     }\r
 483 \r
 484     @Test\r
 485     public void testQueryWithGetWithPayload_NullContent() {\r
 486         String transactionId = "transactionId-1";\r
 487         String remoteAddr = "http://127.0.0.1";\r
 488         String content = null;\r
 489         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 490         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 491         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 492         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 493         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 494         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 495         ResponseEntity<String> response =\r
 496                 documentApi.queryWithGetWithPayload(content, request, headers, "index-1", documentStore);\r
 497         Assert.assertNotNull(response);\r
 498         Assert.assertTrue(HttpStatus.BAD_REQUEST.value() == response.getStatusCodeValue());\r
 499     }\r
 500 \r
 501     @SuppressWarnings("unchecked")\r
 502     @Test\r
 503     public void testQueryWithGetWithPayload_RequestThrowsException() throws Exception {\r
 504         String transactionId = "transactionId-1";\r
 505         String remoteAddr = "http://127.0.0.1";\r
 506         String content = "content";\r
 507         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 508         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 509         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 510         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 511         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 512         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 513         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 514                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 515                 .thenThrow(IllegalArgumentException.class);\r
 516         ResponseEntity<String> response =\r
 517                 documentApi.queryWithGetWithPayload(content, request, headers, "index-1", documentStore);\r
 518         Assert.assertNotNull(response);\r
 519         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 520     }\r
 521 \r
 522     @Test\r
 523     public void testQueryWithGetWithPayload_RequestInvalid() throws Exception {\r
 524         String transactionId = "transactionId-1";\r
 525         String remoteAddr = "http://127.0.0.1";\r
 526         String content = "content";\r
 527         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 528         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 529         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 530         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 531         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 532         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 533         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 534                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 535                 .thenReturn(false);\r
 536         ResponseEntity<String> response =\r
 537                 documentApi.queryWithGetWithPayload(content, request, headers, "index-1", documentStore);\r
 538         Assert.assertNotNull(response);\r
 539         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 540     }\r
 541 \r
 542     @Test\r
 543     public void testCreateProcessIndex_IndexApi_RequestInvalid() throws Exception {\r
 544         String transactionId = "transactionId-1";\r
 545         String remoteAddr = "http://127.0.0.1";\r
 546         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 547         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 548         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 549         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 550         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 551         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 552         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 553                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 554                 .thenReturn(false);\r
 555         ResponseEntity<String> response =\r
 556                 indexApi.processCreateIndex("document-1", request, headers, "index-1", documentStore);\r
 557         Assert.assertNotNull(response);\r
 558         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 559     }\r
 560 \r
 561     @SuppressWarnings("unchecked")\r
 562     @Test\r
 563     public void testCreateProcessIndex_IndexApi_RequestThrowsException() throws Exception {\r
 564         String transactionId = "transactionId-1";\r
 565         String remoteAddr = "http://127.0.0.1";\r
 566         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 567         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 568         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 569         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 570         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 571         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 572         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 573                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 574                 .thenThrow(IllegalArgumentException.class);\r
 575         ResponseEntity<String> response =\r
 576                 indexApi.processCreateIndex("document-1", request, headers, "index-1", documentStore);\r
 577         Assert.assertNotNull(response);\r
 578         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 579     }\r
 580 \r
 581     @Test\r
 582     public void testCreateProcessIndex_IndexApi_NullDocument() throws Exception {\r
 583         String transactionId = "transactionId-1";\r
 584         String remoteAddr = "http://127.0.0.1";\r
 585         String documentSchema = null;\r
 586         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 587         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 588         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 589         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 590         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 591         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 592         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 593                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 594                 .thenReturn(true);\r
 595         ResponseEntity<String> response =\r
 596                 indexApi.processCreateIndex(documentSchema, request, headers, "index-1", documentStore);\r
 597         Assert.assertNotNull(response);\r
 598         Assert.assertTrue(HttpStatus.INTERNAL_SERVER_ERROR.value() == response.getStatusCodeValue());\r
 599     }\r
 600 \r
 601     @Test\r
 602     public void testProcessDelete_IndexApi_RequestInvalid() throws Exception {\r
 603         String transactionId = "transactionId-1";\r
 604         String remoteAddr = "http://127.0.0.1";\r
 605         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 606         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 607         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 608         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 609         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 610         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 611         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 612                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 613                 .thenReturn(false);\r
 614         ResponseEntity<String> response = indexApi.processDelete("document-1", request, headers, documentStore);\r
 615         Assert.assertNotNull(response);\r
 616         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 617     }\r
 618 \r
 619     @SuppressWarnings("unchecked")\r
 620     @Test\r
 621     public void testProcessDelete_IndexApi_RequestThrowsException() throws Exception {\r
 622         String transactionId = "transactionId-1";\r
 623         String remoteAddr = "http://127.0.0.1";\r
 624         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 625         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 626         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 627         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 628         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 629         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 630         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 631                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 632                 .thenThrow(IllegalArgumentException.class);\r
 633         ResponseEntity<String> response = indexApi.processDelete("document-1", request, headers, documentStore);\r
 634         Assert.assertNotNull(response);\r
 635         Assert.assertTrue(HttpStatus.FORBIDDEN.value() == response.getStatusCodeValue());\r
 636     }\r
 637 \r
 638     @SuppressWarnings("unchecked")\r
 639     @Test\r
 640     public void testProcessDelete_IndexApi_DeleteIndexException() throws Exception {\r
 641         String transactionId = "transactionId-1";\r
 642         String remoteAddr = "http://127.0.0.1";\r
 643         // Mockito.when(headers.getRequestHeaders()).thenReturn(multivaluedMap);;\r
 644         Mockito.when(multivaluedMap.getFirst(Mockito.anyString())).thenReturn(transactionId);\r
 645         Mockito.when(request.getRemoteAddr()).thenReturn(remoteAddr);\r
 646         Mockito.when(request.getMethod()).thenReturn("testMethod");\r
 647         Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("http://127.0.0.1"));\r
 648         Mockito.when(request.getRemoteHost()).thenReturn("localhost");\r
 649         Mockito.when(searchServiceApi.validateRequest(Mockito.any(HttpHeaders.class),\r
 650                 Mockito.any(HttpServletRequest.class), Mockito.any(ApiUtils.Action.class), Mockito.anyString()))\r
 651                 .thenReturn(true);\r
 652         Mockito.when(documentStore.deleteIndex(Mockito.anyString())).thenThrow(DocumentStoreOperationException.class);\r
 653         ResponseEntity<String> response = indexApi.processDelete("document-1", request, headers, documentStore);\r
 654         Assert.assertNotNull(response);\r
 655         Assert.assertTrue(HttpStatus.INTERNAL_SERVER_ERROR.value() == response.getStatusCodeValue());\r
 656     }\r
 657 }\r