/** * @see ExceptionMapperResource#throwDataIntegrityUnicityException() */ @Test public void testIntegrityUnicityError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/integrity-unicity"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_PRECONDITION_FAILED, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("integrity-unicity", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("2003/PRIMARY", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
private void delete(String url) throws IOException, HttpException { CredentialsProvider credentials = credentialsProvider(); CloseableHttpClient httpclient = HttpClients.custom() .setDefaultCredentialsProvider(credentials) .build(); try { HttpDelete httpDelete = new HttpDelete(url); httpDelete.setHeader("Accept", "application/json"); System.out.println("Executing request " + httpDelete.getRequestLine()); CloseableHttpResponse response = httpclient.execute(httpDelete); try { LOG.debug("----------------------------------------"); LOG.debug((String)response.getStatusLine().getReasonPhrase()); } finally { response.close(); } } finally { httpclient.close(); } }
@Override public CloseableHttpResponse sendHttpDelete(String url, List<Header> headers) { CloseableHttpResponse execute = null; try { LOGGER.info("Sending GET request to url-" + url); CloseableHttpClient httpClient = this.httpClientFactory.getHttpClient(); HttpDelete httpDelete = new HttpDelete(url); if (headers != null && !headers.isEmpty()) { for (Header header : headers) { httpDelete.addHeader(header); } } execute = httpClient.execute(httpDelete); } catch (IOException e) { LOGGER.log(Level.SEVERE, "Was unable to send Get request to url-" + url, e); } return execute; }
/** * sendDeleteCommand * * @param url * @return */ public Map<String, String> sendDeleteCommand(String url, Map<String, Object> credentials) throws ManagerResponseException { Map<String, String> response = new HashMap<String, String>(); CloseableHttpClient httpclient = HttpClients.createDefault(); HttpDelete httpDelete = new HttpDelete(url); CloseableHttpResponse httpResponse; try { httpResponse = httpclient.execute(httpDelete, localContext); ResponseHandler<String> handler = new CustomResponseErrorHandler(); String body = handler.handleResponse(httpResponse); response.put("body", body); httpResponse.close(); } catch (Exception e) { throw new ManagerResponseException(e.getMessage(), e); } return response; }
public DockerResponse sendDelete(URI uri, Boolean httpRequired) throws JSONClientException { if (logger.isDebugEnabled()) { logger.debug("Send a delete request to : " + uri); } CloseableHttpResponse response = null; try { CloseableHttpClient httpClient = buildSecureHttpClient(); HttpDelete httpDelete = new HttpDelete(uri); response = httpClient.execute(httpDelete); } catch (IOException e) { throw new JSONClientException("Error in sendDelete method due to : " + e.getMessage(), e); } if (logger.isDebugEnabled()) { logger.debug("Status code : " + response.getStatusLine().getStatusCode()); } return new DockerResponse(response.getStatusLine().getStatusCode(), ""); }
private void assertNotFound(final String path, final String message) throws IOException, ClientProtocolException, JsonParseException, JsonMappingException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + path); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_NOT_FOUND, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("entity", result.get("code")); Assert.assertEquals(message, result.get("message")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwCannotAcquireLockException() */ @Test public void testCannotAcquireLockException() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/cannotAcquireLockException"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_CONFLICT, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("database-lock", result.get("code")); Assert.assertNull(result.get("message")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
private HttpRequestBase getRequest(String url){ switch(method){ case DELETE: return new HttpDelete(url); case GET: return new HttpGet(url); case HEAD: return new HttpHead(url); case PATCH: return new HttpPatch(url); case POST: return new HttpPost(url); case PUT: return new HttpPut(url); default: throw new IllegalArgumentException("Invalid or null HttpMethod: " + method); } }
private HttpRequestBase createApacheRequest(SdkHttpFullRequest request, String uri) { switch (request.method()) { case HEAD: return new HttpHead(uri); case GET: return new HttpGet(uri); case DELETE: return new HttpDelete(uri); case OPTIONS: return new HttpOptions(uri); case PATCH: return wrapEntity(request, new HttpPatch(uri)); case POST: return wrapEntity(request, new HttpPost(uri)); case PUT: return wrapEntity(request, new HttpPut(uri)); default: throw new RuntimeException("Unknown HTTP method name: " + request.method()); } }
static Request delete(DeleteRequest deleteRequest) { String endpoint = endpoint(deleteRequest.index(), deleteRequest.type(), deleteRequest.id()); Params parameters = Params.builder(); parameters.withRouting(deleteRequest.routing()); parameters.withParent(deleteRequest.parent()); parameters.withTimeout(deleteRequest.timeout()); parameters.withVersion(deleteRequest.version()); parameters.withVersionType(deleteRequest.versionType()); parameters.withRefreshPolicy(deleteRequest.getRefreshPolicy()); parameters.withWaitForActiveShards(deleteRequest.waitForActiveShards()); return new Request(HttpDelete.METHOD_NAME, endpoint, parameters.getParams(), null); }
public static void deleteRESTUser(String usrName){ try{ DefaultHttpClient client = new DefaultHttpClient(); client.getCredentialsProvider().setCredentials( new AuthScope(host, 8002), new UsernamePasswordCredentials("admin", "admin")); HttpDelete delete = new HttpDelete("http://"+host+":8002/manage/v2/users/"+usrName); HttpResponse response = client.execute(delete); if(response.getStatusLine().getStatusCode()== 202){ Thread.sleep(3500); } }catch (Exception e) { // writing error to Log e.printStackTrace(); } }
public static void deleteUserRole(String roleName){ try{ DefaultHttpClient client = new DefaultHttpClient(); client.getCredentialsProvider().setCredentials( new AuthScope(host, 8002), new UsernamePasswordCredentials("admin", "admin")); HttpDelete delete = new HttpDelete("http://"+host+":8002/manage/v2/roles/"+roleName); HttpResponse response = client.execute(delete); if(response.getStatusLine().getStatusCode()== 202){ Thread.sleep(3500); } }catch (Exception e) { // writing error to Log e.printStackTrace(); } }
public static void deleteRESTServerWithDB(String restServerName) { try{ DefaultHttpClient client = new DefaultHttpClient(); client.getCredentialsProvider().setCredentials( new AuthScope(host, 8002), new UsernamePasswordCredentials("admin", "admin")); HttpDelete delete = new HttpDelete("http://"+host+":8002/v1/rest-apis/"+restServerName+"?include=content&include=modules"); HttpResponse response = client.execute(delete); if(response.getStatusLine().getStatusCode()== 202){ Thread.sleep(9500); } }catch (Exception e) { // writing error to Log e.printStackTrace(); } }
public static void deleteRESTServer(String restServerName) { try{ DefaultHttpClient client = new DefaultHttpClient(); client.getCredentialsProvider().setCredentials( new AuthScope(host, 8002), new UsernamePasswordCredentials("admin", "admin")); HttpDelete delete = new HttpDelete("http://"+host+":8002/v1/rest-apis/"+restServerName+"&include=modules"); HttpResponse response = client.execute(delete); if(response.getStatusLine().getStatusCode()== 202){ Thread.sleep(3500); waitForServerRestart(); } else System.out.println("Server response "+response.getStatusLine().getStatusCode()); }catch (Exception e) { // writing error to Log System.out.println("Inside Deleting Rest server is throwing an error"); e.printStackTrace(); } }
private HttpUtils(HttpRequestBase request) { this.request = request; this.clientBuilder = HttpClientBuilder.create(); this.isHttps = request.getURI().getScheme().equalsIgnoreCase("https"); this.config = RequestConfig.custom().setCookieSpec(CookieSpecs.BROWSER_COMPATIBILITY); this.cookieStore = new BasicCookieStore(); if (request instanceof HttpPost) { this.type = 1; this.builder = EntityBuilder.create().setParameters(new ArrayList<NameValuePair>()); } else if (request instanceof HttpGet) { this.type = 2; this.uriBuilder = new URIBuilder(); } else if (request instanceof HttpPut) { this.type = 3; this.builder = EntityBuilder.create().setParameters(new ArrayList<NameValuePair>()); } else if (request instanceof HttpDelete) { this.type = 4; this.uriBuilder = new URIBuilder(); } }
public static void deleteTask(@NotNull final Integer task, Project project) { final HttpDelete request = new HttpDelete(EduStepicNames.STEPIC_API_URL + EduStepicNames.STEP_SOURCES + task); ApplicationManager.getApplication().invokeLater(() -> { try { final CloseableHttpClient client = EduStepicAuthorizedClient.getHttpClient(); if (client == null) return; final CloseableHttpResponse response = client.execute(request); final HttpEntity responseEntity = response.getEntity(); final String responseString = responseEntity != null ? EntityUtils.toString(responseEntity) : ""; EntityUtils.consume(responseEntity); final StatusLine line = response.getStatusLine(); if (line.getStatusCode() != HttpStatus.SC_NO_CONTENT) { LOG.error("Failed to delete task " + responseString); showErrorNotification(project, "Failed to delete task ", responseString); } } catch (IOException e) { LOG.error(e.getMessage()); } }); }
public String deleteFile(String deleteURL) throws IllegalStateException { HttpResponse response = null; HttpDelete delete = new HttpDelete(deleteURL); try { response = httpClient.execute(delete); String statusCode = String.valueOf(response.getStatusLine().getStatusCode()); if (statusCode.indexOf("20") == 0) { HttpEntity entity = response.getEntity(); String contentType = entity.getContentType().getValue(); LOG.info("contentType=" + contentType); return StrUtil.readStream(entity.getContent(), responseContextEncode); } else if (statusCode.indexOf("40") == 0) { LOG.error("Page: " + deleteURL + " no find"); return "Page no find"; } else { LOG.error("返回状态码:[" + statusCode + "]"); return "返回状态码:[" + statusCode + "]"; } } catch (Exception e) { e.printStackTrace(); } finally { delete.releaseConnection(); } return null; }
/** * Deletes the customer and sets customerName to null ({@link #getCustomerName()}) * * @param customerName unique name of the customer * @return request object to check status codes and return values */ public Response deleteCustomer( String customerName ) { HttpDelete request = new HttpDelete( this.yambasBase + "customers/" + customerName ); setAuthorizationHeader( request ); try { final HttpResponse response = this.client.execute( request ); this.customerName = null; return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * Deletes a module * * @param moduleName * the name of the module to delete * @param deleteCompletely * if set to false, the module is only deleted from the current system and wil still exist in database * @return request object to check status codes and return values */ public Response deleteModule( String moduleName, boolean deleteCompletely ) { HttpDelete request = new HttpDelete( this.yambasBase + "modules/" + moduleName + "?deleteCompletely=" + String.valueOf( deleteCompletely ) ); setAuthorizationHeader( request ); request.addHeader( "x-apiomat-system", this.system.toString( ) ); try { final HttpResponse response = this.client.execute( request ); return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * Deletes the specified app * * @param customerName * the name of the customer which owns the app * @param appName * the name of the app to delete * @return request object to check status codes and return values */ public Response deleteApp( String customerName, String appName ) { final HttpDelete request = new HttpDelete( this.yambasBase + "customers/" + customerName + "/apps/" + appName ); setAuthorizationHeader( request ); try { final HttpResponse response = this.client.execute( request ); return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * Drops all data contained in the currently set app * * @return request object to check status codes and return values */ public Response dropData( ) { final HttpDelete request = new HttpDelete( this.yambasBase + "apps/" + this.appName + "/models" ); setAuthorizationHeader( request ); try { final HttpResponse response = this.client.execute( request ); return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * Delete the references for a specified object * * @param moduleName * the name of the module * @param dataModelName * the name of the datamodel * @param dataModelId * the datamodel-id * @param refAttributeName * the attribute-name of the reference * @param refId * the reference id * @return request object to check status codes and return values */ public Response deleteReference( String moduleName, String dataModelName, String dataModelId, String refAttributeName, String refId ) { final HttpDelete request = new HttpDelete( this.yambasBase + "apps/" + this.appName + "/models/" + moduleName + "/" + dataModelName + "/" + dataModelId + "/" + refAttributeName + "/" + refId ); setAuthorizationHeader( request ); request.addHeader( "ContentType", "application/json" ); request.addHeader( "x-apiomat-apikey", this.apiKey ); request.addHeader( "x-apiomat-system", this.system.toString( ) ); try { final HttpResponse response = this.client.execute( request ); return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * Deletes an object * * @param moduleName * the name of the module * @param dataModelName * the name of the datamodel * @param dataModelId * the datamodel-id * @return request object to check status codes and return values */ public Response deleteObject( String moduleName, String dataModelName, String dataModelId ) { final HttpDelete request = new HttpDelete( this.yambasBase + "apps/" + this.appName + "/models/" + moduleName + "/" + dataModelName + "/" + dataModelId ); setAuthorizationHeader( request ); request.addHeader( "ContentType", "application/json" ); request.addHeader( "x-apiomat-apikey", this.apiKey ); request.addHeader( "x-apiomat-system", this.system.toString( ) ); try { final HttpResponse response = this.client.execute( request ); return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * Deletes static data, either image or file * * @param id the file id * @param isImage indicates whether this is an image or a file * @return request object to check status codes and return values */ public Response deleteStaticData( String id, final boolean isImage ) { final HttpDelete request = new HttpDelete( this.yambasBase + "apps/" + this.appName + "/data/" + ( isImage ? "images/" : "files/" ) + id ); request.addHeader( "Content-Type", "application/octet-stream" ); request.addHeader( "x-apiomat-apikey", this.apiKey ); request.addHeader( "x-apiomat-system", this.system.toString( ) ); try { final HttpResponse response = this.client.execute( request ); return new Response( response ); } catch ( final IOException e ) { e.printStackTrace( ); } return null; }
/** * @see ExceptionMapperResource#throwFailSafe() */ @Test public void testInternalError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/failsafe"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("internal", result.get("code")); Assert.assertNull(result.get("message")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwFailSafe2() */ @Test public void testInternalError2() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/failsafe2"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("internal", result.get("code")); Assert.assertNull(result.get("message")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwFailSafe2() */ @Test public void testInternalError3() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/failsafe3"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("internal", result.get("code")); Assert.assertNull(result.get("message")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwDataIntegrityException() */ @Test public void testIntegrityForeignError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/integrity-foreign"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_PRECONDITION_FAILED, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("integrity-foreign", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("assignment/project", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwDataIntegrityUnknownException() */ @Test public void testIntegrityUnknownError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/integrity-unknown"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_PRECONDITION_FAILED, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("integrity-unknown", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("Any SQL error", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
private void assertUnavailable(final String path) throws IOException, ClientProtocolException, JsonParseException, JsonMappingException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + path); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_SERVICE_UNAVAILABLE, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertNull(result.get("message")); Assert.assertEquals("database-down", result.get("code")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwCommunicationException() */ @Test public void testCommunicationException() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/ldap"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_SERVICE_UNAVAILABLE, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("Connection refused", result.get("message")); Assert.assertEquals("ldap-down", result.get("code")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwMailSendException() */ @Test public void testMailSendException() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/mail"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_SERVICE_UNAVAILABLE, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertNull(result.get("message")); Assert.assertEquals("mail-down", result.get("code")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwTechnical() */ @Test public void testTechnicalErrorWithCause() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/technical"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("message", result.get("message")); Assert.assertEquals("technical", result.get("code")); Assert.assertNotNull(result.get("cause")); @SuppressWarnings("unchecked") final Map<?, ?> cause = (Map<String, String>) result.get("cause"); Assert.assertEquals("message", cause.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwBusiness() */ @Test public void testBusinessError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/business"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals(BusinessException.KEY_UNKNOW_ID, result.get("message")); Assert.assertEquals("business", result.get("code")); Assert.assertNull(result.get("cause")); @SuppressWarnings("unchecked") final List<Object> parameters = (List<Object>) result.get("parameters"); Assert.assertNotNull(parameters); Assert.assertEquals(2, parameters.size()); Assert.assertEquals("parameter1", parameters.get(0)); Assert.assertEquals("parameter2", parameters.get(1)); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwWebApplication() */ @Test public void testJaxRSError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/jax-rs"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("internal", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("HTTP 500 Internal Server Error", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwJSonMapping() */ @Test public void testJSonMappingError() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/json-mapping"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_BAD_REQUEST, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); Assert.assertEquals("{errors={dialDouble=[{rule=Double}]}}", new ObjectMapperTrim().readValue(content, HashMap.class).toString()); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
@Test public void testJaxRS404Error() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/unknow"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_NOT_FOUND, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("internal", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("HTTP 404 Not Found", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwAuthenticationException() */ @Test public void testAuthenticationException() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/security-401"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_UNAUTHORIZED, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("security", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("message", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwNotImplemented() */ @Test public void notImplemented() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/not-implemented"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("not-implemented", result.get("code")); Assert.assertNull(result.get("cause")); Assert.assertEquals("message", result.get("message")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }
/** * @see ExceptionMapperResource#throwTransactionSystemException() */ @Test public void testUnknownTransactionnalException() throws IOException { final HttpDelete httpdelete = new HttpDelete(BASE_URI + RESOURCE + "/transaction-commit"); HttpResponse response = null; try { response = httpclient.execute(httpdelete); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode()); final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class); Assert.assertEquals("message", result.get("message")); Assert.assertEquals("technical", result.get("code")); Assert.assertNull(result.get("cause")); } finally { if (response != null) { response.getEntity().getContent().close(); } } }