facter 2.0.1.rc1-x86-mingw32

data/spec/unit/ec2_spec.rb

@@ -0,0 +1,187 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/ec2'
+
+describe "ec2 facts" do
+  # This is the standard prefix for making an API call in EC2 (or fake)
+  # environments.
+  let(:api_prefix) { "http://169.254.169.254" }
+
+  describe "when running on ec2" do
+    before :each do
+      # This is an ec2 instance, not a eucalyptus instance
+      Facter::Util::EC2.stubs(:has_euca_mac?).returns(false)
+      Facter::Util::EC2.stubs(:has_openstack_mac?).returns(false)
+      Facter::Util::EC2.stubs(:has_ec2_arp?).returns(true)
+
+      # Assume we can connect
+      Facter::Util::EC2.stubs(:can_connect?).returns(true)
+    end
+
+    it "should create flat meta-data facts" do
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/").
+        at_least_once.returns(StringIO.new("foo"))
+
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/foo").
+        at_least_once.returns(StringIO.new("bar"))
+
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_foo).value.should == "bar"
+    end
+
+    it "should create flat meta-data facts with comma seperation" do
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/").
+        at_least_once.returns(StringIO.new("foo"))
+
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/foo").
+        at_least_once.returns(StringIO.new("bar\nbaz"))
+
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_foo).value.should == "bar,baz"
+    end
+
+    it "should create structured meta-data facts" do
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/").
+        at_least_once.returns(StringIO.new("foo/"))
+
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/foo/").
+        at_least_once.returns(StringIO.new("bar"))
+
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/foo/bar").
+        at_least_once.returns(StringIO.new("baz"))
+
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_foo_bar).value.should == "baz"
+    end
+
+    it "should create ec2_user_data fact" do
+      # No meta-data
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/").
+        at_least_once.returns(StringIO.new(""))
+
+      Facter::Util::EC2.stubs(:read_uri).
+        with("#{api_prefix}/latest/user-data/").
+        returns("test")
+
+      Facter.collection.internal_loader.load(:ec2)
+      Facter.fact(:ec2_userdata).value.should == ["test"]
+    end
+  end
+
+  describe "when running on eucalyptus" do
+    before :each do
+      # Return false for ec2, true for eucalyptus
+      Facter::Util::EC2.stubs(:has_euca_mac?).returns(true)
+      Facter::Util::EC2.stubs(:has_openstack_mac?).returns(false)
+      Facter::Util::EC2.stubs(:has_ec2_arp?).returns(false)
+
+      # Assume we can connect
+      Facter::Util::EC2.stubs(:can_connect?).returns(true)
+    end
+
+    it "should create ec2_user_data fact" do
+      # No meta-data
+      Object.any_instance.expects(:open).\
+        with("#{api_prefix}/2008-02-01/meta-data/").\
+        at_least_once.returns(StringIO.new(""))
+
+      Facter::Util::EC2.stubs(:read_uri).
+        with("#{api_prefix}/latest/user-data/").
+        returns("test")
+
+      # Force a fact load
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_userdata).value.should == ["test"]
+    end
+  end
+
+  describe "when running on openstack" do
+    before :each do
+      # Return false for ec2, true for eucalyptus
+      Facter::Util::EC2.stubs(:has_openstack_mac?).returns(true)
+      Facter::Util::EC2.stubs(:has_euca_mac?).returns(false)
+      Facter::Util::EC2.stubs(:has_ec2_arp?).returns(false)
+
+      # Assume we can connect
+      Facter::Util::EC2.stubs(:can_connect?).returns(true)
+    end
+
+    it "should create ec2_user_data fact" do
+      # No meta-data
+      Object.any_instance.expects(:open).\
+        with("#{api_prefix}/2008-02-01/meta-data/").\
+        at_least_once.returns(StringIO.new(""))
+
+      Facter::Util::EC2.stubs(:read_uri).
+        with("#{api_prefix}/latest/user-data/").
+        returns("test")
+
+      # Force a fact load
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_userdata).value.should == ["test"]
+    end
+
+    it "should return nil if open fails" do
+      Facter.stubs(:warn) # do not pollute test output
+      Facter.expects(:warn).with('Could not retrieve ec2 metadata: host unreachable')
+
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/").
+        at_least_once.raises(RuntimeError, 'host unreachable')
+
+      Facter::Util::EC2.stubs(:read_uri).
+        with("#{api_prefix}/latest/user-data/").
+        raises(RuntimeError, 'host unreachable')
+
+      # Force a fact load
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_userdata).value.should be_nil
+    end
+
+  end
+
+  describe "when api connect test fails" do
+    before :each do
+      Facter.stubs(:warnonce)
+    end
+
+    it "should not populate ec2_userdata" do
+      # Emulate ec2 for now as it matters little to this test
+      Facter::Util::EC2.stubs(:has_euca_mac?).returns(true)
+      Facter::Util::EC2.stubs(:has_ec2_arp?).never
+      Facter::Util::EC2.expects(:can_connect?).at_least_once.returns(false)
+
+      # The API should never be called at this point
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/meta-data/").never
+      Object.any_instance.expects(:open).
+        with("#{api_prefix}/2008-02-01/user-data/").never
+
+      # Force a fact load
+      Facter.collection.internal_loader.load(:ec2)
+
+      Facter.fact(:ec2_userdata).should == nil
+    end
+
+    it "should rescue the exception" do
+      Facter::Util::EC2.expects(:open).with("#{api_prefix}:80/").raises(Timeout::Error)
+
+      Facter::Util::EC2.should_not be_can_connect
+    end
+  end
+end

data/spec/unit/facter_spec.rb

@@ -0,0 +1,108 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Facter do
+  it "caches the collection" do
+    Facter.collection.should equal(Facter.collection)
+  end
+
+  describe "methods on the collection" do
+    it "delegates the :flush method to the collection" do
+      Facter.collection.expects(:flush)
+      Facter.flush
+    end
+
+    it "delegates the :fact method to the collection" do
+      Facter.collection.expects(:fact).with("afact")
+      Facter.fact("afact")
+    end
+
+    it "delegates the :list method to the collection" do
+      Facter.collection.expects(:list)
+      Facter.list
+    end
+
+    it "loads all facts when listing" do
+      Facter.collection.expects(:load_all)
+      Facter.list
+    end
+
+    it "delegates the :to_hash method to the collection" do
+      Facter.collection.expects(:to_hash)
+      Facter.to_hash
+    end
+
+    it "loads all facts when calling :to_hash" do
+      Facter.collection.expects(:load_all)
+      Facter.collection.stubs(:to_hash)
+      Facter.to_hash
+    end
+
+    it "delegates the :value method to the collection" do
+      Facter.collection.expects(:value).with("myvaluefact")
+      Facter.value("myvaluefact")
+    end
+
+    it "delegates the :each method to the collection" do
+      Facter.collection.expects(:each)
+      Facter.each
+    end
+
+    it "delegates the :add method to the collection" do
+      Facter.collection.expects(:add).with("factname", {})
+      Facter.add("factname")
+    end
+
+    it "delegates the :define_fact method to the collection" do
+      Facter.collection.expects(:define_fact).with("factname", {})
+      Facter.define_fact("factname")
+    end
+
+    it "loads all facts when calling :each" do
+      Facter.collection.expects(:load_all)
+      Facter.collection.stubs(:each)
+      Facter.each
+    end
+  end
+
+  it "yields to the block when using :each" do
+    Facter.collection.stubs(:load_all)
+    Facter.collection.stubs(:each).yields "foo"
+    result = []
+    Facter.each { |f| result << f }
+    result.should == %w{foo}
+  end
+
+  describe "when registering directories to search" do
+    after { Facter.reset_search_path! }
+
+    it "allows registration of a directory" do
+      Facter.search "/my/dir"
+    end
+
+    it "allows registration of multiple directories" do
+      Facter.search "/my/dir", "/other/dir"
+    end
+
+    it "returns all registered directories when asked" do
+      Facter.search "/my/dir", "/other/dir"
+      Facter.search_path.should == %w{/my/dir /other/dir}
+    end
+  end
+
+  describe "when registering directories to search for external facts" do
+    it "allows registration of a directory" do
+      Facter.search_external ["/my/dir"]
+    end
+
+    it "allows registration of multiple directories" do
+      Facter.search_external ["/my/dir", "/other/dir"]
+    end
+
+    it "returns all registered directories when asked" do
+      Facter.search_external ["/my/dir", "/other/dir"]
+      Facter.search_external_path.should include("/my/dir", "/other/dir")
+    end
+  end
+end

data/spec/unit/filesystems_spec.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe 'Filesystem facts' do
+  describe 'on non-Linux OS' do
+    it 'should not exist' do
+      Facter.fact(:kernel).stubs(:value).returns('SunOS')
+      Facter.fact(:filesystems).value.should == nil
+    end
+  end
+
+  describe 'on Linux' do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns('Linux')
+      fixture_data = my_fixture_read('linux')
+      Facter::Core::Execution.expects(:exec) \
+        .with('cat /proc/filesystems 2> /dev/null').returns(fixture_data)
+      Facter.collection.internal_loader.load(:filesystems)
+    end
+
+    after :each do
+      Facter.clear
+    end
+
+    it 'should exist' do
+      Facter.fact(:filesystems).value.should_not == nil
+    end
+
+    it 'should detect the correct number of filesystems' do
+      Facter.fact(:filesystems).value.split(',').length.should == 6
+    end
+
+    # Check that lines from /proc/filesystems that start with 'nodev' are
+    # skipped
+    it 'should not detect sysfs' do
+      Facter.fact(:filesystems).value.split(',').should_not include('sysfs')
+    end
+
+    # Check that all other lines are counted as valid filesystems
+    it 'should detect ext4' do
+      Facter.fact(:filesystems).value.split(',').should include('ext4')
+    end
+
+    # fuseblk is never included in the filesystem list
+    it 'should not detect fuseblk' do
+      Facter.fact(:filesystems).value.split(',').should_not include('fuseblk')
+    end
+  end
+end

data/spec/unit/hardwareisa_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "Hardwareisa fact" do
+  it "should match uname -p on Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter::Core::Execution.stubs(:exec).with("uname -p").returns("Inky")
+
+    Facter.fact(:hardwareisa).value.should == "Inky"
+  end
+
+  it "should match uname -p on Darwin" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Core::Execution.stubs(:exec).with("uname -p").returns("Blinky")
+
+    Facter.fact(:hardwareisa).value.should == "Blinky"
+  end
+
+  it "should match uname -p on SunOS" do
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    Facter::Core::Execution.stubs(:exec).with("uname -p").returns("Pinky")
+
+    Facter.fact(:hardwareisa).value.should == "Pinky"
+  end
+
+  it "should match uname -p on FreeBSD" do
+    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+    Facter::Core::Execution.stubs(:exec).with("uname -p").returns("Clyde")
+
+    Facter.fact(:hardwareisa).value.should == "Clyde"
+  end
+
+  it "should match uname -m on HP-UX" do
+    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+    Facter::Core::Execution.stubs(:exec).with("uname -m").returns("Pac-Man")
+
+    Facter.fact(:hardwareisa).value.should == "Pac-Man"
+  end
+end

data/spec/unit/hardwaremodel_spec.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "Hardwaremodel fact" do
+  it "should match uname -m by default" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Core::Execution.stubs(:exec).with("uname -m").returns("Inky")
+
+    Facter.fact(:hardwaremodel).value.should == "Inky"
+  end
+
+  describe "on Windows" do
+    require 'facter/util/wmi'
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("windows")
+    end
+
+    it "should detect i486" do
+      cpu = mock('cpu', :Architecture => 0)
+      cpu.expects(:Level).returns(4).twice
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i486"
+    end    
+
+    it "should detect i686" do
+      cpu = mock('cpu', :Architecture => 0, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+
+    it "should detect x64" do
+      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 64, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "x64"
+    end
+
+    it "(#16948) reports i686 when a 32 bit OS is running on a 64 bit CPU" do
+      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 32, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+
+    it "(#20989) should report i686 when a 32 bit OS is running on a 64 bit CPU and when level is greater than 6 (and not something like i1586)" do
+      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 32, :Level => 15)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+  end
+end

data/spec/unit/hostname_spec.rb

@@ -0,0 +1,40 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "Hostname facts" do
+
+  describe "on linux" do
+    before do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+      Facter.fact(:kernelrelease).stubs(:value).returns("2.6")
+    end
+
+    it "should use the hostname command" do
+      Facter::Core::Execution.expects(:exec).with('hostname').at_least_once
+      Facter.fact(:hostname).value.should be_nil
+    end
+
+    it "should use hostname as the fact if unqualified" do
+      Facter::Core::Execution.stubs(:exec).with('hostname').returns('host1')
+      Facter.fact(:hostname).value.should == "host1"
+    end
+
+    it "should truncate the domain name if qualified" do
+      Facter::Core::Execution.stubs(:exec).with('hostname').returns('host1.example.com')
+      Facter.fact(:hostname).value.should == "host1"
+    end
+  end
+
+  describe "on darwin release R7" do
+    before do
+      Facter.fact(:kernel).stubs(:value).returns("Darwin")
+      Facter.fact(:kernelrelease).stubs(:value).returns("R7")
+    end
+
+    it "should use scutil to get the hostname" do
+      Facter::Core::Execution.expects(:exec).with('/usr/sbin/scutil --get LocalHostName').returns("host1")
+      Facter.fact(:hostname).value.should == "host1"
+    end
+  end
+end