rubyipmi 0.9.2 → 0.11.1

data/spec/unit/freeipmi/bmc-info_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-
-describe "Bmc" do
-  before :all do
-    @path = '/usr/local/bin'
-  end
-
-  before :each do
-    allow_message_expectations_on_nil
-    provider = "freeipmi"
-    user = "ipmiuser"
-    pass = "impipass"
-    host = "ipmihost"
-    allow(Rubyipmi).to receive(:locate_command).with('ipmipower').and_return("#{@path}/ipmipower")
-
-    @conn = Rubyipmi.connect(user, pass, host, provider, {:debug => true})
-    @bmcinfo = @conn.bmc.information
-    data = nil
-    File.open("spec/fixtures/#{provider}/bmc_info.txt",'r') do |file|
-      data = file.read
-    end
-    allow(@bmcinfo).to receive(:locate_command).with('bmc-info').and_return("#{@path}/bmc-info")
-    allow(@bmcinfo).to receive(:`).and_return(data)
-    allow($?).to receive(:success?).and_return(true)
-  end
-
-  it "cmd should be bmc-info with correct number of arguments" do
-    @bmcinfo.retrieve
-    verify_freeipmi_command(@bmcinfo, 2, "#{@path}/bmc-info")
-  end
-
-  it "cmd should be bmc-info with correct number of arguments" do
-    @bmcinfo.guid
-    verify_freeipmi_command(@bmcinfo, 3, "#{@path}/bmc-info")
-  end
-
-end

data/spec/unit/freeipmi/bmc_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-
-describe "Bmc" do
-  before :all do
-    @path = '/usr/local/bin'
-  end
-
-  before :each do
-    allow_message_expectations_on_nil
-    provider = "freeipmi"
-    user = "ipmiuser"
-    pass = "impipass"
-    host = "ipmihost"
-    allow(Rubyipmi).to receive(:locate_command).with('ipmipower').and_return("#{@path}/ipmipower")
-
-    @conn = Rubyipmi.connect(user, pass, host, provider,{:debug => true})
-    @bmc = @conn.bmc
-    data = nil
-    File.open("spec/fixtures/#{provider}/bmc_info.txt",'r') do |file|
-      data = file.read
-    end
-    allow(@bmc).to receive(:guid).and_return("guid")
-    allow(@bmc).to receive(:info).and_return("info")
-  end
-
-  it "bmc should not be nil" do
-    expect(@bmc).not_to be nil
-  end
-
-  it "lan should not be nil" do
-    expect(@bmc.lan).not_to be_nil
-  end
-
-  it "guid should not be nil" do
-     expect(@bmc.guid).not_to be_nil
-  end
-
-  it "info should not be nill" do
-    expect(@bmc.info).not_to be_nil
-  end
-
-end

data/spec/unit/freeipmi/connection_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe "Bmc" do
-
-  before :all do
-    @path = '/usr/local/bin'
-    @provider = "freeipmi"
-    @user = "ipmiuser"
-    @pass = "impipass"
-    @host = "ipmihost"
-  end
-
- before :each do
-
-
-    allow(Rubyipmi).to receive(:locate_command).with('ipmipower').and_return("#{@path}/ipmipower")
-
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true})
-
-
-  end
-
-  it "connection should not be nil" do
-    expect(@conn).not_to be_nil
-  end
-
-  it "fru should not be nil" do
-    expect(@conn.fru).not_to be_nil
-  end
-
-  it "provider should not be nil" do
-    expect(@conn.provider).not_to be_nil
-  end
-
-  it "provider should be freeipmi" do
-    expect(@conn.provider).to eq("freeipmi")
-  end
-
-  it "bmc should not be nil" do
-    expect(@conn.bmc).not_to be_nil
-  end
-
-  it "sensors should not be nil" do
-    expect(@conn.sensors).not_to be_nil
-
-  end
-
-  it "chassis should not be nill" do
-    expect(@conn.chassis).not_to be_nil
-
-  end
-
-  it 'object should have driver set to auto if not specified' do
-    expect(@conn.options.has_key?('driver-type')).to eq false
-  end
-
-  it 'object should have driver set to auto if not specified' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-    expect(@conn.options.has_key?('driver-type')).to eq false
-  end
-
-  it 'object should have priv type set to ADMINISTRATOR if not specified' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-    expect(@conn.options.has_key?('privilege-level')).to eq false
-  end
-
-  it 'object should have priv type set to USER ' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:privilege => 'USER', :debug => true, :driver => 'auto'})
-    expect(@conn.options.fetch('privilege-level')).to eq('USER')
-  end
-
-  it 'should raise exception if invalid privilege type' do
-    expect{Rubyipmi.connect(@user, @pass, @host, @provider,{:privilege => 'BLAH',:debug => true, :driver => 'auto'})}.to raise_error(RuntimeError)
-  end
-
-  it 'should raise exception if invalid driver type' do
-    expect{Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'foo'})}.to raise_error(RuntimeError)
-  end
-
-  it 'object should have driver set to lan_2_0' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'lan20'})
-    expect(@conn.options['driver-type']).to eq('LAN_2_0')
-  end
-
-  it 'object should have driver set to lan' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'lan15'})
-    expect(@conn.options['driver-type']).to eq('LAN')
-  end
-
-  it 'object should have driver set to openipmi' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'open'})
-    expect(@conn.options['driver-type']).to eq('OPENIPMI')
-  end
-
-  describe 'test' do
-    it 'should retrun boolean on test connection when result is not a hash' do
-      conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-      bmc = double()
-      allow(bmc).to receive(:info).and_return('')
-      allow(conn).to receive(:bmc).and_return(bmc)
-      expect(conn.connection_works?).to eq false
-    end
-
-    it 'should retrun boolean on test connection when result is a hash' do
-      conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-      bmc = double()
-      allow(bmc).to receive(:info).and_return({:test => true})
-      allow(conn).to receive(:bmc).and_return(bmc)
-      expect(conn.connection_works?).to eq true
-    end
-
-    it 'should retrun boolean on test connection when nil' do
-      conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-      bmc = double()
-      allow(bmc).to receive(:info).and_return(nil)
-      allow(conn).to receive(:bmc).and_return(bmc)
-      expect(conn.connection_works?).to eq false
-    end
-  end
-end

data/spec/unit/freeipmi/errorcodes_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-#require 'rubyipmi/Freeipmi/errorcodes'
-
-describe "Errorcodes" do
-  it 'should return the length of fix hash' do
-    expect(Rubyipmi::Freeipmi::ErrorCodes.length).to be >= 1
-  end
-
-  it 'should return a hash of codes' do
-    expect(Rubyipmi::Freeipmi::ErrorCodes.code).to be_an_instance_of Hash
-
-  end
-
-  it 'should return a fix if code is found' do
-    code = 'authentication type unavailable for attempted privilege level'
-    expect(Rubyipmi::Freeipmi::ErrorCodes.search(code)).to eq({"driver-type" => "LAN_2_0"})
-  end
-
-  it 'should throw and error if no fix is found' do
-    code = 'Crap Shoot'
-    expect {Rubyipmi::Freeipmi::ErrorCodes.search(code)}.to raise_error
-  end
-
-  it 'should throw and error when a bad code is given' do
-    code = nil
-    expect {Rubyipmi::Freeipmi::ErrorCodes.search(code)}.to raise_error
-  end
-end

data/spec/unit/freeipmi/fru_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-describe :Fru do
-
-  before :all do
-    @path = '/usr/local/bin'
-  end
-
-  before :each do
-
-    allow_message_expectations_on_nil
-    data = nil
-    provider = "freeipmi"
-    user = "ipmiuser"
-    pass = "impipass"
-    host = "ipmihost"
-    allow(Rubyipmi).to receive(:locate_command).with('ipmipower').and_return("#{@path}/ipmipower")
-
-    @conn = Rubyipmi.connect(user, pass, host, provider, {:debug => true})
-    @fru = @conn.fru
-    File.open("spec/fixtures/#{provider}/fru.txt",'r') do |file|
-      data = file.read
-    end
-
-    allow(@fru).to receive(:locate_command).with('ipmi-fru').and_return("#{@path}/ipmi-fru")
-    allow(@fru).to receive(:`).and_return(data)
-    allow($?).to receive(:success?).and_return(true)
-  end
-
-  it "cmd should be ipmi-fru with correct number of arguments" do
-    @fru.list
-    verify_freeipmi_command(@fru, 2, "#{@path}/ipmi-fru")
-  end
-
-  it 'should list data' do
-    expect(@fru.names.count).to eq(1)
-  end
-
-  it 'should return a list of unparsed frus' do
-    expect(@fru.getfrus).not_to be_nil
-  end
-
-
-  it "should return a list of parsed frus" do
-    expect(@fru.list.count).to eq(1)
-  end
-
-  it 'should return a manufacturer' do
-    expect(@fru.board_manufacturer).to eq('HP')
-  end
-
-  it 'should return a product' do
-    expect(@fru.board_product_name).to eq('ProLiant DL380 G5')
-  end
-
-  it 'should return a chassis serial' do
-    expect(@fru.chassis_serial_number).to eq('2UX64201U2')
-  end
-
-  it 'should return a board serial' do
-    expect(@fru.board_serial_number).to eq('2UX64201U2')
-  end
-
-  it 'should return a list of fru names' do
-    expect(@fru.names.count).to eq(1)
-  end
-
-  it 'should return a fru using method missing' do
-    @fru.names.each do |name|
-      fru = @fru.send(name)
-      expect(fru).to be_an_instance_of(Rubyipmi::Freeipmi::FruData)
-      expect(fru[:name]).to eq(name)
-
-    end
-  end
-
-end

data/spec/unit/freeipmi/sensors_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-
-describe :Sensors do
-  before :all do
-    @path = '/usr/local/bin'
-  end
-
-  before :each do
-    allow_message_expectations_on_nil
-    data = nil
-    provider = "freeipmi"
-    user = "ipmiuser"
-    pass = "impipass"
-    host = "ipmihost"
-    # this stub allows us to mock the command that would be used to verify provider installation
-    allow(Rubyipmi).to receive(:locate_command).with('ipmipower').and_return("#{@path}/ipmipower")
-
-    @conn = Rubyipmi.connect(user, pass, host, provider, {:debug => true})
-    @sensors = @conn.sensors
-    File.open("spec/fixtures/#{provider}/sensors.txt",'r') do |file|
-      data = file.read
-    end
-    # this stub allows us to mock the command that is used with this test case
-    allow(@sensors).to receive(:locate_command).with('ipmi-sensors').and_return('/usr/local/bin/ipmi-sensors')
-
-    # these stubs allow us to run the command and return the fixtures
-    allow(@sensors).to receive(:`).and_return(data)
-    allow($?).to receive(:success?).and_return(true)
-
-  end
-
- it "cmd should be ipmi-sensors with six arguments" do
-    @sensors.list
-    verify_freeipmi_command(@sensors, 5, "#{@path}/ipmi-sensors")
- end
-
-  it "can return a list of sensors" do
-   expect(@sensors.list).not_to be_nil
-  end
-
-  it "should return a count of sensors" do
-    expect(@sensors.count).to eq(29)
-  end
-
-  it "should return a list of fan names" do
-    expect(@sensors.fanlist.count).to eq(13)
-  end
-
-  it 'should return a list of temp names' do
-    expect(@sensors.templist.count).to eq(7)
-  end
-
-  it 'should return a list of sensor names as an array' do
-    expect(@sensors.names).to be_an_instance_of(Array)
-    expect(@sensors.names.count).to eq(29)
-  end
-
-  it 'should return an empty list if no data exists' do
-    allow(@sensors).to receive(:getsensors).and_return(nil)
-    expect(@sensors.names.count).to eq(0)
-  end
-
-  it 'should return a sensor using method missing' do
-    @sensors.names.each do |name|
-      sensor = @sensors.send(name)
-      expect(sensor).to be_an_instance_of(Rubyipmi::Freeipmi::Sensor)
-      expect(sensor[:name]).to eq(name)
-    end
-  end
-
-  #it 'fix should be added to options after error occurs' do
-  #  error = nil
-  #  File.open("spec/fixtures/freeipmi/errors.txt",'r') do |file|
-  #    error = file.read
-  #  end
-  #  @sensors.stub(:`).and_return(error)
-  #  $?.stub(:success?).and_return(false)
-  #  @sensors.refresh
-  #  after = @sensors.options.fetch('driver-type', false).should_not be_false
-  #end
-
-
-end
-

data/spec/unit/ipmitool/bmc_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-
-describe "Bmc" do
-
-  before :all do
-    @path = '/usr/local/bin'
-  end
-
-  before :each do
-    allow_message_expectations_on_nil
-    provider = "ipmitool"
-    user = "ipmiuser"
-    pass = "impipass"
-    host = "ipmihost"
-    allow(Rubyipmi).to receive(:locate_command).with('ipmitool').and_return("#{@path}/ipmitool")
-    @conn = Rubyipmi.connect(user, pass, host, provider, {:debug => true})
-    @bmc = @conn.bmc
-    data = nil
-    File.open("spec/fixtures/#{provider}/bmc_info.txt",'r') do |file|
-      data = file.read
-    end
-
-    allow(@bmc).to receive(:locate_command).with('ipmitool').and_return("#{@path}/ipmitool")
-    allow(@bmc).to receive(:`).and_return(data)
-    allow($?).to receive(:success?).and_return(true)
-
-    allow(@bmc).to receive(:guid).and_return("guid")
-
-  end
-
-  it "bmc should not be nil" do
-    expect(@bmc).not_to be nil
-  end
-
-  it "lan should not be nil" do
-    expect(@bmc.lan).not_to be_nil
-  end
-
-  it "guid should not be nil" do
-     expect(@bmc.guid).not_to be_nil
-  end
-
-  it "info should not be nil" do
-    expect(@bmc.info).not_to be_nil
-  end
-
-  it "info should parse as expected" do
-    expect(@bmc.info).to eq(RETRIEVE)
-  end
-
-end
-
-RETRIEVE = {
-  'Device ID' => '17',
-  'Device Revision' => '1',
-  'Firmware Revision' => '2.9',
-  'IPMI Version' => '2.0',
-  'Manufacturer ID' => '11',
-  'Manufacturer Name' => 'Hewlett-Packard',
-  'Product ID' => '8192 (0x2000)',
-  'Product Name' => 'Unknown (0x2000)',
-  'Device Available' => 'yes',
-  'Provides Device SDRs' => 'yes',
-  'Additional Device Support' => [
-    'Sensor Device',
-    'SDR Repository Device',
-    'SEL Device',
-    'FRU Inventory Device'
-  ],
-  'Aux Firmware Rev Info' => [
-    '0x00',
-    '0x00',
-    '0x00',
-    '0x30'
-  ]
-}

data/spec/unit/ipmitool/connection_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-describe :Connection do
-
-  before :all do
-    @path = '/usr/local/bin'
-    @provider = "ipmitool"
-    @user = "ipmiuser"
-    @pass = "impipass"
-    @host = "ipmihost"
-  end
-
-  before :each do
-
-    allow(Rubyipmi).to receive(:locate_command).with('ipmitool').and_return("#{@path}/ipmitool")
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true})
-
-  end
-
-  it "connection should not be nil" do
-    expect(@conn).not_to be_nil
-  end
-
-  it "fru should not be nil" do
-    expect(@conn.fru).not_to be_nil
-  end
-
-  it "provider should not be nil" do
-    expect(@conn.provider).not_to be_nil
-  end
-
-  it "provider should be ipmitool" do
-    expect(@conn.provider).to eq("ipmitool")
-  end
-
-  it "bmc should not be nil" do
-    expect(@conn.bmc).not_to be_nil
-  end
-
-  it "sensors should not be nil" do
-    expect(@conn.sensors).not_to be_nil
-
-  end
-
-  it "chassis should not be nill" do
-    expect(@conn.chassis).not_to be_nil
-  end
-
-  it "provider should return ipmitool" do
-    expect(@conn.provider).to eq("ipmitool")
-  end
-
-  it 'object should have driver set to auto if not specified' do
-    expect(@conn.options.has_key?('driver-type')).to eq false
-  end
-
-  it 'object should have driver set to auto if not specified' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-    expect(@conn.options.has_key?('I')).to eq false
-  end
-
-  it 'should raise exception if invalid driver type' do
-    expect{Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'foo'})}.to raise_error(RuntimeError)
-  end
-
-  it 'object should have priv type set to ADMINISTRATOR if not specified' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-    expect(@conn.options.has_key?('L')).to eq false
-  end
-
-  it 'object should have priv type set to USER ' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:privilege => 'USER', :debug => true, :driver => 'auto'})
-    expect(@conn.options.fetch('L')).to eq('USER')
-  end
-
-  it 'should raise exception if invalid privilege type' do
-    expect{Rubyipmi.connect(@user, @pass, @host, @provider,{:privilege => 'BLAH',:debug => true, :driver => 'auto'})}.to raise_error(RuntimeError)
-  end
-
-  it 'object should have driver set to lanplus' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'lan20'})
-    expect(@conn.options['I']).to eq('lanplus')
-  end
-
-  it 'object should have driver set to lanplus' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'lan15'})
-    expect(@conn.options['I']).to eq('lan')
-  end
-
-  it 'object should have driver set to open' do
-    @conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'open'})
-    expect(@conn.options['I']).to eq('open')
-  end
-  describe 'test' do
-    it 'should retrun boolean on test connection when result is not a hash' do
-      conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-      bmc = double()
-      allow(bmc).to receive(:info).and_return('')
-      allow(conn).to receive(:bmc).and_return(bmc)
-      expect(conn.connection_works?).to eq false
-    end
-
-    it 'should retrun boolean on test connection when result is a hash' do
-      conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-      bmc = double()
-      allow(bmc).to receive(:info).and_return({:test => true})
-      allow(conn).to receive(:bmc).and_return(bmc)
-      expect(conn.connection_works?).to eq true
-    end
-
-    it 'should retrun boolean on test connection when nil' do
-      conn = Rubyipmi.connect(@user, @pass, @host, @provider,{:debug => true, :driver => 'auto'})
-      bmc = double()
-      allow(bmc).to receive(:info).and_return(nil)
-      allow(conn).to receive(:bmc).and_return(bmc)
-      expect(conn.connection_works?).to eq false
-    end
-  end
-
-
-end

data/spec/unit/ipmitool/errorcodes_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-require 'rubyipmi/ipmitool/errorcodes'
-
-describe "Errorcodes" do
-
-
-
-  it 'should return the length of fix hash' do
-     expect(Rubyipmi::Ipmitool::ErrorCodes.length).to be > 1
-  end
-
-  it 'should return a hash of codes' do
-    expect(Rubyipmi::Ipmitool::ErrorCodes.code).to be_an_instance_of Hash
-
-  end
-
-  it 'should return a fix if code is found' do
-    code = 'Authentication type NONE not supported'
-    expect(Rubyipmi::Ipmitool::ErrorCodes.search(code)).to eq({"I"=>"lanplus"})
-  end
-
-  it 'should throw and error if no fix is found' do
-    code = 'Crap Shoot'
-    expect {Rubyipmi::Ipmitool::ErrorCodes.search(code)}.to raise_error
-  end
-
-  it 'should throw and error when a bad code is given' do
-    code = nil
-    expect {Rubyipmi::Ipmitool::ErrorCodes.search(code)}.to raise_error
-  end
-
-
-
-end