ServerDtoTest.java

/*******************************************************************************
 * Copyright (c) 2012-2017 Codenvy, S.A.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 *******************************************************************************/
package org.eclipse.che.dto;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;

import org.eclipse.che.dto.definitions.ComplicatedDto;
import org.eclipse.che.dto.definitions.DTOHierarchy;
import org.eclipse.che.dto.definitions.DtoWithAny;
import org.eclipse.che.dto.definitions.DtoWithDelegate;
import org.eclipse.che.dto.definitions.DtoWithFieldNames;
import org.eclipse.che.dto.definitions.SimpleDto;
import org.eclipse.che.dto.definitions.DTOHierarchy.GrandchildDto;
import org.eclipse.che.dto.definitions.model.Model;
import org.eclipse.che.dto.definitions.model.ModelComponentDto;
import org.eclipse.che.dto.definitions.model.ModelDto;
import org.eclipse.che.dto.server.DtoFactory;
import org.testng.Assert;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static java.util.Arrays.asList;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;

/**
 * Tests that the interfaces specified in org.eclipse.che.dto.definitions have
 * corresponding generated server implementations.
 *
 * @author Artem Zatsarynnyi
 */
public class ServerDtoTest {

    protected final static DtoFactory dtoFactory = DtoFactory.getInstance();

    @Test
    public void testCreateSimpleDto() throws Exception {
        final String fooString = "Something";
        final int fooId = 1;
        final String _default = "test_default_keyword";

        SimpleDto dto = dtoFactory.createDto(SimpleDto.class).withName(fooString).withId(fooId).withDefault(_default);

        // Check to make sure things are in a sane state.
        checkSimpleDto(dto, fooString, fooId, _default);
    }

    @Test
    public void testSimpleDtoSerializer() throws Exception {
        final String fooString = "Something";
        final int fooId = 1;
        final String _default = "test_default_keyword";

        SimpleDto dto = dtoFactory.createDto(SimpleDto.class).withName(fooString).withId(fooId).withDefault(_default);
        final String json = dtoFactory.toJson(dto);

        JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
        assertEquals(jsonObject.get("name").getAsString(), fooString);
        assertEquals(jsonObject.get("id").getAsInt(), fooId);
        assertEquals(jsonObject.get("default").getAsString(), _default);
    }

    @Test
    public void testSimpleDtoDeserializer() throws Exception {
        final String fooString = "Something";
        final int fooId = 1;
        final String _default = "test_default_keyword";

        JsonObject json = new JsonObject();
        json.add("name", new JsonPrimitive(fooString));
        json.add("id", new JsonPrimitive(fooId));
        json.add("default", new JsonPrimitive(_default));

        SimpleDto dto = dtoFactory.createDtoFromJson(json.toString(), SimpleDto.class);

        // Check to make sure things are in a sane state.
        checkSimpleDto(dto, fooString, fooId, _default);
    }

    @Test
    public void testSerializerWithFieldNames() throws Exception {
        final String fooString = "Something";
        final String _default = "test_default_keyword";

        DtoWithFieldNames dto = dtoFactory.createDto(DtoWithFieldNames.class).withTheName(fooString).withTheDefault(_default);
        final String json = dtoFactory.toJson(dto);

        JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
        assertEquals(jsonObject.get(DtoWithFieldNames.THENAME_FIELD).getAsString(), fooString);
        assertEquals(jsonObject.get(DtoWithFieldNames.THEDEFAULT_FIELD).getAsString(), _default);
    }

    @Test
    public void testDeerializerWithFieldNames() throws Exception {
        final String fooString = "Something";
        final String _default = "test_default_keyword";

        JsonObject json = new JsonObject();
        json.add(DtoWithFieldNames.THENAME_FIELD, new JsonPrimitive(fooString));
        json.add(DtoWithFieldNames.THEDEFAULT_FIELD, new JsonPrimitive(_default));

        DtoWithFieldNames dto = dtoFactory.createDtoFromJson(json.toString(), DtoWithFieldNames.class);

        assertEquals(dto.getTheName(), fooString);
        assertEquals(dto.getTheDefault(), _default);
    }

    @Test
    public void testSerializerWithAny() throws Exception {
        final List<Object> objects = createListTestValueForAny();
        DtoWithAny dto = dtoFactory.createDto(DtoWithAny.class).withStuff(createTestValueForAny())
                                   .withObjects(objects);
        final String json = dtoFactory.toJson(dto);

        JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
        Assert.assertEquals(jsonObject.get("stuff"), createTestValueForAny());

        Assert.assertTrue(jsonObject.has("objects"));
        JsonArray jsonArray = jsonObject.get("objects").getAsJsonArray();
        assertEquals(jsonArray.size(), objects.size());
        for (int i = 0; i < jsonArray.size(); i++) {
            assertEquals(jsonArray.get(i), objects.get(i));
        }
    }

    @Test
    public void testDeserializerWithAny() throws Exception {
        JsonObject json = new JsonObject();
        json.add("stuff", createTestValueForAny());
        JsonArray jsonArray = createElementListTestValueForAny();
        json.add("objects", jsonArray);

        DtoWithAny dto = dtoFactory.createDtoFromJson(json.toString(), DtoWithAny.class);

        Gson gson = new Gson();
        Object stuffValue = gson.fromJson(createTestValueForAny(), Object.class);
        Assert.assertEquals(dto.getStuff(), stuffValue);
        Object objectsValue = gson.fromJson(createElementListTestValueForAny(), Object.class);
        Assert.assertEquals(dto.getObjects(), objectsValue);
    }

    @Test
    public void testCloneWithNullAny() throws Exception {
        DtoWithAny dto1 = dtoFactory.createDto(DtoWithAny.class);
        DtoWithAny dto2 = dtoFactory.clone(dto1);
        Assert.assertEquals(dto1, dto2);
        JsonElement json = new JsonParser().parse(dtoFactory.toJson(dto1));
        JsonObject expJson = new JsonObject();
        expJson.addProperty("id", 0);
        expJson.add("objects", new JsonArray());
        assertEquals(expJson, json);
    }

    @Test
    public void testShadowedFields() throws Exception {
        GrandchildDto dto1 = dtoFactory.createDto(GrandchildDto.class);
        dtoFactory.toJson(dto1);
    }

    /** Intentionally call several times to ensure non-reference equality */
    private static JsonElement createTestValueForAny() {
        return new JsonParser().parse("{a:100,b:{c:'blah'}}");
    }

    /** Intentionally call several times to ensure non-reference equality */
    private static List<Object> createListTestValueForAny() {
        final ArrayList<Object> objects = new ArrayList<>();
        objects.add(new JsonParser().parse("{x:1}"));
        objects.add(new JsonParser().parse("{b:120}"));
        return objects;
    }

    private JsonArray createElementListTestValueForAny() {
        JsonArray jsonArray = new JsonArray();
        for (Object object : createListTestValueForAny()) {
            jsonArray.add((JsonElement)object);
        }
        return jsonArray;
    }

    @Test
    public void testListSimpleDtoDeserializer() throws Exception {
        final String fooString_1 = "Something 1";
        final int fooId_1 = 1;
        final String _default_1 = "test_default_keyword_1";
        final String fooString_2 = "Something 2";
        final int fooId_2 = 2;
        final String _default_2 = "test_default_keyword_2";

        JsonObject json1 = new JsonObject();
        json1.add("name", new JsonPrimitive(fooString_1));
        json1.add("id", new JsonPrimitive(fooId_1));
        json1.add("default", new JsonPrimitive(_default_1));

        JsonObject json2 = new JsonObject();
        json2.add("name", new JsonPrimitive(fooString_2));
        json2.add("id", new JsonPrimitive(fooId_2));
        json2.add("default", new JsonPrimitive(_default_2));

        JsonArray jsonArray = new JsonArray();
        jsonArray.add(json1);
        jsonArray.add(json2);

        org.eclipse.che.dto.shared.JsonArray<SimpleDto> listDtoFromJson =
                dtoFactory.createListDtoFromJson(jsonArray.toString(), SimpleDto.class);

        assertEquals(listDtoFromJson.get(0).getName(), fooString_1);
        assertEquals(listDtoFromJson.get(0).getId(), fooId_1);
        assertEquals(listDtoFromJson.get(0).getDefault(), _default_1);

        assertEquals(listDtoFromJson.get(1).getName(), fooString_2);
        assertEquals(listDtoFromJson.get(1).getId(), fooId_2);
        assertEquals(listDtoFromJson.get(1).getDefault(), _default_2);
    }

    @Test
    public void testComplicatedDtoSerializer() throws Exception {
        final String fooString = "Something";
        final int fooId = 1;
        final String _default = "test_default_keyword";

        List<String> listStrings = new ArrayList<>(2);
        listStrings.add("Something 1");
        listStrings.add("Something 2");

        ComplicatedDto.SimpleEnum simpleEnum = ComplicatedDto.SimpleEnum.ONE;

        // Assume that SimpleDto works. Use it to test nested objects
        SimpleDto simpleDto = dtoFactory.createDto(SimpleDto.class).withName(fooString).withId(fooId).withDefault(_default);

        Map<String, SimpleDto> mapDtos = new HashMap<>(1);
        mapDtos.put(fooString, simpleDto);

        List<SimpleDto> listDtos = new ArrayList<>(1);
        listDtos.add(simpleDto);

        List<List<ComplicatedDto.SimpleEnum>> listOfListOfEnum = new ArrayList<>(1);
        List<ComplicatedDto.SimpleEnum> listOfEnum = new ArrayList<>(3);
        listOfEnum.add(ComplicatedDto.SimpleEnum.ONE);
        listOfEnum.add(ComplicatedDto.SimpleEnum.TWO);
        listOfEnum.add(ComplicatedDto.SimpleEnum.THREE);
        listOfListOfEnum.add(listOfEnum);

        ComplicatedDto dto = dtoFactory.createDto(ComplicatedDto.class).withStrings(listStrings).
                withSimpleEnum(simpleEnum).withMap(mapDtos).withSimpleDtos(listDtos).
                                               withArrayOfArrayOfEnum(listOfListOfEnum);


        final String json = dtoFactory.toJson(dto);
        JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();

        Assert.assertTrue(jsonObject.has("strings"));
        JsonArray jsonArray = jsonObject.get("strings").getAsJsonArray();
        assertEquals(jsonArray.get(0).getAsString(), listStrings.get(0));
        assertEquals(jsonArray.get(1).getAsString(), listStrings.get(1));

        Assert.assertTrue(jsonObject.has("simpleEnum"));
        assertEquals(jsonObject.get("simpleEnum").getAsString(), simpleEnum.name());

        Assert.assertTrue(jsonObject.has("map"));
        JsonObject jsonMap = jsonObject.get("map").getAsJsonObject();
        JsonObject value = jsonMap.get(fooString).getAsJsonObject();
        assertEquals(value.get("name").getAsString(), fooString);
        assertEquals(value.get("id").getAsInt(), fooId);
        assertEquals(value.get("default").getAsString(), _default);

        Assert.assertTrue(jsonObject.has("simpleDtos"));
        JsonArray simpleDtos = jsonObject.get("simpleDtos").getAsJsonArray();
        JsonObject simpleDtoJsonObject = simpleDtos.get(0).getAsJsonObject();
        assertEquals(simpleDtoJsonObject.get("name").getAsString(), fooString);
        assertEquals(simpleDtoJsonObject.get("id").getAsInt(), fooId);
        assertEquals(simpleDtoJsonObject.get("default").getAsString(), _default);

        Assert.assertTrue(jsonObject.has("arrayOfArrayOfEnum"));
        JsonArray arrayOfArrayOfEnum = jsonObject.get("arrayOfArrayOfEnum").getAsJsonArray().get(0).getAsJsonArray();
        assertEquals(arrayOfArrayOfEnum.get(0).getAsString(), ComplicatedDto.SimpleEnum.ONE.name());
        assertEquals(arrayOfArrayOfEnum.get(1).getAsString(), ComplicatedDto.SimpleEnum.TWO.name());
        assertEquals(arrayOfArrayOfEnum.get(2).getAsString(), ComplicatedDto.SimpleEnum.THREE.name());
    }

    @Test
    public void testComplicatedDtoDeserializer() throws Exception {
        final String fooString = "Something";
        final int fooId = 1;
        final String _default = "test_default_keyword";

        JsonArray jsonArray = new JsonArray();
        jsonArray.add(new JsonPrimitive(fooString));

        JsonObject simpleDtoJsonObject = new JsonObject();
        simpleDtoJsonObject.add("name", new JsonPrimitive(fooString));
        simpleDtoJsonObject.add("id", new JsonPrimitive(fooId));
        simpleDtoJsonObject.add("default", new JsonPrimitive(_default));

        JsonObject jsonMap = new JsonObject();
        jsonMap.add(fooString, simpleDtoJsonObject);

        JsonArray simpleDtosArray = new JsonArray();
        simpleDtosArray.add(simpleDtoJsonObject);

        JsonArray arrayOfEnum = new JsonArray();
        arrayOfEnum.add(new JsonPrimitive(ComplicatedDto.SimpleEnum.ONE.name()));
        arrayOfEnum.add(new JsonPrimitive(ComplicatedDto.SimpleEnum.TWO.name()));
        arrayOfEnum.add(new JsonPrimitive(ComplicatedDto.SimpleEnum.THREE.name()));
        JsonArray arrayOfArrayEnum = new JsonArray();
        arrayOfArrayEnum.add(arrayOfEnum);

        JsonObject complicatedDtoJsonObject = new JsonObject();
        complicatedDtoJsonObject.add("strings", jsonArray);
        complicatedDtoJsonObject.add("simpleEnum", new JsonPrimitive(ComplicatedDto.SimpleEnum.ONE.name()));
        complicatedDtoJsonObject.add("map", jsonMap);
        complicatedDtoJsonObject.add("simpleDtos", simpleDtosArray);
        complicatedDtoJsonObject.add("arrayOfArrayOfEnum", arrayOfArrayEnum);

        ComplicatedDto complicatedDto =
                dtoFactory.createDtoFromJson(complicatedDtoJsonObject.toString(), ComplicatedDto.class);

        assertEquals(complicatedDto.getStrings().get(0), fooString);
        assertEquals(complicatedDto.getSimpleEnum(), ComplicatedDto.SimpleEnum.ONE);
        checkSimpleDto(complicatedDto.getMap().get(fooString), fooString, fooId, _default);
        checkSimpleDto(complicatedDto.getSimpleDtos().get(0), fooString, fooId, _default);
        assertEquals(complicatedDto.getArrayOfArrayOfEnum().get(0).get(0), ComplicatedDto.SimpleEnum.ONE);
        assertEquals(complicatedDto.getArrayOfArrayOfEnum().get(0).get(1), ComplicatedDto.SimpleEnum.TWO);
        assertEquals(complicatedDto.getArrayOfArrayOfEnum().get(0).get(2), ComplicatedDto.SimpleEnum.THREE);
    }

    private void checkSimpleDto(SimpleDto dto, String expectedName, int expectedId, String expectedDefault) {
        assertEquals(dto.getName(), expectedName);
        assertEquals(dto.getId(), expectedId);
        assertEquals(dto.getDefault(), expectedDefault);
    }

    @Test
    public void testDelegate() {
        assertEquals(DtoFactory.getInstance().createDto(DtoWithDelegate.class).withFirstName("TEST").nameWithPrefix("### "), "### TEST");
    }

    @Test
    public void shouldBeAbleToExtendModelSkeletonWithDTOs() {
        final DtoFactory factory = DtoFactory.getInstance();
        final Model model = factory.createDto(ModelDto.class)
                                   .withPrimary(factory.createDto(ModelComponentDto.class).withName("primary name"))
                                   .withComponents(asList(factory.createDto(ModelComponentDto.class).withName("name"),
                                                          factory.createDto(ModelComponentDto.class).withName("name2"),
                                                          factory.createDto(ModelComponentDto.class).withName("name3")));

        assertEquals(model.getPrimary(), factory.createDto(ModelComponentDto.class).withName("primary name"));
        assertEquals(model.getComponents().size(), 3);
        assertTrue(model.getComponents().contains(factory.createDto(ModelComponentDto.class).withName("name")));
        assertTrue(model.getComponents().contains(factory.createDto(ModelComponentDto.class).withName("name2")));
        assertTrue(model.getComponents().contains(factory.createDto(ModelComponentDto.class).withName("name3")));
    }

    @Test
    public void shouldBeAbleToExtendsNotDTOInterfacesHierarchyWithDTOInterface() {
        final DTOHierarchy.ChildDto childDto = DtoFactory.getInstance()
                                                         .createDto(DTOHierarchy.ChildDto.class)
                                                         .withDtoField("dto-field")
                                                         .withChildField("child-field")
                                                         .withParentField("parent-field");

        assertEquals(childDto.getDtoField(), "dto-field");
        assertEquals(childDto.getChildField(), "child-field");
        assertEquals(childDto.getParentField(), "parent-field");
    }
}