facter 1.5 → 1.5.2

data/lib/facter/virtual.rb

@@ -0,0 +1,62 @@
+Facter.add("virtual") do
+  confine :kernel => %w{Linux FreeBSD OpenBSD}
+  
+  ENV["PATH"]="/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/sbin:/usr/local/bin"
+  
+  result = "physical"
+  
+  setcode do 
+
+    if FileTest.exists?("/proc/user_beancounters")
+      result = "openvz"
+    end
+
+    if FileTest.exists?("/proc/xen/capabilities") && FileTest.readable?("/proc/xen/capabilities")
+      txt = File.read("/proc/xen/capabilities")
+      if txt =~ /control_d/i
+        result = "xen0"
+      else
+        result = "xenu" 
+      end
+    end
+
+    if result == "physical"
+      lspciexists = system "which lspci > /dev/null 2>&1"
+      if $?.exitstatus == 0
+        output = %x{lspci}
+        output.each {|p|
+          # --- look for the vmware video card to determine if it is virtual => vmware.
+          # ---     00:0f.0 VGA compatible controller: VMware Inc [VMware SVGA II] PCI Display Adapter
+          result = "vmware" if p =~ /VM[wW]are/
+        }
+      else
+        dmidecodeexists = system "which dmidecode > /dev/null 2>&1"
+        if $?.exitstatus == 0
+          outputd = %x{dmidecode}
+          outputd.each {|pd|
+            result = "vmware" if pd =~ /VMware|Parallels/
+          }
+        end
+      end
+    end
+
+    # VMware server 1.0.3 rpm places vmware-vmx in this place, other versions or platforms may not.
+    if FileTest.exists?("/usr/lib/vmware/bin/vmware-vmx")
+      result = "vmware_server"
+    end
+
+    mountexists = system "which mount > /dev/null 2>&1"
+    if $?.exitstatus == 0
+      output = %x{mount}
+      output.each {|p|
+        result = "vserver" if p =~ /\/dev\/hdv1/
+      }
+    end
+
+    if FileTest.directory?('/proc/virtual')
+      result = "vserver_host"
+    end
+
+    result
+  end
+end

data/spec/Rakefile

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'rake'
+require 'spec/rake/spectask'
+
+basedir = File.dirname(__FILE__)
+puppetlibdir = File.join(basedir, "../lib")
+puppettestlibdir = File.join(basedir, "../test/lib")
+speclibdir = File.join(basedir, "lib")
+
+libs = [puppetlibdir, puppettestlibdir, speclibdir]
+desc "Run all specs"
+Spec::Rake::SpecTask.new('all') do |t|
+    t.spec_files = FileList['integration/**/*.rb', 'unit/**/*.rb']
+    t.libs = libs
+    t.spec_opts = ['--options', 'spec.opts']
+end
+
+task :default => [:all]

data/spec/integration/facter.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Facter do
+    before do
+        Facter.reset
+    end
+
+    after do
+        Facter.reset
+    end
+
+    it "should create a new collection if one does not exist" do
+        Facter.reset
+        coll = mock('coll')
+        Facter::Util::Collection.stubs(:new).returns coll
+        Facter.collection.should equal(coll)
+        Facter.reset
+    end
+
+    it "should remove the collection when reset" do
+        old = Facter.collection
+        Facter.reset
+        Facter.collection.should_not equal(old)
+    end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+dir = File.expand_path(File.dirname(__FILE__))
+
+$LOAD_PATH.unshift("#{dir}/")
+$LOAD_PATH.unshift("#{dir}/../lib")
+
+# include any gems in vendor/gems
+Dir["#{dir}/../vendor/gems/**"].each do |path| 
+    libpath = File.join(path, "lib")
+    if File.directory?(libpath)
+        $LOAD_PATH.unshift(libpath)
+    else
+        $LOAD_PATH.unshift(path)
+    end
+end
+
+require 'mocha'
+require 'spec'
+require 'facter'
+
+# load any monkey-patches
+Dir["#{dir}/monkey_patches/*.rb"].map { |file| require file }
+
+Spec::Runner.configure do |config|
+    config.mock_with :mocha
+end

data/spec/unit/data/linux_ifconfig_all_with_single_interface

@@ -0,0 +1,18 @@
+eth0      Link encap:Ethernet  HWaddr 00:0c:29:52:15:e9  
+          inet addr:172.16.15.133  Bcast:172.16.15.255  Mask:255.255.255.0
+          inet6 addr: fe80::20c:29ff:fe52:15e9/64 Scope:Link
+          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
+          RX packets:173 errors:173 dropped:0 overruns:0 frame:0
+          TX packets:208 errors:0 dropped:0 overruns:0 carrier:0
+          collisions:0 txqueuelen:1000 
+          RX bytes:40970 (40.0 KB)  TX bytes:24760 (24.1 KB)
+          Interrupt:16 Base address:0x2024 
+
+lo        Link encap:Local Loopback  
+          inet addr:127.0.0.1  Mask:255.0.0.0
+          inet6 addr: ::1/128 Scope:Host
+          UP LOOPBACK RUNNING  MTU:16436  Metric:1
+          RX packets:1630 errors:0 dropped:0 overruns:0 frame:0
+          TX packets:1630 errors:0 dropped:0 overruns:0 carrier:0
+          collisions:0 txqueuelen:0 
+          RX bytes:81500 (79.5 KB)  TX bytes:81500 (79.5 KB)

data/spec/unit/data/solaris_ifconfig_single_interface

@@ -0,0 +1,3 @@
+e1000g0: flags=201004843<UP,BROADCAST,RUNNING,MULTICAST,DHCP,IPv4,CoS> mtu 1500 index 2
+        inet 172.16.15.138 netmask ffffff00 broadcast 172.16.15.255
+        ether 0:c:29:c1:70:2a

data/spec/unit/facter.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Facter do
+    
+    it "should have a version" do
+        Facter.version.should =~ /^[0-9]+(\.[0-9]+)*$/
+    end
+
+    it "should have a method for returning its collection" do
+        Facter.should respond_to(:collection)
+    end
+
+    it "should cache the collection" do
+        Facter.collection.should equal(Facter.collection)
+    end
+
+    it "should delegate the :flush method to the collection" do
+        Facter.collection.expects(:flush)
+        Facter.flush
+    end
+
+    it "should delegate the :fact method to the collection" do
+        Facter.collection.expects(:fact)
+        Facter.fact
+    end
+
+    it "should delegate the :list method to the collection" do
+        Facter.collection.expects(:list)
+        Facter.list
+    end
+
+    it "should load all facts when listing" do
+        Facter.collection.expects(:load_all)
+        Facter.collection.stubs(:list)
+        Facter.list
+    end
+
+    it "should delegate the :to_hash method to the collection" do
+        Facter.collection.expects(:to_hash)
+        Facter.to_hash
+    end
+
+    it "should load all facts when calling :to_hash" do
+        Facter.collection.expects(:load_all)
+        Facter.collection.stubs(:to_hash)
+        Facter.to_hash
+    end
+
+    it "should delegate the :value method to the collection" do
+        Facter.collection.expects(:value)
+        Facter.value
+    end
+
+    it "should delegate the :each method to the collection" do
+        Facter.collection.expects(:each)
+        Facter.each
+    end
+
+    it "should load all facts when calling :each" do
+        Facter.collection.expects(:load_all)
+        Facter.collection.stubs(:each)
+        Facter.each
+    end
+
+    it "should yield 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 provided code as a string" do
+        it "should execute the code in the shell" do
+            Facter.add("shell_testing") do
+                setcode "echo yup"
+            end
+
+            Facter["shell_testing"].value.should == "yup"
+        end
+    end
+
+    describe "when passed code as a block" do
+        it "should execute the provided block" do
+            Facter.add("block_testing") { setcode { "foo" } }
+
+            Facter["block_testing"].value.should == "foo"
+        end
+    end
+
+    describe Facter[:hostname] do
+        it "should have its ldapname set to 'cn'" do
+            Facter[:hostname].ldapname.should == "cn"
+        end
+    end
+
+    describe Facter[:ipaddress] do
+        it "should have its ldapname set to 'iphostnumber'" do
+            Facter[:ipaddress].ldapname.should == "iphostnumber"
+        end
+    end
+
+    # #33 Make sure we only get one mac address
+    it "should only return one mac address" do
+        Facter.value(:macaddress).should_not be_include(" ")
+    end
+
+    it "should have a method for registering directories to search" do
+        Facter.should respond_to(:search)
+    end
+
+    it "should have a method for returning the registered search directories" do
+        Facter.should respond_to(:search_path)
+    end
+
+    describe "when registering directories to search" do
+        after { Facter.instance_variable_set("@search_path", []) }
+
+        it "should allow registration of a directory" do
+            Facter.search "/my/dir"
+        end
+
+        it "should allow registration of multiple directories" do
+            Facter.search "/my/dir", "/other/dir"
+        end
+
+        it "should return all registered directories when asked" do
+            Facter.search "/my/dir", "/other/dir"
+            Facter.search_path.should == %w{/my/dir /other/dir}
+        end
+    end
+end

data/spec/unit/util/collection.rb

@@ -0,0 +1,255 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'facter/util/collection'
+
+describe Facter::Util::Collection do
+    it "should have a method for adding facts" do
+        Facter::Util::Collection.new.should respond_to(:add)
+    end
+
+    it "should have a method for returning a loader" do
+        Facter::Util::Collection.new.should respond_to(:loader)
+    end
+
+    it "should use an instance of the Loader class as its loader" do
+        Facter::Util::Collection.new.loader.should be_instance_of(Facter::Util::Loader)
+    end
+
+    it "should cache its loader" do
+        coll = Facter::Util::Collection.new
+        coll.loader.should equal(coll.loader)
+    end
+
+    it "should have a method for loading all facts" do
+        Facter::Util::Collection.new.should respond_to(:load_all)
+    end
+
+    it "should delegate its load_all method to its loader" do
+        coll = Facter::Util::Collection.new
+        coll.loader.expects(:load_all)
+        coll.load_all
+    end
+
+    describe "when adding facts" do
+        before do
+            @coll = Facter::Util::Collection.new
+        end
+
+        it "should create a new fact if no fact with the same name already exists" do
+            fact = mock 'fact'
+            Facter::Util::Fact.expects(:new).with { |name, *args| name == :myname }.returns fact
+
+            @coll.add(:myname)
+        end
+
+        it "should accept options" do
+            @coll.add(:myname, :ldapname => "whatever") { }
+        end
+
+        it "should set any appropriate options on the fact instances" do
+            # Use a real fact instance, because we're using respond_to?
+            fact = Facter::Util::Fact.new(:myname)
+            fact.expects(:ldapname=).with("testing")
+            Facter::Util::Fact.expects(:new).with(:myname).returns fact
+
+            @coll.add(:myname, :ldapname => "testing")
+        end
+
+        it "should set appropriate options on the resolution instance" do
+            fact = Facter::Util::Fact.new(:myname)
+            Facter::Util::Fact.expects(:new).with(:myname).returns fact
+
+            resolve = Facter::Util::Resolution.new(:myname) {}
+            fact.expects(:add).returns resolve
+
+            @coll.add(:myname, :timeout => "myval") {}
+        end
+
+        it "should not pass fact-specific options to resolutions" do
+            fact = Facter::Util::Fact.new(:myname)
+            Facter::Util::Fact.expects(:new).with(:myname).returns fact
+
+            resolve = Facter::Util::Resolution.new(:myname) {}
+            fact.expects(:add).returns resolve
+
+            fact.expects(:ldapname=).with("foo")
+            resolve.expects(:timeout=).with("myval")
+
+            @coll.add(:myname, :timeout => "myval", :ldapname => "foo") {}
+        end
+
+        it "should fail if invalid options are provided" do
+            lambda { @coll.add(:myname, :foo => :bar) }.should raise_error(ArgumentError)
+        end
+
+        describe "and a block is provided" do
+            it "should use the block to add a resolution to the fact" do
+                fact = mock 'fact'
+                Facter::Util::Fact.expects(:new).returns fact
+
+                fact.expects(:add)
+
+                @coll.add(:myname) {}
+            end
+        end
+    end
+
+    it "should have a method for retrieving facts by name" do
+        Facter::Util::Collection.new.should respond_to(:fact)
+    end
+
+    describe "when retrieving facts" do
+        before do
+            @coll = Facter::Util::Collection.new
+
+            @fact = @coll.add("YayNess")
+        end
+
+        it "should return the fact instance specified by the name" do
+            @coll.fact("YayNess").should equal(@fact)
+        end
+
+        it "should be case-insensitive" do
+            @coll.fact("yayness").should equal(@fact)
+        end
+        
+        it "should treat strings and symbols equivalently" do
+            @coll.fact(:yayness).should equal(@fact)
+        end
+
+        it "should use its loader to try to load the fact if no fact can be found" do
+            @coll.loader.expects(:load).with(:testing)
+            @coll.fact("testing")
+        end
+
+        it "should return nil if it cannot find or load the fact" do
+            @coll.loader.expects(:load).with(:testing)
+            @coll.fact("testing").should be_nil
+        end
+    end
+
+    it "should have a method for returning a fact's value" do
+        Facter::Util::Collection.new.should respond_to(:value)
+    end
+
+    describe "when returning a fact's value" do
+        before do
+            @coll = Facter::Util::Collection.new
+            @fact = @coll.add("YayNess")
+
+            @fact.stubs(:value).returns "result"
+        end
+
+        it "should use the 'fact' method to retrieve the fact" do
+            @coll.expects(:fact).with(:yayness).returns @fact
+            @coll.value(:yayness)
+        end
+
+        it "should return the result of calling :value on the fact" do
+            @fact.expects(:value).returns "result"
+
+            @coll.value("YayNess").should == "result"
+        end
+
+        it "should be case-insensitive" do
+            @coll.value("yayness").should_not be_nil
+        end
+        
+        it "should treat strings and symbols equivalently" do
+            @coll.value(:yayness).should_not be_nil
+        end
+    end
+
+    it "should return the fact's value when the array index method is used" do
+        @coll = Facter::Util::Collection.new
+        @coll.expects(:value).with("myfact").returns "foo"
+        @coll["myfact"].should == "foo"
+    end
+
+    it "should have a method for flushing all facts" do
+        @coll = Facter::Util::Collection.new
+        @fact = @coll.add("YayNess")
+
+        @fact.expects(:flush)
+
+        @coll.flush
+    end
+
+    it "should have a method that returns all fact names" do
+        @coll = Facter::Util::Collection.new
+        @coll.add(:one)
+        @coll.add(:two)
+
+        @coll.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
+    end
+
+    it "should have a method for returning a hash of fact values" do
+        Facter::Util::Collection.new.should respond_to(:to_hash)
+    end
+
+    describe "when returning a hash of values" do
+        before do
+            @coll = Facter::Util::Collection.new
+            @fact = @coll.add(:one)
+            @fact.stubs(:value).returns "me"
+        end
+
+        it "should return a hash of fact names and values with the fact names as strings" do
+            @coll.to_hash.should == {"one" => "me"}
+        end
+
+        it "should not include facts that did not return a value" do
+            f = @coll.add(:two)
+            f.stubs(:value).returns nil
+            @coll.to_hash.should_not be_include(:two)
+        end
+    end
+
+    it "should have a method for iterating over all facts" do
+        Facter::Util::Collection.new.should respond_to(:each)
+    end
+
+    it "should include Enumerable" do
+        Facter::Util::Collection.ancestors.should be_include(Enumerable)
+    end
+
+    describe "when iterating over facts" do
+        before do
+            @coll = Facter::Util::Collection.new
+            @one = @coll.add(:one)
+            @two = @coll.add(:two)
+        end
+
+        it "should yield each fact name and the fact value" do
+            @one.stubs(:value).returns "ONE"
+            @two.stubs(:value).returns "TWO"
+            facts = {}
+            @coll.each do |fact, value|
+                facts[fact] = value
+            end
+            facts.should == {"one" => "ONE", "two" => "TWO"}
+        end
+
+        it "should convert the fact name to a string" do
+            @one.stubs(:value).returns "ONE"
+            @two.stubs(:value).returns "TWO"
+            facts = {}
+            @coll.each do |fact, value|
+                fact.should be_instance_of(String)
+            end
+        end
+
+        it "should only yield facts that have values" do
+            @one.stubs(:value).returns "ONE"
+            @two.stubs(:value).returns nil
+            facts = {}
+            @coll.each do |fact, value|
+                facts[fact] = value
+            end
+
+            facts.should_not be_include("two")
+        end
+    end
+end