hiera 1.3.0 → 2.0.0

data/lib/hiera/interpolate.rb

@@ -1,28 +1,71 @@
 require 'hiera/backend'
+require 'hiera/recursive_guard'
+
+
+class Hiera::InterpolationInvalidValue < StandardError; end
 
 class Hiera::Interpolate
   class << self
     INTERPOLATION = /%\{([^\}]*)\}/
-    METHOD_INTERPOLATION = /%\{(scope|hiera)\(['"]([^"']*)["']\)\}/
+    METHOD_INTERPOLATION = /%\{(scope|hiera|literal|alias)\(['"]([^"']*)["']\)\}/
+
+    def interpolate(data, scope, extra_data, context)
+      if data.is_a?(String)
+        # Wrapping do_interpolation in a gsub block ensures we process
+        # each interpolation site in isolation using separate recursion guards.
+        context ||= {}
+        new_context = context.clone
+        new_context[:recurse_guard] ||= Hiera::RecursiveGuard.new
+        data.gsub(INTERPOLATION) do |match|
+          interp_val = do_interpolation(match, scope, extra_data, new_context)
 
-    def interpolate(data, recurse_guard, scope, extra_data)
+          # Get interp method in case we are aliasing
+          if data.is_a?(String) && (match = data.match(INTERPOLATION))
+            interpolate_method, key = get_interpolation_method_and_key(data)
+          else
+            interpolate_method = nil
+          end
+
+          if ( (interpolate_method == :alias_interpolate) and (!interp_val.is_a?(String)) )
+            if data.match("^#{INTERPOLATION}$")
+              return interp_val
+            else
+              raise Hiera::InterpolationInvalidValue, "Cannot call alias in the string context"
+            end
+          else
+            interp_val
+          end
+        end
+      else
+        data
+      end
+    end
+
+    def do_interpolation(data, scope, extra_data, context)
       if data.is_a?(String) && (match = data.match(INTERPOLATION))
         interpolation_variable = match[1]
-        recurse_guard.check(interpolation_variable) do
+        context[:recurse_guard].check(interpolation_variable) do
           interpolate_method, key = get_interpolation_method_and_key(data)
-          interpolated_data = send(interpolate_method, data, key, scope, extra_data)
-          interpolate(interpolated_data, recurse_guard, scope, extra_data)
+          interpolated_data = send(interpolate_method, data, key, scope, extra_data, context)
+
+          # Halt recursion if we encounter a literal.
+          return interpolated_data if interpolate_method == :literal_interpolate
+
+          do_interpolation(interpolated_data, scope, extra_data, context)
         end
       else
         data
       end
     end
+    private :do_interpolation
 
     def get_interpolation_method_and_key(data)
       if (match = data.match(METHOD_INTERPOLATION))
         case match[1]
         when 'hiera' then [:hiera_interpolate, match[2]]
         when 'scope' then [:scope_interpolate, match[2]]
+        when 'literal' then [:literal_interpolate, match[2]]
+        when 'alias' then [:alias_interpolate, match[2]]
         end
       elsif (match = data.match(INTERPOLATION))
         [:scope_interpolate, match[1]]
@@ -30,19 +73,26 @@ class Hiera::Interpolate
     end
     private :get_interpolation_method_and_key
 
-    def scope_interpolate(data, key, scope, extra_data)
-      value = scope[key]
-      if value.nil? || value == :undefined
-        value = extra_data[key]
-      end
-      data.sub(INTERPOLATION, value.to_s)
+    def scope_interpolate(data, key, scope, extra_data, context)
+      segments = key.split('.')
+      catch(:no_such_key) { return Hiera::Backend.qualified_lookup(segments, scope) }
+      catch(:no_such_key) { Hiera::Backend.qualified_lookup(segments, extra_data) }
     end
     private :scope_interpolate
 
-    def hiera_interpolate(data, key, scope, extra_data)
-      value = Hiera::Backend.lookup(key, nil, scope, nil, :priority)
-      data.sub(METHOD_INTERPOLATION, value)
+    def hiera_interpolate(data, key, scope, extra_data, context)
+      Hiera::Backend.lookup(key, nil, scope, context[:order_override], :priority, context)
     end
     private :hiera_interpolate
+
+    def literal_interpolate(data, key, scope, extra_data, context)
+      key
+    end
+    private :literal_interpolate
+
+    def alias_interpolate(data, key, scope, extra_data, context)
+      Hiera::Backend.lookup(key, nil, scope, context[:order_override], :priority, context)
+    end
+    private :alias_interpolate
   end
 end

data/lib/hiera/util.rb

@@ -9,7 +9,7 @@ class Hiera
 
     def microsoft_windows?
       return false unless file_alt_separator
-      
+
       begin
         require 'win32/dir'
         true
@@ -21,17 +21,17 @@ class Hiera
 
     def config_dir
       if microsoft_windows?
-         File.join(common_appdata, 'PuppetLabs', 'hiera', 'etc')
+         File.join(common_appdata, 'PuppetLabs', 'code')
       else
-        '/etc'
+        '/etc/puppetlabs/code'
       end
     end
 
     def var_dir
       if microsoft_windows?
-        File.join(common_appdata, 'PuppetLabs', 'hiera', 'var')
+        File.join(common_appdata, 'PuppetLabs', 'code', 'hieradata')
       else
-        '/var/lib/hiera'
+        '/etc/puppetlabs/code/hieradata'
       end
     end
 

data/lib/hiera/version.rb

@@ -7,7 +7,7 @@
 
 
 class Hiera
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 
   ##
   # version is a public API method intended to always provide a fast and

data/lib/hiera.rb

@@ -49,15 +49,67 @@ class Hiera
 
   # Calls the backends to do the actual lookup.
   #
-  # The scope can be anything that responds to [], if you have input
+  # The _scope_ can be anything that responds to `[]`, if you have input
   # data like a Puppet Scope that does not you can wrap that data in a
-  # class that has a [] method that fetches the data from your source.
+  # class that has a `[]` method that fetches the data from your source.
   # See hiera-puppet for an example of this.
   #
   # The order-override will insert as first in the hierarchy a data source
   # of your choice.
+  #
+  # Possible values for the _resolution_type_ parameter:
+  #
+  # - _:priority_ - This is the default. First found value is returned and no merge is performed
+  # - _:array_ - An array merge lookup assembles a value from every matching level of the hierarchy. It retrieves all
+  #     of the (string or array) values for a given key, then flattens them into a single array of unique values.
+  #     If _priority_ lookup can be thought of as a “default with overrides” pattern, _array_ merge lookup can be though
+  #     of as “default with additions.”
+  # - _:hash_ - A hash merge lookup assembles a value from every matching level of the hierarchy. It retrieves all of
+  #     the (hash) values for a given key, then merges the hashes into a single hash. Hash merge lookups will fail with
+  #     an error if any of the values found in the data sources are strings or arrays. It only works when every value
+  #     found is a hash. The actual merge behavior is determined by looking up the keys `:merge_behavior` and
+  #     `:deep_merge_options` in the Hiera config. `:merge_behavior` can be set to `:deep`, :deeper` or `:native`
+  #     (explained in detail below).
+  # - _{ deep merge options }_ - Configured values for `:merge_behavior` and `:deep_merge_options`will be completely
+  #     ignored. Instead the _resolution_type_ will be a `:hash` merge where the `:merge_behavior` will be the value
+  #     keyed by `:behavior` in the given hash and the `:deep_merge_options` will be the remaining top level entries of
+  #     that same hash.
+  #
+  # Valid behaviors for the _:hash_ resolution type:
+  #
+  # - _native_ - Performs a simple hash-merge by overwriting keys of lower lookup priority.
+  # - _deeper_ - In a deeper hash merge, Hiera recursively merges keys and values in each source hash. For each key,
+  #     if the value is:
+  #        - only present in one source hash, it goes into the final hash.
+  #        - a string/number/boolean and exists in two or more source hashes, the highest priority value goes into
+  #          the final hash.
+  #        - an array and exists in two or more source hashes, the values from each source are merged into a single
+  #          array and de-duplicated (but not automatically flattened, as in an array merge lookup).
+  #        - a hash and exists in two or more source hashes, the values from each source are recursively merged, as
+  #          though they were source hashes.
+  #        - mismatched between two or more source hashes, we haven’t validated the behavior. It should act as
+  #          described in the deep_merge gem documentation.
+  # - _deep_ - In a deep hash merge, Hiera behaves the same as for _deeper_, except that when a string/number/boolean
+  #     exists in two or more source hashes, the lowest priority value goes into the final hash. This is considered
+  #     largely useless and should be avoided. Use _deeper_ instead.
+  #
+  # The _merge_ can be given as a hash with the mandatory key `:strategy` to denote the actual strategy. This
+  # is useful for the `:deeper` and `:deep` strategy since they can use additional options to control the behavior.
+  # The options can be passed as top level keys in the `merge` parameter when it is a given as a hash. Recognized
+  # options are:
+  #
+  #  - 'knockout_prefix' Set to string value to signify prefix which deletes elements from existing element. Defaults is _undef_
+  #  - 'sort_merged_arrays' Set to _true_ to sort all arrays that are merged together. Default is _false_
+  #  - 'unpack_arrays' Set to string value used as a deliminator to join all array values and then split them again. Default is _undef_
+  #  - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
+  #
+  # @param key [String] The key to lookup
+  # @param default [Object,nil] The value to return when there is no match for _key_
+  # @param scope [#[],nil] The scope to use for the lookup
+  # @param order_override [#[]] An override that will considered the first source of lookup
+  # @param resolution_type [String,Hash<Symbol,String>] Symbolic resolution type or deep merge configuration
+  # @return [Object] The found value or the given _default_ value
   def lookup(key, default, scope, order_override=nil, resolution_type=:priority)
     Backend.lookup(key, default, scope, order_override, resolution_type)
   end
 end
-

data/spec/spec_helper.rb

@@ -8,6 +8,29 @@ require 'tmpdir'
 
 RSpec.configure do |config|
   config.mock_with :mocha
+
+  if Hiera::Util.microsoft_windows? && RUBY_VERSION =~ /^1\./
+    require 'win32console'
+    config.output_stream = $stdout
+    config.error_stream = $stderr
+    config.formatters.each { |f| f.instance_variable_set(:@output, $stdout) }
+  end
+
+  config.after :suite do
+    # Log the spec order to a file, but only if the LOG_SPEC_ORDER environment variable is
+    #  set.  This should be enabled on Jenkins runs, as it can be used with Nick L.'s bisect
+    #  script to help identify and debug order-dependent spec failures.
+    if ENV['LOG_SPEC_ORDER']
+      File.open("./spec_order.txt", "w") do |logfile|
+        config.instance_variable_get(:@files_to_run).each { |f| logfile.puts f }
+      end
+    end
+  end
+end
+
+# So everyone else doesn't have to include this base constant.
+module HieraSpec
+  FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), 'unit', 'fixtures') unless defined?(FIXTURE_DIR)
 end
 
 # In ruby 1.8.5 Dir does not have mktmpdir defined, so this monkey patches

data/spec/unit/backend/json_backend_spec.rb

@@ -25,7 +25,7 @@ class Hiera
           Backend.expects(:datafile).with(:json, {}, "one", "json").returns(nil)
           Backend.expects(:datafile).with(:json, {}, "two", "json").returns(nil)
 
-          @backend.lookup("key", {}, nil, :priority)
+          expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
         end
 
         it "should retain the data types found in data files" do
@@ -35,9 +35,9 @@ class Hiera
 
           @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"stringval" => "string", "boolval" => true, "numericval" => 1}).times(3)
 
-          @backend.lookup("stringval", {}, nil, :priority).should == "string"
-          @backend.lookup("boolval", {}, nil, :priority).should == true
-          @backend.lookup("numericval", {}, nil, :priority).should == 1
+          @backend.lookup("stringval", {}, nil, :priority, nil).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
+          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
         end
 
         it "should pick data earliest source that has it for priority searches" do
@@ -49,12 +49,12 @@ class Hiera
           File.stubs(:exist?).with("/nonexisting/one.json").returns(true)
           @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "test_%{rspec}"})
 
-          @backend.lookup("key", scope, nil, :priority).should == "test_test"
+          @backend.lookup("key", scope, nil, :priority, nil).should == "test_test"
         end
 
         it "should build an array of all data sources for array searches" do
           Hiera::Backend.stubs(:empty_answer).returns([])
-          Backend.stubs(:parse_answer).with('answer', {}).returns("answer")
+          Backend.stubs(:parse_answer).with('answer', {}, {}, anything).returns("answer")
           Backend.expects(:datafile).with(:json, {}, "one", "json").returns("/nonexisting/one.json")
           Backend.expects(:datafile).with(:json, {}, "two", "json").returns("/nonexisting/two.json")
 
@@ -66,18 +66,18 @@ class Hiera
           @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "answer"})
           @cache.expects(:read_file).with("/nonexisting/two.json", Hash).returns({"key" => "answer"})
 
-          @backend.lookup("key", {}, nil, :array).should == ["answer", "answer"]
+          @backend.lookup("key", {}, nil, :array, nil).should == ["answer", "answer"]
         end
 
         it "should parse the answer for scope variables" do
-          Backend.stubs(:parse_answer).with('test_%{rspec}', {'rspec' => 'test'}).returns("test_test")
+          Backend.stubs(:parse_answer).with('test_%{rspec}', {'rspec' => 'test'}, {}, anything).returns("test_test")
           Backend.expects(:datasources).yields("one")
           Backend.expects(:datafile).with(:json, {"rspec" => "test"}, "one", "json").returns("/nonexisting/one.json")
 
           File.expects(:exist?).with("/nonexisting/one.json").returns(true)
           @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "test_%{rspec}"})
 
-          @backend.lookup("key", {"rspec" => "test"}, nil, :priority).should == "test_test"
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
         end
       end
     end

data/spec/unit/backend/yaml_backend_spec.rb

@@ -3,12 +3,29 @@ require 'hiera/backend/yaml_backend'
 
 class Hiera
   module Backend
+    class FakeCache
+      attr_accessor :value
+      def read(path, expected_type, default, &block)
+        read_file(path, expected_type, &block)
+      rescue => e
+        default
+      end
+
+      def read_file(path, expected_type, &block)
+        output = block.call(@value)
+        if !output.is_a? expected_type
+          raise TypeError
+        end
+        output
+      end
+    end
+
     describe Yaml_backend do
       before do
         Config.load({})
         Hiera.stubs(:debug)
         Hiera.stubs(:warn)
-        @cache = mock
+        @cache = FakeCache.new
         @backend = Yaml_backend.new(@cache)
       end
 
@@ -20,128 +37,100 @@ class Hiera
       end
 
       describe "#lookup" do
-        it "should look for data in all sources" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(nil)
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns(nil)
-
-          @backend.lookup("key", {}, nil, :priority)
-        end
-
         it "should pick data earliest source that has it for priority searches" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns(nil).never
-          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"answer"})
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-
-          @backend.lookup("key", {}, nil, :priority).should == "answer"
-        end
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
+          @cache.value = "---\nkey: answer"
 
-        it "should not look up missing data files" do
-          Backend.expects(:datasources).multiple_yields(["one"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(nil)
-          YAML.expects(:load_file).never
-
-          @backend.lookup("key", {}, nil, :priority)
+          @backend.lookup("key", {}, nil, :priority, nil).should == "answer"
         end
 
-        it "should return nil for empty data files" do
-          Backend.expects(:datasources).multiple_yields(["one"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({})
-
-          @backend.lookup("key", {}, nil, :priority).should be_nil
+        describe "handling unexpected YAML values" do
+          before do
+            Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
+          end
+
+          it "throws :no_such_key when key is missing in YAML" do
+            @cache.value = "---\n"
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+          end
+
+          it "returns nil when the YAML value is nil" do
+            @cache.value = "key: ~\n"
+            @backend.lookup("key", {}, nil, :priority, nil).should be_nil
+          end
+
+          it "throws :no_such_key when the YAML file is false" do
+            @cache.value = ""
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+          end
+
+          it "raises a TypeError when the YAML value is not a hash" do
+            @cache.value = "---\n[one, two, three]"
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to raise_error(TypeError)
+          end
         end
 
         it "should build an array of all data sources for array searches" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-          File.stubs(:exist?).with("/nonexisting/two.yaml").returns(true)
-
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"answer"})
           @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>"answer"})
 
-          @backend.lookup("key", {}, nil, :array).should == ["answer", "answer"]
+          @backend.lookup("key", {}, nil, :array, nil).should == ["answer", "answer"]
         end
 
         it "should ignore empty hash of data sources for hash searches" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-          File.stubs(:exist?).with("/nonexisting/two.yaml").returns(true)
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
 
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({})
           @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
 
-          @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer"}
+          @backend.lookup("key", {}, nil, :hash, nil).should == {"a" => "answer"}
         end
 
         it "should build a merged hash of data sources for hash searches" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-          File.stubs(:exist?).with("/nonexisting/two.yaml").returns(true)
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
 
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
           @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"b"=>"answer", "a"=>"wrong"}})
 
-          @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer", "b" => "answer"}
+          @backend.lookup("key", {}, nil, :hash, nil).should == {"a" => "answer", "b" => "answer"}
         end
 
         it "should fail when trying to << a Hash" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-          File.stubs(:exist?).with("/nonexisting/two.yaml").returns(true)
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
 
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>["a", "answer"]})
           @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
 
-          expect {@backend.lookup("key", {}, nil, :array)}.to raise_error(Exception, "Hiera type mismatch: expected Array and got Hash")
+          expect {@backend.lookup("key", {}, nil, :array, nil)}.to raise_error(Exception, "Hiera type mismatch for key 'key': expected Array and got Hash")
         end
 
         it "should fail when trying to merge an Array" do
-          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
-          File.stubs(:exist?).with("/nonexisting/two.yaml").returns(true)
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
 
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
           @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>["a", "wrong"]})
 
-          expect { @backend.lookup("key", {}, nil, :hash) }.to raise_error(Exception, "Hiera type mismatch: expected Hash and got Array")
+          expect { @backend.lookup("key", {}, nil, :hash, nil) }.to raise_error(Exception, "Hiera type mismatch for key 'key': expected Hash and got Array")
         end
 
         it "should parse the answer for scope variables" do
-          Backend.expects(:datasources).yields("one")
-          Backend.expects(:datafile).with(:yaml, {"rspec" => "test"}, "one", "yaml").returns("/nonexisting/one.yaml")
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
+          Backend.expects(:datasourcefiles).with(:yaml, {"rspec" => "test"}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"])
 
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"test_%{rspec}"})
 
-          @backend.lookup("key", {"rspec" => "test"}, nil, :priority).should == "test_test"
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
         end
 
         it "should retain datatypes found in yaml files" do
-          Backend.expects(:datasources).yields("one").times(3)
-          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml").times(3)
-          File.stubs(:exist?).with("/nonexisting/one.yaml").returns(true)
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"]).times(3)
 
-          yaml = "---\nstringval: 'string'\nboolval: true\nnumericval: 1"
 
-          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).times(3).returns({"boolval"=>true, "numericval"=>1, "stringval"=>"string"})
+          @cache.value = "---\nstringval: 'string'\nboolval: true\nnumericval: 1"
 
-          @backend.lookup("stringval", {}, nil, :priority).should == "string"
-          @backend.lookup("boolval", {}, nil, :priority).should == true
-          @backend.lookup("numericval", {}, nil, :priority).should == 1
+          @backend.lookup("stringval", {}, nil, :priority, nil).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
+          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
         end
       end
     end