funicular 0.1.0 → 0.2.0

data/lib/funicular/testing/node_runner.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const manifestPath = process.argv[2];
+
+if (!manifestPath) {
+  console.error('Usage: node node_runner.mjs <manifest.json>');
+  process.exit(1);
+}
+
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+const appRequire = createRequire(join(manifest.appRoot, 'package.json'));
+const RESULT_MARKER = '__FUNICULAR_TEST_RESULTS_JSON__=';
+
+let JSDOM;
+try {
+  ({ JSDOM } = appRequire('jsdom'));
+} catch (error) {
+  console.error('Funicular client tests require jsdom.');
+  console.error('Install it in the Rails app with: npm install --save-dev jsdom');
+  console.error(error.message);
+  process.exit(1);
+}
+
+const runtimeDir = resolve(manifest.runtimeDir);
+const modulePath = join(runtimeDir, 'picoruby.js');
+
+function installDom() {
+  const dom = new JSDOM(manifest.html, {
+    url: manifest.url,
+    pretendToBeVisual: true,
+    runScripts: 'outside-only'
+  });
+
+  const win = dom.window;
+  globalThis.window = win;
+  globalThis.document = win.document;
+  globalThis.location = win.location;
+  globalThis.history = win.history;
+  Object.defineProperty(globalThis, 'navigator', { value: win.navigator, configurable: true });
+  Object.defineProperty(globalThis, 'localStorage', { value: win.localStorage, configurable: true });
+  globalThis.Event = win.Event;
+  globalThis.CustomEvent = win.CustomEvent;
+  globalThis.MouseEvent = win.MouseEvent;
+  globalThis.KeyboardEvent = win.KeyboardEvent;
+  globalThis.InputEvent = win.InputEvent;
+  globalThis.FormData = win.FormData;
+  globalThis.Element = win.Element;
+  globalThis.Document = win.Document;
+  globalThis.HTMLElement = win.HTMLElement;
+  globalThis.Node = win.Node;
+  globalThis.Text = win.Text;
+  globalThis.Response = globalThis.Response || win.Response;
+  globalThis.fetch = globalThis.fetch || win.fetch?.bind(win);
+  win.fetch = globalThis.fetch;
+
+  return dom;
+}
+
+function rubyString(value) {
+  return JSON.stringify(String(value));
+}
+
+function bootstrapRuby() {
+  const sourceFiles = manifest.sourceFiles.map(rubyString).join(', ');
+  const testFiles = manifest.testFiles.map(rubyString).join(', ');
+
+  return `
+require 'json'
+require 'picotest'
+require 'funicular'
+
+module Funicular
+  module Testing
+    class DOMTest < Picotest::Test
+      def setup
+        JS.eval("document.body.innerHTML = '<div id=\\\\\\"app\\\\\\"></div>'")
+      end
+
+      def document
+        JS.document
+      end
+
+      def container
+        document.getElementById('app')
+      end
+
+      def mount(component_class, props = {})
+        @component = component_class.new(props)
+        @component.mount(container)
+        drain
+        @component
+      end
+
+      def query(selector)
+        document.querySelector(selector)
+      end
+
+      def assert_selector(selector)
+        actual = query(selector)
+        report(!actual.nil?, "Expected selector #{selector.inspect} to exist", selector, actual)
+      end
+
+      def text(selector = nil)
+        target = selector ? query(selector) : document.body
+        target ? target[:textContent].to_s : ''
+      end
+
+      def assert_text(expected, selector = nil)
+        actual = text(selector)
+        report(
+          actual.include?(expected.to_s),
+          "Expected text to include #{expected.to_s.inspect}",
+          expected.to_s,
+          actual
+        )
+      end
+
+      def dispatch(selector, event_type)
+        script = "document.querySelector(" + JSON.generate(selector) + ")" \
+          + ".dispatchEvent(new Event(" + JSON.generate(event_type) \
+          + ", { bubbles: true, cancelable: true }))"
+        JS.eval(script)
+        drain
+      end
+
+      def click(selector)
+        dispatch(selector, 'click')
+      end
+
+      def submit(selector = 'form')
+        dispatch(selector, 'submit')
+      end
+
+      def input(selector, value)
+        JS.global[:__funicularTestingValue] = value.to_s
+        script = "document.querySelector(" + JSON.generate(selector) + ")" \
+          + ".value = globalThis.__funicularTestingValue"
+        JS.eval(script)
+        dispatch(selector, 'input')
+      ensure
+        JS.global[:__funicularTestingValue] = nil
+      end
+
+      def drain(ms = 20)
+        sleep_ms(ms) if respond_to?(:sleep_ms)
+      end
+    end
+  end
+end
+
+source_files = [${sourceFiles}]
+test_files = [${testFiles}]
+
+(source_files + test_files).each { |file| load file }
+
+test_classes = Object.constants.map { |name| Object.const_get(name) }.select do |klass|
+  klass.class? &&
+    klass != Picotest::Test &&
+    klass != Funicular::Testing::DOMTest &&
+    klass.ancestors.include?(Picotest::Test)
+end
+
+results = {}
+
+test_classes.each do |klass|
+  test = klass.new
+  test.list_tests.each do |method_name|
+    puts
+    print "  #{klass}##{method_name} "
+    failure_count_before = test.result["failures"].size
+    exception_count_before = test.result["exceptions"].size
+    begin
+      test.setup
+      test.send(method_name)
+    rescue Picotest::Skip => e
+      test.report_skip({ method: method_name.to_s, reason: e.message })
+    rescue => e
+      test.report_exception({ method: method_name.to_s, raise_message: "#{e.class}: #{e.message}" })
+    ensure
+      begin
+        test.teardown
+      rescue => e
+        test.report_exception({ method: method_name.to_s, raise_message: "teardown #{e.class}: #{e.message}" })
+      end
+      test.clear_doubles
+    end
+    test.result["failures"][failure_count_before..-1].each do |failure|
+      failure[:test] ||= "#{klass}##{method_name}"
+    end
+    test.result["exceptions"][exception_count_before..-1].each do |exception|
+      exception[:test] ||= "#{klass}##{method_name}"
+    end
+  end
+  results[klass.to_s] = test.result
+end
+
+puts
+
+JS.global[:__funicularTestResult] = JSON.generate(results)
+JS.global[:__funicularTestDone] = true
+`;
+}
+
+function summarize(results) {
+  let success = 0;
+  let failures = 0;
+  let exceptions = 0;
+  let crashes = 0;
+  let skips = 0;
+
+  for (const [name, result] of Object.entries(results)) {
+    const failureCount = result.failures?.length || 0;
+    const exceptionCount = result.exceptions?.length || 0;
+    const crashCount = result.crashes?.length || 0;
+    const skipCount = result.skipped_count || 0;
+    success += result.success_count || 0;
+    failures += failureCount;
+    exceptions += exceptionCount;
+    crashes += crashCount;
+    skips += skipCount;
+
+    console.log(`${name}: success=${result.success_count || 0}, failure=${failureCount}, exception=${exceptionCount}, crash=${crashCount}, skip=${skipCount}`);
+    for (const failure of result.failures || []) {
+      const location = failure.method ? ` (${failure.method})` : '';
+      console.log(`  F ${failure.test || name}${location}: ${failure.error_message}`);
+      if (failure.expected !== undefined || failure.actual !== undefined) {
+        console.log(`    expected: ${JSON.stringify(failure.expected)}`);
+        console.log(`    actual:   ${JSON.stringify(failure.actual)}`);
+      }
+    }
+    for (const exception of result.exceptions || []) {
+      console.log(`  E ${exception.test || exception.method || name}: ${exception.raise_message}`);
+    }
+  }
+
+  console.log(`Total: success=${success}, failure=${failures}, exception=${exceptions}, crash=${crashes}, skip=${skips}`);
+  return failures + exceptions + crashes;
+}
+
+async function main() {
+  const { default: createModule } = await import(pathToFileURL(modulePath).href);
+  const Module = await createModule({
+    locateFile: (file) => join(runtimeDir, file),
+    print: (text) => process.stdout.write(text + '\n'),
+    printErr: (text) => process.stderr.write(text + '\n')
+  });
+
+  installDom();
+
+  const initResult = Module.ccall('picorb_init', 'number', [], []);
+  if (initResult !== 0) {
+    throw new Error('Failed to initialize PicoRuby');
+  }
+
+  const code = bootstrapRuby();
+  const createResult = Module.ccall(
+    'picorb_create_task_with_filename',
+    'number',
+    ['string', 'string'],
+    [code, 'funicular-client-tests.rb']
+  );
+  if (createResult !== 0) {
+    throw new Error('Failed to create Funicular test task');
+  }
+
+  const timeoutAt = Date.now() + Number(manifest.timeoutMs || 5000);
+  while (!(globalThis.__funicularTestDone || globalThis.window?.__funicularTestDone) && Date.now() < timeoutAt) {
+    Module.ccall('mrb_run_step', 'number', [], []);
+    Module.ccall('mrb_tick_wasm', null, [], []);
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 1));
+  }
+
+  if (!(globalThis.__funicularTestDone || globalThis.window?.__funicularTestDone)) {
+    console.error(`Funicular client tests timed out after ${manifest.timeoutMs}ms`);
+    process.exit(1);
+  }
+
+  const resultJson = globalThis.__funicularTestResult || globalThis.window?.__funicularTestResult || '{}';
+  const results = JSON.parse(resultJson);
+  console.log(`${RESULT_MARKER}${JSON.stringify(results)}`);
+  const errorCount = summarize(results);
+  process.exit(errorCount === 0 ? 0 : 1);
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  process.exit(1);
+});

data/lib/funicular/testing/node_runner.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "tempfile"
+
+module Funicular
+  module Testing
+    class NodeRunner
+      RESULT_MARKER = "__FUNICULAR_TEST_RESULTS_JSON__="
+
+      Result = Struct.new(:status, :stdout, :stderr, :picotest_results, keyword_init: true) do
+        def success?
+          status.success?
+        end
+
+        def output
+          [stdout, stderr].reject(&:empty?).join("\n")
+        end
+
+        def picotest_assertion_count
+          each_picotest_result.sum do |_name, result|
+            result.fetch("success_count", 0) +
+              Array(result["failures"]).size +
+              Array(result["exceptions"]).size +
+              Array(result["crashes"]).size
+          end
+        end
+
+        def picotest_test_count
+          picotest_assertion_count + picotest_skip_count
+        end
+
+        def picotest_failure_count
+          each_picotest_result.sum { |_name, result| Array(result["failures"]).size }
+        end
+
+        def picotest_exception_count
+          each_picotest_result.sum { |_name, result| Array(result["exceptions"]).size }
+        end
+
+        def picotest_crash_count
+          each_picotest_result.sum { |_name, result| Array(result["crashes"]).size }
+        end
+
+        def picotest_skip_count
+          each_picotest_result.sum { |_name, result| result.fetch("skipped_count", 0) }
+        end
+
+        def picotest_summary
+          "Funicular picotest: #{picotest_test_count} tests, " \
+            "#{picotest_assertion_count} assertions, " \
+            "#{picotest_failure_count} failures, " \
+            "#{picotest_exception_count} exceptions, " \
+            "#{picotest_crash_count} crashes, " \
+            "#{picotest_skip_count} skips"
+        end
+
+        private
+
+        def each_picotest_result
+          (picotest_results || {}).each
+        end
+      end
+
+      DEFAULT_TEST_GLOB = "test/funicular/client/**/*_picotest.rb"
+
+      attr_reader :app_root, :source_dir, :test_glob, :runtime_dir, :node, :timeout_ms
+
+      def initialize(app_root: nil, source_dir: nil, test_glob: DEFAULT_TEST_GLOB,
+                     runtime_dir: nil, node: nil, timeout_ms: 5000)
+        @app_root = File.expand_path(app_root || rails_root || Dir.pwd)
+        @source_dir = File.expand_path(source_dir || File.join(@app_root, "app", "funicular"))
+        @test_glob = test_glob
+        @runtime_dir = File.expand_path(runtime_dir || default_runtime_dir)
+        @node = node || ENV["NODE"] || "node"
+        @timeout_ms = timeout_ms
+      end
+
+      def run
+        manifest = build_manifest
+        with_manifest_file(manifest) do |path|
+          stdout, stderr, status = Open3.capture3(node, runner_js, path, chdir: app_root)
+          stdout = strip_ansi(stdout)
+          stderr = strip_ansi(stderr)
+          results, stdout = extract_picotest_results(stdout)
+          Result.new(status: status, stdout: stdout, stderr: stderr, picotest_results: results)
+        end
+      end
+
+      private
+
+      def strip_ansi(output)
+        output.gsub(/\e\[[0-9;]*m/, "")
+      end
+
+      def extract_picotest_results(output)
+        results = {}
+        lines = output.lines.reject do |line|
+          next false unless line.start_with?(RESULT_MARKER)
+
+          results = JSON.parse(line.delete_prefix(RESULT_MARKER))
+          true
+        rescue JSON::ParserError
+          false
+        end
+        [results, lines.join]
+      end
+
+      def rails_root
+        Rails.root.to_s if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+      end
+
+      def gem_root
+        File.expand_path("../../..", __dir__)
+      end
+
+      def default_runtime_dir
+        ENV["FUNICULAR_TEST_PICORUBY_DIR"] ||
+          existing_path(File.join(gem_root, "lib", "funicular", "vendor", "picoruby-test-node")) ||
+          existing_path(File.expand_path("../picoruby/build/picoruby-wasm-test/bin", gem_root)) ||
+          existing_path(File.expand_path("../../build/picoruby-wasm-test/bin", gem_root)) ||
+          File.join(gem_root, "lib", "funicular", "vendor", "picoruby-test-node")
+      end
+
+      def existing_path(path)
+        path if Dir.exist?(path)
+      end
+
+      def runner_js
+        File.expand_path("node_runner.mjs", __dir__)
+      end
+
+      def build_manifest
+        {
+          appRoot: app_root,
+          runtimeDir: runtime_dir,
+          timeoutMs: timeout_ms,
+          html: "<!doctype html><html><body><div id=\"app\"></div></body></html>",
+          url: "http://localhost/",
+          sourceFiles: source_files,
+          testFiles: test_files
+        }
+      end
+
+      def source_files
+        return [] unless Dir.exist?(source_dir)
+
+        files = if rails_app_source_dir? && defined?(Funicular::Compiler)
+                  Funicular::Compiler.source_files(source_dir)
+                else
+                  generic_source_files
+                end
+        app_files = files.reject { |path| File.basename(path) == "initializer.rb" || path.end_with?("_initializer.rb") }
+        plugin_source_files + app_files
+      end
+
+      def rails_app_source_dir?
+        source_dir == File.expand_path(File.join(app_root, "app", "funicular"))
+      end
+
+      def generic_source_files
+        nested = Dir.glob(File.join(source_dir, "*", "**", "*.rb")).sort
+        top_level = Dir.glob(File.join(source_dir, "*.rb")).sort
+        nested + top_level
+      end
+
+      def plugin_source_files
+        return [] unless defined?(Funicular::Plugin::Registry)
+
+        Funicular::Plugin::Registry.new(app_root).local_source_files
+      rescue Funicular::Plugin::Error
+        []
+      end
+
+      def test_files
+        Dir.glob(File.join(app_root, test_glob)).sort
+      end
+
+      def with_manifest_file(manifest)
+        file = Tempfile.new(["funicular-test-manifest", ".json"])
+        file.write(JSON.pretty_generate(manifest))
+        file.close
+        yield file.path
+      ensure
+        file&.unlink
+      end
+    end
+  end
+end

data/lib/funicular/testing.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "testing/node_runner"
+
+module Funicular
+  module Testing
+    def self.run!(**options)
+      NodeRunner.new(**options).run
+    end
+
+    def self.assert_picotests(test_case, result, print_summary: true)
+      puts result.picotest_summary if print_summary
+      test_case.assert result.success?, result.output
+
+      # The Minitest wrapper is one CRuby test method, but the actual client
+      # checks run inside PicoRuby. Reflect those inner checks in Minitest's
+      # assertion count so successful runs do not look like a single assertion.
+      extra_assertions = result.picotest_assertion_count - 1
+      test_case.assertions += extra_assertions if extra_assertions.positive?
+    end
+  end
+end