View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.transport.http.functional;
8   
9   import org.mule.api.MuleEventContext;
10  import org.mule.api.MuleMessage;
11  import org.mule.api.config.MuleProperties;
12  import org.mule.api.transformer.TransformerException;
13  import org.mule.config.i18n.LocaleMessageHandler;
14  import org.mule.module.client.MuleClient;
15  import org.mule.tck.functional.EventCallback;
16  import org.mule.tck.functional.FunctionalTestComponent;
17  import org.mule.tck.junit4.FunctionalTestCase;
18  import org.mule.tck.junit4.rule.DynamicPort;
19  import org.mule.transformer.AbstractTransformer;
20  import org.mule.transport.http.HttpConnector;
21  import org.mule.transport.http.HttpConstants;
22  import org.mule.util.SystemUtils;
23  import org.mule.util.concurrent.Latch;
24  
25  import java.net.URLEncoder;
26  import java.util.HashMap;
27  import java.util.Locale;
28  import java.util.Map;
29  
30  import edu.emory.mathcs.backport.java.util.concurrent.TimeUnit;
31  import junit.framework.Assert;
32  import org.apache.commons.httpclient.Header;
33  import org.apache.commons.httpclient.HttpClient;
34  import org.apache.commons.httpclient.methods.GetMethod;
35  import org.junit.Rule;
36  import org.junit.Test;
37  
38  import static org.junit.Assert.assertEquals;
39  import static org.junit.Assert.assertNotNull;
40  import static org.junit.Assert.assertTrue;
41  import static org.junit.Assert.fail;
42  
43  public class HttpEncodingNonAsciiFunctionalTestCase extends FunctionalTestCase
44  {
45      private static final String ENCODING_JP = "ISO-2022-JP";
46      private static final String FORM_ENCODED_CONTENT_TYPE_HEADER = "application/x-www-form-urlencoded; charset=" + ENCODING_JP;
47      private static final String PLAIN_CONTENT_TYPE_HEADER = "text/plain; charset=" + ENCODING_JP;
48  
49      @Rule
50      public DynamicPort dynamicPort = new DynamicPort("port1");
51  
52      @Override
53      protected String getConfigResources()
54      {
55          return "http-encoding-non-ascii-test.xml";
56      }
57  
58      @Override
59      protected boolean isDisabledInThisEnvironment()
60      {
61          // MULE-5268
62          return SystemUtils.isIbmJDK();
63      }
64  
65      @Test
66      public void testSendViaGET() throws Exception
67      {
68          Latch latch = new Latch();
69          setupAssertIncomingMessage(HttpConstants.METHOD_GET, latch, PLAIN_CONTENT_TYPE_HEADER);
70  
71          String testMessage = getTestMessage(Locale.JAPAN);
72          String encodedPayload = URLEncoder.encode(testMessage, "ISO-2022-JP");
73          String url = String.format("http://localhost:%1d/get?%2s=%3s",
74              dynamicPort.getNumber(), HttpConnector.DEFAULT_HTTP_GET_BODY_PARAM_PROPERTY, encodedPayload);
75  
76          GetMethod method = new GetMethod(url);
77          method.addRequestHeader(HttpConstants.HEADER_CONTENT_TYPE, PLAIN_CONTENT_TYPE_HEADER);
78          int status = new HttpClient().executeMethod(method);
79          assertEquals(HttpConstants.SC_OK, status);
80  
81          assertTrue(latch.await(RECEIVE_TIMEOUT, TimeUnit.MILLISECONDS));
82          String expected = testMessage + " Received";
83          String response = method.getResponseBodyAsString();
84          assertEquals(expected, response);
85  
86          Header responseContentType = method.getResponseHeader(HttpConstants.HEADER_CONTENT_TYPE);
87          assertEquals("text/plain;charset=EUC-JP", responseContentType.getValue());
88      }
89  
90      @Test
91      public void testSendViaPOST() throws Exception
92      {
93          Object payload = getTestMessage(Locale.JAPAN);
94  
95          Map<String, Object> messageProperties = new HashMap<String, Object>();
96          messageProperties.put(MuleProperties.MULE_ENCODING_PROPERTY, "ISO-2022-JP");
97  
98          doTestSend(HttpConstants.METHOD_POST, payload, messageProperties, PLAIN_CONTENT_TYPE_HEADER);
99      }
100 
101     @Test
102     public void testSendViaPostMap() throws Exception
103     {
104         Map<String, Object> messagePayload = new HashMap<String, Object>();
105         messagePayload.put("body", getTestMessage(Locale.JAPAN));
106 
107         Map<String, Object> messageProperties = new HashMap<String, Object>();
108         messageProperties.put(MuleProperties.MULE_ENCODING_PROPERTY, "ISO-2022-JP");
109         doTestSend("POSTMap", messagePayload, messageProperties, FORM_ENCODED_CONTENT_TYPE_HEADER);
110     }
111 
112     private void doTestSend(String method, Object messagePayload, Map<String, Object> messageProperties,
113         String expectedContentTypeHeader) throws Exception
114     {
115         Latch latch = new Latch();
116 
117         setupAssertIncomingMessage(method, latch, expectedContentTypeHeader);
118 
119         MuleClient client = new MuleClient(muleContext);
120         MuleMessage reply = client.send("vm://sendBy" + method, messagePayload, messageProperties);
121 
122         assertTrue(latch.await(RECEIVE_TIMEOUT, TimeUnit.MILLISECONDS));
123         assertNotNull(reply);
124         assertEquals("EUC-JP", reply.getEncoding());
125         assertEquals(getTestMessage(Locale.JAPAN) + " Received", reply.getPayloadAsString());
126     }
127 
128     private void setupAssertIncomingMessage(String method, final Latch latch,
129         final String expectedContentTypeHeader) throws Exception
130     {
131         FunctionalTestComponent ftc = getFunctionalTestComponent("testReceive" + method);
132         ftc.setEventCallback(new EventCallback()
133         {
134             public void eventReceived(MuleEventContext context, Object serviceComponent) throws Exception
135             {
136                 MuleMessage message = context.getMessage();
137 
138                 Assert.assertEquals(expectedContentTypeHeader,
139                     message.getInboundProperty(HttpConstants.HEADER_CONTENT_TYPE, null));
140                 Assert.assertEquals("ISO-2022-JP", message.getEncoding());
141 
142                 Object payload = message.getPayload();
143                 if (payload instanceof String)
144                 {
145                     assertEquals(getTestMessage(Locale.JAPAN), payload);
146                 }
147                 else
148                 {
149                     fail();
150                 }
151 
152                 latch.countDown();
153             }
154         });
155     }
156 
157     private String getTestMessage(Locale locale)
158     {
159         return LocaleMessageHandler.getString("test-data", locale,
160             "HttpEncodingNonAsciiFunctionalTestCase.getMessage", new Object[]{});
161     }
162 
163     public static class ParamMapToString extends AbstractTransformer
164     {
165         @Override
166         @SuppressWarnings("unchecked")
167         protected Object doTransform(Object src, String outputEncoding) throws TransformerException
168         {
169             Map<String, Object> map = (Map<String, Object>)src;
170             return map.get(HttpConnector.DEFAULT_HTTP_GET_BODY_PARAM_PROPERTY);
171         }
172     }
173 }