facter 2.0.1.rc1-x86-mingw32

data/spec/unit/util/values_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'facter/util/values'
+
+describe Facter::Util::Values do
+  describe 'deep_freeze' do
+    it "it dups and freezes strings" do
+      input = "hi"
+      output = described_class.deep_freeze(input)
+      expect(input).to_not be_frozen
+      expect(output).to be_frozen
+    end
+
+    it "freezes arrays and each element in the array" do
+      input = %w[one two three]
+      output = described_class.deep_freeze(input)
+
+      input.each { |entry| expect(entry).to_not be_frozen }
+      output.each { |entry| expect(entry).to be_frozen }
+
+      expect(input).to_not be_frozen
+      expect(output).to be_frozen
+    end
+
+    it "freezes hashes and each key and value in the hash" do
+      input = {'one' => 'two', 'three' => 'four'}
+
+      output = described_class.deep_freeze(input)
+
+      input.each_pair do |key, val|
+        # Ruby freezes all string keys, so these will always be frozen
+        expect(key).to be_frozen
+        expect(val).to_not be_frozen
+      end
+
+      output.each_pair do |key, val|
+        expect(key).to be_frozen
+        expect(val).to be_frozen
+      end
+
+      expect(input).to_not be_frozen
+      expect(output).to be_frozen
+    end
+
+    it "raises an error when given a structure that cannot be deeply frozen" do
+      expect {
+        described_class.deep_freeze(Set.new)
+      }.to raise_error(Facter::Util::Values::DeepFreezeError, /Cannot deep freeze.*Set/)
+    end
+  end
+
+  describe 'deep_merge' do
+    it "non-destructively concatenates arrays" do
+      first = %w[foo bar]
+      second = %w[baz quux]
+
+      expect(described_class.deep_merge(first, second)).to eq %w[foo bar baz quux]
+      expect(first).to eq %w[foo bar]
+      expect(second).to eq %w[baz quux]
+    end
+
+    it "returns the left value if the right value is nil" do
+      expect(described_class.deep_merge("left", nil)).to eq "left"
+    end
+
+    it "returns the right value if the left value is nil" do
+      expect(described_class.deep_merge(nil, "right")).to eq "right"
+    end
+
+    it "returns nil if both values are nil" do
+      expect(described_class.deep_merge(nil, nil)).to be_nil
+    end
+
+    describe "with hashes" do
+      it "merges when keys do not overlap" do
+
+        first = {:foo => 'bar'}
+        second = {:baz => 'quux'}
+
+        expect(described_class.deep_merge(first, second)).to eq(:foo => 'bar', :baz => 'quux')
+        expect(first).to eq(:foo => 'bar')
+        expect(second).to eq(:baz => 'quux')
+      end
+
+      it "concatenates arrays when both keys are arrays" do
+        first = {:foo => %w[bar]}
+        second = {:foo => %w[baz quux]}
+
+        expect(described_class.deep_merge(first, second)).to eq(:foo => %w[bar baz quux])
+        expect(first).to eq(:foo => %w[bar])
+        expect(second).to eq(:foo => %w[baz quux])
+      end
+
+      it "merges hashes when both keys are hashes" do
+        first = {:foo => {:pb => 'lead', :ag => 'silver'}}
+        second = {:foo => {:au => 'gold', :na => 'sodium'}}
+
+        expect(described_class.deep_merge(first, second)).to eq(
+          :foo => {
+            :pb => 'lead',
+            :ag => 'silver',
+            :au => 'gold',
+            :na => 'sodium'
+          }
+        )
+      end
+
+      it "prints the data structure path if an error is raised" do
+        first = {:foo => {:bar => {:baz => {:quux => true}}}}
+        second = {:foo => {:bar => {:baz => {:quux => false}}}}
+
+        expect {
+          described_class.deep_merge(first, second)
+        }.to raise_error(Facter::Util::Values::DeepMergeError, /Cannot merge .*at .*foo.*bar.*baz.*quux/)
+      end
+    end
+
+    describe "with unmergable scalar values" do
+      [
+        [true, false],
+        [1, 2],
+        ['up', 'down']
+      ].each do |(left, right)|
+        it "raises an error when merging #{left}:#{left.class} and #{right}:#{right.class}" do
+          expect {
+            described_class.deep_merge(left, right)
+          }.to raise_error(Facter::Util::Values::DeepMergeError, /Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}/)
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/virtual_spec.rb

@@ -0,0 +1,294 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/virtual'
+require 'stringio'
+
+describe Facter::Util::Virtual do
+
+  after do
+    Facter.clear
+  end
+  it "should detect openvz" do
+    FileTest.stubs(:directory?).with("/proc/vz").returns(true)
+    Dir.stubs(:glob).with("/proc/vz/*").returns(['vzquota'])
+    Facter::Util::Virtual.should be_openvz
+  end
+
+  it "should not detect openvz when /proc/lve/list is present" do
+    FileTest.stubs(:file?).with("/proc/lve/list").returns(true)
+    Facter::Util::Virtual.should_not be_openvz
+  end
+
+  it "should not detect openvz when /proc/vz/ is empty" do
+    FileTest.stubs(:file?).with("/proc/lve/list").returns(false)
+    FileTest.stubs(:directory?).with("/proc/vz").returns(true)
+    Dir.stubs(:glob).with("/proc/vz/*").returns([])
+    Facter::Util::Virtual.should_not be_openvz
+  end
+
+  it "should identify openvzhn when /proc/self/status has envID of 0" do
+    Facter::Util::Virtual.stubs(:openvz?).returns(true)
+    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
+    Facter::Core::Execution.stubs(:exec).with('grep "envID" /proc/self/status').returns("envID:  0")
+    Facter::Util::Virtual.openvz_type().should == "openvzhn"
+  end
+
+  it "should identify openvzve when /proc/self/status has envID of 0" do
+    Facter::Util::Virtual.stubs(:openvz?).returns(true)
+    FileTest.stubs(:exists?).with('/proc/self/status').returns(true)
+    Facter::Core::Execution.stubs(:exec).with('grep "envID" /proc/self/status').returns("envID:  666")
+    Facter::Util::Virtual.openvz_type().should == "openvzve"
+  end
+
+  it "should not attempt to identify openvz when /proc/self/status has no envID" do
+    Facter::Util::Virtual.stubs(:openvz?).returns(true)
+    FileTest.stubs(:exists?).with('/proc/self/status').returns(true)
+    Facter::Core::Execution.stubs(:exec).with('grep "envID" /proc/self/status').returns("")
+    Facter::Util::Virtual.openvz_type().should be_nil
+  end
+
+  it "should identify Solaris zones when non-global zone" do
+    Facter::Core::Execution.stubs(:exec).with("/sbin/zonename").returns("somezone")
+    Facter::Util::Virtual.should be_zone
+  end
+
+  it "should not identify Solaris zones when global zone" do
+    Facter::Core::Execution.stubs(:exec).with("/sbin/zonename").returns("global")
+    Facter::Util::Virtual.should_not be_zone
+  end
+
+  it "(#14522) handles the unencoded binary data in /proc/self/status on Solaris" do
+    Facter.fact(:osfamily).stubs(:value).returns("Solaris")
+    File.stubs(:open).with('/proc/self/status', 'rb').returns(solaris_proc_self_status)
+    FileTest.stubs(:exists?).with('/proc/self/status').returns(true)
+
+    Facter::Util::Virtual.vserver?.should eq(false)
+  end
+
+  it "should not detect vserver if no self status" do
+    FileTest.stubs(:exists?).with("/proc/self/status").returns(false)
+    Facter::Util::Virtual.should_not be_vserver
+  end
+
+  it "should detect vserver when vxid present in process status" do
+    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
+    File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new("VxID: 42\n"))
+    Facter::Util::Virtual.should be_vserver
+  end
+
+  it "should detect vserver when s_context present in process status" do
+    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
+    File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new("s_context: 42\n"))
+    Facter::Util::Virtual.should be_vserver
+  end
+
+  it "should not detect vserver when vserver flags not present in process status" do
+    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
+    File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new("wibble: 42\n"))
+    Facter::Util::Virtual.should_not be_vserver
+  end
+
+  it "should identify kvm" do
+    Facter::Util::Virtual.stubs(:kvm?).returns(true)
+    Facter::Core::Execution.stubs(:exec).with('dmidecode 2> /dev/null').returns("something")
+    Facter::Util::Virtual.kvm_type().should == "kvm"
+  end
+
+  it "should be able to detect RHEV via sysfs on Linux" do
+    # Fake files are always hard to stub. :/
+    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
+      returns("RHEV Hypervisor")
+
+    Facter::Util::Virtual.should be_rhev
+  end
+
+  it "should be able to detect RHEV via sysfs on Linux improperly" do
+    # Fake files are always hard to stub. :/
+    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
+      returns("something else")
+
+    Facter::Util::Virtual.should_not be_rhev
+  end
+
+  it "should be able to detect ovirt via sysfs on Linux" do
+    # Fake files are always hard to stub. :/
+    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
+      returns("oVirt Node")
+
+    Facter::Util::Virtual.should be_ovirt
+  end
+
+  it "should be able to detect ovirt via sysfs on Linux improperly" do
+    # Fake files are always hard to stub. :/
+    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
+      returns("something else")
+
+    Facter::Util::Virtual.should_not be_ovirt
+  end
+
+  fixture_path = fixtures('virtual', 'proc_self_status')
+
+  test_cases = [
+    [File.join(fixture_path, 'vserver_2_1', 'guest'), true, 'vserver 2.1 guest'],
+    [File.join(fixture_path, 'vserver_2_1', 'host'),  true, 'vserver 2.1 host'],
+    [File.join(fixture_path, 'vserver_2_3', 'guest'), true, 'vserver 2.3 guest'],
+    [File.join(fixture_path, 'vserver_2_3', 'host'),  true, 'vserver 2.3 host']
+  ]
+
+  test_cases.each do |status_file, expected, description|
+    describe "with /proc/self/status from #{description}" do
+      it "should detect vserver as #{expected.inspect}" do
+        status = File.read(status_file)
+        FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
+        File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new(status))
+        Facter::Util::Virtual.vserver?.should == expected
+      end
+    end
+  end
+
+  it "reads dmi entries as ascii data" do
+    entries_file = my_fixture('invalid_unicode_dmi_entries')
+    expected_contents = 'Virtual'
+
+    entries = Facter::Util::Virtual.read_sysfs_dmi_entries(entries_file)
+
+    entries.should =~ /#{expected_contents}/
+  end
+
+  it "should identify vserver_host when /proc/virtual exists" do
+    Facter::Util::Virtual.expects(:vserver?).returns(true)
+    FileTest.stubs(:exists?).with("/proc/virtual").returns(true)
+    Facter::Util::Virtual.vserver_type().should == "vserver_host"
+  end
+
+  it "should identify vserver_type as vserver when /proc/virtual does not exist" do
+    Facter::Util::Virtual.expects(:vserver?).returns(true)
+    FileTest.stubs(:exists?).with("/proc/virtual").returns(false)
+    Facter::Util::Virtual.vserver_type().should == "vserver"
+  end
+
+  it "should detect xen when /proc/sys/xen exists" do
+    FileTest.expects(:exists?).with("/proc/sys/xen").returns(true)
+    Facter::Util::Virtual.should be_xen
+  end
+
+  it "should detect xen when /sys/bus/xen exists" do
+    FileTest.expects(:exists?).with("/proc/sys/xen").returns(false)
+    FileTest.expects(:exists?).with("/sys/bus/xen").returns(true)
+    Facter::Util::Virtual.should be_xen
+  end
+
+  it "should detect xen when /proc/xen exists" do
+    FileTest.expects(:exists?).with("/proc/sys/xen").returns(false)
+    FileTest.expects(:exists?).with("/sys/bus/xen").returns(false)
+    FileTest.expects(:exists?).with("/proc/xen").returns(true)
+    Facter::Util::Virtual.should be_xen
+  end
+
+  it "should not detect xen when no sysfs/proc xen directories exist" do
+    FileTest.expects(:exists?).with("/proc/sys/xen").returns(false)
+    FileTest.expects(:exists?).with("/sys/bus/xen").returns(false)
+    FileTest.expects(:exists?).with("/proc/xen").returns(false)
+    Facter::Util::Virtual.should_not be_xen
+  end
+
+  it "should detect kvm" do
+    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(true)
+    File.stubs(:read).with("/proc/cpuinfo").returns("model name : QEMU Virtual CPU version 0.9.1\n")
+    Facter::Util::Virtual.should be_kvm
+  end
+
+  it "should detect kvm on FreeBSD" do
+    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(false)
+    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+    Facter::Core::Execution.stubs(:exec).with("/sbin/sysctl -n hw.model").returns("QEMU Virtual CPU version 0.12.4")
+    Facter::Util::Virtual.should be_kvm
+  end
+
+  it "should detect kvm on OpenBSD" do
+    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(false)
+    Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
+    Facter::Core::Execution.stubs(:exec).with("/sbin/sysctl -n hw.model").returns('QEMU Virtual CPU version (cpu64-rhel6) ("AuthenticAMD" 686-class, 512KB L2 cache)')
+    Facter::Util::Virtual.should be_kvm
+  end
+
+  it "should identify FreeBSD jail when in jail" do
+    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+    Facter::Core::Execution.stubs(:exec).with("/sbin/sysctl -n security.jail.jailed").returns("1")
+    Facter::Util::Virtual.should be_jail
+  end
+
+  it "should not identify GNU/kFreeBSD jail when not in jail" do
+    Facter.fact(:kernel).stubs(:value).returns("GNU/kFreeBSD")
+    Facter::Core::Execution.stubs(:exec).with("/bin/sysctl -n security.jail.jailed").returns("0")
+    Facter::Util::Virtual.should_not be_jail
+  end
+
+  it "should detect hpvm on HP-UX" do
+    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+    Facter::Core::Execution.stubs(:exec).with("/usr/bin/getconf MACHINE_MODEL").returns('ia64 hp server Integrity Virtual Machine')
+    Facter::Util::Virtual.should be_hpvm
+  end
+
+  it "should not detect hpvm on HP-UX when not in hpvm" do
+    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+    Facter::Core::Execution.stubs(:exec).with("/usr/bin/getconf MACHINE_MODEL").returns('ia64 hp server rx660')
+    Facter::Util::Virtual.should_not be_hpvm
+  end
+
+  it "should be able to detect virtualbox via sysfs on Linux" do
+    # Fake files are always hard to stub. :/
+    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
+      returns("VirtualBox")
+
+    Facter::Util::Virtual.should be_virtualbox
+  end
+
+  it "should be able to detect virtualbox via sysfs on Linux improperly" do
+    # Fake files are always hard to stub. :/
+    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
+      returns("HP-Oracle-Sun-VMWare-funky-town")
+
+    Facter::Util::Virtual.should_not be_virtualbox
+  end
+
+  let :solaris_proc_self_status do
+    sample_data = my_fixture_read('solaris10_proc_self_status1')
+    mockfile = mock('File')
+    mockfile.stubs(:read).returns(sample_data)
+    mockfile
+  end
+
+  shared_examples_for "virt-what" do |kernel, path, null_device|
+    before(:each) do
+      Facter.fact(:kernel).stubs(:value).returns(kernel)
+      Facter::Core::Execution.expects(:which).with("virt-what").returns(path)
+      Facter::Core::Execution.expects(:exec).with("#{path} 2>#{null_device}")
+    end
+
+    it "on #{kernel} virt-what is at #{path} and stderr is sent to #{null_device}" do
+      Facter::Util::Virtual.virt_what
+    end
+  end
+
+  context "on linux" do
+    it_should_behave_like "virt-what", "linux", "/usr/bin/virt-what", "/dev/null"
+
+    it "should strip out warnings on stdout from virt-what" do
+      virt_what_warning = "virt-what: this script must be run as root"
+      Facter.fact(:kernel).stubs(:value).returns('linux')
+      Facter::Core::Execution.expects(:which).with('virt-what').returns "/usr/bin/virt-what"
+      Facter::Core::Execution.expects(:exec).with('/usr/bin/virt-what 2>/dev/null').returns virt_what_warning
+      Facter::Util::Virtual.virt_what.should_not match /^virt-what: /
+    end
+  end
+
+  context "on unix" do
+    it_should_behave_like "virt-what", "unix", "/usr/bin/virt-what", "/dev/null"
+  end
+
+  context "on windows" do
+    it_should_behave_like "virt-what", "windows", 'c:\windows\system32\virt-what', "NUL"
+  end
+end

data/spec/unit/util/vlans_spec.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/vlans'
+
+describe Facter::Util::Vlans do
+  it "should return a list of vlans on Linux" do
+    linux_vlanconfig = my_fixture_read("linux_vlan_config")
+    Facter::Util::Vlans.stubs(:get_vlan_config).returns(linux_vlanconfig)
+    Facter::Util::Vlans.get_vlans().should == %{400,300,200,100}
+  end
+end

data/spec/unit/util/wmi_spec.rb

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/wmi'
+
+describe Facter::Util::WMI do
+  let(:connection) { stub 'connection' }
+
+  it "should default to localhost" do
+    Facter::Util::WMI.wmi_resource_uri.should == "winmgmts:{impersonationLevel=impersonate}!//./root/cimv2"
+  end
+
+  it "should execute the query on the connection" do
+    Facter::Util::WMI.stubs(:connect).returns(connection)
+    connection.stubs(:execquery).with("select * from Win32_OperatingSystem")
+
+    Facter::Util::WMI.execquery("select * from Win32_OperatingSystem")
+  end
+end