From 9e60edb6216fce615b13f9bcc68d8f86258b85c3 Mon Sep 17 00:00:00 2001 From: Kseniya Tomskikh Date: Thu, 10 Aug 2017 19:25:00 +0600 Subject: PDSUI-2188 Created and fixed test for json formats of TriC --- .../json/sprayformats/ArmFormatTestSuite.scala | 36 ++++++++++++ .../sprayformats/CriterionFormatTestSuite.scala | 68 ++++++++++++++++++++++ .../sprayformats/InterventionFormatTestSuite.scala | 63 ++++++++++++++++++++ .../json/sprayformats/TrialFormatTestSuite.scala | 50 ++++++++++++++++ 4 files changed, 217 insertions(+) create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala (limited to 'src/test/scala') diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.scala new file mode 100644 index 0000000..4a4b3c4 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.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.Arm + +class ArmFormatTestSuite extends FlatSpec with Matchers { + import arm._ + + "Json format for Arm" should "read and write correct JSON" in { + val arm = Arm( + id = LongId(10), + trialId = StringId("NCT000001"), + name = "arm name", + originalName = "orig arm name" + ) + val writtenJson = armFormat.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 = 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 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/CriterionFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala new file mode 100644 index 0000000..0167620 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala @@ -0,0 +1,68 @@ +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.services.CriterionService.RichCriterion + +class CriterionFormatTestSuite extends FlatSpec with Matchers { + import criterion._ + + "Json format for Criterion" should "read and write correct JSON" in { + val criterion = Criterion( + id = LongId(10), + trialId = StringId("NCT000001"), + text = Some("text"), + isCompound = false, + meta = "{}" + ) + val labels = List( + CriterionLabel( + id = LongId(1L), + labelId = Some(LongId(101)), + criterionId = criterion.id, + categoryId = Some(LongId(3)), + value = Some(true), + isDefining = true + ), + CriterionLabel( + id = LongId(2L), + labelId = Some(LongId(102)), + criterionId = criterion.id, + categoryId = Some(LongId(3)), + value = Some(false), + isDefining = true + ) + ) + val arms = List(LongId[Arm](20), LongId[Arm](21), LongId[Arm](21)) + val richCriterion = RichCriterion( + criterion = criterion, + armIds = arms, + labels = labels + ) + val writtenJson = richCriterionFormat.write(richCriterion) + + writtenJson should be( + """{"text":"text","isCompound":false,"trialId":"NCT000001","arms":[20,21,21],"id":10,"meta":"{}", + "labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true}, + {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson) + + val createCriterionJson = + """{"text":"text","isCompound":false,"trialId":"NCT000001", + "arms":[20,21,21],"meta":"{}","labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true}, + {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson + val parsedRichCriterion = richCriterionFormat.read(createCriterionJson) + val expectedRichCriterion = richCriterion.copy( + criterion = criterion.copy(id = LongId(0)), + labels = labels.map(_.copy(id = LongId(0), criterionId = LongId(0))) + ) + parsedRichCriterion should be(expectedRichCriterion) + + val updateCriterionJson = """{"meta":null,"text":"new text","isCompound":true}""".parseJson + val expectedUpdatedCriterion = richCriterion.copy(criterion = criterion.copy(text = Some("new text"), isCompound = true, meta = "{}")) + val parsedUpdateCriterion = applyUpdateToCriterion(updateCriterionJson, richCriterion) + parsedUpdateCriterion should be(expectedUpdatedCriterion) + } + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala new file mode 100644 index 0000000..280b2a7 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala @@ -0,0 +1,63 @@ +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.{Intervention, InterventionArm, InterventionType, InterventionWithArms} + +class InterventionFormatTestSuite extends FlatSpec with Matchers { + import intervention._ + + "Json format for Intervention" should "read and write correct JSON" in { + val intervention = Intervention( + id = LongId(1), + trialId = StringId("NCT000001"), + name = "intervention name", + originalName = "orig name", + typeId = Some(LongId(10)), + originalType = Some("orig type"), + description = "", + originalDescription = "", + isActive = true + ) + val arms = List( + InterventionArm(interventionId = intervention.id, armId = LongId(20)), + InterventionArm(interventionId = intervention.id, armId = LongId(21)), + InterventionArm(interventionId = intervention.id, armId = LongId(22)) + ) + val orig = InterventionWithArms( + intervention = intervention, + arms = arms + ) + val writtenJson = interventionWriter.write(orig) + + writtenJson should be( + """{"id":1,"name":"intervention name","typeId":10,"description":"","isActive":true,"arms":[20,21,22], + "trialId":"NCT000001","originalName":"orig name","originalDescription":"","originalType":"orig type"}""".parseJson) + + val updateInterventionJson = """{"description":"descr","arms":[21,22]}""".parseJson + val expectedUpdatedIntervention = orig.copy( + intervention = intervention.copy(description = "descr"), + arms = List( + InterventionArm(interventionId = intervention.id, armId = LongId(21)), + InterventionArm(interventionId = intervention.id, armId = LongId(22)) + ) + ) + val parsedUpdateIntervention = applyUpdateToInterventionWithArms(updateInterventionJson, orig) + parsedUpdateIntervention should be(expectedUpdatedIntervention) + } + + "Json format for InterventionType" should "read and write correct JSON" in { + val interventionType = InterventionType( + id = LongId(10), + name = "type name" + ) + val writtenJson = interventionTypeFormat.write(interventionType) + + writtenJson should be("""{"id":10,"name":"type name"}""".parseJson) + + val parsedInterventionType = interventionTypeFormat.read(writtenJson) + parsedInterventionType should be(interventionType) + } + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala new file mode 100644 index 0000000..397d2aa --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala @@ -0,0 +1,50 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId} +import xyz.driver.pdsuidomain.entities.Trial + +class TrialFormatTestSuite extends FlatSpec with Matchers { + import trial._ + + "Json format for Trial" should "read and write correct JSON" in { + val orig = Trial( + id = StringId("NCT000001"), + externalId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), + status = Trial.Status.New, + assignee = None, + previousStatus = None, + previousAssignee = None, + lastActiveUserId = None, + lastUpdate = LocalDateTime.parse("2017-08-10T18:16:19"), + condition = Trial.Condition.Breast, + phase = "", + hypothesisId = Some(UuidId("3b80b2e2-5372-4cf5-a342-6e4ebe10fafd")), + studyDesignId = Some(LongId(321)), + originalStudyDesign = None, + isPartner = false, + overview = None, + overviewTemplate = "", + isUpdated = false, + title = "trial title", + originalTitle = "orig trial title" + ) + val writtenJson = trialWriter.write(orig) + + 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","condition":"Breast","status":"New","overview":null,"previousAssignee":null,"title":"trial title"}""".parseJson) + + val updateTrialJson = """{"hypothesisId":null,"overview":"new overview"}""".parseJson + val expectedUpdatedTrial = orig.copy(hypothesisId = None, overview = Some("new overview")) + val parsedUpdateTrial = applyUpdateToTrial(updateTrialJson, orig) + parsedUpdateTrial should be(expectedUpdatedTrial) + + } +} -- cgit v1.2.3 From bfac6a54dcf37e0280cc8f2ec6ff3802dc8e8dfe Mon Sep 17 00:00:00 2001 From: Kseniya Tomskikh Date: Fri, 11 Aug 2017 14:40:19 +0600 Subject: PDSUI-2188 Created and fixed test for json formats for ReP and TM --- .../formats/json/sprayformats/common.scala | 7 +- .../formats/json/sprayformats/document.scala | 64 +++-- .../formats/json/sprayformats/documentissue.scala | 8 +- .../formats/json/sprayformats/extracteddata.scala | 101 ++++---- .../formats/json/sprayformats/patientissue.scala | 6 +- .../formats/json/sprayformats/patientlabel.scala | 20 +- .../formats/json/sprayformats/record.scala | 124 +++++++++- .../formats/json/sprayformats/recordissue.scala | 8 +- .../formats/json/ApiDocumentSuite.scala | 78 ------ .../formats/json/ApiPartialDocumentSuite.scala | 263 --------------------- .../formats/json/sprayformats/ArmFormatSuite.scala | 36 +++ .../json/sprayformats/ArmFormatTestSuite.scala | 36 --- .../json/sprayformats/CriterionFormatSuite.scala | 68 ++++++ .../sprayformats/CriterionFormatTestSuite.scala | 68 ------ .../json/sprayformats/DocumentFormatSuite.scala | 74 ++++++ .../sprayformats/DocumentHistoryFormatSuite.scala | 32 +++ .../sprayformats/DocumentIssueFormatSuite.scala | 47 ++++ .../sprayformats/ExtractedDataFormatSuite.scala | 95 ++++++++ .../sprayformats/InterventionFormatSuite.scala | 63 +++++ .../sprayformats/InterventionFormatTestSuite.scala | 63 ----- .../sprayformats/MedicalRecordFormatSuite.scala | 77 ++++++ .../MedicalRecordHistoryFormatSuite.scala | 32 +++ .../MedicalRecordIssueFormatSuite.scala | 47 ++++ .../json/sprayformats/PatientFormatSuite.scala | 36 +++ .../sprayformats/PatientHistoryFormatSuite.scala | 32 +++ .../PatientHypothesisFormatSuite.scala | 31 +++ .../sprayformats/PatientIssueFormatSuite.scala | 44 ++++ .../sprayformats/PatientLabelFormatSuite.scala | 76 ++++++ .../json/sprayformats/TrialFormatSuite.scala | 50 ++++ .../json/sprayformats/TrialFormatTestSuite.scala | 50 ---- .../sprayformats/TrialHistoryFormatSuite.scala | 32 +++ .../json/sprayformats/TrialIssueFormatSuite.scala | 49 ++++ 32 files changed, 1131 insertions(+), 686 deletions(-) delete mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiDocumentSuite.scala delete mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiPartialDocumentSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatSuite.scala delete mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala delete mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentHistoryFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentIssueFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExtractedDataFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatSuite.scala delete mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordHistoryFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordIssueFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHistoryFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHypothesisFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientIssueFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientLabelFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatSuite.scala delete mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialHistoryFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialIssueFormatSuite.scala (limited to 'src/test/scala') diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala index 4dadb11..dbd0a43 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala @@ -1,7 +1,6 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats -import java.time.format.DateTimeFormatter -import java.time.{LocalDate, LocalDateTime, ZonedDateTime} +import java.time.{LocalDate, LocalDateTime, ZoneId, ZonedDateTime} import spray.json._ import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId, UuidId} @@ -33,9 +32,9 @@ object common { } implicit def dateTimeFormat = new RootJsonFormat[LocalDateTime] { - override def write(date: LocalDateTime): JsString = JsString(date.toString) + override def write(date: LocalDateTime): JsString = JsString(ZonedDateTime.of(date, ZoneId.of("Z")).toString) override def read(json: JsValue): LocalDateTime = json match { - case JsString(value) => LocalDateTime.parse(value) + case JsString(value) => ZonedDateTime.parse(value).toLocalDateTime case _ => deserializationError(s"Expected date as LocalDateTime, but got $json") } } diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala index 20cf6af..baf1b4e 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala @@ -39,41 +39,35 @@ object document { .get("physician") .map(_.convertTo[String]) - val typeId = if (fields.contains("typeId")) { - fields - .get("typeId") - .map(_.convertTo[LongId[DocumentType]]) - } else orig.typeId - - val provider = if (fields.contains("provider")) { - fields - .get("provider") - .map(_.convertTo[String]) - } else orig.providerName - - val providerTypeId = if (fields.contains("providerTypeId")) { - fields - .get("providerTypeId") - .map(_.convertTo[LongId[ProviderType]]) - } else orig.providerTypeId - - val meta = if (fields.contains("meta")) { - fields - .get("meta") - .map(_.convertTo[TextJson[Meta]]) - } else orig.meta - - val startDate = if (fields.contains("startDate")) { - fields - .get("startDate") - .map(_.convertTo[LocalDate]) - } else orig.startDate - - val endDate = if (fields.contains("endDate")) { - fields - .get("endDate") - .map(_.convertTo[LocalDate]) - } else orig.endDate + val typeId = fields + .get("typeId") + .map(_.convertTo[Option[LongId[DocumentType]]]) + .getOrElse(orig.typeId) + + val provider = fields + .get("provider") + .map(_.convertTo[Option[String]]) + .getOrElse(orig.providerName) + + val providerTypeId = fields + .get("providerTypeId") + .map(_.convertTo[Option[LongId[ProviderType]]]) + .getOrElse(orig.providerTypeId) + + val meta = fields + .get("meta") + .map(_.convertTo[Option[TextJson[Meta]]]) + .getOrElse(orig.meta) + + val startDate = fields + .get("startDate") + .map(_.convertTo[Option[LocalDate]]) + .getOrElse(orig.startDate) + + val endDate = fields + .get("endDate") + .map(_.convertTo[Option[LocalDate]]) + .getOrElse(orig.endDate) orig.copy( physician = physician.orElse(orig.physician), diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documentissue.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documentissue.scala index 9ba3614..28b2a5e 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documentissue.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documentissue.scala @@ -44,12 +44,6 @@ object documentissue { .map(_.convertTo[String]) .getOrElse(deserializationError(s"DocumentIssue json object does not contain `text` field: $json")) - val archiveRequired = fields - .get("archiveRequired") - .map(_.convertTo[Boolean]) - .getOrElse( - deserializationError(s"DocumentIssue json object does not contain `archiveRequired` field: $json")) - val startPage = fields.get("startPage").map(_.convertTo[Double]) val endPage = fields.get("endPage").map(_.convertTo[Double]) DocumentIssue( @@ -59,7 +53,7 @@ object documentissue { lastUpdate = LocalDateTime.MIN, isDraft = true, text = text, - archiveRequired = archiveRequired, + archiveRequired = false, startPage = startPage, endPage = endPage ) diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala index ab27b67..42473bc 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala @@ -21,7 +21,7 @@ object extracteddata { override def read(json: JsValue): TextJson[Meta] = TextJson(extractedDataMetaFormat.read(json)) } - implicit val extractedDataLabelFormat: RootJsonFormat[ExtractedDataLabel] = new RootJsonFormat[ExtractedDataLabel] { + implicit val extractedDataLabelWriter: JsonWriter[ExtractedDataLabel] = new JsonWriter[ExtractedDataLabel] { override def write(label: ExtractedDataLabel): JsObject = { JsObject( "id" -> label.labelId.toJson, @@ -29,59 +29,57 @@ object extracteddata { "value" -> label.value.toJson ) } + } - override def read(json: JsValue): ExtractedDataLabel = json match { - case JsObject(fields) => - val labelId = fields - .get("id") - .map(_.convertTo[LongId[Label]]) - - val categoryId = fields - .get("categoryId") - .map(_.convertTo[LongId[Category]]) - - val value = fields - .get("value") - .map(_.convertTo[FuzzyValue]) - - ExtractedDataLabel( - id = LongId(0), - dataId = LongId(0), - labelId = labelId, - categoryId = categoryId, - value = value - ) + def applyLabelsForExtractedData(json: JsValue, dataId: LongId[ExtractedData]): ExtractedDataLabel = json match { + case JsObject(fields) => + val labelId = fields + .get("id") + .map(_.convertTo[LongId[Label]]) + + val categoryId = fields + .get("categoryId") + .map(_.convertTo[LongId[Category]]) + + val value = fields + .get("value") + .map(_.convertTo[FuzzyValue]) + + ExtractedDataLabel( + id = LongId(0), + dataId = dataId, + labelId = labelId, + categoryId = categoryId, + value = value + ) - case _ => deserializationError(s"Expected Json Object as ExtractedDataLabel, but got $json") - } + case _ => deserializationError(s"Expected Json Object as ExtractedDataLabel, but got $json") } def applyUpdateToExtractedData(json: JsValue, orig: RichExtractedData): RichExtractedData = json match { case JsObject(fields) => - val keywordId = if (fields.contains("keywordId")) { - fields - .get("keywordId") - .map(_.convertTo[LongId[Keyword]]) - } else orig.extractedData.keywordId - - val evidence = if (fields.contains("evidence")) { - fields - .get("evidence") - .map(_.convertTo[String]) - } else orig.extractedData.evidenceText - - val meta = if (fields.contains("meta")) { - fields - .get("meta") - .map(_.convertTo[TextJson[Meta]]) - } else orig.extractedData.meta - - val labels = if (fields.contains("labels")) { - fields - .get("labels") - .map(_.convertTo[List[ExtractedDataLabel]]) - .getOrElse(List.empty[ExtractedDataLabel]) - } else orig.labels + val keywordId = fields + .get("keywordId") + .map(_.convertTo[Option[LongId[Keyword]]]) + .getOrElse(orig.extractedData.keywordId) + + val evidence = fields + .get("evidence") + .map(_.convertTo[Option[String]]) + .getOrElse(orig.extractedData.evidenceText) + + val meta = fields + .get("meta") + .map(_.convertTo[Option[TextJson[Meta]]]) + .getOrElse(orig.extractedData.meta) + + val labels = fields + .get("labels") + .map( + _.convertTo[Option[List[JsValue]]] + .getOrElse(List.empty[JsValue]) + .map(l => applyLabelsForExtractedData(l, orig.extractedData.id))) + .getOrElse(orig.labels) val extractedData = orig.extractedData.copy( keywordId = keywordId, @@ -105,7 +103,7 @@ object extracteddata { "keywordId" -> richData.extractedData.keywordId.toJson, "evidence" -> richData.extractedData.evidenceText.toJson, "meta" -> richData.extractedData.meta.toJson, - "labels" -> richData.labels.toJson + "labels" -> richData.labels.map(_.toJson).toJson ) override def read(json: JsValue): RichExtractedData = json match { @@ -130,8 +128,9 @@ object extracteddata { val labels = fields .get("labels") - .map(_.convertTo[List[ExtractedDataLabel]]) - .getOrElse(List.empty[ExtractedDataLabel]) + .map(_.convertTo[List[JsValue]]) + .getOrElse(List.empty[JsValue]) + .map(l => applyLabelsForExtractedData(l, LongId(0))) val extractedData = ExtractedData( documentId = documentId, diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala index ffe31cf..7d35bd1 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala @@ -23,8 +23,8 @@ object patientissue { } def jsValueToPatientIssue(json: JsValue, patientId: UuidId[Patient], userId: StringId[User]): PatientIssue = { - json.asJsObject.getFields("text", "archiveRequired") match { - case Seq(text, archiveRequired) => + json.asJsObject.getFields("text") match { + case Seq(text) => PatientIssue( id = LongId(0), userId = userId, @@ -32,7 +32,7 @@ object patientissue { lastUpdate = LocalDateTime.MIN, isDraft = true, text = text.convertTo[String], - archiveRequired = archiveRequired.convertTo[Boolean] + archiveRequired = false ) case _ => deserializationError(s"Expected Json Object as PatientIssue, but got $json") diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala index e29b9fd..3b52833 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala @@ -10,17 +10,15 @@ object patientlabel { def applyUpdateToPatientLabel(json: JsValue, orig: PatientLabel): PatientLabel = json match { case JsObject(fields) => - val primaryValue = if (fields.contains("primaryValue")) { - fields - .get("primaryValue") - .map(_.convertTo[FuzzyValue]) - } else orig.primaryValue + val primaryValue = fields + .get("primaryValue") + .map(_.convertTo[Option[FuzzyValue]]) + .getOrElse(orig.primaryValue) - val verifiedPrimaryValue = if (fields.contains("verifiedPrimaryValue")) { - fields - .get("verifiedPrimaryValue") - .map(_.convertTo[FuzzyValue]) - } else orig.verifiedPrimaryValue + val verifiedPrimaryValue = fields + .get("verifiedPrimaryValue") + .map(_.convertTo[Option[FuzzyValue]]) + .getOrElse(orig.verifiedPrimaryValue) orig.copy( primaryValue = primaryValue, @@ -56,7 +54,7 @@ object patientlabel { "evidenceText" -> evidence.evidenceText.toJson, "documentId" -> evidence.documentId.toJson, "evidenceId" -> evidence.evidenceId.toJson, - "reportId" -> evidence.isImplicitMatch.toJson, + "reportId" -> evidence.reportId.toJson, "documentType" -> evidence.documentType.toJson, "date" -> evidence.date.toJson, "providerType" -> evidence.providerType.toJson diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala index 352704a..e378dbd 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala @@ -6,6 +6,7 @@ import java.util.UUID import spray.json._ import xyz.driver.core.json.{EnumJsonFormat, GadtJsonFormat} import xyz.driver.pdsuicommon.domain.{LongId, TextJson, UuidId} +import xyz.driver.pdsuidomain.entities.MedicalRecord.Meta._ import xyz.driver.pdsuidomain.entities._ object record { @@ -43,12 +44,116 @@ object record { } } + implicit val duplicateMetaFormat: RootJsonFormat[Duplicate] = new RootJsonFormat[Duplicate] { + override def write(obj: Duplicate) = + JsObject( + "type" -> "duplicate".toJson, + "predicted" -> obj.predicted.toJson, + "startPage" -> obj.startPage.toJson, + "endPage" -> obj.endPage.toJson, + "startOriginalPage" -> obj.startOriginalPage.toJson, + "endOriginalPage" -> obj.endOriginalPage.toJson + ) + + override def read(json: JsValue): Duplicate = json match { + case JsObject(fields) => + val predicted = fields + .get("predicted") + .map(_.convertTo[Boolean]) + + val startPage = fields + .get("startPage") + .map(_.convertTo[Double]) + .getOrElse(deserializationError(s"Duplicate meta json object does not contain `startPage` field: $json")) + + val endPage = fields + .get("endPage") + .map(_.convertTo[Double]) + .getOrElse(deserializationError(s"Duplicate meta json object does not contain `endPage` field: $json")) + + val startOriginalPage = fields + .get("startOriginalPage") + .map(_.convertTo[Double]) + .getOrElse( + deserializationError(s"Duplicate meta json object does not contain `startOriginalPage` field: $json")) + + val endOriginalPage = fields + .get("endOriginalPage") + .map(_.convertTo[Double]) + + Duplicate( + predicted = predicted, + startPage = startPage, + endPage = endPage, + startOriginalPage = startOriginalPage, + endOriginalPage = endOriginalPage + ) + + case _ => deserializationError(s"Expected JsObject as Duplicate meta of medical record, but got $json") + } + } + + implicit val reorderMetaFormat: RootJsonFormat[Reorder] = new RootJsonFormat[Reorder] { + override def write(obj: Reorder) = + JsObject( + "type" -> "reorder".toJson, + "predicted" -> obj.predicted.toJson, + "items" -> obj.items.toJson + ) + + override def read(json: JsValue): Reorder = json match { + case JsObject(fields) => + val predicted = fields + .get("predicted") + .map(_.convertTo[Boolean]) + + val items = fields + .get("items") + .map(_.convertTo[Seq[Int]]) + .getOrElse(deserializationError(s"Reorder meta json object does not contain `items` field: $json")) + + Reorder( + predicted = predicted, + items = items + ) + + case _ => deserializationError(s"Expected JsObject as Reorder meta of medical record, but got $json") + } + } + + implicit val rotateMetaFormat: RootJsonFormat[Rotation] = new RootJsonFormat[Rotation] { + override def write(obj: Rotation) = + JsObject( + "type" -> "rotation".toJson, + "predicted" -> obj.predicted.toJson, + "items" -> obj.items.toJson + ) + + override def read(json: JsValue): Rotation = json match { + case JsObject(fields) => + val predicted = fields + .get("predicted") + .map(_.convertTo[Boolean]) + + val items = fields + .get("items") + .map(_.convertTo[Map[String, Int]]) + .getOrElse(deserializationError(s"Rotation meta json object does not contain `items` field: $json")) + + Rotation( + predicted = predicted, + items = items + ) + + case _ => deserializationError(s"Expected JsObject as Rotation meta of medical record, but got $json") + } + } + implicit val recordMetaTypeFormat: GadtJsonFormat[MedicalRecord.Meta] = { - import Meta._ - GadtJsonFormat.create[Meta]("meta")({ case m => m.metaType }) { - case "duplicate" => jsonFormat5(Duplicate.apply) - case "reorder" => jsonFormat2(Reorder.apply) - case "rotation" => jsonFormat2(Rotation.apply) + GadtJsonFormat.create[Meta]("type")({ case m => m.metaType }) { + case "duplicate" => duplicateMetaFormat + case "reorder" => reorderMetaFormat + case "rotation" => rotateMetaFormat } } @@ -120,11 +225,10 @@ object record { def applyUpdateToMedicalRecord(json: JsValue, orig: MedicalRecord): MedicalRecord = json match { case JsObject(fields) => - val meta = if (fields.contains("meta")) { - fields - .get("meta") - .map(_.convertTo[TextJson[List[Meta]]]) - } else orig.meta + val meta = fields + .get("meta") + .map(_.convertTo[Option[TextJson[List[Meta]]]]) + .getOrElse(orig.meta) orig.copy(meta = meta) case _ => deserializationError(s"Expected Json Object as partial MedicalRecord, but got $json") diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/recordissue.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/recordissue.scala index 9e23b8a..4ae04d0 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/recordissue.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/recordissue.scala @@ -46,12 +46,6 @@ object recordissue { .map(_.convertTo[String]) .getOrElse(deserializationError(s"MedicalRecordIssue json object does not contain `text` field: $json")) - val archiveRequired = fields - .get("archiveRequired") - .map(_.convertTo[Boolean]) - .getOrElse( - deserializationError(s"MedicalRecordIssue json object does not contain `archiveRequired` field: $json")) - val startPage = fields.get("startPage").map(_.convertTo[Double]) val endPage = fields.get("endPage").map(_.convertTo[Double]) MedicalRecordIssue( @@ -61,7 +55,7 @@ object recordissue { lastUpdate = LocalDateTime.MIN, isDraft = true, text = text, - archiveRequired = archiveRequired, + archiveRequired = false, startPage = startPage, endPage = endPage ) diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiDocumentSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiDocumentSuite.scala deleted file mode 100644 index d9d62dd..0000000 --- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiDocumentSuite.scala +++ /dev/null @@ -1,78 +0,0 @@ -package xyz.driver.pdsuidomain.formats.json - -/* -import java.time.LocalDateTime - -import org.scalatest.FreeSpecLike -import play.api.libs.json.Json - -import scala.collection.breakOut - -class ApiDocumentSuite extends FreeSpecLike { - - "ApiDocument" - { - "conforms to specification when serialized" in { - val document = ApiDocument( - id = 1L, - recordId = 123L, - physician = Some("physician"), - lastUpdate = LocalDateTime.now(), - `type` = "some-type", - startDate = LocalDateTime.now(), - endDate = Some(LocalDateTime.now()), - provider = "test-provider", - providerType = "test-provider-type", - status = "New", - assignee = Some(5L), - previousAssignee = None, - meta = "{}" - ) - - val actualJson = serialize(document) - val matcher = - """^\{ - |"id":"[^"]+", - |"recordId":"[^"]+", - |"physician":"[^"]+", - |"lastUpdate":"[^"]+", - |"type":"[^"]+", - |"startDate":"[^"]+", - |"endDate":"[^"]+", - |"provider":"[^"]+", - |"providerType":"[^"]+", - |"status":"[^"]+", - |"assignee":"[^"]+", - |"meta":\{[^\}]*\} - |\}""".stripMargin.lines.mkString.r - - assert( - matcher.pattern.matcher(actualJson).matches(), - s"""see https://driverinc.atlassian.net/wiki/display/RA/REST+API+Specification#RESTAPISpecification-DocumentObject - |pattern = ${matcher.pattern} - |json = $actualJson""".stripMargin - ) - } - - "has optional fields according to specification" in { - val expectedOptionalFields = Set("physician", "endDate", "assignee", "previousAssignee") - - val klass = classOf[ApiDocument] - val actualOptionalFields: Set[String] = klass.getDeclaredFields.collect({ - case x if x.getType == classOf[Option[_]] => x.getName - })(breakOut) - - assert( - actualOptionalFields === expectedOptionalFields, - """actual vs expected - |see https://driverinc.atlassian.net/wiki/display/RA/REST+API+Specification#RESTAPISpecification-DocumentObject - """.stripMargin.trim - ) - } - } - - private def serialize(document: ApiDocument): String = { - Json.stringify(Json.toJson(document)) - } - -} - */ diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiPartialDocumentSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiPartialDocumentSuite.scala deleted file mode 100644 index 2ae52f9..0000000 --- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/ApiPartialDocumentSuite.scala +++ /dev/null @@ -1,263 +0,0 @@ -package xyz.driver.pdsuidomain.formats.json - -/* -import java.time.LocalDateTime - -import xyz.driver.pdsuicommon.domain._ -import org.davidbild.tristate.Tristate -import org.scalatest.FreeSpecLike -import play.api.libs.json.Json - -class ApiPartialDocumentSuite extends FreeSpecLike { - - "serialization" - { - "can be deserialized" in deserialize(defaultJson) - - "endDate" - { - def jsonWithEndDate(rawValue: String) = json("endDate" -> rawValue) - def jsonWithoutEndDate = json() - - "when specified" - { - "if non-empty object - should be parsed as date" in { - val rawEndDate = "2007-12-03T10:15:30.000" - val apiPartialEntity = deserialize(jsonWithEndDate(quoted(rawEndDate))) - assert(apiPartialEntity.endDate.exists(_ == LocalDateTime.parse(rawEndDate))) - } - - "if null - should be parsed as Absent" in { - val apiPartialEntity = deserialize(jsonWithEndDate("null")) - assert(apiPartialEntity.endDate.isAbsent) - } - } - - "when unspecified - should be parsed as Unspecified" in { - val apiPartialEntity = deserialize(jsonWithoutEndDate) - assert(apiPartialEntity.endDate.isUnspecified) - } - } - - "assignee" - { - def jsonWithAssignee(rawValue: String) = json("assignee" -> rawValue) - def jsonWithoutAssignee = json() - - "when specified" - { - "if non-empty object - should be parsed as UUID" in { - val rawAssignee = 123 - val apiPartialEntity = deserialize(jsonWithAssignee(quoted(rawAssignee.toString))) - assert(apiPartialEntity.assignee.exists(_ == rawAssignee)) - } - - "if null - should be parsed as Absent" in { - val apiPartialEntity = deserialize(jsonWithAssignee("null")) - assert(apiPartialEntity.assignee.isAbsent) - } - } - - "when unspecified - should be parsed as Unspecified" in { - val apiPartialEntity = deserialize(jsonWithoutAssignee) - assert(apiPartialEntity.assignee.isUnspecified) - } - } - - "meta" - { - def jsonWithMeta(rawValue: String) = json("meta" -> rawValue) - def jsonWithoutMeta = json() - - "when specified" - { - "if non-empty object - should be parsed as normalized JSON-string" in { - val apiPartialEntity = deserialize(jsonWithMeta(""" { "foo" : 1} """)) - assert(apiPartialEntity.meta.exists(_ == """{"foo":1}""")) - } - - "if null - should be parsed as Absent" in { - val apiPartialEntity = deserialize(jsonWithMeta("null")) - assert(apiPartialEntity.meta.isAbsent) - } - - "if empty object ({}) - should be parsed as Absent (same as null case)" in { - val apiPartialEntity = deserialize(jsonWithMeta(" { } ")) - assert(apiPartialEntity.meta.isAbsent) - } - } - - "when unspecified - should be parsed as Unspecified" in { - val apiPartialEntity = deserialize(jsonWithoutMeta) - assert(apiPartialEntity.meta.isUnspecified) - } - } - - def deserialize(json: String): ApiPartialDocument = { - Json.parse(json).as[ApiPartialDocument] - } - } - - "applyTo" - { - "endDate" - { - "should choose a value of the api partial document" - { - "if it present" in test(Tristate.Present(LocalDateTime.now().plusDays(1))) - "if it absent" in test(Tristate.Absent) - - def test(newEndDate: Tristate[LocalDateTime]): Unit = { - val origDocument = documentExample - val apiPartialDocument = apiPartialDocumentExample.copy(endDate = newEndDate) - - val newDocument = apiPartialDocument.applyTo(origDocument) - assert(newDocument.endDate === newEndDate.toOption) - } - } - - "should choose a value of the original document if it unspecified" in { - val newEndDate = Tristate.Unspecified - val origDocument = documentExample - val apiPartialDocument = apiPartialDocumentExample.copy(endDate = newEndDate) - - val newDocument = apiPartialDocument.applyTo(origDocument) - assert(newDocument.endDate == origDocument.endDate) - } - } - - "assignee" - { - "should choose a value of the api partial document" - { - "if it present" in test(Tristate.Present(123)) - "if it absent" in test(Tristate.Absent) - - def test(newAssignee: Tristate[Long]): Unit = { - val origDocument = documentExample - val apiPartialDocument = apiPartialDocumentExample.copy(assignee = newAssignee) - - val newDocument = apiPartialDocument.applyTo(origDocument) - assert(newDocument.assignee === newAssignee.toOption.map(StringId[User])) - } - } - - "should choose a value of the original document if it unspecified" in { - val newAssignee = Tristate.Unspecified - val origDocument = documentExample - val apiPartialDocument = apiPartialDocumentExample.copy(assignee = newAssignee) - - val newDocument = apiPartialDocument.applyTo(origDocument) - assert(newDocument.assignee == origDocument.assignee) - } - } - - /*"meta" - { - val documentId = Id[Document]() - def test(origMeta: Option[RawMeta], metaUpdate: Tristate[String], expectedNewMeta: Option[RawMeta]): Unit = { - val apiPartialDocument = apiPartialDocumentExample.copy(meta = metaUpdate) - - val actualNewMeta = apiPartialDocument.applyTo(documentId, origMeta) - assert(actualNewMeta == expectedNewMeta) - } - - "should choose a new meta's value" - { - "if it present" - { - "when original meta is present" in test( - origMeta = Some(RawMeta(documentId, """{"foo":42}""")), - metaUpdate = Tristate.Present("""{"bar":1}"""), - expectedNewMeta = Some(RawMeta(documentId, """{"bar":1}""")) - ) - - "when original meta is absent" in test( - origMeta = None, - metaUpdate = Tristate.Present("""{"bar":1}"""), - expectedNewMeta = Some(RawMeta(documentId, """{"bar":1}""")) - ) - } - - "if it absent" - { - "when original meta is present" in test( - origMeta = Some(RawMeta(documentId, """{"foo":42}""")), - metaUpdate = Tristate.Absent, - expectedNewMeta = None - ) - - "when original meta is absent" in test( - origMeta = None, - metaUpdate = Tristate.Absent, - expectedNewMeta = None - ) - } - } - - "should choose an original meta if a new one is unspecified" - { - "when original meta is present" in test( - origMeta = Some(RawMeta(documentId, """{"foo":42}""")), - metaUpdate = Tristate.Unspecified, - expectedNewMeta = Some(RawMeta(documentId, """{"foo":42}""")) - ) - - "when original meta is absent" in test( - origMeta = None, - metaUpdate = Tristate.Unspecified, - expectedNewMeta = None - ) - } - }*/ - } - - private def documentExample = Document( - id = LongId(1), - status = Document.Status.Organized, - assignee = Some(LongId(1)), - previousAssignee = None, - recordId = LongId(1), - physician = None, - documentType = "type", - providerName = "provider name", - providerType = "provider type", - meta = None, - startDate = LocalDateTime.now, - endDate = None, - lastUpdate = LocalDateTime.now - ) - - private def apiPartialDocumentExample = ApiPartialDocument( - recordId = Some(12), - physician = Some("new physician"), - `type` = Some("new type"), - startDate = Some(LocalDateTime.now), - endDate = Tristate.Present(LocalDateTime.now), - provider = Some("new provider name"), - providerType = Some("new provider type"), - status = Some("Extracted"), - assignee = Tristate.Present(13), - meta = Tristate.Present("""{"foo":42}""") - ) - - private def quoted(v: String): String = s""""$v"""" - - private def defaultJson = json( - "endDate" -> quoted("2007-12-03T10:15:30.000"), - "assignee" -> quoted("c8b1b818-e1eb-4831-b0c8-26753b109deb"), - "meta" -> """{"foo": 1}""" - ) - - /** - * Without fields: - * - endDate - * - assignee - * - meta - */ - private def json(addFields: (String, String)*): String = { - val addJson = addFields - .collect { - case (k, v) if v.nonEmpty => s""" "$k": $v """ - } - .mkString(",\n") - - s"""{ - |"recordId":"bc542d3d-a928-42b8-824d-ca1520b07500", - |"patientId":"foobar", - |"caseId":"bazquux", - |"physician":"zed", - |"lastUpdate":"2007-12-03T10:15:30.000", - |"type":"type1", - |"startDate":"2007-10-01T09:40:00.000", - |"provider":"some provider name", - |"providerType":"some provider type", - |"status":"New"${if (addJson.isEmpty) "" else ","} - |$addJson - |}""".stripMargin - } -} - */ 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 new file mode 100644 index 0000000..e7d37a0 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatSuite.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.Arm + +class ArmFormatSuite extends FlatSpec with Matchers { + import arm._ + + "Json format for Arm" should "read and write correct JSON" in { + val arm = Arm( + id = LongId(10), + trialId = StringId("NCT000001"), + name = "arm name", + originalName = "orig arm name" + ) + val writtenJson = armFormat.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 = 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 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/ArmFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.scala deleted file mode 100644 index 4a4b3c4..0000000 --- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ArmFormatTestSuite.scala +++ /dev/null @@ -1,36 +0,0 @@ -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 - -class ArmFormatTestSuite extends FlatSpec with Matchers { - import arm._ - - "Json format for Arm" should "read and write correct JSON" in { - val arm = Arm( - id = LongId(10), - trialId = StringId("NCT000001"), - name = "arm name", - originalName = "orig arm name" - ) - val writtenJson = armFormat.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 = 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 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/CriterionFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala new file mode 100644 index 0000000..d24c4c1 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala @@ -0,0 +1,68 @@ +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.services.CriterionService.RichCriterion + +class CriterionFormatSuite extends FlatSpec with Matchers { + import criterion._ + + "Json format for Criterion" should "read and write correct JSON" in { + val criterion = Criterion( + id = LongId(10), + trialId = StringId("NCT000001"), + text = Some("text"), + isCompound = false, + meta = "{}" + ) + val labels = List( + CriterionLabel( + id = LongId(1L), + labelId = Some(LongId(101)), + criterionId = criterion.id, + categoryId = Some(LongId(3)), + value = Some(true), + isDefining = true + ), + CriterionLabel( + id = LongId(2L), + labelId = Some(LongId(102)), + criterionId = criterion.id, + categoryId = Some(LongId(3)), + value = Some(false), + isDefining = true + ) + ) + val arms = List(LongId[Arm](20), LongId[Arm](21), LongId[Arm](21)) + val richCriterion = RichCriterion( + criterion = criterion, + armIds = arms, + labels = labels + ) + val writtenJson = richCriterionFormat.write(richCriterion) + + writtenJson should be( + """{"text":"text","isCompound":false,"trialId":"NCT000001","arms":[20,21,21],"id":10,"meta":"{}", + "labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true}, + {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson) + + val createCriterionJson = + """{"text":"text","isCompound":false,"trialId":"NCT000001", + "arms":[20,21,21],"meta":"{}","labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true}, + {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson + val parsedRichCriterion = richCriterionFormat.read(createCriterionJson) + val expectedRichCriterion = richCriterion.copy( + criterion = criterion.copy(id = LongId(0)), + labels = labels.map(_.copy(id = LongId(0), criterionId = LongId(0))) + ) + parsedRichCriterion should be(expectedRichCriterion) + + val updateCriterionJson = """{"meta":null,"text":"new text","isCompound":true}""".parseJson + val expectedUpdatedCriterion = richCriterion.copy(criterion = criterion.copy(text = Some("new text"), isCompound = true, meta = "{}")) + val parsedUpdateCriterion = applyUpdateToCriterion(updateCriterionJson, richCriterion) + parsedUpdateCriterion should be(expectedUpdatedCriterion) + } + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala deleted file mode 100644 index 0167620..0000000 --- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatTestSuite.scala +++ /dev/null @@ -1,68 +0,0 @@ -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.services.CriterionService.RichCriterion - -class CriterionFormatTestSuite extends FlatSpec with Matchers { - import criterion._ - - "Json format for Criterion" should "read and write correct JSON" in { - val criterion = Criterion( - id = LongId(10), - trialId = StringId("NCT000001"), - text = Some("text"), - isCompound = false, - meta = "{}" - ) - val labels = List( - CriterionLabel( - id = LongId(1L), - labelId = Some(LongId(101)), - criterionId = criterion.id, - categoryId = Some(LongId(3)), - value = Some(true), - isDefining = true - ), - CriterionLabel( - id = LongId(2L), - labelId = Some(LongId(102)), - criterionId = criterion.id, - categoryId = Some(LongId(3)), - value = Some(false), - isDefining = true - ) - ) - val arms = List(LongId[Arm](20), LongId[Arm](21), LongId[Arm](21)) - val richCriterion = RichCriterion( - criterion = criterion, - armIds = arms, - labels = labels - ) - val writtenJson = richCriterionFormat.write(richCriterion) - - writtenJson should be( - """{"text":"text","isCompound":false,"trialId":"NCT000001","arms":[20,21,21],"id":10,"meta":"{}", - "labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true}, - {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson) - - val createCriterionJson = - """{"text":"text","isCompound":false,"trialId":"NCT000001", - "arms":[20,21,21],"meta":"{}","labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true}, - {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson - val parsedRichCriterion = richCriterionFormat.read(createCriterionJson) - val expectedRichCriterion = richCriterion.copy( - criterion = criterion.copy(id = LongId(0)), - labels = labels.map(_.copy(id = LongId(0), criterionId = LongId(0))) - ) - parsedRichCriterion should be(expectedRichCriterion) - - val updateCriterionJson = """{"meta":null,"text":"new text","isCompound":true}""".parseJson - val expectedUpdatedCriterion = richCriterion.copy(criterion = criterion.copy(text = Some("new text"), isCompound = true, meta = "{}")) - val parsedUpdateCriterion = applyUpdateToCriterion(updateCriterionJson, richCriterion) - parsedUpdateCriterion should be(expectedUpdatedCriterion) - } - -} 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 new file mode 100644 index 0000000..9394735 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentFormatSuite.scala @@ -0,0 +1,74 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.{LocalDate, LocalDateTime} + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, TextJson} +import xyz.driver.pdsuidomain.entities.Document + +class DocumentFormatSuite extends FlatSpec with Matchers { + import document._ + + "Json format for Document" should "read and write correct JSON" in { + val orig = Document( + id = LongId(1), + status = Document.Status.New, + assignee = None, + previousStatus = None, + previousAssignee = None, + lastActiveUserId = None, + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"), + recordId = LongId(101), + physician = Some("physician"), + typeId = Some(LongId(10)), + providerName = Some("provider 21"), + providerTypeId = Some(LongId(21)), + requiredType = Some(Document.RequiredType.OPN), + meta = None, + startDate = None, + endDate = None + ) + val writtenJson = documentFormat.write(orig) + + 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) + + val createDocumentJson = + """{"recordId":101,"physician":"physician","typeId":10,"provider":"provider 21","providerTypeId":21}""".parseJson + val expectedCreatedDocument = orig.copy( + id = LongId(0), + lastUpdate = LocalDateTime.MIN, + requiredType = None + ) + val parsedCreatedDocument = documentFormat.read(createDocumentJson) + parsedCreatedDocument should be(expectedCreatedDocument) + + val updateDocumentJson = + """{"startDate":"2017-08-10","endDate":"2018-08-10","meta":{"predicted":true,"startPage":1.0,"endPage":2.0}}""".parseJson + val expectedUpdatedDocument = orig.copy( + startDate = Some(LocalDate.parse("2017-08-10")), + endDate = Some(LocalDate.parse("2018-08-10")), + meta = Some(TextJson(Document.Meta(predicted = Some(true), startPage = 1.0, endPage = 2.0))) + ) + val parsedUpdatedDocument = applyUpdateToDocument(updateDocumentJson, orig) + parsedUpdatedDocument should be(expectedUpdatedDocument) + } + + "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 writtenJson = documentMetaFormat.write(meta) + writtenJson should be ("""{"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 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 new file mode 100644 index 0000000..ddbda1d --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentHistoryFormatSuite.scala @@ -0,0 +1,32 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId} +import xyz.driver.pdsuidomain.entities.DocumentHistory + +class DocumentHistoryFormatSuite extends FlatSpec with Matchers { + import documenthistory._ + + "Json format for DocumentHistory" should "read and write correct JSON" in { + val documentHistory = DocumentHistory( + id = LongId(10), + documentId = LongId(1), + executor = StringId("userId-001"), + state = DocumentHistory.State.Extract, + action = DocumentHistory.Action.Start, + created = LocalDateTime.parse("2017-08-10T18:00:00") + ) + val writtenJson = documentHistoryFormat.write(documentHistory) + + 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) + parsedDocumentHistory should be(documentHistory) + } + +} 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 new file mode 100644 index 0000000..1a8e3f0 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/DocumentIssueFormatSuite.scala @@ -0,0 +1,47 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId} +import xyz.driver.pdsuidomain.entities.DocumentIssue + +class DocumentIssueFormatSuite extends FlatSpec with Matchers { + import documentissue._ + + "Json format for DocumentIssue" should "read and write correct JSON" in { + val documentIssue = DocumentIssue( + id = LongId(10), + documentId = LongId(1), + userId = StringId("userId-001"), + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"), + isDraft = false, + text = "message text", + archiveRequired = false, + startPage = Some(1.0), + endPage = Some(2.0) + ) + val writtenJson = documentIssueWriter.write(documentIssue) + + writtenJson should be( + """{"id":10,"userId":"userId-001","lastUpdate":"2017-08-10T18:00Z","isDraft":false, + "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 parsedCreateDocumentIssue = jsValueToDocumentIssue(createDocumentIssueJson, LongId(1), StringId("userId-001")) + parsedCreateDocumentIssue should be(expectedCreatedDocumentIssue) + + val updateDocumentIssueJson = + """{"text":"new issue text","evidence":"issue evidence","archiveRequired":true,"startPage":1.0,"endPage":4.0}""".parseJson + val expectedUpdatedDocumentIssue = documentIssue.copy( + text = "new issue text", + archiveRequired = true, + endPage = Some(4.0) + ) + val parsedUpdateDocumentIssue = applyUpdateToDocumentIssue(updateDocumentIssueJson, documentIssue) + parsedUpdateDocumentIssue should be(expectedUpdatedDocumentIssue) + } + +} 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 new file mode 100644 index 0000000..a4b8bab --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExtractedDataFormatSuite.scala @@ -0,0 +1,95 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, TextJson} +import xyz.driver.pdsuidomain.entities.ExtractedData.Meta +import xyz.driver.pdsuidomain.entities.{ExtractedData, ExtractedDataLabel} +import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData + +class ExtractedDataFormatSuite extends FlatSpec with Matchers { + import extracteddata._ + + "Json format for ExtractedData" should "read and write correct JSON" in { + val extractedData = ExtractedData( + id = LongId(1), + documentId = LongId(101), + keywordId = Some(LongId(201)), + evidenceText = Some("evidence text"), + meta = None + ) + val extractedDataLabels = List( + ExtractedDataLabel( + id = LongId(1), + dataId = extractedData.id, + labelId = None, + categoryId = None, + value = Some(FuzzyValue.Yes) + ), + ExtractedDataLabel( + id = LongId(2), + dataId = extractedData.id, + labelId = Some(LongId(12)), + categoryId = Some(LongId(1)), + value = Some(FuzzyValue.No) + ) + ) + val origRichExtractedData = RichExtractedData( + extractedData = extractedData, + labels = extractedDataLabels + ) + val writtenJson = extractedDataFormat.write(origRichExtractedData) + + 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) + + val createExtractedDataJson = + """{"documentId":101,"keywordId":201,"evidence":"evidence text", + "labels":[{"value":"Yes"},{"id":12,"categoryId":1,"value":"No"}]}""".parseJson + val expectedCreatedExtractedData = origRichExtractedData.copy( + extractedData = extractedData.copy(id = LongId(0)), + labels = extractedDataLabels.map(_.copy(id = LongId(0), dataId = LongId(0))) + ) + val parsedCreatedExtractedData = extractedDataFormat.read(createExtractedDataJson) + parsedCreatedExtractedData should be(expectedCreatedExtractedData) + + val updateExtractedDataJson = + """{"evidence":"new evidence text","meta":{"keyword":{"page":1,"index":2,"sortIndex":"ASC"}, + "evidence":{"pageRatio":1.0,"start":{"page":1,"index":3,"offset":2},"end":{"page":2,"index":3,"offset":10}}}, + "labels":[{"id":20,"categoryId":1,"value":"Yes"},{"id":12,"categoryId":1,"value":"No"}]}""".parseJson + val updatedExtractedDataLabels = List( + ExtractedDataLabel( + id = LongId(0), + dataId = extractedData.id, + labelId = Some(LongId(20)), + categoryId = Some(LongId(1)), + value = Some(FuzzyValue.Yes) + ), + ExtractedDataLabel( + id = LongId(0), + dataId = extractedData.id, + labelId = Some(LongId(12)), + categoryId = Some(LongId(1)), + value = Some(FuzzyValue.No) + ) + ) + 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) + ) + ))) + ), + labels = updatedExtractedDataLabels + ) + val parsedUpdatedExtractedData = applyUpdateToExtractedData(updateExtractedDataJson, origRichExtractedData) + parsedUpdatedExtractedData should be(expectedUpdatedExtractedData) + } + +} 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 new file mode 100644 index 0000000..784a655 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatSuite.scala @@ -0,0 +1,63 @@ +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.{Intervention, InterventionArm, InterventionType, InterventionWithArms} + +class InterventionFormatSuite extends FlatSpec with Matchers { + import intervention._ + + "Json format for Intervention" should "read and write correct JSON" in { + val intervention = Intervention( + id = LongId(1), + trialId = StringId("NCT000001"), + name = "intervention name", + originalName = "orig name", + typeId = Some(LongId(10)), + originalType = Some("orig type"), + description = "", + originalDescription = "", + isActive = true + ) + val arms = List( + InterventionArm(interventionId = intervention.id, armId = LongId(20)), + InterventionArm(interventionId = intervention.id, armId = LongId(21)), + InterventionArm(interventionId = intervention.id, armId = LongId(22)) + ) + val orig = InterventionWithArms( + intervention = intervention, + arms = arms + ) + val writtenJson = interventionWriter.write(orig) + + writtenJson should be( + """{"id":1,"name":"intervention name","typeId":10,"description":"","isActive":true,"arms":[20,21,22], + "trialId":"NCT000001","originalName":"orig name","originalDescription":"","originalType":"orig type"}""".parseJson) + + val updateInterventionJson = """{"description":"descr","arms":[21,22]}""".parseJson + val expectedUpdatedIntervention = orig.copy( + intervention = intervention.copy(description = "descr"), + arms = List( + InterventionArm(interventionId = intervention.id, armId = LongId(21)), + InterventionArm(interventionId = intervention.id, armId = LongId(22)) + ) + ) + val parsedUpdateIntervention = applyUpdateToInterventionWithArms(updateInterventionJson, orig) + parsedUpdateIntervention should be(expectedUpdatedIntervention) + } + + "Json format for InterventionType" should "read and write correct JSON" in { + val interventionType = InterventionType( + id = LongId(10), + name = "type name" + ) + val writtenJson = interventionTypeFormat.write(interventionType) + + writtenJson should be("""{"id":10,"name":"type name"}""".parseJson) + + val parsedInterventionType = interventionTypeFormat.read(writtenJson) + parsedInterventionType should be(interventionType) + } + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala deleted file mode 100644 index 280b2a7..0000000 --- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/InterventionFormatTestSuite.scala +++ /dev/null @@ -1,63 +0,0 @@ -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.{Intervention, InterventionArm, InterventionType, InterventionWithArms} - -class InterventionFormatTestSuite extends FlatSpec with Matchers { - import intervention._ - - "Json format for Intervention" should "read and write correct JSON" in { - val intervention = Intervention( - id = LongId(1), - trialId = StringId("NCT000001"), - name = "intervention name", - originalName = "orig name", - typeId = Some(LongId(10)), - originalType = Some("orig type"), - description = "", - originalDescription = "", - isActive = true - ) - val arms = List( - InterventionArm(interventionId = intervention.id, armId = LongId(20)), - InterventionArm(interventionId = intervention.id, armId = LongId(21)), - InterventionArm(interventionId = intervention.id, armId = LongId(22)) - ) - val orig = InterventionWithArms( - intervention = intervention, - arms = arms - ) - val writtenJson = interventionWriter.write(orig) - - writtenJson should be( - """{"id":1,"name":"intervention name","typeId":10,"description":"","isActive":true,"arms":[20,21,22], - "trialId":"NCT000001","originalName":"orig name","originalDescription":"","originalType":"orig type"}""".parseJson) - - val updateInterventionJson = """{"description":"descr","arms":[21,22]}""".parseJson - val expectedUpdatedIntervention = orig.copy( - intervention = intervention.copy(description = "descr"), - arms = List( - InterventionArm(interventionId = intervention.id, armId = LongId(21)), - InterventionArm(interventionId = intervention.id, armId = LongId(22)) - ) - ) - val parsedUpdateIntervention = applyUpdateToInterventionWithArms(updateInterventionJson, orig) - parsedUpdateIntervention should be(expectedUpdatedIntervention) - } - - "Json format for InterventionType" should "read and write correct JSON" in { - val interventionType = InterventionType( - id = LongId(10), - name = "type name" - ) - val writtenJson = interventionTypeFormat.write(interventionType) - - writtenJson should be("""{"id":10,"name":"type name"}""".parseJson) - - val parsedInterventionType = interventionTypeFormat.read(writtenJson) - parsedInterventionType should be(interventionType) - } - -} 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 new file mode 100644 index 0000000..899e5c9 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordFormatSuite.scala @@ -0,0 +1,77 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime +import java.util.UUID + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, TextJson, UuidId} +import xyz.driver.pdsuidomain.entities.{MedicalRecord, RecordRequestId} + +class MedicalRecordFormatSuite extends FlatSpec with Matchers { + import record._ + import MedicalRecord._ + + "Json format for MedicalRecord" should "read and write correct JSON" in { + val orig = MedicalRecord( + id = LongId(1), + status = Status.New, + assignee = None, + previousStatus = None, + previousAssignee = None, + lastActiveUserId = None, + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"), + physician = Some("physician"), + meta = None, + predictedMeta = None, + predictedDocuments = None, + disease = "Breast", + requestId = RecordRequestId(UUID.fromString("7b54a75d-4197-4b27-9045-b9b6cb131be9")), + caseId = None, + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343") + ) + val writtenJson = recordFormat.write(orig) + + 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) + + val createRecordJson = + """{"disease":"Breast","patientId":"748b5884-3528-4cb9-904b-7a8151d6e343","requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9"}""".parseJson + val expectedCreatedRecord = MedicalRecord( + id = LongId(0), + status = MedicalRecord.Status.New, + previousStatus = None, + assignee = None, + previousAssignee = None, + lastActiveUserId = None, + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + requestId = RecordRequestId(UUID.fromString("7b54a75d-4197-4b27-9045-b9b6cb131be9")), + disease = "Breast", + caseId = None, + physician = None, + meta = None, + predictedMeta = None, + predictedDocuments = None, + lastUpdate = LocalDateTime.now() + ) + val parsedCreatedRecord = recordFormat.read(createRecordJson).copy(lastUpdate = expectedCreatedRecord.lastUpdate) + parsedCreatedRecord should be(expectedCreatedRecord) + + val updateRecordJson = + """{"meta":[{"type":"duplicate","predicted":true,"startPage":1.0,"endPage":2.0,"startOriginalPage":1.0}, + {"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)) + ))) + ) + 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 new file mode 100644 index 0000000..5cd6c8d --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordHistoryFormatSuite.scala @@ -0,0 +1,32 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId} +import xyz.driver.pdsuidomain.entities.MedicalRecordHistory + +class MedicalRecordHistoryFormatSuite extends FlatSpec with Matchers { + import recordhistory._ + + "Json format for MedicalRecordHistory" should "read and write correct JSON" in { + val recordHistory = MedicalRecordHistory( + id = LongId(10), + recordId = LongId(1), + executor = StringId("userId-001"), + state = MedicalRecordHistory.State.Clean, + action = MedicalRecordHistory.Action.Start, + created = LocalDateTime.parse("2017-08-10T18:00:00") + ) + val writtenJson = recordHistoryFormat.write(recordHistory) + + 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) + parsedRecordHistory should be(recordHistory) + } + +} 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 new file mode 100644 index 0000000..9b89c97 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/MedicalRecordIssueFormatSuite.scala @@ -0,0 +1,47 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId} +import xyz.driver.pdsuidomain.entities.MedicalRecordIssue + +class MedicalRecordIssueFormatSuite extends FlatSpec with Matchers { + import recordissue._ + + "Json format for MedicalRecordIssue" should "read and write correct JSON" in { + val recordIssue = MedicalRecordIssue( + id = LongId(10), + recordId = LongId(1), + userId = StringId("userId-001"), + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"), + isDraft = false, + text = "message text", + archiveRequired = false, + startPage = Some(1.0), + endPage = Some(2.0) + ) + val writtenJson = recordIssueWriter.write(recordIssue) + + writtenJson should be( + """{"id":10,"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 expectedCreatedRecordIssue = recordIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true) + val parsedCreateRecordIssue = jsValueToRecordIssue(createRecordIssueJson, LongId(1), StringId("userId-001")) + parsedCreateRecordIssue should be(expectedCreatedRecordIssue) + + val updateRecordIssueJson = + """{"text":"new issue text","evidence":"issue evidence","archiveRequired":true,"startPage":1.0,"endPage":4.0}""".parseJson + val expectedUpdatedRecordIssue = recordIssue.copy( + text = "new issue text", + archiveRequired = true, + endPage = Some(4.0) + ) + val parsedUpdateRecordIssue = applyUpdateToRecordIssue(updateRecordIssueJson, recordIssue) + parsedUpdateRecordIssue should be(expectedUpdatedRecordIssue) + } + +} 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 new file mode 100644 index 0000000..2761d6a --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientFormatSuite.scala @@ -0,0 +1,36 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.{LocalDate, LocalDateTime} + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.UuidId +import xyz.driver.pdsuidomain.entities.{Patient, PatientOrderId} + +class PatientFormatSuite extends FlatSpec with Matchers { + import patient._ + + "Json format for Patient" should "read and write correct JSON" in { + val orig = Patient( + id = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + status = Patient.Status.New, + name = "John Doe", + dob = LocalDate.parse("1980-06-30"), + assignee = None, + previousStatus = None, + previousAssignee = None, + lastActiveUserId = None, + isUpdateRequired = false, + condition = "breast", + orderId = PatientOrderId("7b54a75d-4197-4b27-9045-b9b6cb131be9"), + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00") + ) + val writtenJson = patientWriter.write(orig) + + 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/PatientHistoryFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHistoryFormatSuite.scala new file mode 100644 index 0000000..c6a5a9f --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHistoryFormatSuite.scala @@ -0,0 +1,32 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId} +import xyz.driver.pdsuidomain.entities.PatientHistory + +class PatientHistoryFormatSuite extends FlatSpec with Matchers { + import patienthistory._ + + "Json format for PatientHistory" should "read and write correct JSON" in { + val patientHistory = PatientHistory( + id = LongId(10), + patientId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), + executor = StringId("userId-001"), + state = PatientHistory.State.Verify, + action = PatientHistory.Action.Start, + created = LocalDateTime.parse("2017-08-10T18:00:00") + ) + val writtenJson = patientHistoryFormat.write(patientHistory) + + writtenJson should be( + """{"id":10,"executor":"userId-001","patientId":"40892a07-c638-49d2-9795-1edfefbbcc7c","state":"Verify", + "action":"Start","created":"2017-08-10T18:00Z"}""".parseJson) + + val parsedPatientHistory = patientHistoryFormat.read(writtenJson) + parsedPatientHistory should be(patientHistory) + } + +} 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 new file mode 100644 index 0000000..2999cc1 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientHypothesisFormatSuite.scala @@ -0,0 +1,31 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.UuidId +import xyz.driver.pdsuidomain.entities.PatientHypothesis + +class PatientHypothesisFormatSuite extends FlatSpec with Matchers { + import patienthypothesis._ + + "Json format for PatientHypothesis" should "read and write correct JSON" in { + val orig = PatientHypothesis( + id = UuidId("815d9715-1089-4775-b120-3afb983b9a97"), + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + hypothesisId = UuidId("e76e2fc4-a29c-44fb-a81b-8856d06bb1d4"), + rationale = None, + matchedTrials = 1 + ) + val writtenJson = patientHypothesisWriter.write((orig, true)) + + 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 expectedUpdatedPatientHypothesis = orig.copy(rationale = Some("rationale")) + 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 new file mode 100644 index 0000000..1e2a11e --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientIssueFormatSuite.scala @@ -0,0 +1,44 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId} +import xyz.driver.pdsuidomain.entities.PatientIssue + +class PatientIssueFormatSuite extends FlatSpec with Matchers { + import patientissue._ + + "Json format for PatientIssue" should "read and write correct JSON" in { + val patientIssue = PatientIssue( + id = LongId(10), + patientId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), + userId = StringId("userId-001"), + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"), + isDraft = false, + text = "message text", + archiveRequired = false + ) + val writtenJson = patientIssueWriter.write(patientIssue) + + 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 expectedCreatedPatientIssue = patientIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true) + val parsedCreatePatientIssue = jsValueToPatientIssue(createPatientIssueJson, UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), StringId("userId-001")) + parsedCreatePatientIssue should be(expectedCreatedPatientIssue) + + val updatePatientIssueJson = + """{"text":"new issue text","evidence":"issue evidence","archiveRequired":true}""".parseJson + val expectedUpdatedPatientIssue = patientIssue.copy( + text = "new issue text", + archiveRequired = true + ) + val parsedUpdatePatientIssue = applyUpdateToPatientIssue(updatePatientIssueJson, patientIssue) + parsedUpdatePatientIssue should be(expectedUpdatedPatientIssue) + } + +} 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 new file mode 100644 index 0000000..e18239c --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientLabelFormatSuite.scala @@ -0,0 +1,76 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDate + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, UuidId} +import xyz.driver.pdsuidomain.entities.{PatientLabel, PatientLabelEvidenceView} + +class PatientLabelFormatSuite extends FlatSpec with Matchers { + + "Json format for PatientLabel" should "read and write correct JSON" in { + import patientlabel._ + val orig = PatientLabel( + id = LongId(1), + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + labelId = LongId(20), + primaryValue = Some(FuzzyValue.Yes), + verifiedPrimaryValue = None, + isVisible = true, + score = 1, + isImplicitMatch = false + ) + val writtenJson = patientLabelWriter.write((orig, true)) + + 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 expectedUpdatedPatientLabel = orig.copy(verifiedPrimaryValue = Some(FuzzyValue.No)) + val parsedUpdatePatientLabel = applyUpdateToPatientLabel(updatePatientLabelJson, orig) + parsedUpdatePatientLabel should be(expectedUpdatedPatientLabel) + } + + "Json format for PatientLabelEvidence" should "read and write correct JSON" in { + import patientlabel._ + val orig = PatientLabelEvidenceView( + id = LongId(1), + value = FuzzyValue.Maybe, + evidenceText = "evidence text", + documentId = Some(LongId(21)), + evidenceId = Some(LongId(10)), + reportId = None, + documentType = "document type", + date = Some(LocalDate.parse("2017-08-10")), + providerType = "provider type", + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + labelId = LongId(20), + isImplicitMatch = false + ) + val writtenJson = patientLabelEvidenceWriter.write(orig) + + 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) + } + + "Json format for PatientLabelDefiningCriteria" should "read and write correct JSON" in { + import patientdefiningcriteria._ + val orig = PatientLabel( + id = LongId(1), + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + labelId = LongId(20), + primaryValue = Some(FuzzyValue.Yes), + verifiedPrimaryValue = Some(FuzzyValue.Yes), + isVisible = true, + score = 1, + isImplicitMatch = false + ) + val writtenJson = patientLabelDefiningCriteriaWriter.write(orig) + + writtenJson should be ("""{"id":1,"value":"Yes"}""".parseJson) + } + +} 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 new file mode 100644 index 0000000..59cf779 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatSuite.scala @@ -0,0 +1,50 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId} +import xyz.driver.pdsuidomain.entities.Trial + +class TrialFormatSuite extends FlatSpec with Matchers { + import trial._ + + "Json format for Trial" should "read and write correct JSON" in { + val orig = Trial( + id = StringId("NCT000001"), + externalId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), + status = Trial.Status.New, + assignee = None, + previousStatus = None, + previousAssignee = None, + lastActiveUserId = None, + lastUpdate = LocalDateTime.parse("2017-08-10T18:16:19"), + condition = Trial.Condition.Breast, + phase = "", + hypothesisId = Some(UuidId("3b80b2e2-5372-4cf5-a342-6e4ebe10fafd")), + studyDesignId = Some(LongId(321)), + originalStudyDesign = None, + isPartner = false, + overview = None, + overviewTemplate = "", + isUpdated = false, + title = "trial title", + originalTitle = "orig trial title" + ) + val writtenJson = trialWriter.write(orig) + + 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","condition":"Breast","status":"New","overview":null,"previousAssignee":null,"title":"trial title"}""".parseJson) + + val updateTrialJson = """{"hypothesisId":null,"overview":"new overview"}""".parseJson + val expectedUpdatedTrial = orig.copy(hypothesisId = None, overview = Some("new overview")) + val parsedUpdateTrial = applyUpdateToTrial(updateTrialJson, orig) + parsedUpdateTrial should be(expectedUpdatedTrial) + } + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala deleted file mode 100644 index 397d2aa..0000000 --- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialFormatTestSuite.scala +++ /dev/null @@ -1,50 +0,0 @@ -package xyz.driver.pdsuidomain.formats.json.sprayformats - -import java.time.LocalDateTime - -import spray.json._ -import org.scalatest.{FlatSpec, Matchers} -import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId} -import xyz.driver.pdsuidomain.entities.Trial - -class TrialFormatTestSuite extends FlatSpec with Matchers { - import trial._ - - "Json format for Trial" should "read and write correct JSON" in { - val orig = Trial( - id = StringId("NCT000001"), - externalId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), - status = Trial.Status.New, - assignee = None, - previousStatus = None, - previousAssignee = None, - lastActiveUserId = None, - lastUpdate = LocalDateTime.parse("2017-08-10T18:16:19"), - condition = Trial.Condition.Breast, - phase = "", - hypothesisId = Some(UuidId("3b80b2e2-5372-4cf5-a342-6e4ebe10fafd")), - studyDesignId = Some(LongId(321)), - originalStudyDesign = None, - isPartner = false, - overview = None, - overviewTemplate = "", - isUpdated = false, - title = "trial title", - originalTitle = "orig trial title" - ) - val writtenJson = trialWriter.write(orig) - - 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","condition":"Breast","status":"New","overview":null,"previousAssignee":null,"title":"trial title"}""".parseJson) - - val updateTrialJson = """{"hypothesisId":null,"overview":"new overview"}""".parseJson - val expectedUpdatedTrial = orig.copy(hypothesisId = None, overview = Some("new overview")) - 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 new file mode 100644 index 0000000..dbb143c --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialHistoryFormatSuite.scala @@ -0,0 +1,32 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId} +import xyz.driver.pdsuidomain.entities.TrialHistory + +class TrialHistoryFormatSuite extends FlatSpec with Matchers { + import trialhistory._ + + "Json format for TrialHistory" should "read and write correct JSON" in { + val trialHistory = TrialHistory( + id = LongId(10), + trialId = StringId("NCT000001"), + executor = StringId("userId-001"), + state = TrialHistory.State.Summarize, + action = TrialHistory.Action.Start, + created = LocalDateTime.parse("2017-08-10T18:00:00") + ) + val writtenJson = trialHistoryFormat.write(trialHistory) + + 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) + parsedTrialHistory should be(trialHistory) + } + +} 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 new file mode 100644 index 0000000..02e14ba --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/TrialIssueFormatSuite.scala @@ -0,0 +1,49 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{LongId, StringId} +import xyz.driver.pdsuidomain.entities.TrialIssue + +class TrialIssueFormatSuite extends FlatSpec with Matchers { + import trialissue._ + + "Json format for TrialIssue" should "read and write correct JSON" in { + val trialIssue = TrialIssue( + id = LongId(10), + trialId = StringId("NCT000001"), + userId = StringId("userId-001"), + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"), + isDraft = false, + text = "message text", + evidence = "evidence", + archiveRequired = false, + meta = "{}" + ) + val writtenJson = trialIssueWriter.write(trialIssue) + + 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 expectedCreatedTrialIssue = trialIssue.copy(id = LongId(0), lastUpdate = LocalDateTime.MIN, isDraft = true) + val parsedCreateTrialIssue = jsValueToTrialIssue(createTrialIssueJson, StringId("NCT000001"), StringId("userId-001")) + parsedCreateTrialIssue should be(expectedCreatedTrialIssue) + + val updateTrialIssueJson = + """{"text":"new issue text","evidence":"issue evidence","archiveRequired":true, + "meta":"{\"startPage\":1.0,\"endPage\":2.0}"}""".parseJson + val expectedUpdatedTrialIssue = trialIssue.copy( + text = "new issue text", + evidence = "issue evidence", + archiveRequired = true, + meta = """{"startPage":1.0,"endPage":2.0}""" + ) + val parsedUpdateTrialIssue = applyUpdateToTrialIssue(updateTrialIssueJson, trialIssue) + parsedUpdateTrialIssue should be(expectedUpdatedTrialIssue) + } + +} -- cgit v1.2.3 From 442579b27ccbac82cb001a5b02402a593d005977 Mon Sep 17 00:00:00 2001 From: Kseniya Tomskikh Date: Mon, 14 Aug 2017 14:15:14 +0600 Subject: PDSUI-2188 Created tests for export and dictionary API --- .../json/sprayformats/bridgeuploadqueue.scala | 68 +++++++++++ .../formats/json/sprayformats/export.scala | 78 +++++++++++++ .../formats/json/sprayformats/hypothesis.scala | 12 ++ .../json/sprayformats/patientcriterion.scala | 6 +- .../formats/json/sprayformats/studydesign.scala | 12 ++ .../sprayformats/BridgeUploadQueueFormat.scala | 32 ++++++ .../json/sprayformats/ExportFormatSuite.scala | 124 +++++++++++++++++++++ .../json/sprayformats/HypothesisFormatSuite.scala | 28 +++++ .../sprayformats/PatientCriterionFormatSuite.scala | 55 +++++++++ .../PatientEligibleTrialFormatSuite.scala | 62 +++++++++++ .../json/sprayformats/StudyDesignFormatSuite.scala | 24 ++++ 11 files changed, 500 insertions(+), 1 deletion(-) create mode 100644 src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/bridgeuploadqueue.scala create mode 100644 src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala create mode 100644 src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/hypothesis.scala create mode 100644 src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/studydesign.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/BridgeUploadQueueFormat.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientCriterionFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientEligibleTrialFormatSuite.scala create mode 100644 src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/StudyDesignFormatSuite.scala (limited to 'src/test/scala') diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/bridgeuploadqueue.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/bridgeuploadqueue.scala new file mode 100644 index 0000000..77fb4d2 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/bridgeuploadqueue.scala @@ -0,0 +1,68 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue +import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue.Item + +object bridgeuploadqueue { + import DefaultJsonProtocol._ + import common._ + + implicit val queueUploadItemFormat: RootJsonFormat[BridgeUploadQueue.Item] = new RootJsonFormat[Item] { + override def write(obj: Item) = + JsObject( + "kind" -> obj.kind.toJson, + "tag" -> obj.tag.toJson, + "created" -> obj.created.toJson, + "attempts" -> obj.attempts.toJson, + "nextAttempt" -> obj.nextAttempt.toJson, + "completed" -> obj.completed.toJson + ) + + override def read(json: JsValue): Item = json match { + case JsObject(fields) => + val kind = fields + .get("kind") + .map(_.convertTo[String]) + .getOrElse(deserializationError(s"BridgeUploadQueue.Item json object does not contain `kind` field: $json")) + + val tag = fields + .get("tag") + .map(_.convertTo[String]) + .getOrElse(deserializationError(s"BridgeUploadQueue.Item json object does not contain `tag` field: $json")) + + val created = fields + .get("created") + .map(_.convertTo[LocalDateTime]) + .getOrElse( + deserializationError(s"BridgeUploadQueue.Item json object does not contain `created` field: $json")) + + val attempts = fields + .get("attempts") + .map(_.convertTo[Int]) + .getOrElse( + deserializationError(s"BridgeUploadQueue.Item json object does not contain `attempts` field: $json")) + + val nextAttempt = fields + .get("nextAttempt") + .map(_.convertTo[LocalDateTime]) + .getOrElse( + deserializationError(s"BridgeUploadQueue.Item json object does not contain `nextAttempt` field: $json")) + + BridgeUploadQueue.Item( + kind = kind, + tag = tag, + created = created, + attempts = attempts, + nextAttempt = nextAttempt, + completed = true, + dependencyKind = None, + dependencyTag = None + ) + + case _ => deserializationError(s"Expected Json Object as BridgeUploadQueue.Item, but got $json") + } + } +} diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala new file mode 100644 index 0000000..20b6ed0 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala @@ -0,0 +1,78 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import xyz.driver.pdsuidomain.entities.export.patient._ +import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrialArm, ExportTrialLabelCriterion, ExportTrialWithLabels} + +object export { + import DefaultJsonProtocol._ + import common._ + import record._ + + implicit val patientLabelEvidenceDocumentFormat: RootJsonFormat[ExportPatientLabelEvidenceDocument] = jsonFormat5( + ExportPatientLabelEvidenceDocument.apply) + + implicit val patientLabelEvidenceWriter: JsonWriter[ExportPatientLabelEvidence] = + new JsonWriter[ExportPatientLabelEvidence] { + override def write(obj: ExportPatientLabelEvidence): JsValue = + JsObject( + "evidenceId" -> obj.id.toJson, + "labelValue" -> obj.value.toJson, + "evidenceText" -> obj.evidenceText.toJson, + "document" -> obj.document.toJson + ) + } + + implicit val patientLabelWriter: JsonWriter[ExportPatientLabel] = new JsonWriter[ExportPatientLabel] { + override def write(obj: ExportPatientLabel): JsValue = + JsObject( + "labelId" -> obj.id.toJson, + "evidence" -> obj.evidences.map(_.toJson).toJson + ) + } + + implicit val patientWithLabelsWriter: JsonWriter[ExportPatientWithLabels] = new JsonWriter[ExportPatientWithLabels] { + override def write(obj: ExportPatientWithLabels): JsValue = + JsObject( + "patientId" -> obj.patientId.toJson, + "labelVersion" -> obj.labelVersion.toJson, + "labels" -> obj.labels.map(_.toJson).toJson + ) + } + + implicit val trialArmFormat: RootJsonFormat[ExportTrialArm] = jsonFormat2(ExportTrialArm.apply) + + implicit val trialLabelCriterionWriter: JsonWriter[ExportTrialLabelCriterion] = + new JsonWriter[ExportTrialLabelCriterion] { + override def write(obj: ExportTrialLabelCriterion): JsValue = + JsObject( + "value" -> obj.value + .map { + case true => "Yes" + case false => "No" + } + .getOrElse("Unknown") + .toJson, + "labelId" -> obj.labelId.toJson, + "criterionId" -> obj.criterionId.toJson, + "criterionText" -> obj.criteria.toJson, + "armIds" -> obj.armIds.toJson, + "isCompound" -> obj.isCompound.toJson, + "isDefining" -> obj.isDefining.toJson + ) + } + + implicit val trialWithLabelsWriter: JsonWriter[ExportTrialWithLabels] = new JsonWriter[ExportTrialWithLabels] { + override def write(obj: ExportTrialWithLabels) = + JsObject( + "nctId" -> obj.nctId.toJson, + "trialId" -> obj.trialId.toJson, + "disease" -> obj.condition.toJson, + "lastReviewed" -> obj.lastReviewed.toJson, + "labelVersion" -> obj.labelVersion.toJson, + "arms" -> obj.arms.toJson, + "criteria" -> obj.criteria.map(_.toJson).toJson + ) + } + +} diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/hypothesis.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/hypothesis.scala new file mode 100644 index 0000000..c05ff23 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/hypothesis.scala @@ -0,0 +1,12 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import xyz.driver.pdsuidomain.entities._ + +object hypothesis { + import DefaultJsonProtocol._ + import common._ + + implicit val hypothesisFormat: RootJsonFormat[Hypothesis] = jsonFormat4(Hypothesis.apply) + +} diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala index ff7593f..53e927d 100644 --- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala @@ -31,7 +31,11 @@ object patientcriterion { case _ => deserializationError(s"Expected Json Object as partial PatientCriterion, but got $json") } - implicit val patientCriterionFormat: RootJsonFormat[DraftPatientCriterion] = jsonFormat3(DraftPatientCriterion.apply) + implicit val draftPatientCriterionFormat: RootJsonFormat[DraftPatientCriterion] = jsonFormat3( + DraftPatientCriterion.apply) + implicit val draftPatientCriterionListReader = new JsonReader[List[DraftPatientCriterion]] { + override def read(json: JsValue) = json.convertTo[List[JsValue]].map(_.convertTo[DraftPatientCriterion]) + } implicit val patientCriterionWriter: JsonWriter[(PatientCriterion, LongId[Label], List[PatientCriterionArm])] = new JsonWriter[(PatientCriterion, LongId[Label], List[PatientCriterionArm])] { diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/studydesign.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/studydesign.scala new file mode 100644 index 0000000..e801666 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/studydesign.scala @@ -0,0 +1,12 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import xyz.driver.pdsuidomain.entities._ + +object studydesign { + import DefaultJsonProtocol._ + import common._ + + implicit val studyDesignFormat: RootJsonFormat[StudyDesign] = jsonFormat2(StudyDesign.apply) + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/BridgeUploadQueueFormat.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/BridgeUploadQueueFormat.scala new file mode 100644 index 0000000..854f51f --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/BridgeUploadQueueFormat.scala @@ -0,0 +1,32 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue + +class BridgeUploadQueueFormat extends FlatSpec with Matchers { + import bridgeuploadqueue._ + + "Json format for BridgeUploadQueue.Item" should "read and write correct JSON" in { + val item = BridgeUploadQueue.Item( + kind = "kind", + tag = "tag", + created = LocalDateTime.parse("2017-08-10T18:00:00"), + attempts = 0, + nextAttempt = LocalDateTime.parse("2017-08-10T18:10:00"), + completed = false, + dependencyKind = Some("dependency king"), + dependencyTag = None + ) + val writtenJson = queueUploadItemFormat.write(item) + + writtenJson should be( + """{"kind":"kind","tag":"tag","created":"2017-08-10T18:00Z","attempts":0,"nextAttempt":"2017-08-10T18:10Z","completed":false}""".parseJson) + + val parsedItem = queueUploadItemFormat.read(writtenJson) + parsedItem should be(item.copy(dependencyKind = None, completed = true)) + } + +} 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 new file mode 100644 index 0000000..d0d4d1a --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala @@ -0,0 +1,124 @@ +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 xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId, UuidId} +import xyz.driver.pdsuidomain.entities.RecordRequestId + +class ExportFormatSuite extends FlatSpec with Matchers { + import export._ + + "Json format for ExportPatientWithLabels" should "read and write correct JSON" in { + import xyz.driver.pdsuidomain.entities.export.patient._ + val document = ExportPatientLabelEvidenceDocument( + documentId = LongId(101), + requestId = RecordRequestId(UUID.fromString("7b54a75d-4197-4b27-9045-b9b6cb131be9")), + documentType = "document type", + providerType = "provider type", + date = LocalDate.parse("2017-08-10") + ) + val labels = List( + ExportPatientLabel( + id = LongId(1), + evidences = List( + ExportPatientLabelEvidence( + id = LongId(11), + value = FuzzyValue.Yes, + evidenceText = "evidence text 11", + document = document + ), + ExportPatientLabelEvidence( + id = LongId(12), + value = FuzzyValue.No, + evidenceText = "evidence text 12", + document = document + ) + ) + ), + ExportPatientLabel( + id = LongId(2), + evidences = List( + ExportPatientLabelEvidence( + id = LongId(12), + value = FuzzyValue.Yes, + evidenceText = "evidence text 12", + document = document + ), + ExportPatientLabelEvidence( + id = LongId(13), + value = FuzzyValue.Yes, + evidenceText = "evidence text 13", + document = document + ) + ) + ) + ) + val patientWithLabels = ExportPatientWithLabels( + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + labelVersion = 1L, + labels = labels + ) + + val writtenJson = patientWithLabelsWriter.write(patientWithLabels) + writtenJson should be( + """{"patientId":"748b5884-3528-4cb9-904b-7a8151d6e343","labelVersion":1,"labels":[{"labelId":1,"evidence":[{"evidenceId":11, + "labelValue":"Yes","evidenceText":"evidence text 11","document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9", + "documentType":"document type","providerType":"provider type","date":"2017-08-10"}},{"evidenceId":12,"labelValue":"No", + "evidenceText":"evidence text 12","document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9", + "documentType":"document type","providerType":"provider type","date":"2017-08-10"}}]}, + {"labelId":2,"evidence":[{"evidenceId":12,"labelValue":"Yes","evidenceText":"evidence text 12","document": + {"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","documentType":"document type", + "providerType":"provider type","date":"2017-08-10"}},{"evidenceId":13,"labelValue":"Yes","evidenceText":"evidence text 13", + "document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","documentType":"document type", + "providerType":"provider type","date":"2017-08-10"}}]}]}""".parseJson) + } + + "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") + ) + val criteriaList = List( + ExportTrialLabelCriterion( + criterionId = LongId(10), + value = Some(true), + labelId = LongId(21), + armIds = Set(LongId(1), LongId(2)), + criteria = "criteria 10 text", + isCompound = false, + isDefining = false + ), + ExportTrialLabelCriterion( + criterionId = LongId(11), + value = None, + labelId = LongId(21), + armIds = Set(LongId(2)), + criteria = "criteria 11 text", + isCompound = true, + isDefining = false + ) + ) + val trialWithLabels = ExportTrialWithLabels( + nctId = StringId("NCT000001"), + trialId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), + condition = "Breast", + lastReviewed = LocalDateTime.parse("2017-08-10T18:00:00"), + labelVersion = 1L, + arms = arms, + criteria = criteriaList + ) + + val writtenJson = trialWithLabelsWriter.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":[ + {"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/HypothesisFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala new file mode 100644 index 0000000..306fb17 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/HypothesisFormatSuite.scala @@ -0,0 +1,28 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.UuidId +import xyz.driver.pdsuidomain.entities.Hypothesis + +class HypothesisFormatSuite extends FlatSpec with Matchers { + import hypothesis._ + + "Json format for Hypothesis" should "read and write correct JSON" in { + val hypothesis = Hypothesis( + id = UuidId("3b80b2e2-5372-4cf5-a342-6e4ebe10fafd"), + name = "hypothesis name", + treatmentType = "treatment type", + description = "descr" + ) + val writtenJson = hypothesisFormat.write(hypothesis) + + writtenJson should be( + """{"id":"3b80b2e2-5372-4cf5-a342-6e4ebe10fafd","name":"hypothesis name", + "treatmentType":"treatment type","description":"descr"}""".parseJson) + + val parsedHypothesis = hypothesisFormat.read(writtenJson) + parsedHypothesis should be(hypothesis) + } + +} 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 new file mode 100644 index 0000000..0f5e4e2 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientCriterionFormatSuite.scala @@ -0,0 +1,55 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId} +import xyz.driver.pdsuidomain.entities.{PatientCriterion, PatientCriterionArm} +import xyz.driver.pdsuidomain.services.PatientCriterionService.DraftPatientCriterion + +class PatientCriterionFormatSuite extends FlatSpec with Matchers { + import patientcriterion._ + + "Json format for PatientCriterion" should "read and write correct JSON" in { + val orig = PatientCriterion( + id = LongId(1), + patientLabelId = LongId(1), + trialId = 0L, + nctId = StringId("NCT00001"), + criterionId = LongId(101), + criterionText = "criterion text", + criterionValue = Some(true), + criterionIsDefining = false, + eligibilityStatus = Some(FuzzyValue.Yes), + verifiedEligibilityStatus = None, + isVisible = true, + isVerified = true, + lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00") + ) + val arms = List( + PatientCriterionArm(patientCriterionId = LongId(1), armId = LongId(31), armName = "arm 31"), + PatientCriterionArm(patientCriterionId = LongId(1), armId = LongId(32), armName = "arm 32") + ) + val writtenJson = patientCriterionWriter.write((orig, LongId(21), arms)) + + 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 expectedUpdatedPatientCriterion = orig.copy(verifiedEligibilityStatus = Some(FuzzyValue.No)) + val parsedUpdatePatientCriterion = applyUpdateToPatientCriterion(updatePatientCriterionJson, orig) + parsedUpdatePatientCriterion should be(expectedUpdatedPatientCriterion) + + 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)) + ) + val parsedDraftPatientCriterionList = draftPatientCriterionListReader.read(updateBulkPatientCriterionJson) + parsedDraftPatientCriterionList should be(expectedDraftPatientCriterionList) + } + +} 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 new file mode 100644 index 0000000..ad54946 --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/PatientEligibleTrialFormatSuite.scala @@ -0,0 +1,62 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import java.time.LocalDateTime + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId, UuidId} +import xyz.driver.pdsuidomain.entities.{PatientCriterionArm, PatientTrialArmGroupView, Trial} +import xyz.driver.pdsuidomain.services.PatientEligibleTrialService.RichPatientEligibleTrial + +class PatientEligibleTrialFormatSuite extends FlatSpec with Matchers { + import patienteligibletrial._ + + "Json format for PatientEligibleTrial" should "read and write correct JSON" in { + val trial = Trial( + id = StringId("NCT000001"), + externalId = UuidId("40892a07-c638-49d2-9795-1edfefbbcc7c"), + status = Trial.Status.Done, + assignee = None, + previousStatus = None, + previousAssignee = None, + lastActiveUserId = None, + lastUpdate = LocalDateTime.parse("2017-08-10T18:16:19"), + condition = Trial.Condition.Breast, + phase = "", + hypothesisId = Some(UuidId("e76e2fc4-a29c-44fb-a81b-8856d06bb1d4")), + studyDesignId = Some(LongId(321)), + originalStudyDesign = None, + isPartner = false, + overview = None, + overviewTemplate = "", + isUpdated = false, + title = "trial title", + originalTitle = "orig trial title" + ) + val group = PatientTrialArmGroupView( + id = LongId(1), + patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"), + trialId = StringId("NCT000001"), + hypothesisId = UuidId("e76e2fc4-a29c-44fb-a81b-8856d06bb1d4"), + eligibilityStatus = Some(FuzzyValue.Yes), + verifiedEligibilityStatus = Some(FuzzyValue.Yes), + isVerified = false + ) + val arms = List( + 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 writtenJson = patientEligibleTrialWriter.write(orig) + + 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 expectedUpdatedPatientTrialArmGroup = group.copy(isVerified = true) + val parsedUpdatePatientTrialArmGroup = applyUpdateToTrialArmGroup(updatePatientEligibleTrialJson, group) + parsedUpdatePatientTrialArmGroup should be(expectedUpdatedPatientTrialArmGroup) + } + +} diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/StudyDesignFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/StudyDesignFormatSuite.scala new file mode 100644 index 0000000..9cf9b5f --- /dev/null +++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/StudyDesignFormatSuite.scala @@ -0,0 +1,24 @@ +package xyz.driver.pdsuidomain.formats.json.sprayformats + +import spray.json._ +import org.scalatest.{FlatSpec, Matchers} +import xyz.driver.pdsuicommon.domain.LongId +import xyz.driver.pdsuidomain.entities.StudyDesign + +class StudyDesignFormatSuite extends FlatSpec with Matchers { + import studydesign._ + + "Json format for StudyDesign" should "read and write correct JSON" in { + val studyDesign = StudyDesign( + id = LongId(10), + name = "study design name" + ) + val writtenJson = studyDesignFormat.write(studyDesign) + + writtenJson should be("""{"id":10,"name":"study design name"}""".parseJson) + + val parsedStudyDesign = studyDesignFormat.read(writtenJson) + parsedStudyDesign should be(studyDesign) + } + +} -- cgit v1.2.3