sys-proctable 1.2.6 → 1.3.0

data/spec/sys_proctable_aix_spec.rb

@@ -2,13 +2,11 @@
 # sys_proctable_aix_spec.rb
 #
 # Test suite for the AIX version of the sys-proctable library. You
-# should run these tests via the 'rake test' task.
+# 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, :aix do
   let(:fields){
     %w[
         addr argc argv bindpro cid clname cmd_args cmdline cwd egid environ
@@ -30,8 +28,8 @@ describe Sys::ProcTable do
     end
 
     @myenv = ENV.to_hash
-    @p1args = %w/aix-child.rb testing how well this works 1/
-    @p2args = %w/aix-child.rb testing how well this works 2/
+    @p1args = %w[aix-child.rb testing how well this works 1]
+    @p2args = %w[aix-child.rb testing how well this works 2]
 
     @pid1 = fork do
       exec('ruby', *@p1args)
@@ -61,212 +59,212 @@ describe Sys::ProcTable do
     File.unlink('aix-child.rb') rescue nil
   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 eql(fields)
     end
   end
 
-  context "ProcTable::Struct members" do
-    it "contains a flag member and returns the expected value" do
+  context 'ProcTable::Struct members' do
+    it 'contains a flag member and returns the expected value' do
       expect(@p1info).to respond_to(:flag)
-      expect(@p1info.flag).to be_kind_of(Fixnum)
+      expect(@p1info.flag).to be_kind_of(Integer)
     end
 
-    it "contains a flag2 member and returns the expected value" do
+    it 'contains a flag2 member and returns the expected value' do
       expect(@p1info).to respond_to(:flag2)
-      expect(@p1info.flag2).to be_kind_of(Fixnum)
+      expect(@p1info.flag2).to be_kind_of(Integer)
     end
 
-    it "contains a nlwp member and returns the expected value" do
+    it 'contains a nlwp member and returns the expected value' do
       expect(@p1info).to respond_to(:nlwp)
-      expect(@p1info.nlwp).to be_kind_of(Fixnum)
+      expect(@p1info.nlwp).to be_kind_of(Integer)
     end
 
-    it "contains a uid member and returns the expected value" do
+    it 'contains a uid member and returns the expected value' do
       expect(@p1info).to respond_to(:uid)
       expect(@p1info.uid).to be_kind_of(Integer)
-      expect(@p1info.uid).to eql(@p1info.uid)
+      expect(@p1info.uid).to eql(Process.uid)
     end
 
-    it "contains a euid member and returns the expected value" do
+    it 'contains a euid member and returns the expected value' do
       expect(@p1info).to respond_to(:euid)
       expect(@p1info.euid).to be_kind_of(Integer)
-      expect(@p1info.euid).to eql(@p1info.euid)
+      expect(@p1info.euid).to eql(Process.euid)
     end
 
-    it "contains a gid member and returns the expected value" do
+    it 'contains a gid member and returns the expected value' do
       expect(@p1info).to respond_to(:gid)
       expect(@p1info.gid).to be_kind_of(Integer)
-      expect(@p1info.gid).to eql(@p1info.gid)
+      expect(@p1info.gid).to eql(Process.gid)
     end
 
-    it "contains a egid member and returns the expected value" do
+    it 'contains a egid member and returns the expected value' do
       expect(@p1info).to respond_to(:egid)
       expect(@p1info.egid).to be_kind_of(Integer)
-      expect(@p1info.egid).to eql(@p1info.egid)
+      expect(@p1info.egid).to eql(Process.egid)
     end
 
-    it "contains a pid member and returns the expected value" do
+    it 'contains a pid member and returns the expected value' do
       expect(@p1info).to respond_to(:pid)
       expect(@p1info.pid).to be_kind_of(Integer)
-      expect(@p1info.pid).to eql(@p1info.pid)
+      expect(@p1info.pid).to eql(@pid1)
     end
 
-    it "contains a ppid member and returns the expected value" do
+    it 'contains a ppid member and returns the expected value' do
       expect(@p1info).to respond_to(:ppid)
       expect(@p1info.ppid).to be_kind_of(Integer)
-      expect(@p1info.ppid).to eql(@p1info.ppid)
+      expect(@p1info.ppid).to eql(Process.pid)
     end
 
-    it "contains a pgid member and returns the expected value" do
+    it 'contains a pgid member and returns the expected value' do
       expect(@p1info).to respond_to(:pgid)
       expect(@p1info.pgid).to be_kind_of(Integer)
-      expect(@p1info.pgid).to eql(@p1info.pgid)
+      expect(@p1info.pgid).to eql(Process.getpgrp)
     end
 
-    it "contains a sid member and returns the expected value" do
+    it 'contains a sid member and returns the expected value' do
       expect(@p1info).to respond_to(:sid)
       expect(@p1info.sid).to be_kind_of(Integer)
     end
 
-    it "contains a ttydev member and returns the expected value" do
+    it 'contains a ttydev member and returns the expected value' do
       expect(@p1info).to respond_to(:ttydev)
       expect(@p1info.ttydev).to be_kind_of(Integer)
     end
 
-    it "contains a addr member and returns the expected value" do
+    it 'contains a addr member and returns the expected value' do
       expect(@p1info).to respond_to(:addr)
       expect(@p1info.addr).to be_kind_of(Integer)
     end
 
-    it "contains a size member and returns the expected value" do
+    it 'contains a size member and returns the expected value' do
       expect(@p1info).to respond_to(:size)
       expect(@p1info.size).to be_kind_of(Integer)
     end
 
-    it "contains a rssize member and returns the expected value" do
+    it 'contains a rssize member and returns the expected value' do
       expect(@p1info).to respond_to(:rssize)
       expect(@p1info.rssize).to be_kind_of(Integer)
     end
 
-    it "contains a start member and returns the expected value" do
+    it 'contains a start member and returns the expected value' do
       expect(@p1info).to respond_to(:start)
       expect(@p1info.start).to be_kind_of(Time)
     end
 
-    it "contains a time member and returns the expected value" do
+    it 'contains a time member and returns the expected value' do
       expect(@p1info).to respond_to(:time)
       expect(@p1info.time).to be_kind_of(Time)
     end
 
-    it "contains a cid member and returns the expected value" do
+    it 'contains a cid member and returns the expected value' do
       expect(@p1info).to respond_to(:cid)
-      expect(@p1info.cid).to be_kind_of(Fixnum)
+      expect(@p1info.cid).to be_kind_of(Integer)
     end
 
-    it "contains an argc member and returns the expected value" do
+    it 'contains an argc member and returns the expected value' do
       expect(@p1info).to respond_to(:argc)
-      expect(@p1info.argc).to be_kind_of(Fixnum)
+      expect(@p1info.argc).to be_kind_of(Integer)
       expect(@p1info.argc).to eql(@p1args.size + 1)
     end
 
-    it "contains an argv member and returns the expected value" do
+    it 'contains an argv member and returns the expected value' do
       expect(@p1info).to respond_to(:argv)
       expect(@p1info.argv).to be_kind_of(Integer)
     end
 
-    it "contains an envp member and returns the expected value" do
+    it 'contains an envp member and returns the expected value' do
       expect(@p1info).to respond_to(:envp)
       expect(@p1info.envp).to be_kind_of(Integer)
     end
 
-    it "contains an fname member and returns the expected value" do
+    it 'contains an fname member and returns the expected value' do
       expect(@p1info).to respond_to(:fname)
       expect(@p1info.fname).to be_kind_of(String)
     end
 
-    it "contains an fname member and returns the expected value" do
+    it 'contains an psargs member and returns the expected value' do
       expect(@p1info).to respond_to(:psargs)
       expect(@p1info.psargs).to be_kind_of(String)
     end
 
-    it "contains an lwpid member and returns the expected value" do
+    it 'contains an lwpid member and returns the expected value' do
       expect(@p1info).to respond_to(:lwpid)
       expect(@p1info.lwpid).to be_kind_of(Integer)
     end
 
-    it "contains a wchan member and returns the expected value" do
+    it 'contains a wchan member and returns the expected value' do
       expect(@p1info).to respond_to(:wchan)
       expect(@p1info.wchan).to be_kind_of(Integer)
     end
 
-    it "contains a wtype member and returns the expected value" do
+    it 'contains a wtype member and returns the expected value' do
       expect(@p1info).to respond_to(:wtype)
-      expect(@p1info.wchan).to be_kind_of(Fixnum)
+      expect(@p1info.wchan).to be_kind_of(Integer)
     end
 
-    it "contains a state member and returns the expected value" do
+    it 'contains a state member and returns the expected value' do
       expect(@p1info).to respond_to(:state)
-      expect(@p1info.state).to be_kind_of(Fixnum)
+      expect(@p1info.state).to be_kind_of(Integer)
     end
 
-    it "contains an sname member and returns the expected value" do
+    it 'contains an sname member and returns the expected value' do
       expect(@p1info).to respond_to(:sname)
       expect(@p1info.sname).to be_kind_of(String)
     end
 
-    it "contains a nice member and returns the expected value" do
+    it 'contains a nice member and returns the expected value' do
       expect(@p1info).to respond_to(:nice)
-      expect(@p1info.nice).to be_kind_of(Fixnum)
+      expect(@p1info.nice).to be_kind_of(Integer)
     end
 
-    it "contains a pri member and returns the expected value" do
+    it 'contains a pri member and returns the expected value' do
       expect(@p1info).to respond_to(:pri)
-      expect(@p1info.pri).to be_kind_of(Fixnum)
+      expect(@p1info.pri).to be_kind_of(Integer)
     end
 
-    it "contains a policy member and returns the expected value" do
+    it 'contains a policy member and returns the expected value' do
       expect(@p1info).to respond_to(:policy)
-      expect(@p1info.policy).to be_kind_of(Fixnum)
+      expect(@p1info.policy).to be_kind_of(Integer)
     end
 
-    it "contains a clname member and returns the expected value" do
+    it 'contains a clname member and returns the expected value' do
       expect(@p1info).to respond_to(:clname)
       expect(@p1info.clname).to be_kind_of(String)
     end
 
-    it "contains an onpro member and returns the expected value" do
+    it 'contains an onpro member and returns the expected value' do
       expect(@p1info).to respond_to(:onpro)
-      expect(@p1info.onpro).to be_kind_of(Fixnum)
+      expect(@p1info.onpro).to be_kind_of(Integer)
     end
 
-    it "contains a bindpro member and returns the expected value" do
+    it 'contains a bindpro member and returns the expected value' do
       expect(@p1info).to respond_to(:bindpro)
-      expect(@p1info.bindpro).to be_kind_of(Fixnum)
+      expect(@p1info.bindpro).to be_kind_of(Integer)
     end
 
-    it "contains a ptid member and returns the expected value" do
+    it 'contains a ptid member and returns the expected value' do
       expect(@p1info).to respond_to(:ptid)
-      expect(@p1info.ptid).to be_kind_of(Fixnum)
+      expect(@p1info.ptid).to be_kind_of(Integer)
     end
 
-    it "contains a comm member and returns the expected value" do
+    it 'contains a comm member and returns the expected value' do
       expect(@p1info).to respond_to(:comm)
       expect(@p1info.comm).to be_kind_of(String)
     end
 
-    it "contains a fd member and returns the expected value" do
+    it 'contains a fd member and returns the expected value' do
       expect(@p1info).to respond_to(:fd)
       expect(@p1info.fd).to be_kind_of(Array)
     end
 
-    it "contains a cmd_args member and returns the expected value" do
+    it 'contains a cmd_args member and returns the expected value' do
       expect(@p1info).to respond_to(:cmd_args)
       expect(@p1info.cmd_args).to be_kind_of(Array)
       expect(@p1info.cmd_args).to_eql(['ruby', @p1args].flatten)
@@ -276,7 +274,7 @@ describe Sys::ProcTable do
       expect(@p2info.cmd_args).to_eql(['ruby', @p2args].flatten)
     end
 
-    it "contains an environ member and returns the expected value" do
+    it 'contains an environ member and returns the expected value' do
       expect(@p1info).to respond_to(:environ)
       expect(@p1info.environ).to be_kind_of(Hash)
       expect(@p1info.environ).to eql(@myenv)
@@ -286,29 +284,29 @@ describe Sys::ProcTable do
       expect(@p2info.environ).to eql(@myenv)
     end
 
-    it "contains a cmdline member and returns the expected value" do
+    it 'contains a cmdline member and returns the expected value' do
       expect(@p1info).to respond_to(:cmdline)
       expect(@p1info.cmdline).to be_kind_of(String)
     end
 
-    it "contains a cwd member and returns the expected value" do
+    it 'contains a cwd member and returns the expected value' do
       expect(@p1info).to respond_to(:cwd)
       expect(@p1info.cwd).to be_kind_of(String) if @p1info.cwd
     end
 
-    it "contains a map member and returns the expected value" do
+    it 'contains a map member and returns the expected value' do
       expect(@p1info).to respond_to(:map)
       expect(@p1info.map).to be_kind_of(Array) if @p1info.map
     end
   end
 
-  context "Struct::ProcTableMapStruct" do
-    it "contains the expected members" do
+  context 'Struct::ProcTableMapStruct' do
+    it 'contains the expected members' do
       expect(@p1info.map).to be_kind_of(Array)
       expect(map_fields.sort).to eql(@p1info.map[0].members.sort)
     end
 
-    it "has members of the expected type" do
+    it 'has members of the expected type' do
       expect(@p1info.map).to be_kind_of(Array)
       p1info_map = @p1info.map
 

data/spec/sys_proctable_all_spec.rb

@@ -2,89 +2,89 @@
 # sys_proctable_all_spec.rb
 #
 # Test suite for methods common to all platforms. Generally speaking
-# you should run these specs using the 'rake test' task.
+# you should run these specs using the 'rake spec' task.
 #######################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_top_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe 'common' do
   let(:windows) { File::ALT_SEPARATOR }
 
   before(:all) do
     @pid = Process.pid
   end
 
-  it "has a VERSION constant set to the expected value" do
-    expect(Sys::ProcTable::VERSION).to eql('1.2.6')
-    expect(Sys::ProcTable::VERSION).to be_frozen
-  end
+  context 'constants' do
+    it 'has a VERSION constant set to the expected value' do
+      expect(Sys::ProcTable::VERSION).to eql('1.3.0')
+      expect(Sys::ProcTable::VERSION).to be_frozen
+    end
 
-  it "defines a custom error class" do
-    expect{ Sys::ProcTable::Error }.to_not raise_error
-    expect(Sys::ProcTable::Error.new).to be_kind_of(StandardError)
+    it 'defines a custom error class' do
+      expect{ Sys::ProcTable::Error }.not_to raise_error
+      expect(Sys::ProcTable::Error.new).to be_kind_of(StandardError)
+    end
   end
 
-  context "fields" do
-    it "has a fields singleton method" do
-      expect(described_class).to respond_to(:fields)
+  context 'fields' do
+    it 'has a fields singleton method' do
+      expect(Sys::ProcTable).to respond_to(:fields)
     end
 
-    it "returns the expected data type for the fields singleton method" do
-      expect(described_class.fields).to be_kind_of(Array)
-      expect(described_class.fields.first).to be_kind_of(String)
+    it 'returns the expected data type for the fields singleton method' do
+      expect(Sys::ProcTable.fields).to be_kind_of(Array)
+      expect(Sys::ProcTable.fields.first).to be_kind_of(String)
     end
   end
 
-  context "ps" do
-    it "defines a ps singleton method" do
-      expect(described_class).to respond_to(:ps)
+  context 'ps' do
+    it 'defines a ps singleton method' do
+      expect(Sys::ProcTable).to respond_to(:ps)
     end
 
-    it "allows a pid option as an argument" do
-      expect{ described_class.ps(pid: 0) }.to_not raise_error
+    it 'allows a pid option as an argument' do
+      expect{ Sys::ProcTable.ps(:pid => 0) }.not_to raise_error
     end
 
-    it "allows the pid to be nil" do
-      expect{ described_class.ps(pid: nil) }.to_not raise_error
-      expect(described_class.ps(pid: nil)).to be_kind_of(Array)
+    it 'allows the pid to be nil' do
+      expect{ Sys::ProcTable.ps(:pid => nil) }.not_to raise_error
+      expect(Sys::ProcTable.ps(:pid => nil)).to be_kind_of(Array)
     end
 
-    it "returns expected results with no arguments" do
-      expect(described_class.ps).to be_kind_of(Array)
+    it 'returns expected results with no arguments' do
+      expect(Sys::ProcTable.ps).to be_kind_of(Array)
     end
 
-    it "returns expected results with a pid argument" do
-      expect(described_class.ps(pid: @pid)).to be_kind_of(Struct::ProcTableStruct)
+    it 'returns expected results with a pid argument' do
+      expect(Sys::ProcTable.ps(:pid => @pid)).to be_kind_of(Struct::ProcTableStruct)
     end
 
-    it "returns nil if the process does not exist" do
-      expect(described_class.ps(pid: 999999999)).to be_nil
+    it 'returns nil if the process does not exist' do
+      expect(Sys::ProcTable.ps(:pid => 999999999)).to be_nil
     end
 
-    it "returns nil in block form whether or not a pid was provided" do
-      expect(described_class.ps{}).to be_nil
-      expect(described_class.ps(pid: 999999999){}).to be_nil
+    it 'returns nil in block form whether or not a pid was provided' do
+      expect(Sys::ProcTable.ps{}).to be_nil
+      expect(Sys::ProcTable.ps(:pid => 999999999){}).to be_nil
     end
 
-    it "returns frozen structs" do
-      expect(described_class.ps.first.frozen?).to eql(true)
+    it 'returns frozen structs' do
+      expect(Sys::ProcTable.ps.first.frozen?).to be(true)
     end
 
-    it "expects a numeric pid argument if present" do
-      expect{ described_class.ps(pid: 'vim') }.to raise_error(TypeError)
+    it 'expects a numeric pid argument if present' do
+      expect{ Sys::ProcTable.ps(:pid => 'vim') }.to raise_error(TypeError)
     end
 
-    it "accepts keyword arguments only" do
-      expect{ described_class.ps(0, 'localhost') }.to raise_error(ArgumentError)
+    it 'accepts keyword arguments only' do
+      expect{ Sys::ProcTable.ps(0, 'localhost') }.to raise_error(ArgumentError)
     end
 
-    it "disables the traditional constructor" do
-      expect{ described_class.new }.to raise_error(NoMethodError)
+    it 'disables the traditional constructor' do
+      expect{ Sys::ProcTable.new }.to raise_error(NoMethodError)
     end
 
-    it "works within a thread" do
-      expect{ Thread.new{ described_class.ps }.value }.to_not raise_error
+    it 'works within a thread' do
+      expect{ Thread.new{ Sys::ProcTable.ps }.value }.not_to raise_error
     end
   end
 end