Add first version management tests to PM

enso-org · radeusgd · Nov 16, 2020 · Oct 30, 2020 · Nov 2, 2020 · Nov 5, 2020
commit 1c0c69135716a2badc89038dbe82799924bd4650
diff --git a/...cala/json-rpc-server-test/src/main/scala/org/enso/jsonrpc/test/JsonRpcServerTestKit.scala b/...cala/json-rpc-server-test/src/main/scala/org/enso/jsonrpc/test/JsonRpcServerTestKit.scala
@@ -12,7 +12,7 @@ import io.circe.parser.parse
 import org.enso.jsonrpc.{ClientControllerFactory, JsonRpcServer, Protocol}
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpecLike
-import org.scalatest.{Assertion, BeforeAndAfterAll, BeforeAndAfterEach}
+import org.scalatest.{Assertion, BeforeAndAfterAll, BeforeAndAfterEach, Inside}
 
 import scala.concurrent.Await
 import scala.concurrent.duration._
@@ -25,7 +25,8 @@ abstract class JsonRpcServerTestKit
     with AnyWordSpecLike
     with Matchers
     with BeforeAndAfterAll
-    with BeforeAndAfterEach {
+    with BeforeAndAfterEach
+    with Inside {
 
   implicit final class ACursorExpectedField(cursor: ACursor) {
 

diff --git a/...er/src/main/scala/org/enso/projectmanager/requesthandler/EngineListAvailableHandler.scala b/...er/src/main/scala/org/enso/projectmanager/requesthandler/EngineListAvailableHandler.scala
@@ -24,10 +24,11 @@ class EngineListAvailableHandler[F[+_, +_]: Exec: CovariantFlatMap](
     case Request(EngineListAvailable, id, Unused) =>
       for {
         result <- service.listAvailableEngines()
+        sorted = result.sortBy(_.version).reverse
       } yield ResponseResult(
         EngineListAvailable,
         id,
-        EngineListAvailable.Result(result)
+        EngineListAvailable.Result(sorted)
       )
   }
 }

diff --git a/...er/src/main/scala/org/enso/projectmanager/requesthandler/EngineListInstalledHandler.scala b/...er/src/main/scala/org/enso/projectmanager/requesthandler/EngineListInstalledHandler.scala
@@ -24,10 +24,11 @@ class EngineListInstalledHandler[F[+_, +_]: Exec: CovariantFlatMap](
     case Request(EngineListInstalled, id, Unused) =>
       for {
         result <- service.listInstalledEngines()
+        sorted = result.sortBy(_.version).reverse
       } yield ResponseResult(
         EngineListInstalled,
         id,
-        EngineListInstalled.Result(result)
+        EngineListInstalled.Result(sorted)
       )
   }
 }

diff --git a/lib/scala/project-manager/src/test/scala/org/enso/projectmanager/BaseServerSpec.scala b/lib/scala/project-manager/src/test/scala/org/enso/projectmanager/BaseServerSpec.scala
@@ -28,6 +28,7 @@ import org.enso.projectmanager.service.config.GlobalConfigService
 import org.enso.projectmanager.service.versionmanagement.RuntimeVersionManagementService
 import org.enso.projectmanager.service.{MonadicProjectValidator, ProjectService}
 import org.enso.projectmanager.test.{ObservableGenerator, ProgrammableClock}
+import org.enso.runtimeversionmanager.test.{DropLogs, FakeReleases}
 import pureconfig.ConfigSource
 import pureconfig.generic.auto._
 import zio.interop.catz.core._
@@ -36,7 +37,7 @@ import zio.{Runtime, Semaphore, ZEnv, ZIO}
 import scala.concurrent.{Await, Future}
 import scala.concurrent.duration._
 
-class BaseServerSpec extends JsonRpcServerTestKit {
+class BaseServerSpec extends JsonRpcServerTestKit with DropLogs {
 
   override def protocol: Protocol = JsonRpc.protocol
 
@@ -124,7 +125,11 @@ class BaseServerSpec extends JsonRpcServerTestKit {
     )
 
   lazy val distributionConfiguration =
-    TestDistributionConfiguration.withoutReleases(testDistributionRoot.toPath)
+    TestDistributionConfiguration(
+      distributionRoot       = testDistributionRoot.toPath,
+      engineReleaseProvider  = FakeReleases.engineReleaseProvider,
+      runtimeReleaseProvider = FakeReleases.runtimeReleaseProvider
+    )
 
   lazy val globalConfigService = new GlobalConfigService[ZIO[ZEnv, +*, +*]](
     distributionConfiguration

diff --git a/...roject-manager/src/test/scala/org/enso/projectmanager/TestDistributionConfiguration.scala b/...roject-manager/src/test/scala/org/enso/projectmanager/TestDistributionConfiguration.scala
@@ -83,4 +83,15 @@ object TestDistributionConfiguration {
     )
   }
 
+  def apply(
+    distributionRoot: Path,
+    engineReleaseProvider: ReleaseProvider[EngineRelease],
+    runtimeReleaseProvider: GraalVMRuntimeReleaseProvider
+  ): TestDistributionConfiguration =
+    new TestDistributionConfiguration(
+      distributionRoot,
+      engineReleaseProvider,
+      runtimeReleaseProvider
+    )
+
 }
diff --git a/...ect-manager/src/test/scala/org/enso/projectmanager/protocol/EngineManagementApiSpec.scala b/...ect-manager/src/test/scala/org/enso/projectmanager/protocol/EngineManagementApiSpec.scala
@@ -0,0 +1,146 @@
+package org.enso.projectmanager.protocol
+
+import io.circe.literal._
+import org.enso.projectmanager.{BaseServerSpec, ProjectManagementOps}
+import org.enso.testkit.FlakySpec
+
+class EngineManagementApiSpec
+    extends BaseServerSpec
+    with FlakySpec
+    with ProjectManagementOps {
+
+  "engine/*" must {
+    "report no installed engines" in {
+      implicit val client = new WsTestClient(address)
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/list-installed",
+              "id": 0
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":0,
+            "result" : {
+              "versions" : []
+            }
+          }
+          """)
+    }
+
+    "report available engines" in {
+      implicit val client = new WsTestClient(address)
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/list-available",
+              "id": 0
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":0,
+            "result" : {
+              "versions" : [
+                {"version": "0.999.0-broken", "markedAsBroken": true},
+                {"version": "0.0.1", "markedAsBroken": false},
+                {"version": "0.0.1-pre", "markedAsBroken": false},
+                {"version": "0.0.0", "markedAsBroken": false}
+              ]
+            }
+          }
+          """)
+    }
+
+    "install and uninstall the engine and reflect changes in list" ignore {
+      implicit val client = new WsTestClient(address)
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/install",
+              "id": 0,
+              "params": {
+                "version": "0.0.0"
+              }
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":0
+          }
+          """)
+
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/install",
+              "id": 1,
+              "params": {
+                "version": "0.0.1-pre"
+              }
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":1
+          }
+          """)
+
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/list-installed",
+              "id": 2
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":2,
+            "result" : {
+              "versions" : [
+                {"version": "0.0.1-pre", "markedAsBroken": false},
+                {"version": "0.0.0", "markedAsBroken": false}
+              ]
+            }
+          }
+          """)
+
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/uninstall",
+              "id": 3,
+              "params": {
+                "version": "0.0.1-pre"
+              }
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":3
+          }
+          """)
+
+      client.send(json"""
+            { "jsonrpc": "2.0",
+              "method": "engine/list-installed",
+              "id": 4
+            }
+          """)
+      client.expectJson(json"""
+          {
+            "jsonrpc":"2.0",
+            "id":4,
+            "result" : {
+              "versions" : [
+                {"version": "0.0.0", "markedAsBroken": false}
+              ]
+            }
+          }
+          """)
+    }
+
+    "only install broken releases if specifically asked to" ignore {}
+  }
+}
diff --git a/...ct-manager/src/test/scala/org/enso/projectmanager/protocol/ProjectManagementApiSpec.scala b/...ct-manager/src/test/scala/org/enso/projectmanager/protocol/ProjectManagementApiSpec.scala
@@ -768,56 +768,4 @@ class ProjectManagementApiSpec
     }
 
   }
-
-  "engine/*" must {
-    "report no installed engines" in {
-      implicit val client = new WsTestClient(address)
-      client.send(json"""
-            { "jsonrpc": "2.0",
-              "method": "engine/list-installed",
-              "id": 0
-            }
-          """)
-      client.expectJson(json"""
-          {
-            "jsonrpc":"2.0",
-            "id":0,
-            "result" : {
-              "versions" : []
-            }
-          }
-          """)
-    }
-
-    // TODO [RW] add these tests
-    "report available engines" ignore {}
-
-    "install and uninstall the engine and reflect changes in list" ignore {
-      // TODO [RW] this is just a stub test for parsing, it should be replaced
-      //  with actual tests once this functionality is implemented
-      implicit val client = new WsTestClient(address)
-      client.send(json"""
-            { "jsonrpc": "2.0",
-              "method": "engine/install",
-              "id": 0,
-              "params": {
-                "version": "0.1.0-rc3"
-              }
-            }
-          """)
-      client.expectJson(json"""
-          {
-            "jsonrpc":"2.0",
-            "id":0,
-            "error":{
-              "code":10,
-              "message":"The requested method is not implemented"
-            }
-          }
-          """)
-    }
-
-    "only install broken releases if specifically asked to" ignore {}
-  }
-
 }
diff --git a/...me-version-manager-test/src/main/scala/org/enso/runtimeversionmanager/test/DropLogs.scala b/...me-version-manager-test/src/main/scala/org/enso/runtimeversionmanager/test/DropLogs.scala
@@ -3,8 +3,14 @@ package org.enso.runtimeversionmanager.test
 import org.enso.loggingservice.TestLogger
 import org.scalatest.{BeforeAndAfterAll, Suite}
 
+/** Ensures that any pending logs that were not processed when executing tests
+  * are ignored instead of being dumped to stderr.
+  *
+  * This does not affect tests that set up the loggings service themselves or
+  * capture the logs. It only affects logs that were not handled at all.
+  */
 trait DropLogs extends BeforeAndAfterAll { self: Suite =>
-  override protected def afterAll(): Unit = {
+  override def afterAll(): Unit = {
     super.afterAll()
     TestLogger.dropLogs()
   }

diff --git a/...ersion-manager-test/src/main/scala/org/enso/runtimeversionmanager/test/FakeReleases.scala b/...ersion-manager-test/src/main/scala/org/enso/runtimeversionmanager/test/FakeReleases.scala
@@ -2,10 +2,27 @@ package org.enso.runtimeversionmanager.test
 
 import java.nio.file.Path
 
+import org.enso.runtimeversionmanager.releases.engine.EngineReleaseProvider
+import org.enso.runtimeversionmanager.releases.graalvm.GraalCEReleaseProvider
+import org.enso.runtimeversionmanager.releases.testing.FakeReleaseProvider
+
 object FakeReleases {
 
   /** Location of fake engine and runtime releases used for testing component
     * installation.
     */
-  def path: Path = Path.of(getClass.getResource("fake-releases").toURI)
+  def releaseRoot: Path = Path.of(getClass.getResource("fake-releases").toURI)
+
+  /** Provider of engine releases using the test fixtures. */
+  lazy val engineReleaseProvider = new EngineReleaseProvider(
+    FakeReleaseProvider(
+      releaseRoot.resolve("enso"),
+      copyIntoArchiveRoot = Seq("manifest.yaml")
+    )
+  )
+
+  /** Provider of Graal runtime releases using the test fixtures. */
+  lazy val runtimeReleaseProvider = new GraalCEReleaseProvider(
+    FakeReleaseProvider(releaseRoot.resolve("graalvm"))
+  )
 }
diff --git a/...r-test/src/main/scala/org/enso/runtimeversionmanager/test/RuntimeVersionManagerTest.scala b/...r-test/src/main/scala/org/enso/runtimeversionmanager/test/RuntimeVersionManagerTest.scala
@@ -3,6 +3,7 @@ package org.enso.runtimeversionmanager.test
 import java.nio.file.Path
 
 import nl.gn0s1s.bump.SemVer
+import org.enso.pkg.{PackageManager, SemVerEnsoVersion}
 import org.enso.runtimeversionmanager._
 import org.enso.runtimeversionmanager.components.{
   RuntimeVersionManagementUserInterface,
@@ -13,10 +14,6 @@ import org.enso.runtimeversionmanager.distribution.{
   PortableDistributionManager,
   TemporaryDirectoryManager
 }
-import org.enso.runtimeversionmanager.releases.engine.EngineReleaseProvider
-import org.enso.runtimeversionmanager.releases.graalvm.GraalCEReleaseProvider
-import org.enso.runtimeversionmanager.releases.testing.FakeReleaseProvider
-import org.enso.pkg.{PackageManager, SemVerEnsoVersion}
 import org.scalatest.OptionValues
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
@@ -46,16 +43,6 @@ class RuntimeVersionManagerTest
   ): (DistributionManager, RuntimeVersionManager, Environment) = {
     val env                 = fakeInstalledEnvironment(environmentOverrides)
     val distributionManager = new PortableDistributionManager(env)
-    val fakeReleasesRoot    = FakeReleases.path
-    val engineProvider = new EngineReleaseProvider(
-      FakeReleaseProvider(
-        fakeReleasesRoot.resolve("enso"),
-        copyIntoArchiveRoot = Seq("manifest.yaml")
-      )
-    )
-    val runtimeProvider = new GraalCEReleaseProvider(
-      FakeReleaseProvider(fakeReleasesRoot.resolve("graalvm"))
-    )
 
     val resourceManager = TestLocalResourceManager.create()
     val temporaryDirectoryManager =
@@ -66,8 +53,8 @@ class RuntimeVersionManagerTest
       distributionManager,
       temporaryDirectoryManager,
       resourceManager,
-      engineProvider,
-      runtimeProvider
+      FakeReleases.engineReleaseProvider,
+      FakeReleases.runtimeReleaseProvider
     )
 
     (distributionManager, runtimeVersionManager, env)