facter 1.7.6 → 2.0.1.rc1

data/spec/unit/util/macaddress_spec.rb

@@ -67,11 +67,11 @@ describe "Darwin", :unless => Facter::Util::Config.is_windows? do
 
             it "should warn about the lack of default" do
               Facter.expects(:warn).with("Could not find a default route. Using first non-loopback interface")
-              Facter::Util::Macaddress::Darwin.stubs(:default_interface).returns('')
               Facter::Util::Macaddress::Darwin.macaddress
             end
 
             it "should return the macaddress of the first non-loopback interface" do
+              Facter.expects(:warn).with("Could not find a default route. Using first non-loopback interface")
               Facter::Util::Macaddress::Darwin.macaddress.should == fallback_macaddress
             end
           end
@@ -90,7 +90,7 @@ describe "The macaddress fact" do
     include FacterSpec::WindowsNetwork
 
     before :each do
-      Facter.fact(:kernel).stubs(:value).returns(:windows)
+      Facter.fact(:kernel).stubs(:value).returns('windows')
       Facter::Util::Registry.stubs(:hklm_read).returns(nic_bindings)
     end
 

data/spec/unit/util/macosx_spec.rb

@@ -27,7 +27,7 @@ describe Facter::Util::Macosx do
   end
 
   it "should be able to retrieve profiler data as xml for a given data field" do
-    Facter::Util::Resolution.expects(:exec).with("/usr/sbin/system_profiler -xml foo").returns "yay"
+    Facter::Core::Execution.expects(:exec).with("/usr/sbin/system_profiler -xml foo").returns "yay"
     Facter::Util::Macosx.profiler_xml("foo").should == "yay"
   end
 
@@ -45,7 +45,7 @@ describe Facter::Util::Macosx do
     STDERR.stubs(:<<)
     expect {
       Facter::Util::Macosx.intern_xml('<bad}|%-->xml<--->')
-    }.to raise_error(RuntimeError, /A plist file could not be properly read by Facter::Util::CFPropertyList/)
+    }.to raise_error(RuntimeError, /A plist file could not be properly read by CFPropertyList/)
   end
 
   describe "when collecting profiler data" do
@@ -80,17 +80,17 @@ describe Facter::Util::Macosx do
   describe "when working out software version" do
 
     before do
-      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productName").returns "Mac OS X"
-      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -buildVersion").returns "9J62"
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productName").returns "Mac OS X"
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -buildVersion").returns "9J62"
     end
 
     it "should have called sw_vers three times when determining software version" do
-      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
       Facter::Util::Macosx.sw_vers
     end
 
     it "should return a hash with the correct keys when determining software version" do
-      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
       Facter::Util::Macosx.sw_vers.keys.sort.should == ["macosx_productName",
                                                         "macosx_buildVersion",
                                                         "macosx_productversion_minor",
@@ -99,14 +99,14 @@ describe Facter::Util::Macosx do
     end
 
     it "should split a product version of 'x.y.z' into separate hash entries correctly" do
-      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "1.2.3"
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "1.2.3"
       sw_vers = Facter::Util::Macosx.sw_vers
       sw_vers["macosx_productversion_major"].should == "1.2"
       sw_vers["macosx_productversion_minor"].should == "3"
     end
 
     it "should treat a product version of 'x.y' as 'x.y.0" do
-      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "2.3"
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "2.3"
       Facter::Util::Macosx.sw_vers["macosx_productversion_minor"].should == "0"
     end
   end

data/spec/unit/util/manufacturer_spec.rb

@@ -18,14 +18,14 @@ describe Facter::Manufacturer do
   end
 
   it "should parse prtdiag output on a sunfire v120" do
-    Facter::Util::Resolution.stubs(:exec).returns(my_fixture_read("solaris_sunfire_v120_prtdiag"))
+    Facter::Core::Execution.stubs(:exec).returns(my_fixture_read("solaris_sunfire_v120_prtdiag"))
     Facter::Manufacturer.prtdiag_sparc_find_system_info()
     Facter.value(:manufacturer).should == "Sun Microsystems"
     Facter.value(:productname).should == "Sun Fire V120 (UltraSPARC-IIe 648MHz)"
   end
 
   it "should parse prtdiag output on a t5220" do
-    Facter::Util::Resolution.stubs(:exec).returns(my_fixture_read("solaris_t5220_prtdiag"))
+    Facter::Core::Execution.stubs(:exec).returns(my_fixture_read("solaris_t5220_prtdiag"))
     Facter::Manufacturer.prtdiag_sparc_find_system_info()
     Facter.value(:manufacturer).should == "Sun Microsystems"
     Facter.value(:productname).should == "SPARC Enterprise T5220"
@@ -36,7 +36,7 @@ describe Facter::Manufacturer do
     Facter.fact(:kernel).stubs(:value).returns("SunOS")
     Facter.fact(:hardwareisa).stubs(:value).returns("sparc")
 
-    Facter::Util::Resolution.stubs(:exec).with(regexp_matches(/prtdiag/)).returns(nil)
+    Facter::Core::Execution.stubs(:exec).with(regexp_matches(/prtdiag/)).returns(nil)
     Facter::Manufacturer.prtdiag_sparc_find_system_info()
     Facter.value(:manufacturer).should_not == "Sun Microsystems"
   end

data/spec/unit/util/normalization_spec.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'facter/util/normalization'
+
+describe Facter::Util::Normalization do
+
+  subject { described_class }
+
+  def utf16(str)
+    if String.method_defined?(:encode) && defined?(::Encoding)
+      str.encode(Encoding::UTF_16LE)
+    else
+      str
+    end
+  end
+
+  def utf8(str)
+    if String.method_defined?(:encode) && defined?(::Encoding)
+      str.encode(Encoding::UTF_8)
+    else
+      str
+    end
+  end
+
+  describe "validating strings" do
+    describe "and string encoding is supported", :if => String.instance_methods.include?(:encoding) do
+      it "accepts strings that are ASCII and match their encoding and converts them to UTF-8" do
+        str = "ASCII".encode(Encoding::ASCII)
+        normalized_str = subject.normalize(str)
+        expect(normalized_str.encoding).to eq(Encoding::UTF_8)
+      end
+
+      it "accepts strings that are UTF-8 and match their encoding" do
+        str = "let's make a ☃!".encode(Encoding::UTF_8)
+        expect(subject.normalize(str)).to eq(str)
+      end
+
+      it "converts valid non UTF-8 strings to UTF-8" do
+        str = "let's make a ☃!".encode(Encoding::UTF_16LE)
+        enc = subject.normalize(str).encoding
+        expect(enc).to eq(Encoding::UTF_8)
+      end
+
+      it "normalizes a frozen string returning a non-frozen string" do
+        str = "factvalue".encode(Encoding::UTF_16LE).freeze
+        normalized_str = subject.normalize(str)
+        expect(normalized_str.encoding).to eq(Encoding::UTF_8)
+        expect(normalized_str).to_not be_frozen
+      end
+
+      it "rejects strings that are not UTF-8 and do not match their claimed encoding" do
+        invalid_shift_jis = "\xFF\x5C!".force_encoding(Encoding::SHIFT_JIS)
+        expect {
+          subject.normalize(invalid_shift_jis)
+        }.to raise_error(Facter::Util::Normalization::NormalizationError, /String encoding Shift_JIS is not UTF-8 and could not be converted to UTF-8/)
+      end
+
+      it "rejects strings that claim to be UTF-8 encoded but aren't" do
+        str = "\255ay!".force_encoding(Encoding::UTF_8)
+        expect {
+          subject.normalize(str)
+        }.to raise_error(Facter::Util::Normalization::NormalizationError, /String.*doesn't match the reported encoding UTF-8/)
+      end
+    end
+
+    describe "and string encoding is not supported", :unless => String.instance_methods.include?(:encoding) do
+      it "accepts strings that are UTF-8 and match their encoding" do
+        str = "let's make a ☃!"
+        expect(subject.normalize(str)).to eq(str)
+      end
+
+      it "rejects strings that are not UTF-8" do
+        str = "let's make a \255\255\255!"
+        expect {
+          subject.normalize(str)
+        }.to raise_error(Facter::Util::Normalization::NormalizationError, /String .* is not valid UTF-8/)
+      end
+    end
+  end
+
+  describe "normalizing arrays" do
+    it "normalizes each element in the array" do
+      arr = [utf16('first'), utf16('second'), [utf16('third'), utf16('fourth')]]
+      expected_arr = [utf8('first'), utf8('second'), [utf8('third'), utf8('fourth')]]
+
+      expect(subject.normalize_array(arr)).to eq(expected_arr)
+    end
+  end
+
+  describe "normalizing hashes" do
+    it "normalizes each element in the array" do
+      hsh = {utf16('first') => utf16('second'), utf16('third') => [utf16('fourth'), utf16('fifth')]}
+      expected_hsh = {utf8('first') => utf8('second'), utf8('third') => [utf8('fourth'), utf8('fifth')]}
+
+      expect(subject.normalize_hash(hsh)).to eq(expected_hsh)
+    end
+  end
+
+  [1, 1.0, true, false, nil].each do |val|
+    it "accepts #{val.inspect}:#{val.class}" do
+      expect(subject.normalize(val)).to eq(val)
+    end
+  end
+
+  [:sym, Object.new, Set.new].each do |val|
+    it "rejects #{val.inspect}:#{val.class}" do
+      expect {
+        subject.normalize(val)
+      }.to raise_error(Facter::Util::Normalization::NormalizationError, /Expected .*but was #{val.class}/ )
+    end
+  end
+end

data/spec/unit/util/parser_spec.rb

@@ -95,7 +95,7 @@ describe Facter::Util::Parser do
     let(:data_in_txt) { "one=two\nthree=four\n" }
 
     def expects_script_to_return(path, content, result)
-      Facter::Util::Resolution.stubs(:exec).with(path).returns(content)
+      Facter::Core::Execution.stubs(:exec).with(path).returns(content)
       File.stubs(:executable?).with(path).returns(true)
       File.stubs(:file?).with(path).returns(true)
 
@@ -123,7 +123,7 @@ describe Facter::Util::Parser do
     it "quotes scripts with spaces" do
       path = "/h a s s p a c e s#{ext}"
 
-      Facter::Util::Resolution.expects(:exec).with("\"#{path}\"").returns(data_in_txt)
+      Facter::Core::Execution.expects(:exec).with("\"#{path}\"").returns(data_in_txt)
 
       expects_script_to_return(path, data_in_txt, data)
     end
@@ -149,12 +149,34 @@ describe Facter::Util::Parser do
       end
     end
 
+    context "exe, bat, cmd, and com files" do
+      let :cmds do ["/tmp/foo.bat", "/tmp/foo.cmd", "/tmp/foo.exe", "/tmp/foo.com"] end
+
+      before :each do
+        cmds.each {|cmd|
+          File.stubs(:executable?).with(cmd).returns(true)
+          File.stubs(:file?).with(cmd).returns(true)
+        }
+      end
+
+      it "should return nothing parser if not on windows" do
+        Facter::Util::Config.stubs(:is_windows?).returns(false)
+        cmds.each {|cmd| Facter::Util::Parser.parser_for(cmd).should be_an_instance_of(Facter::Util::Parser::NothingParser) }
+      end
+
+      it "should return script  parser if on windows" do
+        Facter::Util::Config.stubs(:is_windows?).returns(true)
+        cmds.each {|cmd| Facter::Util::Parser.parser_for(cmd).should be_an_instance_of(Facter::Util::Parser::ScriptParser) }
+      end
+
+     end
+
     describe "powershell parser" do
       let(:ps1) { "/tmp/foo.ps1" }
 
       def expects_to_parse_powershell(cmd, content, result)
         Facter::Util::Config.stubs(:is_windows?).returns(true)
-        Facter::Util::Resolution.stubs(:exec).returns(content)
+        Facter::Core::Execution.stubs(:exec).returns(content)
         File.stubs(:file?).with(ps1).returns(true)
 
         Facter::Util::Parser.parser_for(cmd).results.should == result

data/spec/unit/util/processor_spec.rb

@@ -70,14 +70,14 @@ describe Facter::Util::Processor do
 
     it "should get the processor description on Solaris (x86)" do
       Facter.fact(:architecture).stubs(:value).returns("i86pc")
-      Facter::Util::Resolution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-i86pc"))
+      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-i86pc"))
 
       Facter::Util::Processor.enum_kstat[0].should == "Intel(r) Core(tm) i5 CPU       M 450  @ 2.40GHz"
     end
 
     it "should get the processor description on Solaris (SPARC64)" do
       Facter.fact(:architecture).stubs(:value).returns("sun4u")
-      Facter::Util::Resolution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-sun4u"))
+      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-sun4u"))
 
       Facter::Util::Processor.enum_kstat[0].should == "SPARC64-VII"
       Facter::Util::Processor.enum_kstat[1].should == "SPARC64-VII"

data/spec/unit/util/resolution_spec.rb

@@ -6,695 +6,124 @@ require 'facter/util/resolution'
 describe Facter::Util::Resolution do
   include FacterSpec::ConfigHelper
 
-  it "should require a name" do
-    lambda { Facter::Util::Resolution.new }.should raise_error(ArgumentError)
-  end
-
-  it "should have a name" do
-    Facter::Util::Resolution.new("yay").name.should == "yay"
-  end
+  subject(:resolution) { described_class.new(:foo, stub_fact) }
 
-  it "should be able to set the value" do
-    resolve = Facter::Util::Resolution.new("yay")
-    resolve.value = "foo"
-    resolve.value.should == "foo"
-  end
-
-  it "should have a method for setting the weight" do
-    Facter::Util::Resolution.new("yay").should respond_to(:has_weight)
-  end
+  let(:stub_fact) { stub('fact', :name => :stubfact) }
 
-  it "should have a method for setting the code" do
-    Facter::Util::Resolution.new("yay").should respond_to(:setcode)
+  it "requires a name" do
+    expect { Facter::Util::Resolution.new }.to raise_error(ArgumentError)
   end
 
-  it "should support a timeout value" do
-    Facter::Util::Resolution.new("yay").should respond_to(:timeout=)
+  it "requires a fact" do
+    expect { Facter::Util::Resolution.new('yay') }.to raise_error(ArgumentError)
   end
 
-  it "should default to a timeout of 0 seconds" do
-    Facter::Util::Resolution.new("yay").limit.should == 0
+  it "can return its name" do
+    expect(resolution.name).to eq :foo
   end
 
-  it "should default to nil for code" do
-    Facter::Util::Resolution.new("yay").code.should be_nil
+  it "can explicitly set a value" do
+    resolution.value = "foo"
+    expect(resolution.value).to eq "foo"
   end
 
-  it "should default to nil for interpreter" do
-    Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version.")
-    Facter::Util::Resolution.new("yay").interpreter.should be_nil
-  end
-
-  it "should provide a 'limit' method that returns the timeout" do
-    res = Facter::Util::Resolution.new("yay")
-    res.timeout = "testing"
-    res.limit.should == "testing"
-  end
-
-
-  describe "when overriding environment variables" do
-    it "should execute the caller's block with the specified env vars" do
-      test_env = { "LANG" => "C", "FOO" => "BAR" }
-      Facter::Util::Resolution.with_env test_env do
-        test_env.keys.each do |key|
-          ENV[key].should == test_env[key]
-        end
-      end
-    end
-
-    it "should restore pre-existing environment variables to their previous values" do
-      orig_env = {}
-      new_env = {}
-      # an arbitrary sentinel value to use to temporarily set the environment vars to
-      sentinel_value = "Abracadabra"
-
-      # grab some values from the existing ENV (arbitrarily choosing 3 here)
-      ENV.keys.first(3).each do |key|
-        # save the original values so that we can test against them later
-        orig_env[key] = ENV[key]
-        # create bogus temp values for the chosen keys
-        new_env[key] = sentinel_value
-      end
-
-      # verify that, during the 'with_env', the new values are used
-      Facter::Util::Resolution.with_env new_env do
-        orig_env.keys.each do |key|
-          ENV[key].should == new_env[key]
-        end
-      end
-
-      # verify that, after the 'with_env', the old values are restored
-      orig_env.keys.each do |key|
-        ENV[key].should == orig_env[key]
-      end
-    end
-
-    it "should not be affected by a 'return' statement in the yield block" do
-      @sentinel_var = :resolution_test_foo.to_s
-
-      # the intent of this test case is to test a yield block that contains a return statement.  However, it's illegal
-      # to use a return statement outside of a method, so we need to create one here to give scope to the 'return'
-      def handy_method()
-        ENV[@sentinel_var] = "foo"
-        new_env = { @sentinel_var => "bar" }
-
-        Facter::Util::Resolution.with_env new_env do
-          ENV[@sentinel_var].should == "bar"
-          return
-        end
-      end
-
-      handy_method()
-
-      ENV[@sentinel_var].should == "foo"
-
-    end
+  it "defaults to nil for code" do
+    expect(resolution.code).to be_nil
   end
 
   describe "when setting the code" do
     before do
       Facter.stubs(:warnonce)
-      @resolve = Facter::Util::Resolution.new("yay")
-    end
-
-    it "should deprecate the interpreter argument to 'setcode'" do
-      Facter.expects(:warnonce).with("The interpreter parameter to 'setcode' is deprecated and will be removed in a future version.")
-      @resolve.setcode "foo", "bar"
-      @resolve.interpreter.should == "bar"
-    end
-
-    it "should deprecate the interpreter= method" do
-      Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter=' method is deprecated and will be removed in a future version.")
-      @resolve.interpreter = "baz"
-      @resolve.interpreter.should == "baz"
     end
 
-    it "should deprecate the interpreter method" do
-      Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version.")
-      @resolve.interpreter
+    it "creates a block when given a command" do
+      resolution.setcode "foo"
+      expect(resolution.code).to be_a_kind_of Proc
     end
 
-    it "should set the code to any provided string" do
-      @resolve.setcode "foo"
-      @resolve.code.should == "foo"
-    end
-
-    it "should set the code to any provided block" do
+    it "stores the provided block when given a block" do
       block = lambda { }
-      @resolve.setcode(&block)
-      @resolve.code.should equal(block)
-    end
-
-    it "should prefer the string over a block" do
-      @resolve.setcode("foo") { }
-      @resolve.code.should == "foo"
+      resolution.setcode(&block)
+      resolution.code.should equal(block)
     end
 
-    it "should fail if neither a string nor block has been provided" do
-      lambda { @resolve.setcode }.should raise_error(ArgumentError)
-    end
-  end
 
-  describe 'callbacks when flushing facts' do
-    class FlushFakeError < StandardError; end
-
-    subject do
-      Facter::Util::Resolution.new("jeff")
-    end
-
-    context '#on_flush' do
-      it 'accepts a block with on_flush' do
-        subject.on_flush() { raise NotImplementedError }
-      end
+    it "prefers a command over a block" do
+      block = lambda { }
+      resolution.setcode("foo", &block)
+      expect(resolution.code).to_not eq block
     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
+    it "fails if neither a string nor block has been provided" do
+      expect { resolution.setcode }.to raise_error(ArgumentError)
     end
   end
 
-  it "should be able to return a value" do
-    Facter::Util::Resolution.new("yay").should respond_to(:value)
-  end
-
   describe "when returning the value" do
-    before do
-      @resolve = Facter::Util::Resolution.new("yay")
-    end
-
-    it "should return any value that has been provided" do
-      @resolve.value = "foo"
-      @resolve.value.should == "foo"
+    it "returns any value that has been provided" do
+      resolution.value = "foo"
+      expect(resolution.value).to eq "foo"
     end
 
     describe "and setcode has not been called" do
-      it "should return nil" do
-        Facter::Util::Resolution.expects(:exec).with(nil, nil).never
-        @resolve.value.should be_nil
+      it "returns nil" do
+        expect(resolution.value).to be_nil
       end
     end
 
     describe "and the code is a string" do
-      describe "on windows" do
-        before do
-          given_a_configuration_of(:is_windows => true)
-        end
-
-        it "should return the result of executing the code" do
-          @resolve.setcode "/bin/foo"
-          Facter::Util::Resolution.expects(:exec).once.with("/bin/foo").returns "yup"
-
-          @resolve.value.should == "yup"
-        end
-
-        it "should return nil if the value is an empty string" do
-          @resolve.setcode "/bin/foo"
-          Facter::Util::Resolution.expects(:exec).once.returns ""
-          @resolve.value.should be_nil
-        end
-      end
-
-      describe "on non-windows systems" do
-        before do
-          given_a_configuration_of(:is_windows => false)
-        end
+      it "returns the result of executing the code" do
+        resolution.setcode "/bin/foo"
+        Facter::Core::Execution.expects(:exec).once.with("/bin/foo").returns "yup"
 
-        it "should return the result of executing the code" do
-          @resolve.setcode "/bin/foo"
-          Facter::Util::Resolution.expects(:exec).once.with("/bin/foo").returns "yup"
-
-          @resolve.value.should == "yup"
-        end
-
-        it "should return nil if the value is an empty string" do
-          @resolve.setcode "/bin/foo"
-          Facter::Util::Resolution.expects(:exec).once.returns ""
-          @resolve.value.should be_nil
-        end
+        expect(resolution.value).to eq "yup"
       end
     end
 
     describe "and the code is a block" do
-      it "should warn but not fail if the code fails" do
-        @resolve.setcode { raise "feh" }
-        Facter.expects(:warn)
-        @resolve.value.should be_nil
-      end
-
-      it "should return the value returned by the block" do
-        @resolve.setcode { "yayness" }
-        @resolve.value.should == "yayness"
-      end
-
-      it "should return nil if the value is an empty string" do
-        @resolve.setcode { "" }
-        @resolve.value.should be_nil
-      end
-
-      it "should return nil if the value is an empty block" do
-        @resolve.setcode { "" }
-        @resolve.value.should be_nil
-      end
-
-      it "should use its limit method to determine the timeout, to avoid conflict when a 'timeout' method exists for some other reason" do
-        @resolve.expects(:timeout).never
-        @resolve.expects(:limit).returns "foo"
-        Timeout.expects(:timeout).with("foo")
-
-        @resolve.setcode { sleep 2; "raise This is a test"}
-        @resolve.value
-      end
-
-      it "should timeout after the provided timeout" do
-        Facter.expects(:warn)
-        @resolve.timeout = 0.1
-        @resolve.setcode { sleep 2; raise "This is a test" }
-        Thread.expects(:new).yields
-
-        @resolve.value.should be_nil
-      end
-
-      it "should waitall to avoid zombies if the timeout is exceeded" do
-        Facter.stubs(:warn)
-        @resolve.timeout = 0.1
-        @resolve.setcode { sleep 2; raise "This is a test" }
-
-        Thread.expects(:new).yields
-        Process.expects(:waitall)
-
-        @resolve.value
-      end
-    end
-  end
-
-  it "should return its value when converted to a string" do
-    @resolve = Facter::Util::Resolution.new("yay")
-    @resolve.expects(:value).returns "myval"
-    @resolve.to_s.should == "myval"
-  end
-
-  it "should allow the adding of confines" do
-    Facter::Util::Resolution.new("yay").should respond_to(:confine)
-  end
-
-  it "should provide a method for returning the number of confines" do
-    @resolve = Facter::Util::Resolution.new("yay")
-    @resolve.confine "one" => "foo", "two" => "fee"
-    @resolve.weight.should == 2
-  end
-
-  it "should return 0 confines when no confines have been added" do
-    Facter::Util::Resolution.new("yay").weight.should == 0
-  end
-
-  it "should provide a way to set the weight" do
-    @resolve = Facter::Util::Resolution.new("yay")
-    @resolve.has_weight(45)
-    @resolve.weight.should == 45
-  end
-
-  it "should allow the weight to override the number of confines" do
-    @resolve = Facter::Util::Resolution.new("yay")
-    @resolve.confine "one" => "foo", "two" => "fee"
-    @resolve.weight.should == 2
-    @resolve.has_weight(45)
-    @resolve.weight.should == 45
-  end
-
-  it "should have a method for determining if it is suitable" do
-    Facter::Util::Resolution.new("yay").should respond_to(:suitable?)
-  end
-
-  describe "when adding confines" do
-    before do
-      @resolve = Facter::Util::Resolution.new("yay")
-    end
-
-    it "should accept a hash of fact names and values" do
-      lambda { @resolve.confine :one => "two" }.should_not raise_error
-    end
-
-    it "should create a Util::Confine instance for every argument in the provided hash" do
-      Facter::Util::Confine.expects(:new).with("one", "foo")
-      Facter::Util::Confine.expects(:new).with("two", "fee")
-
-      @resolve.confine "one" => "foo", "two" => "fee"
-    end
-
-  end
-
-  describe "when determining suitability" do
-    before do
-      @resolve = Facter::Util::Resolution.new("yay")
-    end
-
-    it "should always be suitable if no confines have been added" do
-      @resolve.should be_suitable
-    end
-
-    it "should be unsuitable if any provided confines return false" do
-      confine1 = mock 'confine1', :true? => true
-      confine2 = mock 'confine2', :true? => false
-      Facter::Util::Confine.expects(:new).times(2).returns(confine1).then.returns(confine2)
-      @resolve.confine :one => :two, :three => :four
-
-      @resolve.should_not be_suitable
-    end
-
-    it "should be suitable if all provided confines return true" do
-      confine1 = mock 'confine1', :true? => true
-      confine2 = mock 'confine2', :true? => true
-      Facter::Util::Confine.expects(:new).times(2).returns(confine1).then.returns(confine2)
-      @resolve.confine :one => :two, :three => :four
-
-      @resolve.should be_suitable
-    end
-  end
-
-  it "should have a class method for executing code" do
-    Facter::Util::Resolution.should respond_to(:exec)
-  end
-
-  # taken from puppet: spec/unit/util_spec.rb
-  describe "#absolute_path?" do
-    context "when run on unix", :as_platform => :posix do
-      %w[/ /foo /foo/../bar //foo //Server/Foo/Bar //?/C:/foo/bar /\Server/Foo /foo//bar/baz].each do |path|
-        it "should return true for #{path}" do
-          Facter::Util::Resolution.should be_absolute_path(path)
-        end
-      end
-
-      %w[. ./foo \foo C:/foo \\Server\Foo\Bar \\?\C:\foo\bar \/?/foo\bar \/Server/foo foo//bar/baz].each do |path|
-        it "should return false for #{path}" do
-          Facter::Util::Resolution.should_not be_absolute_path(path)
-        end
-      end
-    end
-
-    context "when run on windows", :as_platform => :windows  do
-      %w[C:/foo C:\foo \\\\Server\Foo\Bar \\\\?\C:\foo\bar //Server/Foo/Bar //?/C:/foo/bar /\?\C:/foo\bar \/Server\Foo/Bar c:/foo//bar//baz].each do |path|
-        it "should return true for #{path}" do
-          Facter::Util::Resolution.should be_absolute_path(path)
-        end
-      end
-
-      %w[/ . ./foo \foo /foo /foo/../bar //foo C:foo/bar foo//bar/baz].each do |path|
-        it "should return false for #{path}" do
-          Facter::Util::Resolution.should_not be_absolute_path(path)
-        end
+      it "returns the value returned by the block" do
+        resolution.setcode { "yayness" }
+        expect(resolution.value).to eq "yayness"
       end
     end
   end
 
-  describe "#search_paths" do
-    context "on windows", :as_platform => :windows do
-      it "should use the PATH environment variable to determine locations" do
-        ENV.expects(:[]).with('PATH').returns 'C:\Windows;C:\Windows\System32'
-        Facter::Util::Resolution.search_paths.should == %w{C:\Windows C:\Windows\System32}
-      end
-    end
-
-    context "on posix", :as_platform => :posix do
-      it "should use the PATH environment variable plus /sbin and /usr/sbin on unix" do
-        ENV.expects(:[]).with('PATH').returns "/bin:/usr/bin"
-        Facter::Util::Resolution.search_paths.should == %w{/bin /usr/bin /sbin /usr/sbin}
-      end
+  describe "setting options" do
+    it "can set the value" do
+      resolution.set_options(:value => 'something')
+      expect(resolution.value).to eq 'something'
     end
-  end
-
-  describe "#which" do
-    context "when run on posix", :as_platform => :posix  do
-      before :each do
-        Facter::Util::Resolution.stubs(:search_paths).returns [ '/bin', '/sbin', '/usr/sbin']
-      end
-
-      context "and provided with an absolute path" do
-        it "should return the binary if executable" do
-          File.expects(:executable?).with('/opt/foo').returns true
-          Facter::Util::Resolution.which('/opt/foo').should == '/opt/foo'
-        end
-
-        it "should return nil if the binary is not executable" do
-          File.expects(:executable?).with('/opt/foo').returns false
-          Facter::Util::Resolution.which('/opt/foo').should be_nil
-        end
-      end
 
-      context "and not provided with an absolute path" do
-        it "should return the absolute path if found" do
-          File.expects(:executable?).with('/bin/foo').returns false
-          File.expects(:executable?).with('/sbin/foo').returns true
-          File.expects(:executable?).with('/usr/sbin/foo').never
-          Facter::Util::Resolution.which('foo').should == '/sbin/foo'
-        end
-
-        it "should return nil if not found" do
-          File.expects(:executable?).with('/bin/foo').returns false
-          File.expects(:executable?).with('/sbin/foo').returns false
-          File.expects(:executable?).with('/usr/sbin/foo').returns false
-          Facter::Util::Resolution.which('foo').should be_nil
-        end
-      end
+    it "can set the timeout" do
+      resolution.set_options(:timeout => 314)
+      expect(resolution.limit).to eq 314
     end
 
-    context "when run on windows", :as_platform => :windows do
-      before :each do
-        Facter::Util::Resolution.stubs(:search_paths).returns ['C:\Windows\system32', 'C:\Windows', 'C:\Windows\System32\Wbem' ]
-        ENV.stubs(:[]).with('PATHEXT').returns nil
-      end
-
-      context "and provided with an absolute path" do
-        it "should return the binary if executable" do
-          File.expects(:executable?).with('C:\Tools\foo.exe').returns true
-          File.expects(:executable?).with('\\\\remote\dir\foo.exe').returns true
-          Facter::Util::Resolution.which('C:\Tools\foo.exe').should == 'C:\Tools\foo.exe'
-          Facter::Util::Resolution.which('\\\\remote\dir\foo.exe').should == '\\\\remote\dir\foo.exe'
-        end
-
-        it "should return the binary with added extension if executable" do
-          ['.COM', '.BAT', '.CMD', '' ].each do |ext|
-            File.stubs(:executable?).with('C:\Windows\system32\netsh'+ext).returns false
-          end
-          File.expects(:executable?).with('C:\Windows\system32\netsh.EXE').returns true
-
-          Facter.expects(:warnonce).with('Using Facter::Util::Resolution.which with an absolute path like C:\\Windows\\system32\\netsh but no fileextension is deprecated. Please add the correct extension (.EXE)')
-          Facter::Util::Resolution.which('C:\Windows\system32\netsh').should == 'C:\Windows\system32\netsh.EXE'
-        end
-
-        it "should return nil if the binary is not executable" do
-          File.expects(:executable?).with('C:\Tools\foo.exe').returns false
-          File.expects(:executable?).with('\\\\remote\dir\foo.exe').returns false
-          Facter::Util::Resolution.which('C:\Tools\foo.exe').should be_nil
-          Facter::Util::Resolution.which('\\\\remote\dir\foo.exe').should be_nil
-        end
-      end
-
-      context "and not provided with an absolute path" do
-        it "should return the absolute path if found" do
-          File.expects(:executable?).with('C:\Windows\system32\foo.exe').returns false
-          File.expects(:executable?).with('C:\Windows\foo.exe').returns true
-          File.expects(:executable?).with('C:\Windows\System32\Wbem\foo.exe').never
-          Facter::Util::Resolution.which('foo.exe').should == 'C:\Windows\foo.exe'
-        end
-
-        it "should return the absolute path with file extension if found" do
-          ['.COM', '.EXE', '.BAT', '.CMD', '' ].each do |ext|
-            File.stubs(:executable?).with('C:\Windows\system32\foo'+ext).returns false
-            File.stubs(:executable?).with('C:\Windows\System32\Wbem\foo'+ext).returns false
-          end
-          ['.COM', '.BAT', '.CMD', '' ].each do |ext|
-            File.stubs(:executable?).with('C:\Windows\foo'+ext).returns false
-          end
-          File.stubs(:executable?).with('C:\Windows\foo.EXE').returns true
-
-          Facter::Util::Resolution.which('foo').should == 'C:\Windows\foo.EXE'
-        end
-
-        it "should return nil if not found" do
-          File.expects(:executable?).with('C:\Windows\system32\foo.exe').returns false
-          File.expects(:executable?).with('C:\Windows\foo.exe').returns false
-          File.expects(:executable?).with('C:\Windows\System32\Wbem\foo.exe').returns false
-          Facter::Util::Resolution.which('foo.exe').should be_nil
-        end
-      end
+    it "can set the weight" do
+      resolution.set_options(:weight => 27)
+      expect(resolution.weight).to eq 27
     end
 
-    describe "#expand_command" do
-      context "on windows", :as_platform => :windows do
-        it "should expand binary" do
-          Facter::Util::Resolution.expects(:which).with('cmd').returns 'C:\Windows\System32\cmd'
-          Facter::Util::Resolution.expand_command(
-            'cmd /c echo foo > C:\bar'
-          ).should == 'C:\Windows\System32\cmd /c echo foo > C:\bar'
-        end
-
-        it "should expand double quoted binary" do
-          Facter::Util::Resolution.expects(:which).with('my foo').returns 'C:\My Tools\my foo.exe'
-          Facter::Util::Resolution.expand_command('"my foo" /a /b').should == '"C:\My Tools\my foo.exe" /a /b'
-        end
-
-        it "should not expand single quoted binary" do
-          Facter::Util::Resolution.expects(:which).with('\'C:\My').returns nil
-          Facter::Util::Resolution.expand_command('\'C:\My Tools\foo.exe\' /a /b').should be_nil
-        end
-
-        it "should quote expanded binary if found in path with spaces" do
-          Facter::Util::Resolution.expects(:which).with('foo').returns 'C:\My Tools\foo.exe'
-          Facter::Util::Resolution.expand_command('foo /a /b').should == '"C:\My Tools\foo.exe" /a /b'
-        end
-
-        it "should return nil if not found" do
-          Facter::Util::Resolution.expects(:which).with('foo').returns nil
-          Facter::Util::Resolution.expand_command('foo /a | stuff >> /dev/null').should be_nil
-        end
-      end
-
-      context "on unix", :as_platform => :posix do
-        it "should expand binary" do
-          Facter::Util::Resolution.expects(:which).with('foo').returns '/bin/foo'
-          Facter::Util::Resolution.expand_command('foo -a | stuff >> /dev/null').should == '/bin/foo -a | stuff >> /dev/null'
-        end
-
-        it "should expand double quoted binary" do
-          Facter::Util::Resolution.expects(:which).with('/tmp/my foo').returns '/tmp/my foo'
-          Facter::Util::Resolution.expand_command(%q{"/tmp/my foo" bar}).should == %q{"/tmp/my foo" bar}
-        end
-
-        it "should expand single quoted binary" do
-          Facter::Util::Resolution.expects(:which).with('my foo').returns '/home/bob/my path/my foo'
-          Facter::Util::Resolution.expand_command(%q{'my foo' -a}).should == %q{'/home/bob/my path/my foo' -a}
-        end
-
-        it "should quote expanded binary if found in path with spaces" do
-          Facter::Util::Resolution.expects(:which).with('foo.sh').returns '/home/bob/my tools/foo.sh'
-          Facter::Util::Resolution.expand_command('foo.sh /a /b').should == %q{'/home/bob/my tools/foo.sh' /a /b}
-        end
-
-        it "should return nil if not found" do
-          Facter::Util::Resolution.expects(:which).with('foo').returns nil
-          Facter::Util::Resolution.expand_command('foo -a | stuff >> /dev/null').should be_nil
-        end
-      end
+    it "fails on unhandled options" do
+      expect do
+        resolution.set_options(:foo => 'bar')
+      end.to raise_error(ArgumentError, /Invalid resolution options.*foo/)
     end
-
   end
 
-  # It's not possible, AFAICT, to mock %x{}, so I can't really test this bit.
-  describe "when executing code" do
-    # set up some command strings, making sure we get the right version for both unix and windows
-    echo_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c "echo foo"' : 'echo foo'
-    echo_env_var_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c "echo %%%s%%"' : 'echo $%s'
-
-    it "should deprecate the interpreter parameter" do
-      Facter.expects(:warnonce).with("The interpreter parameter to 'exec' is deprecated and will be removed in a future version.")
-      Facter::Util::Resolution.exec("/something", "/bin/perl")
-    end
-
-    # execute a simple echo command
-    it "should execute the binary" do
-      Facter::Util::Resolution.exec(echo_command).should == "foo"
-    end
-
-    it "should override the LANG environment variable" do
-      Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
-    end
-
-    it "should respect other overridden environment variables" do
-      Facter::Util::Resolution.with_env( {"FOO" => "foo"} ) do
-        Facter::Util::Resolution.exec(echo_env_var_command % 'FOO').should == "foo"
-      end
-    end
-
-    it "should restore overridden LANG environment variable after execution" do
-      # we're going to call with_env in a nested fashion, to make sure that the environment gets restored properly
-      # at each level
-      Facter::Util::Resolution.with_env( {"LANG" => "foo"} ) do
-        # Resolution.exec always overrides 'LANG' for its own execution scope
-        Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
-        # But after 'exec' completes, we should see our value restored
-        ENV['LANG'].should == "foo"
-        # Now we'll do a nested call to with_env
-        Facter::Util::Resolution.with_env( {"LANG" => "bar"} ) do
-          # During 'exec' it should still be 'C'
-          Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
-          # After exec it should be restored to our current value for this level of the nesting...
-          ENV['LANG'].should == "bar"
-        end
-        # Now we've dropped out of one level of nesting,
-        ENV['LANG'].should == "foo"
-        # Call exec one more time just for kicks
-        Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
-        # One last check at our current nesting level.
-        ENV['LANG'].should == "foo"
-      end
+  describe "evaluating" do
+    it "evaluates the block in the context of the given resolution" do
+      subject.expects(:has_weight).with(5)
+      subject.evaluate { has_weight(5) }
     end
 
-    context "when run on unix", :as_platform => :posix  do
-      context "binary is present" do
-        it "should run the command if path to binary is absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with('/usr/bin/uname -m').returns('/usr/bin/uname -m')
-          Facter::Util::Resolution.expects(:`).with('/usr/bin/uname -m').returns 'x86_64'
-          Facter::Util::Resolution.exec('/usr/bin/uname -m').should == 'x86_64'
-        end
-
-        it "should run the expanded command if path to binary not absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with('uname -m').returns('/usr/bin/uname -m')
-          Facter::Util::Resolution.expects(:`).with('/usr/bin/uname -m').returns 'x86_64'
-          Facter::Util::Resolution.exec('uname -m').should == 'x86_64'
-        end
+    it "raises a warning if the resolution is evaluated twice" do
+      Facter.expects(:warn).with do |msg|
+        expect(msg).to match /Already evaluated foo at.*reevaluating anyways/
       end
 
-      context "binary is not present" do
-        it "should not run the command if path to binary is absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with('/usr/bin/uname -m').returns nil
-          Facter::Util::Resolution.expects(:`).with('/usr/bin/uname -m').never
-          Facter::Util::Resolution.exec('/usr/bin/uname -m').should be_nil
-        end
-        it "should not run the command if path to binary is not absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with('uname -m').returns nil
-          Facter::Util::Resolution.expects(:`).with('uname -m').never
-          Facter::Util::Resolution.exec('uname -m').should be_nil
-        end
-      end
-    end
-
-    context "when run on windows", :as_platform => :windows do
-      context "binary is present" do
-        it "should run the command if path to binary is absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with(%q{C:\Windows\foo.exe /a /b}).returns(%q{C:\Windows\foo.exe /a /b})
-          Facter::Util::Resolution.expects(:`).with(%q{C:\Windows\foo.exe /a /b}).returns 'bar'
-          Facter::Util::Resolution.exec(%q{C:\Windows\foo.exe /a /b}).should == 'bar'
-        end
-
-        it "should run the expanded command if path to binary not absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with(%q{foo.exe /a /b}).returns(%q{C:\Windows\foo.exe /a /b})
-          Facter::Util::Resolution.expects(:`).with(%q{C:\Windows\foo.exe /a /b}).returns 'bar'
-          Facter::Util::Resolution.exec(%q{foo.exe /a /b}).should == 'bar'
-        end
-      end
-
-      context "binary is not present" do
-        it "should not run the command if path to binary is absolute" do
-          Facter::Util::Resolution.expects(:expand_command).with(%q{C:\Windows\foo.exe /a /b}).returns nil
-          Facter::Util::Resolution.expects(:`).with(%q{C:\Windows\foo.exe /a /b}).never
-          Facter::Util::Resolution.exec(%q{C:\Windows\foo.exe /a /b}).should be_nil
-        end
-        it "should try to run the command and return output of a shell-builtin" do
-          Facter::Util::Resolution.expects(:expand_command).with(%q{echo foo}).returns nil
-          Facter::Util::Resolution.expects(:`).with(%q{echo foo}).returns 'foo'
-          Facter.expects(:warnonce).with 'Using Facter::Util::Resolution.exec with a shell built-in is deprecated. Most built-ins can be replaced with native ruby commands. If you really have to run a built-in, pass "cmd /c your_builtin" as a command (command responsible for this message was "echo foo")'
-          Facter::Util::Resolution.exec(%q{echo foo}).should == 'foo'
-        end
-        it "should try to run the command and return nil if not shell-builtin" do
-          Facter::Util::Resolution.expects(:expand_command).with(%q{echo foo}).returns nil
-          Facter::Util::Resolution.stubs(:`).with(%q{echo foo}).raises Errno::ENOENT, 'some_error_message'
-          Facter.expects(:warnonce).never
-          Facter::Util::Resolution.exec(%q{echo foo}).should be_nil
-        end
-      end
+      subject.evaluate { }
+      subject.evaluate { }
     end
   end
 end