/***
* 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.serialization.gson;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.TimeZone;
import javax.enterprise.inject.Instance;
import javax.servlet.http.HttpServletRequest;
import net.vidageek.mirror.dsl.Mirror;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import br.com.caelum.vraptor.Consumes;
import br.com.caelum.vraptor.controller.BeanClass;
import br.com.caelum.vraptor.controller.ControllerMethod;
import br.com.caelum.vraptor.controller.DefaultBeanClass;
import br.com.caelum.vraptor.controller.DefaultControllerMethod;
import br.com.caelum.vraptor.http.ParameterNameProvider;
import br.com.caelum.vraptor.http.ParanamerNameProvider;
import br.com.caelum.vraptor.ioc.Container;
import br.com.caelum.vraptor.serialization.Deserializee;
import br.com.caelum.vraptor.serialization.Serializee;
import br.com.caelum.vraptor.util.test.MockInstanceImpl;
import br.com.caelum.vraptor.view.GenericController;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSerializer;
public class GsonDeserializerTest {
@Rule
public ExpectedException exception = ExpectedException.none();
private GsonDeserializerBuilder builder;
private GsonDeserialization deserializer;
private ParameterNameProvider provider;
private HttpServletRequest request;
private ControllerMethod dogParameter;
private ControllerMethod dogAndIntegerParameter;
private ControllerMethod noParameter;
private ControllerMethod listDog;
private ControllerMethod integerAndDogParameter;
private ControllerMethod dateParameter;
private ControllerMethod dogParameterWithoutRoot;
private ControllerMethod dogParameterNameEqualsJsonPropertyWithoutRoot;
private @Mock Container container;
private @Mock Instance<Deserializee> deserializeeInstance;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
TimeZone.setDefault(TimeZone.getTimeZone("GMT-0300"));
provider = new ParanamerNameProvider();
request = mock(HttpServletRequest.class);
List<JsonDeserializer<?>> jsonDeserializers = new ArrayList<>();
List<JsonSerializer<?>> jsonSerializers = new ArrayList<>();
jsonDeserializers.add(new CalendarGsonConverter());
jsonDeserializers.add(new DateGsonConverter());
builder = new GsonBuilderWrapper(new MockInstanceImpl<>(jsonSerializers), new MockInstanceImpl<>(jsonDeserializers), new Serializee());
deserializer = new GsonDeserialization(builder, provider, request, container, deserializeeInstance);
BeanClass controllerClass = new DefaultBeanClass(DogController.class);
noParameter = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("noParameter"));
dogParameter = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("dogParameter", Dog.class));
dateParameter = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("dateParameter", Date.class));
dogAndIntegerParameter = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("dogAndIntegerParameter", Dog.class,
Integer.class));
integerAndDogParameter = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("integerAndDogParameter",
Integer.class, Dog.class));
listDog = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("list", List.class));
dogParameterWithoutRoot = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("dogParameterWithoutRoot", Dog.class));
dogParameterNameEqualsJsonPropertyWithoutRoot = new DefaultControllerMethod(controllerClass, DogController.class.getDeclaredMethod("dogParameterNameEqualsJsonPropertyWithoutRoot", Dog.class));
when(deserializeeInstance.get()).thenReturn(new Deserializee());
when(container.instanceFor(WithRoot.class)).thenReturn(new WithRoot());
when(container.instanceFor(WithoutRoot.class)).thenReturn(new WithoutRoot());
}
static class Dog {
private String name;
private Integer age;
private Calendar birthday;
}
static class DogController {
public void noParameter() {}
@Consumes(options=WithRoot.class)
public void dogParameter(Dog dog) {}
@Consumes
public void dogParameterWithoutRoot(Dog dog) {}
@Consumes(options=WithoutRoot.class)
public void dogParameterNameEqualsJsonPropertyWithoutRoot(Dog name) {}
@Consumes
public void dogAndIntegerParameter(Dog dog, Integer times) {}
@Consumes
public void integerAndDogParameter(Integer times, Dog dog) {}
@Consumes
public void dateParameter(Date date) {}
@Consumes
public void list(List<Dog> dogs) {}
}
private class DogDeserializer implements JsonDeserializer<Dog> {
@Override
public Dog deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
Dog dog = new Dog();
dog.name = "Renan";
dog.age = 25;
return dog;
}
}
static class DogGenericController extends GenericController<Dog> {
}
@Test
public void shouldDeserializerParseArraysWithoutRoot(){
InputStream stream = asStream(
"[" +
"{'name':'name1','age':1}," +
"{'name':'name2','age':2}," +
"{'name':'name3','age':3}" +
"]");
Object[] deserialized = deserializer.deserialize(stream, listDog);
List<Dog> dogs = (List<Dog>) deserialized[0];
assertThat(dogs.size(), is(3));
assertThat(dogs.get(0), is(instanceOf(Dog.class)));
Dog dog = (Dog) dogs.get(0);
assertThat(dog.name, is("name1"));
assertThat(dog.age, is(1));
}
@Test
public void shouldDeserializerParseArraysWithRoot(){
InputStream stream = asStream(
"{dogs : [" +
"{'name':'name1','age':1}," +
"{'name':'name2','age':2}," +
"{'name':'name3','age':3}" +
"]}");
Object[] deserialized = deserializer.deserialize(stream, listDog);
List<Dog> dogs = (List<Dog>) deserialized[0];
assertThat(dogs.size(), is(3));
assertThat(dogs.get(0), is(instanceOf(Dog.class)));
Dog dog = (Dog) dogs.get(0);
assertThat(dog.name, is("name1"));
assertThat(dog.age, is(1));
}
@Test
public void shouldNotAcceptMethodsWithoutArguments() throws Exception {
exception.expect(IllegalArgumentException.class);
exception.expectMessage("Methods that consumes representations must receive just one argument");
deserializer.deserialize(emptyStream(), noParameter);
}
@Test
public void shouldBeAbleToDeserializeADog() throws Exception {
InputStream stream = asStream("{'dog':{'name':'Brutus','age':7}}");
Object[] deserialized = deserializer.deserialize(stream, dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldBeAbleToDeserializeADogWithoutRootAndParameterNameEqualsJsonProperty() throws Exception {
InputStream stream = asStream("{'name':'Brutus','age':7}");
Object[] deserialized = deserializer.deserialize(stream, dogParameterNameEqualsJsonPropertyWithoutRoot);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldBeAbleToDeserializeADogWithoutRoot() throws Exception {
InputStream stream = asStream("{'name':'Brutus','age':7}");
Object[] deserialized = deserializer.deserialize(stream, dogParameterWithoutRoot);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldBeAbleToDeserializeADogWithDeserializerAdapter() throws Exception {
List<JsonDeserializer<?>> deserializers = new ArrayList<>();
List<JsonSerializer<?>> serializers = new ArrayList<>();
deserializers.add(new DogDeserializer());
builder = new GsonBuilderWrapper(new MockInstanceImpl<>(serializers), new MockInstanceImpl<>(deserializers), new Serializee());
deserializer = new GsonDeserialization(builder, provider, request, container, deserializeeInstance);
InputStream stream = asStream("{'dog':{'name':'Renan Reis','age':'0'}}");
Object[] deserialized = deserializer.deserialize(stream, dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Renan"));
assertThat(dog.age, is(25));
}
@Test
public void shouldBeAbleToDeserializeADogWhenMethodHasMoreThanOneArgument() throws Exception {
InputStream stream = asStream("{'dog':{'name':'Brutus','age':7}}");
Object[] deserialized = deserializer.deserialize(stream, dogAndIntegerParameter);
assertThat(deserialized.length, is(2));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldBeAbleToDeserializeADogWhenMethodHasMoreThanOneArgumentAndJsonIsTheLastOne() throws Exception {
InputStream stream = asStream("{'dog':{'name':'Brutus','age':7}}");
Object[] deserialized = deserializer.deserialize(stream, integerAndDogParameter);
assertThat(deserialized.length, is(2));
assertThat(deserialized[1], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[1];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldBeAbleToDeserializeADogNamedDifferently() throws Exception {
InputStream stream = asStream("{'dog':{'name':'Brutus','age':7}}");
Object[] deserialized = deserializer.deserialize(stream, dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldHonorRequestHeaderAcceptCharset() throws Exception {
InputStream stream = asStream("{'dog':{'name':'ç'}}", StandardCharsets.ISO_8859_1);
when(request.getHeader("Accept-Charset")).thenReturn("UTF-8,*;q=0.5");
Object[] deserialized = deserializer.deserialize(stream, dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("ç"));
}
@Test
public void whenNoCharsetHeaderIsFoundThanAssumeItIsUTF8() throws Exception {
InputStream stream = asStream("{'dog':{'name':'ç'}}", StandardCharsets.ISO_8859_1);
when(request.getHeader("Accept-Charset")).thenReturn(null);
Object[] deserialized = deserializer.deserialize(stream, dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("ç"));
}
@Test
public void shouldByPassDeserializationWhenHasNoContent() {
Object[] deserialized = deserializer.deserialize(emptyStream(), dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(nullValue()));
}
@Test
public void shouldBeAbleToDeserializeADogWhenMethodHasMoreThanOneArgumentAndHasNotRoot() {
InputStream stream = asStream("{'name':'Brutus','age':7}");
Object[] deserialized = deserializer.deserialize(stream, dogAndIntegerParameter);
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Brutus"));
assertThat(dog.age, is(7));
}
@Test
public void shouldDeserializeFromGenericTypeOneParam() {
InputStream stream = asStream("{'entity':{'name':'Brutus','age':7,'birthday':'2013-07-23T17:14:14-03:00'}}");
BeanClass resourceClass = new DefaultBeanClass(DogGenericController.class);
Method method = new Mirror().on(DogGenericController.class).reflect().method("method").withAnyArgs();
ControllerMethod resource = new DefaultControllerMethod(resourceClass, method);
Object[] deserialized = deserializer.deserialize(stream, resource);
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, equalTo("Brutus"));
}
@Test
public void shouldDeserializeFromGenericTypeTwoParams() {
InputStream stream = asStream("{'entity':{'name':'Brutus','age':7,'birthday':'2013-07-23T17:14:14-03:00'}, 'param': 'test', 'over': 'value'}");
BeanClass resourceClass = new DefaultBeanClass(DogGenericController.class);
Method method = new Mirror().on(DogGenericController.class).reflect().method("anotherMethod").withAnyArgs();
ControllerMethod resource = new DefaultControllerMethod(resourceClass, method);
Object[] deserialized = deserializer.deserialize(stream, resource);
Dog dog = (Dog) deserialized[0];
String param = (String) deserialized[1];
assertThat(dog.name, equalTo("Brutus"));
assertThat(param, equalTo("test"));
assertThat(deserialized.length, equalTo(2));
}
@Test
public void shouldDeserializeADogWithCalendarWithISO8601() {
InputStream stream = asStream("{'dog':{'name':'Otto','age':2,'birthday':'2013-07-23T17:14:14-03:00'}}");
Object[] deserialized = deserializer.deserialize(stream, dogParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Dog.class)));
Dog dog = (Dog) deserialized[0];
assertThat(dog.name, is("Otto"));
assertThat(dog.age, is(2));
Calendar birthday = new GregorianCalendar(2013, 6, 23, 17, 14, 14);
birthday.setTimeZone(TimeZone.getTimeZone("GMT-0300"));
// calendar.equals is too bad :)
assertThat(dog.birthday.compareTo(birthday), is(0));
}
@Test
public void shouldDeserializeADateWithISO8601() {
InputStream stream = asStream("{\"date\":\"1988-02-25T02:30:15 -0300\"}");
Object[] deserialized = deserializer.deserialize(stream, dateParameter);
assertThat(deserialized.length, is(1));
assertThat(deserialized[0], is(instanceOf(Date.class)));
Date deserializedDate = (Date) deserialized[0];
Date date = new GregorianCalendar(1988, 1, 25, 2, 30, 15).getTime();
assertEquals(date, deserializedDate);
}
private InputStream asStream(String str, Charset charset) {
return new ByteArrayInputStream(str.getBytes(charset));
}
private InputStream asStream(String str) {
return asStream(str, Charset.defaultCharset());
}
private InputStream emptyStream() {
return new ByteArrayInputStream(new byte[0]);
}
}