/**
* 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 org.apache.hadoop.yarn.webapp.test;
import org.apache.hadoop.yarn.webapp.Controller;
import org.apache.hadoop.yarn.webapp.SubView;
import org.apache.hadoop.yarn.webapp.View;
import org.apache.hadoop.yarn.webapp.WebAppException;
import java.lang.reflect.Method;
import java.util.Map;
import com.google.inject.Module;
import com.google.inject.Scopes;
import com.google.inject.servlet.RequestScoped;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Provides;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest;
import static org.mockito.Mockito.*;
public class WebAppTests {
/**
* Create a mock injector for tests
* @param <T> type of class/interface
* @param api the interface class of the object to inject
* @param impl the implementation object to inject
* @param modules additional guice modules
* @return an injector
*/
public static <T> Injector createMockInjector(final Class<T> api,
final T impl,
final Module... modules) {
return Guice.createInjector(new AbstractModule() {
final PrintWriter writer = spy(new PrintWriter(System.out));
final HttpServletRequest request = createRequest();
final HttpServletResponse response = createResponse();
@Override
protected void configure() {
if (api != null) {
bind(api).toInstance(impl);
}
bindScope(RequestScoped.class, Scopes.SINGLETON);
if (modules != null) {
for (Module module : modules) {
install(module);
}
}
}
@Provides HttpServletRequest request() {
return request;
}
@Provides HttpServletResponse response() {
return response;
}
@Provides PrintWriter writer() {
return writer;
}
HttpServletRequest createRequest() {
// the default suffices for now
return mock(HttpServletRequest.class);
}
HttpServletResponse createResponse() {
try {
HttpServletResponse res = mock(HttpServletResponse.class);
when(res.getWriter()).thenReturn(writer);
return res;
} catch (Exception e) {
throw new WebAppException(e);
}
}
});
}
// convenience
@SuppressWarnings("unchecked")
public static <T> Injector createMockInjector(T impl) {
return createMockInjector((Class<T>)impl.getClass(), impl);
}
public static void flushOutput(Injector injector) {
HttpServletResponse res = injector.getInstance(HttpServletResponse.class);
try {
res.getWriter().flush();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <T> Injector testController(Class<? extends Controller> ctrlr,
String methodName, Class<T> api, T impl, Module... modules) {
try {
Injector injector = createMockInjector(api, impl, modules);
Method method = ctrlr.getMethod(methodName, (Class<?>[])null);
method.invoke(injector.getInstance(ctrlr), (Object[])null);
return injector;
} catch (Exception e) {
throw new WebAppException(e);
}
}
public static <T> Injector testController(Class<? extends Controller> ctrlr,
String methodName) {
return testController(ctrlr, methodName, null, null);
}
public static <T> Injector testPage(Class<? extends View> page, Class<T> api,
T impl, Map<String,String> params, Module... modules) {
Injector injector = createMockInjector(api, impl, modules);
View view = injector.getInstance(page);
if(params != null) {
for(Map.Entry<String, String> entry: params.entrySet()) {
view.set(entry.getKey(), entry.getValue());
}
}
view.render();
flushOutput(injector);
return injector;
}
public static <T> Injector testPage(Class<? extends View> page, Class<T> api,
T impl, Module... modules) {
return testPage(page, api, impl, null, modules);
}
// convenience
public static <T> Injector testPage(Class<? extends View> page) {
return testPage(page, null, null);
}
public static <T> Injector testBlock(Class<? extends SubView> block,
Class<T> api, T impl, Module... modules) {
Injector injector = createMockInjector(api, impl, modules);
injector.getInstance(block).renderPartial();
flushOutput(injector);
return injector;
}
// convenience
public static <T> Injector testBlock(Class<? extends SubView> block) {
return testBlock(block, null, null);
}
/**
* Convenience method to get the spy writer.
* @param injector the injector used for the test.
* @return The Spy writer.
* @throws IOException
*/
public static PrintWriter getPrintWriter(Injector injector)
throws IOException {
HttpServletResponse res = injector.getInstance(HttpServletResponse.class);
return res.getWriter();
}
}