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(LongId[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
}
}
*/
