specinfra-cisco 2.40.2

data/spec/helper/detect_os/darwin_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'specinfra/helper/detect_os/darwin'
+
+describe Specinfra::Helper::DetectOs::Darwin do
+  darwin = Specinfra::Helper::DetectOs::Darwin.new(:exec)
+  it 'Should return darwin 13.4.0 when Mac OS X 10.9.5 (Mavericks) is installed.' do
+    allow(darwin).to receive(:run_command) {
+      CommandResult.new(:stdout => 'Darwin 13.4.0', :exit_status => 0)
+    }
+    expect(darwin.detect).to include(
+      :family  => 'darwin',
+      :release => '13.4.0'
+    )
+  end
+  it 'Should return darwin 12.6.0 when Mac OS X 10.8.5 (Mountain Lion) is installed.' do
+    allow(darwin).to receive(:run_command) {
+      CommandResult.new(:stdout => 'Darwin 12.6.0', :exit_status => 0)
+    }
+    expect(darwin.detect).to include(
+      :family  => 'darwin',
+      :release => '12.6.0'
+    )
+  end
+  it 'Should return darwin 11.4.2 when Mac OS X 10.7.5 (Lion) is installed.' do
+    allow(darwin).to receive(:run_command) {
+      CommandResult.new(:stdout => 'Darwin 11.4.2', :exit_status => 0)
+    }
+    expect(darwin.detect).to include(
+      :family  => 'darwin',
+      :release => '11.4.2'
+    )
+  end
+  it 'Should return darwin nil when Darwin FooBar is installed.' do
+    allow(darwin).to receive(:run_command) {
+      CommandResult.new(:stdout => 'Darwin FooBar', :exit_status => 0)
+    }
+    expect(darwin.detect).to include(
+      :family  => 'darwin',
+      :release => nil
+    )
+  end
+end

data/spec/helper/detect_os/esxi_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'specinfra/helper/detect_os/esxi'
+
+describe Specinfra::Helper::DetectOs::Esxi do
+  esxi = Specinfra::Helper::DetectOs::Esxi.new(:exec)
+  it 'Should return esxi when esxi is installed.' do
+    allow(esxi).to receive(:run_command) {
+      CommandResult.new(:stdout => 'VMware ESXi 5.0.0 build-123445', :exit_status => 0)
+    }
+    expect(esxi.detect).to include(
+      :family  => 'esxi',
+      :release => '5.0.0 build-123445'
+    )
+  end
+
+  it 'Should not return esxi when VMware Workstation is installed.' do
+    allow(esxi).to receive(:run_command) {
+      CommandResult.new(:stdout => 'VMware Workstation', :exit_status => 0)
+    }
+    expect(esxi.detect).to be_nil
+  end
+end

data/spec/helper/detect_os/freebsd_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'specinfra/helper/detect_os/freebsd'
+
+describe Specinfra::Helper::DetectOs::Freebsd do
+  freebsd = Specinfra::Helper::DetectOs::Freebsd.new(:exec)
+  it 'Should return freebsd 10 when FreeBSD 10.1-RELEASE is installed.' do
+    allow(freebsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'FreeBSD 10.1--RELEASE', :exit_status => 0)
+    }
+    expect(freebsd.detect).to include(
+      :family  => 'freebsd',
+      :release => '10'
+    )
+  end
+  it 'Should return freebsd 9 when FreeBSD 9.3-RELEASE is installed.' do
+    allow(freebsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'FreeBSD 9.3-RELEASE', :exit_status => 0)
+    }
+    expect(freebsd.detect).to include(
+      :family  => 'freebsd',
+      :release => '9'
+    )
+  end
+  it 'Should return freebsd 8 when FreeBSD 8.2-RELEASE-p3 is installed.' do
+    allow(freebsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'FreeBSD 8.2-RELEASE-p3', :exit_status => 0)
+    }
+    expect(freebsd.detect).to include(
+      :family  => 'freebsd',
+      :release => '8'
+    )
+  end
+  it 'Should return freebsd nil when FreeBSD FooBar is installed.' do
+    allow(freebsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'FreeBSD FooBar', :exit_status => 0)
+    }
+    expect(freebsd.detect).to include(
+      :family  => 'freebsd',
+      :release => nil 
+    )
+  end
+end

data/spec/helper/detect_os/openbsd_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'specinfra/helper/detect_os/openbsd'
+
+describe Specinfra::Helper::DetectOs::Openbsd do
+  openbsd = Specinfra::Helper::DetectOs::Openbsd.new(:exec)
+  it 'Should return (fictional) openbsd 10.11 when OpenBSD 10.11 is installed.' do
+    allow(openbsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'OpenBSD 10.11', :exit_status => 0)
+    }
+    expect(openbsd.detect).to include(
+      :family  => 'openbsd',
+      :release => '10.11'
+    )
+  end
+  it 'Should return openbsd 5.7 when OpenBSD 5.7 is installed.' do
+    allow(openbsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'OpenBSD 5.7', :exit_status => 0)
+    }
+    expect(openbsd.detect).to include(
+      :family  => 'openbsd',
+      :release => '5.7'
+    )
+  end
+  it 'Should return openbsd 5.6 when OpenBSD 5.6 is installed.' do
+    allow(openbsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'OpenBSD 5.6', :exit_status => 0)
+    }
+    expect(openbsd.detect).to include(
+      :family  => 'openbsd',
+      :release => '5.6'
+    )
+  end
+  it 'Should return openbsd nil when OpenBSD FooBar is installed.' do
+    allow(openbsd).to receive(:run_command) {
+      CommandResult.new(:stdout => 'OpenBSD FooBar', :exit_status => 0)
+    }
+    expect(openbsd.detect).to include(
+      :family  => 'openbsd',
+      :release => nil
+    )
+  end
+end

data/spec/helper/os_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+def set_stub_chain(keys, value)
+    allow(Specinfra).to receive_message_chain([:configuration, keys].flatten).and_return(value)
+end
+
+describe 'no ssh connection without cache' do
+  before do
+    property[:os] = nil
+    set_stub_chain(:ssh, nil)
+    set_stub_chain(:ssh_options, nil)
+    set_stub_chain(:host, 'localhost')
+    set_stub_chain(:os, :family => 'redhat')
+  end
+
+  it { expect(os[:family]).to eq 'redhat' }
+end
+
+describe 'no ssh connection with cache' do
+  it { expect(property[:os]).to eq(:family => 'redhat') }
+end
+
+describe 'ssh_options without cache' do
+  before do
+    property[:os] = nil
+    set_stub_chain(:ssh, nil)
+    set_stub_chain(:ssh_options, :port => 22)
+    set_stub_chain(:host, 'localhost')
+    set_stub_chain(:os, :family => 'ubuntu')
+  end
+
+  it { expect(os[:family]).to eq 'ubuntu' }
+end
+
+describe 'ssh_options with cache' do
+  it { expect(property[:os]).to eq(:family => 'ubuntu') }
+end
+
+describe 'ssh_connection without cache' do
+  before do
+    property[:os] = nil
+    set_stub_chain([:ssh, :host], 'localhost')
+    set_stub_chain([:ssh, :options], :port => 2222)
+    set_stub_chain(:os, :family => 'nixos')
+  end
+
+  it { expect(os[:family]).to eq 'nixos' }
+end
+
+describe 'ssh_connection wit cache' do
+  before do
+    set_stub_chain([:ssh, :host], 'localhost')
+    set_stub_chain([:ssh, :options], :port => 2222)
+    set_stub_chain(:os, :family => 'nixos')
+  end
+
+  it { expect(property[:os]).to eq(:family => 'nixos') }
+end

data/spec/helper/properties_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+include Specinfra::Helper::Properties
+
+describe 'Properties Helper' do
+  before :all do
+    set_property :role => 'proxy'
+  end
+  subject { property }
+  it { should include :role => 'proxy' }
+end

data/spec/helper/set_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'set method set value to Specinfra.configuration' do
+  it 'set method handle string value correctly' do
+    set :host, 'localhost'
+    expect(Specinfra.configuration.host).to eq 'localhost'
+  end
+
+  it 'set method handle hash value correctly' do
+    set :ssh_options, :password => 'password', :port => 2222
+    ssh_options = { :password => 'password', :port => 2222 }
+    expect(Specinfra.configuration.ssh_options).to eq ssh_options
+  end
+end

data/spec/host_inventory/aix/filesystem_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+# Output from 'df -kP'
+str = <<-EOH
+Filesystem   1024-blocks      Used Available Capacity Mounted on
+/dev/hd4          524288     67328    456960      13% /
+/dev/hd2         4194304   3077768   1116536      74% /usr
+/dev/hd9var      3145728     96588   3049140       4% /var
+/dev/hd3         2097152    128588   1968564       7% /tmp
+/dev/hd1           65536       380     65156       1% /home
+/dev/hd11admin     131072       364    130708      1% /admin
+/proc                  -         -         -       -  /proc
+/dev/hd10opt     4194304    725280   3469024      18% /opt
+/dev/livedump    1572864       568   1572296       1% /var/adm/ras/livedump
+/dev/fslv00      1048576    127848    920728      13% /audit
+EOH
+
+describe Specinfra::HostInventory::Filesystem do
+  let(:host_inventory) { nil }
+  describe 'Example of AIX 7.1' do
+    ret = Specinfra::HostInventory::Filesystem.new(host_inventory).parse(str)
+    example "/dev/fslv00" do
+      expect(ret["/dev/fslv00"]).to include(
+        "kb_available" => "920728",
+        "kb_size"      => "1048576",
+        "kb_used"      => "127848",
+        "mount"        => "/audit",
+        "percent_used" => "13%"
+      )
+    end
+    example "/dev/hd1" do
+      expect(ret["/dev/hd1"]).to include(
+        "kb_available" => "65156",
+        "kb_size"      => "65536",
+        "kb_used"      => "380",
+        "mount"        => "/home",
+        "percent_used" => "1%"
+      )
+    end
+    example "/dev/hd2" do
+      expect(ret["/dev/hd2"]).to include(
+        "kb_available" => "1116536",
+        "kb_used"      => "3077768",
+        "kb_size"      => "4194304",
+        "mount"        => "/usr",
+        "percent_used" => "74%"
+      )
+    end
+    example "/dev/hd3" do
+      expect(ret["/dev/hd3"]).to include(
+        "kb_available" => "1968564",
+        "kb_size"      => "2097152",
+        "kb_used"      => "128588",
+        "mount"        => "/tmp",
+        "percent_used" => "7%"
+      )
+    end
+    example "/dev/hd4" do
+      expect(ret["/dev/hd4"]).to include(
+        "kb_available" => "456960",
+        "kb_size"      => "524288",
+        "kb_used"      => "67328",
+        "mount"        => "/",
+        "percent_used" => "13%"
+      )
+    end
+    example "/dev/hd9var" do
+      expect(ret["/dev/hd9var"]).to include(
+        "kb_available" => "3049140",
+        "kb_size"      => "3145728",
+        "kb_used"      => "96588",
+        "mount"        => "/var",
+        "percent_used" => "4%"
+      )
+    end
+    example "/dev/hd10opt" do
+      expect(ret["/dev/hd10opt"]).to include(
+        "kb_available" => "3469024",
+        "kb_size"      => "4194304",
+        "kb_used"      => "725280",
+        "mount"        => "/opt",
+        "percent_used" => "18%"
+      )
+    end
+    example "/dev/hd11admin" do
+      expect(ret["/dev/hd11admin"]).to include(
+        "kb_available" => "130708",
+        "kb_used"      => "364",
+        "kb_size"      => "131072",
+        "mount"        => "/admin",
+        "percent_used" => "1%"
+      )
+    end
+    example "/dev/livedump" do
+      expect(ret["/dev/livedump"]).to include(
+        "kb_available" => "1572296",
+        "kb_size"      => "1572864",
+        "kb_used"      => "568",
+        "mount"        => "/var/adm/ras/livedump",
+        "percent_used" => "1%"
+      )
+    end
+    example "/proc" do
+      expect(ret).to_not include( "/proc" )
+    end
+  end
+end

data/spec/host_inventory/darwin/filesystem_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+## Output from 'df -k'
+str = <<-EOH
+Filesystem                        1024-blocks      Used Available Capacity  Mounted on
+/dev/disk0s2                        243358976 213852680  29250296    88%    /
+devfs                                     126       126         0   100%    /dev
+map -hosts                                  0         0         0   100%    /net
+map auto_home                               0         0         0   100%    /home
+localhost:/zbXdxUd1sN5zY6jeNUAx8l   243358976 243358976         0   100%    /Volumes/MobileBackups
+EOH
+
+describe Specinfra::HostInventory::Filesystem do
+  let(:host_inventory) { nil }
+  describe 'Example Darwin (MacOS X) release 11.4.2' do
+    ret = Specinfra::HostInventory::Filesystem.new(host_inventory).parse(str)
+    example "/dev/disk0s2" do
+      expect(ret["/dev/disk0s2"]).to include(
+       "kb_available"  => "29250296",
+       "kb_size"       => "243358976",
+       "kb_used"       => "213852680",
+       "mount"         => "/",
+       "percent_used"  => "88%"
+      )
+    end
+    example "map -hosts" do
+      expect(ret["map -hosts"]).to include(
+        "kb_available" => "0",
+        "kb_size"      => "0",
+        "kb_used"      => "0",
+        "mount"        => "/net",
+        "percent_used" => "100%"
+      )
+    end
+    example "map auto_home" do
+      expect(ret["map auto_home"]).to include(
+        "kb_available" => "0",
+        "kb_size"      => "0",
+        "kb_used"      => "0",
+        "mount"        => "/home",
+        "percent_used" => "100%"
+      )
+    end
+    example "devfs" do
+      expect(ret["devfs"]).to include(
+        "kb_available" => "0",
+        "kb_size"      => "126",
+        "kb_used"      => "126",
+        "mount"        => "/dev",
+        "percent_used" => "100%"
+      )
+    end
+    example "localhost:/zbXdxUd1sN5zY6jeNUAx8l" do
+      expect(ret["localhost:/zbXdxUd1sN5zY6jeNUAx8l"]).to include(
+        "kb_available" => "0",
+        "kb_size"      => "243358976",
+        "kb_used"      => "243358976",
+        "mount"        => "/Volumes/MobileBackups",
+        "percent_used" => "100%"
+      )
+    end
+  end
+end

data/spec/host_inventory/freebsd/filesystem_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+## Output from 'df -k'
+str = <<-EOH
+Filesystem         1024-blocks    Used   Avail Capacity  Mounted on
+zroot/ROOT/default     2500692 1345720 1154972    54%    /
+devfs                        1       1       0   100%    /dev
+zroot/tmp              1155148     176 1154972     0%    /tmp
+zroot/usr/home         1353676  198704 1154972    15%    /usr/home
+zroot/usr/ports        2306832 1151860 1154972    50%    /usr/ports
+zroot/usr/src          1155116     144 1154972     0%    /usr/src
+zroot/var              1361412  206440 1154972    15%    /var
+zroot/var/crash        1155120     148 1154972     0%    /var/crash
+zroot/var/log          1156184    1212 1154972     0%    /var/log
+zroot/var/mail         1155168     196 1154972     0%    /var/mail
+zroot/var/tmp          1188108   33136 1154972     3%    /var/tmp
+EOH
+
+describe Specinfra::HostInventory::Filesystem do
+  let(:host_inventory) { nil }
+  describe 'Example of FreeBSD 9.3 amd64' do
+    ret = Specinfra::HostInventory::Filesystem.new(host_inventory).parse(str)
+    example "devfs" do
+      expect(ret["devfs"]).to include(
+        "kb_available" => "0",
+        "kb_size"      => "1",
+        "mount"        => "/dev",
+        "percent_used" => "100%",
+        "kb_used"      => "1"
+      )
+    end
+    example "zroot/ROOT/default" do
+      expect(ret["zroot/ROOT/default"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "2500692",
+        "mount"        => "/",
+        "percent_used" => "54%",
+        "kb_used"      => "1345720"
+      )
+    end
+    example "zroot/tmp" do
+      expect(ret["zroot/tmp"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1155148",
+        "mount"        => "/tmp",
+        "percent_used" => "0%",
+        "kb_used"      => "176"
+      )
+    end
+    example "zroot/usr/home" do
+      expect(ret["zroot/usr/home"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1353676",
+        "mount"        => "/usr/home",
+        "percent_used" => "15%",
+        "kb_used"      => "198704"
+      )
+    end
+    example "zroot/usr/ports" do
+      expect(ret["zroot/usr/ports"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "2306832",
+        "mount"        => "/usr/ports",
+        "percent_used" => "50%",
+        "kb_used"      => "1151860"
+      )
+    end
+    example "zroot/usr/src" do
+      expect(ret["zroot/usr/src"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1155116",
+        "mount"        => "/usr/src",
+        "percent_used" => "0%",
+        "kb_used"      => "144"
+      )
+    end
+    example "zroot/var" do
+      expect(ret["zroot/var"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1361412",
+        "mount"        => "/var",
+        "percent_used" => "15%",
+        "kb_used"      => "206440"
+      )
+    end
+    example "zroot/var/crash" do
+      expect(ret["zroot/var/crash"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1155120",
+        "mount"        => "/var/crash",
+        "percent_used" => "0%",
+        "kb_used"      => "148"
+      )
+    end
+    example "zroot/var/mail" do
+      expect(ret["zroot/var/mail"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1155168",
+        "mount"        => "/var/mail",
+        "percent_used" => "0%",
+        "kb_used"      => "196"
+      )
+    end
+    example "zroot/var/log" do
+      expect(ret["zroot/var/log"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1156184",
+        "mount"        => "/var/log",
+        "percent_used" => "0%",
+        "kb_used"      => "1212"
+      )
+    end
+    example "zroot/var/tmp" do
+      expect(ret["zroot/var/tmp"]).to include(
+        "kb_available" => "1154972",
+        "kb_size"      => "1188108",
+        "mount"        => "/var/tmp",
+        "percent_used" => "3%",
+        "kb_used"      => "33136"
+      )
+    end
+  end 
+end