The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(run): load a Minitest reporter into Ruby test runs (#1547)
Jacob Kjeldahl9fb38769ada4
diff --git a/crates/ide-host/src/ops/run.rs b/crates/ide-host/src/ops/run.rsindex a71a8da5e..7409f0a32 100644--- a/crates/ide-host/src/ops/run.rs+++ b/crates/ide-host/src/ops/run.rs@@ -198,6 +198,7 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emitlet options = StartOptions {encoding: Some(encoding).filter(|e| !e.trim().is_empty()),python_paths: if *root != project.root { vec![root.clone()] } else { super::python::paths(&project) },+ ruby_reporter: ruby_reporter_dir(host, &config),};project.require_trust()?;let mut sink = project.sink.clone();@@ -214,6 +215,21 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emithost.processes.start(&project.root, &config, &options, sink, Box::new(move |c| on_output(c)))}+/// The Ruby test reporter's directory, installed on demand, for runs that take it.+fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathBuf> {+ if !ide_run::ruby_reporter::applies(config) {+ return None;+ }+ let dir = host.local_data_dir.join("ruby-reporter");+ match ide_run::ruby_reporter::install(&dir) {+ Ok(()) => Some(dir),+ Err(e) => {+ tracing::warn!("cannot install the Ruby test reporter in {}: {e}", dir.display());+ None+ }+ }+}+/// Stops a run (interrupt, then kill after Settings › Run's termination timeout).pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {let settings = match host.project(window) {diff --git a/crates/ide-run/src/lib.rs b/crates/ide-run/src/lib.rsindex 97e313423..4b2493041 100644--- a/crates/ide-run/src/lib.rs+++ b/crates/ide-run/src/lib.rs@@ -13,6 +13,7 @@ pub mod junit;mod process;pub mod python_path;pub mod ruby_preload;+pub mod ruby_reporter;pub mod tomcat;mod utf8;pub mod which;diff --git a/crates/ide-run/src/process.rs b/crates/ide-run/src/process.rsindex 2899c026a..9deb76d46 100644--- a/crates/ide-run/src/process.rs+++ b/crates/ide-run/src/process.rs@@ -80,6 +80,8 @@ pub struct StartOptions {pub encoding: Option<String>,/// Project content and source roots added to Python launch environments.pub python_paths: Vec<PathBuf>,+ /// Where the Ruby test reporter is installed (see [`crate::ruby_reporter`]); Ruby test runs load it.+ pub ruby_reporter: Option<PathBuf>,}#[derive(Default)]@@ -355,6 +357,10 @@ impl ProcessManager {if matches!(config.kind.as_str(), "python" | "pytest" | "django-test") {crate::python_path::extend(&mut env.vars, &options.python_paths, !env.clear)?;}+ if let Some(dir) = options.ruby_reporter.as_deref().filter(|_| crate::ruby_reporter::applies(config)) {+ crate::ruby_preload::add(&mut env.vars, dir, crate::ruby_reporter::FEATURE, !env.clear);+ env.vars.insert("OPENIDEA_TEST_REPORT".into(), "1".into());+ }let on_output: OutputFn = Arc::from(on_output);let on_output = match extras.output_file.as_deref() {Some(file) => tee_output(&resolve_cwd(root, Some(Path::new(file))), on_output)?,diff --git a/crates/ide-run/src/ruby_reporter.rs b/crates/ide-run/src/ruby_reporter.rsnew file mode 100644index 000000000..c689d4ddd--- /dev/null+++ b/crates/ide-run/src/ruby_reporter.rs@@ -0,0 +1,52 @@+//! A Minitest reporter the IDE loads into test runs (see `ruby_reporter/`): it prints one record per+//! test on stdout, which the IDE strips from the console and turns into the test tree. Tests then+//! report their real source file and line, and the output no longer needs `-v` to be parsed.+use crate::RunConfig;+use std::io;+use std::path::Path;++/// The Ruby file `RUBYOPT` loads first (`<dir>/openidea_test_hook.rb`).+pub const FEATURE: &str = "openidea_test_hook";++const FILES: [(&str, &str); 2] = [+ ("openidea_test_hook.rb", include_str!("ruby_reporter/openidea_test_hook.rb")),+ ("openidea/minitest_reporter.rb", include_str!("ruby_reporter/minitest_reporter.rb")),+];++/// Whether a run takes the reporter: Minitest-style test runs through `ruby` or `rake`, with their output+/// in the console (a terminal would show the records).+pub fn applies(config: &RunConfig) -> bool {+ config.is_test && matches!(config.kind.as_str(), "ruby" | "rake") && !config.extras.emulate_terminal+}++/// Writes the reporter files under `dir` (unchanged files stay).+pub fn install(dir: &Path) -> io::Result<()> {+ for (name, text) in FILES {+ let path = dir.join(name);+ if std::fs::read_to_string(&path).is_ok_and(|current| current == text) {+ continue;+ }+ if let Some(parent) = path.parent() {+ std::fs::create_dir_all(parent)?;+ }+ std::fs::write(&path, text)?;+ }+ Ok(())+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn installs_the_files_once_and_only_for_ruby_test_runs() {+ let tmp = tempfile::tempdir().unwrap();+ let dir = tmp.path().join("ruby reporter");+ install(&dir).unwrap();+ install(&dir).unwrap();+ for (name, text) in FILES {+ assert_eq!(std::fs::read_to_string(dir.join(name)).unwrap(), text);+ }+ assert!(FILES[0].1.contains("OPENIDEA_TEST_REPORT") && FILES[1].1.contains("@@OPENIDEA@@"));+ }+}diff --git a/crates/ide-run/src/ruby_reporter/minitest_reporter.rb b/crates/ide-run/src/ruby_reporter/minitest_reporter.rbnew file mode 100644index 000000000..a657ad4e9--- /dev/null+++ b/crates/ide-run/src/ruby_reporter/minitest_reporter.rb@@ -0,0 +1,78 @@+# Written by OpenIDEA for test runs; registered by `openidea_test_hook.rb` once Minitest is loaded.+# Nothing in the project is changed.+#+# One record per line on stdout, which the IDE strips from the console again:+# @@OPENIDEA@@{"t":"start","c":"MyTest","n":"test_x","f":"/abs/test.rb","l":12}+# @@OPENIDEA@@{"t":"result","c":"MyTest","n":"test_x","s":"passed","d":0.001,"f":...,"l":...,"m":"failure text"}+# @@OPENIDEA@@{"t":"summary","runs":7,"failures":1,"errors":1,"skips":1,"d":0.4}+require "json"++module Minitest+ class OpenIdeaReporter < AbstractReporter+ MARK = "@@OPENIDEA@@"++ def initialize(io)+ super()+ @io = io+ @cwd = Dir.pwd+ @lock = Mutex.new+ @runs = @failures = @errors = @skips = 0+ @started = nil+ end++ def start+ @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)+ end++ def prerecord(klass, name)+ emit(t: "start", c: klass.to_s, n: name.to_s, **where(klass, name))+ end++ def record(result)+ @runs += 1+ status = result.skipped? ? "skipped" : result.passed? ? "passed" : "failed"+ @skips += 1 if status == "skipped"+ if status == "failed"+ result.failures.any? { |f| f.is_a?(UnexpectedError) } ? @errors += 1 : @failures += 1+ end+ loc = result.source_location+ emit(t: "result", c: result.klass.to_s, n: result.name.to_s, s: status, d: result.time,+ f: loc && absolute(loc[0]), l: loc && loc[1], m: result.failures.map(&:message).join("\n"))+ end++ def report+ d = @started ? Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started : nil+ emit(t: "summary", runs: @runs, failures: @failures, errors: @errors, skips: @skips, d: d)+ end++ private++ # Where the test is defined, known before it runs (so the tree can show it while running).+ def where(klass, name)+ f, l = klass.instance_method(name).source_location+ { f: absolute(f), l: l }+ rescue StandardError+ {}+ end++ # Test files are often loaded by a path relative to the working directory.+ def absolute(file)+ File.expand_path(file, @cwd)+ end++ def emit(record)+ line = "#{MARK}#{JSON.generate(record)}\n"+ @lock.synchronize { @io.write(line) }+ rescue StandardError+ nil # reporting must never fail a test run+ end+ end++ def self.plugin_openidea_init(options)+ return unless ENV["OPENIDEA_TEST_REPORT"]++ io = options[:io] || $stdout+ io.sync = true if io.respond_to?(:sync=)+ reporter << OpenIdeaReporter.new(io)+ end+enddiff --git a/crates/ide-run/src/ruby_reporter/openidea_test_hook.rb b/crates/ide-run/src/ruby_reporter/openidea_test_hook.rbnew file mode 100644index 000000000..57a72084e--- /dev/null+++ b/crates/ide-run/src/ruby_reporter/openidea_test_hook.rb@@ -0,0 +1,32 @@+# Written by OpenIDEA for test runs. Loaded first in every Ruby the run starts+# (RUBYLIB=<this directory>, RUBYOPT=-ropenidea_test_hook).+#+# Registers the test reporter once a test framework is loaded. Minitest 5 would find a plugin on+# its own, Minitest 6 does not load plugins any more, so both are registered the same way.+if ENV["OPENIDEA_TEST_REPORT"]+ module OpenIdeaTestHook+ @registered = false++ def self.register+ return if @registered+ return unless defined?(::Minitest) && ::Minitest.respond_to?(:extensions) && defined?(::Minitest::AbstractReporter)++ @registered = true+ require "openidea/minitest_reporter"+ ::Minitest.extensions << "openidea" unless ::Minitest.extensions.include?("openidea")+ rescue StandardError, LoadError+ nil # reporting must never break a test run+ end++ # `require "minitest/autorun"` loads Minitest through require_relative, so look after every require.+ module Watch+ def require(path)+ result = super+ OpenIdeaTestHook.register+ result+ end+ end+ end++ Kernel.prepend(OpenIdeaTestHook::Watch)+enddiff --git a/crates/ide-run/tests/process.rs b/crates/ide-run/tests/process.rsindex 176be79c9..cbb2ba914 100644--- a/crates/ide-run/tests/process.rs+++ b/crates/ide-run/tests/process.rs@@ -479,6 +479,36 @@ fn python_scripts_import_sibling_packages_and_preserve_env_file_paths() {}}+#[test]+fn ruby_test_runs_load_the_reporter_and_other_runs_do_not() {+ let reporter = std::env::temp_dir().join("ruby reporter");+ let run = |kind: &str, is_test: bool| {+ let h = harness();+ let mut config =+ cfg("ruby-env", "/bin/sh", &["-c", r#"echo "lib=$RUBYLIB opt=$RUBYOPT report=$OPENIDEA_TEST_REPORT""#]);+ config.kind = kind.into();+ config.is_test = is_test;+ let options = StartOptions { ruby_reporter: Some(reporter.clone()), ..Default::default() };+ let chunks: Chunks = Arc::default();+ let sink = chunks.clone();+ let info =+ h.pm.start(h.root.path(), &config, &options, h.sink.clone(), Box::new(move |c| sink.lock().push(c)))+ .unwrap();+ assert_eq!(wait_exit(&h, info.id, Duration::from_secs(10)), Some(0));+ text(&chunks, stdout)+ };+ for kind in ["ruby", "rake"] {+ let out = run(kind, true);+ // The directory has a space: it is on RUBYLIB and only the bare feature name is in RUBYOPT.+ assert!(out.contains(&format!("lib={}", reporter.display())), "{out}");+ assert!(out.contains("-ropenidea_test_hook") && !out.contains(&format!("-r{}", reporter.display())), "{out}");+ assert!(out.contains("report=1"), "{out}");+ }+ for (kind, is_test) in [("ruby", false), ("rspec", true), ("pytest", true)] {+ assert!(run(kind, is_test).contains("report=\n"), "{kind} {is_test}");+ }+}+#[test]fn revoking_one_project_stops_only_its_runs() {let h = harness();diff --git a/src/features/run/store.ts b/src/features/run/store.tsindex 6c542050c..5ed72249f 100644--- a/src/features/run/store.ts+++ b/src/features/run/store.ts@@ -43,6 +43,7 @@ import {} from "./testing";import { GoTestOutput } from "./testing/go";import { moveToReportedClasses } from "./testing/jvm";+import { RubyTestOutput } from "./testing/ruby";import { TeamcityOutput } from "./testing/teamcity";import type { TestStdout } from "./testing/types";import { recordTestStates } from "./testing/states";@@ -87,7 +88,7 @@ interface SessionRuntime {console: ConsoleModel;tests: TestResults | null;parser: TestOutputParser | null;- /** Machine-readable stdout (`go test -json`, `--teamcity`): fed to the parser, shown decoded. */+ /** Machine-readable stdout (`go test -json`, `--teamcity`, the Ruby reporter): fed to the parser, shown decoded. */stdout: TestStdout | null;queue: OutputChunk[];/** rAF id while the page is visible, timeout id while hidden (rAF pauses in background tabs). */@@ -567,13 +568,16 @@ function newRuntime(config: RunConfig): SessionRuntime {if (tests && parser) tests.apply(parser.feed(line));};const framework = tests && parser ? frameworkFor(config) : null;- // PHPUnit `--teamcity` and Gradle's test init script report through service messages.+ // PHPUnit `--teamcity` and Gradle's test init script report through service messages, Minitest through+ // the IDE's own reporter (RSpec has none: its progress dots must show as they come).const stdout =framework === "go"? new GoTestOutput(feed): framework === "phpunit" || framework === "jvm"? new TeamcityOutput(feed)- : null;+ : framework === "ruby" && config.kind !== "rspec"+ ? new RubyTestOutput(feed)+ : null;const runtime: SessionRuntime = {stdout,tests,diff --git a/src/features/run/testing/results.ts b/src/features/run/testing/results.tsindex e0c75aca7..9b67583f9 100644--- a/src/features/run/testing/results.ts+++ b/src/features/run/testing/results.ts@@ -128,7 +128,9 @@ export class TestResults {}case "location": {const n = this.node(e.path);- n.location ??= e.location;+ // The first location wins, except that a place to search for (Ruby tests) gives way to a real one.+ if (!n.location || (n.location.resolve === "rubyTest" && e.location.resolve !== "rubyTest"))+ n.location = e.location;break;}case "output": {diff --git a/src/features/run/testing/ruby.test.ts b/src/features/run/testing/ruby.test.tsindex 769ce3f27..1139bc54d 100644--- a/src/features/run/testing/ruby.test.ts+++ b/src/features/run/testing/ruby.test.ts@@ -1,7 +1,7 @@import { describe, expect, it } from "vitest";import { parseAll, withTestReporting, frameworkFor } from "./index";import { TestResults, nodeStatus } from "./results";-import { rubyParser } from "./ruby";+import { RubyTestOutput, rubyParser } from "./ruby";// Captured from `ruby -Ilib test/mixed_test.rb -v --seed 1` (Minitest 6.0.6).const MINITEST = `Run options: -v --seed 1@@ -125,3 +125,98 @@ describe("Ruby test reporting", () => {expect(frameworkFor(cfg("rake", "bundle", ["exec", "rake", "test"]))).toBe("ruby");});});++// Captured from a run with the IDE's reporter (Minitest 6.0.6): records end with their own newline, so the+// progress dots stay on one line once they are taken out.+const M = "@@OPENIDEA@@";+const F = "/p/test/mixed_test.rb";+const REPORTER_STREAM = [+ "# Running:",+ "",+ `${M}{"t":"start","c":"MixedTest","n":"test_pass","f":"${F}","l":4}`,+ `.${M}{"t":"result","c":"MixedTest","n":"test_pass","s":"passed","d":0.000063,"f":"${F}","l":4,"m":""}`,+ `${M}{"t":"start","c":"MixedTest","n":"test_fail","f":"${F}","l":5}`,+ `F${M}{"t":"result","c":"MixedTest","n":"test_fail","s":"failed","d":0.000054,"f":"${F}","l":5,"m":"Expected: 4\\n Actual: 3"}`,+ `${M}{"t":"start","c":"MixedTest","n":"test_prints","f":"${F}","l":8}`,+ "hello from test",+ `.${M}{"t":"result","c":"MixedTest","n":"test_prints","s":"passed","d":0.000007,"f":"${F}","l":8,"m":""}`,+ `${M}{"t":"start","c":"MixedTest","n":"test_skip","f":"${F}","l":7}`,+ `S${M}{"t":"result","c":"MixedTest","n":"test_skip","s":"skipped","d":0.000006,"f":"${F}","l":7,"m":"later"}`,+ "",+ `${M}{"t":"summary","runs":4,"failures":1,"errors":0,"skips":1,"d":0.0011}`,+ "Finished in 0.001124s",+ "",+].join("\n");++describe("the IDE's Minitest reporter", () => {+ const collect = (chunks: string[]) => {+ const lines: string[] = [];+ const out = new RubyTestOutput((line) => lines.push(line));+ const text = chunks.map((c) => out.feed(c)).join("") + out.end();+ return { text, records: lines.filter((l) => l.includes(M)), lines };+ };++ it("takes the records out of the console, exactly as Minitest prints them without it", () => {+ const { text, records } = collect([REPORTER_STREAM]);+ expect(text).toBe("# Running:\n\n.Fhello from test\n.S\nFinished in 0.001124s\n");+ expect(records).toHaveLength(9);+ expect(records.every((r) => r.includes(M))).toBe(true);+ });++ it("is the same however the output is cut into chunks", () => {+ const whole = collect([REPORTER_STREAM]);+ const chars = collect(REPORTER_STREAM.split(""));+ const odd = collect(REPORTER_STREAM.match(/[\s\S]{1,7}/g)!);+ expect(chars).toEqual(whole);+ expect(odd).toEqual(whole);+ });++ it("drops a record cut off by the end of the process, not the text before it", () => {+ expect(collect([`abc${M}{"t":"sta`]).text).toBe("abc");+ expect(collect(["no marker @@OPEN"]).text).toBe("no marker @@OPEN\n");+ });++ describe("results", () => {+ const parser = rubyParser();+ const results = new TestResults();+ for (const l of collect([REPORTER_STREAM]).lines) results.apply(parser.feed(l));+ // The console's own text arrives too: the same results, printed.+ for (const l of ["MixedTest#test_pass = 0.00 s = .", "1 runs, 1 assertions, 0 failures, 0 errors, 0 skips"])+ results.apply(parser.feed(l));+ const node = (name: string) => results.get(["MixedTest", name].join("\u0000"))!;++ it("builds the tree with statuses, times and failure text", () => {+ expect(nodeStatus(node("test_pass"))).toBe("passed");+ expect(nodeStatus(node("test_fail"))).toBe("failed");+ expect(nodeStatus(node("test_skip"))).toBe("skipped");+ expect(node("test_fail").output).toEqual(["Expected: 4", " Actual: 3"]);+ expect(node("test_pass").durationMs).toBeCloseTo(0.063, 3);+ });++ it("gives every test its real file and line, passed or not", () => {+ for (const [name, line] of [+ ["test_pass", 4],+ ["test_fail", 5],+ ["test_prints", 8],+ ["test_skip", 7],+ ] as const)+ expect(node(name).location).toEqual({ path: F, line, resolve: "path" });+ });++ it("summarises from the reporter, and ignores the repeated text", () => {+ expect(results.summary).toMatchObject({ passed: 2, failed: 1, skipped: 1 });+ expect(results.get("MixedTest")!.children).toHaveLength(4);+ });+ });++ it("a real location replaces the place to search for", () => {+ const results = new TestResults();+ results.apply(parseAll(rubyParser(), "MixedTest#test_pass = 0.00 s = ."));+ const id = ["MixedTest", "test_pass"].join("\u0000");+ expect(results.get(id)!.location?.resolve).toBe("rubyTest");+ results.apply([+ { type: "location", path: ["MixedTest", "test_pass"], location: { path: F, line: 4, resolve: "path" } },+ ]);+ expect(results.get(id)!.location).toEqual({ path: F, line: 4, resolve: "path" });+ });+});diff --git a/src/features/run/testing/ruby.ts b/src/features/run/testing/ruby.tsindex a73fe6cbf..bc7d49ce2 100644--- a/src/features/run/testing/ruby.ts+++ b/src/features/run/testing/ruby.ts@@ -15,7 +15,7 @@* 7 runs, 5 assertions, 1 failures, 1 errors, 1 skips* ```*/-import { parseDuration, type TestEvent, type TestOutputParser, type TestStatus } from "./types";+import { parseDuration, TestStdout, type TestEvent, type TestOutputParser, type TestStatus } from "./types";// A class may be a spec description with spaces (`Spec style#test_0001_works`).const RESULT_RE = /^(.+?)#(\S+) = ([\d.]+ s) = ([.FES])$/;@@ -44,7 +44,81 @@ const located = (path: string[]): TestEvent => ({location: { path: path[1]!, className: path[0], resolve: "rubyTest" },});+/** Starts a record of the IDE's own Minitest reporter (`ide-run/src/ruby_reporter`); a JSON object follows. */+export const RECORD_MARK = "@@OPENIDEA@@";++interface ReporterRecord {+ t: "start" | "result" | "summary";+ c?: string;+ n?: string;+ s?: "passed" | "failed" | "skipped";+ /** Seconds. */+ d?: number | null;+ f?: string | null;+ l?: number | null;+ m?: string;+ runs?: number;+ failures?: number;+ errors?: number;+ skips?: number;+}++/** What a reporter record says: the test's real file and line, its status, time and failure text. */+function fromRecord(json: string): TestEvent[] {+ let r: ReporterRecord;+ try {+ r = JSON.parse(json) as ReporterRecord;+ } catch {+ return [];+ }+ if (r.t === "summary") {+ const failed = (r.failures ?? 0) + (r.errors ?? 0);+ const skipped = r.skips ?? 0;+ return [+ {+ type: "summary",+ passed: Math.max(0, (r.runs ?? 0) - failed - skipped),+ failed,+ skipped,+ durationMs: typeof r.d === "number" ? Math.round(r.d * 1000 * 1000) / 1000 : undefined,+ },+ ];+ }+ if (!r.c || !r.n) return [];+ const path = [r.c, r.n];+ const events: TestEvent[] = [];+ if (r.t === "start") events.push({ type: "start", path });+ if (r.t === "result" && r.s) {+ events.push({+ type: "result",+ path,+ status: r.s,+ durationMs: typeof r.d === "number" ? Math.round(r.d * 1000 * 1000) / 1000 : undefined,+ });+ for (const line of (r.m ?? "").split("\n")) if (line) events.push({ type: "output", path, line });+ }+ if (r.f && r.l) {+ events.push({ type: "location", path, location: { path: r.f, line: r.l, resolve: "path" } });+ }+ return events;+}++/**+ * The console side of the reporter: a record ends with its own newline, so what the line holds before the+ * marker (a progress dot) is all the console shows of it.+ */+export class RubyTestOutput extends TestStdout {+ constructor(feedLine: (line: string) => void) {+ super(feedLine, (line) => {+ const at = line.indexOf(RECORD_MARK);+ return at < 0 ? line + "\n" : line.slice(0, at);+ });+ }+}+export function rubyParser(): TestOutputParser {+ /** The reporter's records are the source of results; the text is then ignored (it would repeat them). */+ let records = false;const seen = new Set<string>();/** The test's own location, once. */const locate = (path: string[]): TestEvent[] => {@@ -60,6 +134,12 @@ export function rubyParser(): TestOutputParser {return {feed(line) {+ const mark = line.indexOf(RECORD_MARK);+ if (mark >= 0) {+ records = true;+ return fromRecord(line.slice(mark + RECORD_MARK.length));+ }+ if (records) return [];const events: TestEvent[] = [];let m: RegExpExecArray | null;