Move REST functionality to separate project

1 files changed, 0 insertions, 264 deletions

diff --git a/src/test/scala/xyz/driver/core/GeneratorsTest.scala b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
deleted file mode 100644
index 7e740a4..0000000
--- a/src/test/scala/xyz/driver/core/GeneratorsTest.scala
+++ /dev/null
@@ -1,264 +0,0 @@
-package xyz.driver.core
-
-import org.scalatest.{Assertions, FlatSpec, Matchers}
-
-import scala.collection.immutable.IndexedSeq
-
-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.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](5)
-    val generatedLimitedId2 = nextId[String](4)
-    val generatedLimitedId3 = nextId[Long](3)
-
-    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)
-  }
-
-  it should "be able to generate com.drivergrp.core.Name names" in {
-
-    Seq.fill(10)(nextName[String]()).distinct.size should be > 1
-    nextName[String]().value.length should be >= 0
-
-    val fixedLengthName = nextName[String](10)
-    fixedLengthName.length should be <= 10
-    assert(!fixedLengthName.value.exists(_.isControl))
-  }
-
-  it should "be able to generate com.drivergrp.core.NonEmptyName with non empty strings" in {
-
-    assert(nextNonEmptyName[String]().value.value.nonEmpty)
-  }
-
-  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 strings non-empty strings whic are non empty" in {
-
-    assert(nextNonEmptyString().value.nonEmpty)
-  }
-
-  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.length should be > 0
-    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.length should be > 0
-    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 a specific value from an enumeratum enum" in {
-
-    import enumeratum._
-    sealed trait TestEnumValue extends EnumEntry
-    object TestEnum extends Enum[TestEnumValue] {
-      case object Value1 extends TestEnumValue
-      case object Value2 extends TestEnumValue
-      case object Value3 extends TestEnumValue
-      case object Value4 extends TestEnumValue
-      val values: IndexedSeq[TestEnumValue] = findValues
-    }
-
-    val picks = (1 to 100).map(_ => generators.oneOf(TestEnum))
-
-    TestEnum.values should contain allElementsOf picks
-    picks.toSet.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("key", 123, 10)
-    generatedConstantMap.size should be <= 1
-    assert(generatedConstantMap.keys.forall(_ == "key"))
-    assert(generatedConstantMap.values.forall(_ == 123))
-
-    val generatedMap = mapOf(nextString(10), nextBigDecimal(), 10)
-    assert(generatedMap.keys.forall(_.length <= 10))
-    assert(generatedMap.values.forall(_ >= BigDecimal(0.00)))
-  }
-
-  it should "compose deeply" in {
-
-    val generatedNestedMap = mapOf(nextString(10), nextPair(nextBigDecimal(), nextOption(123)), 10)
-
-    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)))
-  }
-}