hiera 1.3.0 → 2.0.0

data/spec/unit/backend_spec.rb

@@ -2,6 +2,14 @@ require 'spec_helper'
 require 'hiera/util'
 
 class Hiera
+  module Backend
+    class Backend1x_backend
+      def lookup(key, scope, order_override, resolution_type)
+        ["a", "b"]
+      end
+    end
+  end
+
   describe Backend do
     describe "#datadir" do
       it "interpolates any values in the configured value" do
@@ -84,7 +92,7 @@ class Hiera
       end
 
       it "parses the names of the hierarchy levels using the given scope" do
-        Backend.expects(:parse_string).with("common", {:rspec => :tests})
+        Backend.expects(:parse_string).with("common", {:rspec => :tests}, {}, {:order_override => nil})
         Backend.datasources({:rspec => :tests}) { }
       end
 
@@ -181,17 +189,6 @@ class Hiera
         "test_%{scope('rspec')}_test" => "test__test"
       }
 
-      @interprets_undefined_in_scope_tests.each do |input, expected|
-        it "interprets :undefined in scope as a non-value" do
-          Backend.parse_string(input, {"rspec" => :undefined}).should == expected
-        end
-      end
-
-      it "uses the value from extra_data when scope is :undefined" do
-        input = "test_%{rspec}_test"
-        Backend.parse_string(input, {"rspec" => :undefined}, { "rspec" => "extra" }).should == "test_extra_test"
-      end
-
       @exact_lookup_tests = {
         "test_%{::rspec::data}_test" => "test_value_test",
         "test_%{scope('::rspec::data')}_test" => "test_value_test"
@@ -253,15 +250,32 @@ class Hiera
         end.to raise_error Hiera::InterpolationLoop, "Detected in [first, second]"
       end
 
+      it "replaces repeated occurances of the same lookup" do
+        scope = {"rspec" => "value"}
+        input = "it replaces %{rspec} and %{rspec}"
+        Backend.parse_string(input, scope).should == "it replaces value and value"
+      end
+
       it "replaces hiera interpolations with data looked up in hiera" do
         input = "%{hiera('key1')}"
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("key1", scope, nil, :priority).returns("answer")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("key1", scope, nil, :priority, instance_of(Hash)).returns("answer")
 
         Backend.parse_string(input, scope).should == "answer"
       end
+
+      it "interpolation passes the order_override back into the backend" do
+        Backend.expects(:lookup).with("lookup::key", nil, {}, "order_override_datasource", :priority, instance_of(Hash))
+        Backend.parse_string("%{hiera('lookup::key')}", {}, {}, {:order_override => "order_override_datasource"})
+      end
+
+      it "replaces literal interpolations with their argument" do
+        scope = {}
+        input = "%{literal('%')}{rspec::data}"
+        Backend.parse_string(input, scope).should == "%{rspec::data}"
+      end
     end
 
     describe "#parse_answer" do
@@ -300,16 +314,47 @@ class Hiera
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("test")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("test")
         Backend.parse_answer(input, scope).should == "test_test_test"
       end
 
+      it "interpolates alias lookups with non-string types" do
+        input = "%{alias('rspec')}"
+        scope = {}
+        Config.load({:yaml => {:datadir => "/tmp"}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns(['test', 'test'])
+        Backend.parse_answer(input, scope).should == ['test', 'test']
+      end
+
+      it 'fails if alias interpolation is attempted in a string context with a prefix' do
+        input = "stuff_before%{alias('rspec')}"
+        scope = {}
+        Config.load({:yaml => {:datadir => "/tmp"}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns(['test', 'test'])
+        expect do
+          Backend.parse_answer(input, scope).should == ['test', 'test']
+        end.to raise_error(Hiera::InterpolationInvalidValue, 'Cannot call alias in the string context')
+      end
+
+      it 'fails if alias interpolation is attempted in a string context with a postfix' do
+        input = "%{alias('rspec')}_stiff after"
+        scope = {}
+        Config.load({:yaml => {:datadir => "/tmp"}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns(['test', 'test'])
+        expect do
+          Backend.parse_answer(input, scope).should == ['test', 'test']
+        end.to raise_error(Hiera::InterpolationInvalidValue, 'Cannot call alias in the string context')
+      end
+
       it "interpolates hiera lookups in each string in an array" do
         input = ["test_%{hiera('rspec')}_test", "test_%{hiera('rspec')}_test", ["test_%{hiera('rspec')}_test"]]
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("test")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("test")
         Backend.parse_answer(input, scope).should == ["test_test_test", "test_test_test", ["test_test_test"]]
       end
 
@@ -318,7 +363,7 @@ class Hiera
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("test")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("test")
         Backend.parse_answer(input, scope).should == {"foo"=>"test_test_test", "bar"=>"test_test_test"}
       end
 
@@ -327,7 +372,7 @@ class Hiera
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("foo")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("foo")
         Backend.parse_answer(input, scope).should == {"foo"=>"test"}
       end
 
@@ -336,7 +381,7 @@ class Hiera
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("foo")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("foo")
         Backend.parse_answer(input, scope).should == {"topkey"=>{"foo" => "test"}}
       end
 
@@ -345,7 +390,7 @@ class Hiera
         scope = {}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("test")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("test")
         Backend.parse_answer(input, scope).should == {"foo"=>"test_test_test", "bar"=>["test_test_test", "test_test_test"]}
       end
 
@@ -354,7 +399,7 @@ class Hiera
         scope = {"rspec2" => "scope_rspec"}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("hiera_rspec")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("hiera_rspec")
         Backend.parse_answer(input, scope).should == {"foo"=>"test_hiera_rspec_test", "bar"=>"test_scope_rspec_test"}
       end
 
@@ -363,7 +408,7 @@ class Hiera
         scope = {"rspec" => "scope_rspec"}
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority).returns("hiera_rspec")
+        Backend::Yaml_backend.any_instance.stubs(:lookup).with("rspec", scope, nil, :priority, instance_of(Hash)).returns("hiera_rspec")
         Backend.parse_answer(input, scope).should == "test_hiera_rspec_test_scope_rspec"
       end
 
@@ -425,7 +470,7 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
 
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil).returns("answer")
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil, instance_of(Hash)).returns("answer")
 
         Backend.lookup("key", "default", {}, nil, nil).should == "answer"
       end
@@ -434,9 +479,9 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
 
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("stringval", {}, nil, nil).returns("string")
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("boolval", {}, nil, nil).returns(false)
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("numericval", {}, nil, nil).returns(1)
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("stringval", {}, nil, nil, instance_of(Hash)).returns("string")
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("boolval", {}, nil, nil, instance_of(Hash)).returns(false)
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("numericval", {}, nil, nil, instance_of(Hash)).returns(1)
 
         Backend.lookup("stringval", "default", {}, nil, nil).should == "string"
         Backend.lookup("boolval", "default", {}, nil, nil).should == false
@@ -518,7 +563,7 @@ class Hiera
         Config.load_backends
 
         Backend.expects(:resolve_answer).with("test_test", :priority).returns("parsed")
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, :priority).returns("test_test")
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, :priority, instance_of(Hash)).returns("test_test")
 
         Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, :priority).should == "parsed"
       end
@@ -527,31 +572,129 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
 
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, nil)
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, nil, instance_of(Hash)).throws(:no_such_key)
 
         Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil).should == "test_test"
       end
 
+      it "returns nil instead of the default when key is found with a nil value" do
+        Config.load({:yaml => {:datadir => "/tmp"}})
+        Config.load_backends
+
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, nil, instance_of(Hash)).returns(nil)
+
+        Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil).should == nil
+      end
+
       it "keeps string default data as a string" do
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil)
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil, instance_of(Hash)).throws(:no_such_key)
         Backend.lookup("key", "test", {}, nil, nil).should == "test"
       end
 
       it "keeps array default data as an array" do
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, :array)
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, :array, instance_of(Hash)).throws(:no_such_key)
         Backend.lookup("key", ["test"], {}, nil, :array).should == ["test"]
       end
 
       it "keeps hash default data as a hash" do
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
-        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, :hash)
+        Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, :hash, instance_of(Hash)).throws(:no_such_key)
         Backend.lookup("key", {"test" => "value"}, {}, nil, :hash).should == {"test" => "value"}
       end
+
+      it 'can use qualified key to lookup value in hash' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, nil, instance_of(Hash)).returns({ 'test' => 'value'})
+        Backend.lookup('key.test', 'dflt', {}, nil, nil).should == 'value'
+      end
+
+      it 'can use qualified key to lookup value in array' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, nil, instance_of(Hash)).returns([ 'first', 'second'])
+        Backend.lookup('key.1', 'dflt', {}, nil, nil).should == 'second'
+      end
+
+      it 'will fail when qualified key is partially found but not expected hash' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, nil, instance_of(Hash)).returns(['value 1', 'value 2'])
+        expect do
+          Backend.lookup('key.test', 'dflt', {}, nil, nil)
+        end.to raise_error(Exception, /^Hiera type mismatch:/)
+      end
+
+      it 'will fail when qualified key used with resolution_type :hash' do
+        expect do
+          Backend.lookup('key.test', 'dflt', {}, nil, :hash)
+        end.to raise_error(ArgumentError, /^Resolution type :hash is illegal/)
+      end
+
+      it 'will fail when qualified key used with resolution_type :array' do
+        expect do
+          Backend.lookup('key.test', 'dflt', {}, nil, :array)
+        end.to raise_error(ArgumentError, /^Resolution type :array is illegal/)
+      end
+
+      it 'will succeed when qualified key used with resolution_type :priority' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, :priority, instance_of(Hash)).returns({ 'test' => 'value'})
+        Backend.lookup('key.test', 'dflt', {}, nil, :priority).should == 'value'
+      end
+
+      it 'will fail when qualified key is partially found but not expected array' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, nil, instance_of(Hash)).returns({ 'test' => 'value'})
+        expect do
+          Backend.lookup('key.2', 'dflt', {}, nil, nil)
+        end.to raise_error(Exception, /^Hiera type mismatch:/)
+      end
+
+      it 'will not fail when qualified key is partially not found' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, nil, instance_of(Hash)).returns(nil)
+        Backend.lookup('key.test', 'dflt', {}, nil, nil).should == 'dflt'
+      end
+
+      it 'will not fail when qualified key is array index out of bounds' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', {}, nil, nil, instance_of(Hash)).returns(['value 1', 'value 2'])
+        Backend.lookup('key.33', 'dflt', {}, nil, nil).should == 'dflt'
+      end
+
+      it 'can use qualified key in interpolation to lookup value in hash' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        Hiera::Backend.stubs(:datasourcefiles).yields('foo', 'bar')
+        Hiera::Filecache.any_instance.expects(:read_file).at_most(2).returns({'key' => '%{hiera(\'some.subkey\')}', 'some' => { 'subkey' => 'value' }})
+        Backend.lookup('key', 'dflt', {}, nil, nil).should == 'value'
+      end
+
+      it 'can use qualified key in interpolated default and scope' do
+        Config.load({:yaml => {:datadir => '/tmp'}})
+        Config.load_backends
+        scope = { 'some' => { 'test' => 'value'}}
+        Backend::Yaml_backend.any_instance.expects(:lookup).with('key', scope, nil, nil, instance_of(Hash))
+        Backend.lookup('key.notfound', '%{some.test}', scope, nil, nil).should == 'value'
+      end
+
+      it "handles older backend with 4 argument lookup" do
+        Config.load({})
+        Config.instance_variable_set("@config", {:backends => ["Backend1x"]})
+
+        Hiera.expects(:debug).at_least_once.with(regexp_matches /Using Hiera 1.x backend/)
+        Backend.lookup("key", {}, {"rspec" => "test"}, nil, :priority).should == ["a", "b"]
+      end
     end
 
     describe '#merge_answer' do
@@ -569,13 +712,30 @@ class Hiera
 
       it "uses deep_merge! when configured with :merge_behavior => :deeper" do
         Config.load({:merge_behavior => :deeper})
-        Hash.any_instance.expects('deep_merge!').with({"b" => "bnswer"}).returns({"a" => "answer", "b" => "bnswer"})
+        Hash.any_instance.expects('deep_merge!').with({"b" => "bnswer"}, {}).returns({"a" => "answer", "b" => "bnswer"})
         Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}).should == {"a" => "answer", "b" => "bnswer"}
       end
 
       it "uses deep_merge when configured with :merge_behavior => :deep" do
         Config.load({:merge_behavior => :deep})
-        Hash.any_instance.expects('deep_merge').with({"b" => "bnswer"}).returns({"a" => "answer", "b" => "bnswer"})
+        Hash.any_instance.expects('deep_merge').with({"b" => "bnswer"}, {}).returns({"a" => "answer", "b" => "bnswer"})
+        Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}).should == {"a" => "answer", "b" => "bnswer"}
+      end
+
+      it "disregards configuration when 'merge' parameter is given as a Hash" do
+        Config.load({:merge_behavior => :deep})
+        Hash.any_instance.expects('deep_merge!').with({"b" => "bnswer"}, {}).returns({"a" => "answer", "b" => "bnswer"})
+        Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}, {:behavior => 'deeper' }).should == {"a" => "answer", "b" => "bnswer"}
+      end
+
+      it "propagates deep merge options when given Hash 'merge' parameter" do
+        Hash.any_instance.expects('deep_merge!').with({"b" => "bnswer"}, { :knockout_prefix => '-' }).returns({"a" => "answer", "b" => "bnswer"})
+        Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}, {:behavior => 'deeper', :knockout_prefix => '-'}).should == {"a" => "answer", "b" => "bnswer"}
+      end
+
+      it "passes Config[:deep_merge_options] into calls to deep_merge" do
+        Config.load({:merge_behavior => :deep, :deep_merge_options => { :knockout_prefix => '-' } })
+        Hash.any_instance.expects('deep_merge').with({"b" => "bnswer"}, {:knockout_prefix => '-'}).returns({"a" => "answer", "b" => "bnswer"})
         Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}).should == {"a" => "answer", "b" => "bnswer"}
       end
     end

data/spec/unit/config_spec.rb

@@ -61,7 +61,7 @@ class Hiera
         Config.load({})
       end
 
-      context "loading '/dev/null' as spec tests do" do
+      context "loading '/dev/null' as spec tests do", :unless => Hiera::Util.microsoft_windows? do
         before :each do
           # Simulate the behavior of YAML.load_file('/dev/null') in MRI 1.9.3p194
           Config.stubs(:yaml_load_file).
@@ -69,7 +69,22 @@ class Hiera
         end
 
         it "is not exceptional behavior" do
-          expect { Config.load('/dev/null') }.to_not raise_error
+          Config.load('/dev/null')
+        end
+      end
+
+      describe "if deep_merge can't be loaded" do
+        let(:error_message) { "Must have 'deep_merge' gem installed for the configured merge_behavior." }
+        before(:each) do
+          Config.expects(:require).with("deep_merge").raises(LoadError, "unable to load")
+        end
+
+        it "should error if merge_behavior is 'deep'" do
+          expect { Config.load(:merge_behavior => :deep) }.to raise_error(Hiera::Error, error_message)
+        end
+
+        it "should error if merge_behavior is 'deeper'" do
+          expect { Config.load(:merge_behavior => :deeper) }.to raise_error(Hiera::Error, error_message)
         end
       end
     end

data/spec/unit/fixtures/interpolate/config/hiera.yaml

@@ -0,0 +1,6 @@
+:backends:
+  - yaml
+
+:hierarchy:
+  - recursive
+  - niltest

data/spec/unit/fixtures/interpolate/data/niltest.yaml

@@ -0,0 +1,2 @@
+niltest: 'Missing key #%{hiera("knotfound")}#. Key with nil #%{hiera("knil")}#'
+knil: null

data/spec/unit/fixtures/interpolate/data/recursive.yaml

@@ -0,0 +1,3 @@
+foo: '%{hiera("bar")}'
+
+bar: '%{hiera("foo")}'

data/spec/unit/fixtures/override/config/hiera.yaml

@@ -0,0 +1,5 @@
+:backends:
+  - yaml
+
+:hierarchy:
+  - common

data/spec/unit/fixtures/override/data/alternate.yaml

@@ -0,0 +1 @@
+bar: 'alternate'

data/spec/unit/fixtures/override/data/common.yaml

@@ -0,0 +1,2 @@
+foo: '%{hiera("bar")}'
+bar: 'common'

data/spec/unit/interpolate_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'hiera/util'
+
+describe "Hiera" do
+  context "when doing interpolation" do
+    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
+
+    it 'should prevent endless recursion' do
+      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
+      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
+      expect do
+        hiera.lookup('foo', nil, {})
+      end.to raise_error Hiera::InterpolationLoop, 'Detected in [hiera("bar"), hiera("foo")]'
+    end
+  end
+
+  context "when not finding value for interpolated key" do
+    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
+
+    it 'should resolve the interpolation to an empty string' do
+      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
+      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
+      expect(hiera.lookup('niltest', nil, {})).to eq('Missing key ##. Key with nil ##')
+    end
+  end
+
+  context "when doing interpolation with override" do
+    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'override') }
+
+    it 'should resolve interpolation using the override' do
+      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
+      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
+      expect(hiera.lookup('foo', nil, {}, 'alternate')).to eq('alternate')
+    end
+  end
+end

data/spec/unit/util_spec.rb

@@ -23,26 +23,26 @@ describe Hiera::Util do
   describe 'Hiera::Util.config_dir' do
     it 'should return the correct path for posix systems' do
       Hiera::Util.expects(:file_alt_separator).returns(nil)
-      Hiera::Util.config_dir.should == '/etc'
+      Hiera::Util.config_dir.should == '/etc/puppetlabs/code'
     end
 
     it 'should return the correct path for microsoft windows systems' do
       Hiera::Util.expects(:microsoft_windows?).returns(true)
       Hiera::Util.expects(:common_appdata).returns('C:\\ProgramData')
-      Hiera::Util.config_dir.should == 'C:\\ProgramData/PuppetLabs/hiera/etc'
+      Hiera::Util.config_dir.should == 'C:\\ProgramData/PuppetLabs/code'
     end
   end
 
   describe 'Hiera::Util.var_dir' do
     it 'should return the correct path for posix systems' do
       Hiera::Util.expects(:file_alt_separator).returns(nil)
-      Hiera::Util.var_dir.should == '/var/lib/hiera'
+      Hiera::Util.var_dir.should == '/etc/puppetlabs/code/hieradata'
     end
 
     it 'should return the correct path for microsoft windows systems' do
       Hiera::Util.expects(:microsoft_windows?).returns(true)
       Hiera::Util.expects(:common_appdata).returns('C:\\ProgramData')
-      Hiera::Util.var_dir.should == 'C:\\ProgramData/PuppetLabs/hiera/var'
+      Hiera::Util.var_dir.should == 'C:\\ProgramData/PuppetLabs/code/hieradata'
     end
   end
 end

metadata

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: hiera
 version: !ruby/object:Gem::Version
-  version: 1.3.0
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-21 00:00:00.000000000 Z
+date: 2015-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_pure
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A pluggable data store for hierarcical data
@@ -35,70 +32,83 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/hiera
-- lib/hiera/puppet_logger.rb
+- lib/hiera/backend.rb
+- lib/hiera/backend/json_backend.rb
+- lib/hiera/backend/yaml_backend.rb
+- lib/hiera/config.rb
 - lib/hiera/console_logger.rb
-- lib/hiera/filecache.rb
-- lib/hiera/version.rb
-- lib/hiera/fallback_logger.rb
 - lib/hiera/error.rb
+- lib/hiera/fallback_logger.rb
+- lib/hiera/filecache.rb
 - lib/hiera/interpolate.rb
-- lib/hiera/util.rb
-- lib/hiera/recursive_guard.rb
-- lib/hiera/backend.rb
 - lib/hiera/noop_logger.rb
-- lib/hiera/config.rb
-- lib/hiera/backend/yaml_backend.rb
-- lib/hiera/backend/json_backend.rb
+- lib/hiera/puppet_logger.rb
+- lib/hiera/recursive_guard.rb
+- lib/hiera/util.rb
+- lib/hiera/version.rb
 - lib/hiera.rb
 - COPYING
 - README.md
 - LICENSE
-- spec/unit/util_spec.rb
-- spec/unit/puppet_logger_spec.rb
-- spec/unit/version_spec.rb
-- spec/unit/config_spec.rb
+- spec/spec_helper.rb
+- spec/unit/backend/json_backend_spec.rb
+- spec/unit/backend/yaml_backend_spec.rb
 - spec/unit/backend_spec.rb
-- spec/unit/filecache_spec.rb
-- spec/unit/hiera_spec.rb
+- spec/unit/config_spec.rb
 - spec/unit/console_logger_spec.rb
-- spec/unit/backend/yaml_backend_spec.rb
-- spec/unit/backend/json_backend_spec.rb
 - spec/unit/fallback_logger_spec.rb
-- spec/spec_helper.rb
+- spec/unit/filecache_spec.rb
+- spec/unit/fixtures/interpolate/config/hiera.yaml
+- spec/unit/fixtures/interpolate/data/niltest.yaml
+- spec/unit/fixtures/interpolate/data/recursive.yaml
+- spec/unit/fixtures/override/config/hiera.yaml
+- spec/unit/fixtures/override/data/alternate.yaml
+- spec/unit/fixtures/override/data/common.yaml
+- spec/unit/hiera_spec.rb
+- spec/unit/interpolate_spec.rb
+- spec/unit/puppet_logger_spec.rb
+- spec/unit/util_spec.rb
+- spec/unit/version_spec.rb
 homepage: https://github.com/puppetlabs/hiera
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Light weight hierarchical data store
 test_files:
-- spec/unit/util_spec.rb
-- spec/unit/puppet_logger_spec.rb
-- spec/unit/version_spec.rb
-- spec/unit/config_spec.rb
+- spec/spec_helper.rb
+- spec/unit/backend/json_backend_spec.rb
+- spec/unit/backend/yaml_backend_spec.rb
 - spec/unit/backend_spec.rb
-- spec/unit/filecache_spec.rb
-- spec/unit/hiera_spec.rb
+- spec/unit/config_spec.rb
 - spec/unit/console_logger_spec.rb
-- spec/unit/backend/yaml_backend_spec.rb
-- spec/unit/backend/json_backend_spec.rb
 - spec/unit/fallback_logger_spec.rb
-- spec/spec_helper.rb
+- spec/unit/filecache_spec.rb
+- spec/unit/fixtures/interpolate/config/hiera.yaml
+- spec/unit/fixtures/interpolate/data/niltest.yaml
+- spec/unit/fixtures/interpolate/data/recursive.yaml
+- spec/unit/fixtures/override/config/hiera.yaml
+- spec/unit/fixtures/override/data/alternate.yaml
+- spec/unit/fixtures/override/data/common.yaml
+- spec/unit/hiera_spec.rb
+- spec/unit/interpolate_spec.rb
+- spec/unit/puppet_logger_spec.rb
+- spec/unit/util_spec.rb
+- spec/unit/version_spec.rb