Merge pull request #263 from com-lihaoyi/topic/merge

Support concatenation and grouping of `Tests` instances

readme.md

@@ -1372,6 +1372,12 @@ libraries are currently at.
 Changelog
 =========
 
+0.8.1
+-----
+
+* Add `++` to `Tests` so that test suites can be concatenated
+* Add `.prefix(name: String)` to `Tests` to nest all of its tests under a single test group with a given name
+
 0.8.0
 -----
 

utest/src/utest/Tests.scala

@@ -12,5 +12,31 @@ import scala.collection.mutable
   * test to run you can feed the `List[Int]` path of that test in the `nameTree`
   * into the `callTree` to execute it and return the result.
   */
-case class Tests(nameTree: Tree[String], callTree: TestCallTree)
+case class Tests(nameTree: Tree[String], callTree: TestCallTree) {
+
+  def prefix(name: String): Tests = {
+    val newNameTree = Tree(nameTree.value, nameTree.children.map(_.prefix(name)): _*)
+    val newCallTree = callTree.mapInner {
+      case Right(ts) => Right(ts.map(_.prefix))
+      case l@ Left(_) => l
+    }
+    Tests(newNameTree, newCallTree)
+  }
+
+  def ++(t: Tests): Tests = {
+    val newNameTree = Tree(nameTree.value, (nameTree.children ++ t.nameTree.children): _*)
+    val newCallTree = new TestCallTree({
+      val a = callTree.evalInner()
+      val b = t.callTree.evalInner()
+      (a, b) match {
+        case (Right(x), Right(y)) => Right(x ++ y)
+        case (Left (_), Right(y)) => Right(y)
+        case (Right(x), Left (_)) => Right(x)
+        case (Left (_), Left (y)) => Left(y)
+      }
+    })
+    Tests(newNameTree, newCallTree)
+  }
+}
+
 object Tests extends TestsVersionSpecific

utest/src/utest/framework/Model.scala

@@ -21,7 +21,17 @@ object TestPath{
   * executable, which when run either returns a Left(result) or a
   * Right(sequence) of child nodes which you can execute.
   */
-class TestCallTree(inner: => Either[Any, IndexedSeq[TestCallTree]]){
+class TestCallTree(inner: => Either[Any, IndexedSeq[TestCallTree]]) {
+
+  def evalInner() =
+    inner
+
+  def mapInner(f: Either[Any, IndexedSeq[TestCallTree]] => Either[Any, IndexedSeq[TestCallTree]]): TestCallTree =
+    new TestCallTree(f(inner))
+
+  def prefix: TestCallTree =
+    new TestCallTree(Right(IndexedSeq.empty[TestCallTree] :+ this))
+
   /**
    * Runs the test in this [[TestCallTree]] at the specified `path`. Called
    * by the [[TestTreeSeq.run]] method and usually not called manually.

utest/src/utest/framework/Tree.scala

@@ -59,4 +59,7 @@ case class Tree[+T](value: T, children: Tree[T]*){
     else children.toIterator.flatMap(_.leaves)
   }
 
+  def prefix[A >: T](p: A): Tree[A] =
+    Tree(p, this)
+
 }

utest/test/src/test/utest/MergeTestsTest.scala

@@ -0,0 +1,44 @@
+package test.utest
+
+import utest.framework.Tree
+import utest._
+
+abstract class MergeSubTests1 extends TestSuite {
+  var run = Vector.empty[Int]
+  override def tests = Tests {
+    "one" - { run :+= 1 }
+    test("two") { run :+= 2 }
+    "three" - { run :+= 3 }
+  }
+}
+
+abstract class MergeSubTests2 extends TestSuite {
+  var run = Vector.empty[Int]
+  override def tests = Tests {
+    "one" - { run :+= 1 }
+    test("two") { run :+= 2 }
+  }
+}
+
+object MergeTestsTest extends TestSuite {
+
+  val x = new MergeSubTests1 {}
+  val y = new MergeSubTests2 {}
+
+  val local = Tests {
+    "makeSureTestsRan" - {
+      test("x") { assert(x.run == Vector(1, 2, 3) ) }
+      test("y") { assert(y.run == Vector(1, 2) ) }
+    }
+  }
+
+  override def tests =
+    x.tests.prefix("fst") ++
+    y.tests.prefix("snd") ++
+    local
+
+  override def utestAfterAll(): Unit = {
+    assert(x.run == Vector(1, 2, 3))
+    assert(y.run == Vector(1, 2))
+  }
+}