sys-proctable 1.2.6 → 1.2.7

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

data/spec/sys_proctable_freebsd_spec.rb

@@ -2,13 +2,11 @@
 # sys_proctable_freebsd_rspec.rb
 #
 # Test suite for FreeBSD for the sys-proctable library.
-# You should run these tests via 'rake test'.
+# You should run these tests via the 'rake spec' task.
 ################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_proctable_all_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe Sys::ProcTable, :freebsd do
   let(:fields){
     %w[
       pid ppid pgid tpgid sid tsid jobc uid ruid rgid
@@ -21,190 +19,190 @@ describe Sys::ProcTable do
     ]
   }
 
-  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 eql(fields)
     end
   end
 
-  context "ProcTable::Struct members" do
-    subject { described_class.ps(pid: Process.pid) }
+  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(subject).to respond_to(:pid)
-      expect(subject.pid).to be_kind_of(Numeric)
-      expect(subject.pid).to eql(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(subject).to respond_to(:ppid)
-      expect(subject.ppid).to be_kind_of(Fixnum)
+    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(subject).to respond_to(:pgid)
-      expect(subject.pgid).to be_kind_of(Fixnum)
+    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(subject).to respond_to(:ruid)
-      expect(subject.ruid).to be_kind_of(Fixnum)
+    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(subject).to respond_to(:rgid)
-      expect(subject.rgid).to be_kind_of(Fixnum)
+    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(subject).to respond_to(:comm)
-      expect(subject.comm).to be_kind_of(String)
+    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" do
-      expect(subject).to respond_to(:state)
-      expect(subject.state).to be_kind_of(String)
+    it 'contains a state member and returns the expected value' 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" do
-      expect(subject).to respond_to(:pctcpu)
-      expect(subject.pctcpu).to be_kind_of(Float)
+    it 'contains a pctcpu member and returns the expected value' 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" do
-      expect(subject).to respond_to(:oncpu)
-      expect(subject.oncpu).to be_kind_of(Fixnum)
+    it 'contains a oncpu member and returns the expected value' 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" do
-      expect(subject).to respond_to(:ttynum)
-      expect(subject.ttynum).to be_kind_of(Fixnum)
+    it 'contains a ttynum member and returns the expected value' 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" do
-      expect(subject).to respond_to(:ttydev)
-      expect(subject.ttydev).to be_kind_of(String)
+    it 'contains a ttydev member and returns the expected value' 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" do
-      expect(subject).to respond_to(:wmesg)
-      expect(subject.wmesg).to be_kind_of(String)
+    it 'contains a wmesg member and returns the expected value' 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" do
-      expect(subject).to respond_to(:runtime)
-      expect(subject.runtime).to be_kind_of(Fixnum)
+    it 'contains a runtime member and returns the expected value' 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" do
-      expect(subject).to respond_to(:priority)
-      expect(subject.priority).to be_kind_of(Fixnum)
+    it 'contains a priority member and returns the expected value' 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" do
-      expect(subject).to respond_to(:usrpri)
-      expect(subject.usrpri).to be_kind_of(Fixnum)
+    it 'contains a usrpri member and returns the expected value' 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(subject).to respond_to(:nice)
-      expect(subject.nice).to be_kind_of(Fixnum)
+    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(subject).to respond_to(:cmdline)
-      expect(subject.cmdline).to be_kind_of(String)
+    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(subject).to respond_to(:start)
-      expect(subject.start).to be_kind_of(Time)
+    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" do
-      expect(subject).to respond_to(:maxrss)
-      expect(subject.maxrss).to be_kind_of(Fixnum)
+    it 'contains a maxrss member and returns the expected value' 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" do
-      expect(subject).to respond_to(:ixrss)
-      expect(subject.ixrss).to be_kind_of(Fixnum)
+    it 'contains a ixrss member and returns the expected value' 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" do
-      expect(subject).to respond_to(:idrss)
-      expect(subject.idrss).to be_kind_of(Numeric)
+    it 'contains a idrss member and returns the expected value' 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" do
-      expect(subject).to respond_to(:isrss)
-      expect(subject.isrss).to be_kind_of(Fixnum)
+    it 'contains a isrss member and returns the expected value' 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" do
-      expect(subject).to respond_to(:minflt)
-      expect(subject.minflt).to be_kind_of(Fixnum)
+    it 'contains a minflt member and returns the expected value' 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" do
-      expect(subject).to respond_to(:majflt)
-      expect(subject.majflt).to be_kind_of(Fixnum)
+    it 'contains a majflt member and returns the expected value' 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" do
-      expect(subject).to respond_to(:nswap)
-      expect(subject.nswap).to be_kind_of(Fixnum)
+    it 'contains a nswap member and returns the expected value' 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" do
-      expect(subject).to respond_to(:inblock)
-      expect(subject.inblock).to be_kind_of(Fixnum)
+    it 'contains a inblock member and returns the expected value' 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" do
-      expect(subject).to respond_to(:oublock)
-      expect(subject.oublock).to be_kind_of(Fixnum)
+    it 'contains a oublock member and returns the expected value' 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" do
-      expect(subject).to respond_to(:msgsnd)
-      expect(subject.msgsnd).to be_kind_of(Fixnum)
+    it 'contains a msgsnd member and returns the expected value' 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" do
-      expect(subject).to respond_to(:msgrcv)
-      expect(subject.msgrcv).to be_kind_of(Fixnum)
+    it 'contains a msgrcv member and returns the expected value' 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" do
-      expect(subject).to respond_to(:nsignals)
-      expect(subject.nsignals).to be_kind_of(Fixnum)
+    it 'contains a nsignals member and returns the expected value' 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" do
-      expect(subject).to respond_to(:nvcsw)
-      expect(subject.nvcsw).to be_kind_of(Fixnum)
+    it 'contains a nvcsw member and returns the expected value' 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" do
-      expect(subject).to respond_to(:nivcsw)
-      expect(subject.nivcsw).to be_kind_of(Fixnum)
+    it 'contains a nivcsw member and returns the expected value' 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" do
-      expect(subject).to respond_to(:utime)
-      expect(subject.utime).to be_kind_of(Fixnum)
+    it 'contains a utime member and returns the expected value' 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" do
-      expect(subject).to respond_to(:stime)
-      expect(subject.stime).to be_kind_of(Fixnum)
+    it 'contains a stime member and returns the expected value' do
+      expect(process).to respond_to(:stime)
+      expect(process.stime).to be_kind_of(Integer)
     end
   end
 end