From f55212361d6126a05075a1f00f3915484b4f334e Mon Sep 17 00:00:00 2001
From: Marvin Bertin <marvin.bertin@gmail.com>
Date: Tue, 10 Oct 2017 17:05:32 -0700
Subject: add json format tests for Slot and Eligibility arms

---
 .../parsers/PaginationParserSuite.scala            | 68 +++++++++--------
 .../parsers/SearchFilterParserSuite.scala          | 89 +++++++++++++---------
 .../pdsuicommon/parsers/SortingParserSuite.scala   | 37 +++++----
 .../xyz/driver/pdsuicommon/parsers/TestUtils.scala |  7 +-
 .../driver/pdsuicommon/utils/StringOpsSuite.scala  |  2 +-
 .../formats/json/sprayformats/ArmFormatSuite.scala |  9 ++-
 .../json/sprayformats/DocumentFormatSuite.scala    | 10 +--
 .../sprayformats/DocumentHistoryFormatSuite.scala  |  3 +-
 .../sprayformats/DocumentIssueFormatSuite.scala    |  3 +-
 .../sprayformats/EligibilityArmFormatSuite.scala   | 36 +++++++++
 .../sprayformats/ExtractedDataFormatSuite.scala    | 19 ++---
 .../json/sprayformats/HypothesisFormatSuite.scala  |  3 +-
 .../sprayformats/InterventionFormatSuite.scala     |  2 +-
 .../sprayformats/MedicalRecordFormatSuite.scala    | 17 +++--
 .../MedicalRecordHistoryFormatSuite.scala          |  3 +-
 .../MedicalRecordIssueFormatSuite.scala            |  4 +-
 .../sprayformats/PatientCriterionFormatSuite.scala |  9 ++-
 .../PatientEligibleTrialFormatSuite.scala          |  8 +-
 .../json/sprayformats/PatientFormatSuite.scala     |  2 +-
 .../PatientHypothesisFormatSuite.scala             |  6 +-
 .../sprayformats/PatientIssueFormatSuite.scala     |  9 ++-
 .../sprayformats/PatientLabelFormatSuite.scala     | 10 +--
 .../json/sprayformats/SlotArmFormatSuite.scala     | 36 +++++++++
 .../json/sprayformats/TrialFormatSuite.scala       |  6 +-
 .../sprayformats/TrialHistoryFormatSuite.scala     |  3 +-
 .../json/sprayformats/TrialIssueFormatSuite.scala  |  8 +-
 26 files changed, 259 insertions(+), 150 deletions(-)
 create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/EligibilityArmFormatSuite.scala
 create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/SlotArmFormatSuite.scala

(limited to 'src/test')

diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala
index 48fc99b..609c8c8 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala
@@ -11,36 +11,40 @@ class PaginationParserSuite extends FreeSpecLike with MustMatchers {
   "parse" - {
     "pageSize" - {
       "should parse positive value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "10",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "10",
+            "pageNumber" -> "1"
+          ))
         pagination must success
         pagination.get.pageSize mustBe 10
       }
 
       "should return a default value if there is no one" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageNumber" -> "1"
+          ))
         pagination must success
         pagination.get.pageSize mustBe 100
       }
 
       "should return a error for zero value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "0",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "0",
+            "pageNumber" -> "1"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageSize")
       }
 
       "should return a error for negative value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "-10",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "-10",
+            "pageNumber" -> "1"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageSize")
       }
@@ -48,36 +52,40 @@ class PaginationParserSuite extends FreeSpecLike with MustMatchers {
 
     "pageNumber" - {
       "should parse positive value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "1",
+            "pageNumber" -> "1"
+          ))
         pagination must success
         pagination.get.pageSize mustBe 1
       }
 
       "should return a default value if there is no one" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize" -> "1"
+          ))
         pagination must success
         pagination.get.pageNumber mustBe 1
       }
 
       "should return a error for zero value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1",
-          "pageNumber" -> "0"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "1",
+            "pageNumber" -> "0"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageNumber")
       }
 
       "should return a error for negative value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1",
-          "pageNumber" -> "-1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "1",
+            "pageNumber" -> "-1"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageNumber")
       }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
index 5deaecb..02243aa 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
@@ -30,16 +30,20 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
     "should convert column names to snake case" in {
       import SearchFilterBinaryOperation._
 
-      val filter = SearchFilterParser.parse(Seq(
-        "filters" -> "status IN Summarized,ReviewCriteria,Flagged,Done",
-        "filters" -> "previousStatus NOTEQ New",
-        "filters" -> "previousStatus NOTEQ ReviewSummary"
-      ))
-
-      assert(filter === Success(SearchFilterExpr.Intersection(List(
-        SearchFilterExpr.Atom.NAry(Dimension(None, "status"), In, Seq("Summarized", "ReviewCriteria", "Flagged", "Done")),
-        SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "New"),
-        SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "ReviewSummary")))))
+      val filter = SearchFilterParser.parse(
+        Seq(
+          "filters" -> "status IN Summarized,ReviewCriteria,Flagged,Done",
+          "filters" -> "previousStatus NOTEQ New",
+          "filters" -> "previousStatus NOTEQ ReviewSummary"
+        ))
+
+      assert(
+        filter === Success(SearchFilterExpr.Intersection(List(
+          SearchFilterExpr.Atom
+            .NAry(Dimension(None, "status"), In, Seq("Summarized", "ReviewCriteria", "Flagged", "Done")),
+          SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "New"),
+          SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "ReviewSummary")
+        ))))
     }
     "dimensions" - {
       "with table name" in check {
@@ -50,11 +54,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
         Prop.forAllNoShrink(dimensionGen) {
           case (left, right) =>
             val raw = s"$left.$right"
-            val l = toSnakeCase(left)
-            val r = toSnakeCase(right)
-              SearchFilterParser.dimensionParser.parse(raw) match {
+            val l   = toSnakeCase(left)
+            val r   = toSnakeCase(right)
+            SearchFilterParser.dimensionParser.parse(raw) match {
               case Parsed.Success(Dimension(Some(`l`), `r`), _) => true
-              case _ => false
+              case _                                            => false
             }
         }
       }
@@ -63,7 +67,7 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
           val databaseS = Utils.toSnakeCase(s)
           SearchFilterParser.dimensionParser.parse(s) match {
             case Parsed.Success(Dimension(None, `databaseS`), _) => true
-            case _ => false
+            case _                                               => false
           }
         }
       }
@@ -81,10 +85,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
             )
 
             Prop.forAllNoShrink(testQueryGen) { query =>
-              SearchFilterParser.parse(Seq("filters" -> query))
+              SearchFilterParser
+                .parse(Seq("filters" -> query))
                 .map {
                   case SearchFilterExpr.Atom.Binary(_, Eq | NotEq | Like, _) => true
-                  case x => throw new UnexpectedSearchFilterExprException(x)
+                  case x                                                     => throw new UnexpectedSearchFilterExprException(x)
                 }
                 .successProp
             }
@@ -96,7 +101,9 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
             val testQueryGen = queryGen(
               dimensionGen = Gen.identifier,
               opGen = numericBinaryOpsGen,
-              valueGen = nonEmptyString.filter { s => !s.matches("^\\d+$") }
+              valueGen = nonEmptyString.filter { s =>
+                !s.matches("^\\d+$")
+              }
             )
 
             Prop.forAllNoShrink(testQueryGen) { query =>
@@ -121,10 +128,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
             )
 
             Prop.forAllNoShrink(testQueryGen) { query =>
-              SearchFilterParser.parse(Seq("filters" -> query))
+              SearchFilterParser
+                .parse(Seq("filters" -> query))
                 .map {
                   case _: SearchFilterExpr.Atom.Binary => true
-                  case x => throw new UnexpectedSearchFilterExprException(x)
+                  case x                               => throw new UnexpectedSearchFilterExprException(x)
                 }
                 .successProp
             }
@@ -140,7 +148,8 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
               case Success(_) => ()
               case Failure(t) => t.printStackTrace()
             }
-            assert(filter === Success(SearchFilterExpr.Atom.NAry(Dimension(None, "id"), In, Seq(Long.box(1), Long.box(5)))))
+            assert(
+              filter === Success(SearchFilterExpr.Atom.NAry(Dimension(None, "id"), In, Seq(Long.box(1), Long.box(5)))))
           }
         }
 
@@ -152,10 +161,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
           )
 
           Prop.forAllNoShrink(testQueryGen) { query =>
-            SearchFilterParser.parse(Seq("filters" -> query))
+            SearchFilterParser
+              .parse(Seq("filters" -> query))
               .map {
                 case SearchFilterExpr.Atom.NAry(_, SearchFilterNAryOperation.In, _) => true
-                case x => throw new UnexpectedSearchFilterExprException(x)
+                case x                                                              => throw new UnexpectedSearchFilterExprException(x)
               }
               .successProp
           }
@@ -189,16 +199,19 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
     }
   }
 
-  private val CommonBinaryOps = Seq("eq", "noteq", "like")
+  private val CommonBinaryOps  = Seq("eq", "noteq", "like")
   private val NumericBinaryOps = Seq("gt", "gteq", "lt", "lteq")
 
-  private val allBinaryOpsGen: Gen[String] = Gen.oneOf(CommonBinaryOps ++ NumericBinaryOps).flatMap(randomCapitalization)
-  private val commonBinaryOpsGen: Gen[String] = Gen.oneOf(CommonBinaryOps).flatMap(randomCapitalization)
+  private val allBinaryOpsGen: Gen[String] =
+    Gen.oneOf(CommonBinaryOps ++ NumericBinaryOps).flatMap(randomCapitalization)
+  private val commonBinaryOpsGen: Gen[String]  = Gen.oneOf(CommonBinaryOps).flatMap(randomCapitalization)
   private val numericBinaryOpsGen: Gen[String] = Gen.oneOf(NumericBinaryOps).flatMap(randomCapitalization)
 
   private val inValueCharsGen: Gen[Char] = arbitrary[Char].filter(_ != ',')
 
-  private val nonEmptyString = arbitrary[String].filter { s => !s.safeTrim.isEmpty }
+  private val nonEmptyString = arbitrary[String].filter { s =>
+    !s.safeTrim.isEmpty
+  }
 
   private val numericBinaryAtomValuesGen: Gen[String] = arbitrary[Long].map(_.toString)
   private val inValueGen: Gen[String] = {
@@ -208,18 +221,22 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
     Gen.containerOfN[Seq, String](size, inValueGen).map(_.mkString(","))
   }
 
-  private def queryGen(dimensionGen: Gen[String], opGen: Gen[String], valueGen: Gen[String]): Gen[String] = for {
-    dimension <- dimensionGen
-    op <- opGen
-    value <- valueGen
-  } yield s"$dimension $op $value"
+  private def queryGen(dimensionGen: Gen[String], opGen: Gen[String], valueGen: Gen[String]): Gen[String] =
+    for {
+      dimension <- dimensionGen
+      op        <- opGen
+      value     <- valueGen
+    } yield s"$dimension $op $value"
 
   private def randomCapitalization(input: String): Gen[String] = {
     Gen.containerOfN[Seq, Boolean](input.length, arbitrary[Boolean]).map { capitalize =>
-      input.view.zip(capitalize).map {
-        case (currChar, true) => currChar.toUpper
-        case (currChar, false) => currChar
-      }.mkString
+      input.view
+        .zip(capitalize)
+        .map {
+          case (currChar, true)  => currChar.toUpper
+          case (currChar, false) => currChar
+        }
+        .mkString
     }
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
index e46015c..f34f8e1 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
@@ -12,7 +12,7 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
     "single dimension" - commonTests(singleSortingQueryGen)
     "multiple dimensions in one query" - commonTests(multipleSortingQueryGen)
     "multiple queries" in {
-      val r = SortingParser.parse(Set("foo", "bar"), Seq("sort" -> "foo", "sort" ->"bar"))
+      val r = SortingParser.parse(Set("foo", "bar"), Seq("sort" -> "foo", "sort" -> "bar"))
       r must failWith[ParseQueryArgException]
     }
   }
@@ -21,7 +21,7 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
     "valid" in check {
       val inputGen: Gen[(Set[String], String)] = for {
         validDimensions <- dimensionsGen
-        sorting <- queryGen(validDimensions)
+        sorting         <- queryGen(validDimensions)
       } yield (validDimensions, sorting)
 
       Prop.forAllNoShrink(inputGen) {
@@ -33,7 +33,9 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
     "invalid" in check {
       val inputGen: Gen[(Set[String], String)] = for {
         validDimensions <- dimensionsGen
-        invalidDimensions <- dimensionsGen.filter { xs => xs.intersect(validDimensions).isEmpty }
+        invalidDimensions <- dimensionsGen.filter { xs =>
+                              xs.intersect(validDimensions).isEmpty
+                            }
         sorting <- queryGen(invalidDimensions)
       } yield (validDimensions, sorting)
 
@@ -46,12 +48,12 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
 
   private val dimensionsGen: Gen[Set[String]] = for {
     unPrefixedSize <- Gen.choose(0, 3)
-    prefixedSize <- Gen.choose(0, 3)
+    prefixedSize   <- Gen.choose(0, 3)
     if (unPrefixedSize + prefixedSize) > 0
 
     unPrefixedDimensions <- Gen.containerOfN[Set, String](unPrefixedSize, Gen.identifier)
 
-    prefixes <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
+    prefixes   <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
     dimensions <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
   } yield {
     val prefixedDimensions = prefixes.zip(dimensions).map {
@@ -62,30 +64,33 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
 
   private def multipleSortingQueryGen(validDimensions: Set[String]): Gen[String] = {
     val validDimensionsSeq = validDimensions.toSeq
-    val indexGen = Gen.oneOf(validDimensionsSeq.indices)
+    val indexGen           = Gen.oneOf(validDimensionsSeq.indices)
     val multipleDimensionsGen = Gen.nonEmptyContainerOf[Set, Int](indexGen).filter(_.size >= 2).map { indices =>
       indices.map(validDimensionsSeq.apply)
     }
 
     for {
-      dimensions <- multipleDimensionsGen
+      dimensions  <- multipleDimensionsGen
       isAscending <- Gen.containerOfN[Seq, Boolean](dimensions.size, arbitrary[Boolean])
     } yield {
-      isAscending.zip(dimensions)
+      isAscending
+        .zip(dimensions)
         .map {
-          case (true, dimension) => dimension
+          case (true, dimension)  => dimension
           case (false, dimension) => "-" + dimension
         }
         .mkString(",")
     }
   }
 
-  private def singleSortingQueryGen(validDimensions: Set[String]): Gen[String] = for {
-    isAscending <- arbitrary[Boolean]
-    dimensions <- Gen.oneOf(validDimensions.toSeq)
-  } yield isAscending match {
-    case true => dimensions
-    case false => "-" + dimensions
-  }
+  private def singleSortingQueryGen(validDimensions: Set[String]): Gen[String] =
+    for {
+      isAscending <- arbitrary[Boolean]
+      dimensions  <- Gen.oneOf(validDimensions.toSeq)
+    } yield
+      isAscending match {
+        case true  => dimensions
+        case false => "-" + dimensions
+      }
 
 }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
index 4892b95..09b60ed 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
@@ -22,8 +22,9 @@ object TestUtils {
         left.isFailure && left.failed.get.getClass == ct.runtimeClass,
         left match {
           case Success(x) => s"$left did not fail"
-          case Failure(e) => s"$left did fail with ${Utils.getClassSimpleName(e.getClass)}, " +
-            s"not ${Utils.getClassSimpleName(ct.runtimeClass)}"
+          case Failure(e) =>
+            s"$left did fail with ${Utils.getClassSimpleName(e.getClass)}, " +
+              s"not ${Utils.getClassSimpleName(ct.runtimeClass)}"
         },
         left match {
           case Success(_) => s"$left failed with ${Utils.getClassSimpleName(ct.runtimeClass)}"
@@ -33,7 +34,7 @@ object TestUtils {
     }
   }
 
-  def failWith[ThrowableT <:Throwable](implicit ct: ClassTag[ThrowableT]) = new FailWith[ThrowableT]
+  def failWith[ThrowableT <: Throwable](implicit ct: ClassTag[ThrowableT]) = new FailWith[ThrowableT]
 
   final implicit class TryPropOps(val self: Try[Any]) extends AnyVal {
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala
index 9bd4382..bd0bd2b 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala
@@ -30,4 +30,4 @@ class StringOpsSuite extends FreeSpecLike {
       assert("foo".safeTrim == "foo")
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatSuite.scala
index e7d37a0..35b0fad 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatSuite.scala
@@ -17,19 +17,20 @@ class ArmFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = armFormat.write(arm)
 
-    writtenJson should be("""{"id":10,"trialId":"NCT000001","name":"arm name","originalName":"orig arm name"}""".parseJson)
+    writtenJson should be(
+      """{"id":10,"trialId":"NCT000001","name":"arm name","originalName":"orig arm name"}""".parseJson)
 
     val createArmJson = """{"trialId":"NCT000001","name":"arm name"}""".parseJson
-    val parsedArm = armFormat.read(createArmJson)
+    val parsedArm     = armFormat.read(createArmJson)
     val expectedCreatedArm = arm.copy(
       id = LongId(0),
       originalName = "arm name"
     )
     parsedArm should be(expectedCreatedArm)
 
-    val updateArmJson = """{"name":"new arm name"}""".parseJson
+    val updateArmJson      = """{"name":"new arm name"}""".parseJson
     val expectedUpdatedArm = arm.copy(name = "new arm name")
-    val parsedUpdateArm = applyUpdateToArm(updateArmJson, arm)
+    val parsedUpdateArm    = applyUpdateToArm(updateArmJson, arm)
     parsedUpdateArm should be(expectedUpdatedArm)
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentFormatSuite.scala
index 9394735..481e92f 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentFormatSuite.scala
@@ -31,7 +31,7 @@ class DocumentFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = documentFormat.write(orig)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"recordId":101,"physician":"physician","typeId":10,"provider":"provider 21","providerTypeId":21,
          "requiredType":"OPN","startDate":null,"endDate":null,"status":"New","assignee":null,"previousStatus":null,
          "previousAssignee":null,"lastActiveUser":null,"lastUpdate":"2017-08-10T18:00Z","meta":null}""".parseJson)
@@ -58,15 +58,15 @@ class DocumentFormatSuite extends FlatSpec with Matchers {
   }
 
   "Json format for Document.Meta" should "read and write correct JSON" in {
-    val meta = Document.Meta(predicted = None, startPage = 1.0, endPage = 2.0)
+    val meta        = Document.Meta(predicted = None, startPage = 1.0, endPage = 2.0)
     val writtenJson = documentMetaFormat.write(meta)
-    writtenJson should be ("""{"startPage":1.0,"endPage":2.0}""".parseJson)
+    writtenJson should be("""{"startPage":1.0,"endPage":2.0}""".parseJson)
 
-    val metaJsonWithoutPredicted = """{"startPage":1.0,"endPage":2.0}""".parseJson
+    val metaJsonWithoutPredicted   = """{"startPage":1.0,"endPage":2.0}""".parseJson
     val parsedMetaWithoutPredicted = documentMetaFormat.read(metaJsonWithoutPredicted)
     parsedMetaWithoutPredicted should be(meta)
 
-    val metaJsonWithPredicted = """{"predicted":true,"startPage":1.0,"endPage":2.0}""".parseJson
+    val metaJsonWithPredicted   = """{"predicted":true,"startPage":1.0,"endPage":2.0}""".parseJson
     val parsedMetaWithPredicted = documentMetaFormat.read(metaJsonWithPredicted)
     parsedMetaWithPredicted should be(meta.copy(predicted = Some(true)))
   }
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentHistoryFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentHistoryFormatSuite.scala
index ddbda1d..5975919 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentHistoryFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentHistoryFormatSuite.scala
@@ -21,8 +21,7 @@ class DocumentHistoryFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = documentHistoryFormat.write(documentHistory)
 
-    writtenJson should be(
-      """{"id":10,"executor":"userId-001","documentId":1,"state":"Extract",
+    writtenJson should be("""{"id":10,"executor":"userId-001","documentId":1,"state":"Extract",
         "action":"Start","created":"2017-08-10T18:00Z"}""".parseJson)
 
     val parsedDocumentHistory = documentHistoryFormat.read(writtenJson)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentIssueFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentIssueFormatSuite.scala
index c4c9f7c..54cfe90 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentIssueFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentIssueFormatSuite.scala
@@ -29,7 +29,8 @@ class DocumentIssueFormatSuite extends FlatSpec with Matchers {
         "text":"message text","archiveRequired":false,"startPage":1.0,"endPage":2.0}""".parseJson)
 
     val createDocumentIssueJson = """{"text":"message text","startPage":1.0,"endPage":2.0}""".parseJson
-    val expectedCreatedDocumentIssue = documentIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true)
+    val expectedCreatedDocumentIssue =
+      documentIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true)
     val parsedCreateDocumentIssue = jsValueToDocumentIssue(createDocumentIssueJson, LongId(1), StringId("userId-001"))
     parsedCreateDocumentIssue should be(expectedCreatedDocumentIssue)
 
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/EligibilityArmFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/EligibilityArmFormatSuite.scala
new file mode 100644
index 0000000..bcfb977
--- /dev/null
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/EligibilityArmFormatSuite.scala
@@ -0,0 +1,36 @@
+package xyz.driver.pdsuidomain.formats.json.sprayformats
+
+import spray.json._
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.pdsuicommon.domain.{LongId, StringId}
+import xyz.driver.pdsuidomain.entities.EligibilityArm
+
+class EligibilityArmFormatSuite extends FlatSpec with Matchers {
+  import eligibilityarm._
+
+  "Json format for EligibilityArm" should "read and write correct JSON" in {
+    val arm = EligibilityArm(
+      id = LongId(10),
+      trialId = StringId("NCT000001"),
+      name = "arm name",
+      originalName = "orig arm name"
+    )
+    val writtenJson = eligibilityArmFormat.write(arm)
+
+    writtenJson should be(
+      """{"id":10,"trialId":"NCT000001","name":"arm name","originalName":"orig arm name"}""".parseJson)
+
+    val createArmJson = """{"trialId":"NCT000001","name":"arm name"}""".parseJson
+    val parsedArm     = eligibilityArmFormat.read(createArmJson)
+    val expectedCreatedArm = arm.copy(
+      id = LongId(0),
+      originalName = "arm name"
+    )
+    parsedArm should be(expectedCreatedArm)
+
+    val updateArmJson      = """{"name":"new arm name"}""".parseJson
+    val expectedUpdatedArm = arm.copy(name = "new arm name")
+    val parsedUpdateArm    = applyUpdateToArm(updateArmJson, arm)
+    parsedUpdateArm should be(expectedUpdatedArm)
+  }
+}
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExtractedDataFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExtractedDataFormatSuite.scala
index a4b8bab..c3df80a 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExtractedDataFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExtractedDataFormatSuite.scala
@@ -40,7 +40,7 @@ class ExtractedDataFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = extractedDataFormat.write(origRichExtractedData)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"documentId":101,"keywordId":201,"evidence":"evidence text","meta":null,
         "labels":[{"id":null,"categoryId":null,"value":"Yes"},{"id":12,"categoryId":1,"value":"No"}]}""".parseJson)
 
@@ -77,14 +77,15 @@ class ExtractedDataFormatSuite extends FlatSpec with Matchers {
     val expectedUpdatedExtractedData = origRichExtractedData.copy(
       extractedData = extractedData.copy(
         evidenceText = Some("new evidence text"),
-        meta = Some(TextJson(Meta(
-          keyword = Meta.Keyword(page = 1, pageRatio = None, index = 2, sortIndex = "ASC"),
-          evidence = Meta.Evidence(
-            pageRatio = 1.0,
-            start = Meta.TextLayerPosition(page = 1, index = 3, offset = 2),
-            end = Meta.TextLayerPosition(page = 2, index = 3, offset = 10)
-          )
-        )))
+        meta = Some(
+          TextJson(Meta(
+            keyword = Meta.Keyword(page = 1, pageRatio = None, index = 2, sortIndex = "ASC"),
+            evidence = Meta.Evidence(
+              pageRatio = 1.0,
+              start = Meta.TextLayerPosition(page = 1, index = 3, offset = 2),
+              end = Meta.TextLayerPosition(page = 2, index = 3, offset = 10)
+            )
+          )))
       ),
       labels = updatedExtractedDataLabels
     )
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala
index 306fb17..76d90f5 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala
@@ -17,8 +17,7 @@ class HypothesisFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = hypothesisFormat.write(hypothesis)
 
-    writtenJson should be(
-      """{"id":"3b80b2e2-5372-4cf5-a342-6e4ebe10fafd","name":"hypothesis name",
+    writtenJson should be("""{"id":"3b80b2e2-5372-4cf5-a342-6e4ebe10fafd","name":"hypothesis name",
         "treatmentType":"treatment type","description":"descr"}""".parseJson)
 
     val parsedHypothesis = hypothesisFormat.read(writtenJson)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatSuite.scala
index dad39c8..5891e1c 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatSuite.scala
@@ -60,7 +60,7 @@ class InterventionFormatSuite extends FlatSpec with Matchers {
 
   "Json format for InterventionType" should "read and write correct JSON" in {
     val interventionType = InterventionType.typeFromString("Surgery/Procedure")
-    val writtenJson = interventionTypeFormat.write(interventionType)
+    val writtenJson      = interventionTypeFormat.write(interventionType)
 
     writtenJson should be(
       """{"id":9,"name":"Surgery/Procedure","deliveryMethods":["Radio-Frequency Ablation (RFA)",
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordFormatSuite.scala
index 899e5c9..feedf2f 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordFormatSuite.scala
@@ -32,7 +32,7 @@ class MedicalRecordFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = recordFormat.write(orig)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"status":"New","assignee":null,"previousStatus":null,"previousAssignee":null,"lastActiveUser":null,
         "lastUpdate":"2017-08-10T18:00Z","meta":[],"patientId":"748b5884-3528-4cb9-904b-7a8151d6e343","caseId":null,
         "requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","disease":"Breast","physician":"physician"}""".parseJson)
@@ -64,11 +64,16 @@ class MedicalRecordFormatSuite extends FlatSpec with Matchers {
         {"type":"reorder","items":[1,2]},
         {"type":"rotation","items":{"item1":1,"item2":2}}]}""".parseJson
     val expectedUpdatedRecord = orig.copy(
-      meta = Some(TextJson(List(
-        Meta.Duplicate(predicted = Some(true), startPage = 1.0, endPage = 2.0, startOriginalPage = 1.0, endOriginalPage = None),
-        Meta.Reorder(predicted = None, items = Seq(1, 2)),
-        Meta.Rotation(predicted = None, items = Map("item1" -> 1, "item2" -> 2))
-      )))
+      meta = Some(
+        TextJson(List(
+          Meta.Duplicate(predicted = Some(true),
+                         startPage = 1.0,
+                         endPage = 2.0,
+                         startOriginalPage = 1.0,
+                         endOriginalPage = None),
+          Meta.Reorder(predicted = None, items = Seq(1, 2)),
+          Meta.Rotation(predicted = None, items = Map("item1" -> 1, "item2" -> 2))
+        )))
     )
     val parsedUpdatedRecord = applyUpdateToMedicalRecord(updateRecordJson, orig)
     parsedUpdatedRecord should be(expectedUpdatedRecord)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordHistoryFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordHistoryFormatSuite.scala
index 5cd6c8d..a8634d9 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordHistoryFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordHistoryFormatSuite.scala
@@ -21,8 +21,7 @@ class MedicalRecordHistoryFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = recordHistoryFormat.write(recordHistory)
 
-    writtenJson should be(
-      """{"id":10,"executor":"userId-001","recordId":1,"state":"Clean",
+    writtenJson should be("""{"id":10,"executor":"userId-001","recordId":1,"state":"Clean",
         "action":"Start","created":"2017-08-10T18:00Z"}""".parseJson)
 
     val parsedRecordHistory = recordHistoryFormat.read(writtenJson)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordIssueFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordIssueFormatSuite.scala
index c23ca37..5fa740b 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordIssueFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordIssueFormatSuite.scala
@@ -28,9 +28,9 @@ class MedicalRecordIssueFormatSuite extends FlatSpec with Matchers {
       """{"id":10,"recordId":1,"userId":"userId-001","lastUpdate":"2017-08-10T18:00Z","isDraft":false,
         "text":"message text","archiveRequired":false,"startPage":1.0,"endPage":2.0}""".parseJson)
 
-    val createRecordIssueJson = """{"text":"message text","startPage":1.0,"endPage":2.0}""".parseJson
+    val createRecordIssueJson      = """{"text":"message text","startPage":1.0,"endPage":2.0}""".parseJson
     val expectedCreatedRecordIssue = recordIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true)
-    val parsedCreateRecordIssue = jsValueToRecordIssue(createRecordIssueJson, LongId(1), StringId("userId-001"))
+    val parsedCreateRecordIssue    = jsValueToRecordIssue(createRecordIssueJson, LongId(1), StringId("userId-001"))
     parsedCreateRecordIssue should be(expectedCreatedRecordIssue)
 
     val updateRecordIssueJson =
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientCriterionFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientCriterionFormatSuite.scala
index 0f5e4e2..43f9b48 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientCriterionFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientCriterionFormatSuite.scala
@@ -33,17 +33,18 @@ class PatientCriterionFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientCriterionWriter.write((orig, LongId(21), arms))
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"labelId":21,"nctId":"NCT00001","criterionId":101,"criterionText":"criterion text","criterionValue":"Yes",
          "criterionIsDefining":false,"criterionIsCompound":false,"eligibilityStatus":"Yes","verifiedEligibilityStatus":null,
          "isVisible":true,"isVerified":true,"lastUpdate":"2017-08-10T18:00Z","arms":["arm 31","arm 32"]}""".parseJson)
 
-    val updatePatientCriterionJson = """{"verifiedEligibilityStatus":"No"}""".parseJson
+    val updatePatientCriterionJson      = """{"verifiedEligibilityStatus":"No"}""".parseJson
     val expectedUpdatedPatientCriterion = orig.copy(verifiedEligibilityStatus = Some(FuzzyValue.No))
-    val parsedUpdatePatientCriterion = applyUpdateToPatientCriterion(updatePatientCriterionJson, orig)
+    val parsedUpdatePatientCriterion    = applyUpdateToPatientCriterion(updatePatientCriterionJson, orig)
     parsedUpdatePatientCriterion should be(expectedUpdatedPatientCriterion)
 
-    val updateBulkPatientCriterionJson = """[{"id":1,"eligibilityStatus":"No"},{"id":2,"isVerified":false}]""".parseJson
+    val updateBulkPatientCriterionJson =
+      """[{"id":1,"eligibilityStatus":"No"},{"id":2,"isVerified":false}]""".parseJson
     val expectedDraftPatientCriterionList = List(
       DraftPatientCriterion(id = LongId(1), eligibilityStatus = Some(FuzzyValue.No), isVerified = None),
       DraftPatientCriterion(id = LongId(2), eligibilityStatus = None, isVerified = Some(false))
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientEligibleTrialFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientEligibleTrialFormatSuite.scala
index 8b00883..1d28b2e 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientEligibleTrialFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientEligibleTrialFormatSuite.scala
@@ -45,16 +45,16 @@ class PatientEligibleTrialFormatSuite extends FlatSpec with Matchers {
       PatientCriterionArm(patientCriterionId = LongId(1), armId = LongId(31), armName = "arm 31"),
       PatientCriterionArm(patientCriterionId = LongId(1), armId = LongId(32), armName = "arm 32")
     )
-    val orig = RichPatientEligibleTrial(trial, group, arms)
+    val orig        = RichPatientEligibleTrial(trial, group, arms)
     val writtenJson = patientEligibleTrialWriter.write(orig)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"patientId":"748b5884-3528-4cb9-904b-7a8151d6e343","trialId":"NCT000001","trialTitle":"trial title",
          "hypothesisId":"e76e2fc4-a29c-44fb-a81b-8856d06bb1d4","verifiedEligibilityStatus":"Yes","isVerified":false,"arms":["arm 31","arm 32"]}""".parseJson)
 
-    val updatePatientEligibleTrialJson = """{"isVerified":true}""".parseJson
+    val updatePatientEligibleTrialJson      = """{"isVerified":true}""".parseJson
     val expectedUpdatedPatientTrialArmGroup = group.copy(isVerified = true)
-    val parsedUpdatePatientTrialArmGroup = applyUpdateToTrialArmGroup(updatePatientEligibleTrialJson, group)
+    val parsedUpdatePatientTrialArmGroup    = applyUpdateToTrialArmGroup(updatePatientEligibleTrialJson, group)
     parsedUpdatePatientTrialArmGroup should be(expectedUpdatedPatientTrialArmGroup)
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientFormatSuite.scala
index 2761d6a..b1b6b2a 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientFormatSuite.scala
@@ -27,7 +27,7 @@ class PatientFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientWriter.write(orig)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":"748b5884-3528-4cb9-904b-7a8151d6e343","dob":"1980-06-30","name":"John Doe","status":"New","assignee":null,
          "previousStatus":null,"previousAssignee":null,"lastActiveUser":null,"lastUpdate":"2017-08-10T18:00Z",
          "orderId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","condition":"breast"}""".parseJson)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHypothesisFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHypothesisFormatSuite.scala
index 2999cc1..0e628a8 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHypothesisFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHypothesisFormatSuite.scala
@@ -18,13 +18,13 @@ class PatientHypothesisFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientHypothesisWriter.write((orig, true))
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":"815d9715-1089-4775-b120-3afb983b9a97","patientId":"748b5884-3528-4cb9-904b-7a8151d6e343",
          "hypothesisId":"e76e2fc4-a29c-44fb-a81b-8856d06bb1d4","rationale":null,"matchedTrials":1,"isRationaleRequired":true}""".parseJson)
 
-    val updatePatientHypothesisJson = """{"rationale":"rationale"}""".parseJson
+    val updatePatientHypothesisJson      = """{"rationale":"rationale"}""".parseJson
     val expectedUpdatedPatientHypothesis = orig.copy(rationale = Some("rationale"))
-    val parsedUpdatePatientHypothesis = applyUpdateToPatientHypothesis(updatePatientHypothesisJson, orig)
+    val parsedUpdatePatientHypothesis    = applyUpdateToPatientHypothesis(updatePatientHypothesisJson, orig)
     parsedUpdatePatientHypothesis should be(expectedUpdatedPatientHypothesis)
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientIssueFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientIssueFormatSuite.scala
index 1e2a11e..2776dcc 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientIssueFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientIssueFormatSuite.scala
@@ -22,13 +22,14 @@ class PatientIssueFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientIssueWriter.write(patientIssue)
 
-    writtenJson should be(
-      """{"id":10,"userId":"userId-001","lastUpdate":"2017-08-10T18:00Z","isDraft":false,
+    writtenJson should be("""{"id":10,"userId":"userId-001","lastUpdate":"2017-08-10T18:00Z","isDraft":false,
         "text":"message text","archiveRequired":false}""".parseJson)
 
-    val createPatientIssueJson = """{"text":"message text"}""".parseJson
+    val createPatientIssueJson      = """{"text":"message text"}""".parseJson
     val expectedCreatedPatientIssue = patientIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true)
-    val parsedCreatePatientIssue = jsValueToPatientIssue(createPatientIssueJson, UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), StringId("userId-001"))
+    val parsedCreatePatientIssue = jsValueToPatientIssue(createPatientIssueJson,
+                                                         UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"),
+                                                         StringId("userId-001"))
     parsedCreatePatientIssue should be(expectedCreatedPatientIssue)
 
     val updatePatientIssueJson =
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientLabelFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientLabelFormatSuite.scala
index e18239c..67d678c 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientLabelFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientLabelFormatSuite.scala
@@ -23,13 +23,13 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientLabelWriter.write((orig, true))
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"labelId":20,"primaryValue":"Yes","verifiedPrimaryValue":null,"isVisible":true,"isVerified":true,
         "score":1,"isImplicitMatch":false}""".parseJson)
 
-    val updatePatientLabelJson = """{"verifiedPrimaryValue":"No"}""".parseJson
+    val updatePatientLabelJson      = """{"verifiedPrimaryValue":"No"}""".parseJson
     val expectedUpdatedPatientLabel = orig.copy(verifiedPrimaryValue = Some(FuzzyValue.No))
-    val parsedUpdatePatientLabel = applyUpdateToPatientLabel(updatePatientLabelJson, orig)
+    val parsedUpdatePatientLabel    = applyUpdateToPatientLabel(updatePatientLabelJson, orig)
     parsedUpdatePatientLabel should be(expectedUpdatedPatientLabel)
   }
 
@@ -51,7 +51,7 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientLabelEvidenceWriter.write(orig)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"id":1,"value":"Maybe","evidenceText":"evidence text","documentId":21,"evidenceId":10,"reportId":null,
         "documentType":"document type","date":"2017-08-10","providerType":"provider type"}""".parseJson)
   }
@@ -70,7 +70,7 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientLabelDefiningCriteriaWriter.write(orig)
 
-    writtenJson should be ("""{"id":1,"value":"Yes"}""".parseJson)
+    writtenJson should be("""{"id":1,"value":"Yes"}""".parseJson)
   }
 
 }
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/SlotArmFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/SlotArmFormatSuite.scala
new file mode 100644
index 0000000..7dd085c
--- /dev/null
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/SlotArmFormatSuite.scala
@@ -0,0 +1,36 @@
+package xyz.driver.pdsuidomain.formats.json.sprayformats
+
+import spray.json._
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.pdsuicommon.domain.{LongId, StringId}
+import xyz.driver.pdsuidomain.entities.SlotArm
+
+class SlotArmFormatSuite extends FlatSpec with Matchers {
+  import slotarm._
+
+  "Json format for SlotArm" should "read and write correct JSON" in {
+    val arm = SlotArm(
+      id = LongId(10),
+      trialId = StringId("NCT000001"),
+      name = "arm name",
+      originalName = "orig arm name"
+    )
+    val writtenJson = slotArmFormat.write(arm)
+
+    writtenJson should be(
+      """{"id":10,"trialId":"NCT000001","name":"arm name","originalName":"orig arm name"}""".parseJson)
+
+    val createArmJson = """{"trialId":"NCT000001","name":"arm name"}""".parseJson
+    val parsedArm     = slotArmFormat.read(createArmJson)
+    val expectedCreatedArm = arm.copy(
+      id = LongId(0),
+      originalName = "arm name"
+    )
+    parsedArm should be(expectedCreatedArm)
+
+    val updateArmJson      = """{"name":"new arm name"}""".parseJson
+    val expectedUpdatedArm = arm.copy(name = "new arm name")
+    val parsedUpdateArm    = applyUpdateToArm(updateArmJson, arm)
+    parsedUpdateArm should be(expectedUpdatedArm)
+  }
+}
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatSuite.scala
index 3533c07..a3da52f 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatSuite.scala
@@ -33,16 +33,16 @@ class TrialFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = trialWriter.write(orig)
 
-    writtenJson should be (
+    writtenJson should be(
       """{"isPartner":false,"assignee":null,"lastUpdate":"2017-08-10T18:16:19Z","previousStatus":null,
         "isUpdated":false,"overviewTemplate":"","phase":"","originalStudyDesignId":null,
         "hypothesisId":"3b80b2e2-5372-4cf5-a342-6e4ebe10fafd","originalTitle":"orig trial title",
         "studyDesignId":321,"lastActiveUser":null,"externalid":"40892a07-c638-49d2-9795-1edfefbbcc7c",
         "id":"NCT000001","status":"New","overview":null,"previousAssignee":null,"title":"trial title"}""".parseJson)
 
-    val updateTrialJson = """{"hypothesisId":null,"overview":"new overview"}""".parseJson
+    val updateTrialJson      = """{"hypothesisId":null,"overview":"new overview"}""".parseJson
     val expectedUpdatedTrial = orig.copy(hypothesisId = None, overview = Some("new overview"))
-    val parsedUpdateTrial = applyUpdateToTrial(updateTrialJson, orig)
+    val parsedUpdateTrial    = applyUpdateToTrial(updateTrialJson, orig)
     parsedUpdateTrial should be(expectedUpdatedTrial)
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialHistoryFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialHistoryFormatSuite.scala
index dbb143c..d5ad2ec 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialHistoryFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialHistoryFormatSuite.scala
@@ -21,8 +21,7 @@ class TrialHistoryFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = trialHistoryFormat.write(trialHistory)
 
-    writtenJson should be(
-      """{"id":10,"executor":"userId-001","trialId":"NCT000001","state":"Summarize",
+    writtenJson should be("""{"id":10,"executor":"userId-001","trialId":"NCT000001","state":"Summarize",
         "action":"Start","created":"2017-08-10T18:00Z"}""".parseJson)
 
     val parsedTrialHistory = trialHistoryFormat.read(writtenJson)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialIssueFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialIssueFormatSuite.scala
index 02e14ba..4a9ea4f 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialIssueFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialIssueFormatSuite.scala
@@ -24,13 +24,13 @@ class TrialIssueFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = trialIssueWriter.write(trialIssue)
 
-    writtenJson should be(
-      """{"id":10,"userId":"userId-001","lastUpdate":"2017-08-10T18:00Z","isDraft":false,
+    writtenJson should be("""{"id":10,"userId":"userId-001","lastUpdate":"2017-08-10T18:00Z","isDraft":false,
         "text":"message text","evidence":"evidence","archiveRequired":false,"meta":"{}"}""".parseJson)
 
-    val createTrialIssueJson = """{"text":"message text","evidence":"evidence","meta":"{}"}""".parseJson
+    val createTrialIssueJson      = """{"text":"message text","evidence":"evidence","meta":"{}"}""".parseJson
     val expectedCreatedTrialIssue = trialIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true)
-    val parsedCreateTrialIssue = jsValueToTrialIssue(createTrialIssueJson, StringId("NCT000001"), StringId("userId-001"))
+    val parsedCreateTrialIssue =
+      jsValueToTrialIssue(createTrialIssueJson, StringId("NCT000001"), StringId("userId-001"))
     parsedCreateTrialIssue should be(expectedCreatedTrialIssue)
 
     val updateTrialIssueJson =
-- 
cgit v1.2.3