| /* |
| * 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 freemarker.ext.servlet; |
| |
| import static freemarker.ext.servlet.FreemarkerServlet.*; |
| import static org.hamcrest.Matchers.*; |
| import static org.junit.Assert.*; |
| |
| import java.io.IOException; |
| import java.nio.charset.UnsupportedCharsetException; |
| import java.util.Locale; |
| |
| import javax.servlet.ServletContext; |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.springframework.mock.web.MockHttpServletRequest; |
| import org.springframework.mock.web.MockHttpServletResponse; |
| import org.springframework.mock.web.MockServletConfig; |
| import org.springframework.mock.web.MockServletContext; |
| |
| import freemarker.cache.ConditionalTemplateConfigurationFactory; |
| import freemarker.cache.FileNameGlobMatcher; |
| import freemarker.cache.FirstMatchTemplateConfigurationFactory; |
| import freemarker.cache.StringTemplateLoader; |
| import freemarker.cache.TemplateLoader; |
| import freemarker.core.Environment; |
| import freemarker.core.TemplateConfiguration; |
| import freemarker.template.Configuration; |
| import freemarker.template.Template; |
| import freemarker.template.TemplateException; |
| |
| public class FreemarkerServletTest { |
| |
| private static final String OUTPUT_FORMAT_HEADER_FTL = "outputFormatHeader.ftl"; |
| private static final String CONTENT_TYPE_ATTR_FTL = "contentTypeAttr.ftl"; |
| private static final String CONTENT_TYPE_ATTR_WITH_CHARSET_FTL = "contentTypeAttrWithCharset.ftl"; |
| private static final String FOO_FTL = "foo.ftl"; |
| private static final String FOO_SRC_UTF8_FTL = "foo-src-utf8.ftl"; |
| private static final String FOO_OUT_UTF8_FTL = "foo-out-utf8.ftl"; |
| private static final String STD_OUTPUT_FORMAT_HTML_FTL = "stdOutputFormatHTML.ftl"; |
| private static final String STD_OUTPUT_FORMAT_XML_FTL = "stdOutputFormatXML.ftl"; |
| private static final String STD_OUTPUT_FORMAT_XHTML_FTL = "stdOutputFormatXHTML.ftl"; |
| private static final String STD_OUTPUT_FORMAT_JAVA_SCRIPT_FTL = "stdOutputFormatJavaScript.ftl"; |
| private static final String STD_OUTPUT_FORMAT_JSON_FTL = "stdOutputFormatJSON.ftl"; |
| private static final String STD_OUTPUT_FORMAT_CSS_FTL = "stdOutputFormatCSS.ftl"; |
| private static final String STD_OUTPUT_FORMAT_PLAIN_TEXT_FTL = "stdOutputFormatPlainText.ftl"; |
| private static final String STD_OUTPUT_FORMAT_RTF_FTL = "stdOutputFormatRTF.ftl"; |
| |
| private static final Locale DEFAULT_LOCALE = Locale.US; |
| private static final String CFG_DEFAULT_ENCODING = "US-ASCII"; |
| /** According to the Servlet Specification */ |
| private static final String SERVLET_RESPONSE_DEFAULT_CHARSET = "ISO-8859-1"; |
| private static final String DEFAULT_CONTENT_TYPE = "text/html"; |
| |
| private MockServletContext servletContext; |
| |
| @Before |
| public void setUp() throws Exception { |
| servletContext = new MockServletContext(); |
| servletContext.setContextPath("/"); |
| } |
| |
| @Test |
| public void testContentTypeInitParams() throws Exception { |
| // Default is INIT_PARAM_VALUE_ALWAYS, hence null is the same: |
| for (String overrideCT : new String[] { null, INIT_PARAM_VALUE_ALWAYS }) { |
| assertResponseContentTypeEquals( |
| DEFAULT_CONTENT_TYPE + "; charset=UTF-8", // <- expected |
| null, overrideCT, // <- init-params |
| FOO_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "text/css; charset=UTF-8", // <- expected |
| "text/css", overrideCT, // <- init-params |
| FOO_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| DEFAULT_CONTENT_TYPE + "; charset=UTF-8", // <- expected |
| null, overrideCT, // <- init-params |
| FOO_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "text/css; charset=UTF-8", // <- expected |
| "text/css", overrideCT, // <- init-params |
| FOO_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "text/plain", // <- expected |
| null, overrideCT, // <- init-params |
| CONTENT_TYPE_ATTR_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "text/plain; charset=UTF-8", // <- expected |
| null, overrideCT, // <- init-params |
| OUTPUT_FORMAT_HEADER_FTL, "application/json"); // <- request |
| } |
| |
| assertResponseContentTypeEquals( |
| DEFAULT_CONTENT_TYPE + "; charset=UTF-8", // <- expected |
| null, INIT_PARAM_VALUE_WHEN_TEMPLATE_HAS_MIME_TYPE, // <- init-params |
| FOO_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "text/css; charset=UTF-8", // <- expected |
| "text/css", INIT_PARAM_VALUE_WHEN_TEMPLATE_HAS_MIME_TYPE, // <- init-params |
| FOO_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/json", // <- expected |
| null, INIT_PARAM_VALUE_WHEN_TEMPLATE_HAS_MIME_TYPE, // <- init-params |
| FOO_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "application/json", // <- expected |
| "text/css", INIT_PARAM_VALUE_WHEN_TEMPLATE_HAS_MIME_TYPE, // <- init-params |
| FOO_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "text/plain", // <- expected |
| null, INIT_PARAM_VALUE_WHEN_TEMPLATE_HAS_MIME_TYPE, // <- init-params |
| CONTENT_TYPE_ATTR_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "text/plain; charset=UTF-8", // <- expected |
| null, INIT_PARAM_VALUE_WHEN_TEMPLATE_HAS_MIME_TYPE, // <- init-params |
| OUTPUT_FORMAT_HEADER_FTL, "application/json"); // <- request |
| |
| assertResponseContentTypeEquals( |
| DEFAULT_CONTENT_TYPE + "; charset=UTF-8", // <- expected |
| null, INIT_PARAM_VALUE_NEVER, // <- init-params |
| FOO_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "text/css; charset=UTF-8", // <- expected |
| "text/css", INIT_PARAM_VALUE_NEVER, // <- init-params |
| FOO_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/json", // <- expected |
| null, INIT_PARAM_VALUE_NEVER, // <- init-params |
| FOO_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "application/json", // <- expected |
| "text/css", INIT_PARAM_VALUE_NEVER, // <- init-params |
| FOO_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "application/json", // <- expected |
| null, INIT_PARAM_VALUE_NEVER, // <- init-params |
| CONTENT_TYPE_ATTR_FTL, "application/json"); // <- request |
| assertResponseContentTypeEquals( |
| "application/json", // <- expected |
| null, INIT_PARAM_VALUE_NEVER, // <- init-params |
| OUTPUT_FORMAT_HEADER_FTL, "application/json"); // <- request |
| } |
| |
| @Test |
| public void testStandardContentType() throws Exception { |
| assertResponseContentTypeEquals( |
| "text/html; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_HTML_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/xhtml+xml; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_XHTML_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/xml; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_XML_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/javascript; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_JAVA_SCRIPT_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/json; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_JSON_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "text/css; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_CSS_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "text/plain; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_PLAIN_TEXT_FTL, null); // <- request |
| assertResponseContentTypeEquals( |
| "application/rtf; charset=UTF-8", // <- expected |
| null, null, // <- init-params |
| STD_OUTPUT_FORMAT_RTF_FTL, null); // <- request |
| } |
| |
| @Test |
| public void testResponseLocaleInitParams() throws Exception { |
| assertTemplateLocaleEquals( |
| DEFAULT_LOCALE, // <- expected template locale |
| null, // <- request locale |
| null, // <- init-param |
| FOO_FTL); |
| assertTemplateLocaleEquals( |
| DEFAULT_LOCALE, // <- expected template locale |
| Locale.FRENCH, // <- request locale |
| null, // <- init-param |
| FOO_FTL); |
| assertTemplateLocaleEquals( |
| DEFAULT_LOCALE, // <- expected template locale |
| Locale.FRENCH, // <- request locale |
| INIT_PARAM_VALUE_ALWAYS, // <- init-param |
| FOO_FTL); |
| assertTemplateLocaleEquals( |
| DEFAULT_LOCALE, // <- expected template locale |
| null, // <- request locale |
| INIT_PARAM_VALUE_NEVER, // <- init-param |
| FOO_FTL); |
| assertTemplateLocaleEquals( |
| Locale.FRENCH, // <- expected template locale |
| Locale.FRENCH, // <- request locale |
| INIT_PARAM_VALUE_NEVER, // <- init-param |
| FOO_FTL); |
| } |
| |
| @Test |
| public void testResponseOutputCharsetInitParam() throws Exception { |
| for (String initParamValue : new String[] { null, FreemarkerServlet.INIT_PARAM_VALUE_LEGACY }) { |
| // Legacy mode is not aware of the outputEncoding, thus it doesn't set it: |
| assertOutputEncodingEquals( |
| CFG_DEFAULT_ENCODING, // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| FOO_FTL); |
| assertOutputEncodingEquals( |
| CFG_DEFAULT_ENCODING, // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| FOO_FTL); |
| // Legacy mode follows the source encoding of the template: |
| assertOutputEncodingEquals( |
| "UTF-8", // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| FOO_SRC_UTF8_FTL); |
| // Legacy mode doesn't deal with outputEncoding, but it's inherited by the Environment from the Template: |
| assertOutputEncodingEquals( |
| CFG_DEFAULT_ENCODING, // <- expected response.characterEncoding |
| "UTF-8", // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| FOO_OUT_UTF8_FTL); |
| // Charset in content type is the strongest: |
| assertOutputEncodingEquals( |
| "ISO-8859-2", // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| "text/html; charset=ISO-8859-2", // ContentType init-param |
| FOO_FTL); |
| assertOutputEncodingEquals( |
| "ISO-8859-2", // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| "text/html; charset=ISO-8859-2", // ContentType init-param |
| FOO_SRC_UTF8_FTL); |
| assertOutputEncodingEquals( |
| "UTF-8", // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| CONTENT_TYPE_ATTR_WITH_CHARSET_FTL); |
| assertOutputEncodingEquals( |
| "UTF-8", // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| initParamValue, // <- init-param |
| "text/html; charset=ISO-8859-2", // ContentType init-param |
| CONTENT_TYPE_ATTR_WITH_CHARSET_FTL); |
| } |
| |
| // Non-legacy mode always keeps env.outputEncoding in sync. with the Servlet response encoding: |
| assertOutputEncodingEquals( |
| CFG_DEFAULT_ENCODING, // <- expected response.characterEncoding |
| CFG_DEFAULT_ENCODING, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FROM_TEMPLATE, // <- init-param |
| FOO_FTL); |
| // Non-legacy mode considers the template-specific outputEncoding: |
| assertOutputEncodingEquals( |
| "UTF-8", // <- expected response.characterEncoding |
| "UTF-8", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FROM_TEMPLATE, // <- init-param |
| FOO_OUT_UTF8_FTL); |
| // Non-legacy mode uses the template source encoding as a fallback for outputEncoding: |
| assertOutputEncodingEquals( |
| "UTF-8", // <- expected response.characterEncoding |
| "UTF-8", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FROM_TEMPLATE, // <- init-param |
| FOO_SRC_UTF8_FTL); |
| // Not allowed to specify the charset in the contentType init-param: |
| try { |
| assertOutputEncodingEquals( |
| null, // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FROM_TEMPLATE, // <- init-param |
| "text/html; charset=ISO-8859-2", // ContentType init-param |
| FOO_FTL); |
| fail(); |
| } catch (ServletException e) { |
| assertThat(e.getCause().getCause().getMessage(), containsString(FreemarkerServlet.INIT_PARAM_VALUE_LEGACY)); |
| } |
| // But the legacy content_type template attribute can still set the output charset: |
| assertOutputEncodingEquals( |
| "UTF-8", // <- expected response.characterEncoding |
| "UTF-8", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FROM_TEMPLATE, // <- init-param |
| CONTENT_TYPE_ATTR_WITH_CHARSET_FTL); |
| |
| // Do not set mode: |
| assertOutputEncodingEquals( |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected response.characterEncoding |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_DO_NOT_SET, // <- init-param |
| FOO_FTL); |
| assertOutputEncodingEquals( |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected response.characterEncoding |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_DO_NOT_SET, // <- init-param |
| FOO_SRC_UTF8_FTL); |
| assertOutputEncodingEquals( |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected response.characterEncoding |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_DO_NOT_SET, // <- init-param |
| FOO_OUT_UTF8_FTL); |
| // Not allowed to specify the charset in the contentType init-param: |
| try { |
| assertOutputEncodingEquals( |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected response.characterEncoding |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_DO_NOT_SET, // <- init-param |
| "text/html; charset=ISO-8859-2", // ContentType init-param |
| FOO_FTL); |
| fail(); |
| } catch (ServletException e) { |
| assertThat(e.getCause().getCause().getMessage(), containsString(FreemarkerServlet.INIT_PARAM_VALUE_LEGACY)); |
| } |
| // The legacy content_type template attribute can still specify an output charset, though it will be ignored: |
| assertOutputEncodingEquals( |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected response.characterEncoding |
| SERVLET_RESPONSE_DEFAULT_CHARSET, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_DO_NOT_SET, // <- init-param |
| CONTENT_TYPE_ATTR_WITH_CHARSET_FTL); |
| |
| // Forced mode: |
| assertOutputEncodingEquals( |
| "UTF-16LE", // <- expected response.characterEncoding |
| "UTF-16LE", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FORCE_PREFIX + "UTF-16LE", // <- init-param |
| FOO_FTL); |
| assertOutputEncodingEquals( |
| "UTF-16LE", // <- expected response.characterEncoding |
| "UTF-16LE", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FORCE_PREFIX + "UTF-16LE", // <- init-param |
| FOO_SRC_UTF8_FTL); |
| assertOutputEncodingEquals( |
| "UTF-16LE", // <- expected response.characterEncoding |
| "UTF-16LE", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FORCE_PREFIX + "UTF-16LE", // <- init-param |
| FOO_OUT_UTF8_FTL); |
| try { |
| assertOutputEncodingEquals( |
| null, // <- expected response.characterEncoding |
| null, // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FORCE_PREFIX + "noSuchCharset", // <- init-param |
| FOO_FTL); |
| fail(); |
| } catch (ServletException e) { |
| assertThat(e.getCause().getCause(), instanceOf(UnsupportedCharsetException.class)); |
| } |
| // Not allowed to specify the charset in the contentType init-param: |
| try { |
| assertOutputEncodingEquals( |
| "UTF-16LE", // <- expected response.characterEncoding |
| "UTF-16LE", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FORCE_PREFIX + "UTF-16LE", // <- init-param |
| "text/html; charset=ISO-8859-2", // ContentType init-param |
| FOO_FTL); |
| fail(); |
| } catch (ServletException e) { |
| assertThat(e.getCause().getCause().getMessage(), containsString(FreemarkerServlet.INIT_PARAM_VALUE_LEGACY)); |
| } |
| // The legacy content_type template attribute can still specify an output charset, though it will be overridden: |
| assertOutputEncodingEquals( |
| "UTF-16LE", // <- expected response.characterEncoding |
| "UTF-16LE", // <- expected env.outputEncoding |
| FreemarkerServlet.INIT_PARAM_VALUE_FORCE_PREFIX + "UTF-16LE", // <- init-param |
| CONTENT_TYPE_ATTR_WITH_CHARSET_FTL); |
| } |
| |
| private void assertResponseContentTypeEquals( |
| String exptectContentType, |
| String ctInitParam, String overrideCTInitParam, |
| String templateName, String responseCT) |
| throws ServletException, IOException { |
| MockHttpServletRequest request = createMockHttpServletRequest(servletContext, templateName, null); |
| |
| MockHttpServletResponse response = new MockHttpServletResponse(); |
| if (responseCT != null) { |
| response.setContentType(responseCT); |
| assertEquals(responseCT, response.getContentType()); |
| } else { |
| assertNull(response.getContentType()); |
| } |
| |
| MockServletConfig servletConfig = new MockServletConfig(servletContext); |
| servletConfig.addInitParameter(Configuration.DEFAULT_ENCODING_KEY, "UTF-8"); |
| if (ctInitParam != null) { |
| servletConfig.addInitParameter(INIT_PARAM_CONTENT_TYPE, ctInitParam); |
| } |
| if (overrideCTInitParam != null) { |
| servletConfig.addInitParameter(INIT_PARAM_OVERRIDE_RESPONSE_CONTENT_TYPE, overrideCTInitParam); |
| } |
| |
| TestFreemarkerServlet freemarkerServlet = new TestFreemarkerServlet(); |
| try { |
| freemarkerServlet.init(servletConfig); |
| |
| freemarkerServlet.doGet(request, response); |
| |
| assertEquals(HttpServletResponse.SC_OK, response.getStatus()); |
| assertEquals(exptectContentType, response.getContentType()); |
| } finally { |
| freemarkerServlet.destroy(); |
| } |
| } |
| |
| private void assertTemplateLocaleEquals( |
| Locale exptectLocale, |
| Locale requestLocale, |
| String overrideResponseLocaleInitParam, |
| String templateName) |
| throws ServletException, IOException { |
| MockHttpServletRequest request = createMockHttpServletRequest(servletContext, templateName, requestLocale); |
| MockHttpServletResponse response = new MockHttpServletResponse(); |
| |
| MockServletConfig servletConfig = new MockServletConfig(servletContext); |
| |
| if (overrideResponseLocaleInitParam != null) { |
| servletConfig.addInitParameter(INIT_PARAM_OVERRIDE_RESPONSE_LOCALE, overrideResponseLocaleInitParam); |
| } |
| |
| TestFreemarkerServlet freemarkerServlet = new TestFreemarkerServlet(); |
| |
| try { |
| freemarkerServlet.init(servletConfig); |
| freemarkerServlet.doGet(request, response); |
| |
| assertEquals(HttpServletResponse.SC_OK, response.getStatus()); |
| assertEquals(exptectLocale, freemarkerServlet.lastLocale); |
| assertEquals(freemarkerServlet.lastLocale, freemarkerServlet.lastMainTemplate.getLocale()); |
| } finally { |
| freemarkerServlet.destroy(); |
| } |
| } |
| |
| private void assertOutputEncodingEquals( |
| String exptectRespCharacterEncoding, |
| String exptectEnvOutputEncoding, |
| String responseCharacterEncodingInitParam, |
| String templateName) throws ServletException, IOException { |
| assertOutputEncodingEquals( |
| exptectRespCharacterEncoding, exptectEnvOutputEncoding, |
| responseCharacterEncodingInitParam, null, |
| templateName); |
| } |
| |
| private void assertOutputEncodingEquals( |
| String exptectRespCharacterEncoding, |
| String exptectEnvOutputEncoding, |
| String responseCharacterEncodingInitParam, |
| String contentTypeInitParam, |
| String templateName) |
| throws ServletException, IOException { |
| MockHttpServletRequest request = createMockHttpServletRequest(servletContext, templateName, null); |
| MockHttpServletResponse response = new MockHttpServletResponse(); |
| |
| MockServletConfig servletConfig = new MockServletConfig(servletContext); |
| |
| if (responseCharacterEncodingInitParam != null) { |
| servletConfig.addInitParameter(INIT_PARAM_RESPONSE_CHARACTER_ENCODING, responseCharacterEncodingInitParam); |
| } |
| |
| if (contentTypeInitParam != null) { |
| servletConfig.addInitParameter(INIT_PARAM_CONTENT_TYPE, contentTypeInitParam); |
| } |
| |
| TestFreemarkerServlet freemarkerServlet = new TestFreemarkerServlet(); |
| |
| try { |
| freemarkerServlet.init(servletConfig); |
| freemarkerServlet.doGet(request, response); |
| |
| assertEquals(HttpServletResponse.SC_OK, response.getStatus()); |
| assertEquals(exptectEnvOutputEncoding, freemarkerServlet.lastOutputEncoding); |
| assertEquals(exptectRespCharacterEncoding, response.getCharacterEncoding()); |
| } finally { |
| freemarkerServlet.destroy(); |
| } |
| } |
| |
| private MockHttpServletRequest createMockHttpServletRequest(final ServletContext servletContext, |
| final String pathInfo, final Locale requestLocale) { |
| MockHttpServletRequest servletRequest = new MockHttpServletRequest(servletContext) { |
| |
| @Override |
| public Locale getLocale() { |
| return requestLocale; |
| } |
| }; |
| |
| servletRequest.setServerName("localhost"); |
| servletRequest.setServerPort(8080); |
| servletRequest.setContextPath(""); |
| servletRequest.setRequestURI(pathInfo); |
| servletRequest.setPathInfo(pathInfo); |
| |
| return servletRequest; |
| } |
| |
| static class TestFreemarkerServlet extends FreemarkerServlet { |
| |
| private Template lastMainTemplate; |
| private Locale lastLocale; |
| private String lastOutputEncoding; |
| |
| @Override |
| protected Configuration createConfiguration() { |
| Configuration cfg = super.createConfiguration(); |
| // Needed for the TemplateConfiguration that sets outputEncoding: |
| cfg.setIncompatibleImprovements(Configuration.VERSION_2_3_22); |
| |
| // Set a test runner environment independent default locale: |
| cfg.setLocale(DEFAULT_LOCALE); |
| cfg.setDefaultEncoding(CFG_DEFAULT_ENCODING); |
| |
| { |
| TemplateConfiguration outUtf8TC = new TemplateConfiguration(); |
| outUtf8TC.setOutputEncoding("UTF-8"); |
| |
| TemplateConfiguration srcUtf8TC = new TemplateConfiguration(); |
| srcUtf8TC.setEncoding("UTF-8"); |
| |
| cfg.setTemplateConfigurations( |
| new FirstMatchTemplateConfigurationFactory( |
| new ConditionalTemplateConfigurationFactory( |
| new FileNameGlobMatcher(FOO_SRC_UTF8_FTL), srcUtf8TC), |
| new ConditionalTemplateConfigurationFactory( |
| new FileNameGlobMatcher(FOO_OUT_UTF8_FTL), outUtf8TC) |
| ) |
| .allowNoMatch(true) |
| ); |
| } |
| |
| return cfg; |
| } |
| |
| @Override |
| protected TemplateLoader createTemplateLoader(String templatePath) throws IOException { |
| // Override default template loader |
| if (templatePath.equals("class://")) { |
| StringTemplateLoader tl = new StringTemplateLoader(); |
| |
| tl.putTemplate(FOO_FTL, "foo"); |
| tl.putTemplate(FOO_SRC_UTF8_FTL, "foo"); |
| tl.putTemplate(FOO_OUT_UTF8_FTL, "foo"); |
| tl.putTemplate(CONTENT_TYPE_ATTR_FTL, "<#ftl attributes={ 'content_type': 'text/plain' }>foo"); |
| tl.putTemplate(CONTENT_TYPE_ATTR_WITH_CHARSET_FTL, "<#ftl attributes={ 'content_type': 'text/plain; charset=UTF-8' }>foo"); |
| tl.putTemplate(OUTPUT_FORMAT_HEADER_FTL, "<#ftl outputFormat='plainText'>foo"); |
| |
| tl.putTemplate(STD_OUTPUT_FORMAT_HTML_FTL, "<#ftl outputFormat='HTML'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_XHTML_FTL, "<#ftl outputFormat='XHTML'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_XML_FTL, "<#ftl outputFormat='XML'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_JAVA_SCRIPT_FTL, "<#ftl outputFormat='JavaScript'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_JSON_FTL, "<#ftl outputFormat='JSON'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_CSS_FTL, "<#ftl outputFormat='CSS'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_PLAIN_TEXT_FTL, "<#ftl outputFormat='plainText'>"); |
| tl.putTemplate(STD_OUTPUT_FORMAT_RTF_FTL, "<#ftl outputFormat='RTF'>"); |
| |
| return tl; |
| } else { |
| return super.createTemplateLoader(templatePath); |
| } |
| } |
| |
| @Override |
| protected void processEnvironment(Environment env, HttpServletRequest request, HttpServletResponse response) |
| throws TemplateException, IOException { |
| lastMainTemplate = env.getMainTemplate(); |
| lastLocale = env.getLocale(); |
| lastOutputEncoding = env.getOutputEncoding(); |
| super.processEnvironment(env, request, response); |
| } |
| |
| } |
| |
| } |
