test: cover host probes without a live host

The coverage gate failed on GitHub with 99.63 percent. Four files covered
less than 100 percent: docker_report, host_metrics, host_stats and
cgroup_reader.

These lines had no test of their own. The suite ran them by accident on
the development Mac. A Docker daemon runs there, so the support bundle
got a real snapshot and rendered the container and network tables. The
macOS readers sysctl, vm_stat and sw_vers also answer there. The GitHub
runner has no Docker daemon in the fast job and runs Linux, so these
lines never ran.

Add stubbed examples for each of these paths. They give the same result
on Linux and on macOS.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ledermann

spec/services/host_stats_spec.rb

@@ -182,13 +182,52 @@ def write_proc_file(name, content)
     end
   end
 
-  # macOS dev fallback: no /proc at all, so the numbers come from sysctl.
+  # macOS dev fallback: no /proc at all, so the numbers come from sysctl and
+  # vm_stat. Both are stubbed, so the examples also run on Linux CI, where
+  # these commands exist but answer nothing.
   describe 'the sysctl fallback' do
     it 'reports nothing when sysctl cannot be run' do
       allow(described_class).to receive(:capture_int).and_raise(Errno::ENOENT, 'sysctl')
 
       expect(described_class.send(:mem_from_sysctl)).to be_nil
     end
+
+    it 'reports total RAM from sysctl and available RAM from the vm_stat pages' do
+      page_size = Etc.sysconf(Etc::SC_PAGE_SIZE)
+      stub_sysctl(total: '8589934592')
+      stub_vm_stat(<<~VM_STAT)
+        Mach Virtual Memory Statistics: (page size of #{page_size} bytes)
+        Pages free:                               10000.
+        Pages inactive:                           20000.
+        Pages speculative:                         5000.
+      VM_STAT
+
+      expect(described_class.send(:mem_from_sysctl)).to eq([8_589_934_592, 35_000 * page_size])
+    end
+
+    it 'reports nothing when sysctl answers no memory size' do
+      stub_sysctl(total: 'unknown')
+
+      expect(described_class.send(:mem_from_sysctl)).to be_nil
+    end
+
+    it 'reports nothing when vm_stat fails' do
+      stub_sysctl(total: '8589934592')
+      stub_vm_stat('vm_stat: command not found', success: false)
+
+      expect(described_class.send(:mem_from_sysctl)).to be_nil
+    end
+
+    def stub_sysctl(total:)
+      allow(Open3).to receive(:capture2e).and_call_original
+      allow(Open3).to receive(:capture2e).with('sysctl', '-n', 'hw.memsize')
+                                         .and_return([total, instance_double(Process::Status, success?: true)])
+    end
+
+    def stub_vm_stat(output, success: true)
+      allow(Open3).to receive(:capture2e).with('vm_stat')
+                                         .and_return([output, instance_double(Process::Status, success?: success)])
+    end
   end
 
   describe '.proc_root' do

spec/services/support_bundle/system_info/cgroup_reader_spec.rb

@@ -70,6 +70,46 @@
     end
   end
 
+  describe '.v2?' do
+    it 'is true when the unified hierarchy exposes cgroup.controllers' do
+      stub_host_file('/sys/fs/cgroup/cgroup.controllers')
+
+      expect(described_class).to be_v2
+      expect(described_class.source).to eq('cgroup v2 (container limit)')
+    end
+
+    it 'is false without it, so the v1 paths are used' do
+      stub_missing_host_file('/sys/fs/cgroup/cgroup.controllers')
+
+      expect(described_class).not_to be_v2
+      expect(described_class.source).to eq('cgroup v1 (container limit)')
+    end
+  end
+
+  describe '.cpu_quota_cores' do
+    it 'divides quota by period on cgroup v2' do
+      stub_cgroup(v2: true, '/sys/fs/cgroup/cpu.max' => '150000 100000')
+
+      expect(described_class.cpu_quota_cores).to eq(1.5)
+    end
+
+    it 'reads the two CFS files on cgroup v1' do
+      stub_cgroup(
+        v2: false,
+        '/sys/fs/cgroup/cpu/cpu.cfs_quota_us' => '200000',
+        '/sys/fs/cgroup/cpu/cpu.cfs_period_us' => '100000',
+      )
+
+      expect(described_class.cpu_quota_cores).to eq(2.0)
+    end
+
+    it 'is nil when cgroup v2 reports no quota' do
+      stub_cgroup(v2: true, '/sys/fs/cgroup/cpu.max' => 'max 100000')
+
+      expect(described_class.cpu_quota_cores).to be_nil
+    end
+  end
+
   describe '.cpuset_cores' do
     context 'when the cpuset covers every host CPU' do
       before do

spec/services/support_bundle/system_info/docker_report_spec.rb

@@ -23,6 +23,111 @@
     end
   end
 
+  describe '.engine' do
+    it 'reports version, API version, platform and storage driver' do
+      snapshot = {
+        version: { 'Version' => '27.0.3', 'ApiVersion' => '1.46', 'Os' => 'linux', 'Arch' => 'arm64' },
+        info: { 'Driver' => 'overlay2' },
+      }
+
+      expect(described_class.engine(snapshot)).to eq(
+        'Version' => '27.0.3',
+        'API version' => '1.46',
+        'OS/Arch' => 'linux/arm64',
+        'Storage driver' => 'overlay2',
+      )
+    end
+
+    it 'shows the snapshot error as the status' do
+      expect(described_class.engine(error: 'unavailable: boom')).to eq('Status' => 'unavailable: boom')
+    end
+  end
+
+  describe '.compose' do
+    it 'reports the version of the compose plugin' do
+      allow(SupportBundle::SystemInfo::OutputFormatter)
+        .to receive(:capture).with('docker', 'compose', 'version', '--short').and_return('2.32.4')
+
+      expect(described_class.compose).to eq('Version' => '2.32.4')
+    end
+  end
+
+  describe '.containers' do
+    it 'passes the snapshot error through' do
+      expect(described_class.containers(error: 'unavailable: boom')).to eq('unavailable: boom')
+    end
+
+    it 'reports an empty daemon instead of an empty table' do
+      expect(described_class.containers(containers: [])).to eq('No containers found.')
+    end
+
+    it 'counts the containers and lists the running ones first' do
+      snapshot = {
+        containers: [
+          fake_container('influxdb', { 'solectrus_default' => {} },
+                         state: 'exited', status: 'Exited (0) 2 hours ago', image: 'influxdb:2.7'),
+          fake_container('helios', { 'default' => {}, 'solectrus_default' => {} },
+                         state: 'running', status: 'Up 3 minutes', image: 'ghcr.io/solectrus/helios'),
+        ],
+      }
+
+      result = described_class.containers(snapshot)
+      rows = result.lines.map(&:strip)
+
+      expect(rows.first).to eq('2 total (running: 1, stopped: 1)')
+      expect(rows[3]).to start_with('helios')
+      expect(rows[3]).to include('running', 'Up 3 minutes', 'default,solectrus_default')
+      expect(rows[4]).to start_with('influxdb')
+      expect(rows[4]).to include('exited', 'influxdb:2.7')
+    end
+
+    # A container started outside compose may carry no name; the short id is
+    # the only handle support has on it, and it has no network of its own.
+    it 'falls back to the short id and a dash for a nameless container' do
+      nameless = instance_double(
+        Docker::Container,
+        info: { 'Id' => 'ab12cd34ef567890', 'State' => 'running', 'Status' => 'Up 1 second', 'Image' => 'busybox' },
+      )
+
+      result = described_class.containers(containers: [nameless])
+
+      expect(result).to include('ab12cd34ef56')
+      expect(result.lines.last).to match(/busybox\s+-/)
+    end
+  end
+
+  describe '.networks' do
+    it 'passes the snapshot error through' do
+      expect(described_class.networks(error: 'unavailable: boom')).to eq('unavailable: boom')
+    end
+
+    it 'reports nothing to show when the daemon has no containers' do
+      expect(described_class.networks(containers: [])).to eq('No networks found.')
+    end
+
+    it 'reports nothing to show when no container is attached to a network' do
+      bare = instance_double(Docker::Container, info: { 'Names' => ['/orphan'] })
+
+      expect(described_class.networks(containers: [bare])).to eq('No networks found.')
+    end
+
+    it 'lists each network with its member count and names' do
+      snapshot = {
+        containers: [
+          fake_container('influxdb', { 'solectrus_default' => {} }),
+          fake_container('dashboard', { 'solectrus_default' => {} }),
+          fake_container('helios', { 'default' => {} }),
+        ],
+      }
+
+      rows = described_class.networks(snapshot).lines.map(&:strip)
+
+      expect(rows.first).to match(/NAME\s+CONTAINERS\s+NAMES/)
+      expect(rows[1]).to match(/\Adefault\s+1\s+helios\z/)
+      expect(rows[2]).to match(/\Asolectrus_default\s+2\s+dashboard, influxdb\z/)
+    end
+  end
+
   describe '.network_membership' do
     it 'groups containers by attached network' do
       containers = [
@@ -51,12 +156,18 @@
 
       expect(described_class.network_membership([bare])).to eq({})
     end
+  end
 
-    def fake_container(name, networks)
-      instance_double(
-        Docker::Container,
-        info: { 'Names' => ["/#{name}"], 'NetworkSettings' => { 'Networks' => networks } },
-      )
-    end
+  def fake_container(name, networks, state: 'running', status: 'Up 1 minute', image: 'alpine')
+    instance_double(
+      Docker::Container,
+      info: {
+        'Names' => ["/#{name}"],
+        'State' => state,
+        'Status' => status,
+        'Image' => image,
+        'NetworkSettings' => { 'Networks' => networks },
+      },
+    )
   end
 end

spec/services/support_bundle/system_info/host_metrics_spec.rb

@@ -408,10 +408,133 @@
     end
   end
 
+  # macOS dev boxes have no /proc and no cgroup filesystem; every value comes
+  # from sysctl and vm_stat there. The stubs keep these examples deterministic
+  # on Linux CI, where those binaries answer nothing useful.
+  describe 'the macOS fallbacks' do
+    before do
+      stub_missing_host_file('/usr/sbin/sysctl')
+      stub_host_file('/sbin/sysctl')
+    end
+
+    it 'reads model and core count from sysctl' do
+      stub_capture(%w[sysctl -n machdep.cpu.brand_string hw.ncpu], "Apple M4 Pro\n14")
+
+      expect(described_class.cpu_from_sysctl).to eq('Model' => 'Apple M4 Pro', 'Cores' => '14')
+    end
+
+    it 'falls back to "unknown" when sysctl answers nothing' do
+      stub_capture(%w[sysctl -n machdep.cpu.brand_string hw.ncpu], '')
+
+      expect(described_class.cpu_from_sysctl).to eq('Model' => 'unknown', 'Cores' => 'unknown')
+    end
+
+    it 'reports total RAM from sysctl and available RAM from vm_stat' do
+      stub_capture(%w[sysctl -n hw.memsize hw.pagesize], "2147483648\n16384")
+      stub_capture(['vm_stat'], <<~VM_STAT)
+        Mach Virtual Memory Statistics: (page size of 16384 bytes)
+        Pages free:                               10000.
+        Pages inactive:                           20000.
+        Pages speculative:                         2536.
+      VM_STAT
+
+      expect(described_class.memory_from_sysctl).to eq('Total' => '2 GB', 'Available' => '508 MB')
+    end
+
+    it 'reports unknown available RAM when sysctl gives no page size' do
+      stub_capture(%w[sysctl -n hw.memsize hw.pagesize], '2147483648')
+
+      expect(described_class.memory_from_sysctl).to eq('Total' => '2 GB', 'Available' => 'unknown')
+    end
+
+    it 'reads the product name, version and build from sw_vers' do
+      stub_host_file('/usr/bin/sw_vers')
+      stub_capture(['sw_vers'], <<~SW_VERS)
+        ProductName:\t\tmacOS
+        ProductVersion:\t\t15.0
+        BuildVersion:\t\t24A335
+      SW_VERS
+
+      expect(described_class.macos_os_release).to eq('macOS 15.0 (24A335)')
+      expect(described_class.os_release).to eq('macOS 15.0 (24A335)')
+    end
+  end
+
+  describe '.os_release' do
+    it 'is unavailable when neither os-release nor sw_vers exist' do
+      stub_missing_host_file('/etc/os-release')
+      stub_missing_host_file('/usr/bin/sw_vers')
+
+      expect(described_class.os_release).to eq('unavailable')
+    end
+  end
+
+  describe '.disk' do
+    before { allow(Rails.configuration).to receive(:data_path).and_return('/data') }
+
+    it 'reports the parsed df values next to the data path' do
+      allow(described_class).to receive(:parse_df).with('/data').and_return('Total' => '1 TB')
+
+      expect(described_class.disk).to eq('Data path' => '/data', 'Total' => '1 TB')
+    end
+
+    it 'falls back to the raw df output when parsing fails' do
+      allow(described_class).to receive(:parse_df).with('/data').and_return(nil)
+      stub_capture(%w[df -kP /data], 'df: /data: No such file or directory')
+
+      expect(described_class.disk).to eq(
+        'Data path' => '/data',
+        'Usage' => 'df: /data: No such file or directory',
+      )
+    end
+  end
+
+  describe '.data_volumes' do
+    let(:data_path) { Dir.mktmpdir }
+
+    before { allow(Rails.configuration).to receive(:data_path).and_return(data_path) }
+
+    after { FileUtils.remove_entry(data_path) }
+
+    it 'reports the size of every subdirectory of the data path' do
+      FileUtils.mkdir_p(File.join(data_path, 'influxdb'))
+      FileUtils.mkdir_p(File.join(data_path, 'postgresql'))
+      File.write(File.join(data_path, 'compose.yaml'), "services:\n")
+
+      result = described_class.data_volumes
+
+      expect(result.keys).to eq(%w[influxdb postgresql])
+      expect(result.values).to all(match(/\A\d+(\.\d+)? (Bytes|[KMGT]B)\z/))
+    end
+
+    it 'reports an empty data path' do
+      expect(described_class.data_volumes).to eq('Status' => 'no data directories found')
+    end
+
+    it 'reports a data path that does not exist' do
+      allow(Rails.configuration).to receive(:data_path).and_return(File.join(data_path, 'gone'))
+
+      expect(described_class.data_volumes).to eq('Status' => 'data path unavailable')
+    end
+
+    it 'reports unknown sizes when du fails' do
+      FileUtils.mkdir_p(File.join(data_path, 'influxdb'))
+      allow(described_class).to receive(:directory_sizes).and_call_original
+      stub_capture(['du', '-sk', File.join(data_path, 'influxdb')], 'failed (exit 1): du: cannot read')
+
+      expect(described_class.data_volumes).to eq('influxdb' => 'unknown')
+    end
+  end
+
   # Single helper for the cgroup-stub pattern: pass `v2: true/false` plus a
   # path => content mapping. Files not in the mapping return nil.
   def stub_cgroup(v2:, **paths) # rubocop:disable Naming/MethodParameterName
     allow(SupportBundle::SystemInfo::CgroupReader).to receive(:v2?).and_return(v2)
     allow(SupportBundle::SystemInfo::CgroupReader).to receive(:read_first_line) { |path| paths[path] }
   end
+
+  def stub_capture(command, output)
+    allow(SupportBundle::SystemInfo::OutputFormatter)
+      .to receive(:capture).with(*command).and_return(output)
+  end
 end