AbstractResultSerializerTest.java

package com.tinkerpop.rexster.protocol.serializer;

import com.tinkerpop.blueprints.impls.tg.TinkerGraph;
import com.tinkerpop.blueprints.impls.tg.TinkerGraphFactory;
import com.tinkerpop.pipes.util.structures.Table;
import com.tinkerpop.rexster.protocol.msg.ScriptResponseMessage;
import org.junit.Assert;
import org.junit.Test;

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

/**
 * Tests that results are properly serialized by a serializer class
 */
public abstract class AbstractResultSerializerTest {

    /**
     * @return
     */
    protected abstract RexProSerializer getSerializer();

    /**
     * puts the given value into a serialized response message, then
     * deserializes it and returns the result
     *
     * @param value the value to serialize
     * @return
     */
    private Object serializeAndDeserialize(Object value) throws Exception {
        ScriptResponseMessage msg = new ScriptResponseMessage();
        msg.Results.set(value);
        RexProSerializer serializer = getSerializer();

        byte[] bytes = serializer.serialize(msg, ScriptResponseMessage.class);
        return serializer.deserialize(bytes, ScriptResponseMessage.class);
    }


    @Test
    public void testNull() throws Exception {
        Object obj = serializeAndDeserialize(null);
        Assert.assertEquals(obj, null);
    }

    @Test
    public void testShort() throws Exception {
        Object obj = serializeAndDeserialize(Short.MAX_VALUE);

        Assert.assertTrue(obj instanceof Long);
        Long value = (Long) obj;
        Assert.assertTrue(value == Short.MAX_VALUE);
    }

    @Test
    public void testInt() throws Exception {
        Object obj = serializeAndDeserialize(Integer.MAX_VALUE);

        Assert.assertTrue(obj instanceof Long);
        Long value = (Long) obj;
        Assert.assertTrue(value == Integer.MAX_VALUE);
    }

    @Test
    public void testLong() throws Exception {
        Object obj = serializeAndDeserialize(Long.MAX_VALUE);

        Assert.assertTrue(obj instanceof Long);
        Long value = (Long) obj;
        Assert.assertTrue(value == Long.MAX_VALUE);
    }

    @Test
    public void testFloat() throws Exception {
        Object obj = serializeAndDeserialize(Float.MAX_VALUE);

        Assert.assertTrue(obj instanceof Double);
        Double value = (Double) obj;
        Assert.assertTrue(value == Float.MAX_VALUE);
    }

    @Test
    public void testDouble() throws Exception {
        Object obj = serializeAndDeserialize(Double.MAX_VALUE);

        Assert.assertTrue(obj instanceof Double);
        Double value = (Double) obj;
        Assert.assertTrue(value == Double.MAX_VALUE);
    }

    @Test
    public void convertTable() throws Exception {
        Table table = new Table("col1", "col2");
        table.addRow("x1", "x2");
        table.addRow("y1", "y2");

        final Object unpackedObj = serializeAndDeserialize(table);

        Assert.assertTrue(unpackedObj instanceof ArrayList);
        final ArrayList unpacked = (ArrayList) unpackedObj;

        Map<String, String> mapX = (Map<String, String>) unpacked.get(0);
        Assert.assertTrue(mapX.containsKey("col1"));
        Assert.assertTrue(mapX.containsKey("col2"));
        Assert.assertEquals("x1", mapX.get("col1"));
        Assert.assertEquals("x2", mapX.get("col2"));

        Map<String, String> mapY = (Map<String, String>) unpacked.get(1);
        Assert.assertTrue(mapY.containsKey("col1"));
        Assert.assertTrue(mapY.containsKey("col2"));
        Assert.assertEquals("y1", mapY.get("col1"));
        Assert.assertEquals("y2", mapY.get("col2"));
    }

    @Test
    public void convertElements() throws Exception {
        TinkerGraph g = TinkerGraphFactory.createTinkerGraph();

        final Object unpacked = serializeAndDeserialize(g.getVertices());

        Assert.assertTrue(unpacked instanceof Iterable);

        final Iterator unpackerItty = ((Iterable) unpacked).iterator();

        int counter = 0;
        while (unpackerItty.hasNext()) {
            unpackerItty.next();
            counter++;
        }

        Assert.assertEquals(6, counter);
    }

    @Test
    public void convertIterable() throws Exception {

        ArrayList<String> stringList = new ArrayList<String>();
        stringList.add("abc");
        stringList.add("xyz");
        Iterable<String> iterable = stringList;

        final Object unpacked = serializeAndDeserialize(iterable);

        Assert.assertTrue(unpacked instanceof Iterable);

        final Iterator unpackerItty = ((Iterable) unpacked).iterator();

        int counter = 0;
        boolean matchX = false;
        boolean matchY = false;

        while (unpackerItty.hasNext()) {
            final String v = (String) unpackerItty.next();
            if (v.equals("abc")) matchX = true;
            if (v.equals("xyz")) matchY = true;
            counter++;
        }

        Assert.assertEquals(2, counter);
        Assert.assertTrue(matchX && matchY);
    }

    @Test
    public void convertIterator() throws Exception {

        ArrayList<String> stringList = new ArrayList<String>();
        stringList.add("abc");
        stringList.add("xyz");
        Iterable<String> iterable = stringList;

        final Object unpacked = serializeAndDeserialize(iterable);

        Assert.assertTrue(unpacked instanceof Iterable);

        final Iterator unpackerItty = ((Iterable) unpacked).iterator();

        int counter = 0;
        boolean matchX = false;
        boolean matchY = false;

        while (unpackerItty.hasNext()) {
            final String v = (String) unpackerItty.next();
            if (v.equals("abc")) matchX = true;
            if (v.equals("xyz")) matchY = true;
            counter++;
        }

        Assert.assertEquals(2, counter);
        Assert.assertTrue(matchX && matchY);
    }

    @Test
    public void convertIteratorNullElement() throws Exception {

        ArrayList<String> stringList = new ArrayList<String>();
        stringList.add("abc");
        stringList.add(null);
        stringList.add("xyz");
        Iterable<String> iterable = stringList;

        final Object unpacked = serializeAndDeserialize(iterable);
        Assert.assertTrue(unpacked instanceof  Iterable);
        final Iterator unpackerItty = ((Iterable) unpacked).iterator();

        int counter = 0;
        boolean matchX = false;
        boolean matchY = false;
        boolean matchNil = false;

        while (unpackerItty.hasNext()) {
            final String v = (String) unpackerItty.next();
            if (v != null && v.equals("abc")) matchX = true;
            if (v != null && v.equals("xyz")) matchY = true;
            if (v == null) matchNil = true;
            counter++;
        }

        Assert.assertEquals(3, counter);
        Assert.assertTrue(matchX && matchY && matchNil);
    }

    @Test
    public void convertMap() throws Exception {
        Map<String, Object> map = new HashMap<String, Object>();
        Map<String, String> innerMap = new HashMap<String, String>();
        innerMap.put("a", "b");

        map.put("x", "x");
        map.put("y", "some");
        map.put("z", innerMap);

        final Object unpacked = serializeAndDeserialize(map);

        Map<String, Object> unpackedMap = (Map) unpacked;
        Assert.assertTrue(unpackedMap.containsKey("x"));
        Assert.assertTrue(unpackedMap.containsKey("y"));
        Assert.assertTrue(unpackedMap.containsKey("z"));
        Assert.assertEquals("x", unpackedMap.get("x"));
        Assert.assertEquals("some", unpackedMap.get("y"));

        Object mapValue = unpackedMap.get("z");
        Assert.assertTrue(mapValue instanceof Map);
        Map<String, String> innerMapValue = (Map) mapValue;
        Assert.assertNotNull(innerMapValue);
        Assert.assertEquals("b", innerMapValue.get("a"));
    }
}