Improve test reliability.

Author: ioquatix

fixtures/process/metrics/a_stable_process.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "json"
+
+module Process
+	module Metrics
+		class StableChild
+			def initialize
+				@io = IO.popen(["ruby", File.expand_path("stable_child.rb", __dir__)], "r+")
+				@children = []
+			end
+			
+			def process_id
+				@io.pid
+			end
+			
+			def children
+				@children.dup
+			end
+			
+			def close
+				if io = @io
+					@io = nil
+					io.close
+				end
+			end
+			
+			def write_message(**message)
+				@io.puts(JSON.dump(message))
+			end
+			
+			def read_message
+				if line = @io.gets
+					return JSON.parse(line, symbolize_names: true)
+				end
+			end
+			
+			def wait_for_message(action)
+				while message = read_message
+					if message[:action] == action
+						# Track forked children
+						if action == "forked" && message[:child_pid]
+							@children << message[:child_pid]
+						end
+						
+						return message
+					end
+				end
+			end
+		end
+		
+		AStableProcess = Sus::Shared("a stable process") do
+			around do |&block|
+				begin
+					@child = StableChild.new
+					@pid = @child.process_id
+					
+					# Wait for child to be ready
+					@child.wait_for_message("ready")
+					
+					super(&block)
+				ensure
+					@child&.close
+					@child = nil
+					@pid = nil
+				end
+			end
+		end
+	end
+end

fixtures/process/metrics/stable_child.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "securerandom"
+require "json"
+
+def read_message
+	if line = $stdin.gets
+		return JSON.parse(line, symbolize_names: true)
+	end
+end
+
+def write_message(**message)
+	$stdout.puts(JSON.dump(message))
+	$stdout.flush
+end
+
+begin
+	write_message(action: "ready")
+	
+	allocations = []
+	children = []
+	
+	while message = read_message
+		case message[:action]
+		when "allocate"
+			allocations << SecureRandom.bytes(message[:size])
+			write_message(action: "allocated", size: message[:size])
+		when "free"
+			allocations.pop
+			write_message(action: "freed")
+		when "clear"
+			allocations.clear
+			write_message(action: "cleared")
+		when "fork"
+			# Fork a child process in its own process group
+			child_pid = fork do
+				# Create a new process group for this child
+				Process.setpgid(0, 0)
+				
+				# Sleep forever - will be terminated by signal
+				sleep
+			end
+			
+			children << child_pid
+			write_message(action: "forked", child_pid: child_pid, children_count: children.size)
+		when "stabilize"
+			# Give the OS a moment to settle any page allocations
+			sleep 0.1
+			write_message(action: "stabilized")
+		when "exit"
+			break
+		end
+	end
+rescue Interrupt
+	# Ignore - normal exit.
+ensure
+	# Clean up any child processes using their process groups
+	children.each do |child_pid|
+		begin
+			# Kill the process group (negative PID)
+			Process.kill(:TERM, -child_pid)
+			Process.wait(child_pid)
+		rescue Errno::ESRCH, Errno::ECHILD
+			# Child already exited
+		end
+	end
+end

test/process/general/linux.rb

@@ -6,9 +6,12 @@
 require "process/metrics"
 # Load ProcessStatus backend so we can compare General (Linux) vs General::ProcessStatus.
 require "process/metrics/general/process_status"
+require_relative "../../../fixtures/process/metrics/a_stable_process"
 
 describe Process::Metrics::General do
 	with "Linux backend matches ProcessStatus backend" do
+		include_context Process::Metrics::AStableProcess
+		
 		def assert_backends_match(linux_capture, process_status_capture)
 			expect(linux_capture.keys.sort).to be == process_status_capture.keys.sort
 
@@ -22,6 +25,7 @@ def assert_backends_match(linux_capture, process_status_capture)
 				expect(linux_process.process_group_id).to be == process_status_process.process_group_id
 
 				# VSZ and RSS differ because ps excludes device mappings while /proc/stat includes them.
+				# With a stable controlled process, RSS should be more consistent between measurements.
 				expect(linux_process.virtual_size).to be_within(10.0).percent_of(process_status_process.virtual_size)
 				expect(linux_process.resident_size).to be_within(10.0).percent_of(process_status_process.resident_size)
 
@@ -34,24 +38,67 @@ def assert_backends_match(linux_capture, process_status_capture)
 		it "single pid capture matches" do
 			skip "Linux with ProcessStatus required" unless RUBY_PLATFORM.include?("linux") && Process::Metrics::General::ProcessStatus.supported?
 
-			pid = Process.pid
-			linux_capture = Process::Metrics::General.capture(pid: pid, memory: false)
-			process_status_capture = Process::Metrics::General::ProcessStatus.capture(pid: pid, memory: false)
+			# Stabilize the child process before taking measurements
+			@child.write_message(action: "stabilize")
+			@child.wait_for_message("stabilized")
+			
+			linux_capture = Process::Metrics::General.capture(pid: @pid, memory: false)
+			process_status_capture = Process::Metrics::General::ProcessStatus.capture(pid: @pid, memory: false)
 			assert_backends_match(linux_capture, process_status_capture)
 		end
 
 		it "pid and ppid capture matches" do
 			skip "Linux with ProcessStatus required" unless RUBY_PLATFORM.include?("linux") && Process::Metrics::General::ProcessStatus.supported?
 
-			child_pid = Process.spawn("sleep 10")
-			begin
-				linux_capture = Process::Metrics::General.capture(pid: child_pid, ppid: child_pid, memory: false)
-				process_status_capture = Process::Metrics::General::ProcessStatus.capture(pid: child_pid, ppid: child_pid, memory: false)
-				assert_backends_match(linux_capture, process_status_capture)
-			ensure
-				Process.kill(:TERM, child_pid)
-				Process.wait(child_pid)
+			# Stabilize the child process before taking measurements
+			@child.write_message(action: "stabilize")
+			@child.wait_for_message("stabilized")
+			
+			linux_capture = Process::Metrics::General.capture(pid: @pid, ppid: @pid, memory: false)
+			process_status_capture = Process::Metrics::General::ProcessStatus.capture(pid: @pid, ppid: @pid, memory: false)
+			assert_backends_match(linux_capture, process_status_capture)
+		end
+		
+		it "captures child processes by ppid" do
+			skip "Linux with ProcessStatus required" unless RUBY_PLATFORM.include?("linux") && Process::Metrics::General::ProcessStatus.supported?
+			
+			# Fork 2 child processes
+			@child.write_message(action: "fork")
+			response1 = @child.wait_for_message("forked")
+			
+			@child.write_message(action: "fork")
+			response2 = @child.wait_for_message("forked")
+			
+			child_pids = [response1[:child_pid], response2[:child_pid]]
+			
+			# Stabilize before measuring
+			@child.write_message(action: "stabilize")
+			@child.wait_for_message("stabilized")
+			
+			# Capture using ppid - should get parent + both children
+			linux_capture = Process::Metrics::General.capture(ppid: @pid, memory: false)
+			process_status_capture = Process::Metrics::General::ProcessStatus.capture(ppid: @pid, memory: false)
+			
+			# Should have captured 3 processes: parent + 2 children
+			expect(linux_capture.size).to be == 3
+			expect(process_status_capture.size).to be == 3
+			
+			# Verify parent is included
+			expect(linux_capture.keys).to be(:include?, @pid)
+			expect(process_status_capture.keys).to be(:include?, @pid)
+			
+			# Verify both children are included
+			child_pids.each do |child_pid|
+				expect(linux_capture.keys).to be(:include?, child_pid)
+				expect(process_status_capture.keys).to be(:include?, child_pid)
+				
+				# Verify parent-child relationship
+				expect(linux_capture[child_pid].parent_process_id).to be == @pid
+				expect(process_status_capture[child_pid].parent_process_id).to be == @pid
 			end
+			
+			# Compare all processes
+			assert_backends_match(linux_capture, process_status_capture)
 		end
 	end
 end