facter 2.1.0-x64-mingw32

data/spec/unit/util/partitions/partitions_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'facter'
+require 'facter/util/partitions/linux'
+
+describe 'Facter::Util::Partitions::Linux' do
+  describe 'on Linux OS' do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+
+      File.stubs(:exist?).with('/sys/block/').returns(true)
+      File.stubs(:exist?).with("/sys/block/./device").returns(false)
+      File.stubs(:exist?).with("/sys/block/../device").returns(false)
+      File.stubs(:exist?).with('/dev/disk/by-uuid/').returns(true)
+
+      devices = [".", "..", "sda", "sdb", "sdc"]
+      Dir.stubs(:entries).with('/sys/block/').returns(devices)
+      
+      Facter::Core::Execution.stubs(:which).with('mount').returns(true)
+      Facter::Core::Execution.stubs(:which).with('blkid').returns(true)
+
+      test_parts = {
+        'sda1' => '13459663-22cc-47b4-a9e6-21dea9906e03',  
+        'sdb2' => '98043570-eb10-457f-9718-0b85a26e66bf',  
+        'sdc3' => 'a35fb506-e831-4752-9899-dff6c601214b',
+      }
+      
+      Dir.stubs(:entries).with('/dev/disk/by-uuid/').returns(test_parts.values)
+      test_parts.each do |part,uuid|
+        device = part.match(/(\D+)/)[1]
+        File.stubs(:exist?).with("/sys/block/#{device}/device").returns(true)
+        File.stubs(:symlink?).with("/dev/disk/by-uuid/#{uuid}").returns(true)
+        File.stubs(:readlink).with("/dev/disk/by-uuid/#{uuid}").returns("/dev/#{part}")
+        Dir.stubs(:glob).with("/sys/block/#{device}/#{device}*").returns(["/sys/block/#{device}/#{part}"])
+        Facter::Util::Partitions::Linux.stubs(:read_size).returns('12345')
+        Facter::Core::Execution.stubs(:exec).with("blkid /dev/#{part}").returns("/dev/#{part}: UUID=\"#{uuid}\" TYPE=\"ext4\"")
+      end
+
+      Facter::Core::Execution.stubs(:exec).with('mount').returns(my_fixture_read("mount"))
+    end
+
+    it '.list should return a list of partitions' do
+      Facter::Util::Partitions::Linux.list.should == ['sda1', 'sdb2', 'sdc3']
+    end
+
+    it '.uuid should return a string containing the uuid' do
+      Facter::Util::Partitions::Linux.uuid('sda1').should == '13459663-22cc-47b4-a9e6-21dea9906e03'
+      Facter::Util::Partitions::Linux.uuid('sdb2').should == '98043570-eb10-457f-9718-0b85a26e66bf'
+      Facter::Util::Partitions::Linux.uuid('sdc3').should == 'a35fb506-e831-4752-9899-dff6c601214b'
+    end
+
+    it '.size should return a string containing the size' do
+      Facter::Util::Partitions::Linux.size('sda1').should == '12345'
+    end
+
+    it '.mount should return a string containing the mount point of the partition' do
+      Facter::Util::Partitions::Linux.mount('sda1').should == '/home'
+      Facter::Util::Partitions::Linux.mount('sdb2').should == '/'
+      Facter::Util::Partitions::Linux.mount('sdc3').should == '/var'
+    end
+
+    it '.filesystem should return a string containing the filesystem on the partition' do
+      Facter::Util::Partitions::Linux.filesystem('sda1').should == 'ext4'
+      Facter::Util::Partitions::Linux.filesystem('sdb2').should == 'ext4'
+      Facter::Util::Partitions::Linux.filesystem('sdc3').should == 'ext4'
+    end
+  end
+end

data/spec/unit/util/partitions_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'facter'
+require 'facter/util/partitions'
+
+describe 'Facter::Util::Partitions' do
+  describe 'on unsupported OSs' do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    end
+    
+    it 'list should return empty array' do
+      Facter::Util::Partitions.list.should == []
+    end
+
+    it 'available? should return false' do
+      Facter::Util::Partitions.available?.should == false
+    end
+  end
+end

data/spec/unit/util/posix_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'facter/util/posix'
+
+describe Facter::Util::POSIX do
+  describe "retrieving values via sysctl" do
+    it "returns the result of the sysctl command" do
+      Facter::Util::Resolution.expects(:exec).with("sysctl -n hw.pagesize 2>/dev/null").returns("somevalue")
+      expect(described_class.sysctl("hw.pagesize")).to eq "somevalue"
+    end
+  end
+end

data/spec/unit/util/processor_spec.rb

@@ -0,0 +1,92 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/processor'
+require 'facter_spec/cpuinfo'
+
+describe Facter::Util::Processor do
+  describe "on linux" do
+    include FacterSpec::Cpuinfo
+
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+      File.stubs(:exists?).with("/proc/cpuinfo").returns(true)
+    end
+
+    describe "with architecture amd64" do
+      before :each do
+        Facter.fact(:architecture).stubs(:value).returns("amd64")
+      end
+
+      it "should get the processor description from the amd64solo fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64solo"))
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+      end
+
+      it "should get the processor descriptions from the amd64dual fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64dual"))
+
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+        Facter::Util::Processor.enum_cpuinfo[1].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+      end
+
+      it "should get the processor descriptions from the amd64tri fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64tri"))
+
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+        Facter::Util::Processor.enum_cpuinfo[1].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+        Facter::Util::Processor.enum_cpuinfo[2].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+      end
+
+      it "should get the processor descriptions from the amd64quad fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64quad"))
+
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+        Facter::Util::Processor.enum_cpuinfo[1].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+        Facter::Util::Processor.enum_cpuinfo[2].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+        Facter::Util::Processor.enum_cpuinfo[3].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+      end
+    end
+
+    describe "with architecture x86" do
+      before :each do
+        Facter.fact(:architecture).stubs(:value).returns("x86")
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(my_fixture_read("x86-pentium2").lines)
+      end
+
+      subject { Facter::Util::Processor.enum_cpuinfo }
+
+      it "should have the correct processor titles" do
+        subject[0].should == "Pentium II (Deschutes)"
+        subject[1].should == "Pentium II (Deschutes)"
+      end
+    end
+  end
+
+  describe "on Solaris" do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    end
+
+    it "should get the processor description on Solaris (x86)" do
+      Facter.fact(:architecture).stubs(:value).returns("i86pc")
+      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-i86pc"))
+
+      Facter::Util::Processor.enum_kstat[0].should == "Intel(r) Core(tm) i5 CPU       M 450  @ 2.40GHz"
+    end
+
+    it "should get the processor description on Solaris (SPARC64)" do
+      Facter.fact(:architecture).stubs(:value).returns("sun4u")
+      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-sun4u"))
+
+      Facter::Util::Processor.enum_kstat[0].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[1].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[2].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[3].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[4].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[5].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[6].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[7].should == "SPARC64-VII"
+    end
+  end
+end

data/spec/unit/util/registry_spec.rb

@@ -0,0 +1,76 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'facter/operatingsystem'
+require 'facter/util/registry'
+
+describe Facter::Util::Registry do
+  describe "hklm_read", :if => Facter::Util::Config.is_windows? do
+    before(:all) do
+      require 'win32/registry'
+    end
+    describe "valid params" do
+      [ {:key => "valid_key", :value => "valid_value",  :expected => "valid"},
+        {:key => "valid_key", :value => "",             :expected => "valid"},
+        {:key => "valid_key", :value => nil,            :expected => "invalid"},
+        {:key => "",          :value => "valid_value",  :expected => "valid"},
+        {:key => "",          :value => "",             :expected => "valid"},
+        {:key => "",          :value => nil,            :expected => "invalid"},
+        {:key => nil,         :value => "valid_value",  :expected => "invalid"},
+        {:key => nil,         :value => "",             :expected => "invalid"},
+        {:key => nil,         :value => nil,            :expected => "invalid"}
+      ].each do |scenario|
+        describe "with key #{scenario[:key] || "nil"} and value #{scenario[:value] || "nil"}" do
+          let :fake_registry_key do
+            fake = {}
+            fake[scenario[:value]] = scenario[:expected]
+            fake
+          end
+          it "should return #{scenario[:expected]} value" do
+            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).returns(fake_registry_key)
+            fake_registry_key.stubs(:close)
+
+            Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value]).should == scenario[:expected]
+          end
+        end
+      end
+    end
+
+    describe "invalid params" do
+      [ {:key => "valid_key",   :value => "invalid_value"},
+        {:key => "valid_key",   :value => ""},
+        {:key => "valid_key",   :value => nil},
+      ].each do |scenario|
+        describe "with valid key and value #{scenario[:value] || "nil"}" do
+          let :fake_registry_key do
+            {}
+          end
+          it "should raise an error" do
+            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).returns(fake_registry_key)
+            fake_registry_key.stubs(:close)
+
+            Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value]).should raise_error
+          end
+        end
+      end
+      [ {:key => "invalid_key", :value => "valid_value"},
+        {:key => "invalid_key", :value => ""},
+        {:key => "invalid_key", :value => nil},
+        {:key => "",            :value => "valid_value"},
+        {:key => "",            :value => ""},
+        {:key => "",            :value => nil},
+        {:key => nil,           :value => "valid_value"},
+        {:key => nil,           :value => ""},
+        {:key => nil,           :value => nil}
+      ].each do |scenario|
+        describe "with invalid key #{scenario[:key] || "nil"} and value #{scenario[:value] || "nil"}" do
+          it "should raise an error" do
+            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).raises(Win32::Registry::Error, 2)
+            expect do
+              Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value])
+            end.to raise_error Win32::Registry::Error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/resolution_spec.rb

@@ -0,0 +1,129 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/resolution'
+
+describe Facter::Util::Resolution do
+  include FacterSpec::ConfigHelper
+
+  subject(:resolution) { described_class.new(:foo, stub_fact) }
+
+  let(:stub_fact) { stub('fact', :name => :stubfact) }
+
+  it "requires a name" do
+    expect { Facter::Util::Resolution.new }.to raise_error(ArgumentError)
+  end
+
+  it "requires a fact" do
+    expect { Facter::Util::Resolution.new('yay') }.to raise_error(ArgumentError)
+  end
+
+  it "can return its name" do
+    expect(resolution.name).to eq :foo
+  end
+
+  it "can explicitly set a value" do
+    resolution.value = "foo"
+    expect(resolution.value).to eq "foo"
+  end
+
+  it "defaults to nil for code" do
+    expect(resolution.code).to be_nil
+  end
+
+  describe "when setting the code" do
+    before do
+      Facter.stubs(:warnonce)
+    end
+
+    it "creates a block when given a command" do
+      resolution.setcode "foo"
+      expect(resolution.code).to be_a_kind_of Proc
+    end
+
+    it "stores the provided block when given a block" do
+      block = lambda { }
+      resolution.setcode(&block)
+      resolution.code.should equal(block)
+    end
+
+
+    it "prefers a command over a block" do
+      block = lambda { }
+      resolution.setcode("foo", &block)
+      expect(resolution.code).to_not eq block
+    end
+
+    it "fails if neither a string nor block has been provided" do
+      expect { resolution.setcode }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "when returning the value" do
+    it "returns any value that has been provided" do
+      resolution.value = "foo"
+      expect(resolution.value).to eq "foo"
+    end
+
+    describe "and setcode has not been called" do
+      it "returns nil" do
+        expect(resolution.value).to be_nil
+      end
+    end
+
+    describe "and the code is a string" do
+      it "returns the result of executing the code" do
+        resolution.setcode "/bin/foo"
+        Facter::Core::Execution.expects(:execute).once.with("/bin/foo", anything).returns "yup"
+
+        expect(resolution.value).to eq "yup"
+      end
+    end
+
+    describe "and the code is a block" do
+      it "returns the value returned by the block" do
+        resolution.setcode { "yayness" }
+        expect(resolution.value).to eq "yayness"
+      end
+    end
+  end
+
+  describe "setting options" do
+    it "can set the value" do
+      resolution.set_options(:value => 'something')
+      expect(resolution.value).to eq 'something'
+    end
+
+    it "can set the timeout" do
+      resolution.set_options(:timeout => 314)
+      expect(resolution.limit).to eq 314
+    end
+
+    it "can set the weight" do
+      resolution.set_options(:weight => 27)
+      expect(resolution.weight).to eq 27
+    end
+
+    it "fails on unhandled options" do
+      expect do
+        resolution.set_options(:foo => 'bar')
+      end.to raise_error(ArgumentError, /Invalid resolution options.*foo/)
+    end
+  end
+
+  describe "evaluating" do
+    it "evaluates the block in the context of the given resolution" do
+      subject.expects(:has_weight).with(5)
+      subject.evaluate { has_weight(5) }
+    end
+
+    it "raises a warning if the resolution is evaluated twice" do
+      Facter.expects(:warn).with do |msg|
+        expect(msg).to match /Already evaluated foo at.*reevaluating anyways/
+      end
+
+      subject.evaluate { }
+      subject.evaluate { }
+    end
+  end
+end

data/spec/unit/util/solaris_zones_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'facter/util/solaris_zones'
+
+describe Facter::Util::SolarisZones do
+  let :zone_list do
+    zone_list = <<-EOF
+0:global:running:/::native:shared
+-:local:configured:/::native:shared
+-:zoneA:stopped:/::native:shared
+    EOF
+  end
+
+  let :zone_list2 do
+    zone_list = <<-EOF
+0:global:running:/::native:shared
+-:local:configured:/::native:shared
+-:zoneB:stopped:/::native:shared
+-:zoneC:stopped:/::native:shared
+    EOF
+  end
+
+  subject do
+    described_class.new(:zoneadm_output => zone_list)
+  end
+
+  describe '.add_facts' do
+    before :each do
+      zones = described_class.new(:zoneadm_output => zone_list)
+      zones.send(:parse!)
+      zones.stubs(:refresh)
+      described_class.stubs(:new).returns(zones)
+    end
+
+    it 'defines the zones fact' do
+      described_class.add_facts
+      Facter.fact(:zones).value.should == 3
+    end
+
+    it 'defines a fact for each attribute of a zone' do
+      described_class.add_facts
+      [:id, :name, :status, :path, :uuid, :brand, :iptype].each do |attr|
+        Facter.fact("zone_local_#{attr}".intern).
+          should be_a_kind_of Facter::Util::Fact
+      end
+    end
+  end
+
+  describe '#refresh' do
+    it 'executes the zoneadm_cmd' do
+      Facter::Core::Execution.expects(:execute).with(subject.zoneadm_cmd, {:on_fail => nil}).returns(zone_list)
+      subject.refresh
+    end
+  end
+
+  describe 'multiple facts sharing a single model' do
+    context 'when zones is resolved for the first time' do
+      it 'counts the number of zones' do
+        given_initial_zone_facts
+        Facter.fact(:zones).value.should == 3
+      end
+      it 'defines facts for zoneA' do
+        given_initial_zone_facts
+        Facter.fact(:zone_zoneA_id).value.should == '-'
+      end
+      it 'does not define facts for zoneB' do
+        given_initial_zone_facts
+        Facter.fact(:zone_zoneB_id).should be_nil
+      end
+      it 'uses a single read of the system information for all of the dynamically generated zone facts' do
+        given_initial_zone_facts # <= single read happens here
+
+        Facter::Core::Execution.expects(:execute).never
+        Facter.fact(:zone_zoneA_id).value
+        Facter.fact(:zone_local_id).value
+      end
+    end
+    context 'when all facts have been flushed after zones was resolved once' do
+      it 'updates the number of zones' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter.fact(:zones).value.should == 4
+      end
+      it 'stops resolving a value for a zone that no longer exists' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter.fact(:zone_zoneA_id).value.should be_nil
+        Facter.fact(:zone_zoneA_status).value.should be_nil
+        Facter.fact(:zone_zoneA_path).value.should be_nil
+      end
+      it 'defines facts for new zones' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter.fact(:zone_zoneB_id).should be_nil
+        Facter.fact(:zones).value
+        Facter.fact(:zone_zoneB_id).value.should be_a_kind_of String
+      end
+      it 'uses a single read of the system information for all of the dynamically generated zone facts' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter::Core::Execution.expects(:execute).once.returns(zone_list2)
+        Facter.fact(:zones).value
+        Facter.fact(:zone_zoneA_id).value
+        Facter.fact(:zone_local_id).value
+      end
+
+    end
+  end
+
+  def given_initial_zone_facts
+    Facter::Core::Execution.stubs(:execute).
+      with(subject.zoneadm_cmd, {:on_fail => nil}).
+      returns(zone_list)
+    described_class.add_facts
+  end
+
+  def when_facts_have_been_resolved_then_flushed
+    Facter.fact(:zones).value
+    Facter.fact(:zone_zoneA_id).value
+    Facter.fact(:zone_local_id).value
+    Facter::Core::Execution.stubs(:execute).returns(zone_list2)
+    Facter.flush
+  end
+end