embulk-input-dynamodb 0.2.0 → 0.3.0

data/src/main/scala/org/embulk/input/dynamodb/operation/DynamodbOperationProxy.scala

@@ -0,0 +1,59 @@
+package org.embulk.input.dynamodb.operation
+
+import java.util.Optional
+
+import com.amazonaws.services.dynamodbv2.model.AttributeValue
+import com.amazonaws.services.dynamodbv2.AmazonDynamoDB
+import org.embulk.config.{
+  Config,
+  ConfigDefault,
+  ConfigException,
+  Task => EmbulkTask
+}
+
+object DynamodbOperationProxy {
+
+  trait Task extends EmbulkTask {
+
+    @Config("scan")
+    @ConfigDefault("null")
+    def getScan: Optional[DynamodbScanOperation.Task]
+
+    @Config("query")
+    @ConfigDefault("null")
+    def getQuery: Optional[DynamodbQueryOperation.Task]
+
+    @Config("table")
+    def getTable: String
+  }
+
+  def apply(task: Task): DynamodbOperationProxy = {
+    if (task.getScan.isPresent && task.getQuery.isPresent)
+      throw new ConfigException("You can use either \"scan\" or \"query\".")
+    if (!task.getScan.isPresent && !task.getQuery.isPresent)
+      throw new ConfigException("You must set either \"scan\" or \"query\".")
+    task.getScan.ifPresent(_.setTableName(task.getTable))
+    task.getQuery.ifPresent(_.setTableName(task.getTable))
+    new DynamodbOperationProxy(task)
+  }
+}
+
+case class DynamodbOperationProxy(task: DynamodbOperationProxy.Task)
+    extends EmbulkDynamodbOperation {
+
+  private def getOperation: EmbulkDynamodbOperation = {
+    task.getScan.ifPresent(t => return DynamodbScanOperation(t))
+    task.getQuery.ifPresent(t => return DynamodbQueryOperation(t))
+    throw new IllegalStateException()
+  }
+
+  private val operation: EmbulkDynamodbOperation = getOperation
+
+  override def getEmbulkTaskCount: Int = operation.getEmbulkTaskCount
+
+  override def run(
+      dynamodb: AmazonDynamoDB,
+      embulkTaskIndex: Int,
+      f: Seq[Map[String, AttributeValue]] => Unit
+  ): Unit = operation.run(dynamodb, embulkTaskIndex, f)
+}

data/src/main/scala/org/embulk/input/dynamodb/operation/DynamodbQueryOperation.scala

@@ -0,0 +1,72 @@
+package org.embulk.input.dynamodb.operation
+
+import com.amazonaws.services.dynamodbv2.model.{AttributeValue, QueryRequest}
+import com.amazonaws.services.dynamodbv2.AmazonDynamoDB
+import org.embulk.config.{Config, ConfigDefault}
+import org.embulk.input.dynamodb.logger
+
+import scala.jdk.CollectionConverters._
+import scala.util.chaining._
+
+object DynamodbQueryOperation {
+
+  trait Task extends AbstractDynamodbOperation.Task {
+
+    // ref. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.KeyConditionExpressions
+    @Config("key_condition_expression")
+    def getKeyConditionExpression: String
+
+    // TODO: Is it needed in the embulk context?
+    // ref. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.KeyConditionExpressions
+    @Config("scan_index_forward")
+    @ConfigDefault("true")
+    def getScanIndexForward: Boolean
+
+  }
+}
+
+case class DynamodbQueryOperation(task: DynamodbQueryOperation.Task)
+    extends AbstractDynamodbOperation(task) {
+
+  private def newRequest(
+      lastEvaluatedKey: Option[Map[String, AttributeValue]]
+  ): QueryRequest = {
+    new QueryRequest()
+      .tap(configureRequest(_, lastEvaluatedKey))
+      .tap(r => r.setKeyConditionExpression(task.getKeyConditionExpression))
+      .tap(r => r.setScanIndexForward(task.getScanIndexForward))
+  }
+
+  private def runInternal(
+      dynamodb: AmazonDynamoDB,
+      f: Seq[Map[String, AttributeValue]] => Unit,
+      lastEvaluatedKey: Option[Map[String, AttributeValue]] = None,
+      loadedRecords: Long = 0
+  ): Unit = {
+    val loadableRecords: Option[Long] = calculateLoadableRecords(loadedRecords)
+
+    val result = dynamodb.query(newRequest(lastEvaluatedKey).tap { req =>
+      logger.info(s"Call DynamodbQueryRequest: ${req.toString}")
+    })
+    loadableRecords match {
+      case Some(v) if (result.getCount > v) =>
+        f(result.getItems.asScala.take(v.toInt).map(_.asScala.toMap).toSeq)
+      case None =>
+        f(result.getItems.asScala.map(_.asScala.toMap).toSeq)
+        Option(result.getLastEvaluatedKey).foreach { lastEvaluatedKey =>
+          runInternal(
+            dynamodb,
+            f,
+            lastEvaluatedKey = Option(lastEvaluatedKey.asScala.toMap),
+            loadedRecords = loadedRecords + result.getCount
+          )
+        }
+    }
+  }
+
+  override def run(
+      dynamodb: AmazonDynamoDB,
+      embulkTaskIndex: Int,
+      f: Seq[Map[String, AttributeValue]] => Unit
+  ): Unit = runInternal(dynamodb, f)
+}

data/src/main/scala/org/embulk/input/dynamodb/operation/DynamodbScanOperation.scala

@@ -0,0 +1,93 @@
+package org.embulk.input.dynamodb.operation
+
+import java.util.Optional
+
+import com.amazonaws.services.dynamodbv2.model.{AttributeValue, ScanRequest}
+import com.amazonaws.services.dynamodbv2.AmazonDynamoDB
+import org.embulk.config.{Config, ConfigDefault, ConfigException}
+import org.embulk.input.dynamodb.logger
+
+import scala.jdk.CollectionConverters._
+import scala.util.chaining._
+
+object DynamodbScanOperation {
+
+  trait Task extends AbstractDynamodbOperation.Task {
+
+    // ref. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan
+    @Config("segment")
+    @ConfigDefault("null")
+    def getSegment: Optional[Int]
+
+    // ref. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan
+    @Config("total_segment")
+    @ConfigDefault("null")
+    def getTotalSegment: Optional[Int]
+
+  }
+}
+
+case class DynamodbScanOperation(task: DynamodbScanOperation.Task)
+    extends AbstractDynamodbOperation(task) {
+
+  override def getEmbulkTaskCount: Int = {
+    if (task.getTotalSegment.isPresent && task.getSegment.isPresent) 1
+    else if (task.getTotalSegment.isPresent && !task.getSegment.isPresent)
+      task.getTotalSegment.get()
+    else if (!task.getTotalSegment.isPresent && !task.getSegment.isPresent) 1
+    else // if (!task.getTotalSegment.isPresent && task.getSegment.isPresent)
+      throw new ConfigException(
+        "\"segment\" option must be set with \"total_segment\" option."
+      )
+  }
+
+  private def newRequest(
+      embulkTaskIndex: Int,
+      lastEvaluatedKey: Option[Map[String, AttributeValue]]
+  ): ScanRequest = {
+    new ScanRequest()
+      .tap(configureRequest(_, lastEvaluatedKey))
+      .tap { r =>
+        task.getTotalSegment.ifPresent { totalSegment =>
+          r.setTotalSegments(totalSegment)
+          r.setSegment(task.getSegment.orElse(embulkTaskIndex))
+        }
+      }
+  }
+
+  private def runInternal(
+      dynamodb: AmazonDynamoDB,
+      embulkTaskIndex: Int,
+      f: Seq[Map[String, AttributeValue]] => Unit,
+      lastEvaluatedKey: Option[Map[String, AttributeValue]] = None,
+      loadedRecords: Long = 0
+  ): Unit = {
+    val loadableRecords: Option[Long] = calculateLoadableRecords(loadedRecords)
+
+    val result =
+      dynamodb.scan(newRequest(embulkTaskIndex, lastEvaluatedKey).tap { req =>
+        logger.info(s"Call DynamodbQueryRequest: ${req.toString}")
+      })
+    loadableRecords match {
+      case Some(v) if (result.getCount > v) =>
+        f(result.getItems.asScala.take(v.toInt).map(_.asScala.toMap).toSeq)
+      case None =>
+        f(result.getItems.asScala.map(_.asScala.toMap).toSeq)
+        Option(result.getLastEvaluatedKey).foreach { lastEvaluatedKey =>
+          runInternal(
+            dynamodb,
+            embulkTaskIndex,
+            f,
+            lastEvaluatedKey = Option(lastEvaluatedKey.asScala.toMap),
+            loadedRecords = loadedRecords + result.getCount
+          )
+        }
+    }
+  }
+
+  override def run(
+      dynamodb: AmazonDynamoDB,
+      embulkTaskIndex: Int,
+      f: Seq[Map[String, AttributeValue]] => Unit
+  ): Unit = runInternal(dynamodb, embulkTaskIndex, f)
+}

data/src/main/scala/org/embulk/input/dynamodb/operation/EmbulkDynamodbOperation.scala

@@ -0,0 +1,15 @@
+package org.embulk.input.dynamodb.operation
+
+import com.amazonaws.services.dynamodbv2.AmazonDynamoDB
+import com.amazonaws.services.dynamodbv2.model.AttributeValue
+
+trait EmbulkDynamodbOperation {
+
+  def getEmbulkTaskCount: Int = 1
+
+  def run(
+      dynamodb: AmazonDynamoDB,
+      embulkTaskIndex: Int,
+      f: Seq[Map[String, AttributeValue]] => Unit
+  ): Unit
+}

data/src/main/scala/org/embulk/input/dynamodb/package.scala

@@ -1,14 +1,9 @@
 package org.embulk.input
 
-import com.google.common.base.Optional
-import org.embulk.config.ConfigException
+import org.slf4j.{Logger, LoggerFactory}
 
 package object dynamodb {
-  def require[A](value: Optional[A], message: String): A = {
-    if (value.isPresent) {
-      value.get()
-    } else {
-      throw new ConfigException("Required option is not set: " + message)
-    }
-  }
+
+  val logger: Logger = LoggerFactory.getLogger(classOf[DynamodbInputPlugin])
+
 }

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

@@ -1,20 +1,21 @@
 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.embulk.input.dynamodb.deprecated.AttributeValueHelper._
 import org.hamcrest.CoreMatchers._
+import org.hamcrest.MatcherAssert.assertThat
 import org.junit.Assert._
 import org.junit.Test
 import org.msgpack.value.ValueFactory
 
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters._
 
 class AttributeValueHelperTest {
+
   @Test
   def decodeTest(): Unit = {
     val stringValue = decodeToValue(new AttributeValue().withS("STR"))
@@ -23,7 +24,9 @@ class AttributeValueHelperTest {
     val intValue = decodeToValue(new AttributeValue().withN("123456789"))
     assertEquals(intValue.asNumberValue().toInt, 123456789)
 
-    val doubleValue = decodeToValue(new AttributeValue().withN("-98765432.00000001"))
+    val doubleValue = decodeToValue(
+      new AttributeValue().withN("-98765432.00000001")
+    )
     assertEquals(doubleValue.asNumberValue().toDouble, -98765432.00000001, 0.0)
 
     val trueValue = decodeToValue(new AttributeValue().withBOOL(true))
@@ -36,162 +39,303 @@ class AttributeValueHelperTest {
     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")))
+    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")))
+    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)
+    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]() {
+    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,
+    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)))
-
+        equalTo(stringSetValue.asArrayValue().get(2).asStringValue().asString)
+      )
+    )
 
-    val numberSetValue = decodeToValue(new AttributeValue().withNS(
-      new JUtil.HashSet[String]() {
+    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]() {
+    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]() {
+    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)
+    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)
+  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 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 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]])
+      new File("src/test/resources/json/test.json"),
+      classOf[JUtil.Map[String, Any]]
+    )
 
     assertThat(testA, is(testB))
   }