aboutsummaryrefslogtreecommitdiff
path: root/src/test/scala/xyz/driver/pdsuidomain/formats/json/MedicalRecordFormatSuite.scala
blob: 86462b2b185fd38639cb372b6919d62b830d2453 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package xyz.driver.pdsuidomain.formats.json

import java.time.LocalDateTime

import spray.json._
import org.scalatest.{FlatSpec, Matchers}
import xyz.driver.core.Id
import xyz.driver.entities.clinic.ClinicalRecord
import xyz.driver.pdsuicommon.domain.{LongId, TextJson, UuidId}
import xyz.driver.pdsuidomain.entities.MedicalRecord

class MedicalRecordFormatSuite extends FlatSpec with Matchers {
  import xyz.driver.pdsuidomain.formats.json.record._
  import MedicalRecord._

  "Json format for MedicalRecord.Meta" should "read and write correct JSON" in {
    val duplicate1 = Meta.Duplicate(
      startPage = 1.0d,
      endPage = 2.0d,
      startOriginalPage = 1.0d,
      endOriginalPage = Some(2.0d)
    )

    val duplicate2 = Meta.Duplicate(
      startPage = 1.0d,
      endPage = 2.0d,
      startOriginalPage = 1.0d,
      endOriginalPage = None
    )

    val reorder = Meta.Reorder(
      Seq(1, 2)
    )

    val rotation = Meta.Rotation(
      Map("item1" -> 1, "item2" -> 2)
    )

    val writtenDuplicateJson1 =
      duplicateMetaFormat.write(duplicate1)

    val writtenDuplicateJson2 =
      duplicateMetaFormat.write(duplicate2)

    val writtenReorderJson =
      reorderMetaFormat.write(reorder)

    val writtenRotationJson =
      rotateMetaFormat.write(rotation)

    writtenDuplicateJson1 should be(
      """{"startOriginalPage":1.0,"endPage":2.0,"startPage":1.0,"type":"duplicate","endOriginalPage":2.0}""".parseJson)

    writtenDuplicateJson2 should be(
      """{"startOriginalPage":1.0,"endPage":2.0,"startPage":1.0,"type":"duplicate","endOriginalPage":null}""".parseJson)

    writtenReorderJson should be(
      """{"type":"reorder","items":[1,2]}""".parseJson)

    writtenRotationJson should be(
      """{"type":"rotation","items":{"item1":1,"item2":2}}""".parseJson)

    val parsedDuplicateJson1 =
      duplicateMetaFormat.read(writtenDuplicateJson1)

    val parsedDuplicateJson2 =
      duplicateMetaFormat.read(writtenDuplicateJson2)

    val parsedReorderJson =
      reorderMetaFormat.read(writtenReorderJson)

    val parsedRotationJson =
      rotateMetaFormat.read(writtenRotationJson)

    duplicate1 should be(parsedDuplicateJson1)

    duplicate2 should be(parsedDuplicateJson2)

    reorder should be(parsedReorderJson)

    rotation should be(parsedRotationJson)

    duplicate1 should be(recordMetaTypeFormat.read(recordMetaTypeFormat.write(duplicate1)))
    duplicate2 should be(recordMetaTypeFormat.read(recordMetaTypeFormat.write(duplicate2)))
    reorder should be(recordMetaTypeFormat.read(recordMetaTypeFormat.write(reorder)))
    rotation should be(recordMetaTypeFormat.read(recordMetaTypeFormat.write(rotation)))
  }


  "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,
      disease = "Breast",
      requestId = Id[ClinicalRecord]("7b54a75d-4197-4b27-9045-b9b6cb131be9"),
      caseId = None,
      patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"),
      totalPages = 10
    )
    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","totalPages":10}""".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 = Id[ClinicalRecord]("7b54a75d-4197-4b27-9045-b9b6cb131be9"),
      disease = "Breast",
      caseId = None,
      physician = None,
      meta = None,
      lastUpdate = LocalDateTime.now(),
      totalPages = 0
    )
    val parsedCreatedRecord = recordFormat.read(createRecordJson).copy(lastUpdate = expectedCreatedRecord.lastUpdate)
    parsedCreatedRecord should be(expectedCreatedRecord)

    val updateRecordJson =
      """{"meta":[{"type":"duplicate","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(startPage = 1.0, endPage = 2.0, startOriginalPage = 1.0, endOriginalPage = None),
            Meta.Reorder(Seq(1, 2)),
            Meta.Rotation(Map("item1" -> 1, "item2" -> 2))
          )))
    )
    val parsedUpdatedRecord = applyUpdateToMedicalRecord(updateRecordJson, orig)
    parsedUpdatedRecord should be(expectedUpdatedRecord)
  }

}