Move Ruby JS lib unit tests to test-unit

Author: kateinoigakukun

packages/npm-packages/ruby-wasm-wasi/.prettierignore

@@ -1,3 +1,5 @@
 dist
 src/bindgen
 coverage
+# To avoid breaking shebang trick
+/tools/run-test-unit.mjs

packages/npm-packages/ruby-wasm-wasi/package.json

@@ -23,7 +23,9 @@
   ],
   "license": "MIT",
   "scripts": {
-    "test": "NODE_OPTIONS=\"--experimental-wasi-unstable-preview1\" jest --coverage",
+    "test": "npm run test:unit && npm run test:jest",
+    "test:jest": "NODE_OPTIONS=\"--experimental-wasi-unstable-preview1\" jest --coverage",
+    "test:unit": "./tools/run-test-unit.mjs",
     "format": "prettier --write ."
   },
   "devDependencies": {

packages/npm-packages/ruby-wasm-wasi/test/js_from_rb.test.ts

@@ -11,83 +11,6 @@ describe("Manipulation of JS from Ruby", () => {
     expect((result as any).inner._wasm_val).toBe(Qtrue);
   });
 
-  test.each([
-    // A ruby object always returns false
-    { object: "1", klass: "Integer", result: false },
-    { object: "'x'", klass: "String", result: false },
-    // A js object is not an instance of itself
-    { object: "JS.global", klass: "JS.global", result: false },
-    // globalThis is an instance of Object
-    { object: "JS.global", klass: "JS.global[:Object]", result: true },
-  ])("JS.is_a? %s", async (props) => {
-    const vm = await initRubyVM();
-    const code = `require "js"; JS.is_a?(${props.object}, ${props.klass})`;
-    expect(vm.eval(code).toString()).toBe(String(props.result));
-  });
-
-  test.each([
-    { object: `JS.eval('return 1')`, result: "number" },
-    { object: `JS.eval('return "x"')`, result: "string" },
-    { object: `JS.eval('return null')`, result: "object" },
-    { object: `JS.eval('return undefined')`, result: "undefined" },
-    { object: `JS.global`, result: "object" },
-  ])("JS::Object#typeof (%s)", async (props) => {
-    const vm = await initRubyVM();
-    const code = `require "js"; (${props.object}).typeof`;
-    expect(vm.eval(code).toString()).toBe(String(props.result));
-  });
-
-  test.each([
-    { lhs: `24`, rhs: `24`, result: true },
-    { lhs: `null`, rhs: `null`, result: true },
-    { lhs: `undefined`, rhs: `undefined`, result: true },
-    { lhs: `"str"`, rhs: `"str"`, result: true },
-    { lhs: `48`, rhs: `24`, result: false },
-    { lhs: `NaN`, rhs: `NaN`, result: false },
-  ])("JS::Object#== (%s)", async (props) => {
-    const vm = await initRubyVM();
-    const methodResult = `require "js"; JS.eval('return ${props.lhs}').eql?(JS.eval('return ${props.rhs}'))`;
-    expect(vm.eval(methodResult).toString()).toBe(String(props.result));
-
-    const operatorResult = `require "js"; JS.eval('return ${props.lhs}') == JS.eval('return ${props.rhs}')`;
-    expect(vm.eval(operatorResult).toString()).toBe(String(props.result));
-  });
-
-  test.each([
-    { lhs: `24`, rhs: `24`, result: true },
-    { lhs: `null`, rhs: `null`, result: true },
-    { lhs: `undefined`, rhs: `undefined`, result: true },
-    { lhs: `new String("str")`, rhs: `"str"`, result: false },
-  ])("JS::Object#strictly_eql? (%s)", async (props) => {
-    const vm = await initRubyVM();
-    const result = `require "js"; JS.eval('return ${props.lhs}').strictly_eql?(JS.eval('return ${props.rhs}'))`;
-    expect(vm.eval(result).toString()).toBe(String(props.result));
-  });
-
-  test.each([`24`, `"hello"`, `null`, `undefined`])(
-    "JS::Object#to_s (%s)",
-    async (value) => {
-      const vm = await initRubyVM();
-      const to_s_result = `require "js"; JS.eval('return ${value}').to_s`;
-      const inspect_result = `require "js"; JS.eval('return ${value}').inspect`;
-      expect(vm.eval(to_s_result).toString()).toBe(String(eval(value)));
-      expect(vm.eval(inspect_result).toString()).toBe(String(eval(value)));
-    }
-  );
-
-  test.each([
-    { self: `24`, calee: "toString", args: [], result: "24" },
-    { self: `"hello"`, calee: "charAt", args: [4], result: "o" },
-  ])("JS::Object#method_missing (%s)", async (props) => {
-    const vm = await initRubyVM();
-    const result = `
-    require "js"
-    obj = JS.eval('return ${props.self}')
-    obj.${props.calee}(${props.args.join(", ")})
-    `;
-    expect(vm.eval(result).toString()).toBe(props.result);
-  });
-
   test("JS::Object#method_missing with block", async () => {
     const vm = await initRubyVM();
     const proc = vm.eval(`
@@ -306,21 +229,4 @@ describe("Manipulation of JS from Ruby", () => {
       object.call("itself");
     }
   });
-
-  test("Guard null", async () => {
-    const vm = await initRubyVM();
-    const result = vm.eval(`
-      require "js"
-      intrinsics = JS.eval(<<-JS)
-        return {
-          returnNull(v) { return null },
-          returnUndef(v) { return undefined },
-        }
-      JS
-      js_null = JS.eval("return null")
-      o1 = intrinsics.call(:returnNull)
-      o1 == js_null
-    `);
-    expect(result.toString()).toEqual("true");
-  });
 });

packages/npm-packages/ruby-wasm-wasi/test/test_unit.rb

@@ -0,0 +1,2 @@
+require_relative "./unit/test_js"
+require_relative "./unit/test_object"

packages/npm-packages/ruby-wasm-wasi/test/unit/object.test.ts

@@ -0,0 +1,26 @@
+require "test-unit"
+require "js"
+
+class JS::TestJS < Test::Unit::TestCase
+  def test_is_a?
+    # A ruby object always returns false
+    assert_false JS.is_a?(1, Integer)
+    assert_false JS.is_a?('x', String)
+    # A js object is not an instance of itself
+    assert_false JS.is_a?(JS.global, JS.global)
+    # globalThis is an instance of Object
+    assert_true JS.is_a?(JS.global, JS.global[:Object])
+  end
+
+  def test_eval
+    JS.eval("var x = 42;")
+    # Variable scope is isolated in each JS.eval
+    assert_equal "not defined", JS.eval(<<~JS).to_s
+      try {
+        return x;
+      } catch {
+        return "not defined";
+      }
+    JS
+  end
+end

packages/npm-packages/ruby-wasm-wasi/test/unit/test_js.rb

@@ -0,0 +1,121 @@
+require "test-unit"
+require "js"
+
+class JS::TestObject < Test::Unit::TestCase
+  def test_typeof
+    assert_equal "number", JS.eval("return 1;").typeof
+    assert_equal "boolean", JS.eval("return true;").typeof
+    assert_equal "string", JS.eval("return 'x';").typeof
+    assert_equal "object", JS.eval("return null;").typeof
+    assert_equal "undefined", JS.eval("return undefined;").typeof
+    assert_equal "object", JS.global.typeof
+  end
+
+  def assert_object_eql?(result, a, b)
+    assert_equal result, a == b
+    assert_equal !result, a != b
+    assert_equal result, a.eql?(b)
+    assert_equal result, b.eql?(a)
+  end
+
+  def test_eql?
+    assert_object_eql? true, JS.eval("return 24;"), JS.eval("return 24;")
+    assert_object_eql? true, JS.eval("return null;"), JS.eval("return null;")
+    assert_object_eql? true, JS.eval("return undefined;"), JS.eval("return undefined;")
+    assert_object_eql? true, JS.eval("return 'x';"), JS.eval("return 'x';")
+    assert_object_eql? true, JS.eval("return null;"), JS.eval("return undefined;")
+
+    assert_object_eql? false, JS.eval("return 24;"), JS.eval("return 42;")
+    assert_object_eql? false, JS.eval("return NaN;"), JS.eval("return NaN;")
+  end
+
+  def assert_object_strictly_eql?(result, a, b)
+    assert_equal result, a.strictly_eql?(b)
+    assert_equal result, b.strictly_eql?(a)
+  end
+
+  def test_strictly_eql?
+    assert_object_strictly_eql? true, JS.eval("return 24;"), JS.eval("return 24;")
+    assert_object_strictly_eql? true, JS.eval("return null;"), JS.eval("return null;")
+    assert_object_strictly_eql? true, JS.eval("return undefined;"), JS.eval("return undefined;")
+    assert_object_strictly_eql? false, JS.eval("return new String('str');"), JS.eval("return 'str';")
+    assert_object_strictly_eql? false, JS.eval("return null;"), JS.eval("return undefined;")
+  end
+
+  def test_to_s
+    assert_equal "24", JS.eval("return 24;").to_s
+    assert_equal "true", JS.eval("return true;").to_s
+    assert_equal "null", JS.eval("return null;").to_s
+    assert_equal "undefined", JS.eval("return undefined;").to_s
+  end
+
+  def test_inspect
+    assert_equal "24", JS.eval("return 24;").inspect
+    assert_equal "true", JS.eval("return true;").inspect
+    assert_equal "null", JS.eval("return null;").inspect
+    assert_equal "undefined", JS.eval("return undefined;").inspect
+  end
+
+  def test_call
+    assert_nothing_raised { JS.global.call(:Array) }
+    assert_equal "1,2,3", JS.global.call(:Array, 1, 2, 3).to_s
+  end
+
+  def test_method_missing
+    assert_equal "42", JS.eval("return 42;").toString.to_s
+    assert_equal "o", JS.eval("return 'hello';").charAt(4).to_s
+  end
+
+  def test_method_missing_with_block
+    obj = JS.eval(<<~JS)
+      return {
+        takeBlock(block) {
+          return block(1, 2, 3);
+        }
+      }
+    JS
+    block_called = false
+    # TODO: Support return value in block
+    result = obj.takeBlock do |a, b, c|
+      block_called = true
+      # TODO: Compare them as integers after introducing `JS::Object#to_i`
+      assert_equal 1.to_s, a.to_s
+      assert_equal 2.to_s, b.to_s
+      assert_equal 3.to_s, c.to_s
+    end
+    assert_true block_called
+  end
+
+  def test_method_missing_with_undefined_method
+    object = JS.eval(<<~JS)
+      return { foo() { return true; } };
+    JS
+    assert_raise(NoMethodError) { object.bar }
+  end
+
+  def test_respond_to_missing?
+    object = JS.eval(<<~JS)
+      return { foo() { return true; } };
+    JS
+    assert_true object.respond_to?(:foo)
+    assert_false object.respond_to?(:bar)
+  end
+
+  def test_member_get
+    object = JS.eval(<<~JS)
+      return { foo: 42 };
+    JS
+    assert_equal 42.to_s, object[:foo].to_s
+    assert_equal 42.to_s, object["foo"].to_s
+  end
+
+  def test_member_set
+    object = JS.eval(<<~JS)
+      return { foo: 42 };
+    JS
+    object[:foo] = 24
+    assert_equal 24.to_s, object[:foo].to_s
+    object["foo"] = 42
+    assert_equal 42.to_s, object["foo"].to_s
+  end
+end

packages/npm-packages/ruby-wasm-wasi/test/unit/test_object.rb

@@ -0,0 +1,70 @@
+#!/bin/sh
+":" //# ; exec /usr/bin/env node --experimental-wasi-unstable-preview1 "$0" "$@"
+
+import fs from "fs/promises";
+import path from "path";
+import { WASI } from "wasi";
+import { RubyVM } from "../dist/index.cjs.js";
+
+const instantiate = async (rootTestFile) => {
+  const dirname = path.dirname(new URL(import.meta.url).pathname);
+  let binaryPath;
+  let preopens = {
+    __root__: path.join(dirname, ".."),
+  };
+  if (process.env.RUBY_ROOT) {
+    binaryPath = path.join(process.env.RUBY_ROOT, "./usr/local/bin/ruby");
+    preopens["/usr"] = path.join(process.env.RUBY_ROOT, "./usr");
+  } else {
+    binaryPath = path.join(dirname, "../dist/ruby+stdlib.wasm");
+  }
+  const binary = await fs.readFile(binaryPath);
+  const rubyModule = await WebAssembly.compile(binary);
+  const wasi = new WASI({
+    stdio: "inherit",
+    args: ["ruby.wasm"].concat(process.argv.slice(2)),
+    env: process.env,
+    preopens: preopens,
+  });
+
+  const vm = new RubyVM();
+  const imports = {
+    wasi_snapshot_preview1: wasi.wasiImport,
+  };
+
+  vm.addToImports(imports);
+
+  const instance = await WebAssembly.instantiate(rubyModule, imports);
+  await vm.setInstance(instance);
+
+  wasi.initialize(instance);
+
+  vm.initialize(["ruby.wasm", rootTestFile]);
+  return { instance, vm };
+};
+
+const main = async () => {
+  const rootTestFile = "/__root__/test/test_unit.rb";
+  const { vm } = await instantiate(rootTestFile);
+
+  vm.eval(`
+    # HACK: Until we've fixed the issue in the test-unit or power_assert
+    # See https://github.com/test-unit/test-unit/pull/221
+    module Kernel
+      alias test_unit_original_require require
+
+      def require(path)
+        if path == "power_assert"
+          raise LoadError, "power_assert is not supported in this environment"
+        end
+        test_unit_original_require(path)
+      end
+    end
+
+    require 'test/unit'
+    require_relative '${rootTestFile}'
+    Test::Unit::AutoRunner.run
+  `);
+};
+
+main();