diff --git a/commons/protocol/src/main/scala/net/shrine/protocol/QueryResult.scala b/commons/protocol/src/main/scala/net/shrine/protocol/QueryResult.scala
index a4aae7fa2..6a257940b 100644
--- a/commons/protocol/src/main/scala/net/shrine/protocol/QueryResult.scala
+++ b/commons/protocol/src/main/scala/net/shrine/protocol/QueryResult.scala
@@ -1,326 +1,328 @@
package net.shrine.protocol
import javax.xml.datatype.XMLGregorianCalendar
import net.shrine.problem.ProblemDigest
import scala.xml.NodeSeq
import net.shrine.util.{Tries, XmlUtil, NodeSeqEnrichments, SEnum, XmlDateHelper, OptionEnrichments}
import net.shrine.serialization.{ I2b2Marshaller, XmlMarshaller }
import scala.util.Try
/**
* @author Bill Simons
* @since 4/15/11
* @see http://cbmi.med.harvard.edu
* @see http://chip.org
* <p/>
* NOTICE: This software comes with NO guarantees whatsoever and is
* licensed as Lgpl Open Source
* @see http://www.gnu.org/licenses/lgpl.html
*
* NB: this is a case class to get a structural equality contract in hashCode and equals, mostly for testing
*/
final case class QueryResult(
resultId: Long,
instanceId: Long,
resultType: Option[ResultOutputType], //this won't be present in the case of an error result
setSize: Long,
startDate: Option[XMLGregorianCalendar],
endDate: Option[XMLGregorianCalendar],
description: Option[String],
statusType: QueryResult.StatusType,
statusMessage: Option[String],
breakdowns: Map[ResultOutputType, I2b2ResultEnvelope] = Map.empty,
problemDigest: Option[ProblemDigest] = None
) extends XmlMarshaller with I2b2Marshaller {
def this(
resultId: Long,
instanceId: Long,
resultType: ResultOutputType,
setSize: Long,
startDate: XMLGregorianCalendar,
endDate: XMLGregorianCalendar,
statusType: QueryResult.StatusType) = {
this(
resultId,
instanceId,
Option(resultType),
setSize,
Option(startDate),
Option(endDate),
None, //description
statusType,
None) //statusMessage
}
def this(
resultId: Long,
instanceId: Long,
resultType: ResultOutputType,
setSize: Long,
startDate: XMLGregorianCalendar,
endDate: XMLGregorianCalendar,
description: String,
statusType: QueryResult.StatusType) = {
this(
resultId,
instanceId,
Option(resultType),
setSize,
Option(startDate),
Option(endDate),
Option(description),
statusType,
None) //statusMessage
}
def resultTypeIs(testedResultType: ResultOutputType): Boolean = resultType match {
case Some(rt) => rt == testedResultType
case _ => false
}
import QueryResult._
//NB: Fragile, non-type-safe ==
def isError = statusType == StatusType.Error
def elapsed: Option[Long] = {
def inMillis(xmlGc: XMLGregorianCalendar) = xmlGc.toGregorianCalendar.getTimeInMillis
for {
start <- startDate
end <- endDate
} yield inMillis(end) - inMillis(start)
}
//Sorting isn't strictly necessary, but makes deterministic unit testing easier.
//The number of breakdowns will be at most 4, so performance should not be an issue.
private def sortedBreakdowns: Seq[I2b2ResultEnvelope] = {
breakdowns.values.toSeq.sortBy(_.resultType.name)
}
override def toI2b2: NodeSeq = {
import OptionEnrichments._
XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>{ resultId }</result_instance_id>
<query_instance_id>{ instanceId }</query_instance_id>
{ description.toXml(<description/>) }
{
resultType match {
case Some(rt) if !rt.isError => //noinspection RedundantBlock
{
if (rt.isBreakdown) { rt.toI2b2NameOnly() }
else { rt.toI2b2 }
}
case _ => ResultOutputType.ERROR.toI2b2NameOnly("")
}
}
<set_size>{ setSize }</set_size>
{ startDate.toXml(<start_date/>) }
{ endDate.toXml(<end_date/>) }
<query_status_type>
<name>{ statusType }</name>
{ statusType.toI2b2(this) }
</query_status_type>
{
//NB: Deliberately use Shrine XML format instead of the i2b2 one. Adding breakdowns to i2b2-format XML here is deviating from the i2b2 XSD schema in any case,
//so if we're going to do that, let's produce saner XML.
sortedBreakdowns.map(_.toXml.head).map(XmlUtil.renameRootTag("breakdown_data"))
}
</query_result_instance>
}
}
override def toXml: NodeSeq = XmlUtil.stripWhitespace {
import OptionEnrichments._
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml(_.toXml) }
<setSize>{ setSize }</setSize>
{ startDate.toXml(<startDate/>) }
{ endDate.toXml(<endDate/>) }
{ description.toXml(<description/>) }
<status>{ statusType }</status>
{ statusMessage.toXml(<statusMessage/>) }
{
//Sorting isn't strictly necessary, but makes deterministic unit testing easier.
//The number of breakdowns will be at most 4, so performance should not be an issue.
sortedBreakdowns.map(_.toXml)
}
- { problemDigest.map(_.toXml).orNull }
+ { problemDigest.map(_.toXml).getOrElse("") }
</queryResult>
}
def withId(id: Long): QueryResult = copy(resultId = id)
def withInstanceId(id: Long): QueryResult = copy(instanceId = id)
def modifySetSize(f: Long => Long): QueryResult = withSetSize(f(setSize))
def withSetSize(size: Long): QueryResult = copy(setSize = size)
def withDescription(desc: String): QueryResult = copy(description = Option(desc))
def withResultType(resType: ResultOutputType): QueryResult = copy(resultType = Option(resType))
def withBreakdown(breakdownData: I2b2ResultEnvelope) = copy(breakdowns = breakdowns + (breakdownData.resultType -> breakdownData))
def withBreakdowns(newBreakdowns: Map[ResultOutputType, I2b2ResultEnvelope]) = copy(breakdowns = newBreakdowns)
}
object QueryResult {
final case class StatusType(
name: String,
isDone: Boolean,
i2b2Id: Option[Int] = Some(-1),
private val doToI2b2:(QueryResult => NodeSeq) = StatusType.defaultToI2b2) extends StatusType.Value {
def isError = this == StatusType.Error
def toI2b2(queryResult: QueryResult): NodeSeq = doToI2b2(queryResult)
}
object StatusType extends SEnum[StatusType] {
private val defaultToI2b2: QueryResult => NodeSeq = { queryResult =>
val i2b2Id: Int = queryResult.statusType.i2b2Id.getOrElse{
throw new IllegalStateException(s"queryResult.statusType ${queryResult.statusType} has no i2b2Id")
}
<status_type_id>{ i2b2Id }</status_type_id><description>{ queryResult.statusType.name }</description>
}
val noMessage:NodeSeq = null
val Error = StatusType("ERROR", isDone = true, None, { queryResult =>
(queryResult.statusMessage, queryResult.problemDigest) match {
case (Some(msg),Some(pd)) => <description>{ msg }</description> ++ pd.toXml
case (Some(msg),None) => <description>{ msg }</description>
case (None,Some(pd)) => pd.toXml
case (None, None) => noMessage
}
})
/*
msg =>
<codec>net.shrine.something.is.Broken</codec>
<summary>Something is borked</summary>
<description>{ msg }</description>
<details>Herein is a stack trace, multiple lines</details>
))
*/
val Finished = StatusType("FINISHED", isDone = true, Some(3))
//TODO: Can we use the same <status_type_id> for Queued, Processing, and Incomplete?
val Processing = StatusType("PROCESSING", isDone = false, Some(2))
val Queued = StatusType("QUEUED", isDone = false, Some(2))
val Incomplete = StatusType("INCOMPLETE", isDone = false, Some(2))
//TODO: What <status_type_id>s should these have? Does anyone care?
val Held = StatusType("HELD", isDone = false)
val SmallQueue = StatusType("SMALL_QUEUE", isDone = false)
val MediumQueue = StatusType("MEDIUM_QUEUE", isDone = false)
val LargeQueue = StatusType("LARGE_QUEUE", isDone = false)
val NoMoreQueue = StatusType("NO_MORE_QUEUE", isDone = false)
}
def extractLong(nodeSeq: NodeSeq)(elemName: String): Long = (nodeSeq \ elemName).text.toLong
private def parseDate(lexicalRep: String): Option[XMLGregorianCalendar] = XmlDateHelper.parseXmlTime(lexicalRep).toOption
def elemAt(path: String*)(xml: NodeSeq): NodeSeq = path.foldLeft(xml)(_ \ _)
def asText(path: String*)(xml: NodeSeq): String = elemAt(path: _*)(xml).text.trim
def asResultOutputTypeOption(elemNames: String*)(breakdownTypes: Set[ResultOutputType], xml: NodeSeq): Option[ResultOutputType] = {
import ResultOutputType.valueOf
val typeName = asText(elemNames: _*)(xml)
valueOf(typeName) orElse valueOf(breakdownTypes)(typeName)
}
def extractResultOutputType(xml: NodeSeq)(parse: NodeSeq => Try[ResultOutputType]): Option[ResultOutputType] = {
val attempt = parse(xml)
attempt.toOption
}
+ def extractProblemDigest(xml: NodeSeq):Option[ProblemDigest] = {
+
+ val subXml = xml \ "problem"
+ if(subXml.nonEmpty) Some(ProblemDigest.fromXml(subXml))
+ else None
+ }
+
def fromXml(breakdownTypes: Set[ResultOutputType])(xml: NodeSeq): QueryResult = {
def extract(elemName: String): Option[String] = {
Option((xml \ elemName).text.trim).filter(!_.isEmpty)
}
def extractDate(elemName: String): Option[XMLGregorianCalendar] = extract(elemName).flatMap(parseDate)
val asLong = extractLong(xml) _
import NodeSeqEnrichments.Strictness._
import Tries.sequence
def extractBreakdowns(elemName: String): Map[ResultOutputType, I2b2ResultEnvelope] = {
//noinspection ScalaUnnecessaryParentheses
val mapAttempt = for {
subXml <- xml.withChild(elemName)
envelopes <- sequence(subXml.map(I2b2ResultEnvelope.fromXml(breakdownTypes)))
mappings = envelopes.map(envelope => (envelope.resultType -> envelope))
} yield Map.empty ++ mappings
mapAttempt.getOrElse(Map.empty)
}
- def extractProblemDigest():Option[ProblemDigest] = {
- val subXml = xml \ "problemDigest"
- if(subXml.nonEmpty) Some(ProblemDigest.fromXml(subXml))
- else None
- }
-
QueryResult(
asLong("resultId"),
asLong("instanceId"),
extractResultOutputType(xml \ "resultType")(ResultOutputType.fromXml),
asLong("setSize"),
extractDate("startDate"),
extractDate("endDate"),
extract("description"),
StatusType.valueOf(asText("status")(xml)).get, //TODO: Avoid fragile .get call
extract("statusMessage"),
extractBreakdowns("resultEnvelope"),
- extractProblemDigest()
+ extractProblemDigest(xml)
)
}
def fromI2b2(breakdownTypes: Set[ResultOutputType])(xml: NodeSeq): QueryResult = {
def asLong = extractLong(xml) _
def asTextOption(path: String*): Option[String] = elemAt(path: _*)(xml).headOption.map(_.text.trim)
def asXmlGcOption(path: String): Option[XMLGregorianCalendar] = asTextOption(path).filter(!_.isEmpty).flatMap(parseDate)
QueryResult(
resultId = asLong("result_instance_id"),
instanceId = asLong("query_instance_id"),
resultType = extractResultOutputType(xml \ "query_result_type")(ResultOutputType.fromI2b2),
setSize = asLong("set_size"),
startDate = asXmlGcOption("start_date"),
endDate = asXmlGcOption("end_date"),
description = asTextOption("description"),
statusType = StatusType.valueOf(asText("query_status_type", "name")(xml)).get, //TODO: Avoid fragile .get call
- statusMessage = asTextOption("query_status_type", "description"))
+ statusMessage = asTextOption("query_status_type", "description"),
+ problemDigest = extractProblemDigest(xml \ "query_status_type"))
}
//todo default problem description goes here
def errorResult(description: Option[String], statusMessage: String,problemDigest:Option[ProblemDigest] = None) = {
QueryResult(
resultId = 0L,
instanceId = 0L,
resultType = None,
setSize = 0L,
startDate = None,
endDate = None,
description = description,
statusType = StatusType.Error,
statusMessage = Option(statusMessage),
problemDigest = problemDigest)
}
}
diff --git a/commons/protocol/src/test/scala/net/shrine/protocol/QueryResultTest.scala b/commons/protocol/src/test/scala/net/shrine/protocol/QueryResultTest.scala
index 023a75ad7..079e93f27 100644
--- a/commons/protocol/src/test/scala/net/shrine/protocol/QueryResultTest.scala
+++ b/commons/protocol/src/test/scala/net/shrine/protocol/QueryResultTest.scala
@@ -1,494 +1,510 @@
package net.shrine.protocol
import net.shrine.problem.ProblemDigest
import net.shrine.util.ShouldMatchersForJUnit
import org.junit.Test
import net.shrine.util.XmlUtil
import net.shrine.util.XmlDateHelper
import net.shrine.util.XmlGcEnrichments
/**
* @author Bill Simons
* @author clint
* @since 8/19/11
* @see http://cbmi.med.harvard.edu
* @see http://chip.org
* <p/>
* NOTICE: This software comes with NO guarantees whatsoever and is
* licensed as Lgpl Open Source
* @see http://www.gnu.org/licenses/lgpl.html
*/
//noinspection EmptyParenMethodAccessedAsParameterless,NameBooleanParameters
final class QueryResultTest extends ShouldMatchersForJUnit with XmlRoundTripper[QueryResult] with I2b2SerializableValidator {
private val date = XmlDateHelper.now
private val resultId = 1L
private val instanceId = 2L
private val resultType = ResultOutputType.PATIENTSET
private val setSize = 12L
private val statusType = QueryResult.StatusType.Finished
private val description = "description"
private val statusMessage = "lakjdalsjd"
private val problemCodec = "problem.codec"
private val problemSummary = "test problem"
private val problemDescription = "problem for testing"
private val problemDetails =
"""Details of the problem
|sometimes take
|multiple lines.
""".stripMargin
private val queryResult = QueryResult(resultId, instanceId, Some(resultType), setSize, Option(date), Option(date), Option(description), statusType, Option(statusType.name))
import DefaultBreakdownResultOutputTypes.{ values => breakdownTypes, _ }
private val resultWithBreakDowns = queryResult.copy(
statusMessage = Some(statusMessage),
breakdowns =
Map(PATIENT_AGE_COUNT_XML -> I2b2ResultEnvelope(PATIENT_AGE_COUNT_XML, Map("foo" -> 1L, "bar" -> 2L)),
PATIENT_RACE_COUNT_XML -> I2b2ResultEnvelope(PATIENT_RACE_COUNT_XML, Map("nuh" -> 3L, "zuh" -> 4L)),
PATIENT_VITALSTATUS_COUNT_XML -> I2b2ResultEnvelope(PATIENT_VITALSTATUS_COUNT_XML, Map("blarg" -> 5L, "glarg" -> 6L)),
PATIENT_GENDER_COUNT_XML -> I2b2ResultEnvelope(PATIENT_GENDER_COUNT_XML, Map("huh" -> 7L, "yeah" -> 8))))
private val expectedWhenBreakdownsArePresent = XmlUtil.stripWhitespace {
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml }
<setSize>{ setSize }</setSize>
<startDate>{ date }</startDate>
<endDate>{ date }</endDate>
<description>{ description }</description>
<status>{ statusType }</status>
<statusMessage>{ statusMessage }</statusMessage>
<resultEnvelope>
<resultType>{ PATIENT_AGE_COUNT_XML }</resultType>
<column>
<name>bar</name>
<value>2</value>
</column>
<column>
<name>foo</name>
<value>1</value>
</column>
</resultEnvelope>
<resultEnvelope>
<resultType>{ PATIENT_GENDER_COUNT_XML }</resultType>
<column>
<name>huh</name>
<value>7</value>
</column>
<column>
<name>yeah</name>
<value>8</value>
</column>
</resultEnvelope>
<resultEnvelope>
<resultType>{ PATIENT_RACE_COUNT_XML }</resultType>
<column>
<name>nuh</name>
<value>3</value>
</column>
<column>
<name>zuh</name>
<value>4</value>
</column>
</resultEnvelope>
<resultEnvelope>
<resultType>{ PATIENT_VITALSTATUS_COUNT_XML }</resultType>
<column>
<name>blarg</name>
<value>5</value>
</column>
<column>
<name>glarg</name>
<value>6</value>
</column>
</resultEnvelope>
</queryResult>
}.toString
private val expectedI2b2Xml = XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>{ resultId }</result_instance_id>
<query_instance_id>{ instanceId }</query_instance_id>
<description>{ description }</description>
<query_result_type>
<result_type_id>1</result_type_id>
<name>{ resultType }</name>
<display_type>LIST</display_type><visual_attribute_type>LA</visual_attribute_type><description>Patient set</description>
</query_result_type>
<set_size>{ setSize }</set_size>
<start_date>{ date }</start_date>
<end_date>{ date }</end_date>
<query_status_type>
<name>{ statusType }</name>
<status_type_id>3</status_type_id><description>FINISHED</description>
</query_status_type>
</query_result_instance>
}.toString
private val expectedI2b2XmlWithBreakdowns = XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>{ resultId }</result_instance_id>
<query_instance_id>{ instanceId }</query_instance_id>
<description>{ description }</description>
{ resultType.toI2b2 }
<set_size>{ setSize }</set_size>
<start_date>{ date }</start_date>
<end_date>{ date }</end_date>
<query_status_type>
<name>{ statusType }</name>
<status_type_id>3</status_type_id><description>FINISHED</description>
</query_status_type>
<breakdown_data>
<resultType>{ PATIENT_AGE_COUNT_XML }</resultType>
<column>
<name>bar</name>
<value>2</value>
</column>
<column>
<name>foo</name>
<value>1</value>
</column>
</breakdown_data>
<breakdown_data>
<resultType>{ PATIENT_GENDER_COUNT_XML }</resultType>
<column>
<name>huh</name>
<value>7</value>
</column>
<column>
<name>yeah</name>
<value>8</value>
</column>
</breakdown_data>
<breakdown_data>
<resultType>{ PATIENT_RACE_COUNT_XML }</resultType>
<column>
<name>nuh</name>
<value>3</value>
</column>
<column>
<name>zuh</name>
<value>4</value>
</column>
</breakdown_data>
<breakdown_data>
<resultType>{ PATIENT_VITALSTATUS_COUNT_XML }</resultType>
<column>
<name>blarg</name>
<value>5</value>
</column>
<column>
<name>glarg</name>
<value>6</value>
</column>
</breakdown_data>
</query_result_instance>
}.toString
private val expectedI2b2ErrorXml = XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>0</result_instance_id>
<query_instance_id>0</query_instance_id>
<description>{ description }</description>
<query_result_type>
<name></name>
</query_result_type>
<set_size>0</set_size>
<query_status_type>
<name>ERROR</name>
<description>{ statusMessage }</description>
</query_status_type>
</query_result_instance>
}.toString
private val expectedI2b2ErrorWithProblemDigestXml = XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>0</result_instance_id>
<query_instance_id>0</query_instance_id>
<description>{ description }</description>
<query_result_type>
<name></name>
</query_result_type>
<set_size>0</set_size>
<query_status_type>
<name>ERROR</name>
<description>{ statusMessage }</description>
<problem>
<codec>{ problemCodec }</codec>
<summary>{ problemSummary }</summary>
<description>{ problemDescription }</description>
<details>{ problemDetails }</details>
</problem>
</query_status_type>
</query_result_instance>
}.toString
//NB: See https://open.med.harvard.edu/jira/browse/SHRINE-745
private val expectedI2b2IncompleteXml = XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>0</result_instance_id>
<query_instance_id>0</query_instance_id>
<description>{ description }</description>
<query_result_type>
<name></name>
</query_result_type>
<set_size>0</set_size>
<query_status_type>
<name>INCOMPLETE</name>
<description>{ statusMessage }</description>
</query_status_type>
</query_result_instance>
}.toString
import scala.xml.XML.loadString
//NB: See https://open.med.harvard.edu/jira/browse/SHRINE-745
@Test
def testParseIncomplete() {
val qr = QueryResult.fromI2b2(breakdownTypes.toSet)(loadString(expectedI2b2IncompleteXml))
qr.statusType should be(QueryResult.StatusType.Incomplete)
}
@Test
def testElapsed() {
queryResult.copy(startDate = None).elapsed should be(None)
queryResult.copy(endDate = None).elapsed should be(None)
queryResult.copy(startDate = None, endDate = None).elapsed should be(None)
{
val now = XmlDateHelper.now
queryResult.copy(startDate = Some(now), endDate = Some(now)).elapsed should equal(Some(0L))
}
{
val start = XmlDateHelper.now
val delta = 123L
import XmlGcEnrichments._
import scala.concurrent.duration._
val end = start + delta.milliseconds
queryResult.copy(startDate = Some(start), endDate = Some(end)).elapsed should equal(Some(delta))
}
}
@Test
def testIsError() {
queryResult.isError should be(false)
queryResult.copy(statusType = QueryResult.StatusType.Processing).isError should be(false)
queryResult.copy(statusType = QueryResult.StatusType.Finished).isError should be(false)
queryResult.copy(statusType = QueryResult.StatusType.Queued).isError should be(false)
queryResult.copy(statusType = QueryResult.StatusType.Incomplete).isError should be(false)
queryResult.copy(statusType = QueryResult.StatusType.Error).isError should be(true)
}
@Test
def testToXml() {
val queryResultForShrine = queryResult.copy(statusMessage = Some(statusMessage))
val expectedWhenNoBreakdowns = XmlUtil.stripWhitespace {
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml }
<setSize>{ setSize }</setSize>
<startDate>{ date }</startDate>
<endDate>{ date }</endDate>
<description>{ description }</description>
<status>{ statusType }</status>
<statusMessage>{ statusMessage }</statusMessage>
</queryResult>
}.toString
queryResultForShrine.copy(statusMessage = Some(statusMessage)).toXmlString should equal(expectedWhenNoBreakdowns)
val expectedWhenNoStartDate = XmlUtil.stripWhitespace {
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml }
<setSize>{ setSize }</setSize>
<endDate>{ date }</endDate>
<description>{ description }</description>
<status>{ statusType }</status>
<statusMessage>{ statusMessage }</statusMessage>
</queryResult>
}.toString
queryResultForShrine.copy(startDate = None).toXmlString should equal(expectedWhenNoStartDate)
val expectedWhenNoEndDate = XmlUtil.stripWhitespace {
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml }
<setSize>{ setSize }</setSize>
<startDate>{ date }</startDate>
<description>{ description }</description>
<status>{ statusType }</status>
<statusMessage>{ statusMessage }</statusMessage>
</queryResult>
}.toString
queryResultForShrine.copy(endDate = None).toXmlString should equal(expectedWhenNoEndDate)
val expectedWhenNoDescription = XmlUtil.stripWhitespace {
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml }
<setSize>{ setSize }</setSize>
<startDate>{ date }</startDate>
<endDate>{ date }</endDate>
<status>{ statusType }</status>
<statusMessage>{ statusMessage }</statusMessage>
</queryResult>
}.toString
queryResultForShrine.copy(description = None).toXmlString should equal(expectedWhenNoDescription)
val expectedWhenNoStatusMessage = XmlUtil.stripWhitespace {
<queryResult>
<resultId>{ resultId }</resultId>
<instanceId>{ instanceId }</instanceId>
{ resultType.toXml }
<setSize>{ setSize }</setSize>
<startDate>{ date }</startDate>
<endDate>{ date }</endDate>
<description>{ description }</description>
<status>{ statusType }</status>
</queryResult>
}.toString
queryResult.copy(statusMessage = None).toXmlString should equal(expectedWhenNoStatusMessage)
resultWithBreakDowns.toXmlString should equal(expectedWhenBreakdownsArePresent)
}
@Test
def testFromXml() {
QueryResult.fromXml(breakdownTypes.toSet)(loadString(expectedWhenBreakdownsArePresent)) should equal(resultWithBreakDowns)
}
@Test
def testShrineRoundTrip() = {
QueryResult.fromXml(breakdownTypes.toSet)(resultWithBreakDowns.toXml) should equal(resultWithBreakDowns)
}
private def compareIgnoringBreakdowns(actual: QueryResult, expected: QueryResult) {
//Ignore breakdowns field, since this can't be serialized to i2b2 format as part of a <query_result_instance>
actual.breakdowns should equal(Map.empty)
actual.description should equal(expected.description)
actual.endDate should equal(expected.endDate)
actual.instanceId should equal(expected.instanceId)
actual.resultId should equal(expected.resultId)
actual.resultType should equal(expected.resultType)
actual.setSize should equal(expected.setSize)
actual.startDate should equal(expected.startDate)
actual.statusMessage should equal(expected.statusMessage)
actual.statusType should equal(expected.statusType)
}
@Test
def testI2b2RoundTrip() = {
//NB: Needed because i2b2 handles status messages differently. In the error case, statusMessage is
//descriptive; otherwise, it's the all-caps name of the status type. This is different from how
//Shrine creates and parses statusMessage XML, so we need a new QueryResult here. (Previously, we
//could use the same one, since we were ignoring statusMessage and description when unmarshalling
//from i2b2 format.)
val newStatusMessage = Some(resultWithBreakDowns.statusType.name)
val resultWithBreakDownsForI2b2 = resultWithBreakDowns.copy(statusMessage = newStatusMessage)
val unmarshalled = QueryResult.fromI2b2(breakdownTypes.toSet)(resultWithBreakDownsForI2b2.toI2b2)
compareIgnoringBreakdowns(unmarshalled, resultWithBreakDownsForI2b2)
}
@Test
def testFromI2b2() {
compareIgnoringBreakdowns(QueryResult.fromI2b2(breakdownTypes.toSet)(loadString(expectedI2b2Xml)), queryResult)
}
@Test
def testFromI2b2WithErrors() {
val errorResult = QueryResult.errorResult(Some(description), statusMessage)
val actual = QueryResult.fromI2b2(breakdownTypes.toSet)(loadString(expectedI2b2ErrorXml))
compareIgnoringBreakdowns(actual, errorResult)
}
@Test
def testToI2b2() {
queryResult.toI2b2String should equal(expectedI2b2Xml)
}
@Test
def testToI2b2WithBreakdowns() {
resultWithBreakDowns.toI2b2String should equal(expectedI2b2XmlWithBreakdowns)
}
@Test
def testToI2b2AllStatusTypes(): Unit = {
def doTest(statusType: QueryResult.StatusType) {
val expectedI2b2Xml = XmlUtil.stripWhitespace {
<query_result_instance>
<result_instance_id>{ resultId }</result_instance_id>
<query_instance_id>{ instanceId }</query_instance_id>
<description>{ description }</description>
{ resultType.toI2b2 }
<set_size>{ setSize }</set_size>
<start_date>{ date }</start_date>
<end_date>{ date }</end_date>
<query_status_type>
<name>{ statusType }</name>
<status_type_id>{ statusType.i2b2Id.get }</status_type_id><description>{ statusType }</description>
</query_status_type>
</query_result_instance>
}.toString
val result = queryResult.copy(statusType = statusType)
result.toI2b2String should equal(expectedI2b2Xml)
}
import QueryResult.StatusType
//NB: Error is tested by testToI2b2WithErrors()
val nonErrorStatuses = StatusType.values.toSet - StatusType.Error
for (statusType <- nonErrorStatuses) {
doTest(statusType)
}
}
@Test
def testToI2b2WithErrors(): Unit = {
val actual = QueryResult.errorResult(Some(description), statusMessage).toI2b2String
actual should equal(expectedI2b2ErrorXml)
}
@Test
- def testToI2B2WithErrorsAndProblemDigest():Unit = {
+ def testWithErrorsAndProblemDigest():Unit = {
+
val actual = QueryResult.errorResult(
Some(description),
statusMessage,
- Option(ProblemDigest(problemCodec,problemSummary,problemDescription,problemDetails))).toI2b2String
+ Option(ProblemDigest(problemCodec,problemSummary,problemDescription,problemDetails)))
+
+ val i2b2String = actual.toI2b2String
+
+ i2b2String should equal(expectedI2b2ErrorWithProblemDigestXml)
+
+ val i2b2 = actual.toI2b2
+ val fromI2b2 = QueryResult.fromI2b2(Set.empty)(i2b2)
+
+ println(i2b2)
+
+ println(fromI2b2)
+
+ fromI2b2 should equal(actual)
- actual should equal(expectedI2b2ErrorWithProblemDigestXml)
+ val xml = actual.toXml
+ val fromXml = QueryResult.fromXml(Set.empty)(xml)
+ fromXml should equal(actual)
}
}
\ No newline at end of file
diff --git a/commons/util/src/main/scala/net/shrine/serialization/I2b2Marshaller.scala b/commons/util/src/main/scala/net/shrine/serialization/I2b2Marshaller.scala
index eddd713f8..7beb32be0 100644
--- a/commons/util/src/main/scala/net/shrine/serialization/I2b2Marshaller.scala
+++ b/commons/util/src/main/scala/net/shrine/serialization/I2b2Marshaller.scala
@@ -1,19 +1,19 @@
package net.shrine.serialization
import xml.NodeSeq
/**
* @author Bill Simons
- * @date 3/24/11
- * @link http://cbmi.med.harvard.edu
- * @link http://chip.org
+ * @since 3/24/11
+ * @see http://cbmi.med.harvard.edu
+ * @see http://chip.org
* <p/>
* NOTICE: This software comes with NO guarantees whatsoever and is
* licensed as Lgpl Open Source
- * @link http://www.gnu.org/licenses/lgpl.html
+ * @see http://www.gnu.org/licenses/lgpl.html
*/
trait I2b2Marshaller {
def toI2b2: NodeSeq
- def toI2b2String: String = toI2b2.toString
+ def toI2b2String: String = toI2b2.toString()
}
\ No newline at end of file