Changed test code

Author: kiroco12

server/src/main/scala/org/scalaexercises/evaluator/evaluation.scala

@@ -242,7 +242,7 @@ private class StringCompiler(
   }
 
   def findClass(className: String, classLoader: ClassLoader): Option[Class[_]] =
-    Try( cache.getOrElseUpdate(className, classLoader.loadClass(className) ) ) match {
+    Try(cache.getOrElseUpdate(className, classLoader.loadClass(className))) match {
       case Success(cls) => Some(cls)
       case Failure(_)   => None
     }
@@ -346,6 +346,10 @@ class Eval(target: Option[File] = None, jars: List[File] = Nil) {
     compilerMessageHandler
   )
 
+  lazy val jarUrls        = jars.map(jar => new java.net.URL(s"file://${jar.getAbsolutePath}"))
+  lazy val urlClassLoader = new URLClassLoader(jarUrls, compiler.getClass.getClassLoader)
+  lazy val classLoader    = new AbstractFileClassLoader(compilerOutputDir, urlClassLoader)
+
   /**
    * Will generate a classname of the form Evaluater__<unique>,
    * where unique is computed from the jvmID (a random number)
@@ -358,30 +362,23 @@ class Eval(target: Option[File] = None, jars: List[File] = Nil) {
   }
 
   def execute[T](className: String, code: String, resetState: Boolean, jars: Seq[File]): T = {
-    val jarUrls        = jars.map(jar => new java.net.URL(s"file://${jar.getAbsolutePath}"))
-    val urlClassLoader = new URLClassLoader(jarUrls, compiler.getClass.getClassLoader)
-    val classLoader    = new AbstractFileClassLoader(compilerOutputDir, urlClassLoader)
-
     val cls = compiler(
       wrapCodeInClass(className, code),
       className,
       resetState,
       classLoader
     )
 
-    val res = cls
+    cls
       .getConstructor()
       .newInstance()
       .asInstanceOf[() => T]
       .apply()
       .asInstanceOf[T]
-
-    urlClassLoader.close()
-
-    res
   }
 
   def clean(): Unit = {
+    urlClassLoader.close()
     compiler.close()
     compilerMessageHandler.foreach(_.reset())
   }

server/src/main/scala/org/scalaexercises/evaluator/untitled.sc

@@ -0,0 +1,13 @@
+"""
+  |"\""{
+  |    "id": "c730433b-082c-4984-9d66-855c243266f0",
+  |    "name": "Foo",
+  |    "counts": [1, 2, 3],
+  |    "values": {
+  |      "bar": true,
+  |      "baz": 100.001,
+  |      "qux": ["a", "b"]
+  |    }
+  |  }
+  |  \\"""
+  |  """.stripMargin

server/src/test/scala/org/scalaexercises/evaluator/EvaluatorSpec.scala

@@ -94,9 +94,9 @@ Xor.Right(42).toOption.get
 
       val result: EvalResult[Int] = evaluator
         .eval(
-          fetchCode,
+          circeCode,
           remotes = commonResolvers,
-          dependencies = fetchLibraryDependencies(toScalaVersion(BuildInfo.scalaVersion))
+          dependencies = circeLibraryDependencies(toScalaVersion(BuildInfo.scalaVersion))
         )
         .unsafeRunSync()
 

server/src/test/scala/org/scalaexercises/evaluator/helper.scala

@@ -40,10 +40,14 @@ object helper {
     Dependency("org.scala-lang.modules", s"scala-xml_${scala.version.substring(0, 4)}", "1.2.0")
   )
 
-  def fetchLibraryDependencies(scala: ScalaVersion): List[Dependency] = {
+  def circeLibraryDependencies(scala: ScalaVersion): List[Dependency] = {
     val sv = scala.version
+
+    val circeVersion = "0.12.3"
     List(
-      Dependency("com.47deg", s"fetch_${sv.substring(0, 4)}", "1.2.1")
+      Dependency("io.circe", s"circe-core_${sv.substring(0, 4)}", circeVersion),
+      Dependency("io.circe", s"circe-generic_${sv.substring(0, 4)}", circeVersion),
+      Dependency("io.circe", s"circe-parser_${sv.substring(0, 4)}", circeVersion)
     ) ++ scalaDependencies(scala)
   }
 
@@ -58,59 +62,29 @@ import stdlib._
 Asserts.scalaTestAsserts($assertCheck)
     """
 
-  val fetchCode =
-    """
-  import scala.concurrent.ExecutionContext
-
-  import cats.data.NonEmptyList
-  import cats.effect._
-
-  import fetch._
-  import cats.implicits._
-
-  val executionContext: ExecutionContext = ExecutionContext.fromExecutor(new java.util.concurrent.ForkJoinPool(2))
-
-  implicit val timer: Timer[IO]     = IO.timer(executionContext)
-  implicit val cs: ContextShift[IO] = IO.contextShift(executionContext)
-
-  type UserId = Int
-
-  case class User(id: UserId, username: String)
-
-  def latency[F[_]: Concurrent](msg: String): F[Unit] =
-    for {
-      _ <- Sync[F].delay(println(s"--> [${Thread.currentThread.getId}] $msg"))
-      _ <- Sync[F].delay(Thread.sleep(100))
-      _ <- Sync[F].delay(println(s"<-- [${Thread.currentThread.getId}] $msg"))
-    } yield ()
-
-  val userDatabase: Map[UserId, User] = Map(
-    1 -> User(1, "@one"),
-    2 -> User(2, "@two"),
-    3 -> User(3, "@three"),
-    4 -> User(4, "@four")
-  )
-
-  object Users extends Data[UserId, User] {
-    def name = "Users"
-
-    def source[F[_]: Concurrent]: DataSource[F, UserId, User] = new DataSource[F, UserId, User] {
-      override def data = Users
-
-      def CF = Concurrent[F]
-
-      override def fetch(id: UserId): F[Option[User]] =
-        latency[F](s"One User $id") >> CF.pure(userDatabase.get(id))
+  val json = """"{
+               |    "id": "c730433b-082c-4984-9d66-855c243266f0",
+               |    "name": "Foo",
+               |    "counts": [1, 2, 3],
+               |    "values": {
+               |      "bar": true,
+               |      "baz": 100.001,
+               |      "qux": ["a", "b"]
+               |    }
+               |  }"""".stripMargin
+
+  val circeCode =
+    s"""
+  import cats.syntax.either._
+  import io.circe._
+  import io.circe.parser._
 
-      override def batch(ids: NonEmptyList[UserId]): F[Map[UserId, User]] =
-        latency[F](s"Batch Users $ids") >> CF.pure(userDatabase.view.filterKeys(ids.toList.toSet).toMap)
-    }
-  }
+  val json: String = ""$json""
 
-  def getUser[F[_]: Concurrent](id: UserId): Fetch[F, User] = Fetch[F, UserId, User](id, Users.source)
+  val doc: Json    = parse(json).getOrElse(Json.Null)
 
-  def fetchUser[F[_] : Concurrent]: Fetch[F, User] = getUser(1)
+  val cursor: HCursor = doc.hcursor
 
-  Fetch.run[IO](fetchUser).unsafeRunSync()
+  cursor.downField("values").downField("baz").as[Double]
     """
 }