Merge branch 'master' into js-IncludeFPinScalaExercises

Author: Javier de Silóniz Sandino

src/main/scala/org/scalaexercises/exercises/Evaluator.scala

@@ -22,9 +22,13 @@ import java.util.concurrent.{ TimeoutException, Callable, FutureTask, TimeUnit }
 import scala.util.Try
 import scala.util.control.NonFatal
 import scala.concurrent.duration._
+import scala.concurrent._
 import scala.language.reflectiveCalls
+
 import com.twitter.util.Eval
 
+import monix.execution._
+
 import scala.reflect.internal.util.{ BatchSourceFile, Position }
 
 sealed trait Severity
@@ -43,12 +47,14 @@ object EvalResult {
 
   case object Timeout extends EvalResult[Nothing]
   case class Success[T](complilationInfos: CI, result: T, consoleOutput: String) extends EvalResult[T]
+  case class Timeout[T]() extends EvalResult[T]
   case class EvalRuntimeError(complilationInfos: CI, runtimeError: Option[RuntimeError]) extends EvalResult[Nothing]
   case class CompilationError(complilationInfos: CI) extends EvalResult[Nothing]
   case class GeneralError(stack: Throwable) extends EvalResult[Nothing]
 }
 
-class Evaluator(timeout: Duration = 20.seconds) {
+class Evaluator(timeout: FiniteDuration = 20.seconds) {
+  implicit val scheduler: ExecutionContext = Scheduler.io("evaluation-scheduler")
 
   def convert(errors: (Position, String, String)): (Severity, List[CompilationInfo]) = {
     val (pos, msg, severity) = errors
@@ -60,11 +66,7 @@ class Evaluator(timeout: Duration = 20.seconds) {
     (sev, CompilationInfo(msg, Some(RangePosition(pos.start, pos.point, pos.end))) :: Nil)
   }
 
-  def apply[T](pre: String, code: String): EvalResult[T] = {
-    val allCode = s"""
-                     |$pre
-                     |$code
-                   """.stripMargin
+  def eval[T](code: String): EvalResult[T] = {
     val eval = new Eval {
       @volatile var errors: Map[Severity, List[CompilationInfo]] = Map.empty
 
@@ -82,26 +84,30 @@ class Evaluator(timeout: Duration = 20.seconds) {
     }
 
     val result = for {
-      _ ← Try(eval.check(allCode))
-      result ← Try(eval.apply[T](allCode, resetState = true))
+      _ ← Try(eval.check(code))
+      result ← Try(eval.apply[T](code, resetState = true))
     } yield result
 
     val errors: Map[Severity, List[CompilationInfo]] = eval.errors.toMap
 
-    println(allCode)
-
-    println(result)
-
-    println(errors)
-
     result match {
       case scala.util.Success(r) ⇒ EvalResult.Success[T](errors, r, "")
       case scala.util.Failure(t) ⇒ t match {
         case e: Eval.CompilerException ⇒ EvalResult.CompilationError(errors)
-        case e                         ⇒ EvalResult.EvalRuntimeError(errors, None)
+        case NonFatal(e)               ⇒ EvalResult.EvalRuntimeError(errors, Option(RuntimeError(e, None)))
+        case e                         ⇒ EvalResult.GeneralError(e)
       }
     }
-
   }
 
+  def apply[T](pre: String, code: String): EvalResult[T] = {
+    val allCode = s"""
+                     |$pre
+                     |$code
+                   """.stripMargin
+    val fut = Future({ eval(allCode) })
+    Try(
+      Await.result(fut, timeout)
+    ).getOrElse(EvalResult.Timeout())
+  }
 }

src/test/scala/com/fortysevendeg/exercises/EvaluatorSpec.scala

@@ -0,0 +1,22 @@
+/*
+ * scala-exercises-runtime
+ * Copyright (C) 2015-2016 47 Degrees, LLC. <http://www.47deg.com>
+ */
+
+package org.scalaexercises.runtime
+
+import scala.concurrent.duration._
+import org.scalatest._
+
+class EvaluatorSpec extends FunSpec with Matchers {
+
+  describe("evaluation") {
+    it("fails with a timeout when takes longer than the configured timeout") {
+      val evaluator = new Evaluator(1 second)
+      val result: EvalResult[Int] = evaluator("", "{ while(true) {}; 123 }")
+      result should matchPattern {
+        case t: EvalResult.Timeout[Int] ⇒
+      }
+    }
+  }
+}

src/test/scala/com/fortysevendeg/exercises/ExampleTarget.scala

@@ -1,10 +1,16 @@
 package org.scalaexercises.runtime
 
-object ExampleTarget {
+import org.scalatest._
+
+object ExampleTarget extends FlatSpec with Matchers {
   def intStringMethod(a: Int, b: String): String = {
     s"$a$b"
   }
 
+  def isOne(a: Int) = {
+    a shouldBe 1
+  }
+
   class ExampleException extends Exception("this is an example exception")
 
   def throwsExceptionMethod() {

src/test/scala/com/fortysevendeg/exercises/MethodEvalSpec.scala

@@ -49,7 +49,18 @@ class MethodEvalSpec extends FunSpec with Matchers {
       assert(res.toExecutionXor.isRight)
     }
 
-/* TODO fix this
+    it("fails with assertion error when the parameters are incorrect") {
+      val res = methodEval.eval(
+        "org.scalaexercises.runtime",
+        "org.scalaexercises.runtime.ExampleTarget.isOne",
+        "2" :: Nil
+      )
+
+      res should matchPattern {
+        case EvaluationException(_: TestFailedException) ⇒
+      }
+    }
+
     it("captures exceptions thrown by the called method") {
       val res = methodEval.eval(
         "org.scalaexercises.runtime",
@@ -63,7 +74,6 @@ class MethodEvalSpec extends FunSpec with Matchers {
       assert(res.toSuccessXor.isLeft)
       assert(res.toExecutionXor.isRight)
     }
- */
 
     it("interprets imports properly") {
       val res = methodEval.eval(