Return-Path: X-Original-To: apmail-camel-commits-archive@www.apache.org Delivered-To: apmail-camel-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 28D9517B52 for ; Thu, 15 Jan 2015 09:53:13 +0000 (UTC) Received: (qmail 85777 invoked by uid 500); 15 Jan 2015 09:53:14 -0000 Delivered-To: apmail-camel-commits-archive@camel.apache.org Received: (qmail 85672 invoked by uid 500); 15 Jan 2015 09:53:14 -0000 Mailing-List: contact commits-help@camel.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@camel.apache.org Delivered-To: mailing list commits@camel.apache.org Received: (qmail 85531 invoked by uid 99); 15 Jan 2015 09:53:14 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 15 Jan 2015 09:53:14 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id 2A592A43D55; Thu, 15 Jan 2015 09:53:14 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: cschneider@apache.org To: commits@camel.apache.org Date: Thu, 15 Jan 2015 09:53:18 -0000 Message-Id: In-Reply-To: <870b455ded3444f380697a26863aa931@git.apache.org> References: <870b455ded3444f380697a26863aa931@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [06/23] camel git commit: CAMEL-8239 Split jetty8 and jetty9 support into separate modules http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpTwoServerPortsTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpTwoServerPortsTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpTwoServerPortsTest.java new file mode 100644 index 0000000..52510b1 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpTwoServerPortsTest.java @@ -0,0 +1,75 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +/** + * @version + */ +public class HttpTwoServerPortsTest extends BaseJettyTest { + + private int port1; + private int port2; + + @Test + public void testTwoServerPorts() throws Exception { + String reply = template.requestBody("direct:a", "World", String.class); + assertEquals("Bye World", reply); + + reply = template.requestBody("direct:b", "Camel", String.class); + assertEquals("Hi Camel", reply); + + reply = template.requestBody("direct:a", "Earth", String.class); + assertEquals("Bye Earth", reply); + + reply = template.requestBody("direct:b", "Moon", String.class); + assertEquals("Hi Moon", reply); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + port1 = getPort(); + port2 = getNextPort(); + + from("direct:a").to("http://localhost:" + port1 + "/myapp"); + + from("direct:b").to("http://localhost:" + port2 + "/myotherapp"); + + from("jetty://http://localhost:" + port1 + "/myapp").process(new Processor() { + public void process(Exchange exchange) throws Exception { + String in = exchange.getIn().getBody(String.class); + exchange.getOut().setBody("Bye " + in); + } + }); + + from("jetty://http://localhost:" + port2 + "/myotherapp").process(new Processor() { + public void process(Exchange exchange) throws Exception { + String in = exchange.getIn().getBody(String.class); + exchange.getOut().setBody("Hi " + in); + } + }); + } + }; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpUrlRewriteTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpUrlRewriteTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpUrlRewriteTest.java new file mode 100644 index 0000000..d97c9f3 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpUrlRewriteTest.java @@ -0,0 +1,63 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.impl.JndiRegistry; +import org.junit.Test; + +public class HttpUrlRewriteTest extends BaseJettyTest { + + private int port1; + private int port2; + + @Override + protected JndiRegistry createRegistry() throws Exception { + JndiRegistry jndi = super.createRegistry(); + jndi.bind("myRewrite", new MyUrlRewrite()); + return jndi; + } + + @Test + public void testUrlRewrite() throws Exception { + MockEndpoint mock = getMockEndpoint("mock:result"); + mock.expectedMessageCount(1); + + String response = template.requestBody("http://localhost:" + port1 + "/foo?phrase=Bye", "Camel", String.class); + assertEquals("Get a wrong response", "Bye Camel", response); + + assertMockEndpointsSatisfied(); + } + + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() { + port1 = getPort(); + port2 = getNextPort(); + + from("jetty:http://localhost:" + port1 + "?matchOnUriPrefix=true") + .to("http://localhost:" + port2 + "?throwExceptionOnFailure=false&bridgeEndpoint=true&urlRewrite=#myRewrite"); + + from("jetty://http://localhost:" + port2 + "/bar") + .transform().simple("${header.phrase} ${body}") + .to("mock:result"); + } + }; + } + +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAddSslConnectorPropertiesTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAddSslConnectorPropertiesTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAddSslConnectorPropertiesTest.java new file mode 100644 index 0000000..53753fd --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAddSslConnectorPropertiesTest.java @@ -0,0 +1,55 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.net.URISyntaxException; +import java.net.URL; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; + +public class HttpsRouteAddSslConnectorPropertiesTest extends HttpsRouteTest { + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws URISyntaxException { + // START SNIPPET: e1 + // keystore path + URL keyStoreUrl = this.getClass().getClassLoader().getResource("jsse/localhost.ks"); + String path = keyStoreUrl.toURI().getPath(); + + JettyHttpComponent jetty = context.getComponent("jetty", JettyHttpComponent.class); + setSSLProps(jetty, path, pwd, pwd); + // END SNIPPET: e1 + + from("jetty:https://localhost:" + port1 + "/test").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello").process(proc); + + from("jetty:https://localhost:" + port2 + "/test").to("mock:b"); + } + + }; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAliasTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAliasTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAliasTest.java new file mode 100644 index 0000000..1c99e5d --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteAliasTest.java @@ -0,0 +1,67 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.net.URISyntaxException; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.util.jsse.KeyManagersParameters; +import org.apache.camel.util.jsse.KeyStoreParameters; +import org.apache.camel.util.jsse.SSLContextParameters; + +public class HttpsRouteAliasTest extends HttpsRouteTest { + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws URISyntaxException { + JettyHttpComponent jetty = context.getComponent("jetty", JettyHttpComponent.class); + + KeyStoreParameters ksp = new KeyStoreParameters(); + ksp.setResource(this.getClass().getClassLoader().getResource("jsse/localhost-alias.ks").toString()); + ksp.setPassword(pwd); + + KeyManagersParameters kmp = new KeyManagersParameters(); + kmp.setKeyPassword(pwd); + kmp.setKeyStore(ksp); + + SSLContextParameters sslContextParameters = new SSLContextParameters(); + sslContextParameters.setKeyManagers(kmp); + + // Specify "server" cert alias + sslContextParameters.setCertAlias("server"); + + jetty.setSslContextParameters(sslContextParameters); + + setSSLProps(jetty, "", "asdfasdfasdfdasfs", "sadfasdfasdfas"); + + from("jetty:https://localhost:" + port1 + "/test").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello").process(proc); + + from("jetty:https://localhost:" + port2 + "/test").to("mock:b"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSetupWithSystemPropsTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSetupWithSystemPropsTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSetupWithSystemPropsTest.java new file mode 100644 index 0000000..b569eed --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSetupWithSystemPropsTest.java @@ -0,0 +1,63 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.net.URL; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Before; + +public class HttpsRouteSetupWithSystemPropsTest extends HttpsRouteTest { + + @Override + @Before + public void setUp() throws Exception { + // ensure jsse clients can validate the self signed dummy localhost cert, + // use the server keystore as the trust store for these tests + URL trustStoreUrl = this.getClass().getClassLoader().getResource("jsse/localhost.ks"); + setSystemProp("javax.net.ssl.trustStore", trustStoreUrl.getPath()); + + // START SNIPPET: e1 + // setup SSL using system properties + setSystemProp("org.eclipse.jetty.ssl.keystore", trustStoreUrl.getPath()); + setSystemProp("org.eclipse.jetty.ssl.keypassword", pwd); + setSystemProp("org.eclipse.jetty.ssl.password", pwd); + // END SNIPPET: e1 + + super.setUp(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() { + from("jetty:https://localhost:" + port1 + "/test").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello").process(proc); + + from("jetty:https://localhost:" + port2 + "/test").to("mock:b"); + } + }; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInComponentTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInComponentTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInComponentTest.java new file mode 100644 index 0000000..378f77c --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInComponentTest.java @@ -0,0 +1,63 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.net.URISyntaxException; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.util.jsse.KeyManagersParameters; +import org.apache.camel.util.jsse.KeyStoreParameters; +import org.apache.camel.util.jsse.SSLContextParameters; + +public class HttpsRouteSslContextParametersInComponentTest extends HttpsRouteTest { + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws URISyntaxException { + JettyHttpComponent jetty = getContext().getComponent("jetty", JettyHttpComponent.class); + + KeyStoreParameters ksp = new KeyStoreParameters(); + ksp.setResource(this.getClass().getClassLoader().getResource("jsse/localhost.ks").toString()); + ksp.setPassword(pwd); + + KeyManagersParameters kmp = new KeyManagersParameters(); + kmp.setKeyPassword(pwd); + kmp.setKeyStore(ksp); + + SSLContextParameters sslContextParameters = new SSLContextParameters(); + sslContextParameters.setKeyManagers(kmp); + jetty.setSslContextParameters(sslContextParameters); + // NOTE: These are here to check that they are properly ignored. + setSSLProps(jetty, "", "asdfasdfasdfdasfs", "sadfasdfasdfas"); + + from("jetty:https://localhost:" + port1 + "/test").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello").process(proc); + + from("jetty:https://localhost:" + port2 + "/test").to("mock:b"); + } + }; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInUriTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInUriTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInUriTest.java new file mode 100644 index 0000000..43c8349 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteSslContextParametersInUriTest.java @@ -0,0 +1,71 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.net.URISyntaxException; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.impl.JndiRegistry; +import org.apache.camel.util.jsse.KeyManagersParameters; +import org.apache.camel.util.jsse.KeyStoreParameters; +import org.apache.camel.util.jsse.SSLContextParameters; + +public class HttpsRouteSslContextParametersInUriTest extends HttpsRouteTest { + + @Override + protected JndiRegistry createRegistry() throws Exception { + KeyStoreParameters ksp = new KeyStoreParameters(); + ksp.setResource(this.getClass().getClassLoader().getResource("jsse/localhost.ks").toString()); + ksp.setPassword(pwd); + + KeyManagersParameters kmp = new KeyManagersParameters(); + kmp.setKeyPassword(pwd); + kmp.setKeyStore(ksp); + + SSLContextParameters sslContextParameters = new SSLContextParameters(); + sslContextParameters.setKeyManagers(kmp); + + JndiRegistry registry = super.createRegistry(); + registry.bind("sslContextParameters", sslContextParameters); + + return registry; + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws URISyntaxException { + JettyHttpComponent jetty = getContext().getComponent("jetty", JettyHttpComponent.class); + // NOTE: These are here to check that they are properly ignored. + setSSLProps(jetty, "", "asdfasdfasdfdasfs", "sadfasdfasdfas"); + + from("jetty:https://localhost:" + port1 + "/test?sslContextParametersRef=sslContextParameters").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello?sslContextParametersRef=sslContextParameters").process(proc); + + from("jetty:https://localhost:" + port2 + "/test?sslContextParametersRef=sslContextParameters").to("mock:b"); + } + }; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteTest.java new file mode 100644 index 0000000..56cf84b --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteTest.java @@ -0,0 +1,210 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.SocketException; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.apache.camel.Exchange; +import org.apache.camel.Message; +import org.apache.camel.Processor; +import org.apache.camel.RuntimeCamelException; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.test.junit4.CamelTestSupport; +import org.eclipse.jetty.util.ssl.SslContextFactory; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +public class HttpsRouteTest extends BaseJettyTest { + + private static final String NULL_VALUE_MARKER = CamelTestSupport.class.getCanonicalName(); + + protected String expectedBody = "world!"; + protected String pwd = "changeit"; + protected Properties originalValues = new Properties(); + protected int port1; + protected int port2; + + public String getHttpProducerScheme() { + return "https://"; + } + + @Override + @Before + public void setUp() throws Exception { + port1 = getNextPort(); + port2 = getNextPort(port1 + 1); + + super.setUp(); + // ensure jsse clients can validate the self signed dummy localhost cert, + // use the server keystore as the trust store for these tests + URL trustStoreUrl = this.getClass().getClassLoader().getResource("jsse/localhost.ks"); + setSystemProp("javax.net.ssl.trustStore", trustStoreUrl.toURI().getPath()); + } + + @Override + @After + public void tearDown() throws Exception { + restoreSystemProperties(); + super.tearDown(); + } + + protected void setSystemProp(String key, String value) { + String originalValue = System.setProperty(key, value); + originalValues.put(key, originalValue != null ? originalValue : NULL_VALUE_MARKER); + } + + protected void restoreSystemProperties() { + for (Object key : originalValues.keySet()) { + Object value = originalValues.get(key); + if (NULL_VALUE_MARKER.equals(value)) { + System.getProperties().remove(key); + } else { + System.setProperty((String)key, (String)value); + } + } + } + + @Test + public void testEndpoint() throws Exception { + // these tests does not run well on Windows + if (isPlatform("windows")) { + return; + } + + MockEndpoint mockEndpointA = resolveMandatoryEndpoint("mock:a", MockEndpoint.class); + mockEndpointA.expectedBodiesReceived(expectedBody); + MockEndpoint mockEndpointB = resolveMandatoryEndpoint("mock:b", MockEndpoint.class); + mockEndpointB.expectedBodiesReceived(expectedBody); + + invokeHttpEndpoint(); + + mockEndpointA.assertIsSatisfied(); + mockEndpointB.assertIsSatisfied(); + List list = mockEndpointA.getReceivedExchanges(); + Exchange exchange = list.get(0); + assertNotNull("exchange", exchange); + + Message in = exchange.getIn(); + assertNotNull("in", in); + + Map headers = in.getHeaders(); + + log.info("Headers: " + headers); + + assertTrue("Should be more than one header but was: " + headers, headers.size() > 0); + } + + @Test + public void testEndpointWithoutHttps() throws Exception { + // these tests does not run well on Windows + if (isPlatform("windows")) { + return; + } + + MockEndpoint mockEndpoint = resolveMandatoryEndpoint("mock:a", MockEndpoint.class); + try { + template.sendBodyAndHeader("http://localhost:" + port1 + "/test", expectedBody, "Content-Type", "application/xml"); + fail("expect exception on access to https endpoint via http"); + } catch (RuntimeCamelException expected) { + } + assertTrue("mock endpoint was not called", mockEndpoint.getExchanges().isEmpty()); + } + + @Test + public void testHelloEndpoint() throws Exception { + // these tests does not run well on Windows + if (isPlatform("windows")) { + return; + } + + ByteArrayOutputStream os = new ByteArrayOutputStream(); + InputStream is = new URL("https://localhost:" + port1 + "/hello").openStream(); + int c; + while ((c = is.read()) >= 0) { + os.write(c); + } + + String data = new String(os.toByteArray()); + assertEquals("Hello World", data); + } + + @Test + public void testHelloEndpointWithoutHttps() throws Exception { + // these tests does not run well on Windows + if (isPlatform("windows")) { + return; + } + + try { + new URL("http://localhost:" + port1 + "/hello").openStream(); + fail("expected SocketException on use ot http"); + } catch (SocketException expected) { + } + } + + protected void invokeHttpEndpoint() throws IOException { + template.sendBodyAndHeader(getHttpProducerScheme() + "localhost:" + port1 + "/test", expectedBody, "Content-Type", "application/xml"); + template.sendBodyAndHeader(getHttpProducerScheme() + "localhost:" + port2 + "/test", expectedBody, "Content-Type", "application/xml"); + } + + protected void configureSslContextFactory(SslContextFactory sslContextFactory) { + sslContextFactory.setKeyManagerPassword(pwd); + sslContextFactory.setKeyStorePassword(pwd); + URL keyStoreUrl = this.getClass().getClassLoader().getResource("jsse/localhost.ks"); + try { + sslContextFactory.setKeyStorePath(keyStoreUrl.toURI().getPath()); + } catch (URISyntaxException e) { + throw new RuntimeException(e.getMessage(), e); + } + sslContextFactory.setTrustStoreType("JKS"); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws URISyntaxException { + JettyHttpComponent componentJetty = (JettyHttpComponent) context.getComponent("jetty"); + componentJetty.setSslPassword(pwd); + componentJetty.setSslKeyPassword(pwd); + URL keyStoreUrl = this.getClass().getClassLoader().getResource("jsse/localhost.ks"); + componentJetty.setKeystore(keyStoreUrl.toURI().getPath()); + + from("jetty:https://localhost:" + port1 + "/test").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello").process(proc); + + from("jetty:https://localhost:" + port2 + "/test").to("mock:b"); + } + }; + } +} + http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteWithSslConnectorPropertiesTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteWithSslConnectorPropertiesTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteWithSslConnectorPropertiesTest.java new file mode 100644 index 0000000..b85bd61 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/HttpsRouteWithSslConnectorPropertiesTest.java @@ -0,0 +1,56 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.net.URISyntaxException; +import java.net.URL; +import java.util.HashMap; +import java.util.Map; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; + +public class HttpsRouteWithSslConnectorPropertiesTest extends HttpsRouteTest { + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws URISyntaxException { + // START SNIPPET: e1 + // keystore path + URL keyStoreUrl = this.getClass().getClassLoader().getResource("jsse/localhost.ks"); + String path = keyStoreUrl.toURI().getPath(); + + JettyHttpComponent jetty = getContext().getComponent("jetty", JettyHttpComponent.class); + setSSLProps(jetty, path, pwd, pwd); + // END SNIPPET: e1 + + from("jetty:https://localhost:" + port1 + "/test").to("mock:a"); + + Processor proc = new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Hello World"); + } + }; + from("jetty:https://localhost:" + port1 + "/hello").process(proc); + + from("jetty:https://localhost:" + port2 + "/test").to("mock:b"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/InterfacesTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/InterfacesTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/InterfacesTest.java new file mode 100644 index 0000000..d28af2f --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/InterfacesTest.java @@ -0,0 +1,135 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.io.IOException; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.net.URL; +import java.util.Enumeration; + +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +public class InterfacesTest extends BaseJettyTest { + private static boolean isMacOS = System.getProperty("os.name").startsWith("Mac"); + private String remoteInterfaceAddress; + + private int port1; + private int port2; + private int port3; + private int port4; + + public InterfacesTest() throws IOException { + // Retrieve an address of some remote network interface + Enumeration interfaces = NetworkInterface.getNetworkInterfaces(); + + while (remoteInterfaceAddress == null && interfaces.hasMoreElements()) { + NetworkInterface interfaze = interfaces.nextElement(); + Enumeration addresses = interfaze.getInetAddresses(); + if (addresses.hasMoreElements()) { + InetAddress nextAddress = addresses.nextElement(); + if (nextAddress.isLoopbackAddress() || !nextAddress.isReachable(2000)) { + continue; + } + if (nextAddress instanceof Inet6Address) { + continue; + } else { + remoteInterfaceAddress = nextAddress.getHostAddress(); + } + } + } + } + + @Test + public void testLocalInterfaceHandled() throws IOException, InterruptedException { + int expectedMessages = (remoteInterfaceAddress != null) ? 3 : 2; + getMockEndpoint("mock:endpoint").expectedMessageCount(expectedMessages); + + URL localUrl = new URL("http://localhost:" + port1 + "/testRoute"); + String localResponse = context.getTypeConverter().convertTo(String.class, localUrl.openStream()); + assertEquals("local", localResponse); + + if (!isMacOS) { + localUrl = new URL("http://127.0.0.1:" + port2 + "/testRoute"); + } else { + localUrl = new URL("http://localhost:" + port2 + "/testRoute"); + } + localResponse = context.getTypeConverter().convertTo(String.class, localUrl.openStream()); + assertEquals("local-differentPort", localResponse); + + if (remoteInterfaceAddress != null) { + URL url = new URL("http://" + remoteInterfaceAddress + ":" + port3 + "/testRoute"); + String remoteResponse = context.getTypeConverter().convertTo(String.class, url.openStream()); + assertEquals("remote", remoteResponse); + } + + assertMockEndpointsSatisfied(); + } + + @Test + public void testAllInterfaces() throws Exception { + int expectedMessages = (remoteInterfaceAddress != null) ? 2 : 1; + getMockEndpoint("mock:endpoint").expectedMessageCount(expectedMessages); + + URL localUrl = new URL("http://localhost:" + port4 + "/allInterfaces"); + String localResponse = context.getTypeConverter().convertTo(String.class, localUrl.openStream()); + assertEquals("allInterfaces", localResponse); + + if (remoteInterfaceAddress != null) { + URL url = new URL("http://" + remoteInterfaceAddress + ":" + port4 + "/allInterfaces"); + String remoteResponse = context.getTypeConverter().convertTo(String.class, url.openStream()); + assertEquals("allInterfaces", remoteResponse); + } + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + + @Override + public void configure() throws Exception { + port1 = getNextPort(); + port2 = getNextPort(port1 + 1); + port3 = getNextPort(port2 + 1); + port4 = getNextPort(port3 + 1); + + from("jetty:http://localhost:" + port1 + "/testRoute") + .setBody().constant("local") + .to("mock:endpoint"); + + from("jetty:http://localhost:" + port2 + "/testRoute") + .setBody().constant("local-differentPort") + .to("mock:endpoint"); + + if (remoteInterfaceAddress != null) { + from("jetty:http://" + remoteInterfaceAddress + ":" + port3 + "/testRoute") + .setBody().constant("remote") + .to("mock:endpoint"); + } + + from("jetty:http://0.0.0.0:" + port4 + "/allInterfaces") + .setBody().constant("allInterfaces") + .to("mock:endpoint"); + + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCallHttpThenExceptionTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCallHttpThenExceptionTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCallHttpThenExceptionTest.java new file mode 100644 index 0000000..7468083 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCallHttpThenExceptionTest.java @@ -0,0 +1,71 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +/** + * @version + */ +public class JettyCallHttpThenExceptionTest extends BaseJettyTest { + + @Test + public void testJettyCallHttpThenException() throws Exception { + getMockEndpoint("mock:foo").expectedBodiesReceived("World"); + getMockEndpoint("mock:bar").expectedBodiesReceived("Bye World"); + + Exchange reply = template.request("http://localhost:{{port}}/myserver?throwExceptionOnFailure=false", new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getIn().setBody("World"); + } + }); + + assertMockEndpointsSatisfied(); + + assertNotNull(reply); + assertTrue(reply.getOut().getBody(String.class).startsWith("java.lang.IllegalArgumentException: I cannot do this")); + assertEquals(500, reply.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE)); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + from("jetty://http://localhost:{{port}}/myserver") + .to("log:A") + // remove http headers before and after invoking http service + .removeHeaders("CamelHttp*") + .to("http://localhost:{{port}}/other") + .removeHeaders("CamelHttp*") + .to("mock:bar") + // now just force an exception immediately + .throwException(new IllegalArgumentException("I cannot do this")); + + from("jetty://http://localhost:{{port}}/other") + .convertBodyTo(String.class) + .to("log:C") + .to("mock:foo") + .transform().simple("Bye ${body}"); + } + }; + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCamelHttpUrlCBRTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCamelHttpUrlCBRTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCamelHttpUrlCBRTest.java new file mode 100644 index 0000000..7e48c9f --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyCamelHttpUrlCBRTest.java @@ -0,0 +1,55 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Exchange; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +public class JettyCamelHttpUrlCBRTest extends BaseJettyTest { + + @Test + public void testCamelHttpUrl() throws Exception { + getMockEndpoint("mock:foo").expectedBodiesReceived("Hello World"); + getMockEndpoint("mock:foo").expectedHeaderReceived("beer", "yes"); + getMockEndpoint("mock:foo").expectedHeaderReceived(Exchange.HTTP_METHOD, "POST"); + getMockEndpoint("mock:foo").expectedHeaderReceived(Exchange.HTTP_URL, "http://localhost:" + getPort() + "/foo"); + getMockEndpoint("mock:foo").expectedHeaderReceived(Exchange.HTTP_URI, "/foo"); + getMockEndpoint("mock:foo").expectedHeaderReceived(Exchange.HTTP_QUERY, "beer=yes"); + getMockEndpoint("mock:foo").expectedHeaderReceived(Exchange.HTTP_PATH, ""); + + String out = template.requestBody("http://localhost:{{port}}/foo?beer=yes", "Hello World", String.class); + assertEquals("Bye World", out); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + from("jetty:http://0.0.0.0:{{port}}/foo") + .filter().simple("${header.CamelHttpUrl} contains 'foo'") + .to("mock:foo") + .end() + .transform().constant("Bye World"); + } + }; + } + +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyComponentSpringConfiguredTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyComponentSpringConfiguredTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyComponentSpringConfiguredTest.java new file mode 100644 index 0000000..7814e02 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyComponentSpringConfiguredTest.java @@ -0,0 +1,48 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.test.spring.CamelSpringTestSupport; +import org.junit.Ignore; +import org.junit.Test; +import org.springframework.context.support.AbstractApplicationContext; +import org.springframework.context.support.ClassPathXmlApplicationContext; + +/** + * + */ +public class JettyComponentSpringConfiguredTest extends CamelSpringTestSupport { + + @Override + protected boolean useJmx() { + return true; + } + + @Override + protected AbstractApplicationContext createApplicationContext() { + return new ClassPathXmlApplicationContext("org/apache/camel/component/jetty/JettyComponentSpringConfiguredTest.xml"); + } + + @Test + @Ignore("run manual test") + public void testJetty2() throws Exception { + assertNotNull("Should have jetty2 component", context.hasComponent("jetty2")); + + String reply = template.requestBody("jetty2:http://localhost:9090/myapp", "Camel", String.class); + assertEquals("Hello Camel", reply); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentBasedRouteTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentBasedRouteTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentBasedRouteTest.java new file mode 100644 index 0000000..2a60a34 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentBasedRouteTest.java @@ -0,0 +1,66 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.junit.Test; + +/** + * Unit test with a simple route test. + */ +public class JettyContentBasedRouteTest extends BaseJettyTest { + + private String serverUri = "http://localhost:" + getPort() + "/myservice"; + + @Test + public void testSendOne() throws Exception { + MockEndpoint mock = getMockEndpoint("mock:one"); + + mock.expectedHeaderReceived("one", "true"); + + template.requestBody(serverUri + "?one=true", null, Object.class); + + assertMockEndpointsSatisfied(); + } + + @Test + public void testSendOther() throws Exception { + MockEndpoint mock = getMockEndpoint("mock:other"); + + mock.expectedHeaderReceived("two", "true"); + + template.requestBody(serverUri + "?two=true", null, Object.class); + + assertMockEndpointsSatisfied(); + } + + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws Exception { + // START SNIPPET: e1 + from("jetty:" + serverUri) + .choice() + .when().simple("${header.one}").to("mock:one") + .otherwise() + .to("mock:other"); + // END SNIPPET: e1 + } + }; + } + +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentTypeTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentTypeTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentTypeTest.java new file mode 100644 index 0000000..d2262a8 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContentTypeTest.java @@ -0,0 +1,110 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Endpoint; +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.util.ExchangeHelper; +import org.apache.camel.util.MessageHelper; +import org.junit.Test; + +/** + * Unit test for content-type + */ +public class JettyContentTypeTest extends BaseJettyTest { + + protected void sendMessageWithContentType(String charset, boolean usingGZip) { + Endpoint endpoint = context.getEndpoint("http://localhost:{{port}}/myapp/myservice"); + Exchange exchange = endpoint.createExchange(); + exchange.getIn().setBody("123"); + exchange.getIn().setHeader("User", "Claus"); + exchange.getIn().setHeader("SOAPAction", "test"); + if (charset == null) { + exchange.getIn().setHeader("Content-Type", "text/xml"); + } else { + exchange.getIn().setHeader("Content-Type", "text/xml; charset=" + charset); + } + if (usingGZip) { + exchange.getIn().setHeader(Exchange.CONTENT_ENCODING, "gzip"); + } + template.send(endpoint, exchange); + + String body = exchange.getOut().getBody(String.class); + assertEquals("OK", body); + assertEquals("Get a wrong content-type ", MessageHelper.getContentType(exchange.getOut()), "text/xml"); + } + + @Test + public void testSameContentType() throws Exception { + sendMessageWithContentType(null, false); + sendMessageWithContentType("UTF-8", false); + } + + @Test + public void testContentTypeWithGZipEncoding() throws Exception { + sendMessageWithContentType(null, true); + sendMessageWithContentType("UTF-8", true); + } + + @Test + public void testMixedContentType() throws Exception { + Endpoint endpoint = context.getEndpoint("http://localhost:{{port}}/myapp/myservice"); + Exchange exchange = endpoint.createExchange(); + exchange.getIn().setBody("123"); + exchange.getIn().setHeader("Content-Type", "text/xml"); + template.send(endpoint, exchange); + + String body = exchange.getOut().getBody(String.class); + assertEquals("FAIL", body); + assertEquals("Get a wrong content-type ", MessageHelper.getContentType(exchange.getOut()), "text/plain"); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws Exception { + from("jetty:http://localhost:{{port}}/myapp/myservice").process(new MyBookService()); + } + }; + } + + public class MyBookService implements Processor { + public void process(Exchange exchange) throws Exception { + String user = exchange.getIn().getHeader("User", String.class); + String contentType = ExchangeHelper.getContentType(exchange); + String body = exchange.getIn().getBody(String.class); + String encoding = exchange.getIn().getHeader(Exchange.CONTENT_ENCODING, String.class); + if (encoding != null) { + exchange.getOut().setHeader(Exchange.CONTENT_ENCODING, encoding); + } + if ("Claus".equals(user) && contentType.startsWith("text/xml") && body.equals("123")) { + assertEquals("test", exchange.getIn().getHeader("SOAPAction", String.class)); + if (contentType.endsWith("UTF-8")) { + assertEquals("Get a wrong charset name.", exchange.getProperty(Exchange.CHARSET_NAME, String.class), "UTF-8"); + } + exchange.getOut().setBody("OK"); + exchange.getOut().setHeader("Content-Type", "text/xml"); + } else { + exchange.getOut().setBody("FAIL"); + exchange.getOut().setHeader(Exchange.CONTENT_TYPE, "text/plain"); + } + } + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContinuationDisabledTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContinuationDisabledTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContinuationDisabledTest.java new file mode 100644 index 0000000..135241f --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyContinuationDisabledTest.java @@ -0,0 +1,59 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +/** + * @version + */ +public class JettyContinuationDisabledTest extends BaseJettyTest { + + @Test + public void testJettyContinuationDisabled() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); + + String out = template.requestBody("http://localhost:{{port}}/myservice", null, String.class); + assertEquals("Bye World", out); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + // disable continuation + JettyHttpComponent jetty = context.getComponent("jetty", JettyHttpComponent.class); + jetty.setUseContinuation(false); + + from("jetty:http://localhost:{{port}}/myservice") + .process(new Processor() { + public void process(Exchange exchange) throws Exception { + Thread.sleep(1000); + exchange.getOut().setBody("Bye World"); + } + }) + .to("mock:result"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEnableJmxTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEnableJmxTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEnableJmxTest.java new file mode 100644 index 0000000..d5b0adb --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEnableJmxTest.java @@ -0,0 +1,157 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.lang.management.ManagementFactory; +import java.util.List; +import java.util.Set; +import javax.management.MBeanServer; +import javax.management.MBeanServerConnection; +import javax.management.MBeanServerFactory; +import javax.management.ObjectName; + +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.junit.Test; + +public class JettyEnableJmxTest extends BaseJettyTest { + + private String serverUri0; + private String serverUri1; + private String serverUri2; + private String serverUri3; + private MBeanServerConnection mbsc; + + @Override + public void tearDown() throws Exception { + releaseMBeanServers(); + mbsc = null; + super.tearDown(); + disableJMX(); + } + + @Override + public void setUp() throws Exception { + enableJMX(); + releaseMBeanServers(); + super.setUp(); + mbsc = getMBeanConnection(); + } + + @Test + public void testEnableJmxProperty() throws Exception { + MockEndpoint mock = getMockEndpoint("mock:result"); + String expectedBody = "foo"; + mock.expectedBodiesReceived(expectedBody, expectedBody, expectedBody, expectedBody); + mock.expectedHeaderReceived("x", "foo"); + + template.requestBody(serverUri0 + "&x=foo", null, Object.class); + template.requestBody(serverUri1 + "&x=foo", null, Object.class); + template.requestBody(serverUri2 + "&x=foo", null, Object.class); + template.requestBody(serverUri3 + "&x=foo", null, Object.class); + + assertMockEndpointsSatisfied(); + + Set s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 2 Jetty Server: " + s, 2, s.size()); + } + + @Test + public void testShutdown() throws Exception { + Set s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 2 Jetty Server: " + s, 2, s.size()); + + context.stop(); + + s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 0 Jetty Server: " + s, 0, s.size()); + } + + @Test + public void testEndpointDisconnect() throws Exception { + Set s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 2 Jetty Server: " + s, 2, s.size()); + + context.stopRoute("route0"); + + s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 1 Jetty Server: " + s, 1, s.size()); + + context.stopRoute("route2"); + context.stopRoute("route3"); + + s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 1 Jetty Server: " + s, 1, s.size()); + + context.stopRoute("route1"); + + s = mbsc.queryNames(new ObjectName("org.eclipse.jetty.server:type=server,*"), null); + assertEquals("Could not find 0 Jetty Server: " + s, 0, s.size()); + } + + @Override + protected boolean useJmx() { + return true; + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() throws Exception { + serverUri0 = "http://localhost:" + getNextPort() + "/myservice?enableJmx=true"; + serverUri1 = "http://localhost:" + getNextPort() + "/myservice?enableJmx=true"; + serverUri2 = "http://localhost:" + getNextPort() + "/myservice?enableJmx=false"; + serverUri3 = "http://localhost:" + getNextPort() + "/myservice?enableJmx=false"; + + from("jetty:" + serverUri0) + .routeId("route0") + .setBody().simple("${in.header.x}") + .to("mock:result"); + + from("jetty:" + serverUri1) + .routeId("route1") + .setBody().simple("${in.header.x}") + .to("mock:result"); + + from("jetty:" + serverUri2) + .routeId("route2") + .setBody().simple("${in.header.x}") + .to("mock:result"); + + from("jetty:" + serverUri3) + .routeId("route3") + .setBody().simple("${in.header.x}") + .to("mock:result"); + } + }; + } + + protected void releaseMBeanServers() { + List servers = MBeanServerFactory.findMBeanServer(null); + + for (MBeanServer server : servers) { + MBeanServerFactory.releaseMBeanServer(server); + } + } + + protected MBeanServerConnection getMBeanConnection() throws Exception { + if (mbsc == null) { + mbsc = ManagementFactory.getPlatformMBeanServer(); + } + return mbsc; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointContinuationDisabledTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointContinuationDisabledTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointContinuationDisabledTest.java new file mode 100644 index 0000000..933d1c8 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointContinuationDisabledTest.java @@ -0,0 +1,55 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +/** + * @version + */ +public class JettyEndpointContinuationDisabledTest extends BaseJettyTest { + + @Test + public void testJettyContinuationDisabled() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); + + String out = template.requestBody("http://localhost:{{port}}/myservice", null, String.class); + assertEquals("Bye World", out); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + from("jetty:http://localhost:{{port}}/myservice?useContinuation=false") + .process(new Processor() { + public void process(Exchange exchange) throws Exception { + Thread.sleep(1000); + exchange.getOut().setBody("Bye World"); + } + }) + .to("mock:result"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointSetHttpTraceTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointSetHttpTraceTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointSetHttpTraceTest.java new file mode 100644 index 0000000..111d268 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyEndpointSetHttpTraceTest.java @@ -0,0 +1,61 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.builder.RouteBuilder; +import org.apache.commons.httpclient.HttpClient; +import org.apache.commons.httpclient.methods.TraceMethod; +import org.junit.Test; + +public class JettyEndpointSetHttpTraceTest extends BaseJettyTest { + + private int portTraceOn = getNextPort(); + private int portTraceOff = getNextPort(); + + @Test + public void testTraceDisabled() throws Exception { + HttpClient httpclient = new HttpClient(); + TraceMethod trace = new TraceMethod("http://localhost:" + portTraceOff + "/myservice"); + httpclient.executeMethod(trace); + + // TRACE shouldn't be allowed by default + assertTrue(trace.getStatusCode() == 405); + trace.releaseConnection(); + } + + @Test + public void testTraceEnabled() throws Exception { + HttpClient httpclient = new HttpClient(); + TraceMethod trace = new TraceMethod("http://localhost:" + portTraceOn + "/myservice"); + httpclient.executeMethod(trace); + + // TRACE is now allowed + assertTrue(trace.getStatusCode() == 200); + trace.releaseConnection(); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + from("jetty:http://localhost:" + portTraceOff + "/myservice").to("log:foo"); + from("jetty:http://localhost:" + portTraceOn + "/myservice?traceEnabled=true").to("log:bar"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHandle404Test.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHandle404Test.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHandle404Test.java new file mode 100644 index 0000000..12282de --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHandle404Test.java @@ -0,0 +1,107 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Component; +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.http.HttpOperationFailedException; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.processor.aggregate.AggregationStrategy; +import org.junit.Test; + +/** + * Based on end user on forum how to get the 404 error code in his enrich aggregator + * + * @version + */ +public class JettyHandle404Test extends BaseJettyTest { + + public String getProducerUrl() { + return "http://localhost:{{port}}/myserver?user=Camel"; + } + + @Test + public void testSimulate404() throws Exception { + MockEndpoint mock = getMockEndpoint("mock:result"); + mock.expectedBodiesReceived("Page not found"); + mock.expectedHeaderReceived(Exchange.HTTP_RESPONSE_CODE, 404); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Test + public void testCustomerErrorHandler() throws Exception { + String response = template.requestBody("http://localhost:{{port}}/myserver1?throwExceptionOnFailure=false", null, String.class); + // look for the error message which is sent by MyErrorHandler + assertTrue("Get a wrong error message", response.indexOf("MyErrorHandler") > 0); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + // setup the jetty component with the customx error handler + JettyHttpComponent jettyComponent = (JettyHttpComponent)context.getComponent("jetty"); + jettyComponent.setErrorHandler(new MyErrorHandler()); + + // disable error handling + errorHandler(noErrorHandler()); + + from("direct:start").enrich("direct:tohttp", new AggregationStrategy() { + public Exchange aggregate(Exchange original, Exchange resource) { + // get the response code + Integer code = resource.getIn().getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class); + assertEquals(404, code.intValue()); + return resource; + } + }).to("mock:result"); + + // use this sub route as indirection to handle the HttpOperationFailedException + // and set the data back as data on the exchange to not cause the exception to be thrown + from("direct:tohttp") + .doTry() + .to(getProducerUrl()) + .doCatch(HttpOperationFailedException.class) + .process(new Processor() { + public void process(Exchange exchange) { + // copy the caused exception values to the exchange as we want the response in the regular exchange + // instead as an exception that will get thrown and thus the route breaks + HttpOperationFailedException cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, HttpOperationFailedException.class); + exchange.getOut().setHeader(Exchange.HTTP_RESPONSE_CODE, cause.getStatusCode()); + exchange.getOut().setBody(cause.getResponseBody()); + } + }) + .end(); + + + // this is our jetty server where we simulate the 404 + from("jetty://http://localhost:{{port}}/myserver") + .process(new Processor() { + public void process(Exchange exchange) throws Exception { + exchange.getOut().setBody("Page not found"); + exchange.getOut().setHeader(Exchange.HTTP_RESPONSE_CODE, 404); + } + }); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBindingRefTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBindingRefTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBindingRefTest.java new file mode 100644 index 0000000..54e6989 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBindingRefTest.java @@ -0,0 +1,101 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import java.io.IOException; + +import org.apache.camel.CamelExecutionException; +import org.apache.camel.Exchange; +import org.apache.camel.Message; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.http.HttpOperationFailedException; +import org.apache.camel.impl.JndiRegistry; +import org.apache.camel.spi.HeaderFilterStrategy; +import org.junit.Test; + +/** + * Unit test for jetty http binding ref option. + */ +public class JettyHttpBindingRefTest extends BaseJettyTest { + + @Test + public void testDefaultJettyHttpBinding() throws Exception { + Object out = template.requestBody("jetty:http://localhost:{{port}}/myapp/myservice?jettyHttpBindingRef=default", "Hello World"); + assertEquals("Bye World", context.getTypeConverter().convertTo(String.class, out)); + + try { + template.requestBody("jetty:http://localhost:{{port}}/myapp/myotherservice", "Hello World"); + fail(); + } catch (CamelExecutionException e) { + assertNotNull(e.getCause()); + assertTrue(e.getCause() instanceof HttpOperationFailedException); + + assertFalse("Not exactly the message the server returned.".equals(((HttpOperationFailedException) e.getCause()).getResponseBody())); + } + } + + @Test + public void testCustomJettyHttpBinding() throws Exception { + + Object out = template.requestBody("jetty:http://localhost:{{port}}/myapp/myotherservice?jettyHttpBindingRef=myownbinder", "Hello World"); + assertEquals("Not exactly the message the server returned.", context.getTypeConverter().convertTo(String.class, out)); + } + + @Override + protected JndiRegistry createRegistry() throws Exception { + JndiRegistry jndi = super.createRegistry(); + jndi.bind("default", new DefaultJettyHttpBinding()); + jndi.bind("myownbinder", new MyJettyHttpBinding()); + return jndi; + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + errorHandler(noErrorHandler()); + + from("jetty:http://localhost:{{port}}/myapp/myservice").transform().constant("Bye World"); + + from("jetty:http://localhost:{{port}}/myapp/myotherservice").process(new Processor() { + public void process(Exchange exchange) throws Exception { + throw new IllegalStateException("Not implemented"); + } + }); + } + }; + } + + // START SNIPPET: e1 + public class MyJettyHttpBinding extends DefaultJettyHttpBinding { + @Override + protected void populateResponse(Exchange exchange, JettyContentExchange httpExchange, Message in, + HeaderFilterStrategy strategy, int responseCode) throws IOException { + + Message answer = exchange.getOut(); + + answer.setHeaders(in.getHeaders()); + answer.setHeader(Exchange.HTTP_RESPONSE_CODE, responseCode); + answer.setBody("Not exactly the message the server returned."); + } + } + // END SNIPPET: e1 + +} + http://git-wip-us.apache.org/repos/asf/camel/blob/0d96e56d/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBridgeEncodedPathTest.java ---------------------------------------------------------------------- diff --git a/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBridgeEncodedPathTest.java b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBridgeEncodedPathTest.java new file mode 100644 index 0000000..a09afc4 --- /dev/null +++ b/components/camel-jetty9/src/test/java/org/apache/camel/component/jetty/JettyHttpBridgeEncodedPathTest.java @@ -0,0 +1,66 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.jetty; + +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.junit.Test; + +public class JettyHttpBridgeEncodedPathTest extends BaseJettyTest { + + private int port1; + private int port2; + + @Test + public void testJettyHttpClient() throws Exception { + String response = template.requestBody("http://localhost:" + port2 + "/jettyTestRouteA?param1=%2B447777111222", null, String.class); + assertEquals("Get a wrong response", "param1=+447777111222", response); + } + + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + public void configure() { + + port1 = getPort(); + port2 = getNextPort(); + + errorHandler(noErrorHandler()); + + Processor serviceProc = new Processor() { + public void process(Exchange exchange) throws Exception { + // %2B becomes decoded to a space + Object s = exchange.getIn().getHeader("param1"); + // can be either + or %2B + assertTrue(s.equals(" 447777111222") || s.equals("+447777111222") || s.equals("%2B447777111222")); + + // send back the query + exchange.getOut().setBody(exchange.getIn().getHeader(Exchange.HTTP_QUERY)); + } + }; + from("jetty://http://localhost:" + port2 + "/jettyTestRouteA?matchOnUriPrefix=true") + .log("Using JettyTestRouteA route: CamelHttpPath=[${header.CamelHttpPath}], CamelHttpUri=[${header.CamelHttpUri}]") + .to("jetty://http://localhost:" + port1 + "/jettyTestRouteB?throwExceptionOnFailure=false&bridgeEndpoint=true"); + + from("jetty://http://localhost:" + port1 + "/jettyTestRouteB?matchOnUriPrefix=true") + .log("Using JettyTestRouteB route: CamelHttpPath=[${header.CamelHttpPath}], CamelHttpUri=[${header.CamelHttpUri}]") + .process(serviceProc); + } + }; + } + +}