1   /*
2    * Copyright 2004-2010 the Seasar Foundation and the Others.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13   * either express or implied. See the License for the specific language
14   * governing permissions and limitations under the License.
15   */
16  
17  package org.seasar.cubby.plugins.guice;
18  
19  import static org.easymock.EasyMock.anyObject;
20  import static org.easymock.EasyMock.createNiceMock;
21  import static org.easymock.EasyMock.expect;
22  import static org.easymock.EasyMock.expectLastCall;
23  import static org.easymock.EasyMock.getCurrentArguments;
24  import static org.easymock.EasyMock.replay;
25  import static org.junit.Assert.assertNotSame;
26  import static org.junit.Assert.assertSame;
27  import static org.junit.Assert.assertTrue;
28  import static org.junit.Assert.fail;
29  
30  import java.io.IOException;
31  import java.util.Enumeration;
32  import java.util.Hashtable;
33  import java.util.Vector;
34  
35  import javax.servlet.FilterChain;
36  import javax.servlet.FilterConfig;
37  import javax.servlet.ServletContext;
38  import javax.servlet.ServletContextEvent;
39  import javax.servlet.ServletException;
40  import javax.servlet.ServletRequest;
41  import javax.servlet.ServletResponse;
42  import javax.servlet.http.HttpServletRequest;
43  import javax.servlet.http.HttpServletResponse;
44  
45  import org.apache.commons.fileupload.FileUpload;
46  import org.easymock.IAnswer;
47  import org.junit.Test;
48  import org.seasar.cubby.action.ActionClass;
49  import org.seasar.cubby.action.ActionResult;
50  import org.seasar.cubby.converter.impl.BigDecimalConverter;
51  import org.seasar.cubby.internal.controller.ThreadContext;
52  import org.seasar.cubby.plugin.PluginRegistry;
53  import org.seasar.cubby.routing.PathResolver;
54  import org.seasar.cubby.routing.PathTemplateParser;
55  import org.seasar.cubby.spi.ContainerProvider;
56  import org.seasar.cubby.spi.ConverterProvider;
57  import org.seasar.cubby.spi.PathResolverProvider;
58  import org.seasar.cubby.spi.ProviderFactory;
59  import org.seasar.cubby.spi.container.Container;
60  
61  import com.google.inject.AbstractModule;
62  import com.google.inject.ConfigurationException;
63  import com.google.inject.Inject;
64  import com.google.inject.Injector;
65  import com.google.inject.Singleton;
66  import com.google.inject.servlet.GuiceFilter;
67  import com.google.inject.servlet.RequestScoped;
68  import com.google.inject.servlet.ServletModule;
69  import com.google.inject.util.Modules;
70  
71  public class CubbyModuleTest {
72  
73  	@Test
74  	public void configure() throws Exception {
75  		final HttpServletRequest request = createNiceMock(HttpServletRequest.class);
76  		final HttpServletResponse response = createNiceMock(HttpServletResponse.class);
77  		final ServletContext servletContext = createNiceMock(ServletContext.class);
78  		expect(servletContext.getInitParameter("cubby.guice.module"))
79  				.andStubReturn(TestModule.class.getName());
80  		final Hashtable<String, Object> attributes = new Hashtable<String, Object>();
81  		expect(servletContext.getAttribute((String) anyObject()))
82  				.andStubAnswer(new IAnswer<Object>() {
83  
84  					public Object answer() throws Throwable {
85  						return attributes.get(getCurrentArguments()[0]);
86  					}
87  
88  				});
89  		servletContext.setAttribute((String) anyObject(), anyObject());
90  		expectLastCall().andAnswer(new IAnswer<Void>() {
91  
92  			public Void answer() throws Throwable {
93  				attributes.put((String) getCurrentArguments()[0],
94  						getCurrentArguments()[1]);
95  				return null;
96  			}
97  
98  		});
99  		replay(servletContext);
100 
101 		final CubbyGuiceServletContextListener cubbyGuiceServletContextListener = new CubbyGuiceServletContextListener();
102 		cubbyGuiceServletContextListener
103 				.contextInitialized(new ServletContextEvent(servletContext));
104 
105 		final GuiceFilter guiceFilter = new GuiceFilter();
106 		guiceFilter.init(new FilterConfig() {
107 
108 			public String getFilterName() {
109 				return "guice";
110 			}
111 
112 			public String getInitParameter(final String name) {
113 				return null;
114 			}
115 
116 			@SuppressWarnings("unchecked")
117 			public Enumeration getInitParameterNames() {
118 				return new Vector<String>().elements();
119 			}
120 
121 			public ServletContext getServletContext() {
122 				return servletContext;
123 			}
124 
125 		});
126 
127 		final FilterChain chain = new FilterChain() {
128 
129 			public void doFilter(final ServletRequest request,
130 					final ServletResponse response) throws IOException,
131 					ServletException {
132 				final PluginRegistry pluginRegistry = PluginRegistry
133 						.getInstance();
134 				final GuicePlugin guicePlugin = new GuicePlugin();
135 				try {
136 					guicePlugin.initialize(servletContext);
137 					guicePlugin.ready();
138 					pluginRegistry.register(guicePlugin);
139 				} catch (final Exception e) {
140 					throw new ServletException(e);
141 				}
142 
143 				final Injector injector = guicePlugin.getInjector();
144 				System.out.println(injector);
145 
146 				final PathResolverProvider pathResolverProvider = ProviderFactory
147 						.get(PathResolverProvider.class);
148 				final PathResolver pathResolver = pathResolverProvider
149 						.getPathResolver();
150 				System.out.println(pathResolver);
151 
152 				final PathTemplateParser pathTemplateParser = injector
153 						.getInstance(PathTemplateParser.class);
154 				System.out.println(pathTemplateParser);
155 				assertTrue(pathTemplateParser instanceof MyPathTemplateParser);
156 
157 				final ContainerProvider containerProvider = ProviderFactory
158 						.get(ContainerProvider.class);
159 				final Container container = containerProvider.getContainer();
160 				final Foo foo = container.lookup(Foo.class);
161 				System.out.println(foo);
162 				System.out.println(foo.pathResolver);
163 
164 				assertSame(pathResolver, foo.pathResolver);
165 
166 				try {
167 					final Baz baz = injector.getInstance(Baz.class);
168 					System.out.println(baz);
169 					fail();
170 				} catch (final ConfigurationException e) {
171 					// ok
172 				}
173 
174 				final ConverterProvider converterProvider = ProviderFactory
175 						.get(ConverterProvider.class);
176 				System.out.println(converterProvider);
177 				System.out.println(converterProvider
178 						.getConverter(BigDecimalConverter.class));
179 
180 				final FileUpload fileUpload1 = injector
181 						.getInstance(FileUpload.class);
182 				System.out.println(fileUpload1);
183 				System.out.println(fileUpload1.getFileItemFactory());
184 
185 				final FileUpload fileUpload2 = injector
186 						.getInstance(FileUpload.class);
187 				System.out.println(fileUpload2);
188 				System.out.println(fileUpload2.getFileItemFactory());
189 
190 				assertNotSame(fileUpload1, fileUpload2);
191 				assertNotSame(fileUpload1.getFileItemFactory(), fileUpload2
192 						.getFileItemFactory());
193 			}
194 
195 		};
196 		guiceFilter.doFilter(request, response, chain);
197 		cubbyGuiceServletContextListener
198 				.contextDestroyed(new ServletContextEvent(servletContext));
199 		ThreadContext.remove();
200 	}
201 
202 	public static class TestModule extends AbstractModule {
203 
204 		@Override
205 		protected void configure() {
206 			install(new ServletModule());
207 			// install(new AbstractCubbyModule());
208 			install(Modules.override(new CubbyModule(), new FileUploadModule())
209 					.with(new AbstractModule() {
210 
211 						@Override
212 						protected void configure() {
213 							bind(PathTemplateParser.class).to(
214 									MyPathTemplateParser.class).in(
215 									Singleton.class);
216 						}
217 
218 					}));
219 			bind(BarAction.class);
220 
221 			// {
222 			// @Override
223 			// protected PathResolver getPathResolver() {
224 			// return new PathResolverImpl(new PathTemplateParserImpl());
225 			// }
226 			// });
227 		}
228 
229 	}
230 
231 	public static class MyPathTemplateParser implements PathTemplateParser {
232 
233 		public String parse(final String template, final Handler handler) {
234 			return "mytemplateparser";
235 		}
236 
237 	}
238 
239 	public static class Foo {
240 		@Inject
241 		public PathResolver pathResolver;
242 	}
243 
244 	@ActionClass
245 	@RequestScoped
246 	public static class BarAction {
247 		public ActionResult index() {
248 			return null;
249 		}
250 	}
251 
252 	public interface Baz {
253 
254 	}
255 }