facter 1.7.6 → 2.0.1.rc1

data/spec/unit/core/execution_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'facter/core/execution'
+
+describe Facter::Core::Execution do
+  subject { described_class}
+  let(:impl) { described_class.impl }
+
+  it "delegates #search_paths to the implementation" do
+    impl.expects(:search_paths)
+    subject.search_paths
+  end
+
+  it "delegates #which to the implementation" do
+    impl.expects(:which).with('waffles')
+    subject.which('waffles')
+  end
+
+  it "delegates #absolute_path? to the implementation" do
+    impl.expects(:absolute_path?).with('waffles', nil)
+    subject.absolute_path?('waffles')
+  end
+
+  it "delegates #absolute_path? with an optional platform to the implementation" do
+    impl.expects(:absolute_path?).with('waffles', :windows)
+    subject.absolute_path?('waffles', :windows)
+  end
+
+  it "delegates #expand_command to the implementation" do
+    impl.expects(:expand_command).with('waffles')
+    subject.expand_command('waffles')
+  end
+
+  it "delegates #exec to the implementation" do
+    impl.expects(:exec).with('waffles')
+    subject.exec('waffles')
+  end
+end

data/spec/unit/core/logging_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'facter/core/logging'
+
+describe Facter::Core::Logging do
+
+  subject { described_class }
+
+  after(:all) do
+    subject.debugging(false)
+    subject.timing(false)
+  end
+
+  describe "emitting debug messages" do
+    it "doesn't log a message when debugging is disabled" do
+      subject.debugging(false)
+      subject.expects(:puts).never
+      subject.debug("foo")
+    end
+
+    describe "and debugging is enabled" do
+      before { subject.debugging(true) }
+      it "emits a warning when called with nil" do
+        subject.expects(:warn).with { |msg| expect(msg).to match /invalid message nil:NilClass/ }
+        subject.debug(nil)
+      end
+
+      it "emits a warning when called with an empty string" do
+        subject.expects(:warn).with { |msg| expect(msg).to match /invalid message "":String/ }
+        subject.debug("")
+      end
+
+      it "prints the message when logging is enabled" do
+        subject.expects(:puts).with { |msg| expect(msg).to match /foo/ }
+        subject.debug("foo")
+      end
+    end
+  end
+
+  describe "when warning" do
+    it "emits a warning when given a string" do
+      subject.debugging(true)
+      Kernel.expects(:warn).with('foo')
+      subject.warn('foo')
+    end
+
+    it "emits a warning regardless of log level" do
+      subject.debugging(false)
+      Kernel.expects(:warn).with "foo"
+      subject.warn "foo"
+    end
+
+    it "emits a warning if nil is passed" do
+      Kernel.expects(:warn).with { |msg| expect(msg).to match /invalid message nil:NilClass/ }
+      subject.warn(nil)
+    end
+
+    it "emits a warning if an empty string is passed" do
+      Kernel.expects(:warn).with { |msg| expect(msg).to match /invalid message "":String/ }
+      subject.warn('')
+    end
+  end
+
+  describe "when warning once" do
+    it "only logs a given warning string once" do
+      subject.expects(:warn).with('foo').once
+      subject.warnonce('foo')
+      subject.warnonce('foo')
+    end
+  end
+
+  describe "when setting the debugging mode" do
+    it "is enabled when the given value is true" do
+      subject.debugging(true)
+      expect(subject.debugging?).to be_true
+    end
+
+    it "is disabled when the given value is false" do
+      subject.debugging(false)
+      expect(subject.debugging?).to be_false
+    end
+
+    it "is disabled when the given value is nil" do
+      subject.debugging(nil)
+      expect(subject.debugging?).to be_false
+    end
+  end
+
+  describe "when setting the timing mode" do
+    it "is enabled when the given value is true" do
+      subject.timing(true)
+      expect(subject.timing?).to be_true
+    end
+
+    it "is disabled when the given value is false" do
+      subject.timing(false)
+      expect(subject.timing?).to be_false
+    end
+
+    it "is disabled when the given value is nil" do
+      subject.timing(nil)
+      expect(subject.timing?).to be_false
+    end
+  end
+end

data/spec/unit/core/resolvable_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'facter/core/resolvable'
+
+describe Facter::Core::Resolvable do
+
+  class ResolvableClass
+    def initialize(name)
+      @name = name
+      @fact = Facter::Util::Fact.new("stub fact")
+    end
+    attr_accessor :name, :resolve_value
+    attr_reader :fact
+    include Facter::Core::Resolvable
+  end
+
+  subject { ResolvableClass.new('resolvable') }
+
+  it "has a default timeout of 0 seconds" do
+    expect(subject.limit).to eq 0
+  end
+
+  it "can specify a custom timeout" do
+    subject.timeout = 10
+    expect(subject.limit).to eq 10
+  end
+
+  describe "generating a value" do
+    it "returns the results of #resolve_value" do
+      subject.resolve_value = 'stuff'
+      expect(subject.value).to eq 'stuff'
+    end
+
+    it "normalizes the resolved value" do
+      Facter::Util::Normalization.expects(:normalize).returns 'stuff'
+      subject.resolve_value = 'stuff'
+      expect(subject.value).to eq('stuff')
+    end
+
+    it "logs a warning if an exception was raised" do
+      subject.expects(:resolve_value).raises RuntimeError, "kaboom!"
+      Facter.expects(:warn).with(regexp_matches(/Could not retrieve .*: kaboom!/))
+      expect(subject.value).to eq nil
+    end
+  end
+
+  describe "timing out" do
+    it "uses #limit instead of #timeout to determine the timeout period" do
+      subject.expects(:timeout).never
+      subject.expects(:limit).returns 25
+
+      Timeout.expects(:timeout).with(25)
+      subject.value
+    end
+
+    it "returns nil if the timeout was reached" do
+      Facter.expects(:warn).with(regexp_matches(/Timed out after 0\.1 seconds while resolving/))
+      Timeout.expects(:timeout).raises Timeout::Error
+
+      subject.timeout = 0.1
+
+      expect(subject.value).to be_nil
+    end
+  end
+
+  describe 'callbacks when flushing facts' do
+    class FlushFakeError < StandardError; end
+
+    context '#on_flush' do
+      it 'accepts a block with on_flush' do
+        subject.on_flush() { raise NotImplementedError }
+      end
+    end
+
+    context '#flush' do
+      it 'calls the block passed to on_flush' do
+        subject.on_flush() { raise FlushFakeError }
+        expect { subject.flush }.to raise_error FlushFakeError
+      end
+    end
+  end
+end

data/spec/unit/core/suitable_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'facter/core/suitable'
+
+describe Facter::Core::Suitable do
+
+  class SuitableClass
+    def initialize
+      @confines = []
+    end
+    attr_reader :confines
+    include Facter::Core::Suitable
+  end
+
+  subject { SuitableClass.new }
+
+  describe "confining on facts" do
+    it "can add confines with a fact and a single value" do
+      subject.confine :kernel => 'Linux'
+    end
+
+    it "creates a Facter::Util::Confine object for the confine call" do
+      subject.confine :kernel => 'Linux'
+      conf = subject.confines.first
+      expect(conf).to be_a_kind_of Facter::Util::Confine
+      expect(conf.fact).to eq :kernel
+      expect(conf.values).to eq ['Linux']
+    end
+  end
+
+  describe "confining on blocks" do
+    it "can add a single fact with a block parameter" do
+      subject.confine(:one) { true }
+    end
+
+    it "creates a Util::Confine instance for the provided fact with block parameter" do
+      block = lambda { true }
+      Facter::Util::Confine.expects(:new).with("one")
+
+      subject.confine("one", &block)
+    end
+
+    it "should accept a single block parameter" do
+      subject.confine() { true }
+    end
+
+    it "should create a Util::Confine instance for the provided block parameter" do
+      block = lambda { true }
+      Facter::Util::Confine.expects(:new)
+
+      subject.confine(&block)
+    end
+  end
+
+  describe "determining weight" do
+    it "is zero if no confines are set" do
+      expect(subject.weight).to eq 0
+    end
+
+    it "defaults to the number of confines" do
+      subject.confine :kernel => 'Linux'
+      expect(subject.weight).to eq 1
+    end
+
+    it "can be explicitly set" do
+      subject.has_weight 10
+      expect(subject.weight).to eq 10
+    end
+
+    it "prefers an explicit weight over the number of confines" do
+      subject.confine :kernel => 'Linux'
+      subject.has_weight 11
+      expect(subject.weight).to eq 11
+    end
+  end
+
+  describe "determining suitability" do
+    it "is true if all confines for the object evaluate to true" do
+      subject.confine :kernel => 'Linux'
+      subject.confine :operatingsystem => 'Redhat'
+
+      subject.confines.each { |confine| confine.stubs(:true?).returns true }
+
+      expect(subject).to be_suitable
+    end
+
+    it "is false if any confines for the object evaluate to false" do
+      subject.confine :kernel => 'Linux'
+      subject.confine :operatingsystem => 'Redhat'
+
+      subject.confines.first.stubs(:true?).returns true
+      subject.confines.first.stubs(:true?).returns false
+
+      expect(subject).to_not be_suitable
+    end
+  end
+end

data/spec/unit/domain_spec.rb

@@ -24,11 +24,11 @@ describe "Domain name facts" do
       let(:dnsdomain_command) { "dnsdomainname 2> /dev/null" }
 
       def the_hostname_is(value)
-        Facter::Util::Resolution.stubs(:exec).with(hostname_command).returns(value)
+        Facter::Core::Execution.stubs(:exec).with(hostname_command).returns(value)
       end
 
       def the_dnsdomainname_is(value)
-        Facter::Util::Resolution.stubs(:exec).with(dnsdomain_command).returns(value)
+        Facter::Core::Execution.stubs(:exec).with(dnsdomain_command).returns(value)
       end
 
       before do
@@ -197,7 +197,7 @@ describe "Domain name facts" do
         it "should return nil" do
           expects_dnsdomains([nil])
 
-          Facter::Util::Resolution.stubs(:exec).with(hostname_command).returns('sometest')
+          Facter::Core::Execution.stubs(:exec).with(hostname_command).returns('sometest')
           FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(false)
 
           Facter.fact(:domain).value.should be_nil
@@ -288,8 +288,8 @@ describe "Domain name facts" do
 
         describe scenario[:scenario] do
           before(:each) do
-            Facter::Util::Resolution.stubs(:exec).with("hostname -f 2> /dev/null").returns(scenario[:hostname])
-            Facter::Util::Resolution.stubs(:exec).with("dnsdomainname 2> /dev/null").returns(scenario[:dnsdomainname])
+            Facter::Core::Execution.stubs(:exec).with("hostname -f 2> /dev/null").returns(scenario[:hostname])
+            Facter::Core::Execution.stubs(:exec).with("dnsdomainname 2> /dev/null").returns(scenario[:dnsdomainname])
             resolv_conf_contains(
               "search #{scenario[:resolve_search]}",
               "domain #{scenario[:resolve_domain]}"

data/spec/unit/facter_spec.rb

@@ -3,267 +3,106 @@
 require 'spec_helper'
 
 describe Facter do
-  it "should have a method for returning its collection" do
-    Facter.should respond_to(:collection)
-  end
-
-  it "should cache the collection" do
+  it "caches 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
-      test_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c echo yup' : 'echo yup'
-      Facter.add("shell_testing") do
-        setcode test_command
-      end
-
-      Facter["shell_testing"].value.should == "yup"
+  describe "methods on the collection" do
+    it "delegates the :flush method to the collection" do
+      Facter.collection.expects(:flush)
+      Facter.flush
     end
-  end
 
-  describe "when asked for a fact as an undefined Facter class method" do
-    describe "and the collection is already initialized" do
-      it "should return the fact's value" do
-        Facter.collection
-        Facter.ipaddress.should == Facter['ipaddress'].value
-      end
+    it "delegates the :fact method to the collection" do
+      Facter.collection.expects(:fact).with("afact")
+      Facter.fact("afact")
     end
 
-    describe "and the collection has been just reset" do
-      it "should return the fact's value" do
-        Facter.reset
-        Facter.ipaddress.should == Facter['ipaddress'].value
-      end
+    it "delegates the :list method to the collection" do
+      Facter.collection.expects(:list)
+      Facter.list
     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"
+    it "loads all facts when listing" do
+      Facter.collection.expects(:load_all)
+      Facter.list
     end
-  end
 
-  describe "Facter[:hostname]" do
-    it "should have its ldapname set to 'cn'" do
-      Facter[:hostname].ldapname.should == "cn"
+    it "delegates the :to_hash method to the collection" do
+      Facter.collection.expects(:to_hash)
+      Facter.to_hash
     end
-  end
 
-  describe "Facter[:ipaddress]" do
-    it "should have its ldapname set to 'iphostnumber'" do
-      Facter[:ipaddress].ldapname.should == "iphostnumber"
+    it "loads all facts when calling :to_hash" do
+      Facter.collection.expects(:load_all)
+      Facter.collection.stubs(:to_hash)
+      Facter.to_hash
     end
-  end
-
-  # #33 Make sure we only get one mac address
-  it "should only return one mac address" do
-    if macaddress = Facter.value(:macaddress)
-      macaddress.should_not be_include(" ")
-    end
-  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
-
-  it "should have a method to query debugging mode" do
-    Facter.should respond_to(:debugging?)
-  end
-
-  it "should have a method to query timing mode" do
-    Facter.should respond_to(:timing?)
-  end
-
-  it "should have a method to show timing information" do
-    Facter.should respond_to(:show_time)
-  end
-
-  it "should have a method to warn" do
-    Facter.should respond_to(:warn)
-  end
-
-  describe "when warning" do
-    it "should warn if debugging is enabled" do
-      Facter.debugging(true)
-      Kernel.stubs(:warn)
-      Kernel.expects(:warn).with('foo')
-      Facter.warn('foo')
+    it "delegates the :value method to the collection" do
+      Facter.collection.expects(:value).with("myvaluefact")
+      Facter.value("myvaluefact")
     end
 
-    it "should not warn if debugging is enabled but nil is passed" do
-      Facter.debugging(true)
-      Kernel.stubs(:warn)
-      Kernel.expects(:warn).never
-      Facter.warn(nil)
+    it "delegates the :each method to the collection" do
+      Facter.collection.expects(:each)
+      Facter.each
     end
 
-    it "should not warn if debugging is enabled but an empyt string is passed" do
-      Facter.debugging(true)
-      Kernel.stubs(:warn)
-      Kernel.expects(:warn).never
-      Facter.warn('')
+    it "delegates the :add method to the collection" do
+      Facter.collection.expects(:add).with("factname", {})
+      Facter.add("factname")
     end
 
-    it "should not warn if debugging is disabled" do
-      Facter.debugging(false)
-      Kernel.stubs(:warn)
-      Kernel.expects(:warn).never
-      Facter.warn('foo')
+    it "delegates the :define_fact method to the collection" do
+      Facter.collection.expects(:define_fact).with("factname", {})
+      Facter.define_fact("factname")
     end
 
-    it "should warn for any given element for an array if debugging is enabled" do
-      Facter.debugging(true)
-      Kernel.stubs(:warn)
-      Kernel.expects(:warn).with('foo')
-      Kernel.expects(:warn).with('bar')
-      Facter.warn( ['foo','bar'])
+    it "loads all facts when calling :each" do
+      Facter.collection.expects(:load_all)
+      Facter.collection.stubs(:each)
+      Facter.each
     end
   end
 
-  describe "when warning once" do
-    it "should only warn once" do
-      Kernel.stubs(:warnonce)
-      Kernel.expects(:warn).with('foo').once
-      Facter.warnonce('foo')
-      Facter.warnonce('foo')
-    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
 
-    it "should not warnonce if nil is passed" do
-      Kernel.stubs(:warn)
-      Kernel.expects(:warnonce).never
-      Facter.warnonce(nil)
-    end
+  describe "when registering directories to search" do
+    after { Facter.reset_search_path! }
 
-    it "should not warnonce if an empty string is passed" do
-      Kernel.stubs(:warn)
-      Kernel.expects(:warnonce).never
-      Facter.warnonce('')
+    it "allows registration of a directory" do
+      Facter.search "/my/dir"
     end
-  end
 
-  describe "when setting debugging mode" do
-    it "should have debugging enabled using 1" do
-      Facter.debugging(1)
-      Facter.should be_debugging
-    end
-    it "should have debugging enabled using true" do
-      Facter.debugging(true)
-      Facter.should be_debugging
-    end
-    it "should have debugging enabled using any string except off" do
-      Facter.debugging('aaaaa')
-      Facter.should be_debugging
-    end
-    it "should have debugging disabled using 0" do
-      Facter.debugging(0)
-      Facter.should_not be_debugging
-    end
-    it "should have debugging disabled using false" do
-      Facter.debugging(false)
-      Facter.should_not be_debugging
-    end
-    it "should have debugging disabled using the string 'off'" do
-      Facter.debugging('off')
-      Facter.should_not be_debugging
+    it "allows registration of multiple directories" do
+      Facter.search "/my/dir", "/other/dir"
     end
-  end
 
-  describe "when setting timing mode" do
-    it "should have timing enabled using 1" do
-      Facter.timing(1)
-      Facter.should be_timing
-    end
-    it "should have timing enabled using true" do
-      Facter.timing(true)
-      Facter.should be_timing
-    end
-    it "should have timing disabled using 0" do
-      Facter.timing(0)
-      Facter.should_not be_timing
-    end
-    it "should have timing disabled using false" do
-      Facter.timing(false)
-      Facter.should_not be_timing
+    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" do
-    after { Facter.instance_variable_set("@search_path", []) }
-
-    it "should allow registration of a directory" do
-      Facter.search "/my/dir"
+  describe "when registering directories to search for external facts" do
+    it "allows registration of a directory" do
+      Facter.search_external ["/my/dir"]
     end
 
-    it "should allow registration of multiple directories" do
-      Facter.search "/my/dir", "/other/dir"
+    it "allows registration of multiple directories" do
+      Facter.search_external ["/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}
+    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