facter 1.6.18 → 1.7.0.rc1

data/spec/unit/util/config_spec.rb

@@ -1,24 +1,55 @@
 #! /usr/bin/env ruby
 
 require 'spec_helper'
-require 'facter/util/config'
 
 describe Facter::Util::Config do
+  include PuppetlabsSpec::Files
+
   describe "is_windows? function" do
-    it "should detect windows if RbConfig returns a windows OS" do
+    it "should detect windows if Ruby RbConfig::CONFIG['host_os'] returns a windows OS" do
       host_os = ["mswin","win32","dos","mingw","cygwin"]
       host_os.each do |h|
-        RbConfig::CONFIG.expects(:[]).with('host_os').returns(h)
+        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
         Facter::Util::Config.is_windows?.should be_true
       end
     end
 
-    it "should not detect windows if RbConfig returns a non-windows OS" do
+    it "should not detect windows if Ruby RbConfig::CONFIG['host_os'] returns a non-windows OS" do
       host_os = ["darwin","linux"]
       host_os.each do |h|
-        RbConfig::CONFIG.expects(:[]).with('host_os').returns(h)
+        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
         Facter::Util::Config.is_windows?.should be_false
       end
     end
   end
+
+  describe "is_mac? function" do
+    it "should detect mac if Ruby RbConfig::CONFIG['host_os'] returns darwin" do
+      host_os = ["darwin"]
+      host_os.each do |h|
+        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
+        Facter::Util::Config.is_mac?.should be_true
+      end
+    end
+  end
+
+  describe "external_facts_dirs" do
+    it "should return the default value for linux" do
+      Facter::Util::Config.stubs(:is_windows?).returns(false)
+      Facter::Util::Config.stubs(:windows_data_dir).returns(nil)
+      Facter::Util::Config.external_facts_dirs.should == ["/etc/facter/facts.d", "/etc/puppetlabs/facter/facts.d"]
+    end
+
+    it "should return the default value for windows 2008" do
+      Facter::Util::Config.stubs(:is_windows?).returns(true)
+      Facter::Util::Config.stubs(:windows_data_dir).returns("C:\\ProgramData")
+      Facter::Util::Config.external_facts_dirs.should == [File.join("C:\\ProgramData", 'PuppetLabs', 'facter', 'facts.d')]
+    end
+
+    it "should return the default value for windows 2003R2" do
+      Facter::Util::Config.stubs(:is_windows?).returns(true)
+      Facter::Util::Config.stubs(:windows_data_dir).returns("C:\\Documents")
+      Facter::Util::Config.external_facts_dirs.should == [File.join("C:\\Documents", 'PuppetLabs', 'facter', 'facts.d')]
+    end
+  end
 end

data/spec/unit/util/confine_spec.rb

@@ -32,8 +32,12 @@ describe Facter::Util::Confine do
   end
 
   describe "when evaluating" do
+    def confined(fact_value, *confines)
+      @fact.stubs(:value).returns fact_value
+      Facter::Util::Confine.new("yay", *confines).true?
+    end
+
     before do
-      @confine = Facter::Util::Confine.new("yay", "one", "two", "Four", :xy, true, 1, [3,4])
       @fact = mock 'fact'
       Facter.stubs(:[]).returns @fact
     end
@@ -41,7 +45,7 @@ describe Facter::Util::Confine do
     it "should return false if the fact does not exist" do
       Facter.expects(:[]).with("yay").returns nil
 
-      @confine.true?.should be_false
+      Facter::Util::Confine.new("yay", "test").true?.should be_false
     end
 
     it "should use the returned fact to get the value" do
@@ -49,91 +53,75 @@ describe Facter::Util::Confine do
 
       @fact.expects(:value).returns nil
 
-      @confine.true?
+      Facter::Util::Confine.new("yay", "test").true?
     end
 
     it "should return false if the fact has no value" do
-      @fact.stubs(:value).returns nil
-
-      @confine.true?.should be_false
+      confined(nil, "test").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
+      confined("two", "two").should be_true
     end
 
     it "should return true if any of the provided symbol values matches the fact's value" do
-      @fact.stubs(:value).returns :xy
-
-      @confine.true?.should be_true
+      confined(:xy, :xy).should be_true
     end
 
     it "should return true if any of the provided integer values matches the fact's value" do
-      @fact.stubs(:value).returns 1
-
-      @confine.true?.should be_true
+      confined(1, 1).should be_true
     end
 
     it "should return true if any of the provided boolan values matches the fact's value" do
-      @fact.stubs(:value).returns true
-
-      @confine.true?.should be_true
+      confined(true, true).should be_true
     end
 
     it "should return true if any of the provided array values matches the fact's value" do
-      @fact.stubs(:value).returns [3,4]
-
-      @confine.true?.should be_true
+      confined([3,4], [3,4]).should be_true
     end
 
     it "should return true if any of the provided symbol values matches the fact's string value" do
-      @fact.stubs(:value).returns :one
-
-      @confine.true?.should be_true
+      confined(:one, "one").should be_true
     end
 
     it "should return true if any of the provided string values matches case-insensitive the fact's value" do
-      @fact.stubs(:value).returns "four"
-
-      @confine.true?.should be_true
+      confined("four", "Four").should be_true
     end
 
     it "should return true if any of the provided symbol values matches case-insensitive the fact's string value" do
-      @fact.stubs(:value).returns :four
-
-      @confine.true?.should be_true
+      confined(:four, "Four").should be_true
     end
 
     it "should return true if any of the provided symbol values matches the fact's string value" do
-      @fact.stubs(:value).returns :Xy
+      confined("xy", :xy).should be_true
+    end
 
-      @confine.true?.should be_true
+    it "should return true if any of the provided regexp values matches the fact's string value" do
+      confined("abc", /abc/).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"
+    it "should return true if any of the provided ranges matches the fact's value" do
+      confined(6, (5..7)).should be_true
+    end
 
-      @confine.true?.should be_false
+    it "should return false if none of the provided values matches the fact's value" do
+      confined("three", "two", "four").should be_false
     end
 
     it "should return false if none of the provided integer values matches the fact's value" do
-      @fact.stubs(:value).returns 2
-
-      @confine.true?.should be_false
+      confined(2, 1, [3,4], (5..7)).should be_false
     end
 
     it "should return false if none of the provided boolan values matches the fact's value" do
-      @fact.stubs(:value).returns false
-
-      @confine.true?.should be_false
+      confined(false, true).should be_false
     end
 
     it "should return false if none of the provided array values matches the fact's value" do
-      @fact.stubs(:value).returns [1,2]
+      confined([1,2], [3,4]).should be_false
+    end
 
-      @confine.true?.should be_false
+    it "should return false if none of the provided ranges matches the fact's value" do
+      confined(8, (5..7)).should be_false
     end
   end
 end

data/spec/unit/util/directory_loader_spec.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+require 'facter/util/directory_loader'
+
+describe Facter::Util::DirectoryLoader do
+  include PuppetlabsSpec::Files
+  include FacterSpec::ConfigHelper
+
+  subject { Facter::Util::DirectoryLoader.new(tmpdir('directory_loader')) }
+  let(:collection) { Facter::Util::Collection.new(mock("internal loader"), subject) }
+
+  it "should make the directory available" do
+    subject.directory.should be_instance_of(String)
+  end
+
+  it "can be created with a given directory" do
+    Facter::Util::DirectoryLoader.loader_for("ext").directory.should == "ext"
+  end
+
+  it "raises an error when the directory does not exist" do
+    missing_dir = "missing"
+    File.stubs(:directory?).with(missing_dir).returns(false)
+    expect { Facter::Util::DirectoryLoader.loader_for(missing_dir) }.to raise_error Facter::Util::DirectoryLoader::NoSuchDirectoryError
+  end
+
+  it "should do nothing bad when dir doesn't exist" do
+    fakepath = "/foobar/path"
+    my_loader = Facter::Util::DirectoryLoader.new(fakepath)
+    FileTest.exists?(my_loader.directory).should be_false
+    expect { my_loader.load(collection) }.to_not raise_error
+   end
+
+  describe "when loading facts from disk" do
+    it "should be able to load files from disk and set facts" do
+      data = {"f1" => "one", "f2" => "two"}
+      write_to_file("data.yaml", YAML.dump(data))
+
+      subject.load(collection)
+
+      collection.value("f1").should == "one"
+      collection.value("f2").should == "two"
+    end
+
+    it "should ignore files that begin with '.'" do
+      not_to_be_used_collection = mock("collection should not be used")
+      not_to_be_used_collection.expects(:add).never
+
+      data = {"f1" => "one", "f2" => "two"}
+      write_to_file(".data.yaml", YAML.dump(data))
+
+      subject.load(not_to_be_used_collection)
+    end
+
+    %w{bak orig}.each do |ext|
+      it "should ignore files with an extension of '#{ext}'" do
+        write_to_file("data" + ".#{ext}", "foo=bar")
+
+        subject.load(collection)
+      end
+    end
+
+    it "should warn when trying to parse unknown file types" do
+      write_to_file("file.unknownfiletype", "stuff=bar")
+
+      Facter.expects(:warn).with(regexp_matches(/file.unknownfiletype/))
+
+      subject.load(collection)
+    end
+
+    it "external facts should almost always precedence over all other facts" do
+      Facter.add("f1", :value => "lower_weight_fact") { has_weight(Facter::Util::DirectoryLoader::EXTERNAL_FACT_WEIGHT - 1) }
+      data = {"f1" => "external_fact"}
+      write_to_file("data.yaml", YAML.dump(data))
+
+      subject.load(collection)
+
+      collection.value("f1").should == "external_fact"
+    end
+  end
+
+  def write_to_file(file_name, to_write)
+    file = File.join(subject.directory, file_name)
+    File.open(file, "w") { |f| f.print to_write}
+  end
+end

data/spec/unit/util/fact_spec.rb

@@ -32,39 +32,26 @@ describe Facter::Util::Fact 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)
+      @resolution = Facter::Util::Resolution.new("yay")
     end
 
-    it "should create a new resolution instance" do
+    it "should be to create a new resolution instance with a block" 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 { }
+      @fact.add {
+        setcode { "foo" }
+      }
+      @fact.value.should == "foo"
     end
 
     it "should re-sort the resolutions by weight, so the most restricted resolutions are first" do
-      r1 = stub 'r1', :weight => 1
-      r2 = stub 'r2', :weight => 2
-      r3 = stub 'r3', :weight => 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]
+      @fact.add { self.value = "1"; self.weight = 1 }
+      @fact.add { self.value = "2"; self.weight = 2 }
+      @fact.add { self.value = "0"; self.weight = 0 }
+      @fact.value.should == "2"
     end
   end
 
@@ -122,7 +109,32 @@ describe Facter::Util::Fact do
     end
   end
 
-  it "should have a method for flushing the cached fact" do
-    Facter::Util::Fact.new(:foo).should respond_to(:flush)
+  describe '#flush' do
+    subject do
+      Facter::Util::Fact.new(:foo)
+    end
+    context 'basic facts using setcode' do
+      it "flushes the cached value when invoked" do
+        system = mock('some_system_call')
+        system.expects(:data).twice.returns(100,200)
+
+        subject.add { setcode { system.data } }
+        5.times { subject.value.should == 100 }
+        subject.flush
+        subject.value.should == 200
+      end
+    end
+    context 'facts using setcode and on_flush' do
+      it 'invokes the block passed to on_flush' do
+        model = { :data => "Hello World" }
+        subject.add do
+          on_flush { model[:data] = "FLUSHED!" }
+          setcode { model[:data] }
+        end
+        subject.value.should == "Hello World"
+        subject.flush
+        subject.value.should == "FLUSHED!"
+      end
+    end
   end
 end

data/spec/unit/util/file_read_spec.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby
+
+require 'facter/util/file_read'
+require 'spec_helper'
+
+describe Facter::Util::FileRead do
+  let(:issue) { "Ubuntu 10.04.4 LTS \\n \\l\n\n" }
+
+  it "reads a file" do
+    File.expects(:read).with("/etc/issue").returns(issue)
+    Facter::Util::FileRead.read("/etc/issue").should == issue
+  end
+
+  it "returns nil if the file cannot be accessed" do
+    File.stubs(:read).with("/etc/issue").raises(Errno::EACCES.new("/etc/issue"))
+    Facter::Util::FileRead.read("/etc/issue").should be_nil
+  end
+
+  it "returns nil if the file does not exist" do
+    File.stubs(:read).with("/etc/issue").raises(Errno::ENOENT.new("/etc/issue"))
+    Facter::Util::FileRead.read("/etc/issue").should be_nil
+  end
+
+  it "logs a message when handing exceptions" do
+    File.stubs(:read).with("/etc/issue").raises(Errno::EACCES.new("/etc/issue"))
+    Facter.expects(:debug).with("Could not read /etc/issue: Permission denied - /etc/issue")
+    Facter::Util::FileRead.read("/etc/issue")
+  end
+end

data/spec/unit/util/ip_spec.rb

@@ -4,13 +4,15 @@ require 'spec_helper'
 require 'facter/util/ip'
 
 describe Facter::Util::IP do
+  include FacterSpec::ConfigHelper
+
   before :each do
-    Facter::Util::Config.stubs(:is_windows?).returns(false)
+    given_a_configuration_of(:is_windows => false)
   end
 
   [:freebsd, :linux, :netbsd, :openbsd, :sunos, :darwin, :"hp-ux", :"gnu/kfreebsd", :windows].each do |platform|
     it "should be supported on #{platform}" do
-      Facter::Util::Config.stubs(:is_windows?).returns(platform == :windows)
+      given_a_configuration_of(:is_windows => platform == :windows)
       Facter::Util::IP.supported_platforms.should be_include(platform)
     end
   end

data/spec/unit/util/loader_spec.rb

@@ -21,24 +21,6 @@ describe Facter::Util::Loader do
     Facter::Util::Loader.any_instance.unstub(:load_all)
   end
 
-  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
@@ -51,6 +33,62 @@ describe Facter::Util::Loader do
     Facter::Util::Loader.new.should respond_to(:search_path)
   end
 
+  describe "#valid_seach_path?" do
+    before :each do
+      @loader = Facter::Util::Loader.new
+      @settings = mock 'settings'
+      @settings.stubs(:value).returns "/eh"
+    end
+
+    it "should cache the result of a previous check" do
+      Pathname.any_instance.expects(:absolute?).returns(true).once
+
+      # we explicitly want two calls here to check that we get
+      # the second from the cache
+      @loader.should be_valid_search_path "/foo"
+      @loader.should be_valid_search_path "/foo"
+    end
+
+    # Used to have test for " " as a directory since that should
+    # be a relative directory, but on Windows in both 1.8.7 and
+    # 1.9.3 it is an absolute directory (WTF Windows). Considering
+    # we didn't have a valid use case for a " " directory, the
+    # test was removed.
+
+    [
+      '.',
+      '..',
+      '...',
+      '.foo',
+      '../foo',
+      'foo',
+      'foo/bar',
+      'foo/../bar',
+      ' /',
+      ' \/',
+    ].each do |dir|
+      it "should be false for relative path #{dir}" do
+        @loader.should_not be_valid_search_path dir
+      end
+    end
+    [
+      '/.',
+      '/..',
+      '/...',
+      '/.foo',
+      '/../foo',
+      '/foo',
+      '/foo/bar',
+      '/foo/../bar',
+      '/ ',
+      '/ /..',
+    ].each do |dir|
+      it "should be true for absolute path #{dir}" do
+        @loader.should be_valid_search_path dir
+      end
+    end
+  end
+
   describe "when determining the search path" do
     before do
       @loader = Facter::Util::Loader.new
@@ -60,6 +98,7 @@ describe Facter::Util::Loader do
 
     it "should include the facter subdirectory of all paths in ruby LOAD_PATH" do
       dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
+      @loader.stubs(:valid_search_path?).returns(true)
       paths = @loader.search_path
 
       dirs.each do |dir|
@@ -67,6 +106,24 @@ describe Facter::Util::Loader do
       end
     end
 
+    it "should warn the user when an invalid search path has been excluded" do
+      dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
+      @loader.stubs(:valid_search_path?).returns(false)
+      dirs.each do |dir|
+        Facter.expects(:debugonce).with("Relative directory #{dir} removed from search path.").once
+      end
+      paths = @loader.search_path
+    end
+
+    it "should exclude invalid search paths" do
+      dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
+      @loader.stubs(:valid_search_path?).returns(false)
+      paths = @loader.search_path
+      dirs.each do |dir|
+        paths.should_not 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
@@ -76,7 +133,7 @@ describe Facter::Util::Loader do
 
     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
+        Facter::Util::Resolution.with_env "FACTERLIB" => "/one/path#{File::PATH_SEPARATOR}/two/path" do
           paths = @loader.search_path
           %w{/one/path /two/path}.each do |dir|
             paths.should be_include(dir)
@@ -95,7 +152,7 @@ describe Facter::Util::Loader do
     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
+      Facter::Util::Resolution.with_env "facter_testing" => "yayness" do
         @loader.load(:testing)
       end
     end
@@ -113,21 +170,21 @@ describe Facter::Util::Loader do
     end
 
     it 'should load any ruby files in directories matching the fact name in the search path in sorted order regardless of the order returned by Dir.entries' do
-    @loader = TestLoader.new
+      @loader = TestLoader.new
 
-    @loader.stubs(:search_path).returns %w{/one/dir}
-    FileTest.stubs(:exist?).returns false
-    FileTest.stubs(:directory?).with("/one/dir/testing").returns true
-    @loader.stubs(:search_path).returns %w{/one/dir}
+      @loader.stubs(:search_path).returns %w{/one/dir}
+      FileTest.stubs(:exist?).returns false
+      FileTest.stubs(:directory?).with("/one/dir/testing").returns true
+      @loader.stubs(:search_path).returns %w{/one/dir}
 
-    Dir.stubs(:entries).with("/one/dir/testing").returns %w{foo.rb bar.rb}
-    %w{/one/dir/testing/foo.rb /one/dir/testing/bar.rb}.each do |f|
-      File.stubs(:directory?).with(f).returns false
-      Kernel.stubs(:load).with(f)
-    end
+      Dir.stubs(:entries).with("/one/dir/testing").returns %w{foo.rb bar.rb}
+      %w{/one/dir/testing/foo.rb /one/dir/testing/bar.rb}.each do |f|
+        File.stubs(:directory?).with(f).returns false
+        Kernel.stubs(:load).with(f)
+      end
 
-    @loader.load(:testing)
-    @loader.loaded_files.should == %w{/one/dir/testing/bar.rb /one/dir/testing/foo.rb}
+      @loader.load(:testing)
+      @loader.loaded_files.should == %w{/one/dir/testing/bar.rb /one/dir/testing/foo.rb}
     end
 
     it "should load any ruby files in directories matching the fact name in the search path" do
@@ -156,7 +213,7 @@ describe Facter::Util::Loader do
   end
 
   describe "when loading all facts" do
-    before do
+    before :each do
       @loader = Facter::Util::Loader.new
       @loader.stubs(:search_path).returns []
 
@@ -201,21 +258,21 @@ describe Facter::Util::Loader do
     end
 
     it 'should load all files in sorted order for any given directory regardless of the order returned by Dir.entries' do
-    @loader = TestLoader.new
+      @loader = TestLoader.new
 
-    @loader.stubs(:search_path).returns %w{/one/dir}
-    Dir.stubs(:entries).with("/one/dir").returns %w{foo.rb bar.rb}
+      @loader.stubs(:search_path).returns %w{/one/dir}
+      Dir.stubs(:entries).with("/one/dir").returns %w{foo.rb bar.rb}
 
-    %w{/one/dir}.each { |f| File.stubs(:directory?).with(f).returns true }
+      %w{/one/dir}.each { |f| File.stubs(:directory?).with(f).returns true }
 
-    %w{/one/dir/foo.rb /one/dir/bar.rb}.each do |f|
-      File.stubs(:directory?).with(f).returns false
-      Kernel.expects(:load).with(f)
-    end
+      %w{/one/dir/foo.rb /one/dir/bar.rb}.each do |f|
+        File.stubs(:directory?).with(f).returns false
+        Kernel.expects(:load).with(f)
+      end
 
-    @loader.load_all
+      @loader.load_all
 
-    @loader.loaded_files.should == %w{/one/dir/bar.rb /one/dir/foo.rb}
+      @loader.loaded_files.should == %w{/one/dir/bar.rb /one/dir/foo.rb}
     end
 
     it "should not load files in the util subdirectory" do
@@ -267,7 +324,7 @@ describe Facter::Util::Loader do
       Facter.expects(:add).with('one')
       Facter.expects(:add).with('two')
 
-      with_env "facter_one" => "yayness", "facter_two" => "boo" do
+      Facter::Util::Resolution.with_env "facter_one" => "yayness", "facter_two" => "boo" do
         @loader.load_all
       end
     end
@@ -281,7 +338,7 @@ describe Facter::Util::Loader do
 
   it "should load facts on the facter search path only once" do
     facterlibdir = File.expand_path(File.dirname(__FILE__) + '../../../fixtures/unit/util/loader')
-    with_env 'FACTERLIB' => facterlibdir do
+    Facter::Util::Resolution.with_env 'FACTERLIB' => facterlibdir do
       Facter::Util::Loader.new.load_all
       Facter.value(:nosuchfact).should be_nil
     end