/***
* 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 br.com.caelum.vraptor.serialization.JSONSerialization.ENVIRONMENT_INDENTED_KEY;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.TimeZone;
import javax.servlet.http.HttpServletResponse;
import org.junit.Before;
import org.junit.Test;
import br.com.caelum.vraptor.environment.Environment;
import br.com.caelum.vraptor.interceptor.DefaultTypeNameExtractor;
import br.com.caelum.vraptor.serialization.SkipSerialization;
import br.com.caelum.vraptor.serialization.JSONPSerialization;
import br.com.caelum.vraptor.serialization.Serializee;
import br.com.caelum.vraptor.util.test.MockInstanceImpl;
import com.google.common.collect.ForwardingCollection;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
public class GsonJSONSerializationTest {
private GsonJSONSerialization serialization;
private ByteArrayOutputStream stream;
private HttpServletResponse response;
private DefaultTypeNameExtractor extractor;
private Environment environment;
private GsonSerializerBuilder builder;
@Before
public void setup() throws Exception {
TimeZone.setDefault(TimeZone.getTimeZone("GMT-0300"));
stream = new ByteArrayOutputStream();
response = mock(HttpServletResponse.class);
when(response.getWriter()).thenReturn(new PrintWriter(stream));
extractor = new DefaultTypeNameExtractor();
environment = mock(Environment.class);
List<JsonSerializer<?>> jsonSerializers = new ArrayList<>();
List<JsonDeserializer<?>> jsonDeserializers = new ArrayList<>();
jsonSerializers.add(new CalendarGsonConverter());
jsonSerializers.add(new DateGsonConverter());
jsonSerializers.add(new CollectionSerializer());
jsonSerializers.add(new EnumSerializer());
builder = new GsonBuilderWrapper(new MockInstanceImpl<>(jsonSerializers), new MockInstanceImpl<>(jsonDeserializers), new Serializee());
serialization = new GsonJSONSerialization(response, extractor, builder, environment);
}
@SkipSerialization
public static class UserPrivateInfo {
String cpf;
String phone;
public UserPrivateInfo(String cpf, String phone) {
this.cpf = cpf;
this.phone = phone;
}
}
public static class User {
String login;
@SkipSerialization
String password;
UserPrivateInfo info;
public User(String login, String password, UserPrivateInfo info) {
this.login = login;
this.password = password;
this.info = info;
}
}
public static class Address {
String street;
public Address(String street) {
this.street = street;
}
}
public static class Client {
String name;
Address address;
Calendar included;
public Client(String name) {
this.name = name;
}
public Client(String name, Address address) {
this.name = name;
this.address = address;
}
}
public static class Item {
String name;
double price;
public Item(String name, double price) {
this.name = name;
this.price = price;
}
}
public static class Order {
Client client;
double price;
String comments;
List<Item> items;
public Order(Client client, double price, String comments, Item... items) {
this.client = client;
this.price = price;
this.comments = comments;
this.items = Arrays.asList(items);
}
public String nice() {
return "nice output";
}
}
public static class AdvancedOrder extends Order {
@SuppressWarnings("unused")
private final String notes;
public AdvancedOrder(Client client, double price, String comments, String notes) {
super(client, price, comments);
this.notes = notes;
}
}
public static class GenericWrapper<T> {
Collection<T> entityList;
Integer total;
public GenericWrapper(Collection<T> entityList, Integer total) {
this.entityList = entityList;
this.total = total;
}
}
public static class ClientAddressExclusion implements ExclusionStrategy {
@Override
public boolean shouldSkipField(FieldAttributes f) {
return f.getName().equals("address");
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return false;
}
}
@Test
public void shouldSerializeGenericClass() {
String expectedResult = "{\"genericWrapper\":{\"entityList\":[{\"name\":\"washington botelho\"},{\"name\":\"washington botelho\"}],\"total\":2}}";
Collection<Client> entityList = new ArrayList<>();
entityList.add(new Client("washington botelho"));
entityList.add(new Client("washington botelho"));
GenericWrapper<Client> wrapper = new GenericWrapper<>(entityList, entityList.size());
// serialization.from(wrapper).include("entityList").include("entityList.name").serialize();
serialization.from(wrapper).include("entityList").serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldSerializeAllBasicFields() {
String expectedResult = "{\"order\":{\"price\":15.0,\"comments\":\"pack it nicely, please\"}}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(order).serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldSerializeAllBasicFieldsIndented() {
String expectedResult = "{\n \"order\": {\n \"price\": 15.0,\n \"comments\": \"pack it nicely, please\"\n }\n}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.indented().from(order).serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldIndentedWhenEnvironmentReturnsTrue() {
when(environment.supports(ENVIRONMENT_INDENTED_KEY)).thenReturn(true);
serialization.init();
String expectedResult = "{\n \"order\": {\n \"price\": 15.0,\n \"comments\": \"pack it nicely, please\"\n }\n}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(order).serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldNotIndentedWhenEnvironmentReturnsFalse() {
when(environment.supports(ENVIRONMENT_INDENTED_KEY)).thenReturn(false);
serialization.init();
String expectedResult = "{\"order\":{\"price\":15.0,\"comments\":\"pack it nicely, please\"}}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(order).serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldUseAlias() {
String expectedResult = "{\"customOrder\":{\"price\":15.0,\"comments\":\"pack it nicely, please\"}}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(order, "customOrder").serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
public static enum Type {
basic, advanced
}
class BasicOrder extends Order {
public BasicOrder(Client client, double price, String comments, Type type) {
super(client, price, comments);
this.type = type;
}
@SuppressWarnings("unused")
private final Type type;
}
@Test
public void shouldSerializeEnumFields() {
// String expectedResult =
// "<basicOrder><type>basic</type><price>15.0</price><comments>pack it nicely, please</comments></basicOrder>";
Order order = new BasicOrder(new Client("guilherme silveira"), 15.0, "pack it nicely, please",
Type.basic);
serialization.from(order).serialize();
String result = result();
assertThat(result, containsString("\"type\":\"basic\""));
}
@Test
public void shouldSerializeCollection() {
String expectedResult = "{\"price\":15.0,\"comments\":\"pack it nicely, please\"}";
expectedResult += "," + expectedResult;
expectedResult = "{\"list\":[" + expectedResult + "]}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(Arrays.asList(order, order)).serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldSerializeCollectionWithPrefixTag() {
String expectedResult = "{\"price\":15.0,\"comments\":\"pack it nicely, please\"}";
expectedResult += "," + expectedResult;
expectedResult = "{\"orders\":[" + expectedResult + "]}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(Arrays.asList(order, order), "orders").serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldExcludeNonPrimitiveFieldsFromACollection() {
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item(
"name", 12.99));
serialization.from(Arrays.asList(order, order), "orders").exclude("price").serialize();
assertThat(result(), not(containsString("\"items\"")));
assertThat(result(), not(containsString("name")));
assertThat(result(), not(containsString("\"price\"")));
assertThat(result(), not(containsString("12.99")));
assertThat(result(), not(containsString("15.0")));
}
@Test
public void shouldExcludeOnlyOmmitedFields() {
User user = new User("caelum", "pwd12345",
new UserPrivateInfo("123.456.789-00", "+55 (11) 1111-1111"));
serialization.from(user).recursive().serialize();
assertThat(result(), not(containsString("\"pwd12345\"")));
assertThat(result(), not(containsString("password")));
assertThat(result(), containsString("\"caelum\""));
assertThat(result(), containsString("login"));
}
@Test
public void shouldExcludeOmmitedClasses() {
User user = new User("caelum", "pwd12345",
new UserPrivateInfo("123.456.789-00", "+55 (11) 1111-1111"));
serialization.from(user).recursive().serialize();
assertThat(result(), not(containsString("info")));
assertThat(result(), not(containsString("cpf")));
assertThat(result(), not(containsString("phone")));
}
static class WithAdvanced {
AdvancedOrder order;
}
@Test
public void shouldSerializeParentFields() {
// String expectedResult =
// "<advancedOrder><notes>complex package</notes><price>15.0</price><comments>pack it nicely, please</comments></advancedOrder>";
Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package");
serialization.from(order).serialize();
assertThat(result(), containsString("\"notes\":\"complex package\""));
}
@Test
public void shouldExcludeNonPrimitiveParentFields() {
// String expectedResult =
// "<advancedOrder><notes>complex package</notes><price>15.0</price><comments>pack it nicely, please</comments></advancedOrder>";
WithAdvanced advanced = new WithAdvanced();
advanced.order = new AdvancedOrder(new Client("john"), 15.0, "pack it nicely, please",
"complex package");
serialization.from(advanced).include("order").serialize();
assertThat(result(), not(containsString("\"client\"")));
}
@Test
public void shouldExcludeParentFields() {
Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package");
serialization.from(order).exclude("comments").serialize();
assertThat(result(), not(containsString("\"comments\"")));
}
@Test
public void shouldOptionallyExcludeFields() {
String expectedResult = "{\"order\":{\"comments\":\"pack it nicely, please\"}}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(order).exclude("price").serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldOptionallyIncludeFieldAndNotItsNonPrimitiveFields() {
// String expectedResult =
// "<order><client><name>guilherme silveira</name> </client> <price>15.0</price><comments>pack it nicely, please</comments></order>";
Order order = new Order(new Client("guilherme silveira", new Address("R. Vergueiro")), 15.0,
"pack it nicely, please");
serialization.from(order).include("client").serialize();
assertThat(result(), containsString("\"name\":\"guilherme silveira\""));
assertThat(result(), not(containsString("R. Vergueiro")));
}
@Test
public void shouldOptionallyIncludeChildField() {
// String expectedResult =
// "<order><client><name>guilherme silveira</name> </client> <price>15.0</price><comments>pack it nicely, please</comments></order>";
Order order = new Order(new Client("guilherme silveira", new Address("R. Vergueiro")), 15.0,
"pack it nicely, please");
serialization.from(order).include("client", "client.address").serialize();
assertThat(result(), containsString("\"street\":\"R. Vergueiro\""));
}
@Test
public void shouldOptionallyExcludeChildField() {
// String expectedResult =
// "<order><client></client> <price>15.0</price><comments>pack it nicely, please</comments></order>";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please");
serialization.from(order).include("client").exclude("client.name").serialize();
assertThat(result(), containsString("\"client\""));
assertThat(result(), not(containsString("guilherme silveira")));
}
@Test
public void shouldOptionallyIncludeListChildFields() {
// String expectedResult =
// "<order><client></client> <price>15.0</price><comments>pack it nicely, please</comments></order>";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item(
"any item", 12.99));
serialization.from(order).include("items").serialize();
assertThat(result(), containsString("\"items\""));
assertThat(result(), containsString("\"name\":\"any item\""));
assertThat(result(), containsString("\"price\":12.99"));
}
@Test
public void shouldExcludeAllPrimitiveFieldsInACollection() {
String expectedResult = "{\"list\":[{},{}]}";
List<Order> orders = new ArrayList<>();
orders.add(new Order(new Client("nykolas lima"), 15.0, "gift bags, please"));
orders.add(new Order(new Client("Rafael Dipold"), 15.0, "gift bags, please"));
serialization.from(orders).excludeAll().serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldOptionallyExcludeFieldsFromIncludedListChildFields() {
// String expectedResult =
// "<order><client></client> <price>15.0</price><comments>pack it nicely, please</comments></order>";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item(
"any item", 12.99));
serialization.from(order).include("items").exclude("items.price").serialize();
assertThat(result(), containsString("\"items\""));
assertThat(result(), containsString("\"name\":\"any item\""));
assertThat(result(), not(containsString("12.99")));
}
@Test
public void shouldOptionallyRemoveRoot() {
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item(
"any item", 12.99));
serialization.withoutRoot().from(order).include("items").exclude("items.price").serialize();
assertThat(result(), containsString("\"items\""));
assertThat(result(), containsString("\"name\":\"any item\""));
assertThat(result(), not(containsString("12.99")));
assertThat(result(), not(containsString("\"order\":")));
}
@Test
public void shouldOptionallyRemoveRootIndented() {
String expected = "{\n \"price\": 15.0,\n \"comments\": \"pack it nicely, please\",\n \"items\": [\n {\n \"name\": \"any item\"\n }\n ]\n}";
Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item(
"any item", 12.99));
serialization.indented().withoutRoot().from(order).include("items").exclude("items.price")
.serialize();
assertThat(result(), equalTo(expected));
}
private String result() {
return new String(stream.toByteArray());
}
static class MyCollection extends ForwardingCollection<Order> {
@Override
protected Collection<Order> delegate() {
return Arrays.asList(new Order(new Client("client"), 12.22, "hoay"));
}
}
static class CollectionSerializer implements JsonSerializer<MyCollection> {
@Override
public JsonElement serialize(MyCollection myColl, java.lang.reflect.Type typeOfSrc,
JsonSerializationContext context) {
return new JsonParser().parse("[testing]").getAsJsonArray();
}
}
//Expect that a ParameterizedType should be registered
static class EnumSerializer implements JsonSerializer<Enum<?>> {
@Override public JsonElement serialize(Enum<?> src, java.lang.reflect.Type typeOfSrc, JsonSerializationContext context) {
return new JsonPrimitive(src.name());
}
}
@Test
public void shouldUseCollectionConverterWhenItExists() {
String expectedResult = "[\"testing\"]";
serialization.withoutRoot().from(new MyCollection()).serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldSerializeCalendarTimeWithISO8601() {
Client c = new Client("renan");
c.included = new GregorianCalendar(2012, 8, 3, 1, 5, 9);
c.included.setTimeZone(TimeZone.getTimeZone("GMT-0300"));
serialization.from(c).serialize();
String result = result();
String expectedResult = "{\"client\":{\"name\":\"renan\",\"included\":\"2012-09-03T01:05:09-03:00\"}}";
assertThat(result, is(equalTo(expectedResult)));
}
@Test
public void shouldSerializeDateWithISO8601() {
Date date = new GregorianCalendar(1988, 0, 25, 1, 30, 15).getTime();
serialization.from(date).serialize();
String expectedResult = "{\"date\":\"1988-01-25T01:30:15-0300\"}";
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldExcludeAllPrimitiveFields() {
String expectedResult = "{\"order\":{}}";
Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please");
serialization.from(order).excludeAll().serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldExcludeAllPrimitiveParentFields() {
String expectedResult = "{\"advancedOrder\":{}}";
Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package");
serialization.from(order).excludeAll().serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldExcludeAllThanIncludeAndSerialize() {
String expectedResult = "{\"order\":{\"price\":15.0}}";
Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please");
serialization.from(order).excludeAll().include("price").serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
@Test
public void shouldSerializeWithCallback() {
JSONPSerialization serialization = new GsonJSONPSerialization(response, extractor, builder, environment);
String expectedResult = "calculate({\"order\":{\"price\":15.0}})";
Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please");
serialization.withCallback("calculate").from(order).excludeAll().include("price").serialize();
assertThat(result(), is(equalTo(expectedResult)));
}
}