MsgPackResultConverterTest.java

package com.tinkerpop.rexster.gremlin.converter;

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.serializer.msgpack.templates.ResultsConverter;
import org.junit.Assert;
import org.junit.Test;
import org.msgpack.MessagePack;
import org.msgpack.template.Template;
import org.msgpack.type.MapValue;
import org.msgpack.type.Value;
import org.msgpack.type.ValueFactory;
import org.msgpack.unpacker.BufferUnpacker;
import org.msgpack.unpacker.Converter;

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

import static org.msgpack.template.Templates.TString;
import static org.msgpack.template.Templates.TValue;
import static org.msgpack.template.Templates.tMap;


public class MsgPackResultConverterTest {

    private MsgPackResultConverter converter = new MsgPackResultConverter();
    private MessagePack msgpack = new MessagePack();

    @Test
    public void convertNullResultReturnsNull() throws Exception {
        byte[] results = this.converter.convert(null);
        Assert.assertNotNull(results);
        Assert.assertTrue(msgpack.read(results).isNilValue());
    }

    @Test
    public void convertJSONObjectNullResultReturnsNull() throws Exception {
        byte[] results = this.converter.convert(ValueFactory.createNilValue());
        Assert.assertNotNull(results);
        Assert.assertTrue(msgpack.read(results).isNilValue());
    }

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

        byte[] results = this.converter.convert(table);

        Assert.assertNotNull(results);


        final Object unpackedObj = ResultsConverter.deserializeObject(this.msgpack.read(results));
        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();
        byte[] converted = this.converter.convert(g.getVertices());

        final BufferUnpacker unpacker = msgpack.createBufferUnpacker(converted);
        final Object unpacked = unpacker.readValue();

        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<FunObject> funList = new ArrayList<FunObject>();
        funList.add(new FunObject("x"));
        funList.add(new FunObject("y"));
        Iterable<FunObject> iterable = funList;

        byte[] converted = this.converter.convert(iterable);

        Assert.assertNotNull(converted);

        final BufferUnpacker unpacker = msgpack.createBufferUnpacker(converted);
        final Object unpacked = unpacker.readValue();

        Assert.assertTrue(unpacked instanceof Iterable);

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

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

        while (unpackerItty.hasNext()) {
            final Value v = (Value) unpackerItty.next();
            if (v.asRawValue().getString().equals("x")) {
                matchX = true;
            }

            if (v.asRawValue().getString().equals("y")) {
                matchY = true;
            }

            counter++;
        }

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

    @Test
    public void convertIterator() throws Exception {

        ArrayList<FunObject> funList = new ArrayList<FunObject>();
        funList.add(new FunObject("x"));
        funList.add(new FunObject("y"));
        Iterator<FunObject> iterable = funList.iterator();

        byte[] converted = this.converter.convert(iterable);

        final BufferUnpacker unpacker = msgpack.createBufferUnpacker(converted);
        final Object unpacked = unpacker.readValue();

        Assert.assertTrue(unpacked instanceof Iterable);

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

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

        while (unpackerItty.hasNext()) {
            final Value v = (Value) unpackerItty.next();
            if (v.asRawValue().getString().equals("x")) {
                matchX = true;
            }

            if (v.asRawValue().getString().equals("y")) {
                matchY = true;
            }

            counter++;
        }

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

    @Test
    public void convertIteratorNullElement() throws Exception {

        ArrayList<FunObject> funList = new ArrayList<FunObject>();
        funList.add(new FunObject("x"));
        funList.add(null);
        funList.add(new FunObject("y"));
        Iterator<FunObject> iterable = funList.iterator();

        byte[] converted = this.converter.convert(iterable);

        final BufferUnpacker unpacker = msgpack.createBufferUnpacker(converted);
        final Object unpacked = unpacker.readValue();
        final Iterator unpackerItty = ((Iterable) unpacked).iterator();

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

        while (unpackerItty.hasNext()) {
            final Value v = (Value) unpackerItty.next();
            if (v.isRawValue() && v.asRawValue().getString().equals("x")) {
                matchX = true;
            }

            if (v.isRawValue() && v.asRawValue().getString().equals("y")) {
                matchY = true;
            }

            if (v.isNilValue()) {
                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", new FunObject("x"));
        map.put("y", "some");
        map.put("z", innerMap);

        byte[] converted = this.converter.convert(map);

        Assert.assertNotNull(converted);

        final BufferUnpacker unpacker = msgpack.createBufferUnpacker(converted);
        final Template<Map<String, Value>> mapTmpl = tMap(TString, TValue);

        Map<String, Value> unpackedMap = unpacker.read(mapTmpl);
        Assert.assertTrue(unpackedMap.containsKey("x"));
        Assert.assertTrue(unpackedMap.containsKey("y"));
        Assert.assertTrue(unpackedMap.containsKey("z"));
        Assert.assertEquals("x", unpackedMap.get("x").asRawValue().getString());
        Assert.assertEquals("some", unpackedMap.get("y").asRawValue().getString());

        MapValue mapValue = unpackedMap.get("z").asMapValue();
        Map innerMapValue = new Converter(mapValue).read(tMap(TString, TString));
        Assert.assertNotNull(innerMapValue);
        Assert.assertEquals("b", innerMapValue.get("a"));
    }

    private class FunObject {
        private String val;

        public FunObject(String val) {
            this.val = val;
        }

        public String toString() {
            return this.val;
        }
    }
}