/**
* Copyright@2011 wro4j
*/
package ro.isdc.wro.manager.factory;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.verify;
import java.util.concurrent.Callable;
import javax.servlet.FilterConfig;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import ro.isdc.wro.cache.CacheKey;
import ro.isdc.wro.cache.CacheStrategy;
import ro.isdc.wro.cache.CacheValue;
import ro.isdc.wro.config.Context;
import ro.isdc.wro.config.support.ContextPropagatingCallable;
import ro.isdc.wro.manager.WroManager;
import ro.isdc.wro.manager.callback.LifecycleCallback;
import ro.isdc.wro.manager.callback.LifecycleCallbackSupport;
import ro.isdc.wro.model.WroModel;
import ro.isdc.wro.model.factory.WroModelFactory;
import ro.isdc.wro.model.factory.XmlModelFactory;
import ro.isdc.wro.model.group.processor.InjectorBuilder;
import ro.isdc.wro.model.resource.support.naming.NoOpNamingStrategy;
import ro.isdc.wro.util.ObjectFactory;
import ro.isdc.wro.util.WroTestUtils;
import ro.isdc.wro.util.WroUtil;
/**
* @author Alex Objelean
*/
public class TestBaseWroManagerFactory {
@Mock
private HttpServletRequest mockRequest;
@Mock
private HttpServletResponse mockResponse;
@Mock
private FilterConfig mockFilterConfig;
@Mock
private WroModelFactory mockModelFactory;
@Mock
private CacheStrategy<CacheKey, CacheValue> mockCacheStrategy;
private BaseWroManagerFactory victim;
@BeforeClass
public static void onBeforeClass() {
assertEquals(0, Context.countActive());
}
@AfterClass
public static void onAfterClass() {
assertEquals(0, Context.countActive());
}
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
Context.set(Context.webContext(mockRequest, mockResponse, mockFilterConfig));
victim = new BaseWroManagerFactory();
}
@After
public void tearDown() {
Context.unset();
}
@Test
public void defaultModelFactoryIsXml() {
new BaseWroManagerFactory() {
@Override
protected WroModelFactory newModelFactory() {
final WroModelFactory modelFactory = super.newModelFactory();
Assert.assertEquals(XmlModelFactory.class, modelFactory.getClass());
return modelFactory;
}
};
}
@Test
public void shouldCreateManager()
throws Exception {
final WroManager manager = victim.create();
Assert.assertNotNull(manager);
Assert.assertEquals(NoOpNamingStrategy.class, manager.getNamingStrategy().getClass());
}
@Test
public void shouldSetCallback()
throws Exception {
final LifecycleCallback callback = Mockito.spy(new LifecycleCallbackSupport());
victim = new BaseWroManagerFactory().setModelFactory(WroUtil.factoryFor(new WroModel()));
final WroManager manager = victim.create();
InjectorBuilder.create(victim).build().inject(manager);
manager.registerCallback(new ObjectFactory<LifecycleCallback>() {
public LifecycleCallback create() {
return callback;
}
});
manager.getModelFactory().create();
Mockito.verify(callback).onBeforeModelCreated();
Mockito.verify(callback).onAfterModelCreated();
}
@Test
public void shouldNotFailWhenReloadingModelOutsideOfContext()
throws Exception {
Context.unset();
victim.onModelPeriodChanged(0);
}
@Test
public void shouldNotFailWhenReloadingCacheOutsideOfContext()
throws Exception {
Context.unset();
victim.onCachePeriodChanged(0);
}
@Test
public void shouldReloadOnlyModelWhenClearModelIsInvoked()
throws Exception {
victim = new BaseWroManagerFactory().setModelFactory(mockModelFactory).setCacheStrategy(mockCacheStrategy);
final WroManager manager = victim.create();
manager.onModelPeriodChanged(0);
Context.get().getConfig().reloadModel();
verify(mockModelFactory, Mockito.times(1)).destroy();
verify(mockCacheStrategy, Mockito.never()).clear();
}
@Test
public void shouldReloadOnlyCacheWhenClearCacheIsInvoked()
throws Exception {
victim = new BaseWroManagerFactory().setModelFactory(mockModelFactory).setCacheStrategy(mockCacheStrategy);
final WroManager manager = victim.create();
manager.onCachePeriodChanged(0);
Context.get().getConfig().reloadCache();
verify(mockModelFactory, Mockito.never()).destroy();
verify(mockCacheStrategy, Mockito.times(1)).clear();
}
/**
* TODO find a way to test manager thread safety
*
* @throws Exception
*/
@Ignore
@Test
public void shouldBeThreadSafe()
throws Exception {
// Mockito.when(mockRequest.getRequestURI()).thenReturn("/a/resource.js");
final WroManagerFactory managerFactory = new BaseWroManagerFactory();
WroTestUtils.runConcurrently(new ContextPropagatingCallable<Void>(new Callable<Void>() {
public Void call()
throws Exception {
// Context.set(Context.webContext(mockRequest, mockResponse, mockFilterConfig));
managerFactory.create().process();
// Context.unset();
return null;
}
}));
}
}