StringToOpenTypeConverterTest.java

package org.jolokia.converter.object;

import java.util.List;
import java.util.Set;

import javax.management.*;
import javax.management.openmbean.*;

import org.jolokia.converter.util.CompositeTypeAndJson;
import org.jolokia.converter.util.TabularTypeAndJson;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

import static javax.management.openmbean.SimpleType.*;
import static org.testng.Assert.*;

/*
 * Copyright 2009-2011 Roland Huss
 *
 *   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.
 */

/**
 * @author roland
 * @since 03.08.11
 */
@Test
public class StringToOpenTypeConverterTest {

    private StringToOpenTypeConverter converter;


    @BeforeTest
    public void setup() {

        StringToObjectConverter stringToObjectConverter = new StringToObjectConverter();
        converter = new StringToOpenTypeConverter(stringToObjectConverter);
    }

    @Test
    public void nullValue() throws OpenDataException {
        assertNull(converter.convertToObject(SimpleType.STRING,null));
    }


    @Test
    public void simpleType() {
        assertTrue(converter.canConvert(SimpleType.STRING));
        assertEquals(converter.convertToObject(SimpleType.STRING,"bla"),"bla");
        assertEquals(converter.convertToObject(SimpleType.BOOLEAN,"true"),true);
        assertEquals(converter.convertToObject(SimpleType.BOOLEAN,false),false);
        assertEquals(converter.convertToObject(SimpleType.DOUBLE,4.52),4.52);
        assertEquals(converter.convertToObject(SimpleType.DOUBLE,"4.52"),4.52);
        assertEquals(converter.convertToObject(SimpleType.INTEGER,"9876"),9876);
    }


    @Test(expectedExceptions = { NumberFormatException.class })
    public void simpleTypeFailed() {
        converter.convertToObject(SimpleType.INTEGER,"4.52");
    }


    @Test
    public void arrayType() throws OpenDataException, ParseException {
        ArrayType type = new ArrayType(2,STRING);
        String json = "[ \"hello\", \"world\" ]";
        for (Object element : new Object[] { json, new JSONParser().parse(json) }) {
            Object[] data = (Object[]) converter.convertToObject(type,element);
            assertEquals(data.length,2);
            assertEquals(data[0],"hello");
            assertEquals(data[1],"world");
        }
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*JSONArray.*")
    public void arrayTypeWithWrongJson() throws OpenDataException {
        converter.convertToObject(new ArrayType(2,STRING),"{ \"hello\": \"world\"}");
    }

    @Test
    public void arrayTypeWithCompositeElementType() throws OpenDataException {
        CompositeTypeAndJson taj = new CompositeTypeAndJson(
                STRING,"verein","FCN"

        );
        CompositeData[] result =
                (CompositeData[]) converter.convertToObject(new ArrayType(2,taj.getType()),"[" + taj.getJsonAsString() + "]");
        assertEquals(result[0].get("verein"), "FCN");
        assertEquals(result.length,1);
    }

    @Test(expectedExceptions = UnsupportedOperationException.class,expectedExceptionsMessageRegExp = ".*Unsupported.*")
    public void arrayTypeWithWrongElementType() throws OpenDataException {
        TabularTypeAndJson taj = new TabularTypeAndJson(
                new String[] { "verein" },
                new CompositeTypeAndJson(
                   STRING,"verein","fcn",
                   BOOLEAN,"absteiger",false
                )
        );
        JSONArray array = new JSONArray();
        array.add(taj.getJson());
        converter.convertToObject(new ArrayType(2, taj.getType()),array);
    }

    @Test
    public void compositeType() throws OpenDataException, AttributeNotFoundException, ParseException {
        CompositeTypeAndJson taj = new CompositeTypeAndJson(
                STRING,"verein","FCN",
                INTEGER,"platz",6,
                STRING,"trainer",null,
                BOOLEAN,"absteiger",false
        );
        for (Object input : new Object[] { taj.getJson(), taj.getJsonAsString() }) {
            CompositeData result = (CompositeData) converter.convertToObject(taj.getType(),input);
            assertEquals(result.get("verein"),"FCN");
            assertEquals(result.get("trainer"),null);
            assertEquals(result.get("platz"),6);
            assertEquals(result.get("absteiger"),false);
            assertEquals(result.values().size(),4);
        }
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*JSONObject.*")
    public void compositeTypeWithWrongJson() throws OpenDataException {
        CompositeTypeAndJson taj = new CompositeTypeAndJson(
                STRING,"verein","FCN"

        );
        converter.convertToObject(taj.getType(),"[ 12, 15, 16]");
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*praesident.*")
    public void compositeTypeWithWrongKey() throws OpenDataException {
        CompositeTypeAndJson taj = new CompositeTypeAndJson(
                STRING,"verein","FCN"

        );
        converter.convertToObject(taj.getType(),"{ \"praesident\": \"hoeness\"}");
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*parse.*")
    public void invalidJson() throws OpenDataException {
        CompositeTypeAndJson taj = new CompositeTypeAndJson(
                STRING,"verein","FCN"

        );
        converter.convertToObject(taj.getType(),"{ \"praesident\":");
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*JSONAware.*")
    public void invalidJson2() throws OpenDataException {
        CompositeTypeAndJson taj = new CompositeTypeAndJson(
                STRING,"verein","FCN"

        );
        converter.convertToObject(taj.getType(),"2");
    }


    @Test
    public void tabularType() throws OpenDataException {
        TabularTypeAndJson taj = getSampleTabularType();
        TabularData data = (TabularData) converter.convertToObject(taj.getType(),taj.getJsonAsString());
        assertEquals(data.get(new String[] { "fcn" }).get("absteiger"),false);
        assertEquals(data.get(new String[] { "fcb" }).get("absteiger"),true);
    }

    @Test
    public void tabularTypeForMXBeanMaps() throws OpenDataException {
        TabularTypeAndJson taj = getSampleTabularTypeForMXBeanMap();

        String json = "{ \"keyOne\" : \"valueOne\", \"keyTwo\" : \"valueTwo\"}";
        TabularData data = (TabularData) converter.convertToObject(taj.getType(),json);
        CompositeData col1 = data.get(new String[] { "keyOne" });
        assertEquals(col1.get("key"),"keyOne");
        assertEquals(col1.get("value"),"valueOne");
        CompositeData col2 = data.get(new String[] { "keyTwo" });
        assertEquals(col2.get("key"),"keyTwo");
        assertEquals(col2.get("value"),"valueTwo");
    }

    @Test
    public void tabularTypeInFullRepresentation() throws OpenDataException, MalformedObjectNameException {
        TabularType type = getSampleTabularTypeForComplexTabularData();
        String json = "{ \"indexNames\" : [ \"user\", \"street\" ], " +
                      "  \"values\" : [ " +
                      "      { \"user\" : { \"name\" : \"roland\", \"age\" : 44 }, " +
                      "        \"street\" : \"homestreet\", " +
                      "        \"oname\" : \"java.lang:type=Memory\" " +
                      "      }]" +
                      "}";
        TabularData data = (TabularData) converter.convertToObject(type,json);
        assertNotNull(data);
        Set keySet = data.keySet();
        assertEquals(keySet.size(), 1);
        List keys = (List) keySet.iterator().next();
        assertEquals(keys.size(),2);
        assertTrue(keys.contains("homestreet"));
        CompositeData cd = checkCompositeKey(keys);
        CompositeData row = data.get(new Object[] { cd, "homestreet"});
        assertEquals(row.get("user"),cd);
        assertEquals(row.get("street"),"homestreet");
        assertEquals(row.get("oname"),new ObjectName("java.lang:type=Memory"));
    }

    private CompositeData checkCompositeKey(List pKeys) {
        for (Object o : pKeys) {
            if (o instanceof CompositeData) {
                CompositeData cd = (CompositeData) o;
                assertEquals(cd.get("name"),"roland");
                assertEquals(cd.get("age"),44);
                return cd;
            }
        }
        fail("No CD Key found");
        return null;
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*index.*name.*")
    public void invalidIndexNameForComplexTabularDataConversion() throws OpenDataException {
        TabularType type = getSampleTabularTypeForComplexTabularData();
        String json = "{ \"indexNames\" : [ \"user\", \"bla\" ], " +
                      "  \"values\" : [ " +
                      "      { \"user\" : { \"name\" : \"roland\", \"age\" : 44 }, " +
                      "        \"bla\" : \"homestreet\", " +
                      "        \"oname\" : \"java.lang:type=Memory\" " +
                      "      }]" +
                      "}";
        converter.convertToObject(type,json);
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*index.*name.*")
    public void invalidIndexNameCountForComplexTabularDataConversion() throws OpenDataException {
        TabularType type = getSampleTabularTypeForComplexTabularData();
        String json = "{ \"indexNames\" : [ \"user\", \"street\", \"bla\" ], " +
                      "  \"values\" : [ " +
                      "      { \"user\" : { \"name\" : \"roland\", \"age\" : 44 }, " +
                      "        \"street\" : \"homestreet\", " +
                      "        \"bla\" : \"blub\", " +
                      "        \"oname\" : \"java.lang:type=Memory\" " +
                      "      }]" +
                      "}";
        converter.convertToObject(type,json);
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*array.*")
    public void invalidTypeComplexTabularDataConversion1() throws OpenDataException {
        TabularType type = getSampleTabularTypeForComplexTabularData();
        String json = "{ \"indexNames\" : { \"user\" : \"bla\" }, " +
                      "  \"values\" : [ " +
                      "      { \"user\" : { \"name\" : \"roland\", \"age\" : 44 }, " +
                      "        \"street\" : \"homestreet\", " +
                      "        \"bla\" : \"blub\", " +
                      "        \"oname\" : \"java.lang:type=Memory\" " +
                      "      }]" +
                      "}";
        converter.convertToObject(type,json);
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*array.*")
    public void invalidTypeComplexTabularDataConversion2() throws OpenDataException {
        TabularType type = getSampleTabularTypeForComplexTabularData();
        String json = "{ \"indexNames\" : [ \"user\", \"street\" ], " +
                      "  \"values\" :  " +
                      "      { \"user\" : { \"name\" : \"roland\", \"age\" : 44 }, " +
                      "        \"street\" : \"homestreet\", " +
                      "        \"bla\" : \"blub\", " +
                      "        \"oname\" : \"java.lang:type=Memory\" " +
                      "      }" +
                      "}";
        converter.convertToObject(type,json);
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*object.*")
    public void invalidTypeComplexTabularDataConversion3() throws OpenDataException {
        TabularType type = getSampleTabularTypeForComplexTabularData();
        String json = "{ \"indexNames\" : [ \"user\", \"street\"], " +
                      "  \"values\" : [ " +
                      "      [{ \"user\" : { \"name\" : \"roland\", \"age\" : 44 }, " +
                      "        \"street\" : \"homestreet\", " +
                      "        \"bla\" : \"blub\", " +
                      "        \"oname\" : \"java.lang:type=Memory\" " +
                      "      }]]" +
                      "}";
        converter.convertToObject(type,json);
    }




    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*JSONObject.*")
    public void tabularTypeForMXBeanMapsFail() throws OpenDataException {
        TabularTypeAndJson taj = getSampleTabularTypeForMXBeanMap();

        converter.convertToObject(taj.getType(), "[ { \"keyOne\" : \"valueOne\" } ]");
    }

    @Test
    public void tabularTypeForMXBeanMapsComplex() throws OpenDataException {
        TabularTypeAndJson inner = getSampleTabularTypeForMXBeanMap();
        TabularTypeAndJson taj = new TabularTypeAndJson(
                new String[]{"key"},
                new CompositeTypeAndJson(
                        STRING, "key", null,
                        inner.getType(), "value", null
                )
        );

        String json = "{ \"keyOne\" : { \"innerKeyOne\" : \"valueOne\" }, \"keyTwo\" : { \"innerKeyTwo\" : \"valueTwo\"}}";
        TabularData data = (TabularData) converter.convertToObject(taj.getType(),json);
        CompositeData col1 = data.get(new String[] { "keyOne" });
        assertEquals(col1.get("key"),"keyOne");
        TabularData innerCol1 = (TabularData) col1.get("value");
        CompositeData col1inner = innerCol1.get(new String[]{"innerKeyOne"});
        assertEquals(col1inner.get("key"),"innerKeyOne");
        assertEquals(col1inner.get("value"),"valueOne");
    }


    @Test
    public void multipleLevleTabularData() throws OpenDataException {
        JSONObject map = new JSONObject();
        JSONObject inner = new JSONObject();
        map.put("fcn",inner);
        JSONObject innerinner = new JSONObject();
        inner.put("franconia",innerinner);
        innerinner.put("verein","fcn");
        innerinner.put("region","franconia");
        innerinner.put("absteiger",false);

        TabularType type = new TabularType("soccer","soccer",
                                           new CompositeType("row","row",
                                                             new String[] { "verein", "region", "absteiger" },
                                                             new String[] { "verein","region","absteiger"},
                                                             new OpenType[] { STRING, STRING, BOOLEAN}),
                                           new String[] { "verein", "region" });
        TabularData data = (TabularData) converter.convertToObject(type,map);
        CompositeData row = data.get(new Object[] { "fcn", "franconia" });
        assertNotNull(row);
        assertFalse((Boolean) row.get("absteiger"));
    }


    private TabularTypeAndJson getSampleTabularTypeForMXBeanMap() throws OpenDataException {
        return new TabularTypeAndJson(
                    new String[] { "key" },
                    new CompositeTypeAndJson(
                            STRING,"key","dummy",
                            STRING,"value", "dummy"
                    )
            );
    }



    private TabularType getSampleTabularTypeForComplexTabularData() throws OpenDataException {
        CompositeType keyType = new CompositeType("key","key",
                                                  new String[] { "name", "age"},
                                                  new String[] { "name", "age"},
                                                  new OpenType[] { STRING, INTEGER});
        CompositeTypeAndJson ctj = new CompositeTypeAndJson(
                keyType,"user",null,
                STRING,"street",null,
                OBJECTNAME,"oname",null
        );
        return new TabularType("test","test",ctj.getType(),new String[] {"user", "street"} );
    }




    private TabularTypeAndJson getSampleTabularType() throws OpenDataException {
        return new TabularTypeAndJson(
                    new String[] { "verein" },
                    new CompositeTypeAndJson(
                       STRING,"verein","fcn",
                       BOOLEAN,"absteiger",false
                    ),
                    "fcb",true,
                    "werder",false
            );
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*praesident.*")
    public void compositeTypeWithWrongType() throws OpenDataException {
        converter.convertToObject(getSampleTabularType().getType(),"{ \"praesident\": \"hoeness\"}");
    }

    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*JSONArray.*")
    public void compositeTypeWithWrongInnerType() throws OpenDataException {
        converter.convertToObject(getSampleTabularType().getType(),"[[{ \"praesident\": \"hoeness\"}]]");
    }


    @Test(expectedExceptions = IllegalArgumentException.class,expectedExceptionsMessageRegExp = ".*No converter.*")
    public void unknownOpenType() throws OpenDataException {
        converter.convertToObject(new OpenType("java.util.Date","guenther","guenther") {
            @Override
            public boolean isValue(Object obj) {
                return false;
            }

            @Override
            public boolean equals(Object obj) {
                return false;
            }

            @Override
            public int hashCode() {
                return 0;
            }

            @Override
            public String toString() {
                return null;
            }
        },"bla");
    }
}