sys-proctable 1.2.6 → 1.3.0

data/spec/sys_proctable_bsd_spec.rb

@@ -0,0 +1,244 @@
+################################################################
+# sys_proctable_bsd_rspec.rb
+#
+# Specs for BSD related operating systems for the sys-proctable
+# library. You should run these tests via the 'rake spec' task.
+################################################################
+require 'spec_helper'
+require 'mkmf-lite'
+
+RSpec.describe Sys::ProcTable, :bsd do
+  let(:fields_freebsd){
+    %w[
+      pid ppid pgid tpgid sid tsid jobc uid ruid rgid
+      ngroups groups size rssize swrss tsize dsize ssize
+      xstat acflag pctcpu estcpu slptime swtime runtime start
+      flag state nice lock rqindex oncpu lastcpu wmesg login
+      lockname comm ttynum ttydev jid priority usrpri cmdline
+      utime stime maxrss ixrss idrss isrss minflt majflt nswap
+      inblock oublock msgsnd msgrcv nsignals nvcsw nivcsw
+    ]
+  }
+
+  let(:fields_dragonfly){
+    %w[
+      paddr flags stat lock acflag traceflag fd siglist sigignore
+      sigcatch sigflag start comm uid ngroups groups ruid svuid
+      rgid svgid pid ppid pgid jobc sid login tdev tpgid tsid exitstat
+      nthreads nice swtime vm_map_size vm_rssize vm_swrss vm_tsize
+      vm_dsize vm_ssize vm_prssize jailid ru cru auxflags lwp ktaddr
+    ]
+  }
+
+  context 'fields singleton method' do
+    it 'responds to a fields method' do
+      expect(described_class).to respond_to(:fields)
+    end
+
+    it 'returns the expected results for the fields method' do
+      fields = RbConfig::CONFIG['host_os'] =~ /freebsd/i ? fields_freebsd : fields_dragonfly
+      expect(described_class.fields).to be_kind_of(Array)
+      expect(described_class.fields).to eql(fields)
+    end
+  end
+
+  context 'ProcTable::Struct members' do
+    subject(:process){ described_class.ps(:pid => Process.pid) }
+
+    it 'contains a pid member and returns the expected value' do
+      expect(process).to respond_to(:pid)
+      expect(process.pid).to be_kind_of(Numeric)
+      expect(process.pid).to eql(Process.pid)
+    end
+
+    it 'contains a ppid member and returns the expected value' do
+      expect(process).to respond_to(:ppid)
+      expect(process.ppid).to be_kind_of(Integer)
+    end
+
+    it 'contains a pgid member and returns the expected value' do
+      expect(process).to respond_to(:pgid)
+      expect(process.pgid).to be_kind_of(Integer)
+    end
+
+    it 'contains a ruid member and returns the expected value' do
+      expect(process).to respond_to(:ruid)
+      expect(process.ruid).to be_kind_of(Integer)
+    end
+
+    it 'contains a rgid member and returns the expected value' do
+      expect(process).to respond_to(:rgid)
+      expect(process.rgid).to be_kind_of(Integer)
+    end
+
+    it 'contains a comm member and returns the expected value' do
+      expect(process).to respond_to(:comm)
+      expect(process.comm).to be_kind_of(String)
+    end
+
+    it 'contains a state member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:state)
+      expect(process.state).to be_kind_of(String)
+    end
+
+    it 'contains a pctcpu member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:pctcpu)
+      expect(process.pctcpu).to be_kind_of(Float)
+    end
+
+    it 'contains a oncpu member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:oncpu)
+      expect(process.oncpu).to be_kind_of(Integer)
+    end
+
+    it 'contains a ttynum member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:ttynum)
+      expect(process.ttynum).to be_kind_of(Integer)
+    end
+
+    it 'contains a ttydev member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:ttydev)
+      expect(process.ttydev).to be_kind_of(String)
+    end
+
+    it 'contains a wmesg member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:wmesg)
+      expect(process.wmesg).to be_kind_of(String)
+    end
+
+    it 'contains a runtime member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:runtime)
+      expect(process.runtime).to be_kind_of(Integer)
+    end
+
+    it 'contains a priority member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:priority)
+      expect(process.priority).to be_kind_of(Integer)
+    end
+
+    it 'contains a usrpri member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:usrpri)
+      expect(process.usrpri).to be_kind_of(Integer)
+    end
+
+    it 'contains a nice member and returns the expected value' do
+      expect(process).to respond_to(:nice)
+      expect(process.nice).to be_kind_of(Integer)
+    end
+
+    it 'contains a cmdline member and returns the expected value' do
+      expect(process).to respond_to(:cmdline)
+      expect(process.cmdline).to be_kind_of(String)
+    end
+
+    it 'contains a start member and returns the expected value' do
+      expect(process).to respond_to(:start)
+      expect(process.start).to be_kind_of(Time)
+    end
+
+    it 'contains a maxrss member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:maxrss)
+      expect(process.maxrss).to be_kind_of(Integer)
+    end
+
+    it 'contains a ixrss member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:ixrss)
+      expect(process.ixrss).to be_kind_of(Integer)
+    end
+
+    # TODO: The value returned on PC BSD 10 does not appear to be valid. Investigate.
+    it 'contains a idrss member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:idrss)
+      expect(process.idrss).to be_kind_of(Numeric)
+    end
+
+    it 'contains a isrss member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:isrss)
+      expect(process.isrss).to be_kind_of(Integer)
+    end
+
+    it 'contains a minflt member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:minflt)
+      expect(process.minflt).to be_kind_of(Integer)
+    end
+
+    it 'contains a majflt member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:majflt)
+      expect(process.majflt).to be_kind_of(Integer)
+    end
+
+    it 'contains a nswap member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:nswap)
+      expect(process.nswap).to be_kind_of(Integer)
+    end
+
+    it 'contains a inblock member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:inblock)
+      expect(process.inblock).to be_kind_of(Integer)
+    end
+
+    it 'contains a oublock member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:oublock)
+      expect(process.oublock).to be_kind_of(Integer)
+    end
+
+    it 'contains a msgsnd member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:msgsnd)
+      expect(process.msgsnd).to be_kind_of(Integer)
+    end
+
+    it 'contains a msgrcv member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:msgrcv)
+      expect(process.msgrcv).to be_kind_of(Integer)
+    end
+
+    it 'contains a nsignals member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:nsignals)
+      expect(process.nsignals).to be_kind_of(Integer)
+    end
+
+    it 'contains a nvcsw member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:nvcsw)
+      expect(process.nvcsw).to be_kind_of(Integer)
+    end
+
+    it 'contains a nivcsw member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:nivcsw)
+      expect(process.nivcsw).to be_kind_of(Integer)
+    end
+
+    it 'contains a utime member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:utime)
+      expect(process.utime).to be_kind_of(Integer)
+    end
+
+    it 'contains a stime member and returns the expected value', :freebsd do
+      expect(process).to respond_to(:stime)
+      expect(process.stime).to be_kind_of(Integer)
+    end
+  end
+
+  context 'C struct verification' do
+    let(:dummy){ Class.new{ extend Mkmf::Lite } }
+
+    it 'has a timeval struct of the expected size' do
+      expect(Sys::ProcTableStructs::Timeval.size).to eq(dummy.check_sizeof('struct timeval', 'sys/time.h'))
+    end
+
+    it 'has an rtprio struct of the expected size' do
+      expect(Sys::ProcTableStructs::RTPrio.size).to eq(dummy.check_sizeof('struct rtprio', 'sys/rtprio.h'))
+    end
+
+    it 'has an rusage struct of the expected size' do
+      expect(Sys::ProcTableStructs::Rusage.size).to eq(dummy.check_sizeof('struct rusage', 'sys/resource.h'))
+    end
+
+    it 'has an kinfo_lwp struct of the expected size' do
+      expect(Sys::ProcTableStructs::KInfoLWP.size).to eq(dummy.check_sizeof('struct kinfo_lwp', 'sys/kinfo.h'))
+    end
+
+    it 'has an kinfo_proc struct of the expected size' do
+      expect(Sys::ProcTableStructs::KInfoProc.size).to eq(dummy.check_sizeof('struct kinfo_proc', 'sys/kinfo.h'))
+    end
+  end
+end

data/spec/sys_proctable_darwin_spec.rb

@@ -4,11 +4,9 @@
 # Test suite for the Darwin version of the sys-proctable library. You
 # should run these tests via the 'rake test' task.
 ########################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_proctable_all_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe Sys::ProcTable, :darwin do
   let(:fields){
     %w[
       flags status xstatus pid ppid uid gid ruid rgid svuid svgid rfu1 comm
@@ -21,8 +19,8 @@ describe Sys::ProcTable do
   }
 
   before(:all) do
-    @pid1 = Process.spawn({'A' => 'B', 'Z' => nil}, "sleep 60")
-    @pid2 = Process.spawn("ruby", "-Ilib", "-e", "sleep \'120\'.to_i", "--", "foo bar")
+    @pid1 = Process.spawn({'A' => 'B', 'Z' => nil}, 'sleep 60')
+    @pid2 = Process.spawn('ruby', '-Ilib', '-e', "sleep \'120\'.to_i", '--', 'foo bar')
     sleep 1 # wait to make sure env is replaced by sleep
   end
 
@@ -31,90 +29,119 @@ describe Sys::ProcTable do
     Process.kill('TERM', @pid2)
   end
 
-  context "fields singleton method" do
-    it "responds to a fields method" do
+  context 'fields singleton method' do
+    it 'responds to a fields method' do
       expect(described_class).to respond_to(:fields)
     end
 
-    it "returns the expected results for the fields method" do
+    it 'returns the expected results for the fields method' do
       expect(described_class.fields).to be_kind_of(Array)
       expect(described_class.fields).to eq(fields)
     end
   end
 
-  context "ProcTable::Struct members" do
-    subject { described_class.ps(pid: @pid1) }
+  context 'ProcTable::Struct members' do
+    subject(:process){ described_class.ps(:pid => @pid1) }
 
-    it "contains a pid member and returns the expected value" do
-      expect(subject).to respond_to(:pid)
-      expect(subject.pid).to be_kind_of(Numeric)
-      expect(subject.pid).to eq(@pid1)
+    it 'contains a pid member and returns the expected value' do
+      expect(process).to respond_to(:pid)
+      expect(process.pid).to be_kind_of(Numeric)
+      expect(process.pid).to eq(@pid1)
     end
 
-    it "contains a ppid member and returns the expected value" do
-      expect(subject).to respond_to(:ppid)
-      expect(subject.ppid).to be_kind_of(Numeric)
-      expect(subject.ppid).to eq(Process.pid)
+    it 'contains a ppid member and returns the expected value' do
+      expect(process).to respond_to(:ppid)
+      expect(process.ppid).to be_kind_of(Numeric)
+      expect(process.ppid).to eq(Process.pid)
     end
 
-    it "contains a pgid member and returns the expected value" do
-      expect(subject).to respond_to(:pgid)
-      expect(subject.pgid).to be_kind_of(Numeric)
-      expect(subject.pgid).to eq(Process.getpgrp)
+    it 'contains a pgid member and returns the expected value' do
+      expect(process).to respond_to(:pgid)
+      expect(process.pgid).to be_kind_of(Numeric)
+      expect(process.pgid).to eq(Process.getpgrp)
     end
 
-    it "contains a ruid member and returns the expected value" do
-      expect(subject).to respond_to(:ruid)
-      expect(subject.ruid).to be_kind_of(Numeric)
-      expect(subject.ruid).to eq(Process.uid)
+    it 'contains a ruid member and returns the expected value' do
+      expect(process).to respond_to(:ruid)
+      expect(process.ruid).to be_kind_of(Numeric)
+      expect(process.ruid).to eq(Process.uid)
     end
 
-    it "contains an rgid member and returns the expected value" do
-      expect(subject).to respond_to(:rgid)
-      expect(subject.rgid).to be_kind_of(Numeric)
-      expect(subject.rgid).to eq(Process.gid)
+    it 'contains an rgid member and returns the expected value' do
+      expect(process).to respond_to(:rgid)
+      expect(process.rgid).to be_kind_of(Numeric)
+      expect(process.rgid).to eq(Process.gid)
     end
 
-    it "contains an svuid member and returns the expected value" do
-      expect(subject).to respond_to(:svuid)
-      expect(subject.svuid).to be_kind_of(Numeric)
-      expect(subject.svuid).to eq(Process.uid)
+    it 'contains an svuid member and returns the expected value' do
+      expect(process).to respond_to(:svuid)
+      expect(process.svuid).to be_kind_of(Numeric)
+      expect(process.svuid).to eq(Process.uid)
     end
 
-    it "contains an svgid member and returns the expected value" do
-      expect(subject).to respond_to(:svgid)
-      expect(subject.svgid).to be_kind_of(Numeric)
-      expect(subject.svgid).to eq(Process.gid)
+    it 'contains an svgid member and returns the expected value' do
+      expect(process).to respond_to(:svgid)
+      expect(process.svgid).to be_kind_of(Numeric)
+      expect(process.svgid).to eq(Process.gid)
     end
 
-    it "contains a comm member and returns the expected value" do
-      expect(subject).to respond_to(:comm)
-      expect(subject.comm).to be_kind_of(String)
-      expect(subject.comm).to eq('sleep')
+    it 'contains a comm member and returns the expected value' do
+      expect(process).to respond_to(:comm)
+      expect(process.comm).to be_kind_of(String)
+      expect(process.comm).to eq('sleep')
     end
 
-    it "contains a cmdline member and returns the expected value" do
-      expect(subject).to respond_to(:cmdline)
-      expect(subject.cmdline).to be_kind_of(String)
-      expect(subject.cmdline).to eq('sleep 60')
+    it 'contains a cmdline member and returns the expected value' do
+      expect(process).to respond_to(:cmdline)
+      expect(process.cmdline).to be_kind_of(String)
+      expect(process.cmdline).to eq('sleep 60')
     end
 
-    it "returns a string with the expected arguments for the cmdline member" do
-      ptable = Sys::ProcTable.ps(pid: @pid2)
+    it 'returns a string with the expected arguments for the cmdline member', :skip => :jruby do
+      ptable = Sys::ProcTable.ps(:pid => @pid2)
       expect(ptable.cmdline).to eq('ruby -Ilib -e sleep \'120\'.to_i -- foo bar')
     end
 
-    it "contains an exe member and returns the expected value" do
-      expect(subject).to respond_to(:exe)
-      expect(subject.exe).to be_kind_of(String)
-      expect(subject.exe).to eq(`which sleep`.chomp)
+    it 'contains an exe member and returns the expected value' do
+      expect(process).to respond_to(:exe)
+      expect(process.exe).to be_kind_of(String)
+      expect(process.exe).to eq(`which sleep`.chomp)
     end
 
-    it "contains an environ member and returns the expected value" do
-      expect(subject).to respond_to(:environ)
-      expect(subject.environ).to be_kind_of(Hash)
-      expect(subject.environ['A']).to eq('B')
-      expect(subject.environ['Z']).to be_nil
+    it 'contains an environ member and returns the expected value' do
+      skip 'It appears to no longer be possible to get environ on spawned processes on Catalina or later in most cases'
+      expect(process).to respond_to(:environ)
+      expect(process.environ).to be_kind_of(Hash)
+      expect(process.environ['A']).to eq('B')
+      expect(process.environ['Z']).to be_nil
+    end
+  end
+
+  context 'private constants' do
+    it 'makes FFI methods private' do
+      expect(described_class).not_to respond_to(:sysctl)
+      expect(described_class).not_to respond_to(:proc_listallpids)
+      expect(described_class).not_to respond_to(:proc_pidinfo)
+    end
+
+    it 'makes FFI structs private' do
+      expect(described_class.constants).not_to include(:ProcBsdInfo)
+      expect(described_class.constants).not_to include(:ProcThreadInfo)
+      expect(described_class.constants).not_to include(:ProcTaskInfo)
+      expect(described_class.constants).not_to include(:ProcTaskAllInfo)
+    end
+
+    it 'makes internal constants private' do
+      expect(described_class.constants).not_to include(:PROC_PIDTASKALLINFO)
+      expect(described_class.constants).not_to include(:PROC_PIDTHREADINFO)
+      expect(described_class.constants).not_to include(:PROC_PIDLISTTHREADS)
+      expect(described_class.constants).not_to include(:CTL_KERN)
+      expect(described_class.constants).not_to include(:KERN_PROCARGS)
+      expect(described_class.constants).not_to include(:KERN_PROCARGS2)
+      expect(described_class.constants).not_to include(:MAX_COMLEN)
+      expect(described_class.constants).not_to include(:MAX_PATHLEN)
+      expect(described_class.constants).not_to include(:MAXTHREADNAMESIZE)
+      expect(described_class.constants).not_to include(:PROC_PIDPATHINFO_MAXSIZE)
     end
   end
 end