CDIBasedContainerTest.java

/***
 * Copyright (c) 2009 Caelum - www.caelum.com.br/opensource All rights reserved.
 *
 * Licensed 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 br.com.caelum.vraptor.ioc.cdi;

import static br.com.caelum.vraptor.VRaptorMatchers.canHandle;
import static br.com.caelum.vraptor.VRaptorMatchers.hasOneCopyOf;
import static java.util.Arrays.asList;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertEquals;

import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

import javax.enterprise.event.Event;
import javax.inject.Inject;

import org.hamcrest.Matcher;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import br.com.caelum.cdi.component.UsingCacheComponent;
import br.com.caelum.vraptor.WeldJunitRunner;
import br.com.caelum.vraptor.converter.*;
import br.com.caelum.vraptor.core.Converters;
import br.com.caelum.vraptor.events.VRaptorInitialized;
import br.com.caelum.vraptor.http.route.Route;
import br.com.caelum.vraptor.http.route.Router;
import br.com.caelum.vraptor.interceptor.InterceptorRegistry;
import br.com.caelum.vraptor.ioc.fixture.ControllerInTheClasspath;
import br.com.caelum.vraptor.ioc.fixture.ConverterInTheClasspath;
import br.com.caelum.vraptor.ioc.fixture.InterceptorInTheClasspath;
import br.com.caelum.vraptor.serialization.Deserializer;
import br.com.caelum.vraptor.serialization.Deserializers;

@RunWith(WeldJunitRunner.class)
public class CDIBasedContainerTest {

	@Inject private CDIBasedContainer cdiBasedContainer;
	@Inject private Event<VRaptorInitialized> initEvent;
	@Inject private Contexts contexts;

	@Before
	public void setup() {
		contexts.startApplicationScope();
		contexts.startSessionScope();
		initEvent.fire(new VRaptorInitialized(null));
	}
	
	@After
	public void tearDown() {
		contexts.stopSessionScope();
		contexts.stopApplicationScope();
	}

	@Test
	public void shouldCreateComponentsWithCache(){
		UsingCacheComponent component = cdiBasedContainer.instanceFor(UsingCacheComponent.class);
		component.putWithLRU("test","test");
		component.putWithDefault("test2","test2");
		assertEquals(component.putWithLRU("test","test"),"test");
		assertEquals(component.putWithDefault("test2","test2"),"test2");
	}
	
	@Test
	public void shoudRegisterResourcesInRouter() {
		Router router = instanceFor(Router.class);
		Matcher<Iterable<? super Route>> hasItem = hasItem(canHandle(ControllerInTheClasspath.class,
				ControllerInTheClasspath.class.getDeclaredMethods()[0]));
		assertThat(router.allRoutes(), hasItem);
	}

	@Test
	public void shoudRegisterConvertersInConverters() {
		Converters converters = instanceFor(Converters.class);
		Converter<?> converter = converters.to(Void.class);
		assertThat(converter, is(instanceOf(ConverterInTheClasspath.class)));
	}

	/**
	 * Check if exist {@link Deserializer} registered in VRaptor for determined Content-Types.
	 */
	@Test
	public void shouldReturnAllDefaultDeserializers() {

		Deserializers deserializers = instanceFor(Deserializers.class);
		List<String> types = asList("application/json", "json", "application/xml",
			"xml", "text/xml", "application/x-www-form-urlencoded");

		for (String type : types) {
			assertThat("deserializer not found: " + type,
					deserializers.deserializerFor(type, cdiBasedContainer), is(notNullValue()));
		}
	}

	@Test
	public void shouldReturnAllDefaultConverters() {
		Converters converters = instanceFor(Converters.class);
		final HashMap<Class<?>, Class<?>> EXPECTED_CONVERTERS = new HashMap<Class<?>, Class<?>>() {
			{
				put(int.class, PrimitiveIntConverter.class);
				put(long.class, PrimitiveLongConverter.class);
				put(short.class, PrimitiveShortConverter.class);
				put(byte.class, PrimitiveByteConverter.class);
				put(double.class, PrimitiveDoubleConverter.class);
				put(float.class, PrimitiveFloatConverter.class);
				put(boolean.class, PrimitiveBooleanConverter.class);
				put(Integer.class, IntegerConverter.class);
				put(Long.class, LongConverter.class);
				put(Short.class, ShortConverter.class);
				put(Byte.class, ByteConverter.class);
				put(Double.class, DoubleConverter.class);
				put(Float.class, FloatConverter.class);
				put(Boolean.class, BooleanConverter.class);
				put(Calendar.class, CalendarConverter.class);
				put(Date.class, DateConverter.class);
				put(Enum.class, EnumConverter.class);
			}
			private static final long serialVersionUID = 8559316558416038474L;
		};

		for (Entry<Class<?>, Class<?>> entry : EXPECTED_CONVERTERS.entrySet()) {
			Converter<?> converter = converters.to((Class<?>) entry.getKey());
			assertThat(converter, is(instanceOf(entry.getValue())));
		}
	}

	@Test
	public void shoudRegisterInterceptorsInInterceptorRegistry() {
		InterceptorRegistry registry = instanceFor(InterceptorRegistry.class);
		assertThat(registry.all(), hasOneCopyOf(InterceptorInTheClasspath.class));
	}

	private <T> T instanceFor(final Class<T> component) {
		return cdiBasedContainer.instanceFor(component);
	}

}