embulk-input-dynamodb 0.0.3 → 0.1.0

data/src/main/scala/org/embulk/input/{DynamoDBUtil.scala → dynamodb/DynamoDBUtil.scala}

@@ -1,67 +1,34 @@
-package org.embulk.input
+package org.embulk.input.dynamodb
 
 import java.util.{ArrayList => JArrayList, List => JList, Map => JMap}
 
-import com.amazonaws.auth.profile.ProfileCredentialsProvider
-import com.amazonaws.auth.{AWSCredentials, AWSCredentialsProvider, BasicAWSCredentials}
+import com.amazonaws.ClientConfiguration
 import com.amazonaws.regions.Regions
 import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient
-import com.amazonaws.services.dynamodbv2.model._
-import com.amazonaws.{AmazonClientException, ClientConfiguration}
+import com.amazonaws.services.dynamodbv2.model.{AttributeValue, Condition, ScanRequest, ScanResult}
 import org.embulk.spi._
+import org.embulk.spi.`type`.Types
+import org.msgpack.value.{ValueFactory, Value}
 
 import scala.collection.JavaConversions._
+import scala.collection.JavaConverters._
 
 object DynamoDBUtil {
   def createClient(task: PluginTask): AmazonDynamoDBClient = {
-    try {
-      createClientUsingIAMRole(task)
-    } catch {
-      case e: AmazonClientException =>
-        createClientUsingCredentials(task)
-    }
-  }
-
-  private def getCredentialsProvider(task: PluginTask): AWSCredentialsProvider = {
-   {for {
-      accessKey <- Option(task.getAccessKey.orNull)
-      secretKey <- Option(task.getSecretKey.orNull)
-    } yield {
-     new AWSCredentialsProvider {
-       override def refresh(): Unit = { }
-       override def getCredentials: AWSCredentials = {
-         new BasicAWSCredentials(accessKey, secretKey)
-       }
-     }
-    }}.getOrElse {
-      new ProfileCredentialsProvider()
-    }
-  }
-
-  private def createClientUsingIAMRole(task: PluginTask): AmazonDynamoDBClient = {
-    val client: AmazonDynamoDBClient = new AmazonDynamoDBClient(
-      new ClientConfiguration().withMaxConnections(10))
-      .withRegion(Regions.fromName(task.getRegion))
-
-    client.describeTable(task.getTable)   // FIXME
-
-    client
-  }
-
-  private def createClientUsingCredentials(task: PluginTask): AmazonDynamoDBClient = {
-    val credentialsProvider: AWSCredentialsProvider = getCredentialsProvider(task)
-    val client: AmazonDynamoDBClient = new AmazonDynamoDBClient(
-      credentialsProvider,
-      new ClientConfiguration().withMaxConnections(10))
+    new AmazonDynamoDBClient(
+      AwsCredentials.getCredentialsProvider(task),
+      new ClientConfiguration()
+        .withMaxConnections(50))  // SDK Default Value
       .withRegion(Regions.fromName(task.getRegion))
-
-    client.describeTable(task.getTable)  // FIXME
-
-    client
   }
 
 
-  def scan(client: AmazonDynamoDBClient, task: PluginTask, schema: Schema, output: PageOutput): Unit = {
+  def scan(
+            task: PluginTask,
+            schema: Schema,
+            output: PageOutput)
+          (implicit client: AmazonDynamoDBClient): Unit =
+  {
     val allocator: BufferAllocator = task.getBufferAllocator
     val pageBuilder: PageBuilder = new PageBuilder(allocator, schema, output)
 
@@ -70,7 +37,7 @@ object DynamoDBUtil {
     schema.getColumns.foreach { column =>
       attributes.add(column.getName)
     }
-    val scanFilter: Map[String, Condition] = createScanFilter(task)
+    val scanFilter: JMap[String, Condition] = createScanFilter(task)
     var evaluateKey: JMap[String, AttributeValue] = null
 
     val scanLimit: Long   = task.getScanLimit
@@ -95,23 +62,24 @@ object DynamoDBUtil {
 
       result.getItems.foreach { item =>
         schema.getColumns.foreach { column =>
-          val value = item.get(column.getName)
-          column.getType.getName match {
-            case "string" =>
-              pageBuilder.setString(column, Option(value) map { _.getS } getOrElse { "" })
-            case "long" =>
-              pageBuilder.setLong(column, Option(value) map { _.getN.toLong } getOrElse { 0L })
-            case "double" =>
-              pageBuilder.setDouble(column, Option(value) map { _.getN.toDouble } getOrElse { 0D })
-            case "boolean" =>
-              pageBuilder.setBoolean(column, Option(value) map { _.getBOOL == true } getOrElse { false })
+          val value = item.asScala.get(column.getName)
+          column.getType match {
+            case Types.STRING =>
+              convert(column, value, pageBuilder.setString)
+            case Types.LONG =>
+              convert(column, value, pageBuilder.setLong)
+            case Types.DOUBLE =>
+              convert(column, value, pageBuilder.setDouble)
+            case Types.BOOLEAN =>
+              convert(column, value, pageBuilder.setBoolean)
+            case Types.JSON =>
+              convert(column, value, pageBuilder.setJson)
             case _ => /* Do nothing */
           }
         }
         pageBuilder.addRecord()
         recordCount += 1
       }
-      println(s"$recordLimit $recordLimit $recordCount")
     } while(evaluateKey != null && (recordLimit == 0 || recordLimit > recordCount))
 
     pageBuilder.finish()
@@ -132,7 +100,8 @@ object DynamoDBUtil {
       filters.getFilters.map { filter =>
         val attributeValueList = collection.mutable.ArrayBuffer[AttributeValue]()
         attributeValueList += createAttributeValue(filter.getType, filter.getValue)
-        Option(filter.getValue2).map { value2 => attributeValueList += createAttributeValue(filter.getType, value2) }
+        Option(filter.getValue2).map { value2 =>
+          attributeValueList+= createAttributeValue(filter.getType, value2) }
 
         filterMap += filter.getName -> new Condition()
           .withComparisonOperator(filter.getCondition)
@@ -153,4 +122,27 @@ object DynamoDBUtil {
         new AttributeValue().withBOOL(v.toBoolean)
     }
   }
+
+  private def convert[A](column: Column,
+                   value: Option[AttributeValue],
+                   f: (Column, A) => Unit)(implicit f1: Option[AttributeValue] => A): Unit =
+    f(column, f1(value))
+
+  implicit private def StringConvert(value: Option[AttributeValue]): String =
+    value.map(_.getS).getOrElse("")
+
+  implicit private def LongConvert(value: Option[AttributeValue]): Long =
+    value.map(_.getN.toLong).getOrElse(0L)
+
+  implicit private def DoubleConvert(value: Option[AttributeValue]): Double =
+    value.map(_.getN.toDouble).getOrElse(0D)
+
+  implicit private def BooleanConvert(value: Option[AttributeValue]): Boolean =
+    value.exists(_.getS.toBoolean)
+
+  implicit private def JsonConvert(value: Option[AttributeValue]): Value = {
+    value.map { attr =>
+      AttributeValueHelper.decodeToValue(attr)
+    }.getOrElse(ValueFactory.newNil())
+  }
 }

data/src/main/scala/org/embulk/input/{DynamodbInputPlugin.scala → dynamodb/DynamodbInputPlugin.scala}

@@ -1,4 +1,4 @@
-package org.embulk.input
+package org.embulk.input.dynamodb
 
 import java.util.{List => JList}
 
@@ -21,15 +21,21 @@ class DynamodbInputPlugin extends InputPlugin {
     Exec.newConfigDiff()
   }
 
-  def cleanup(taskSource: TaskSource, schema: Schema, taskCount: Int, successCommitReports: JList[CommitReport]): Unit = {
-  }
-
-  def run(taskSource: TaskSource, schema: Schema, taskIndex: Int, output: PageOutput): CommitReport = {
+  def run(taskSource: TaskSource, schema: Schema, taskIndex: Int, output: PageOutput): TaskReport = {
     val task: PluginTask = taskSource.loadTask(classOf[PluginTask])
 
-    val client: AmazonDynamoDBClient = DynamoDBUtil.createClient(task)
-    DynamoDBUtil.scan(client, task, schema, output)
+    implicit val client: AmazonDynamoDBClient = DynamoDBUtil.createClient(task)
+    DynamoDBUtil.scan(task, schema, output)
+
+    Exec.newTaskReport()
+  }
+
+  def cleanup(taskSource: TaskSource, schema: Schema, taskCount: Int, successTaskReports: JList[TaskReport]): Unit = {
+    // TODO
+  }
 
-    Exec.newCommitReport()
+  def guess(config: ConfigSource): ConfigDiff = {
+    // TODO
+    null
   }
 }

data/src/main/scala/org/embulk/input/{Filter.scala → dynamodb/Filter.scala}

@@ -1,8 +1,8 @@
-package org.embulk.input
+package org.embulk.input.dynamodb
 
 import java.util.{List => JList}
 
-import com.fasterxml.jackson.annotation.{JsonValue, JsonCreator}
+import com.fasterxml.jackson.annotation.{JsonCreator, JsonValue}
 import com.google.common.base.Objects
 
 class Filter {

data/src/main/scala/org/embulk/input/{FilterConfig.scala → dynamodb/FilterConfig.scala}

@@ -1,4 +1,4 @@
-package org.embulk.input
+package org.embulk.input.dynamodb
 
 import com.fasterxml.jackson.annotation.JsonProperty
 import com.google.common.base.Objects

data/src/main/scala/org/embulk/input/{PluginTask.scala → dynamodb/PluginTask.scala}

@@ -1,10 +1,14 @@
-package org.embulk.input
+package org.embulk.input.dynamodb
 
 import com.google.common.base.Optional
-import org.embulk.config.{ConfigInject, ConfigDefault, Config, Task}
+import org.embulk.config.{Config, ConfigDefault, ConfigInject, Task}
 import org.embulk.spi.{BufferAllocator, SchemaConfig}
 
 trait PluginTask extends Task {
+  @Config("auth_method")
+  @ConfigDefault("null")
+  def getAuthMethod: Optional[String]
+
   @Config("access_key")
   @ConfigDefault("null")
   def getAccessKey: Optional[String]
@@ -13,6 +17,10 @@ trait PluginTask extends Task {
   @ConfigDefault("null")
   def getSecretKey: Optional[String]
 
+  @Config("profile_name")
+  @ConfigDefault("null")
+  def getProfileName: Optional[String]
+
   @Config("region")
   @ConfigDefault("ap-northeast-1")
   def getRegion: String

data/src/test/resources/json/test.json

@@ -0,0 +1,50 @@
+{
+  "_id": "56d8e1377a72374918f73bd2",
+  "index": 0,
+  "guid": "5309640c-499a-43f6-801d-3076c810892b",
+  "isActive": true,
+  "age": 37,
+  "name": "Battle Lancaster",
+  "email": "battlelancaster@zytrac.com",
+  "registered": "2014-07-16T04:40:58 -09:00",
+  "latitude": 45.574906,
+  "longitude": 36.596302,
+  "tags": [
+    "veniam",
+    "exercitation",
+    "velit",
+    "pariatur",
+    "sit",
+    "non",
+    "dolore"
+  ],
+  "friends": [
+    {
+      "id": 0,
+      "name": "Mejia Montgomery",
+      "tags": [
+        "duis",
+        "proident",
+        "et"
+      ]
+    },
+    {
+      "id": 1,
+      "name": "Carpenter Reed",
+      "tags": [
+        "labore",
+        "nisi",
+        "ipsum"
+      ]
+    },
+    {
+      "id": 2,
+      "name": "Gamble Watts",
+      "tags": [
+        "occaecat",
+        "voluptate",
+        "eu"
+      ]
+    }
+  ]
+}

data/src/test/resources/json/test.template

@@ -0,0 +1,27 @@
+{
+  _id: '{{objectId()}}',
+  index: '{{index()}}',
+  guid: '{{guid()}}',
+  isActive: '{{bool()}}',
+  age: '{{integer(20, 40)}}',
+  name: '{{firstName()}} {{surname()}}',
+  email: '{{email()}}',
+  registered: '{{date(new Date(2014, 0, 1), new Date(), "YYYY-MM-ddThh:mm:ss Z")}}',
+  latitude: '{{floating(-90.000001, 90)}}',
+  longitude: '{{floating(-180.000001, 180)}}',
+  tags: [
+    '{{repeat(7)}}',
+    '{{lorem(1, "words")}}'
+  ],
+  friends: [
+    '{{repeat(3)}}',
+    {
+      id: '{{index()}}',
+      name: '{{firstName()}} {{surname()}}',
+      tags: [
+        '{{repeat(3)}}',
+        '{{lorem(1, "words")}}'
+      ]
+    }
+  ]
+}

data/src/test/resources/yaml/authMethodBasic.yml

@@ -0,0 +1,20 @@
+in:
+  type: dynamodb
+  region: ENV_VAR
+  table: ENV_VAR
+  auth_method: basic
+  access_key: ENV_VAR
+  secret_key: ENV_VAR
+  columns:
+    - {name: pri-key,  type: string}
+    - {name: sort-key, type: long}
+    - {name: value, type: string}
+
+out:
+  type: file
+  path_prefix: result
+  file_ext: tsv
+  formatter:
+    type: csv
+    delimiter: "\t"
+    header_line: false

data/src/test/resources/yaml/authMethodBasic_Error.yml

@@ -0,0 +1,18 @@
+in:
+  type: dynamodb
+  region: ENV_VAR
+  table: ENV_VAR
+  auth_method: basic
+  columns:
+    - {name: pri-key,  type: string}
+    - {name: sort-key, type: long}
+    - {name: value, type: string}
+
+out:
+  type: file
+  path_prefix: result
+  file_ext: tsv
+  formatter:
+    type: csv
+    delimiter: "\t"
+    header_line: false

data/src/test/resources/yaml/authMethodEnv.yml

@@ -0,0 +1,18 @@
+in:
+  type: dynamodb
+  region: ENV_VAR
+  table: ENV_VAR
+  auth_method: env
+  columns:
+    - {name: pri-key,  type: string}
+    - {name: sort-key, type: long}
+    - {name: value, type: string}
+
+out:
+  type: file
+  path_prefix: result
+  file_ext: tsv
+  formatter:
+    type: csv
+    delimiter: "\t"
+    header_line: false

data/src/test/resources/yaml/authMethodProfile.yml

@@ -0,0 +1,19 @@
+in:
+  type: dynamodb
+  region: ENV_VAR
+  table: ENV_VAR
+  auth_method: profile
+  profile_name: ENV_VAR
+  columns:
+    - {name: pri-key,  type: string}
+    - {name: sort-key, type: long}
+    - {name: value, type: string}
+
+out:
+  type: file
+  path_prefix: result
+  file_ext: tsv
+  formatter:
+    type: csv
+    delimiter: "\t"
+    header_line: false

data/src/test/resources/yaml/notSetAuthMethod.yml

@@ -0,0 +1,19 @@
+in:
+  type: dynamodb
+  region: ENV_VAR
+  table: ENV_VAR
+  access_key: ENV_VAR
+  secret_key: ENV_VAR
+  columns:
+    - {name: pri-key,  type: string}
+    - {name: sort-key, type: long}
+    - {name: value, type: string}
+
+out:
+  type: file
+  path_prefix: result
+  file_ext: tsv
+  formatter:
+    type: csv
+    delimiter: "\t"
+    header_line: false

data/src/test/scala/org/embulk/input/dynamodb/AttributeValueHelperTest.scala

@@ -0,0 +1,192 @@
+package org.embulk.input.dynamodb
+
+
+import java.io.File
+import java.{util => JUtil}
+
+import com.amazonaws.services.dynamodbv2.model.AttributeValue
+import com.fasterxml.jackson.databind.ObjectMapper
+import org.embulk.input.dynamodb.AttributeValueHelper._
+import org.hamcrest.CoreMatchers._
+import org.junit.Assert._
+import org.junit.Test
+import org.msgpack.value.ValueFactory
+
+import scala.collection.JavaConverters._
+
+class AttributeValueHelperTest {
+  @Test
+  def decodeTest(): Unit = {
+    val stringValue = decodeToValue(new AttributeValue().withS("STR"))
+    assertEquals(stringValue.asStringValue.asString, "STR")
+
+    val intValue = decodeToValue(new AttributeValue().withN("123456789"))
+    assertEquals(intValue.asNumberValue().toInt, 123456789)
+
+    val doubleValue = decodeToValue(new AttributeValue().withN("-98765432.00000001"))
+    assertEquals(doubleValue.asNumberValue().toDouble, -98765432.00000001, 0.0)
+
+    val trueValue = decodeToValue(new AttributeValue().withBOOL(true))
+    assertEquals(trueValue.asBooleanValue().getBoolean, true)
+
+    val falseValue = decodeToValue(new AttributeValue().withBOOL(false))
+    assertEquals(falseValue.asBooleanValue().getBoolean, false)
+
+    val nilValue = decodeToValue(new AttributeValue().withNULL(true))
+    assertEquals(nilValue.isNilValue, true)
+  }
+
+
+  @Test
+  def listDecodeTest(): Unit = {
+    val stringListValue = decodeToValue(new AttributeValue().withL(
+      new AttributeValue().withS("ValueA"),
+      new AttributeValue().withS("ValueB"),
+      new AttributeValue().withS("ValueC")))
+
+    assertTrue(stringListValue.isArrayValue)
+    assertEquals(stringListValue.asArrayValue().size(), 3)
+
+    assertTrue(stringListValue.asArrayValue().get(0).isStringValue)
+    assertEquals(stringListValue.asArrayValue().get(0).asStringValue().asString(), "ValueA")
+    assertEquals(stringListValue.asArrayValue().get(1).asStringValue().asString(), "ValueB")
+    assertEquals(stringListValue.asArrayValue().get(2).asStringValue().asString(), "ValueC")
+
+
+    val numberListValue = decodeToValue(new AttributeValue().withL(
+      new AttributeValue().withN("123"),
+      new AttributeValue().withN("-456"),
+      new AttributeValue().withN("0.0000045679"),
+      new AttributeValue().withN("-1234567890.123")))
+
+    assertTrue(numberListValue.isArrayValue)
+    assertEquals(numberListValue.asArrayValue().size(), 4)
+
+    assertTrue(numberListValue.asArrayValue().get(0).isIntegerValue)
+    assertEquals(numberListValue.asArrayValue().get(0).asNumberValue().toInt, 123)
+    assertEquals(numberListValue.asArrayValue().get(1).asNumberValue().toInt, -456)
+
+    assertTrue(numberListValue.asArrayValue().get(2).isFloatValue)
+    assertEquals(numberListValue.asArrayValue().get(2).asNumberValue().toDouble, 0.0000045679, 0.0)
+    assertEquals(numberListValue.asArrayValue().get(3).asNumberValue().toDouble, -1234567890.123, 0.0)
+
+
+    val stringSetValue = decodeToValue(new AttributeValue().withSS(
+      new JUtil.HashSet[String]() {
+        add("ValueA")
+        add("ValueB")
+        add("ValueC")
+      }))
+
+    assertTrue(stringSetValue.isArrayValue)
+    assertEquals(stringSetValue.asArrayValue().size(), 3)
+
+    assertThat(List("ValueA", "ValueB", "ValueC").asJava,
+      hasItems(
+        equalTo(stringSetValue.asArrayValue().get(0).asStringValue().asString),
+        equalTo(stringSetValue.asArrayValue().get(1).asStringValue().asString),
+        equalTo(stringSetValue.asArrayValue().get(2).asStringValue().asString)))
+
+
+    val numberSetValue = decodeToValue(new AttributeValue().withNS(
+      new JUtil.HashSet[String]() {
+        add("123")
+        add("-456")
+        add("0.0000045679")
+        add("-1234567890.123")
+      }))
+
+    assertTrue(numberSetValue.isArrayValue)
+    assertEquals(numberSetValue.asArrayValue().size(), 4)
+  }
+
+
+  @Test
+  def mapDecodeTest(): Unit = {
+    val stringMap = decodeToValue(new AttributeValue().withM(
+      new JUtil.HashMap[String, AttributeValue]() {
+        put("KeyA", new AttributeValue().withS("ValueA"))
+        put("KeyB", new AttributeValue().withS("ValueB"))
+        put("KeyC", new AttributeValue().withS("ValueC"))
+      }))
+
+    assertTrue(stringMap.isMapValue)
+    assertEquals(stringMap.asMapValue().size(), 3)
+    assertEquals(stringMap.asMapValue().map().get(ValueFactory.newString("KeyA")).asStringValue().asString(), "ValueA")
+    assertEquals(stringMap.asMapValue().map().get(ValueFactory.newString("KeyB")).asStringValue().asString(), "ValueB")
+    assertEquals(stringMap.asMapValue().map().get(ValueFactory.newString("KeyC")).asStringValue().asString(), "ValueC")
+
+
+    val numberMap = decodeToValue(new AttributeValue().withM(
+      new JUtil.HashMap[String, AttributeValue]() {
+        put("KeyA", new AttributeValue().withN("123"))
+        put("KeyB", new AttributeValue().withN("-456"))
+        put("KeyC", new AttributeValue().withN("0.0000045679"))
+        put("KeyD", new AttributeValue().withN("-1234567890.123"))
+      }))
+
+    assertTrue(numberMap.isMapValue)
+    assertEquals(numberMap.asMapValue().size(), 4)
+
+    assertTrue(numberMap.asMapValue().map().get(ValueFactory.newString("KeyA")).isIntegerValue)
+    assertEquals(numberMap.asMapValue().map().get(ValueFactory.newString("KeyA")).asNumberValue().toInt, 123)
+    assertEquals(numberMap.asMapValue().map().get(ValueFactory.newString("KeyB")).asNumberValue().toInt, -456)
+
+    assertTrue(numberMap.asMapValue().map().get(ValueFactory.newString("KeyC")).isFloatValue)
+    assertEquals(numberMap.asMapValue().map().get(ValueFactory.newString("KeyC")).asFloatValue().toDouble, 0.0000045679, 0.0)
+    assertEquals(numberMap.asMapValue().map().get(ValueFactory.newString("KeyD")).asFloatValue().toDouble, -1234567890.123, 0.0)
+  }
+
+  def attr[A](value: A)(implicit f: A=> AttributeValue): AttributeValue = f(value)
+  implicit def StringAttributeValue(value: String): AttributeValue   = new AttributeValue().withS(value)
+  implicit def IntegerAttributeValue(value: Int): AttributeValue     = new AttributeValue().withN(value.toString)
+  implicit def LongAttributeValue(value: Long): AttributeValue       = new AttributeValue().withN(value.toString)
+  implicit def FloatAttributeValue(value: Float): AttributeValue       = new AttributeValue().withN(value.toString)
+  implicit def DoubleAttributeValue(value: Double): AttributeValue       = new AttributeValue().withN(value.toString)
+  implicit def BooleanAttributeValue(value: Boolean): AttributeValue = new AttributeValue().withBOOL(value)
+  implicit def MapAttributeValue(value: Map[String, AttributeValue]): AttributeValue
+    = new AttributeValue().withM(value.asJava)
+  implicit def ListAttributeValue(value: List[AttributeValue]): AttributeValue
+    = new AttributeValue().withL(value.asJava)
+
+  @Test
+  def nestedDecodeTest(): Unit = {
+    // TODO: Json -> AttributeValue...
+    val testData = decodeToValue(attr(Map(
+      "_id"        -> attr("56d8e1377a72374918f73bd2"),
+      "index"      -> attr(0),
+      "guid"       -> attr("5309640c-499a-43f6-801d-3076c810892b"),
+      "isActive"   -> attr(true),
+      "age"        -> attr(37),
+      "name"       -> attr("Battle Lancaster"),
+      "email"      -> attr("battlelancaster@zytrac.com"),
+      "registered" -> attr("2014-07-16T04:40:58 -09:00"),
+      "latitude"   -> attr(45.574906),
+      "longitude"  -> attr(36.596302),
+      "tags"       -> attr(List(
+        attr("veniam"),
+        attr("exercitation"),
+        attr("velit"),
+        attr("pariatur"),
+        attr("sit"),
+        attr("non"),
+        attr("dolore"))),
+      "friends" -> attr(List(
+        attr(Map("id" -> attr(0), "name" -> attr("Mejia Montgomery"),
+          "tags" -> attr(List(attr("duis"), attr("proident"), attr("et"))))),
+        attr(Map("id" -> attr(1), "name" -> attr("Carpenter Reed"),
+          "tags" -> attr(List(attr("labore"), attr("nisi"), attr("ipsum"))))),
+        attr(Map("id" -> attr(2), "name" -> attr("Gamble Watts"),
+          "tags" -> attr(List(attr("occaecat"), attr("voluptate"), attr("eu")))))
+      ))
+      )
+    ))
+
+    val testA = new ObjectMapper().readValue(
+      testData.toJson, classOf[JUtil.Map[String, Any]])
+    val testB = new ObjectMapper().readValue(
+      new File("src/test/resources/json/test.json"), classOf[JUtil.Map[String, Any]])
+
+    assertThat(testA, is(testB))
+  }
+}