From 02810f5eac3b4ce6a5d1128281a01b2a2ed0647c Mon Sep 17 00:00:00 2001
From: vlad <vlad@drivergrp.com>
Date: Fri, 21 Oct 2016 16:07:05 -0400
Subject: Renamed package to xyz, New formatting, authorize directive
 supporting multiple permissions

---
 src/test/scala/xyz/driver/core/AuthTest.scala      |  77 +++++++
 src/test/scala/xyz/driver/core/CoreTest.scala      |  61 ++++++
 src/test/scala/xyz/driver/core/FileTest.scala      | 126 +++++++++++
 .../scala/xyz/driver/core/GeneratorsTest.scala     | 234 +++++++++++++++++++++
 src/test/scala/xyz/driver/core/JsonTest.scala      | 101 +++++++++
 src/test/scala/xyz/driver/core/MessagesTest.scala  |  80 +++++++
 src/test/scala/xyz/driver/core/StatsTest.scala     |  43 ++++
 src/test/scala/xyz/driver/core/TimeTest.scala      |  87 ++++++++
 8 files changed, 809 insertions(+)
 create mode 100644 src/test/scala/xyz/driver/core/AuthTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/CoreTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/FileTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/GeneratorsTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/JsonTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/MessagesTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/StatsTest.scala
 create mode 100644 src/test/scala/xyz/driver/core/TimeTest.scala

(limited to 'src/test/scala/xyz/driver/core')

diff --git a/src/test/scala/xyz/driver/core/AuthTest.scala b/src/test/scala/xyz/driver/core/AuthTest.scala
new file mode 100644
index 0000000..fef3eda
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/AuthTest.scala
@@ -0,0 +1,77 @@
+package xyz.driver.core
+
+import akka.http.scaladsl.testkit.ScalatestRouteTest
+import akka.http.scaladsl.server._
+import Directives._
+import akka.http.scaladsl.model.headers.{HttpChallenges, RawHeader}
+import akka.http.scaladsl.server.AuthenticationFailedRejection.CredentialsRejected
+import org.scalatest.mock.MockitoSugar
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.auth._
+
+import scala.concurrent.Future
+import scalaz.OptionT
+
+class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRouteTest {
+
+  val authStatusService: AuthService[User] = new AuthService[User] {
+    override def authStatus(authToken: AuthToken): OptionT[Future, User] = OptionT.optionT[Future] {
+      Future.successful(Some(new User() {
+        override def id: Id[User]     = Id[User](1L)
+        override def roles: Set[Role] = Set(PathologistRole)
+      }))
+    }
+  }
+
+  import authStatusService._
+
+  "'authorize' directive" should "throw error is auth token is not in the request" in {
+
+    Get("/naive/attempt") ~>
+      authorize(CanSignOutReport) {
+        case (authToken, user) =>
+          complete("Never going to be here")
+      } ~>
+      check {
+        handled shouldBe false
+        rejections should contain(MissingHeaderRejection("WWW-Authenticate"))
+      }
+  }
+
+  it should "throw error is authorized user is not having the requested permission" in {
+
+    val referenceAuthToken = AuthToken(Base64("I am a pathologist's token"))
+
+    Post("/administration/attempt").addHeader(
+      RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value.value)
+    ) ~>
+      authorize(CanAssignRoles) {
+        case (authToken, user) =>
+          complete("Never going to get here")
+      } ~>
+      check {
+        handled shouldBe false
+        rejections should contain(
+          AuthenticationFailedRejection(
+            CredentialsRejected,
+            HttpChallenges.basic("User does not have the required permissions: CanAssignRoles")))
+      }
+  }
+
+  it should "pass and retrieve the token to client code, if token is in request and user has permission" in {
+
+    val referenceAuthToken = AuthToken(Base64("I am token"))
+
+    Get("/valid/attempt/?a=2&b=5").addHeader(
+      RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value.value)
+    ) ~>
+      authorize(CanSignOutReport) {
+        case (authToken, user) =>
+          complete("Alright, \"" + authToken.value.value + "\" is handled")
+      } ~>
+      check {
+        handled shouldBe true
+        responseAs[String] shouldBe "Alright, \"I am token\" is handled"
+      }
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/CoreTest.scala b/src/test/scala/xyz/driver/core/CoreTest.scala
new file mode 100644
index 0000000..f9a1aab
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/CoreTest.scala
@@ -0,0 +1,61 @@
+package xyz.driver.core
+
+import java.io.ByteArrayOutputStream
+
+import org.mockito.Mockito._
+import org.scalatest.mock.MockitoSugar
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.revision.Revision
+
+class CoreTest extends FlatSpec with Matchers with MockitoSugar {
+
+  "'make' function" should "allow initialization for objects" in {
+
+    val createdAndInitializedValue = make(new ByteArrayOutputStream(128)) { baos =>
+      baos.write(Array(1.toByte, 1.toByte, 0.toByte))
+    }
+
+    createdAndInitializedValue.toByteArray should be(Array(1.toByte, 1.toByte, 0.toByte))
+  }
+
+  "'using' function" should "call close after performing action on resource" in {
+
+    val baos = mock[ByteArrayOutputStream]
+
+    using(baos /* usually new ByteArrayOutputStream(128) */ ) { baos =>
+      baos.write(Array(1.toByte, 1.toByte, 0.toByte))
+    }
+
+    verify(baos).close()
+  }
+
+  "Id" should "have equality and ordering working correctly" in {
+
+    (Id[String](1234213L) === Id[String](1234213L)) should be(true)
+    (Id[String](1234213L) === Id[String](213414L)) should be(false)
+    (Id[String](213414L) === Id[String](1234213L)) should be(false)
+
+    Seq(Id[String](4L), Id[String](3L), Id[String](2L), Id[String](1L)).sorted should contain
+    theSameElementsInOrderAs(Seq(Id[String](1L), Id[String](2L), Id[String](3L), Id[String](4L)))
+  }
+
+  "Name" should "have equality and ordering working correctly" in {
+
+    (Name[String]("foo") === Name[String]("foo")) should be(true)
+    (Name[String]("foo") === Name[String]("bar")) should be(false)
+    (Name[String]("bar") === Name[String]("foo")) should be(false)
+
+    Seq(Name[String]("d"), Name[String]("cc"), Name[String]("a"), Name[String]("bbb")).sorted should contain
+    theSameElementsInOrderAs(Seq(Name[String]("a"), Name[String]("bbb"), Name[String]("cc"), Name[String]("d")))
+  }
+
+  "Revision" should "have equality working correctly" in {
+
+    val bla = Revision[String]("85569dab-a3dc-401b-9f95-d6fb4162674b")
+    val foo = Revision[String]("f54b3558-bdcd-4646-a14b-8beb11f6b7c4")
+
+    (bla === bla) should be(true)
+    (bla === foo) should be(false)
+    (foo === bla) should be(false)
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/FileTest.scala b/src/test/scala/xyz/driver/core/FileTest.scala
new file mode 100644
index 0000000..aba79f7
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/FileTest.scala
@@ -0,0 +1,126 @@
+package xyz.driver.core
+
+import java.io.File
+import java.nio.file.Paths
+
+import com.amazonaws.services.s3.AmazonS3
+import com.amazonaws.services.s3.model._
+import org.mockito.Matchers._
+import org.mockito.Mockito._
+import org.scalatest.mock.MockitoSugar
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.file.{FileSystemStorage, S3Storage}
+
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+class FileTest extends FlatSpec with Matchers with MockitoSugar {
+
+  "S3 Storage" should "create and download local files and do other operations" in {
+    import scala.collection.JavaConverters._
+
+    val tempDir        = System.getProperty("java.io.tmpdir")
+    val sourceTestFile = generateTestLocalFile(tempDir)
+    val testFileName   = "uploadTestFile"
+
+    val randomFolderName = java.util.UUID.randomUUID().toString
+    val testDirPath      = Paths.get(randomFolderName)
+    val testFilePath     = Paths.get(randomFolderName, testFileName)
+
+    val testBucket = Name[Bucket]("IamBucket")
+
+    val s3PutMock = mock[PutObjectResult]
+    when(s3PutMock.getETag).thenReturn("IAmEtag")
+
+    val s3ObjectSummaryMock = mock[S3ObjectSummary]
+    when(s3ObjectSummaryMock.getKey).thenReturn(testFileName)
+    when(s3ObjectSummaryMock.getETag).thenReturn("IAmEtag")
+    when(s3ObjectSummaryMock.getLastModified).thenReturn(new java.util.Date())
+
+    val s3ResultsMock = mock[ListObjectsV2Result]
+    when(s3ResultsMock.getNextContinuationToken).thenReturn("continuationToken")
+    when(s3ResultsMock.isTruncated).thenReturn(false, // before file created it is empty (zero pages)
+                                               true,
+                                               false, // after file is uploaded it contains this one file (one page)
+                                               false) // after file is deleted it is empty (zero pages) again
+    when(s3ResultsMock.getObjectSummaries).thenReturn(
+      // before file created it is empty, `getObjectSummaries` is never called
+      List[S3ObjectSummary](s3ObjectSummaryMock).asJava, // after file is uploaded it contains this one file
+      List.empty[S3ObjectSummary].asJava) // after file is deleted it is empty again
+
+    val s3ObjectMetadataMock = mock[ObjectMetadata]
+    val amazonS3Mock         = mock[AmazonS3]
+    when(amazonS3Mock.listObjectsV2(any[ListObjectsV2Request]())).thenReturn(s3ResultsMock)
+    when(amazonS3Mock.putObject(testBucket, testFilePath.toString, sourceTestFile)).thenReturn(s3PutMock)
+    when(amazonS3Mock.getObject(any[GetObjectRequest](), any[File]())).thenReturn(s3ObjectMetadataMock)
+
+    val s3Storage = new S3Storage(amazonS3Mock, testBucket, scala.concurrent.ExecutionContext.global)
+
+    val filesBefore = Await.result(s3Storage.list(testDirPath).run, 10 seconds)
+    filesBefore shouldBe empty
+
+    Await.result(s3Storage.upload(sourceTestFile, testFilePath), 10 seconds)
+
+    val filesAfterUpload = Await.result(s3Storage.list(testDirPath).run, 10 seconds)
+    filesAfterUpload.size should be(1)
+    val uploadedFileLine = filesAfterUpload.head
+    uploadedFileLine.name should be(Name[File](testFileName))
+    uploadedFileLine.location should be(testFilePath)
+    uploadedFileLine.revision.id.length should be > 0
+    uploadedFileLine.lastModificationDate.millis should be > 0L
+
+    val downloadedFile = Await.result(s3Storage.download(testFilePath).run, 10 seconds)
+    downloadedFile shouldBe defined
+    downloadedFile.foreach {
+      _.getAbsolutePath.endsWith(testFilePath.toString) should be(true)
+    }
+
+    Await.result(s3Storage.delete(testFilePath), 10 seconds)
+
+    val filesAfterRemoval = Await.result(s3Storage.list(testDirPath).run, 10 seconds)
+    filesAfterRemoval shouldBe empty
+  }
+
+  "Filesystem files storage" should "create and download local files and do other operations" in {
+
+    val tempDir        = System.getProperty("java.io.tmpdir")
+    val sourceTestFile = generateTestLocalFile(tempDir)
+
+    val randomFolderName = java.util.UUID.randomUUID().toString
+    val testDirPath      = Paths.get(tempDir, randomFolderName)
+    val testFilePath     = Paths.get(tempDir, randomFolderName, "uploadTestFile")
+
+    val fileStorage = new FileSystemStorage(scala.concurrent.ExecutionContext.global)
+
+    val filesBefore = Await.result(fileStorage.list(testDirPath).run, 10 seconds)
+    filesBefore shouldBe empty
+
+    Await.result(fileStorage.upload(sourceTestFile, testFilePath), 10 seconds)
+
+    val filesAfterUpload = Await.result(fileStorage.list(testDirPath).run, 10 seconds)
+    filesAfterUpload.size should be(1)
+    val uploadedFileLine = filesAfterUpload.head
+    uploadedFileLine.name should be(Name[File]("uploadTestFile"))
+    uploadedFileLine.location should be(testFilePath)
+    uploadedFileLine.revision.id.length should be > 0
+    uploadedFileLine.lastModificationDate.millis should be > 0L
+
+    val downloadedFile = Await.result(fileStorage.download(testFilePath).run, 10 seconds)
+    downloadedFile shouldBe defined
+    downloadedFile.map(_.getAbsolutePath) should be(Some(testFilePath.toString))
+
+    Await.result(fileStorage.delete(testFilePath), 10 seconds)
+
+    val filesAfterRemoval = Await.result(fileStorage.list(testDirPath).run, 10 seconds)
+    filesAfterRemoval shouldBe empty
+  }
+
+  private def generateTestLocalFile(path: String): File = {
+    val randomSourceFolderName = java.util.UUID.randomUUID().toString
+    val sourceTestFile         = new File(Paths.get(path, randomSourceFolderName, "uploadTestFile").toString)
+    sourceTestFile.getParentFile.mkdirs() should be(true)
+    sourceTestFile.createNewFile() should be(true)
+    using(new java.io.PrintWriter(sourceTestFile)) { _.append("Test File Contents") }
+    sourceTestFile
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/GeneratorsTest.scala b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
new file mode 100644
index 0000000..0432b2a
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
@@ -0,0 +1,234 @@
+package xyz.driver.core
+
+import org.scalatest.{Assertions, FlatSpec, Matchers}
+
+class GeneratorsTest extends FlatSpec with Matchers with Assertions {
+  import generators._
+
+  "Generators" should "be able to generate com.drivergrp.core.Id identifiers" in {
+
+    val generatedId1 = nextId[String]()
+    val generatedId2 = nextId[String]()
+    val generatedId3 = nextId[Long]()
+
+    generatedId1 should be >= 0L
+    generatedId2 should be >= 0L
+    generatedId3 should be >= 0L
+    generatedId1 should not be generatedId2
+    generatedId2 should !==(generatedId3)
+  }
+
+  it should "be able to generate com.drivergrp.core.Id identifiers with max value" in {
+
+    val generatedLimitedId1 = nextId[String](10000)
+    val generatedLimitedId2 = nextId[String](1000)
+    val generatedLimitedId3 = nextId[Long](2000)
+
+    generatedLimitedId1 should be >= 0L
+    generatedLimitedId1 should be < 10000L
+    generatedLimitedId2 should be >= 0L
+    generatedLimitedId2 should be < 1000L
+    generatedLimitedId3 should be >= 0L
+    generatedLimitedId3 should be < 2000L
+    generatedLimitedId1 should not be generatedLimitedId2
+    generatedLimitedId2 should !==(generatedLimitedId3)
+  }
+
+  it should "be able to generate com.drivergrp.core.Name names" in {
+
+    nextName[String]() should not be nextName[String]()
+    nextName[String]().length should be >= 0
+
+    val fixedLengthName = nextName[String](10)
+    fixedLengthName.length should be <= 10
+    assert(!fixedLengthName.exists(_.isControl))
+  }
+
+  it should "be able to generate proper UUIDs" in {
+
+    nextUuid() should not be nextUuid()
+    nextUuid().toString.length should be(36)
+  }
+
+  it should "be able to generate new Revisions" in {
+
+    nextRevision[String]() should not be nextRevision[String]()
+    nextRevision[String]().id.length should be > 0
+  }
+
+  it should "be able to generate strings" in {
+
+    nextString() should not be nextString()
+    nextString().length should be >= 0
+
+    val fixedLengthString = nextString(20)
+    fixedLengthString.length should be <= 20
+    assert(!fixedLengthString.exists(_.isControl))
+  }
+
+  it should "be able to generate options which are sometimes have values and sometimes not" in {
+
+    val generatedOption = nextOption("2")
+
+    generatedOption should not contain "1"
+    assert(generatedOption === Some("2") || generatedOption === None)
+  }
+
+  it should "be able to generate a pair of two generated values" in {
+
+    val constantPair = nextPair("foo", 1L)
+    constantPair._1 should be("foo")
+    constantPair._2 should be(1L)
+
+    val generatedPair = nextPair(nextId[Int](), nextName[Int]())
+
+    generatedPair._1 should be > 0L
+    generatedPair._2.length should be > 0
+
+    nextPair(nextId[Int](), nextName[Int]()) should not be
+      nextPair(nextId[Int](), nextName[Int]())
+  }
+
+  it should "be able to generate a triad of two generated values" in {
+
+    val constantTriad = nextTriad("foo", "bar", 1L)
+    constantTriad._1 should be("foo")
+    constantTriad._2 should be("bar")
+    constantTriad._3 should be(1L)
+
+    val generatedTriad = nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal())
+
+    generatedTriad._1 should be > 0L
+    generatedTriad._2.length should be > 0
+    generatedTriad._3 should be >= BigDecimal(0.00)
+
+    nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal()) should not be
+      nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal())
+  }
+
+  it should "be able to generate a time value" in {
+
+    val generatedTime = nextTime()
+    val currentTime   = System.currentTimeMillis()
+
+    generatedTime.millis should be >= 0L
+    generatedTime.millis should be <= currentTime
+  }
+
+  it should "be able to generate a time range value" in {
+
+    val generatedTimeRange = nextTimeRange()
+    val currentTime        = System.currentTimeMillis()
+
+    generatedTimeRange.start.millis should be >= 0L
+    generatedTimeRange.start.millis should be <= currentTime
+    generatedTimeRange.end.millis should be >= 0L
+    generatedTimeRange.end.millis should be <= currentTime
+    generatedTimeRange.start.millis should be <= generatedTimeRange.end.millis
+  }
+
+  it should "be able to generate a BigDecimal value" in {
+
+    val defaultGeneratedBigDecimal = nextBigDecimal()
+
+    defaultGeneratedBigDecimal should be >= BigDecimal(0.00)
+    defaultGeneratedBigDecimal should be <= BigDecimal(1000000.00)
+    defaultGeneratedBigDecimal.precision should be(2)
+
+    val unitIntervalBigDecimal = nextBigDecimal(1.00, 8)
+
+    unitIntervalBigDecimal should be >= BigDecimal(0.00)
+    unitIntervalBigDecimal should be <= BigDecimal(1.00)
+    unitIntervalBigDecimal.precision should be(8)
+  }
+
+  it should "be able to generate a specific value from a set of values" in {
+
+    val possibleOptions = Set(1, 3, 5, 123, 0, 9)
+
+    val pick1 = generators.oneOf(possibleOptions)
+    val pick2 = generators.oneOf(possibleOptions)
+    val pick3 = generators.oneOf(possibleOptions)
+
+    possibleOptions should contain(pick1)
+    possibleOptions should contain(pick2)
+    possibleOptions should contain(pick3)
+
+    val pick4 = generators.oneOf(1, 3, 5, 123, 0, 9)
+    val pick5 = generators.oneOf(1, 3, 5, 123, 0, 9)
+    val pick6 = generators.oneOf(1, 3, 5, 123, 0, 9)
+
+    possibleOptions should contain(pick4)
+    possibleOptions should contain(pick5)
+    possibleOptions should contain(pick6)
+
+    Set(pick1, pick2, pick3, pick4, pick5, pick6).size should be >= 1
+  }
+
+  it should "be able to generate array with values generated by generators" in {
+
+    val arrayOfTimes = arrayOf(nextTime(), 16)
+    arrayOfTimes.length should be <= 16
+
+    val arrayOfBigDecimals = arrayOf(nextBigDecimal(), 8)
+    arrayOfBigDecimals.length should be <= 8
+  }
+
+  it should "be able to generate seq with values generated by generators" in {
+
+    val seqOfTimes = seqOf(nextTime(), 16)
+    seqOfTimes.size should be <= 16
+
+    val seqOfBigDecimals = seqOf(nextBigDecimal(), 8)
+    seqOfBigDecimals.size should be <= 8
+  }
+
+  it should "be able to generate vector with values generated by generators" in {
+
+    val vectorOfTimes = vectorOf(nextTime(), 16)
+    vectorOfTimes.size should be <= 16
+
+    val vectorOfStrings = seqOf(nextString(), 8)
+    vectorOfStrings.size should be <= 8
+  }
+
+  it should "be able to generate list with values generated by generators" in {
+
+    val listOfTimes = listOf(nextTime(), 16)
+    listOfTimes.size should be <= 16
+
+    val listOfBigDecimals = seqOf(nextBigDecimal(), 8)
+    listOfBigDecimals.size should be <= 8
+  }
+
+  it should "be able to generate set with values generated by generators" in {
+
+    val setOfTimes = vectorOf(nextTime(), 16)
+    setOfTimes.size should be <= 16
+
+    val setOfBigDecimals = seqOf(nextBigDecimal(), 8)
+    setOfBigDecimals.size should be <= 8
+  }
+
+  it should "be able to generate maps with keys and values generated by generators" in {
+
+    val generatedConstantMap = mapOf(10, "key", 123)
+    generatedConstantMap.size should be <= 1
+    assert(generatedConstantMap.keys.forall(_ == "key"))
+    assert(generatedConstantMap.values.forall(_ == 123))
+
+    val generatedMap = mapOf(10, nextString(10), nextBigDecimal())
+    assert(generatedMap.keys.forall(_.length <= 10))
+    assert(generatedMap.values.forall(_ >= BigDecimal(0.00)))
+  }
+
+  it should "compose deeply" in {
+
+    val generatedNestedMap = mapOf(10, nextString(10), nextPair(nextBigDecimal(), nextOption(123)))
+
+    generatedNestedMap.size should be <= 10
+    generatedNestedMap.keySet.size should be <= 10
+    generatedNestedMap.values.size should be <= 10
+    assert(generatedNestedMap.values.forall(value => !value._2.exists(_ != 123)))
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/JsonTest.scala b/src/test/scala/xyz/driver/core/JsonTest.scala
new file mode 100644
index 0000000..bcdcd5d
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/JsonTest.scala
@@ -0,0 +1,101 @@
+package xyz.driver.core
+
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.json.{EnumJsonFormat, ValueClassFormat}
+import xyz.driver.core.revision.Revision
+import xyz.driver.core.time.provider.SystemTimeProvider
+
+class JsonTest extends FlatSpec with Matchers {
+
+  "Json format for Id" should "read and write correct JSON" in {
+
+    val referenceId = Id[String](1312L)
+
+    val writtenJson = json.idFormat.write(referenceId)
+    writtenJson.prettyPrint should be("1312")
+
+    val parsedId = json.idFormat.read(writtenJson)
+    parsedId should be(referenceId)
+  }
+
+  "Json format for Name" should "read and write correct JSON" in {
+
+    val referenceName = Name[String]("Homer")
+
+    val writtenJson = json.nameFormat.write(referenceName)
+    writtenJson.prettyPrint should be("\"Homer\"")
+
+    val parsedName = json.nameFormat.read(writtenJson)
+    parsedName should be(referenceName)
+  }
+
+  "Json format for Time" should "read and write correct JSON" in {
+
+    val referenceTime = new SystemTimeProvider().currentTime()
+
+    val writtenJson = json.timeFormat.write(referenceTime)
+    writtenJson.prettyPrint should be("{\n  \"timestamp\": " + referenceTime.millis + "\n}")
+
+    val parsedTime = json.timeFormat.read(writtenJson)
+    parsedTime should be(referenceTime)
+  }
+
+  "Json format for Revision" should "read and write correct JSON" in {
+
+    val referenceRevision = Revision[String]("037e2ec0-8901-44ac-8e53-6d39f6479db4")
+
+    val writtenJson = json.revisionFormat.write(referenceRevision)
+    writtenJson.prettyPrint should be("\"" + referenceRevision.id + "\"")
+
+    val parsedRevision = json.revisionFormat.read(writtenJson)
+    parsedRevision should be(referenceRevision)
+  }
+
+  "Json format for Enums" should "read and write correct JSON" in {
+
+    sealed trait EnumVal
+    case object Val1 extends EnumVal
+    case object Val2 extends EnumVal
+    case object Val3 extends EnumVal
+
+    val format = new EnumJsonFormat[EnumVal]("a" -> Val1, "b" -> Val2, "c" -> Val3)
+
+    val referenceEnumValue1 = Val2
+    val referenceEnumValue2 = Val3
+
+    val writtenJson1 = format.write(referenceEnumValue1)
+    writtenJson1.prettyPrint should be("\"b\"")
+
+    val writtenJson2 = format.write(referenceEnumValue2)
+    writtenJson2.prettyPrint should be("\"c\"")
+
+    val parsedEnumValue1 = format.read(writtenJson1)
+    val parsedEnumValue2 = format.read(writtenJson2)
+
+    parsedEnumValue1 should be(referenceEnumValue1)
+    parsedEnumValue2 should be(referenceEnumValue2)
+  }
+
+  // Should be defined outside of case to have a TypeTag
+  case class CustomWrapperClass(value: Int)
+
+  "Json format for Value classes" should "read and write correct JSON" in {
+
+    val format = new ValueClassFormat[CustomWrapperClass](v => BigDecimal(v.value), d => CustomWrapperClass(d.toInt))
+
+    val referenceValue1 = CustomWrapperClass(-2)
+    val referenceValue2 = CustomWrapperClass(10)
+
+    val writtenJson1 = format.write(referenceValue1)
+    writtenJson1.prettyPrint should be("-2")
+
+    val writtenJson2 = format.write(referenceValue2)
+    writtenJson2.prettyPrint should be("10")
+
+    val parsedValue1 = format.read(writtenJson1)
+    val parsedValue2 = format.read(writtenJson2)
+
+    parsedValue1 should be(referenceValue1)
+    parsedValue2 should be(referenceValue2)
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/MessagesTest.scala b/src/test/scala/xyz/driver/core/MessagesTest.scala
new file mode 100644
index 0000000..dc44ee1
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/MessagesTest.scala
@@ -0,0 +1,80 @@
+package xyz.driver.core
+
+import java.util.Locale
+
+import com.typesafe.config.{ConfigException, ConfigFactory}
+import org.mockito.Mockito._
+import org.scalatest.mock.MockitoSugar
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.logging.Logger
+import xyz.driver.core.messages.Messages
+
+import scala.collection.JavaConversions._
+
+class MessagesTest extends FlatSpec with Matchers with MockitoSugar {
+
+  val englishLocaleMessages =
+    Map("en.greeting" -> "Hello {0}!", "en.greetingFullName" -> "Hello {0} {1} {2}!", "en.hello" -> "Hello world!")
+
+  "Messages" should "read messages from config and format with parameters" in {
+
+    val log            = mock[Logger]
+    val messagesConfig = ConfigFactory.parseMap(englishLocaleMessages)
+
+    val messages = Messages.messages(messagesConfig, log, Locale.US)
+
+    messages("hello") should be("Hello world!")
+    messages("greeting", "Homer") should be("Hello Homer!")
+    messages("greetingFullName", "Homer", "J", "Simpson") should be("Hello Homer J Simpson!")
+  }
+
+  it should "be able to read messages for different locales" in {
+
+    val log = mock[Logger]
+
+    val messagesConfig = ConfigFactory.parseMap(
+      englishLocaleMessages ++ Map(
+        "zh.hello"            -> "你好，世界!",
+        "zh.greeting"         -> "你好，{0}!",
+        "zh.greetingFullName" -> "你好，{0} {1} {2}!"
+      ))
+
+    val englishMessages    = Messages.messages(messagesConfig, log, Locale.US)
+    val englishMessagesToo = Messages.messages(messagesConfig, log, Locale.ENGLISH)
+    val chineseMessages    = Messages.messages(messagesConfig, log, Locale.CHINESE)
+
+    englishMessages("hello") should be("Hello world!")
+    englishMessages("greeting", "Homer") should be("Hello Homer!")
+    englishMessages("greetingFullName", "Homer", "J", "Simpson") should be("Hello Homer J Simpson!")
+
+    englishMessagesToo("hello") should be(englishMessages("hello"))
+    englishMessagesToo("greeting", "Homer") should be(englishMessages("greeting", "Homer"))
+    englishMessagesToo("greetingFullName", "Homer", "J", "Simpson") should be(
+      englishMessages("greetingFullName", "Homer", "J", "Simpson"))
+
+    chineseMessages("hello") should be("你好，世界!")
+    chineseMessages("greeting", "Homer") should be("你好，Homer!")
+    chineseMessages("greetingFullName", "Homer", "J", "Simpson") should be("你好，Homer J Simpson!")
+  }
+
+  it should "raise exception when locale is not available" in {
+
+    val log            = mock[Logger]
+    val messagesConfig = ConfigFactory.parseMap(englishLocaleMessages)
+
+    an[ConfigException.Missing] should be thrownBy
+      Messages.messages(messagesConfig, log, Locale.GERMAN)
+  }
+
+  it should "log a problem, when there is no message for key" in {
+
+    val log            = mock[Logger]
+    val messagesConfig = ConfigFactory.parseMap(englishLocaleMessages)
+
+    val messages = Messages.messages(messagesConfig, log, Locale.US)
+
+    messages("howdy") should be("howdy")
+
+    verify(log).error(s"Message with key 'howdy' not found for locale 'en'")
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/StatsTest.scala b/src/test/scala/xyz/driver/core/StatsTest.scala
new file mode 100644
index 0000000..27ea1bd
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/StatsTest.scala
@@ -0,0 +1,43 @@
+package xyz.driver.core
+
+import org.mockito.Mockito._
+import org.scalatest.mock.MockitoSugar
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.logging.Logger
+import xyz.driver.core.stats.LogStats
+import xyz.driver.core.time.{Time, TimeRange}
+
+class StatsTest extends FlatSpec with Matchers with MockitoSugar {
+
+  "Stats" should "format and store all recorded data" in {
+
+    val log   = mock[Logger]
+    val stats = new LogStats(log)
+
+    stats.recordStats(Seq(), TimeRange(Time(2L), Time(5L)), BigDecimal(123.324))
+    verify(log).audit(s"(2-5)=123.324")
+
+    stats.recordStats("stat", TimeRange(Time(5L), Time(5L)), BigDecimal(333L))
+    verify(log).audit(s"stat(5-5)=333")
+
+    stats.recordStats("stat", Time(934L), 123)
+    verify(log).audit(s"stat(934-934)=123")
+
+    stats.recordStats("stat", Time(0L), 123)
+    verify(log).audit(s"stat(0-0)=123")
+  }
+
+  it should "format BigDecimal with all precision digits" in {
+
+    val log   = mock[Logger]
+    val stats = new LogStats(log)
+
+    stats.recordStats(Seq("root", "group", "stat", "substat"),
+                      TimeRange(Time(1467381889834L), Time(1468937089834L)),
+                      BigDecimal(3.333333333333333))
+    verify(log).audit(s"root.group.stat.substat(1467381889834-1468937089834)=3.333333333333333")
+
+    stats.recordStats("stat", Time(1233L), BigDecimal(0.00000000000000000000001))
+    verify(log).audit(s"stat(1233-1233)=0.000000000000000000000010")
+  }
+}
diff --git a/src/test/scala/xyz/driver/core/TimeTest.scala b/src/test/scala/xyz/driver/core/TimeTest.scala
new file mode 100644
index 0000000..76ef42c
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/TimeTest.scala
@@ -0,0 +1,87 @@
+package xyz.driver.core
+
+import java.util.TimeZone
+
+import org.scalacheck.Arbitrary._
+import org.scalacheck.Prop.BooleanOperators
+import org.scalacheck.{Arbitrary, Gen}
+import org.scalatest.prop.Checkers
+import org.scalatest.{FlatSpec, Matchers}
+import xyz.driver.core.time.{Time, _}
+
+import scala.concurrent.duration._
+
+class TimeTest extends FlatSpec with Matchers with Checkers {
+
+  implicit val arbitraryDuration = Arbitrary[Duration](Gen.chooseNum(0L, 9999999999L).map(_.milliseconds))
+  implicit val arbitraryTime     = Arbitrary[Time](Gen.chooseNum(0L, 9999999999L).map(millis => Time(millis)))
+
+  "Time" should "have correct methods to compare" in {
+
+    Time(234L).isAfter(Time(123L)) should be(true)
+    Time(123L).isAfter(Time(123L)) should be(false)
+    Time(123L).isAfter(Time(234L)) should be(false)
+
+    check((a: Time, b: Time) => (a.millis > b.millis) ==> a.isAfter(b))
+
+    Time(234L).isBefore(Time(123L)) should be(false)
+    Time(123L).isBefore(Time(123L)) should be(false)
+    Time(123L).isBefore(Time(234L)) should be(true)
+
+    check { (a: Time, b: Time) =>
+      (a.millis < b.millis) ==> a.isBefore(b)
+    }
+  }
+
+  it should "not modify time" in {
+
+    Time(234L).millis should be(234L)
+
+    check { millis: Long =>
+      Time(millis).millis == millis
+    }
+  }
+
+  it should "support arithmetic with scala.concurrent.duration" in {
+
+    Time(123L).advanceBy(0 minutes).millis should be(123L)
+    Time(123L).advanceBy(1 second).millis should be(123L + Second)
+    Time(123L).advanceBy(4 days).millis should be(123L + 4 * Days)
+
+    check { (time: Time, duration: Duration) =>
+      time.advanceBy(duration).millis == (time.millis + duration.toMillis)
+    }
+  }
+
+  it should "have ordering defined correctly" in {
+
+    Seq(Time(321L), Time(123L), Time(231L)).sorted should
+      contain theSameElementsInOrderAs Seq(Time(123L), Time(231L), Time(321L))
+
+    check { times: List[Time] =>
+      times.sorted.sliding(2).filter(_.size == 2).forall {
+        case Seq(a, b) =>
+          a.millis <= b.millis
+      }
+    }
+  }
+
+  it should "reset to the start of the period, e.g. month" in {
+
+    startOfMonth(Time(1468937089834L)) should be(Time(1467381889834L))
+    startOfMonth(Time(1467381889834L)) should be(Time(1467381889834L)) // idempotent
+  }
+
+  it should "have correct textual representations" in {
+
+    textualDate(TimeZone.getTimeZone("EDT"))(Time(1468937089834L)) should be("July 19, 2016")
+    textualTime(TimeZone.getTimeZone("PDT"))(Time(1468937089834L)) should be("Jul 19, 2016 02:04:49 PM")
+  }
+
+  "TimeRange" should "have duration defined as a difference of start and end times" in {
+
+    TimeRange(Time(321L), Time(432L)).duration should be(111.milliseconds)
+    TimeRange(Time(432L), Time(321L)).duration should be((-111).milliseconds)
+    TimeRange(Time(333L), Time(333L)).duration should be(0.milliseconds)
+  }
+}
-- 
cgit v1.2.3


From 88978d91edca16f9c6a4177b5ed997bc12486b29 Mon Sep 17 00:00:00 2001
From: vlad <vlad@drivergrp.com>
Date: Wed, 26 Oct 2016 20:06:38 -0400
Subject: Request tracing and audit logging

---
 src/main/scala/xyz/driver/core/app.scala      | 80 ++++++++++++++-------------
 src/main/scala/xyz/driver/core/auth.scala     | 11 +++-
 src/main/scala/xyz/driver/core/rest.scala     |  3 +-
 src/test/scala/xyz/driver/core/AuthTest.scala |  4 +-
 4 files changed, 54 insertions(+), 44 deletions(-)

(limited to 'src/test/scala/xyz/driver/core')

diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala
index e080e1b..8f892e8 100644
--- a/src/main/scala/xyz/driver/core/app.scala
+++ b/src/main/scala/xyz/driver/core/app.scala
@@ -7,12 +7,13 @@ import akka.http.scaladsl.model.StatusCodes._
 import akka.http.scaladsl.model.{HttpResponse, StatusCodes}
 import akka.http.scaladsl.server.Directives._
 import akka.http.scaladsl.server.RouteResult._
-import akka.http.scaladsl.server.{ExceptionHandler, Route, RouteConcatenation}
+import akka.http.scaladsl.server.{ExceptionHandler, RequestContext, Route, RouteConcatenation}
 import akka.stream.ActorMaterializer
 import com.typesafe.config.Config
 import org.slf4j.LoggerFactory
 import spray.json.DefaultJsonProtocol
 import xyz.driver.core
+import xyz.driver.core.auth.AuthService
 import xyz.driver.core.logging.{Logger, TypesafeScalaLogger}
 import xyz.driver.core.rest.Swagger
 import xyz.driver.core.stats.SystemStats
@@ -63,48 +64,51 @@ object app {
       val swaggerRoutes  = swaggerService.routes ~ swaggerService.swaggerUI
       val versionRt      = versionRoute(version, gitHash, time.currentTime())
 
-      val generalExceptionHandler = ExceptionHandler {
-
-        case is: IllegalStateException =>
-          extractUri { uri =>
-            // TODO: extract `requestUuid` from request or thread, provided by linkerd/zipkin
-            def requestUuid = java.util.UUID.randomUUID.toString
-
-            log.debug(s"Request is not allowed to $uri ($requestUuid)", is)
-            complete(
-              HttpResponse(BadRequest,
-                           entity = s"""{ "requestUuid": "$requestUuid", "message": "${is.getMessage}" }"""))
-          }
-
-        case cm: ConcurrentModificationException =>
-          extractUri { uri =>
-            // TODO: extract `requestUuid` from request or thread, provided by linkerd/zipkin
-            def requestUuid = java.util.UUID.randomUUID.toString
-
-            log.debug(s"Concurrent modification of the resource $uri ($requestUuid)", cm)
-            complete(
-              HttpResponse(Conflict, entity = s"""{ "requestUuid": "$requestUuid", "message": "${cm.getMessage}" }"""))
-          }
-
-        case t: Throwable =>
-          extractUri { uri =>
-            // TODO: extract `requestUuid` from request or thread, provided by linkerd/zipkin
-            def requestUuid = java.util.UUID.randomUUID.toString
-
-            log.error(s"Request to $uri could not be handled normally ($requestUuid)", t)
-            complete(
-              HttpResponse(InternalServerError,
-                           entity = s"""{ "requestUuid": "$requestUuid", "message": "${t.getMessage}" }"""))
-          }
-      }
-
       val _ = Future {
-        http.bindAndHandle(route2HandlerFlow(handleExceptions(generalExceptionHandler) {
-          logRequestResult("log")(modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _))
+        http.bindAndHandle(route2HandlerFlow(handleExceptions(exceptionHandler) { ctx =>
+          log.audit(s"Received request ${ctx.request}")
+          modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _)(ctx)
         }), interface, port)(materializer)
       }
     }
 
+    protected def extractTrackingId(ctx: RequestContext) = {
+      ctx.request.headers
+        .find(_.name == AuthService.TrackingIdHeader)
+        .map(_.value())
+        .getOrElse(java.util.UUID.randomUUID.toString)
+      // TODO: In the case when absent, should be taken the same generated id, as in `authorize`
+    }
+
+    protected def exceptionHandler = ExceptionHandler {
+
+      case is: IllegalStateException =>
+        ctx =>
+          val trackingId = extractTrackingId(ctx)
+          log.debug(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is)
+          complete(
+            HttpResponse(BadRequest, entity = s"""{ "trackingId": "$trackingId", "message": "${is.getMessage}" }"""))(
+            ctx)
+
+      case cm: ConcurrentModificationException =>
+        ctx =>
+          val trackingId                    = extractTrackingId(ctx)
+          val concurrentModificationMessage = "Resource was changed concurrently, try requesting a newer version"
+          log.audit(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm)
+          complete(
+            HttpResponse(
+              Conflict,
+              entity = s"""{ "trackingId": "$trackingId", "message": "$concurrentModificationMessage" }"""))(ctx)
+
+      case t: Throwable =>
+        ctx =>
+          val trackingId = extractTrackingId(ctx)
+          log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t)
+          complete(
+            HttpResponse(InternalServerError,
+                         entity = s"""{ "trackingId": "$trackingId", "message": "${t.getMessage}" }"""))(ctx)
+    }
+
     protected def versionRoute(version: String, gitHash: String, startupTime: Time): Route = {
       import DefaultJsonProtocol._
       import SprayJsonSupport._
diff --git a/src/main/scala/xyz/driver/core/auth.scala b/src/main/scala/xyz/driver/core/auth.scala
index 874f1e1..17f89c0 100644
--- a/src/main/scala/xyz/driver/core/auth.scala
+++ b/src/main/scala/xyz/driver/core/auth.scala
@@ -72,12 +72,13 @@ object auth {
 
   final case class Base64[T](value: String)
 
-  final case class AuthToken(value: Base64[Macaroon])
+  final case class AuthToken(value: Base64[Macaroon], trackingId: String)
 
   final case class PasswordHash(value: String)
 
   object AuthService {
     val AuthenticationTokenHeader = "WWW-Authenticate"
+    val TrackingIdHeader          = "l5d-ctx-trace" // https://linkerd.io/doc/0.7.4/linkerd/protocol-http/
   }
 
   trait AuthService[U <: User] {
@@ -90,16 +91,20 @@ object auth {
     def authorize(permissions: Permission*): Directive1[(AuthToken, U)] = {
       parameters('authToken.?).flatMap { parameterTokenValue =>
         optionalHeaderValueByName(AuthService.AuthenticationTokenHeader).flatMap { headerTokenValue =>
-          verifyAuthToken(headerTokenValue.orElse(parameterTokenValue), permissions.toSet)
+          optionalHeaderValueByName(AuthService.TrackingIdHeader).flatMap { trackingIdValue =>
+            verifyAuthToken(headerTokenValue.orElse(parameterTokenValue), trackingIdValue, permissions.toSet)
+          }
         }
       }
     }
 
     private def verifyAuthToken(tokenOption: Option[String],
+                                trackingIdValue: Option[String],
                                 permissions: Set[Permission]): Directive1[(AuthToken, U)] =
       tokenOption match {
         case Some(tokenValue) =>
-          val token = AuthToken(Base64[Macaroon](tokenValue))
+          val trackingId = trackingIdValue.getOrElse(java.util.UUID.randomUUID.toString)
+          val token      = AuthToken(Base64[Macaroon](tokenValue), trackingId)
 
           onComplete(authStatus(token).run).flatMap { tokenUserResult =>
             checkPermissions(tokenUserResult, permissions, token)
diff --git a/src/main/scala/xyz/driver/core/rest.scala b/src/main/scala/xyz/driver/core/rest.scala
index bfb4ddd..eaf97db 100644
--- a/src/main/scala/xyz/driver/core/rest.scala
+++ b/src/main/scala/xyz/driver/core/rest.scala
@@ -54,7 +54,8 @@ object rest {
 
       val request = (if(requestStub.entity.isKnownEmpty()) requestStub else {
         requestStub.withEntity(requestStub.entity.transformDataBytes(encryptionFlow))
-      }).withHeaders(RawHeader(AuthService.AuthenticationTokenHeader, authToken.value.value))
+      }).withHeaders(RawHeader(AuthService.AuthenticationTokenHeader, authToken.value.value),
+        RawHeader(AuthService.TrackingIdHeader, authToken.trackingId))
 
       log.audit(s"Sending to ${request.uri} request $request")
 
diff --git a/src/test/scala/xyz/driver/core/AuthTest.scala b/src/test/scala/xyz/driver/core/AuthTest.scala
index fef3eda..97279de 100644
--- a/src/test/scala/xyz/driver/core/AuthTest.scala
+++ b/src/test/scala/xyz/driver/core/AuthTest.scala
@@ -40,7 +40,7 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
 
   it should "throw error is authorized user is not having the requested permission" in {
 
-    val referenceAuthToken = AuthToken(Base64("I am a pathologist's token"))
+    val referenceAuthToken = AuthToken(Base64("I am a pathologist's token"), "BC131CD")
 
     Post("/administration/attempt").addHeader(
       RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value.value)
@@ -60,7 +60,7 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
 
   it should "pass and retrieve the token to client code, if token is in request and user has permission" in {
 
-    val referenceAuthToken = AuthToken(Base64("I am token"))
+    val referenceAuthToken = AuthToken(Base64("I am token"), "AAADDDFFF")
 
     Get("/valid/attempt/?a=2&b=5").addHeader(
       RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value.value)
-- 
cgit v1.2.3


From 16bdae27befd9cf3b723ad919ba2140b38d18c48 Mon Sep 17 00:00:00 2001
From: vlad <vlad@drivergrp.com>
Date: Tue, 1 Nov 2016 15:19:36 -0700
Subject: DIR-135 Consistent request context extraction

---
 src/main/scala/xyz/driver/core/app.scala      | 33 +++++++-------
 src/main/scala/xyz/driver/core/auth.scala     | 65 ++++++++-------------------
 src/main/scala/xyz/driver/core/crypto.scala   | 27 -----------
 src/main/scala/xyz/driver/core/rest.scala     | 55 +++++++++++++++--------
 src/test/scala/xyz/driver/core/AuthTest.scala | 22 ++++-----
 5 files changed, 80 insertions(+), 122 deletions(-)
 delete mode 100644 src/main/scala/xyz/driver/core/crypto.scala

(limited to 'src/test/scala/xyz/driver/core')

diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala
index 8f892e8..f972158 100644
--- a/src/main/scala/xyz/driver/core/app.scala
+++ b/src/main/scala/xyz/driver/core/app.scala
@@ -4,18 +4,18 @@ import akka.actor.ActorSystem
 import akka.http.scaladsl.Http
 import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
 import akka.http.scaladsl.model.StatusCodes._
+import akka.http.scaladsl.model.headers.RawHeader
 import akka.http.scaladsl.model.{HttpResponse, StatusCodes}
 import akka.http.scaladsl.server.Directives._
 import akka.http.scaladsl.server.RouteResult._
-import akka.http.scaladsl.server.{ExceptionHandler, RequestContext, Route, RouteConcatenation}
+import akka.http.scaladsl.server.{ExceptionHandler, Route, RouteConcatenation}
 import akka.stream.ActorMaterializer
 import com.typesafe.config.Config
 import org.slf4j.LoggerFactory
 import spray.json.DefaultJsonProtocol
 import xyz.driver.core
-import xyz.driver.core.auth.AuthService
 import xyz.driver.core.logging.{Logger, TypesafeScalaLogger}
-import xyz.driver.core.rest.Swagger
+import xyz.driver.core.rest.{ContextHeaders, Swagger}
 import xyz.driver.core.stats.SystemStats
 import xyz.driver.core.time.Time
 import xyz.driver.core.time.provider.{SystemTimeProvider, TimeProvider}
@@ -65,26 +65,23 @@ object app {
       val versionRt      = versionRoute(version, gitHash, time.currentTime())
 
       val _ = Future {
-        http.bindAndHandle(route2HandlerFlow(handleExceptions(exceptionHandler) { ctx =>
-          log.audit(s"Received request ${ctx.request}")
-          modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _)(ctx)
+        http.bindAndHandle(route2HandlerFlow(handleExceptions(ExceptionHandler(exceptionHandler)) { ctx =>
+          val trackingId = rest.extractTrackingId(ctx)
+          val contextWithTrackingId =
+            ctx.withRequest(ctx.request.withHeaders(RawHeader(ContextHeaders.TrackingIdHeader, trackingId)))
+
+          log.audit(s"Received request ${ctx.request} with tracking id $trackingId")
+
+          modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _)(contextWithTrackingId)
         }), interface, port)(materializer)
       }
     }
 
-    protected def extractTrackingId(ctx: RequestContext) = {
-      ctx.request.headers
-        .find(_.name == AuthService.TrackingIdHeader)
-        .map(_.value())
-        .getOrElse(java.util.UUID.randomUUID.toString)
-      // TODO: In the case when absent, should be taken the same generated id, as in `authorize`
-    }
-
-    protected def exceptionHandler = ExceptionHandler {
+    protected def exceptionHandler = PartialFunction[Throwable, Route] {
 
       case is: IllegalStateException =>
         ctx =>
-          val trackingId = extractTrackingId(ctx)
+          val trackingId = rest.extractTrackingId(ctx)
           log.debug(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is)
           complete(
             HttpResponse(BadRequest, entity = s"""{ "trackingId": "$trackingId", "message": "${is.getMessage}" }"""))(
@@ -92,7 +89,7 @@ object app {
 
       case cm: ConcurrentModificationException =>
         ctx =>
-          val trackingId                    = extractTrackingId(ctx)
+          val trackingId                    = rest.extractTrackingId(ctx)
           val concurrentModificationMessage = "Resource was changed concurrently, try requesting a newer version"
           log.audit(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm)
           complete(
@@ -102,7 +99,7 @@ object app {
 
       case t: Throwable =>
         ctx =>
-          val trackingId = extractTrackingId(ctx)
+          val trackingId = rest.extractTrackingId(ctx)
           log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t)
           complete(
             HttpResponse(InternalServerError,
diff --git a/src/main/scala/xyz/driver/core/auth.scala b/src/main/scala/xyz/driver/core/auth.scala
index 17f89c0..3dd21d9 100644
--- a/src/main/scala/xyz/driver/core/auth.scala
+++ b/src/main/scala/xyz/driver/core/auth.scala
@@ -4,7 +4,7 @@ import akka.http.scaladsl.model.headers.HttpChallenges
 import akka.http.scaladsl.server.AuthenticationFailedRejection.CredentialsRejected
 
 import scala.concurrent.Future
-import scala.util.{Failure, Success, Try}
+import scala.util.{Failure, Success}
 import scalaz.OptionT
 
 object auth {
@@ -68,17 +68,12 @@ object auth {
     def permissions: Set[Permission] = roles.flatMap(_.permissions)
   }
 
-  final case class Macaroon(value: String)
-
-  final case class Base64[T](value: String)
-
-  final case class AuthToken(value: Base64[Macaroon], trackingId: String)
+  final case class AuthToken(value: String)
 
   final case class PasswordHash(value: String)
 
   object AuthService {
     val AuthenticationTokenHeader = "WWW-Authenticate"
-    val TrackingIdHeader          = "l5d-ctx-trace" // https://linkerd.io/doc/0.7.4/linkerd/protocol-http/
   }
 
   trait AuthService[U <: User] {
@@ -88,49 +83,25 @@ object auth {
 
     protected def authStatus(authToken: AuthToken): OptionT[Future, U]
 
-    def authorize(permissions: Permission*): Directive1[(AuthToken, U)] = {
-      parameters('authToken.?).flatMap { parameterTokenValue =>
-        optionalHeaderValueByName(AuthService.AuthenticationTokenHeader).flatMap { headerTokenValue =>
-          optionalHeaderValueByName(AuthService.TrackingIdHeader).flatMap { trackingIdValue =>
-            verifyAuthToken(headerTokenValue.orElse(parameterTokenValue), trackingIdValue, permissions.toSet)
-          }
-        }
-      }
-    }
-
-    private def verifyAuthToken(tokenOption: Option[String],
-                                trackingIdValue: Option[String],
-                                permissions: Set[Permission]): Directive1[(AuthToken, U)] =
-      tokenOption match {
-        case Some(tokenValue) =>
-          val trackingId = trackingIdValue.getOrElse(java.util.UUID.randomUUID.toString)
-          val token      = AuthToken(Base64[Macaroon](tokenValue), trackingId)
+    def authorize(permissions: Permission*): Directive1[U] = {
+      headerValueByName(AuthService.AuthenticationTokenHeader).flatMap { tokenValue =>
+        val token = AuthToken(tokenValue)
 
-          onComplete(authStatus(token).run).flatMap { tokenUserResult =>
-            checkPermissions(tokenUserResult, permissions, token)
-          }
+        onComplete(authStatus(token).run).flatMap {
+          case Success(Some(user)) =>
+            if (permissions.forall(user.permissions.contains)) provide(user)
+            else {
+              val challenge =
+                HttpChallenges.basic(s"User does not have the required permissions: ${permissions.mkString(", ")}")
+              reject(AuthenticationFailedRejection(CredentialsRejected, challenge))
+            }
 
-        case None =>
-          reject(MissingHeaderRejection(AuthService.AuthenticationTokenHeader))
-      }
+          case Success(None) =>
+            reject(ValidationRejection(s"Wasn't able to find authenticated user for the token provided"))
 
-    private def checkPermissions(userResult: Try[Option[U]],
-                                 permissions: Set[Permission],
-                                 token: AuthToken): Directive1[(AuthToken, U)] = {
-      userResult match {
-        case Success(Some(user)) =>
-          if (permissions.forall(user.permissions.contains)) provide(token -> user)
-          else {
-            val challenge =
-              HttpChallenges.basic(s"User does not have the required permissions: ${permissions.mkString(", ")}")
-            reject(AuthenticationFailedRejection(CredentialsRejected, challenge))
-          }
-
-        case Success(None) =>
-          reject(ValidationRejection(s"Wasn't able to find authenticated user for the token provided"))
-
-        case Failure(t) =>
-          reject(ValidationRejection(s"Wasn't able to verify token for authenticated user", Some(t)))
+          case Failure(t) =>
+            reject(ValidationRejection(s"Wasn't able to verify token for authenticated user", Some(t)))
+        }
       }
     }
   }
diff --git a/src/main/scala/xyz/driver/core/crypto.scala b/src/main/scala/xyz/driver/core/crypto.scala
deleted file mode 100644
index d001e0f..0000000
--- a/src/main/scala/xyz/driver/core/crypto.scala
+++ /dev/null
@@ -1,27 +0,0 @@
-package xyz.driver.core
-
-import xyz.driver.core.auth.AuthToken
-
-object crypto {
-
-  final case class EncryptionKey(value: String)
-
-  final case class DecryptionKey(value: String)
-
-  trait Crypto {
-
-    def keyForToken(authToken: AuthToken): EncryptionKey
-
-    def encrypt(encryptionKey: EncryptionKey)(message: Array[Byte]): Array[Byte]
-
-    def decrypt(decryptionKey: EncryptionKey)(message: Array[Byte]): Array[Byte]
-  }
-
-  object NoCrypto extends Crypto {
-
-    override def keyForToken(authToken: AuthToken): EncryptionKey = EncryptionKey(authToken.value.value)
-
-    override def decrypt(decryptionKey: EncryptionKey)(message: Array[Byte]): Array[Byte] = message
-    override def encrypt(encryptionKey: EncryptionKey)(message: Array[Byte]): Array[Byte] = message
-  }
-}
diff --git a/src/main/scala/xyz/driver/core/rest.scala b/src/main/scala/xyz/driver/core/rest.scala
index eaf97db..c52d9e0 100644
--- a/src/main/scala/xyz/driver/core/rest.scala
+++ b/src/main/scala/xyz/driver/core/rest.scala
@@ -4,15 +4,13 @@ import akka.actor.ActorSystem
 import akka.http.scaladsl.Http
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.model.headers.RawHeader
+import akka.http.scaladsl.server.RequestContext
 import akka.http.scaladsl.unmarshalling.Unmarshal
 import akka.stream.ActorMaterializer
-import akka.stream.scaladsl.Flow
-import akka.util.ByteString
 import com.github.swagger.akka.model._
 import com.github.swagger.akka.{HasActorSystem, SwaggerHttpService}
 import com.typesafe.config.Config
-import xyz.driver.core.auth.{AuthService, AuthToken}
-import xyz.driver.core.crypto.Crypto
+import xyz.driver.core.auth.AuthService
 import xyz.driver.core.logging.Logger
 import xyz.driver.core.stats.Stats
 import xyz.driver.core.time.TimeRange
@@ -20,15 +18,41 @@ import xyz.driver.core.time.provider.TimeProvider
 
 import scala.concurrent.{ExecutionContext, Future}
 import scala.util.{Failure, Success}
-import scalaz.{Failure => _, Success => _}
+import scalaz.Scalaz.{Id => _, _}
 
 object rest {
 
+  object ContextHeaders {
+    val AuthenticationTokenHeader = AuthService.AuthenticationTokenHeader
+    val TrackingIdHeader          = "l5d-ctx-trace" // https://linkerd.io/doc/0.7.4/linkerd/protocol-http/
+  }
+
+  final case class ServiceRequestContext(trackingId: String, contextHeaders: Map[String, String])
+
+  def serviceContext(ctx: RequestContext): ServiceRequestContext = {
+    ServiceRequestContext(extractTrackingId(ctx), extractContextHeaders(ctx))
+  }
+
+  def extractTrackingId(ctx: RequestContext): String = {
+    ctx.request.headers
+      .find(_.name == ContextHeaders.TrackingIdHeader)
+      .fold(java.util.UUID.randomUUID.toString)(_.value())
+  }
+
+  def extractContextHeaders(ctx: RequestContext): Map[String, String] = {
+    ctx.request.headers.filter { h =>
+      h.lowercaseName.startsWith("l5d-") || h.name === ContextHeaders.AuthenticationTokenHeader
+    } map { header =>
+      header.name -> header.value
+    } toMap
+  }
+
+
   trait Service
 
   trait ServiceTransport {
 
-    def sendRequest(authToken: AuthToken)(requestStub: HttpRequest): Future[Unmarshal[ResponseEntity]]
+    def sendRequest(context: ServiceRequestContext)(requestStub: HttpRequest): Future[Unmarshal[ResponseEntity]]
   }
 
   trait ServiceDiscovery {
@@ -37,25 +61,18 @@ object rest {
   }
 
   class HttpRestServiceTransport(actorSystem: ActorSystem, executionContext: ExecutionContext,
-                                 crypto: Crypto, log: Logger, stats: Stats, time: TimeProvider) extends ServiceTransport {
+                                 log: Logger, stats: Stats, time: TimeProvider) extends ServiceTransport {
 
     protected implicit val materializer = ActorMaterializer()(actorSystem)
     protected implicit val execution = executionContext
 
-    def sendRequest(authToken: AuthToken)(requestStub: HttpRequest): Future[Unmarshal[ResponseEntity]] = {
+    def sendRequest(context: ServiceRequestContext)(requestStub: HttpRequest): Future[Unmarshal[ResponseEntity]] = {
 
       val requestTime = time.currentTime()
-      val encryptionFlow = Flow[ByteString] map { bytes =>
-        ByteString(crypto.encrypt(crypto.keyForToken(authToken))(bytes.toArray))
-      }
-      val decryptionFlow = Flow[ByteString] map { bytes =>
-        ByteString(crypto.decrypt(crypto.keyForToken(authToken))(bytes.toArray))
-      }
 
-      val request = (if(requestStub.entity.isKnownEmpty()) requestStub else {
-        requestStub.withEntity(requestStub.entity.transformDataBytes(encryptionFlow))
-      }).withHeaders(RawHeader(AuthService.AuthenticationTokenHeader, authToken.value.value),
-        RawHeader(AuthService.TrackingIdHeader, authToken.trackingId))
+      val request = requestStub
+        .withHeaders(RawHeader(ContextHeaders.TrackingIdHeader, context.trackingId))
+        .withHeaders(context.contextHeaders.toSeq.map { h => RawHeader(h._1, h._2): HttpHeader }: _*)
 
       log.audit(s"Sending to ${request.uri} request $request")
 
@@ -65,7 +82,7 @@ object rest {
         } else if(response.status.isFailure()) {
           throw new Exception("Http status is failure " + response.status)
         } else {
-          Unmarshal(response.entity.transformDataBytes(decryptionFlow))
+          Unmarshal(response.entity)
         }
       }
 
diff --git a/src/test/scala/xyz/driver/core/AuthTest.scala b/src/test/scala/xyz/driver/core/AuthTest.scala
index 97279de..ca7e019 100644
--- a/src/test/scala/xyz/driver/core/AuthTest.scala
+++ b/src/test/scala/xyz/driver/core/AuthTest.scala
@@ -16,10 +16,10 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
 
   val authStatusService: AuthService[User] = new AuthService[User] {
     override def authStatus(authToken: AuthToken): OptionT[Future, User] = OptionT.optionT[Future] {
-      Future.successful(Some(new User() {
+      Future.successful(Some(new User {
         override def id: Id[User]     = Id[User](1L)
         override def roles: Set[Role] = Set(PathologistRole)
-      }))
+      }: User))
     }
   }
 
@@ -29,7 +29,7 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
 
     Get("/naive/attempt") ~>
       authorize(CanSignOutReport) {
-        case (authToken, user) =>
+        case user =>
           complete("Never going to be here")
       } ~>
       check {
@@ -40,13 +40,13 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
 
   it should "throw error is authorized user is not having the requested permission" in {
 
-    val referenceAuthToken = AuthToken(Base64("I am a pathologist's token"), "BC131CD")
+    val referenceAuthToken = AuthToken("I am a pathologist's token")
 
     Post("/administration/attempt").addHeader(
-      RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value.value)
+      RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value)
     ) ~>
       authorize(CanAssignRoles) {
-        case (authToken, user) =>
+        case user =>
           complete("Never going to get here")
       } ~>
       check {
@@ -60,18 +60,18 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
 
   it should "pass and retrieve the token to client code, if token is in request and user has permission" in {
 
-    val referenceAuthToken = AuthToken(Base64("I am token"), "AAADDDFFF")
+    val referenceAuthToken = AuthToken("I am token")
 
     Get("/valid/attempt/?a=2&b=5").addHeader(
-      RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value.value)
+      RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value)
     ) ~>
       authorize(CanSignOutReport) {
-        case (authToken, user) =>
-          complete("Alright, \"" + authToken.value.value + "\" is handled")
+        case user =>
+          complete("Alright, user \"" + user.id + "\" is authorized")
       } ~>
       check {
         handled shouldBe true
-        responseAs[String] shouldBe "Alright, \"I am token\" is handled"
+        responseAs[String] shouldBe "Alright, user \"1\" is authorized"
       }
   }
 }
-- 
cgit v1.2.3


From e3268b87bc9446e69b59ed5f3990f42c8a00d918 Mon Sep 17 00:00:00 2001
From: vlad <vlad@drivergrp.com>
Date: Wed, 2 Nov 2016 13:59:36 -0700
Subject: DIR-135 Directive for more effortless context extraction

---
 src/main/scala/xyz/driver/core/auth.scala     | 12 ++++++------
 src/main/scala/xyz/driver/core/rest.scala     | 16 +++++++++-------
 src/test/scala/xyz/driver/core/AuthTest.scala | 19 ++++++++++++-------
 3 files changed, 27 insertions(+), 20 deletions(-)

(limited to 'src/test/scala/xyz/driver/core')

diff --git a/src/main/scala/xyz/driver/core/auth.scala b/src/main/scala/xyz/driver/core/auth.scala
index 3dd21d9..e4d726b 100644
--- a/src/main/scala/xyz/driver/core/auth.scala
+++ b/src/main/scala/xyz/driver/core/auth.scala
@@ -2,6 +2,7 @@ package xyz.driver.core
 
 import akka.http.scaladsl.model.headers.HttpChallenges
 import akka.http.scaladsl.server.AuthenticationFailedRejection.CredentialsRejected
+import xyz.driver.core.rest.ServiceRequestContext
 
 import scala.concurrent.Future
 import scala.util.{Failure, Success}
@@ -73,7 +74,8 @@ object auth {
   final case class PasswordHash(value: String)
 
   object AuthService {
-    val AuthenticationTokenHeader = "WWW-Authenticate"
+    val AuthenticationTokenHeader    = rest.ContextHeaders.AuthenticationTokenHeader
+    val SetAuthenticationTokenHeader = "set-authorization"
   }
 
   trait AuthService[U <: User] {
@@ -81,13 +83,11 @@ object auth {
     import akka.http.scaladsl.server._
     import Directives._
 
-    protected def authStatus(authToken: AuthToken): OptionT[Future, U]
+    protected def authStatus(context: ServiceRequestContext): OptionT[Future, U]
 
     def authorize(permissions: Permission*): Directive1[U] = {
-      headerValueByName(AuthService.AuthenticationTokenHeader).flatMap { tokenValue =>
-        val token = AuthToken(tokenValue)
-
-        onComplete(authStatus(token).run).flatMap {
+      rest.serviceContext flatMap { ctx =>
+        onComplete(authStatus(ctx).run).flatMap {
           case Success(Some(user)) =>
             if (permissions.forall(user.permissions.contains)) provide(user)
             else {
diff --git a/src/main/scala/xyz/driver/core/rest.scala b/src/main/scala/xyz/driver/core/rest.scala
index c52d9e0..18dbcf7 100644
--- a/src/main/scala/xyz/driver/core/rest.scala
+++ b/src/main/scala/xyz/driver/core/rest.scala
@@ -4,13 +4,11 @@ import akka.actor.ActorSystem
 import akka.http.scaladsl.Http
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.model.headers.RawHeader
-import akka.http.scaladsl.server.RequestContext
 import akka.http.scaladsl.unmarshalling.Unmarshal
 import akka.stream.ActorMaterializer
 import com.github.swagger.akka.model._
 import com.github.swagger.akka.{HasActorSystem, SwaggerHttpService}
 import com.typesafe.config.Config
-import xyz.driver.core.auth.AuthService
 import xyz.driver.core.logging.Logger
 import xyz.driver.core.stats.Stats
 import xyz.driver.core.time.TimeRange
@@ -23,15 +21,19 @@ import scalaz.Scalaz.{Id => _, _}
 object rest {
 
   object ContextHeaders {
-    val AuthenticationTokenHeader = AuthService.AuthenticationTokenHeader
+    val AuthenticationTokenHeader = "WWW-Authenticate"
     val TrackingIdHeader          = "l5d-ctx-trace" // https://linkerd.io/doc/0.7.4/linkerd/protocol-http/
   }
 
   final case class ServiceRequestContext(trackingId: String, contextHeaders: Map[String, String])
 
-  def serviceContext(ctx: RequestContext): ServiceRequestContext = {
+  import akka.http.scaladsl.server._
+  import Directives._
+
+  def serviceContext: Directive1[ServiceRequestContext] = extract(ctx => extractServiceContext(ctx))
+
+  def extractServiceContext(ctx: RequestContext): ServiceRequestContext =
     ServiceRequestContext(extractTrackingId(ctx), extractContextHeaders(ctx))
-  }
 
   def extractTrackingId(ctx: RequestContext): String = {
     ctx.request.headers
@@ -74,13 +76,13 @@ object rest {
         .withHeaders(RawHeader(ContextHeaders.TrackingIdHeader, context.trackingId))
         .withHeaders(context.contextHeaders.toSeq.map { h => RawHeader(h._1, h._2): HttpHeader }: _*)
 
-      log.audit(s"Sending to ${request.uri} request $request")
+      log.audit(s"Sending to ${request.uri} request $request with tracking id ${context.trackingId}")
 
       val responseEntity = Http()(actorSystem).singleRequest(request)(materializer) map { response =>
         if(response.status == StatusCodes.NotFound) {
           Unmarshal(HttpEntity.Empty: ResponseEntity)
         } else if(response.status.isFailure()) {
-          throw new Exception("Http status is failure " + response.status)
+          throw new Exception(s"Http status is failure ${response.status}")
         } else {
           Unmarshal(response.entity)
         }
diff --git a/src/test/scala/xyz/driver/core/AuthTest.scala b/src/test/scala/xyz/driver/core/AuthTest.scala
index ca7e019..e5e991b 100644
--- a/src/test/scala/xyz/driver/core/AuthTest.scala
+++ b/src/test/scala/xyz/driver/core/AuthTest.scala
@@ -8,6 +8,7 @@ import akka.http.scaladsl.server.AuthenticationFailedRejection.CredentialsReject
 import org.scalatest.mock.MockitoSugar
 import org.scalatest.{FlatSpec, Matchers}
 import xyz.driver.core.auth._
+import xyz.driver.core.rest.ServiceRequestContext
 
 import scala.concurrent.Future
 import scalaz.OptionT
@@ -15,11 +16,15 @@ import scalaz.OptionT
 class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRouteTest {
 
   val authStatusService: AuthService[User] = new AuthService[User] {
-    override def authStatus(authToken: AuthToken): OptionT[Future, User] = OptionT.optionT[Future] {
-      Future.successful(Some(new User {
-        override def id: Id[User]     = Id[User](1L)
-        override def roles: Set[Role] = Set(PathologistRole)
-      }: User))
+    override def authStatus(context: ServiceRequestContext): OptionT[Future, User] = OptionT.optionT[Future] {
+      if (context.contextHeaders.keySet.contains(AuthService.AuthenticationTokenHeader)) {
+        Future.successful(Some(new User {
+          override def id: Id[User]     = Id[User](1L)
+          override def roles: Set[Role] = Set(PathologistRole)
+        }: User))
+      } else {
+        Future.successful(Option.empty[User])
+      }
     }
   }
 
@@ -33,8 +38,8 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
           complete("Never going to be here")
       } ~>
       check {
-        handled shouldBe false
-        rejections should contain(MissingHeaderRejection("WWW-Authenticate"))
+        // handled shouldBe false
+        rejections should contain(ValidationRejection("Wasn't able to find authenticated user for the token provided"))
       }
   }
 
-- 
cgit v1.2.3


From 16b308b33a0c300e756ff2725affd8259a69ad85 Mon Sep 17 00:00:00 2001
From: vlad <vlad@drivergrp.com>
Date: Tue, 29 Nov 2016 14:08:56 -0800
Subject: Changed ids underlying type to String and made Ids and Names —
 value-classes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/scala/xyz/driver/core/auth.scala          | 10 +++----
 src/main/scala/xyz/driver/core/core.scala          | 34 +++++++++++++---------
 src/main/scala/xyz/driver/core/database.scala      |  6 ++--
 src/main/scala/xyz/driver/core/file.scala          |  8 ++---
 src/main/scala/xyz/driver/core/generators.scala    | 14 ++++++---
 src/main/scala/xyz/driver/core/json.scala          | 16 +++++-----
 src/test/scala/xyz/driver/core/AuthTest.scala      | 17 +++++------
 src/test/scala/xyz/driver/core/CoreTest.scala      | 10 +++----
 src/test/scala/xyz/driver/core/FileTest.scala      |  2 +-
 .../scala/xyz/driver/core/GeneratorsTest.scala     | 32 ++++++++++----------
 src/test/scala/xyz/driver/core/JsonTest.scala      |  4 +--
 11 files changed, 80 insertions(+), 73 deletions(-)

(limited to 'src/test/scala/xyz/driver/core')

diff --git a/src/main/scala/xyz/driver/core/auth.scala b/src/main/scala/xyz/driver/core/auth.scala
index e4d726b..67de21d 100644
--- a/src/main/scala/xyz/driver/core/auth.scala
+++ b/src/main/scala/xyz/driver/core/auth.scala
@@ -32,32 +32,32 @@ object auth {
   }
 
   case object ObserverRole extends Role {
-    val id          = Id(1L)
+    val id          = Id("1")
     val name        = Name("observer")
     val permissions = Set[Permission](CanSeeUser, CanSeeAssay, CanSeeReport)
   }
 
   case object PatientRole extends Role {
-    val id          = Id(2L)
+    val id          = Id("2")
     val name        = Name("patient")
     val permissions = Set.empty[Permission]
   }
 
   case object CuratorRole extends Role {
-    val id          = Id(3L)
+    val id          = Id("3")
     val name        = Name("curator")
     val permissions = ObserverRole.permissions ++ Set[Permission](CanEditReport, CanReviewReport)
   }
 
   case object PathologistRole extends Role {
-    val id   = Id(4L)
+    val id   = Id("4")
     val name = Name("pathologist")
     val permissions = ObserverRole.permissions ++
         Set[Permission](CanEditReport, CanSignOutReport, CanAmendReport, CanEditReviewingReport)
   }
 
   case object AdministratorRole extends Role {
-    val id   = Id(5L)
+    val id   = Id("5")
     val name = Name("administrator")
     val permissions = CuratorRole.permissions ++
         Set[Permission](CanCreateReport, CanShareReportWithPatient, CanAssignRoles)
diff --git a/src/main/scala/xyz/driver/core/core.scala b/src/main/scala/xyz/driver/core/core.scala
index b7fbeb6..fa0028b 100644
--- a/src/main/scala/xyz/driver/core/core.scala
+++ b/src/main/scala/xyz/driver/core/core.scala
@@ -3,10 +3,13 @@ package xyz.driver
 import scalaz.Equal
 
 package object core {
+
   import scala.language.reflectiveCalls
 
   def make[T](v: => T)(f: T => Unit): T = {
-    val value = v; f(value); value
+    val value = v
+    f(value)
+    value
   }
 
   def using[R <: { def close() }, P](r: => R)(f: R => P): P = {
@@ -17,30 +20,33 @@ package object core {
       resource.close()
     }
   }
+}
 
-  object tagging {
-    private[core] trait Tagged[+V, +Tag]
+package core {
+
+  final case class Id[+Tag](value: String) extends AnyVal {
+    def length: Int               = value.length
+    override def toString: String = value
   }
-  type @@[+V, +Tag] = V with tagging.Tagged[V, Tag]
 
-  type Id[+Tag] = Long @@ Tag
   object Id {
-    def apply[Tag](value: Long) = value.asInstanceOf[Id[Tag]]
+    implicit def idEqual[T]: Equal[Id[T]]       = Equal.equal[Id[T]](_ == _)
+    implicit def idOrdering[T]: Ordering[Id[T]] = Ordering.by[Id[T], String](_.value)
   }
-  implicit def idEqual[T]: Equal[Id[T]]       = Equal.equal[Id[T]](_ == _)
-  implicit def idOrdering[T]: Ordering[Id[T]] = Ordering.by(i => i: Long)
 
-  type Name[+Tag] = String @@ Tag
-  object Name {
-    def apply[Tag](value: String) = value.asInstanceOf[Name[Tag]]
+  final case class Name[+Tag](value: String) extends AnyVal {
+    def length: Int               = value.length
+    override def toString: String = value
   }
 
-  implicit def nameEqual[T]: Equal[Name[T]]       = Equal.equal[Name[T]](_ == _)
-  implicit def nameOrdering[T]: Ordering[Name[T]] = Ordering.by(n => n: String)
+  object Name {
+    implicit def nameEqual[T]: Equal[Name[T]]       = Equal.equal[Name[T]](_ == _)
+    implicit def nameOrdering[T]: Ordering[Name[T]] = Ordering.by(_.value)
+  }
 
   object revision {
     final case class Revision[T](id: String)
 
     implicit def revisionEqual[T]: Equal[Revision[T]] = Equal.equal[Revision[T]](_.id == _.id)
   }
-}
+}
\ No newline at end of file
diff --git a/src/main/scala/xyz/driver/core/database.scala b/src/main/scala/xyz/driver/core/database.scala
index 85a8cc4..a8ad477 100644
--- a/src/main/scala/xyz/driver/core/database.scala
+++ b/src/main/scala/xyz/driver/core/database.scala
@@ -37,12 +37,12 @@ object database {
     import database.profile.api._
 
     implicit def idColumnType[T] =
-      MappedColumnType.base[Id[T], Long](id => id: Long, Id[T](_))
+      MappedColumnType.base[Id[T], String](_.value, Id[T](_))
 
     implicit def nameColumnType[T] =
-      MappedColumnType.base[Name[T], String](name => name: String, Name[T](_))
+      MappedColumnType.base[Name[T], String](_.value, Name[T](_))
 
-    implicit val timeColumnType = MappedColumnType.base[Time, Long](time => time.millis, Time(_))
+    implicit val timeColumnType = MappedColumnType.base[Time, Long](_.millis, Time.apply)
   }
 
   trait DatabaseObject extends IdColumnTypes {
diff --git a/src/main/scala/xyz/driver/core/file.scala b/src/main/scala/xyz/driver/core/file.scala
index 38a2766..9cea9e5 100644
--- a/src/main/scala/xyz/driver/core/file.scala
+++ b/src/main/scala/xyz/driver/core/file.scala
@@ -59,7 +59,7 @@ object file {
 
     def upload(localSource: File, destination: Path): Future[Unit] = Future {
       checkSafeFileName(destination) {
-        val _ = s3.putObject(bucket, destination.toString, localSource).getETag
+        val _ = s3.putObject(bucket.value, destination.toString, localSource).getETag
       }
     }
 
@@ -72,20 +72,20 @@ object file {
         if (!tempDestinationFile.getParentFile.mkdirs()) {
           throw new Exception(s"Failed to create temp directory to download file `$tempDestinationFile`")
         } else {
-          Option(s3.getObject(new GetObjectRequest(bucket, filePath.toString), tempDestinationFile)).map { _ =>
+          Option(s3.getObject(new GetObjectRequest(bucket.value, filePath.toString), tempDestinationFile)).map { _ =>
             tempDestinationFile
           }
         }
       })
 
     def delete(filePath: Path): Future[Unit] = Future {
-      s3.deleteObject(bucket, filePath.toString)
+      s3.deleteObject(bucket.value, filePath.toString)
     }
 
     def list(path: Path): ListT[Future, FileLink] =
       ListT.listT(Future {
         import scala.collection.JavaConverters._
-        val req = new ListObjectsV2Request().withBucketName(bucket).withPrefix(path.toString).withMaxKeys(2)
+        val req = new ListObjectsV2Request().withBucketName(bucket.value).withPrefix(path.toString).withMaxKeys(2)
 
         def isInSubFolder(path: Path)(fileLink: FileLink) =
           fileLink.location.toString.replace(path.toString + "/", "").contains("/")
diff --git a/src/main/scala/xyz/driver/core/generators.scala b/src/main/scala/xyz/driver/core/generators.scala
index bb026a9..6bf579b 100644
--- a/src/main/scala/xyz/driver/core/generators.scala
+++ b/src/main/scala/xyz/driver/core/generators.scala
@@ -13,12 +13,18 @@ object generators {
   private val random = new Random
   import random._
 
-  private val DefaultMaxLength = 100
+  private val DefaultMaxLength = 10
   private val StringLetters    = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ".toSet
 
-  def nextId[T](): Id[T] = Id[T](scala.math.abs(nextLong()))
+  def nextInt(maxValue: Int): Int = random.nextInt(maxValue)
 
-  def nextId[T](maxValue: Int): Id[T] = Id[T](scala.math.abs(nextInt(maxValue).toLong))
+  def nextBoolean(): Boolean = random.nextBoolean()
+
+  def nextDouble(): Double = random.nextDouble()
+
+  def nextId[T](): Id[T] = Id[T](nextString(DefaultMaxLength))
+
+  def nextId[T](maxLength: Int): Id[T] = Id[T](nextString(maxLength))
 
   def nextName[T](maxLength: Int = DefaultMaxLength): Name[T] = Name[T](nextString(maxLength))
 
@@ -29,7 +35,7 @@ object generators {
   def nextString(maxLength: Int = DefaultMaxLength): String =
     (oneOf[Char](StringLetters) +: arrayOf(oneOf[Char](StringLetters), maxLength - 1)).mkString
 
-  def nextOption[T](value: => T): Option[T] = if (nextBoolean) Option(value) else None
+  def nextOption[T](value: => T): Option[T] = if (nextBoolean()) Option(value) else None
 
   def nextPair[L, R](left: => L, right: => R): (L, R) = (left, right)
 
diff --git a/src/main/scala/xyz/driver/core/json.scala b/src/main/scala/xyz/driver/core/json.scala
index 3917eca..cc27944 100644
--- a/src/main/scala/xyz/driver/core/json.scala
+++ b/src/main/scala/xyz/driver/core/json.scala
@@ -12,18 +12,16 @@ import scala.reflect.runtime.universe._
 
 object json {
 
-  def IdInPath[T]: PathMatcher1[Id[T]] =
-    PathMatcher("""[+-]?\d*""".r) flatMap { string =>
-      try Some(Id[T](string.toLong))
-      catch { case _: IllegalArgumentException => None }
-    }
+  def IdInPath[T]: PathMatcher1[Id[T]] = new PathMatcher1[Id[T]] {
+    def apply(path: Path) = Matched(Path.Empty, Tuple1(Id[T](path.toString)))
+  }
 
   implicit def idFormat[T] = new RootJsonFormat[Id[T]] {
-    def write(id: Id[T]) = JsNumber(id)
+    def write(id: Id[T]) = JsString(id.value)
 
     def read(value: JsValue) = value match {
-      case JsNumber(id) => Id[T](id.toLong)
-      case _            => throw DeserializationException("Id expects number")
+      case JsString(id) => Id[T](id)
+      case _            => throw DeserializationException("Id expects string")
     }
   }
 
@@ -32,7 +30,7 @@ object json {
   }
 
   implicit def nameFormat[T] = new RootJsonFormat[Name[T]] {
-    def write(name: Name[T]) = JsString(name)
+    def write(name: Name[T]) = JsString(name.value)
 
     def read(value: JsValue): Name[T] = value match {
       case JsString(name) => Name[T](name)
diff --git a/src/test/scala/xyz/driver/core/AuthTest.scala b/src/test/scala/xyz/driver/core/AuthTest.scala
index e5e991b..f4d4d2a 100644
--- a/src/test/scala/xyz/driver/core/AuthTest.scala
+++ b/src/test/scala/xyz/driver/core/AuthTest.scala
@@ -19,7 +19,7 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
     override def authStatus(context: ServiceRequestContext): OptionT[Future, User] = OptionT.optionT[Future] {
       if (context.contextHeaders.keySet.contains(AuthService.AuthenticationTokenHeader)) {
         Future.successful(Some(new User {
-          override def id: Id[User]     = Id[User](1L)
+          override def id: Id[User]     = Id[User]("1")
           override def roles: Set[Role] = Set(PathologistRole)
         }: User))
       } else {
@@ -33,9 +33,8 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
   "'authorize' directive" should "throw error is auth token is not in the request" in {
 
     Get("/naive/attempt") ~>
-      authorize(CanSignOutReport) {
-        case user =>
-          complete("Never going to be here")
+      authorize(CanSignOutReport) { user =>
+        complete("Never going to be here")
       } ~>
       check {
         // handled shouldBe false
@@ -50,9 +49,8 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
     Post("/administration/attempt").addHeader(
       RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value)
     ) ~>
-      authorize(CanAssignRoles) {
-        case user =>
-          complete("Never going to get here")
+      authorize(CanAssignRoles) { user =>
+        complete("Never going to get here")
       } ~>
       check {
         handled shouldBe false
@@ -70,9 +68,8 @@ class AuthTest extends FlatSpec with Matchers with MockitoSugar with ScalatestRo
     Get("/valid/attempt/?a=2&b=5").addHeader(
       RawHeader(AuthService.AuthenticationTokenHeader, referenceAuthToken.value)
     ) ~>
-      authorize(CanSignOutReport) {
-        case user =>
-          complete("Alright, user \"" + user.id + "\" is authorized")
+      authorize(CanSignOutReport) { user =>
+        complete("Alright, user \"" + user.id + "\" is authorized")
       } ~>
       check {
         handled shouldBe true
diff --git a/src/test/scala/xyz/driver/core/CoreTest.scala b/src/test/scala/xyz/driver/core/CoreTest.scala
index f9a1aab..3eb9eaa 100644
--- a/src/test/scala/xyz/driver/core/CoreTest.scala
+++ b/src/test/scala/xyz/driver/core/CoreTest.scala
@@ -31,12 +31,12 @@ class CoreTest extends FlatSpec with Matchers with MockitoSugar {
 
   "Id" should "have equality and ordering working correctly" in {
 
-    (Id[String](1234213L) === Id[String](1234213L)) should be(true)
-    (Id[String](1234213L) === Id[String](213414L)) should be(false)
-    (Id[String](213414L) === Id[String](1234213L)) should be(false)
+    (Id[String]("1234213") === Id[String]("1234213")) should be(true)
+    (Id[String]("1234213") === Id[String]("213414")) should be(false)
+    (Id[String]("213414") === Id[String]("1234213")) should be(false)
 
-    Seq(Id[String](4L), Id[String](3L), Id[String](2L), Id[String](1L)).sorted should contain
-    theSameElementsInOrderAs(Seq(Id[String](1L), Id[String](2L), Id[String](3L), Id[String](4L)))
+    Seq(Id[String]("4"), Id[String]("3"), Id[String]("2"), Id[String]("1")).sorted should contain
+    theSameElementsInOrderAs(Seq(Id[String]("1"), Id[String]("2"), Id[String]("3"), Id[String]("4")))
   }
 
   "Name" should "have equality and ordering working correctly" in {
diff --git a/src/test/scala/xyz/driver/core/FileTest.scala b/src/test/scala/xyz/driver/core/FileTest.scala
index aba79f7..57af1c2 100644
--- a/src/test/scala/xyz/driver/core/FileTest.scala
+++ b/src/test/scala/xyz/driver/core/FileTest.scala
@@ -51,7 +51,7 @@ class FileTest extends FlatSpec with Matchers with MockitoSugar {
     val s3ObjectMetadataMock = mock[ObjectMetadata]
     val amazonS3Mock         = mock[AmazonS3]
     when(amazonS3Mock.listObjectsV2(any[ListObjectsV2Request]())).thenReturn(s3ResultsMock)
-    when(amazonS3Mock.putObject(testBucket, testFilePath.toString, sourceTestFile)).thenReturn(s3PutMock)
+    when(amazonS3Mock.putObject(testBucket.value, testFilePath.toString, sourceTestFile)).thenReturn(s3PutMock)
     when(amazonS3Mock.getObject(any[GetObjectRequest](), any[File]())).thenReturn(s3ObjectMetadataMock)
 
     val s3Storage = new S3Storage(amazonS3Mock, testBucket, scala.concurrent.ExecutionContext.global)
diff --git a/src/test/scala/xyz/driver/core/GeneratorsTest.scala b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
index 0432b2a..4ec73ec 100644
--- a/src/test/scala/xyz/driver/core/GeneratorsTest.scala
+++ b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
@@ -11,25 +11,25 @@ class GeneratorsTest extends FlatSpec with Matchers with Assertions {
     val generatedId2 = nextId[String]()
     val generatedId3 = nextId[Long]()
 
-    generatedId1 should be >= 0L
-    generatedId2 should be >= 0L
-    generatedId3 should be >= 0L
+    generatedId1.length should be >= 0
+    generatedId2.length should be >= 0
+    generatedId3.length should be >= 0
     generatedId1 should not be generatedId2
     generatedId2 should !==(generatedId3)
   }
 
   it should "be able to generate com.drivergrp.core.Id identifiers with max value" in {
 
-    val generatedLimitedId1 = nextId[String](10000)
-    val generatedLimitedId2 = nextId[String](1000)
-    val generatedLimitedId3 = nextId[Long](2000)
+    val generatedLimitedId1 = nextId[String](5)
+    val generatedLimitedId2 = nextId[String](4)
+    val generatedLimitedId3 = nextId[Long](3)
 
-    generatedLimitedId1 should be >= 0L
-    generatedLimitedId1 should be < 10000L
-    generatedLimitedId2 should be >= 0L
-    generatedLimitedId2 should be < 1000L
-    generatedLimitedId3 should be >= 0L
-    generatedLimitedId3 should be < 2000L
+    generatedLimitedId1.length should be >= 0
+    generatedLimitedId1.length should be < 6
+    generatedLimitedId2.length should be >= 0
+    generatedLimitedId2.length should be < 5
+    generatedLimitedId3.length should be >= 0
+    generatedLimitedId3.length should be < 4
     generatedLimitedId1 should not be generatedLimitedId2
     generatedLimitedId2 should !==(generatedLimitedId3)
   }
@@ -37,11 +37,11 @@ class GeneratorsTest extends FlatSpec with Matchers with Assertions {
   it should "be able to generate com.drivergrp.core.Name names" in {
 
     nextName[String]() should not be nextName[String]()
-    nextName[String]().length should be >= 0
+    nextName[String]().value.length should be >= 0
 
     val fixedLengthName = nextName[String](10)
     fixedLengthName.length should be <= 10
-    assert(!fixedLengthName.exists(_.isControl))
+    assert(!fixedLengthName.value.exists(_.isControl))
   }
 
   it should "be able to generate proper UUIDs" in {
@@ -82,7 +82,7 @@ class GeneratorsTest extends FlatSpec with Matchers with Assertions {
 
     val generatedPair = nextPair(nextId[Int](), nextName[Int]())
 
-    generatedPair._1 should be > 0L
+    generatedPair._1.length should be > 0
     generatedPair._2.length should be > 0
 
     nextPair(nextId[Int](), nextName[Int]()) should not be
@@ -98,7 +98,7 @@ class GeneratorsTest extends FlatSpec with Matchers with Assertions {
 
     val generatedTriad = nextTriad(nextId[Int](), nextName[Int](), nextBigDecimal())
 
-    generatedTriad._1 should be > 0L
+    generatedTriad._1.length should be > 0
     generatedTriad._2.length should be > 0
     generatedTriad._3 should be >= BigDecimal(0.00)
 
diff --git a/src/test/scala/xyz/driver/core/JsonTest.scala b/src/test/scala/xyz/driver/core/JsonTest.scala
index bcdcd5d..c113c59 100644
--- a/src/test/scala/xyz/driver/core/JsonTest.scala
+++ b/src/test/scala/xyz/driver/core/JsonTest.scala
@@ -9,10 +9,10 @@ class JsonTest extends FlatSpec with Matchers {
 
   "Json format for Id" should "read and write correct JSON" in {
 
-    val referenceId = Id[String](1312L)
+    val referenceId = Id[String]("1312-34A")
 
     val writtenJson = json.idFormat.write(referenceId)
-    writtenJson.prettyPrint should be("1312")
+    writtenJson.prettyPrint should be("\"1312-34A\"")
 
     val parsedId = json.idFormat.read(writtenJson)
     parsedId should be(referenceId)
-- 
cgit v1.2.3


From 828cc12194663f107a08251bbabc256ae0d7c936 Mon Sep 17 00:00:00 2001
From: vlad <vlad@drivergrp.com>
Date: Thu, 8 Dec 2016 18:52:37 -0800
Subject: General GADT json format

---
 src/main/scala/xyz/driver/core/json.scala      | 48 ++++++++++++++++++++++++++
 src/test/scala/xyz/driver/core/JsonTest.scala  | 38 +++++++++++++++++++-
 src/test/scala/xyz/driver/core/TestTypes.scala | 14 ++++++++
 3 files changed, 99 insertions(+), 1 deletion(-)
 create mode 100644 src/test/scala/xyz/driver/core/TestTypes.scala

(limited to 'src/test/scala/xyz/driver/core')

diff --git a/src/main/scala/xyz/driver/core/json.scala b/src/main/scala/xyz/driver/core/json.scala
index 66cae52..277543b 100644
--- a/src/main/scala/xyz/driver/core/json.scala
+++ b/src/main/scala/xyz/driver/core/json.scala
@@ -107,4 +107,52 @@ object json {
       case _               => deserializationError(s"Expected number as ${typeOf[T].getClass.getName}, but got " + json)
     }
   }
+
+  class GadtJsonFormat[T: TypeTag](typeField: String,
+                                   typeValue: PartialFunction[T, String],
+                                   jsonFormat: PartialFunction[String, JsonFormat[_ <: T]])
+      extends RootJsonFormat[T] {
+
+    def write(value: T): JsValue = {
+
+      val valueType = typeValue.applyOrElse(value, { v: T =>
+        deserializationError(s"No Value type for this type of ${typeOf[T].getClass.getName}: " + v)
+      })
+
+      val valueFormat =
+        jsonFormat.applyOrElse(valueType, { f: String =>
+          deserializationError(s"No Json format for this type of $valueType")
+        })
+
+      valueFormat.asInstanceOf[JsonFormat[T]].write(value) match {
+        case JsObject(fields) => JsObject(fields ++ Map(typeField -> JsString(valueType)))
+        case _                => serializationError(s"${typeOf[T].getClass.getName} serialized not to a JSON object")
+      }
+    }
+
+    def read(json: JsValue): T = json match {
+      case JsObject(fields) =>
+        val valueJson = JsObject(fields.filterNot(_._1 == typeField))
+        fields(typeField) match {
+          case JsString(valueType) =>
+            val valueFormat = jsonFormat.applyOrElse(valueType, { t: String =>
+              deserializationError(s"Unknown ${typeOf[T].getClass.getName} type ${fields(typeField)}")
+            })
+            valueFormat.read(valueJson)
+          case _ =>
+            deserializationError(s"Unknown ${typeOf[T].getClass.getName} type ${fields(typeField)}")
+        }
+      case _ =>
+        deserializationError(s"Expected Json Object as ${typeOf[T].getClass.getName}, but got " + json)
+    }
+  }
+
+  object GadtJsonFormat {
+
+    def create[T: TypeTag](typeField: String)(typeValue: PartialFunction[T, String])(
+            jsonFormat: PartialFunction[String, JsonFormat[_ <: T]]) = {
+
+      new GadtJsonFormat[T](typeField, typeValue, jsonFormat)
+    }
+  }
 }
diff --git a/src/test/scala/xyz/driver/core/JsonTest.scala b/src/test/scala/xyz/driver/core/JsonTest.scala
index c113c59..eb8d5d8 100644
--- a/src/test/scala/xyz/driver/core/JsonTest.scala
+++ b/src/test/scala/xyz/driver/core/JsonTest.scala
@@ -1,9 +1,11 @@
 package xyz.driver.core
 
 import org.scalatest.{FlatSpec, Matchers}
-import xyz.driver.core.json.{EnumJsonFormat, ValueClassFormat}
+import xyz.driver.core.json.{EnumJsonFormat, GadtJsonFormat, ValueClassFormat}
 import xyz.driver.core.revision.Revision
 import xyz.driver.core.time.provider.SystemTimeProvider
+import spray.json._
+import xyz.driver.core.TestTypes.CustomGADT
 
 class JsonTest extends FlatSpec with Matchers {
 
@@ -98,4 +100,38 @@ class JsonTest extends FlatSpec with Matchers {
     parsedValue1 should be(referenceValue1)
     parsedValue2 should be(referenceValue2)
   }
+
+  "Json format for classes GADT" should "read and write correct JSON" in {
+
+    import CustomGADT._
+    import DefaultJsonProtocol._
+    implicit val case1Format = jsonFormat1(GadtCase1)
+    implicit val case2Format = jsonFormat1(GadtCase2)
+    implicit val case3Format = jsonFormat1(GadtCase3)
+
+    val format = GadtJsonFormat.create[CustomGADT]("gadtTypeField") {
+      case t1: CustomGADT.GadtCase1 => "case1"
+      case t2: CustomGADT.GadtCase2 => "case2"
+      case t3: CustomGADT.GadtCase3 => "case3"
+    } {
+      case "case1" => case1Format
+      case "case2" => case2Format
+      case "case3" => case3Format
+    }
+
+    val referenceValue1 = CustomGADT.GadtCase1("4")
+    val referenceValue2 = CustomGADT.GadtCase2("Hi!")
+
+    val writtenJson1 = format.write(referenceValue1)
+    writtenJson1 should be("{\n \"field\": \"4\",\n\"gadtTypeField\": \"case1\"\n}".parseJson)
+
+    val writtenJson2 = format.write(referenceValue2)
+    writtenJson2 should be("{\"field\":\"Hi!\",\"gadtTypeField\":\"case2\"}".parseJson)
+
+    val parsedValue1 = format.read(writtenJson1)
+    val parsedValue2 = format.read(writtenJson2)
+
+    parsedValue1 should be(referenceValue1)
+    parsedValue2 should be(referenceValue2)
+  }
 }
diff --git a/src/test/scala/xyz/driver/core/TestTypes.scala b/src/test/scala/xyz/driver/core/TestTypes.scala
new file mode 100644
index 0000000..bb25deb
--- /dev/null
+++ b/src/test/scala/xyz/driver/core/TestTypes.scala
@@ -0,0 +1,14 @@
+package xyz.driver.core
+
+object TestTypes {
+
+  sealed trait CustomGADT {
+    val field: String
+  }
+
+  object CustomGADT {
+    final case class GadtCase1(field: String) extends CustomGADT
+    final case class GadtCase2(field: String) extends CustomGADT
+    final case class GadtCase3(field: String) extends CustomGADT
+  }
+}
-- 
cgit v1.2.3