facter 1.5 → 1.5.2

data/spec/unit/util/confine.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'facter/util/confine'
+
+describe Facter::Util::Confine do
+    it "should require a fact name" do
+        Facter::Util::Confine.new("yay", true).fact.should == "yay"
+    end
+
+    it "should accept a value specified individually" do
+        Facter::Util::Confine.new("yay", "test").values.should == ["test"]
+    end
+
+    it "should accept multiple values specified at once" do
+        Facter::Util::Confine.new("yay", "test", "other").values.should == ["test", "other"]
+    end
+
+    it "should convert all values to strings" do
+        Facter::Util::Confine.new("yay", :test).values.should == %w{test}
+    end
+
+    it "should fail if no fact name is provided" do
+        lambda { Facter::Util::Confine.new(nil, :test) }.should raise_error(ArgumentError)
+    end
+
+    it "should fail if no values were provided" do
+        lambda { Facter::Util::Confine.new("yay") }.should raise_error(ArgumentError)
+    end
+
+    it "should have a method for testing whether it matches" do
+        Facter::Util::Confine.new("yay", :test).should respond_to(:true?)
+    end
+
+    describe "when evaluating" do
+        before do
+            @confine = Facter::Util::Confine.new("yay", "one", "two")
+            @fact = mock 'fact'
+            Facter.stubs(:[]).returns @fact
+        end
+
+        it "should return false if the fact does not exist" do
+            Facter.expects(:[]).with("yay").returns nil
+
+            @confine.true?.should be_false
+        end
+
+        it "should use the returned fact to get the value" do
+            Facter.expects(:[]).with("yay").returns @fact
+
+            @fact.expects(:value).returns nil
+
+            @confine.true?
+        end
+
+        it "should return false if the fact has no value" do
+            @fact.stubs(:value).returns nil
+
+            @confine.true?.should be_false
+        end
+
+        it "should return true if any of the provided values matches the fact's value" do
+            @fact.stubs(:value).returns "two"
+
+            @confine.true?.should be_true
+        end
+
+        it "should return false if none of the provided values matches the fact's value" do
+            @fact.stubs(:value).returns "three"
+
+            @confine.true?.should be_false
+        end
+    end
+end

data/spec/unit/util/fact.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'facter/util/fact'
+
+describe Facter::Util::Fact do
+    it "should require a name" do
+        lambda { Facter::Util::Fact.new }.should raise_error(ArgumentError)
+    end
+
+    it "should always downcase the name and convert it to a symbol" do
+        Facter::Util::Fact.new("YayNess").name.should == :yayness
+    end
+
+    it "should default to its name converted to a string as its ldapname" do
+        Facter::Util::Fact.new("YayNess").ldapname.should == "yayness"
+    end
+
+    it "should allow specifying the ldap name at initialization" do
+        Facter::Util::Fact.new("YayNess", :ldapname => "fooness").ldapname.should == "fooness"
+    end
+
+    it "should fail if an unknown option is provided" do
+        lambda { Facter::Util::Fact.new('yay', :foo => :bar) }.should raise_error(ArgumentError)
+    end
+
+    it "should have a method for adding resolution mechanisms" do
+        Facter::Util::Fact.new("yay").should respond_to(:add)
+    end
+
+    describe "when adding resolution mechanisms" do
+        before do
+            @fact = Facter::Util::Fact.new("yay")
+
+            @resolution = mock 'resolution'
+            @resolution.stub_everything
+
+        end
+
+        it "should fail if no block is given" do
+            lambda { @fact.add }.should raise_error(ArgumentError)
+        end
+
+        it "should create a new resolution instance" do
+            Facter::Util::Resolution.expects(:new).returns @resolution
+
+            @fact.add { }
+        end
+
+        it "should instance_eval the passed block on the new resolution" do
+            @resolution.expects(:instance_eval)
+
+            Facter::Util::Resolution.stubs(:new).returns @resolution
+
+            @fact.add { }
+        end
+
+        it "should re-sort the resolutions by length, so the most restricted resolutions are first" do
+            r1 = stub 'r1', :length => 1
+            r2 = stub 'r2', :length => 2
+            r3 = stub 'r3', :length => 0
+            Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
+            @fact.add { }
+            @fact.add { }
+            @fact.add { }
+
+            @fact.instance_variable_get("@resolves").should == [r2, r1, r3]
+        end
+    end
+
+    it "should be able to return a value" do
+        Facter::Util::Fact.new("yay").should respond_to(:value)
+    end
+
+    describe "when returning a value" do
+        before do
+            @fact = Facter::Util::Fact.new("yay")
+        end
+
+        it "should return nil if there are no resolutions" do
+            Facter::Util::Fact.new("yay").value.should be_nil
+        end
+
+        it "should return the first value returned by a resolution" do
+            r1 = stub 'r1', :length => 2, :value => nil, :suitable? => true
+            r2 = stub 'r2', :length => 1, :value => "yay", :suitable? => true
+            r3 = stub 'r3', :length => 0, :value => "foo", :suitable? => true
+            Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
+            @fact.add { }
+            @fact.add { }
+            @fact.add { }
+
+            @fact.value.should == "yay"
+        end
+
+        it "should short-cut returning the value once one is found" do
+            r1 = stub 'r1', :length => 2, :value => "foo", :suitable? => true
+            r2 = stub 'r2', :length => 1, :suitable? => true # would fail if 'value' were asked for
+            Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
+            @fact.add { }
+            @fact.add { }
+
+            @fact.value
+        end
+
+        it "should skip unsuitable resolutions" do
+            r1 = stub 'r1', :length => 2, :suitable? => false # would fail if 'value' were asked for'
+            r2 = stub 'r2', :length => 1, :value => "yay", :suitable? => true
+            Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
+            @fact.add { }
+            @fact.add { }
+
+            @fact.value.should == "yay"
+        end
+
+        it "should return nil if the value is the empty string" do
+            r1 = stub 'r1', :suitable? => true, :value => ""
+            Facter::Util::Resolution.expects(:new).returns r1
+            @fact.add { }
+
+            @fact.value.should be_nil
+        end
+    end
+
+    it "should have a method for flushing the cached fact" do
+        Facter::Util::Fact.new(:foo).should respond_to(:flush)
+    end
+end

data/spec/unit/util/ip.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'facter/util/ip'
+
+describe Facter::IPAddress do
+
+    it "should return a list of interfaces" do
+       Facter::IPAddress.should respond_to(:get_interfaces)
+    end
+
+    it "should return an empty list of interfaces on an unknown kernel" do
+        Facter.stubs(:value).returns("UnknownKernel")
+        Facter::IPAddress.get_interfaces().should == []
+    end
+
+    it "should return a list with a single interface on Linux with a single interface" do
+        sample_output_file = File.dirname(__FILE__) + '/../data/linux_ifconfig_all_with_single_interface'
+        linux_ifconfig = File.new(sample_output_file).read()
+        Facter::IPAddress.stubs(:get_all_interface_output).returns(linux_ifconfig)
+        Facter::IPAddress.get_interfaces().should == ["eth0"]
+    end
+
+    it "should return a value for a specific interface" do
+       Facter::IPAddress.should respond_to(:get_interface_value)
+    end
+
+    it "should return a human readable netmask on Solaris" do
+        sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
+        solaris_ifconfig_interface = File.new(sample_output_file).read()
+
+        Facter::IPAddress.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+        Facter.stubs(:value).with(:kernel).returns("SunOS")
+
+        Facter::IPAddress.get_interface_value("e1000g0", "netmask").should == "255.255.255.0"
+    end
+
+end
+

data/spec/unit/util/loader.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'facter/util/loader'
+
+describe Facter::Util::Loader do
+    def with_env(values)
+        old = {}
+        values.each do |var, value|
+            if old_val = ENV[var]
+                old[var] = old_val
+            end
+            ENV[var] = value
+        end
+        yield
+        values.each do |var, value|
+            if old.include?(var)
+                ENV[var] = old[var]
+            else
+                ENV.delete(var)
+            end
+        end
+    end
+
+    it "should have a method for loading individual facts by name" do
+        Facter::Util::Loader.new.should respond_to(:load)
+    end
+
+    it "should have a method for loading all facts" do
+        Facter::Util::Loader.new.should respond_to(:load_all)
+    end
+
+    it "should have a method for returning directories containing facts" do
+        Facter::Util::Loader.new.should respond_to(:search_path)
+    end
+
+    describe "when determining the search path" do
+        before do
+            @loader = Facter::Util::Loader.new
+            @settings = mock 'settings'
+            @settings.stubs(:value).returns "/eh"
+        end
+
+        it "should include the facter subdirectory of all paths in ruby LOAD_PATH" do
+            dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
+            paths = @loader.search_path
+
+            dirs.each do |dir|
+                paths.should be_include(dir)
+            end
+        end
+
+        it "should include all search paths registered with Facter" do
+            Facter.expects(:search_path).returns %w{/one /two}
+            paths = @loader.search_path
+            paths.should be_include("/one")
+            paths.should be_include("/two")
+        end
+
+        describe "and the FACTERLIB environment variable is set" do
+            it "should include all paths in FACTERLIB" do
+                with_env "FACTERLIB" => "/one/path:/two/path" do
+                    paths = @loader.search_path
+                    %w{/one/path /two/path}.each do |dir|
+                        paths.should be_include(dir)
+                    end
+                end
+            end
+        end
+    end
+
+    describe "when loading facts" do
+        before do
+            @loader = Facter::Util::Loader.new
+            @loader.stubs(:search_path).returns []
+        end
+
+        it "should load values from the matching environment variable if one is present" do
+            Facter.expects(:add).with("testing")
+
+            with_env "facter_testing" => "yayness" do
+                @loader.load(:testing)
+            end
+        end
+        
+        it "should load any files in the search path with names matching the fact name" do
+            @loader.expects(:search_path).returns %w{/one/dir /two/dir}
+            FileTest.stubs(:exist?).returns false
+            FileTest.expects(:exist?).with("/one/dir/testing.rb").returns true
+            FileTest.expects(:exist?).with("/two/dir/testing.rb").returns true
+
+            Kernel.expects(:load).with("/one/dir/testing.rb")
+            Kernel.expects(:load).with("/two/dir/testing.rb")
+
+            @loader.load(:testing)
+        end
+
+        it "should load any ruby files in directories matching the fact name in the search path" do
+            @loader.expects(:search_path).returns %w{/one/dir}
+            FileTest.stubs(:exist?).returns false
+            FileTest.expects(:directory?).with("/one/dir/testing").returns true
+
+            Dir.expects(:entries).with("/one/dir/testing").returns %w{two.rb}
+
+            Kernel.expects(:load).with("/one/dir/testing/two.rb")
+
+            @loader.load(:testing)
+        end
+
+        it "should not load files that don't end in '.rb'" do
+            @loader.expects(:search_path).returns %w{/one/dir}
+            FileTest.stubs(:exist?).returns false
+            FileTest.expects(:directory?).with("/one/dir/testing").returns true
+
+            Dir.expects(:entries).with("/one/dir/testing").returns %w{one}
+
+            Kernel.expects(:load).never
+
+            @loader.load(:testing)
+        end
+    end
+
+    describe "when loading all facts" do
+        before do
+            @loader = Facter::Util::Loader.new
+            @loader.stubs(:search_path).returns []
+
+            FileTest.stubs(:directory?).returns true
+        end
+
+        it "should skip directories that do not exist" do
+            @loader.expects(:search_path).returns %w{/one/dir}
+
+            FileTest.expects(:directory?).with("/one/dir").returns false
+
+            Dir.expects(:entries).with("/one/dir").never
+
+            @loader.load_all
+        end
+
+        it "should load all files in all search paths" do
+            @loader.expects(:search_path).returns %w{/one/dir /two/dir}
+
+            Dir.expects(:entries).with("/one/dir").returns %w{a.rb b.rb}
+            Dir.expects(:entries).with("/two/dir").returns %w{c.rb d.rb}
+
+            %w{/one/dir/a.rb /one/dir/b.rb /two/dir/c.rb /two/dir/d.rb}.each { |f| Kernel.expects(:load).with(f) }
+
+            @loader.load_all
+        end
+
+        it "should load all files in all subdirectories in all search paths" do
+            @loader.expects(:search_path).returns %w{/one/dir /two/dir}
+
+            Dir.expects(:entries).with("/one/dir").returns %w{a}
+            Dir.expects(:entries).with("/two/dir").returns %w{b}
+
+            %w{/one/dir/a /two/dir/b}.each { |f| File.expects(:directory?).with(f).returns true }
+
+            Dir.expects(:entries).with("/one/dir/a").returns %w{c.rb}
+            Dir.expects(:entries).with("/two/dir/b").returns %w{d.rb}
+
+            %w{/one/dir/a/c.rb /two/dir/b/d.rb}.each { |f| Kernel.expects(:load).with(f) }
+
+            @loader.load_all
+        end
+
+        it "should not load files in the util subdirectory" do
+            @loader.expects(:search_path).returns %w{/one/dir}
+
+            Dir.expects(:entries).with("/one/dir").returns %w{util}
+
+            File.expects(:directory?).with("/one/dir/util").returns true
+
+            Dir.expects(:entries).with("/one/dir/util").never
+
+            @loader.load_all
+        end
+
+        it "should not load files in a lib subdirectory" do
+            @loader.expects(:search_path).returns %w{/one/dir}
+
+            Dir.expects(:entries).with("/one/dir").returns %w{lib}
+
+            File.expects(:directory?).with("/one/dir/lib").returns true
+
+            Dir.expects(:entries).with("/one/dir/lib").never
+
+            @loader.load_all
+        end
+
+        it "should not load files in '.' or '..'" do
+            @loader.expects(:search_path).returns %w{/one/dir}
+
+            Dir.expects(:entries).with("/one/dir").returns %w{. ..}
+
+            File.expects(:entries).with("/one/dir/.").never
+            File.expects(:entries).with("/one/dir/..").never
+
+            @loader.load_all
+        end
+
+        it "should load all facts from the environment" do
+            Facter.expects(:add).with('one')
+            Facter.expects(:add).with('two')
+
+            with_env "facter_one" => "yayness", "facter_two" => "boo" do
+                @loader.load_all
+            end
+        end
+
+        it "should only load all facts one time" do
+            @loader.expects(:load_env).once
+            @loader.load_all
+            @loader.load_all
+        end
+    end
+end