sys-cpu 0.8.1 → 1.0.1

data/Rakefile

@@ -1,10 +1,10 @@
 require 'rake'
 require 'rake/clean'
-require 'rake/testtask'
 require 'rbconfig'
+require 'rspec/core/rake_task'
 include RbConfig
 
-CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx')
+CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx', '**/*.lock')
 
 namespace 'gem' do
   desc "Create the sys-cpu gem"
@@ -12,7 +12,7 @@ namespace 'gem' do
     require 'rubygems/package'
     spec = eval(IO.read('sys-cpu.gemspec'))
     spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
-    Gem::Package.build(spec, true)
+    Gem::Package.build(spec)
   end
 
   desc "Install the sys-cpu gem"
@@ -44,9 +44,7 @@ task :example => [:clean] do
 
 end
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/test_sys_cpu.rb']
-end
+desc "Run the test suite"
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
+task :default => :spec

data/lib/sys/cpu.rb

@@ -5,7 +5,7 @@ require 'rbconfig'
 module Sys
   class CPU
     # The version of the sys-cpu gem.
-    VERSION = '0.8.1'.freeze
+    VERSION = '1.0.1'.freeze
   end
 end
 

data/lib/sys/linux/sys/cpu.rb

@@ -70,11 +70,43 @@ module Sys
       array unless block_given?
     end
 
+    # Return the total number of logical CPU on the system.
+    #
+    def self.num_cpu
+      CPU_ARRAY.size
+    end
+
+    # Return the architecture of the CPU.
+    #
+    def self.architecture
+      case CPU_ARRAY.first['cpu_family']
+      when '3'
+        "x86"
+      when '6'
+        "x86_64"
+      else
+        nil
+      end
+    end
+
+    # Returns a string indicating the CPU model.
+    #
+    def self.model
+      CPU_ARRAY.first['model_name']
+    end
+
+    # Returns an integer indicating the speed of the CPU.
+    #
+    def self.freq
+      CPU_ARRAY.first['cpu_mhz'].to_f.round
+    end
+
     private
 
     # Create singleton methods for each of the attributes.
     #
     def self.method_missing(id, arg=0)
+      raise NoMethodError, "'#{id}'" unless CPU_ARRAY[arg].has_key?(id.to_s)
       rv = CPU_ARRAY[arg][id.to_s]
       if rv.nil?
         id = id.to_s + "?"

data/lib/sys/windows/sys/cpu.rb

@@ -278,7 +278,7 @@ module Sys
     # Note that this value returns nil on my system.
     #
     def self.get_cmec(num)
-      case
+      case num
         when 0
           str = "The device is working properly."
           return str

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+
+RSpec.configure do |config|
+  config.filter_run_excluding(:bsd) if RbConfig::CONFIG['host_os'] !~ /bsd|darwin|mach|osx/i
+  config.filter_run_excluding(:sunos) if RbConfig::CONFIG['host_os'] !~ /sunos|solaris/i
+  config.filter_run_excluding(:windows) if RbConfig::CONFIG['host_os'] !~ /mswin|win32|dos|mingw|cygwin/i
+  config.filter_run_excluding(:hpux) if RbConfig::CONFIG['host_os'] !~ /hpux/i
+  config.filter_run_excluding(:linux) if RbConfig::CONFIG['host_os'] !~ /linux/i
+end

data/spec/sys_cpu_bsd_spec.rb

@@ -0,0 +1,94 @@
+#############################################################
+# test_sys_cpu_bsd.rb
+#
+# The test case for sys-cpu on BSD flavors, including OS X.
+#############################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :bsd => true do
+  example "architecture method basic functionality" do
+    expect(Sys::CPU).to respond_to(:architecture)
+    expect{ Sys::CPU.architecture }.not_to raise_error
+  end
+
+  example "architecture method returns a sane value" do
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+    expect(Sys::CPU.architecture.size).to be > 0
+  end
+
+  example "architecture method does not accept any arguments" do
+    expect{ Sys::CPU.architecture(0) }.to raise_error(ArgumentError)
+  end
+
+  example "freq method basic functionality" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+  end
+
+  example "freq method returns expected value" do
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+    expect(Sys::CPU.freq).to be > 0
+  end
+
+  example "freq method does not accept any arguments" do
+    expect{ Sys::CPU.freq(0) }.to raise_error(ArgumentError)
+  end
+
+  example "load_avg method basic functionality" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+  end
+
+  example "load_avg returns the expected results" do
+    expect(Sys::CPU.load_avg).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg.length).to eq(3)
+    expect(Sys::CPU.load_avg[0]).to be_kind_of(Float)
+  end
+
+  example "load_avg does not accept any arguments" do
+    expect{ Sys::CPU.load_avg(0) }.to raise_error(ArgumentError)
+  end
+
+  example "machine method basic functionality" do
+    expect(Sys::CPU).to respond_to(:machine)
+    expect{ Sys::CPU.machine }.not_to raise_error
+  end
+
+  example "machine method returns sane value" do
+    expect(Sys::CPU.machine).to be_kind_of(String)
+    expect(Sys::CPU.machine.size).to be > 0
+  end
+
+  example "machine method does not accept any arguments" do
+    expect{ Sys::CPU.machine(0) }.to raise_error(ArgumentError)
+  end
+
+  example "model method basic functionality" do
+    expect(Sys::CPU).to respond_to(:model)
+    expect{ Sys::CPU.model }.not_to raise_error
+  end
+
+  example "model method returns sane value" do
+    expect(Sys::CPU.model).to be_kind_of(String)
+    expect(Sys::CPU.model.length).to be > 0
+  end
+
+  example "model method does not accept any arguments" do
+    expect{ Sys::CPU.model(0) }.to raise_error(ArgumentError)
+  end
+
+  example "num_cpu method basic functionality" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+  end
+
+  example "num_cpu method returns expected value" do
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+    expect(Sys::CPU.num_cpu).to be > 0
+  end
+
+  example "num_cpu method does not accept any arguments" do
+    expect{ Sys::CPU.num_cpu(0) }.to raise_error(ArgumentError)
+  end
+end

data/spec/sys_cpu_hpux_spec.rb

@@ -0,0 +1,50 @@
+#####################################################################
+# sys_cpu_hpux_spec.rb
+#
+# Test suite for the HP-UX platform. This should be run via the
+# 'rake test' task.
+#####################################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :hpux => true do
+  example "cpu_freq" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+    expect{ Sys::CPU.freq(0) }.not_to raise_error
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+  end
+
+  example "num_cpu" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+  end
+
+  example "num_active_cpu" do
+    expect(Sys::CPU).to respond_to(:num_active_cpu)
+    expect{ Sys::CPU.num_active_cpu }.not_to raise_error
+    expect(Sys::CPU.num_active_cpu).to be_kind_of(Integer)
+  end
+
+  example "cpu_architecture" do
+    expect(Sys::CPU).to respond_to(:architecture)
+    expect{ Sys::CPU.architecture }.not_to raise_error
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+  end
+
+  example "load_avg sanity check" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+    expect{ Sys::CPU.load_avg(0) }.not_to raise_error
+    expect{ Sys::CPU.load_avg{ |e| }.not_to raise_error }
+    expect{ Sys::CPU.load_avg(0){ }.to raise_error(ArgumentError) }
+  end
+
+  example "load_avg expected results" do
+    expect(Sys::CPU.load_avg).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg(0)).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg.length).to eq(3)
+    expect(Sys::CPU.load_avg(0).length).to eq(3)
+  end
+end

data/spec/sys_cpu_linux_spec.rb

@@ -0,0 +1,53 @@
+###########################################################
+# sys_cpu_linux_spec.rb
+#
+# Specs for sys-cpu for Linux. This should be run via
+# the 'rake spec' task.
+###########################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :linux => true do
+  example "dynamic methods are defined as expected" do
+    expect{
+      Sys::CPU.processors{ |cs|
+        cs.members.each{ |m| cs[m].to_s }
+      }
+    }.not_to raise_error
+  end
+
+  example "load average works as expected" do
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+    expect(Sys::CPU.load_avg.length).to eq(3)
+  end
+
+  example "cpu_stats works as expected" do
+    expect{ Sys::CPU.cpu_stats }.not_to raise_error
+    expect(Sys::CPU.cpu_stats).to be_kind_of(Hash)
+    expect(Sys::CPU.cpu_stats['cpu0'].length).to be >= 4
+  end
+
+  example "architecture works as expected" do
+    expect{ Sys::CPU.architecture }.not_to raise_error
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+  end
+
+  example "model works as expected" do
+    expect{ Sys::CPU.model }.not_to raise_error
+    expect(Sys::CPU.model).to be_kind_of(String)
+  end
+
+  example "freq works as expected" do
+    expect{ Sys::CPU.freq }.not_to raise_error
+    expect(Sys::CPU.freq).to be_kind_of(Numeric)
+  end
+
+  example "num_cpu works as expected" do
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+    expect(Sys::CPU.num_cpu).to be_kind_of(Numeric)
+  end
+
+  example "bogus methods are not picked up by method_missing" do
+    expect{Sys::CPU.bogus }.to raise_error(NoMethodError)
+  end
+end

data/spec/sys_cpu_spec.rb

@@ -0,0 +1,18 @@
+#######################################################################
+# sys_cpu_spec.rb
+#
+# Only shared specs go here. Everything else goes into its own tagged
+# spec file.
+#######################################################################
+require 'sys/cpu'
+require 'rspec'
+
+RSpec.describe Sys::CPU::VERSION do
+  example "version number is set to the expected value" do
+    expect(Sys::CPU::VERSION).to eq('1.0.1')
+  end
+
+  example "version number is frozen" do
+    expect(Sys::CPU::VERSION).to be_frozen
+  end
+end

data/spec/sys_cpu_sunos_spec.rb

@@ -0,0 +1,80 @@
+###########################################################
+# sys_cpu_sunos_spec.rb
+#
+# Test suite for sys-cpu on Solaris. This should be run
+# via the 'rake spec' task.
+###########################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :sunos => true do
+  example "freq method basic functionality" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+  end
+
+  example "freq method does not accept any arguments" do
+    expect{ Sys::CPU.freq(0) }.to raise_error(ArgumentError)
+  end
+
+  example "freq method returns a sane value" do
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+    expect(Sys::CPU.freq).to be > 100
+  end
+
+  example "fpu_type basic functionality" do
+    expect(Sys::CPU).to respond_to(:fpu_type)
+    expect{ Sys::CPU.fpu_type }.not_to raise_error
+  end
+
+  example "fpu_type returns a sane value" do
+    expect(Sys::CPU.fpu_type).to be_kind_of(String)
+    expect(Sys::CPU.fpu_type).not_to be_empty
+  end
+
+  example "load_avg basic functionality" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+  end
+
+  example "load_avg method returns the expected values" do
+    expect(Sys::CPU.load_avg).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg.length).to eq(3)
+    expect(Sys::CPU.load_avg.first).to be_kind_of(Float)
+  end
+
+  example "model method basic functionality" do
+    expect(Sys::CPU).to respond_to(:model)
+    expect{ Sys::CPU.model }.not_to raise_error
+  end
+
+  example "model method returns a sane value" do
+    expect(Sys::CPU.model).to be_kind_of(String)
+    expect(Sys::CPU.model).not_to be_empty
+  end
+
+  example "num_cpu method basic functionalty" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+  end
+
+  example "num_cpu method returns a sane value" do
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+    expect(Sys::CPU.num_cpu).to be > 0
+  end
+
+  example "state basic functionality" do
+    expect(Sys::CPU).to respond_to(:state)
+    expect{ Sys::CPU.state }.not_to raise_error
+  end
+
+  example "state method accepts one optional argument" do
+    expect{ Sys::CPU.state(0) }.not_to raise_error
+    expect{ Sys::CPU.state(0,0) }.to raise_error(ArgumentError)
+  end
+
+  example "state method returns a sane value" do
+    expect(Sys::CPU.state(0)).to be_kind_of(String)
+    expect(Sys::CPU.state.empty?).to be false
+  end
+end

data/spec/sys_cpu_windows_spec.rb

@@ -0,0 +1,61 @@
+######################################################################
+# sys_cpu_windows_spec.rb
+#
+# Test suite for MS Windows systems. This should be run via the
+# 'rake test' task.
+######################################################################
+require 'spec_helper'
+require 'sys/cpu'
+require 'socket'
+
+RSpec.describe Sys::CPU, :windows => true do
+  let(:host) { Socket.gethostname }
+
+  example "architecture" do
+    expect(Sys::CPU).to respond_to(:architecture)
+    expect{ Sys::CPU.architecture }.not_to raise_error
+    expect{ Sys::CPU.architecture(host) }.not_to raise_error
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+  end
+
+  example "freq" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+    expect{ Sys::CPU.freq(0) }.not_to raise_error
+    expect{ Sys::CPU.freq(0, host) }.not_to raise_error
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+  end
+
+  example "model" do
+    expect(Sys::CPU).to respond_to(:model)
+    expect{ Sys::CPU.model }.not_to raise_error
+    expect{ Sys::CPU.model(host) }.not_to raise_error
+    expect(Sys::CPU.model).to be_kind_of(String)
+  end
+
+  example "num_cpu" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+    expect{ Sys::CPU.num_cpu(host) }.not_to raise_error
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+  end
+
+  example "cpu_type" do
+    expect(Sys::CPU).to respond_to(:cpu_type)
+    expect{ Sys::CPU.cpu_type }.not_to raise_error
+    expect{ Sys::CPU.cpu_type(host) }.not_to raise_error
+    expect(Sys::CPU.cpu_type).to be_kind_of(String)
+  end
+
+  example "load_avg" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+    expect{ Sys::CPU.load_avg(0, host) }.not_to raise_error
+    expect(Sys::CPU.load_avg).to be_kind_of(Integer)
+  end
+
+  example "processors" do
+    expect(Sys::CPU).to respond_to(:processors)
+    expect{ Sys::CPU.processors{}.not_to raise_error }
+  end
+end