View Javadoc

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