/**
* Further addresses the use of EJBs as JAX-RS components.
*
* @throws Exception
*/
@Test
public void testAsJaxRSResource() throws Exception {
log.info("entering testAsJaxRSResource()");
// Create book.
ClientRequest request = new ClientRequest("http://localhost:8080/resteasy-ejb-test/create/");
Book book1 = new Book("RESTEasy: the Sequel");
request.body(Constants.MEDIA_TYPE_TEST_XML, book1);
ClientResponse<?> response = request.post();
log.info("Status: " + response.getStatus());
assertEquals(200, response.getStatus());
int id1 = response.getEntity(int.class);
log.info("id: " + id1);
Assert.assertEquals(Counter.INITIAL_VALUE, id1);
// Create another book.
request = new ClientRequest("http://localhost:8080/resteasy-ejb-test/create/");
Book book2 = new Book("RESTEasy: It's Alive");
request.body(Constants.MEDIA_TYPE_TEST_XML, book2);
response = request.post();
log.info("Status: " + response.getStatus());
assertEquals(200, response.getStatus());
int id2 = response.getEntity(int.class);
log.info("id: " + id2);
Assert.assertEquals(Counter.INITIAL_VALUE + 1, id2);
// Retrieve first book.
request = new ClientRequest("http://localhost:8080/resteasy-ejb-test/book/" + id1);
request.accept(Constants.MEDIA_TYPE_TEST_XML);
response = request.get();
log.info("Status: " + response.getStatus());
assertEquals(200, response.getStatus());
Book result = response.getEntity(Book.class);
log.info("book: " + book1);
Assert.assertEquals(book1, result);
// Retrieve second book.
request = new ClientRequest("http://localhost:8080/resteasy-ejb-test/book/" + id2);
request.accept(Constants.MEDIA_TYPE_TEST_XML);
response = request.get();
log.info("Status: " + response.getStatus());
assertEquals(200, response.getStatus());
result = response.getEntity(Book.class);
log.info("book: " + book2);
Assert.assertEquals(book2, result);
// Verify that EJBBookReader and EJBBookWriter have been used, twice on each side.
request = new ClientRequest("http://localhost:8080/resteasy-ejb-test/uses/4");
response = request.get();
log.info("Status: " + response.getStatus());
assertEquals(200, response.getStatus());
response.releaseConnection();
// Reset counter.
request = new ClientRequest("http://localhost:8080/resteasy-ejb-test/reset");
response = request.get();
log.info("Status: " + response.getStatus());
assertEquals(204, response.getStatus());
response.releaseConnection();
}
/**
* Verify that EJBBookReader and EJBBookWriterImpl are correctly injected into EJBBookResource.
*
* @throws Exception
*/
@Test
public void testVerifyInjectionJaxRs() throws Exception {
log.info("starting testVerifyInjectionJaxRs()");
ClientRequest request =
new ClientRequest("http://localhost:8080/resteasy-ejb-test/verifyInjection/");
ClientResponse<?> response = request.get();
log.info("result: " + response.getEntity(Integer.class));
assertEquals(200, response.getStatus());
assertEquals(200, response.getEntity(Integer.class).intValue());
}
// @Test
public void testInheritance() throws Exception {
ResteasyDeployment dep = deployment;
ClientRequest request = new ClientRequest(generateURL("/datacenters/1"));
ClientResponse res = request.get();
Assert.assertEquals(200, res.getStatus());
DataCenter dc = (DataCenter) res.getEntity(DataCenter.class);
Assert.assertEquals(dc.getName(), "Bill");
request = new ClientRequest(generateURL("/datacenters/1"));
res = request.body("application/xml", dc).put();
Assert.assertEquals(200, res.getStatus());
dc = (DataCenter) res.getEntity(DataCenter.class);
Assert.assertEquals(dc.getName(), "Bill");
}
/**
* Gets a list of custom deployers from the dtgov server.
*
* @throws DtgovApiClientException
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public List<Deployer> getCustomDeployers() throws DtgovApiClientException {
try {
String url =
String.format("%1$s/system/config/deployers/custom", this.endpoint); // $NON-NLS-1$
ClientRequest request = createClientRequest(url);
request.accept(MediaType.APPLICATION_XML);
ClientResponse<List> response = request.get(new GenericType<List<Deployer>>() {});
response.getEntity();
List<Deployer> deployers = response.getEntity();
return deployers;
} catch (Throwable e) {
throw new DtgovApiClientException(e);
}
}
private void checkResponse(ClientResponse<?> responseObj) throws Exception {
ClientResponse<?> test = BaseClientResponse.copyFromError(responseObj);
responseObj.resetStream();
if (test.getResponseStatus() == javax.ws.rs.core.Response.Status.BAD_REQUEST) {
throw new BadRequestException(test.getEntity(String.class));
} else if (test.getResponseStatus() != javax.ws.rs.core.Response.Status.OK) {
throw new Exception(
"Request operation failed. Response status = "
+ test.getResponseStatus()
+ "\n\n"
+ test.getEntity(String.class));
} else {
logger.debug("Response: " + test.getEntity(String.class));
}
}
/**
* Handles the possibility of an error found in the response.
*
* @param response
* @throws Exception
*/
private <T> void handlePotentialServerError(ClientResponse<T> response) throws Exception {
String contentType =
String.valueOf(response.getMetadata().getFirst(HttpHeaderNames.CONTENT_TYPE));
if (response.getStatus() == 500) {
Exception error = new Exception(Messages.i18n.format("UNKNOWN_SRAMP_ERROR")); // $NON-NLS-1$
if (MediaType.APPLICATION_SRAMP_ATOM_EXCEPTION.equals(contentType)) {
try {
SrampAtomException entity = response.getEntity(SrampAtomException.class);
if (entity != null) error = entity;
} catch (Throwable t) {
t.printStackTrace();
}
}
throw error;
}
if (response.getStatus() == 404 || response.getStatus() == 415) {
SrampAtomException error =
new SrampAtomException(Messages.i18n.format("ENDPOINT_NOT_FOUND")); // $NON-NLS-1$
throw error;
}
if (response.getStatus() == 403) {
SrampAtomException error =
new SrampAtomException(Messages.i18n.format("AUTHORIZATION_FAILED")); // $NON-NLS-1$
throw error;
}
if (response.getStatus() == 401) {
SrampAtomException error =
new SrampAtomException(Messages.i18n.format("AUTHENTICATION_FAILED")); // $NON-NLS-1$
throw error;
}
}
@Test
@RunAsClient
public void putJsonProjectIteration() throws Exception {
final ProjectIteration newIteration = new ProjectIteration("new-iteration");
new ResourceRequest(
getRestEndpointUrl("/projects/p/sample-project/iterations/i/" + newIteration.getId()),
"PUT",
getAuthorizedEnvironment()) {
@Override
protected void prepareRequest(ClientRequest request) {
request.body(
MediaTypes.APPLICATION_ZANATA_PROJECT_ITERATION_JSON, jsonMarshal(newIteration));
};
@Override
protected void onResponse(ClientResponse response) {
assertThat(response.getStatus(), is(Status.CREATED.getStatusCode())); // 201
}
}.run();
// Retreive it again
IProjectIterationResource iterationClient =
super.createProxy(
createClientProxyFactory(TRANSLATOR, TRANSLATOR_KEY),
IProjectIterationResource.class,
"/projects/p/sample-project/iterations/i/" + newIteration.getId());
ClientResponse<ProjectIteration> getResponse = iterationClient.get();
assertThat(getResponse.getStatus(), is(Status.OK.getStatusCode())); // 200
ProjectIteration it = getResponse.getEntity();
assertThat(it.getId(), is("new-iteration"));
}
/**
* Creates a WSDL artifact in the s-ramp repository.
*
* @return the new artifact
* @throws Exception
*/
private XmlDocument createXmlArtifact() throws Exception {
String artifactFileName = "PO.xml";
InputStream contentStream =
this.getClass().getResourceAsStream("/sample-files/core/" + artifactFileName);
try {
ClientRequest request = clientRequest("/s-ramp/core/XmlDocument");
request.header("Slug", artifactFileName);
request.body("application/xml", contentStream);
ClientResponse<Entry> response = request.post(Entry.class);
Entry entry = response.getEntity();
Assert.assertEquals(artifactFileName, entry.getTitle());
BaseArtifactType arty = ArtificerAtomUtils.unwrapSrampArtifact(entry);
Assert.assertTrue(arty instanceof XmlDocument);
XmlDocument doc = (XmlDocument) arty;
Assert.assertEquals(artifactFileName, doc.getName());
Long size = doc.getContentSize();
Assert.assertTrue(size >= 825L);
Assert.assertEquals("application/xml", doc.getContentType());
return doc;
} finally {
IOUtils.closeQuietly(contentStream);
}
}
private JaxbCommandResponse<?> executeTaskCommand(String deploymentId, Command<?> command)
throws Exception {
List<Command<?>> commands = new ArrayList<Command<?>>();
commands.add(command);
String urlString =
new URL(
deploymentUrl,
deploymentUrl.getPath() + "rest/runtime/" + DEPLOYMENT_ID + "/execute")
.toExternalForm();
logger.info("Client request to: " + urlString);
ClientRequest restRequest = new ClientRequest(urlString);
JaxbCommandsRequest commandMessage = new JaxbCommandsRequest(commands);
assertNotNull("Commands are null!", commandMessage.getCommands());
assertTrue("Commands are empty!", commandMessage.getCommands().size() > 0);
String body = JaxbSerializationProvider.convertJaxbObjectToString(commandMessage);
restRequest.body(MediaType.APPLICATION_XML, body);
ClientResponse<JaxbCommandsResponse> responseObj = restRequest.post(JaxbCommandsResponse.class);
checkResponse(responseObj);
JaxbCommandsResponse cmdsResp = responseObj.getEntity();
return cmdsResp.getResponses().get(0);
}
@Test
public void testAsync() throws Exception {
ClientRequest request = new ClientRequest("http://localhost:8080/");
ClientResponse<String> response = request.get(String.class);
Assert.assertEquals(200, response.getStatus());
Assert.assertEquals("hello", response.getEntity());
}
@Test
public void testFailure() throws Exception {
try {
String testName = "testFailure";
startup();
deployTopic(testName);
ClientRequest request = new ClientRequest(generateURL("/topics/" + testName));
ClientResponse<?> response = request.head();
response.releaseConnection();
Assert.assertEquals(200, response.getStatus());
Link sender =
MessageTestBase.getLinkByTitle(
manager.getQueueManager().getLinkStrategy(), response, "create");
System.out.println("create: " + sender);
Link pushSubscriptions =
MessageTestBase.getLinkByTitle(
manager.getQueueManager().getLinkStrategy(), response, "push-subscriptions");
System.out.println("push subscriptions: " + pushSubscriptions);
PushTopicRegistration reg = new PushTopicRegistration();
reg.setDurable(true);
XmlLink target = new XmlLink();
target.setHref("http://localhost:3333/error");
target.setRelationship("uri");
reg.setTarget(target);
reg.setDisableOnFailure(true);
reg.setMaxRetries(3);
reg.setRetryWaitMillis(10);
response = pushSubscriptions.request().body("application/xml", reg).post();
Assert.assertEquals(201, response.getStatus());
Link pushSubscription = response.getLocationLink();
response.releaseConnection();
ClientResponse<?> res = sender.request().body("text/plain", Integer.toString(1)).post();
res.releaseConnection();
Assert.assertEquals(201, res.getStatus());
Thread.sleep(5000);
response = pushSubscription.request().get();
PushTopicRegistration reg2 = response.getEntity(PushTopicRegistration.class);
response.releaseConnection();
Assert.assertEquals(reg.isDurable(), reg2.isDurable());
Assert.assertEquals(reg.getTarget().getHref(), reg2.getTarget().getHref());
Assert.assertFalse(reg2.isEnabled());
response.releaseConnection();
String destination = reg2.getDestination();
ClientSession session =
manager.getQueueManager().getSessionFactory().createSession(false, false, false);
ClientSession.QueueQuery query = session.queueQuery(new SimpleString(destination));
Assert.assertFalse(query.isExists());
manager.getQueueManager().getPushStore().removeAll();
} finally {
shutdown();
}
}
public <T> T execute(Command<T> command) {
ClientRequest restRequest = new ClientRequest(url);
try {
restRequest.body(MediaType.APPLICATION_XML, new JaxbCommandsRequest(deploymentId, command));
ClientResponse<Object> response = restRequest.post(Object.class);
if (response.getResponseStatus() == Status.OK) {
JaxbCommandsResponse commandResponse = response.getEntity(JaxbCommandsResponse.class);
List<JaxbCommandResponse<?>> responses = commandResponse.getResponses();
if (responses.size() == 0) {
return null;
} else if (responses.size() == 1) {
JaxbCommandResponse<?> responseObject = responses.get(0);
if (responseObject instanceof JaxbExceptionResponse) {
JaxbExceptionResponse exceptionResponse = (JaxbExceptionResponse) responseObject;
String causeMessage = exceptionResponse.getCauseMessage();
throw new RuntimeException(
exceptionResponse.getMessage()
+ (causeMessage == null ? "" : " Caused by: " + causeMessage));
} else {
return (T) responseObject.getResult();
}
} else {
throw new RuntimeException("Unexpected number of results: " + responses.size());
}
} else {
// TODO error handling
throw new RuntimeException("REST request error code " + response.getResponseStatus());
}
} catch (Exception e) {
throw new RuntimeException("Unable to execute REST request: " + e.getMessage(), e);
}
}
private JsonNode sendRequest() throws Exception {
final ClientRequest clientRequest = new ClientRequest(SEARCH_URI);
// For capturing Response
final ClientResponse<String> clientResponse = clientRequest.get(String.class);
// Collecting response in JsonNode
final JsonNode jsonReply = new ObjectMapper().readTree(clientResponse.getEntity());
return jsonReply;
}
@Test
public void testGetCustomerByIdUsingClientRequest() throws Exception {
// deploymentUrl = new URL("http://localhost:8180/test/");
// GET http://localhost:8080/test/rest/customer/1
ClientRequest request =
new ClientRequest(deploymentUrl.toString() + RESOURCE_PREFIX + "/customer/1");
request.header("Accept", MediaType.APPLICATION_XML);
// we're expecting a String back
ClientResponse<String> responseObj = request.get(String.class);
Assert.assertEquals(200, responseObj.getStatus());
System.out.println("GET /customer/1 HTTP/1.1\n\n" + responseObj.getEntity());
String response = responseObj.getEntity().replaceAll("<\\?xml.*\\?>", "").trim();
Assert.assertEquals("<customer><id>1</id><name>Acme Corporation</name></customer>", response);
}
@Test
public void testRestUrlStartHumanTaskProcess() throws Exception {
// create REST request
String urlString =
new URL(
deploymentUrl,
deploymentUrl.getPath() + "rest/runtime/test/process/org.jbpm.humantask/start")
.toExternalForm();
ClientRequest restRequest = new ClientRequest(urlString);
// Get and check response
logger.debug(">> [org.jbpm.humantask/start]" + urlString);
ClientResponse responseObj = restRequest.post();
assertEquals(200, responseObj.getStatus());
JaxbProcessInstanceResponse processInstance =
(JaxbProcessInstanceResponse) responseObj.getEntity(JaxbProcessInstanceResponse.class);
long procInstId = processInstance.getId();
urlString =
new URL(deploymentUrl, deploymentUrl.getPath() + "rest/task/query?taskOwner=" + USER_ID)
.toExternalForm();
restRequest = new ClientRequest(urlString);
logger.debug(">> [task/query]" + urlString);
responseObj = restRequest.get();
assertEquals(200, responseObj.getStatus());
JaxbTaskSummaryListResponse taskSumlistResponse =
(JaxbTaskSummaryListResponse) responseObj.getEntity(JaxbTaskSummaryListResponse.class);
long taskId = findTaskId(procInstId, taskSumlistResponse.getResult());
urlString =
new URL(
deploymentUrl,
deploymentUrl.getPath() + "rest/task/" + taskId + "/start?userId=" + USER_ID)
.toExternalForm();
restRequest = new ClientRequest(urlString);
// Get response
logger.debug(">> [task/?/start] " + urlString);
responseObj = restRequest.post();
// Check response
checkResponse(responseObj);
}
// Success outcomes
@Test(
dataProvider = "testName",
dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createIntakeWithAuthRefs"})
public void readAndCheckAuthRefDocs(String testName) throws Exception {
// Perform setup.
testSetup(STATUS_OK, ServiceRequestType.READ);
// Get the auth ref docs and check them
OrgAuthorityClient orgAuthClient = new OrgAuthorityClient();
ClientResponse<AuthorityRefDocList> refDocListResp =
orgAuthClient.getReferencingObjects(orgAuthCSID, currentOwnerOrgCSID);
AuthorityRefDocList list = null;
try {
assertStatusCode(refDocListResp, testName);
list = refDocListResp.getEntity();
Assert.assertNotNull(list);
} finally {
if (refDocListResp != null) {
refDocListResp.releaseConnection();
}
}
// Optionally output additional data about list members for debugging.
boolean iterateThroughList = true;
int nIntakesFound = 0;
if (iterateThroughList && logger.isDebugEnabled()) {
List<AuthorityRefDocList.AuthorityRefDocItem> items = list.getAuthorityRefDocItem();
int i = 0;
logger.debug(testName + ": Docs that use: " + currentOwnerRefName);
for (AuthorityRefDocList.AuthorityRefDocItem item : items) {
logger.debug(
testName
+ ": list-item["
+ i
+ "] "
+ item.getDocType()
+ "("
+ item.getDocId()
+ ") Name:["
+ item.getDocName()
+ "] Number:["
+ item.getDocNumber()
+ "] in field:["
+ item.getSourceField()
+ "]");
if (knownIntakeId.equalsIgnoreCase(item.getDocId())) {
nIntakesFound++;
}
i++;
}
//
Assert.assertTrue((nIntakesFound == 2), "Did not find Intake (twice) with authref!");
}
}
@Test
public void testRestHistoryLogs() throws Exception {
String urlString =
new URL(
deploymentUrl,
deploymentUrl.getPath() + "rest/runtime/test/process/var-proc/start?map_x=initVal")
.toExternalForm();
ClientRequest restRequest = new ClientRequest(urlString);
// Get and check response
logger.debug(">> " + urlString);
ClientResponse responseObj = restRequest.post();
assertEquals(200, responseObj.getStatus());
JaxbProcessInstanceResponse processInstance =
(JaxbProcessInstanceResponse) responseObj.getEntity(JaxbProcessInstanceResponse.class);
long procInstId = processInstance.getId();
urlString =
new URL(
deploymentUrl,
deploymentUrl.getPath()
+ "rest/runtime/test/history/instance/"
+ procInstId
+ "/variable/x")
.toExternalForm();
restRequest = new ClientRequest(urlString);
logger.debug(">> [history/variables]" + urlString);
responseObj = restRequest.get();
assertEquals(200, responseObj.getStatus());
JaxbHistoryLogList logList =
(JaxbHistoryLogList) responseObj.getEntity(JaxbHistoryLogList.class);
List<AbstractJaxbHistoryObject> varLogList = logList.getHistoryLogList();
assertEquals("Incorrect number of variable logs", 4, varLogList.size());
for (AbstractJaxbHistoryObject<?> log : logList.getHistoryLogList()) {
JaxbVariableInstanceLog varLog = (JaxbVariableInstanceLog) log;
assertEquals("Incorrect variable id", "x", varLog.getVariableId());
assertEquals("Incorrect process id", "var-proc", varLog.getProcessId());
assertEquals("Incorrect process instance id", "var-proc", varLog.getProcessId());
}
}
@Test
public void showUser() {
ObjectMapper m = new ObjectMapper();
ObjectNode body = m.createObjectNode();
ClientResponse<JsonNode> response =
client.showUser(
(String) properties.getProperty(PROPERTY_NAME_CKAN_AUTHORIZATION_KEY), body);
if (response.getStatus() == Response.Status.OK.getStatusCode()) {
log.info(response.getEntity().toString());
}
}
@Ignore("needs mock connection to test with")
@Test
public void connect() {
CandlepinConnection conn = new CandlepinConnection(new CandlepinCommonTestConfig());
Credentials creds = new UsernamePasswordCredentials("admin", "admin");
OwnerClient client = conn.connect(OwnerClient.class, creds, "http://localhost:8080/candlepin/");
ClientResponse<Owner> resp = client.replicateOwner("admin");
assertNotNull(resp);
assertEquals(200, resp.getStatus());
Owner o = resp.getEntity();
assertNotNull(o);
System.out.println(o);
}
@Test(dependsOnMethods = {"createCollectionObject"})
public void updateCollectionObject() {
ClientResponse<CollectionObject> res = collectionObjectClient.getCollectionObject(updateId);
CollectionObject collectionObject = res.getEntity();
verbose(
"Got CollectionObject to update with ID: " + updateId,
collectionObject,
CollectionObject.class);
// collectionObject.setCsid("updated-" + updateId);
collectionObject.setObjectNumber("updated-" + collectionObject.getObjectNumber());
collectionObject.setObjectName("updated-" + collectionObject.getObjectName());
// make call to update service
res = collectionObjectClient.updateCollectionObject(updateId, collectionObject);
// check the response
CollectionObject updatedCollectionObject = res.getEntity();
Assert.assertEquals(updatedCollectionObject.getObjectName(), collectionObject.getObjectName());
verbose("updateCollectionObject: ", updatedCollectionObject, CollectionObject.class);
return;
}
@BeforeClass
public static void deployServer() throws InterruptedException {
System.out.println("server default charset: " + Charset.defaultCharset());
Map<String, Charset> charsets = Charset.availableCharsets();
Charset charset = null;
for (Iterator<String> it = charsets.keySet().iterator(); it.hasNext(); ) {
String cs = it.next();
if (!cs.equals(Charset.defaultCharset().name())) {
charset = charsets.get(cs);
break;
}
}
System.out.println("server using charset: " + charset);
System.out.println(TestServerExpand.class.getCanonicalName());
String separator = System.getProperty("file.separator");
String classpath = System.getProperty("java.class.path");
String path = System.getProperty("java.home") + separator + "bin" + separator + "java";
System.out.println("classpath: " + classpath);
System.out.println("path: " + path);
ProcessBuilder processBuilder =
new ProcessBuilder(path, "-cp", classpath, TestServerNoExpand.class.getCanonicalName());
try {
System.out.println("Starting server JVM");
process = processBuilder.start();
System.out.println("Started server JVM");
} catch (IOException e1) {
e1.printStackTrace();
}
ClientRequest request = new ClientRequest(generateURL("/junk"));
ClientResponse<?> response = null;
while (true) {
try {
response = request.get();
if (response.getStatus() == 200) {
System.out.println("Server started: " + response.getEntity(String.class));
break;
}
System.out.println("Waiting on server ...");
} catch (Exception e) {
// keep trying
}
System.out.println("Waiting for server");
Thread.sleep(1000);
}
}
/**
* The purpose of this method is to run the external REST request.
*
* @param url The url of the RESTful service
* @param mediaType The mediatype of the RESTful service
*/
private String runRequest(String url, MediaType mediaType) {
String result = null;
System.out.println("===============================================");
System.out.println("URL: " + url);
System.out.println("MediaType: " + mediaType.toString());
try {
// Using the RESTEasy libraries, initiate a client request
// using the url as a parameter
ClientRequest request = new ClientRequest(url);
// Be sure to set the mediatype of the request
request.accept(mediaType);
// Request has been made, now let's get the response
ClientResponse<String> response = request.get(String.class);
// Check the HTTP status of the request
// HTTP 200 indicates the request is OK
if (response.getStatus() != 200) {
throw new RuntimeException("Failed request with HTTP status: " + response.getStatus());
}
// We have a good response, let's now read it
BufferedReader br =
new BufferedReader(
new InputStreamReader(new ByteArrayInputStream(response.getEntity().getBytes())));
// Loop over the br in order to print out the contents
System.out.println("\n*** Response from Server ***\n");
String output = null;
while ((output = br.readLine()) != null) {
System.out.println(output);
result = output;
}
} catch (ClientProtocolException cpe) {
System.err.println(cpe);
} catch (IOException ioe) {
System.err.println(ioe);
} catch (Exception e) {
System.err.println(e);
}
System.out.println("\n===============================================");
return result;
}
@Test
public void testContentType() throws Exception {
String message =
"--boo\r\n"
+ "Content-Disposition: form-data; name=\"foo\"\r\n"
+ "Content-Transfer-Encoding: 8bit\r\n\r\n"
+ "bar\r\n"
+ "--boo--\r\n";
ClientRequest request = new ClientRequest(TEST_URI + "/mime");
request.body("multipart/form-data; boundary=boo", message.getBytes());
ClientResponse<String> response = request.post(String.class);
Assert.assertEquals("Status code is wrong.", 20, response.getStatus() / 10);
Assert.assertEquals(
"Response text is wrong",
MediaType.valueOf(TEXT_PLAIN_WITH_CHARSET_UTF_8),
MediaType.valueOf(response.getEntity()));
}
public Status doGet(String url, MediaType mediaType) throws Exception {
ClientRequest request = createClientRequest(url);
ClientResponse<String> result = null;
try {
if (mediaType != null) {
request.accept(mediaType);
}
addParams(request);
result = request.get(String.class);
LOGGER.info("O servico '{}' respondeu com a seguinte mensagem: {}.", url, result.getEntity());
return result.getResponseStatus();
} catch (Exception e) {
LOGGER.warn("Erro durante chamada ao metodo GET da URL: {}.", url, e);
throw e;
} finally {
releaseConnection(result);
}
}
private Link consumeOrder(Order order, Link consumeNext) throws Exception {
ClientResponse<?> response =
consumeNext
.request()
.header("Accept-Wait", "4")
.accept("application/xml")
.post(String.class);
Assert.assertEquals(200, response.getStatus());
Assert.assertEquals(
"application/xml", response.getHeaders().getFirst("Content-Type").toString().toLowerCase());
Order order2 = (Order) response.getEntity(Order.class);
Assert.assertEquals(order, order2);
consumeNext =
MessageTestBase.getLinkByTitle(
manager.getQueueManager().getLinkStrategy(), response, "consume-next");
Assert.assertNotNull(consumeNext);
response.releaseConnection();
return consumeNext;
}
public void retrieveCity() throws Exception {
ClientRequest request = new ClientRequest("http://api.geonames.org/postalCodeSearchJSON");
request.queryParameter("postalcode", order.getZip());
request.queryParameter("country", "DE");
request.queryParameter("username", "camunda");
request.accept("application/json");
ClientResponse<String> response = request.get(String.class);
JSONObject jsonObject = new JSONObject(response.getEntity());
JSONArray jsonArray = jsonObject.getJSONArray("postalCodes");
if (jsonArray.length() == 0) {
throw new BpmnError("CITY_NOT_FOUND");
}
String city = jsonArray.getJSONObject(0).getString("placeName");
log.info("### city retrieved: " + city);
order.setCity(city);
}
public Status doPut(String url, MediaType mediaType) throws Exception {
ClientRequest request = createClientRequest(url);
ClientResponse<String> result = null;
try {
addParams(request);
String type;
if (mediaType != null) {
LOGGER.info(String.format("Content-Type:%s", type = mediaType.toString()));
} else {
LOGGER.info(String.format("Content-Type:%s", type = "text/plain"));
}
addBody(request, type);
result = request.put(String.class);
LOGGER.info("O servico '{}' respondeu com a seguinte mensagem: {}.", url, result.getEntity());
return result.getResponseStatus();
} catch (Exception e) {
LOGGER.warn("Erro durante chamada ao metodo PUT da URL: {}.", url, e);
throw e;
} finally {
releaseConnection(result);
}
}
private <T> T doHttpMethod(String url, Class<T> clazz, MediaType accept, HTTPCommand<T> command) {
ClientRequest request = createClientRequest(url);
request.accept(accept);
ClientResponse<T> result = null;
try {
addParams(request);
result = command.execute(request, clazz);
if (result.getResponseStatus() == Response.Status.OK
|| result.getResponseStatus() == Response.Status.ACCEPTED) {
T entity;
LOGGER.info(
"O servico '{}' respondeu com a seguinte mensagem: {}",
url,
(entity = result.getEntity(clazz)).toString());
return entity;
}
} catch (Exception e) {
LOGGER.warn("Erro durante chamada na URL: {}.", url, e);
} finally {
releaseConnection(result);
}
return null;
}
@Test
public void testMetadata() throws Exception {
TransformationMetadata metadata =
RealMetadataFactory.fromDDL(
ObjectConverterUtil.convertFileToString(UnitTestUtil.getTestDataFile("northwind.ddl")),
"northwind",
"nw");
EdmDataServices eds = ODataEntitySchemaBuilder.buildMetadata(metadata.getMetadataStore());
Client client = mock(Client.class);
stub(client.getMetadataStore()).toReturn(metadata.getMetadataStore());
stub(client.getMetadata()).toReturn(eds);
MockProvider.CLIENT = client;
StringWriter sw = new StringWriter();
EdmxFormatWriter.write(eds, sw);
ClientRequest request =
new ClientRequest(TestPortProvider.generateURL("/odata/northwind/$metadata"));
ClientResponse<String> response = request.get(String.class);
Assert.assertEquals(200, response.getStatus());
Assert.assertEquals(sw.toString(), response.getEntity());
}
@Test
public void testSuccessFirst() throws Exception {
String testName = "AutoAckTopicTest.testSuccessFirst";
TopicDeployment deployment = new TopicDeployment();
deployment.setDuplicatesAllowed(true);
deployment.setDurableSend(false);
deployment.setName(testName);
manager.getTopicManager().deploy(deployment);
ClientRequest request = new ClientRequest(TestPortProvider.generateURL("/topics/" + testName));
ClientResponse<?> response = request.head();
response.releaseConnection();
Assert.assertEquals(200, response.getStatus());
Link sender = getLinkByTitle(manager.getTopicManager().getLinkStrategy(), response, "create");
Link subscriptions =
getLinkByTitle(manager.getTopicManager().getLinkStrategy(), response, "pull-subscriptions");
ClientResponse<?> res = subscriptions.request().post();
res.releaseConnection();
Assert.assertEquals(201, res.getStatus());
Link sub1 = res.getLocationLink();
Assert.assertNotNull(sub1);
Link consumeNext1 =
getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
Assert.assertNotNull(consumeNext1);
System.out.println("consumeNext1: " + consumeNext1);
res = subscriptions.request().post();
res.releaseConnection();
Assert.assertEquals(201, res.getStatus());
Link sub2 = res.getLocationLink();
Assert.assertNotNull(sub2);
Link consumeNext2 =
getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
Assert.assertNotNull(consumeNext2);
System.out.println("consumeNext2: " + consumeNext2);
res = sender.request().body("text/plain", "1").post();
res.releaseConnection();
Assert.assertEquals(201, res.getStatus());
res = sender.request().body("text/plain", "2").post();
res.releaseConnection();
Assert.assertEquals(201, res.getStatus());
res = consumeNext1.request().post(String.class);
Assert.assertEquals(200, res.getStatus());
Assert.assertEquals("1", res.getEntity(String.class));
res.releaseConnection();
consumeNext1 = getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
res = consumeNext1.request().post(String.class);
Assert.assertEquals(200, res.getStatus());
Assert.assertEquals("2", res.getEntity(String.class));
res.releaseConnection();
consumeNext1 = getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
res = consumeNext2.request().post(String.class);
Assert.assertEquals(200, res.getStatus());
Assert.assertEquals("1", res.getEntity(String.class));
res.releaseConnection();
consumeNext2 = getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
res = consumeNext2.request().post(String.class);
Assert.assertEquals(200, res.getStatus());
Assert.assertEquals("2", res.getEntity(String.class));
res.releaseConnection();
consumeNext2 = getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
Assert.assertEquals(204, sub1.request().delete().getStatus());
Assert.assertEquals(204, sub2.request().delete().getStatus());
}