Merge pull request #37 from drivergroup/add-slot-eligibility-armsv0.8.1

Add slot eligibility arms

29 files changed, 272 insertions, 178 deletions

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/CriterionFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala
index 708aed9..51665d2 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala
@@ -3,7 +3,7 @@ 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.{Arm, Criterion, CriterionLabel}
+import xyz.driver.pdsuidomain.entities.{EligibilityArm, Criterion, CriterionLabel}
 import xyz.driver.pdsuidomain.services.CriterionService.RichCriterion
 
 class CriterionFormatSuite extends FlatSpec with Matchers {
@@ -36,7 +36,7 @@ class CriterionFormatSuite extends FlatSpec with Matchers {
         isDefining = true
       )
     )
-    val arms = List(LongId[Arm](20), LongId[Arm](21), LongId[Arm](21))
+    val arms = List(LongId[EligibilityArm](20), LongId[EligibilityArm](21), LongId[EligibilityArm](21))
     val richCriterion = RichCriterion(
       criterion = criterion,
       armIds = arms,
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 193e066..e6dd4a1 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
@@ -32,7 +32,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","institutionName":"institution name","startDate":null,"endDate":null,"status":"New","assignee":null,"previousStatus":null,
          "previousAssignee":null,"lastActiveUser":null,"lastUpdate":"2017-08-10T18:00Z","meta":null}""".parseJson)
@@ -60,11 +60,11 @@ class DocumentFormatSuite extends FlatSpec with Matchers {
   }
 
   "Json format for Document.Meta" should "read and write correct JSON" in {
-    val meta = Document.Meta(startPage = 1.0, endPage = 2.0)
+    val meta        = Document.Meta(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 metaJson = """{"startPage":1.0,"endPage":2.0}""".parseJson
+    val metaJson   = """{"startPage":1.0,"endPage":2.0}""".parseJson
     val parsedMeta = documentMetaFormat.read(metaJson)
     parsedMeta should be(meta)
   }
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/ExportFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala
index 402e893..d78e754 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala
@@ -3,8 +3,8 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 import java.time.{LocalDate, LocalDateTime}
 import java.util.UUID
 
-import spray.json._
 import org.scalatest.{FlatSpec, Matchers}
+import spray.json._
 import xyz.driver.entities.labels.LabelValue
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
 import xyz.driver.pdsuidomain.entities.{DocumentType, ProviderType, RecordRequestId}
@@ -81,8 +81,8 @@ class ExportFormatSuite extends FlatSpec with Matchers {
   "Json format for ApiExportTrialWithLabels" should "read and write correct JSON" in {
     import xyz.driver.pdsuidomain.entities.export.trial._
     val arms = List(
-      ExportTrialArm(armId = LongId(1), armName = "arm 1"),
-      ExportTrialArm(armId = LongId(2), armName = "arm 2")
+      ExportTrialArm(armId = LongId(1), armName = "arm 1", diseaseList = Seq("Breast")),
+      ExportTrialArm(armId = LongId(2), armName = "arm 2", diseaseList = Seq("Breast"))
     )
     val criteriaList = List(
       ExportTrialLabelCriterion(
@@ -107,7 +107,6 @@ class ExportFormatSuite extends FlatSpec with Matchers {
     val trialWithLabels = ExportTrialWithLabels(
       nctId = StringId("NCT000001"),
       trialId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"),
-      disease = "Breast",
       lastReviewed = LocalDateTime.parse("2017-08-10T18:00:00"),
       labelVersion = 1L,
       arms = arms,
@@ -116,8 +115,8 @@ class ExportFormatSuite extends FlatSpec with Matchers {
 
     val writtenJson = trialWithLabelsFormat.write(trialWithLabels)
     writtenJson should be(
-      """{"nctId":"NCT000001","trialId":"40892a07-c638-49d2-9795-1edfefbbcc7c","disease":"Breast","lastReviewed":"2017-08-10T18:00Z",
-        "labelVersion":1,"arms":[{"armId":1,"armName":"arm 1"},{"armId":2,"armName":"arm 2"}],"criteria":[
+      """{"nctId":"NCT000001","trialId":"40892a07-c638-49d2-9795-1edfefbbcc7c","lastReviewed":"2017-08-10T18:00Z",
+        "labelVersion":1,"arms":[{"armId":1,"armName":"arm 1","diseaseList":["Breast"]},{"armId":2,"armName":"arm 2","diseaseList":["Breast"]}],"criteria":[
         {"value":"Yes","labelId":21,"criterionId":10,"criterionText":"criteria 10 text","armIds":[1,2],"isCompound":false,"isDefining":false},
         {"value":"Unknown","labelId":21,"criterionId":11,"criterionText":"criteria 11 text","armIds":[2],"isCompound":true,"isDefining":false}]}""".parseJson)
   }
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 aa82b98..1feca6a 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
@@ -41,7 +41,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)
 
@@ -78,14 +78,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/ListResponseSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ListResponseSuite.scala
index 65024a3..d7f1a9b 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ListResponseSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ListResponseSuite.scala
@@ -10,10 +10,9 @@ import xyz.driver.pdsuidomain.entities.MedicalRecord.Status
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.record.recordFormat
 
-
 class ListResponseSuite extends FlatSpec with Matchers {
 
-  private val lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00")
+  private val lastUpdate        = LocalDateTime.parse("2017-08-10T18:00:00")
   private val lastUpdateToLocal = "2017-08-10T18:00Z"
 
   private def metaJsonObjectAsString(meta: ListResponse.Meta) = {
@@ -25,7 +24,6 @@ class ListResponseSuite extends FlatSpec with Matchers {
     s"""{"itemsCount":$itemsCount,"pageNumber":$pageNumber,"pageSize":$pageSize$lastUpdate}"""
   }
 
-
   "Json format for ListResponse.Meta" should "read and write correct JSON" in {
     val meta1 =
       ListResponse.Meta(
@@ -38,15 +36,13 @@ class ListResponseSuite extends FlatSpec with Matchers {
     val writtenJson1 =
       ListResponse.listResponseMetaFormat.write(meta1)
 
-    writtenJson1 should be(
-      metaJsonObjectAsString(meta1).parseJson)
+    writtenJson1 should be(metaJsonObjectAsString(meta1).parseJson)
 
     val parsedItem1: ListResponse.Meta =
       ListResponse.listResponseMetaFormat.read(writtenJson1)
 
     meta1 shouldBe parsedItem1
 
-
     val meta2 =
       ListResponse.Meta(
         itemsCount = 1,
@@ -58,8 +54,7 @@ class ListResponseSuite extends FlatSpec with Matchers {
     val writtenJson2 =
       ListResponse.listResponseMetaFormat.write(meta2)
 
-    writtenJson2 should be(
-      metaJsonObjectAsString(meta2).parseJson)
+    writtenJson2 should be(metaJsonObjectAsString(meta2).parseJson)
 
     val parsedItem2: ListResponse.Meta =
       ListResponse.listResponseMetaFormat.read(writtenJson2)
@@ -67,7 +62,6 @@ class ListResponseSuite extends FlatSpec with Matchers {
     meta2 shouldBe parsedItem2
   }
 
-
   "Json format for ListResponse" should "write correct JSON" in {
 
     val orig = MedicalRecord(
@@ -102,11 +96,10 @@ class ListResponseSuite extends FlatSpec with Matchers {
 
     val listResponse = ListResponse(Seq(orig), meta)
 
-    val writtenJson = ListResponse.listResponseMetaWriter.write(listResponse)
+    val writtenJson  = ListResponse.listResponseMetaWriter.write(listResponse)
     val expectedJson = s"""{"items":[$recordJsonAsString],"meta":${metaJsonObjectAsString(meta)}}"""
 
-    writtenJson should be(
-      expectedJson.parseJson)
+    writtenJson should be(expectedJson.parseJson)
   }
 
 }
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 90d5b6e..9616e70 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
@@ -31,7 +31,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","totalPages":10}""".parseJson)
@@ -62,11 +62,13 @@ 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(startPage = 1.0, endPage = 2.0, startOriginalPage = 1.0, endOriginalPage = None),
-        Meta.Reorder(Seq(1, 2)),
-        Meta.Rotation(Map("item1" -> 1, "item2" -> 2))
-      )))
+      meta = Some(
+        TextJson(
+          List(
+            Meta.Duplicate(startPage = 1.0, endPage = 2.0, startOriginalPage = 1.0, endOriginalPage = None),
+            Meta.Reorder(Seq(1, 2)),
+            Meta.Rotation(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 fc206c7..b254013 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,19 +33,20 @@ class PatientCriterionFormatSuite extends FlatSpec with Matchers {
       PatientCriterionArm(patientCriterionId = LongId(1), armId = LongId(32), armName = "arm 32")
     )
     val richPatientCriterion = RichPatientCriterion(orig, LongId(21), arms)
-    val writtenJson = patientCriterionWriter.write(richPatientCriterion)
+    val writtenJson          = patientCriterionWriter.write(richPatientCriterion)
 
-    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(LabelValue.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(LabelValue.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 31f541f..b8f6f8e 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
@@ -2,10 +2,9 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import java.time.LocalDateTime
 
-import spray.json._
 import org.scalatest.{FlatSpec, Matchers}
+import spray.json._
 import xyz.driver.entities.labels.LabelValue
-import xyz.driver.entities.patient.CancerType
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
 import xyz.driver.pdsuidomain.entities.{PatientCriterionArm, PatientTrialArmGroupView, Trial}
 import xyz.driver.pdsuidomain.services.PatientEligibleTrialService.RichPatientEligibleTrial
@@ -23,7 +22,6 @@ class PatientEligibleTrialFormatSuite extends FlatSpec with Matchers {
       previousAssignee = None,
       lastActiveUserId = None,
       lastUpdate = LocalDateTime.parse("2017-08-10T18:16:19"),
-      disease = CancerType.Breast,
       phase = "",
       hypothesisId = Some(UuidId("e76e2fc4-a29c-44fb-a81b-8856d06bb1d4")),
       studyDesignId = Some(LongId(321)),
@@ -48,16 +46,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 ad12b3b..128cad1 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
@@ -29,7 +29,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":{"firstName":"John","middleName":"","lastName":"Doe"},"status":"New","assignee":null,
          "previousStatus":null,"previousAssignee":null,"lastActiveUser":null,"lastUpdate":"2017-08-10T18:00Z",
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 fbb5213..71cbbad 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
@@ -19,13 +19,13 @@ class PatientHypothesisFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = richPatientHypothesisWriter.write(RichPatientHypothesis(orig, isRequired = 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)
   }
 
@@ -39,7 +39,7 @@ class PatientHypothesisFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = patientHypothesisWriter.write(orig)
 
-    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}""".parseJson)
   }
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 e837861..2122777 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
@@ -25,13 +25,13 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
     )
     val writtenJson = richPatientLabelWriter.write(RichPatientLabel(orig, isVerified = 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(LabelValue.No))
-    val parsedUpdatePatientLabel = applyUpdateToPatientLabel(updatePatientLabelJson, orig)
+    val parsedUpdatePatientLabel    = applyUpdateToPatientLabel(updatePatientLabelJson, orig)
     parsedUpdatePatientLabel should be(expectedUpdatedPatientLabel)
   }
 
@@ -53,7 +53,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":{"id":3,"name":"Laboratory Report"},"date":"2017-08-10",
         "providerType":{"id":26,"name":"Emergency Medicine"}}""".parseJson)
@@ -73,7 +73,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 beb69c4..c9dc85f 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
@@ -2,9 +2,8 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import java.time.LocalDateTime
 
-import spray.json._
 import org.scalatest.{FlatSpec, Matchers}
-import xyz.driver.entities.patient.CancerType
+import spray.json._
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
 import xyz.driver.pdsuidomain.entities.Trial
 
@@ -21,7 +20,6 @@ class TrialFormatSuite extends FlatSpec with Matchers {
       previousAssignee = None,
       lastActiveUserId = None,
       lastUpdate = LocalDateTime.parse("2017-08-10T18:16:19"),
-      disease = CancerType.Breast,
       phase = "",
       hypothesisId = Some(UuidId("3b80b2e2-5372-4cf5-a342-6e4ebe10fafd")),
       studyDesignId = Some(LongId(321)),
@@ -35,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","disease":"Breast","status":"New","overview":null,"previousAssignee":null,"title":"trial title"}""".parseJson)
+        "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 =