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