Use assertion instead of info

Author: exoego

app/current/src/test/resources/fileA2.txt

@@ -1,7 +1,7 @@
 package io.scalajs.nodejs
 
-import io.scalajs.JSON
 import io.scalajs.nodejs.Process.ProcessEnvExtensions
+import io.scalajs.nodejs.os.OS
 import org.scalatest.FunSpec
 
 import scala.scalajs.js
@@ -12,30 +12,34 @@ import scala.scalajs.js
 class ProcessTest extends FunSpec {
 
   describe("Process") {
+    val versionPrefix =
+      if (TestEnvironment.isExecutedInExactNode8) "v8."
+      else if (TestEnvironment.isExecutedInExactNode10) "v10."
+      else if (TestEnvironment.isExecutedInExactNode12) "v12."
+      else "Unknown node.js version"
 
     it("contains the following properties") {
-      show("process.arch", process.arch)
-      show("process.argv", process.argv)
-      show("process.config", process.config)
-      show("process.connected", process.connected)
-      show("process.cwd()", process.cwd())
-      show("process.domain", process.domain)
-      show("process.env", process.env)
-      show("process.env.NODE_ENV", process.env.NODE_ENV)
-      show("process.env.PATH", process.env.PATH)
-      show("process.execArgv", process.execArgv)
-      show("process.execPath", process.execPath)
-      show("process.features", process.features)
-      show("process.moduleLoadList", process.moduleLoadList)
-      show("process.title", process.title)
-      show("process.version", process.version)
-      show("process.versions", JSON.stringify(process.versions))
-      //show("process.stdout.isTTY", process.stdout.isTTY)
-      //show("process.stderr.isTTY", process.stderr.isTTY)
+      assert(process.arch.isInstanceOf[String])
+      assert(process.argv.length === 1)
+      assert(process.argv(0).endsWith("node"))
+      assert(process.config("variables").asInstanceOf[js.Dictionary[String]]("host_arch") === OS.arch())
+      assert(process.connected.isEmpty)
+      assert(process.cwd().nonEmpty)
+      assert(process.env("PATH").nonEmpty)
+      assert(process.env.PATH === process.env("PATH"))
+      assert(process.execArgv.length === 0)
+      assert(process.execPath.endsWith("node"))
+      assert(process.features.contains("debug"))
+      assert(process.moduleLoadList.length > 0)
+      assert(process.title.isInstanceOf[String])
+      assert(process.version.startsWith(versionPrefix))
+      assert(process.versions.node.map(v => s"v${v}").getOrElse("").startsWith(versionPrefix))
+
+      // TODO: actually undefined in test
+      // assert(process.stdout.isTTY)
+      // assert(process.stderr.isTTY)
     }
 
   }
 
-  private def show(label: String, value: js.Any) = info(s"$label: $value")
-
 }

app/nodejs-v8/src/test/scala/io/scalajs/nodejs/ProcessTest.scala

@@ -3,19 +3,15 @@ package io.scalajs.nodejs
 import io.scalajs.nodejs.buffer.Buffer
 import org.scalatest.FunSpec
 
-/**
-  * StringDecoder Tests
-  */
 class StringDecoderTest extends FunSpec {
 
   describe("StringDecoder") {
 
     it("should decode strings or buffer") {
       val decoder = new StringDecoder("utf8")
-
-      info(decoder.write(Buffer.from("Hello ")))
-      info(decoder.write(Buffer.from("World")))
-      info(decoder.end(Buffer.from("!")))
+      assert(decoder.write(Buffer.from("Hello ")) === "Hello ")
+      assert(decoder.write(Buffer.from("World")) === "World")
+      assert(decoder.end(Buffer.from("!")) === "!")
     }
 
   }

app/nodejs-v8/src/test/scala/io/scalajs/nodejs/StringDecoderTest.scala

@@ -8,6 +8,8 @@ object TestEnvironment {
   private lazy val nodeMajorVersion: Int =
     ChildProcess.execSync("node -v").asInstanceOf[Buffer].toString().drop(1).takeWhile(_.isDigit).toInt
 
+  def isWindows: Boolean = os.OS.platform().startsWith("win")
+
   def isExecutedInExactNode12: Boolean = nodeMajorVersion == 12
   def isExecutedInExactNode10: Boolean = nodeMajorVersion == 10
   def isExecutedInExactNode8: Boolean  = nodeMajorVersion == 8

app/nodejs-v8/src/test/scala/io/scalajs/nodejs/TestEnvironment.scala

@@ -1,15 +1,11 @@
 package io.scalajs.nodejs.buffer
 
-import io.scalajs.collection.Iterator.Entry
 import io.scalajs.nodejs.{TestEnvironment, buffer}
 import org.scalatest.FunSpec
 
 import scala.scalajs.js
 import scala.scalajs.js.typedarray.{ArrayBuffer, DataView, Uint8Array}
 
-/**
-  * Buffer Tests
-  */
 class BufferTest extends FunSpec {
 
   describe("Buffer") {
@@ -26,19 +22,19 @@ class BufferTest extends FunSpec {
         assert(buf2.compare(buf3) === 1)
       }
 
-      it("should support iterating entries [classic]") {
-        val buf                   = Buffer.from("Hello!")
-        val it                    = buf.entries()
-        var result: Entry[js.Any] = null
-        do {
-          result = it.next()
-          if (!result.done) info(s"value: ${result.value}")
-        } while (!result.done)
-      }
-
-      it("should support iterating entries [Scala]") {
+      it("should support iterating entries") {
         val buf = Buffer.from("Hello!")
-        for (value <- buf.entries()) info(s"value: $value")
+        val it  = buf.entries()
+        assert(
+          it.toSeq.map(_.toSeq) === Seq(
+            Seq(0, 72),
+            Seq(1, 101),
+            Seq(2, 108),
+            Seq(3, 108),
+            Seq(4, 111),
+            Seq(5, 33)
+          )
+        )
       }
 
       it("should support buffer property") {
@@ -76,24 +72,20 @@ class BufferTest extends FunSpec {
 
       it("should create buffers from strings") {
         val bufA = Buffer.from("Hello ")
-        info(s"bufA => ${bufA.toString()}")
         val bufB = Buffer.from("World")
-        info(s"bufB => ${bufB.toString()}")
         val bufC = bufA + bufB
-        info(s"bufC => ${bufC.toString()}, length = ${bufC.byteLength()}")
 
         assert(bufA.toString() === "Hello ")
         assert(bufB.toString() === "World")
-        assert(bufC.byteLength() === 11)
+        assert(bufC.byteLength === 11)
       }
 
       it("should create buffers from buffers") {
         val buffer = Buffer.from("hello")
         assert(Buffer.from(buffer).toString() === "hello")
 
-        // TODO: when Scala.js added TypedArray.from
-        // val uints = Uint8Array.from(???)
-        // assert(Buffer.from(uints).toString() ==="worlds")
+        val uints = Uint8Array.from(js.Array(72, 101, 108, 108, 111))
+        assert(Buffer.from(uints).toString() === "Hello")
       }
 
       it("should support concat") {

app/nodejs-v8/src/test/scala/io/scalajs/nodejs/buffer/BufferTest.scala

@@ -1,46 +1,69 @@
 package io.scalajs.nodejs
 package child_process
 
-import io.scalajs.nodejs.Error
 import io.scalajs.nodejs.buffer.Buffer
 import io.scalajs.util.ScalaJsHelper._
-import org.scalatest.FunSpec
+import org.scalatest.AsyncFunSpec
 
+import scala.concurrent.{ExecutionContext, Promise}
 import scala.scalajs.js
 import scala.scalajs.js.|
 
 /**
   * ChildProcess Test
   *
   */
-class ChildProcessTest extends FunSpec {
+class ChildProcessTest extends AsyncFunSpec {
+  override implicit val executionContext = ExecutionContext.Implicits.global
+
+  describe("Extension") {
+    it("supports execFuture(...)") {
+      for {
+        r <- ChildProcess.execFuture("cat ./package.json | wc -l")
+      } yield {
+        assert(r._1.asInstanceOf[Buffer].toString().trim.toInt > 0)
+      }
+    }
+  }
 
   describe("ChildProcess") {
     it("supports exec(...)") {
+      val promise = Promise[(Output, Output)]()
       ChildProcess.exec(
         "cat ./package.json | wc -l",
-        callback = (error: Error, stdout: Buffer | String, stderr: Buffer | String) => {
+        callback = (error: Error, stdout: Output, stderr: Output) => {
           if (isDefined(error)) {
-            console.error(s"exec error: $error")
+            promise.failure(error)
+          } else {
+            promise.success((stdout, stderr))
           }
-          info(s"stdout: $stdout")
-          info(s"stderr: $stderr")
         }
       )
+      promise.future.map {
+        case (stdout, stderr) =>
+          assert(stdout.toString.trim.toInt === 19)
+          assert(stderr.toString.trim === "")
+      }
     }
 
     it("supports execFile(...)") {
+      val promise = Promise[(Output, Output)]()
       ChildProcess.execFile(
         "ls",
         js.Array("-l"),
-        callback = (error: Error, stdout: Buffer | String, stderr: Buffer | String) => {
+        callback = (error: Error, stdout: Output, stderr: Output) => {
           if (isDefined(error)) {
-            console.error(s"exec error: $error")
+            promise.failure(error)
+          } else {
+            promise.success((stdout, stderr))
           }
-          info(s"stdout: $stdout")
-          info(s"stderr: $stderr")
         }
       )
+      promise.future.map {
+        case (stdout, stderr) =>
+          assert(stdout.toString.trim.linesIterator.length > 10)
+          assert(stderr.toString.trim === "")
+      }
     }
 
     it("supports execSync(...)") {

app/nodejs-v8/src/test/scala/io/scalajs/nodejs/child_process/ChildProcessAsyncTest.scala

@@ -8,30 +8,23 @@ import org.scalatest.FunSpec
 import scala.concurrent.duration._
 import scala.scalajs.js
 
-/**
-  * Cluster Tests
-  */
 class ClusterTest extends FunSpec {
 
   describe("Cluster") {
 
     it("cluster should be master") {
-      info(s"cluster.isMaster => ${Cluster.isMaster}")
       assert(Cluster.isMaster)
     }
 
     it("cluster should not be a worker") {
-      info(s"cluster.isWorker => ${Cluster.isWorker}")
       assert(!Cluster.isWorker)
     }
 
     it("cluster.schedulingPolicy must be defined") {
-      info(s"cluster.schedulingPolicy => ${Cluster.schedulingPolicy}")
       assert(!js.isUndefined(Cluster.schedulingPolicy))
     }
 
     it("cluster.settings  must be defined") {
-      info(s"cluster.settings => ${JSON.stringify(Cluster.settings)}")
       assert(!js.isUndefined(Cluster.settings))
     }
 

app/nodejs-v8/src/test/scala/io/scalajs/nodejs/child_process/ChildProcessTest.scala

@@ -3,17 +3,57 @@ package dns
 
 import org.scalatest.AsyncFunSpec
 
-import scala.concurrent.ExecutionContext
+import scala.concurrent.{ExecutionContext, Promise}
 import scala.scalajs.js
 
-/**
-  * DNS Tests
-  */
 class DNSAsyncTest extends AsyncFunSpec {
-  private val domain                     = "google.com"
   override implicit val executionContext = ExecutionContext.Implicits.global
 
+  private val domain = "google.com"
+
   describe("DNS") {
+
+    it("supports lookup") {
+      val promise = Promise[String]()
+      DNS.lookup(domain, (err, ipAddress) => {
+        assert(err === null)
+        promise.success(ipAddress)
+      })
+      promise.future.map { ipAddress =>
+        assert(ipAddress.nonEmpty)
+      }
+    }
+
+    it("supports lookupService:SSH") {
+      val promise = Promise[(String, String)]()
+      DNS.lookupService("127.0.0.1", 22, (err, hostname, service) => {
+        assert(err === null)
+        promise.success((hostname, service))
+      })
+      promise.future.map {
+        case (host, service) =>
+          assert(host === "localhost")
+          assert(service === "ssh")
+      }
+    }
+
+    it("supports resolve:NS") {
+      val promise = Promise[js.Array[String]]()
+      DNS.resolve(
+        domain,
+        "NS",
+        (err: DnsError, addresses: ResolveResult) => {
+          assert(err === null)
+          promise.success(addresses.asInstanceOf[js.Array[String]])
+        }
+      )
+      promise.future.map { addresses =>
+        assert(addresses.nonEmpty)
+      }
+    }
+  }
+
+  describe("DNS future extension") {
     it("supports lookupFuture") {
       DNS.lookupFuture(domain) map {
         case (ipAddress, ttl) =>