hiera 3.0.1 → 3.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 259e9f1b56334fd62e84ca94918da9726f0bae8f
+  data.tar.gz: 7fae6afbfbfa9ffc56e3004d80165a1b03c95d05
+SHA512:
+  metadata.gz: 57199f18022e40b85f241b8a8f692c6d1f7ca692231db0283e8f8326fb56b57bf11e279b539fafc119f883cdd7d5e540986fdd2ea502a32fa5f1316774d86815
+  data.tar.gz: 6a58134a4ef75d8cd4f57cf56f9c0fd88c4a2015ef7e6bd9131103d9a278fc8cc38b8e6eefc761393df35d1c0dc72fff7efa6c3b3ea59a9246d25bdd16396227

data/lib/hiera/filecache.rb

@@ -53,7 +53,7 @@ class Hiera
         @cache[path][:data] = block_given? ? yield(data) : data
 
         if !@cache[path][:data].is_a?(expected_type)
-          raise TypeError, "Data retrieved from #{path} is #{data.class} not #{expected_type}"
+          raise TypeError, "Data retrieved from #{path} is #{@cache[path][:data].class} not #{expected_type}"
         end
       end
 

data/lib/hiera/version.rb

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

data/spec/unit/backend/json_backend_spec.rb

@@ -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, nil).should == "string"
-          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
-          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
+          expect(@backend.lookup("stringval", {}, nil, :priority, nil)).to eq("string")
+          expect(@backend.lookup("boolval", {}, nil, :priority, nil)).to eq(true)
+          expect(@backend.lookup("numericval", {}, nil, :priority, nil)).to eq(1)
         end
 
         it "should pick data earliest source that has it for priority searches" do
@@ -49,7 +49,7 @@ 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, nil).should == "test_test"
+          expect(@backend.lookup("key", scope, nil, :priority, nil)).to eq("test_test")
         end
 
         it "should build an array of all data sources for array searches" do
@@ -66,7 +66,7 @@ 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, nil).should == ["answer", "answer"]
+          expect(@backend.lookup("key", {}, nil, :array, nil)).to eq(["answer", "answer"])
         end
 
         it "should parse the answer for scope variables" do
@@ -77,7 +77,7 @@ class Hiera
           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, nil).should == "test_test"
+          expect(@backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil)).to eq("test_test")
         end
       end
     end

data/spec/unit/backend/yaml_backend_spec.rb

@@ -41,7 +41,7 @@ class Hiera
           Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
           @cache.value = "---\nkey: answer"
 
-          @backend.lookup("key", {}, nil, :priority, nil).should == "answer"
+          expect(@backend.lookup("key", {}, nil, :priority, nil)).to eq("answer")
         end
 
         describe "handling unexpected YAML values" do
@@ -56,7 +56,7 @@ class Hiera
 
           it "returns nil when the YAML value is nil" do
             @cache.value = "key: ~\n"
-            @backend.lookup("key", {}, nil, :priority, nil).should be_nil
+            expect(@backend.lookup("key", {}, nil, :priority, nil)).to be_nil
           end
 
           it "throws :no_such_key when the YAML file is false" do
@@ -75,7 +75,7 @@ class Hiera
           @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, nil).should == ["answer", "answer"]
+          expect(@backend.lookup("key", {}, nil, :array, nil)).to eq(["answer", "answer"])
         end
 
         it "should ignore empty hash of data sources for hash searches" do
@@ -84,7 +84,7 @@ class Hiera
           @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, nil).should == {"a" => "answer"}
+          expect(@backend.lookup("key", {}, nil, :hash, nil)).to eq({"a" => "answer"})
         end
 
         it "should build a merged hash of data sources for hash searches" do
@@ -93,7 +93,7 @@ class Hiera
           @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, nil).should == {"a" => "answer", "b" => "answer"}
+          expect(@backend.lookup("key", {}, nil, :hash, nil)).to eq({"a" => "answer", "b" => "answer"})
         end
 
         it "should fail when trying to << a Hash" do
@@ -119,7 +119,7 @@ class Hiera
 
           @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"test_%{rspec}"})
 
-          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
+          expect(@backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil)).to eq("test_test")
         end
 
         it "should retain datatypes found in yaml files" do
@@ -128,9 +128,9 @@ class Hiera
 
           @cache.value = "---\nstringval: 'string'\nboolval: true\nnumericval: 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
+          expect(@backend.lookup("stringval", {}, nil, :priority, nil)).to eq("string")
+          expect(@backend.lookup("boolval", {}, nil, :priority, nil)).to eq(true)
+          expect(@backend.lookup("numericval", {}, nil, :priority, nil)).to eq(1)
         end
       end
     end

data/spec/unit/backend_spec.rb

@@ -17,18 +17,18 @@ class Hiera
 
         dir = Backend.datadir(:rspec, { "interpolate" => "my_data" })
 
-        dir.should == "/tmp/my_data"
+        expect(dir).to eq("/tmp/my_data")
       end
 
       it "defaults to a directory in var" do
         Config.load({})
-        Backend.datadir(:rspec, { "environment" => "foo" }).should == Hiera::Util.var_dir % { :environment => "foo"}
+        expect(Backend.datadir(:rspec, { "environment" => "foo" })).to eq(Hiera::Util.var_dir % { :environment => "foo"})
 
         Config.load({:rspec => nil})
-        Backend.datadir(:rspec, { "environment" => "foo" }).should == Hiera::Util.var_dir % { :environment => "foo"}
+        expect(Backend.datadir(:rspec, { "environment" => "foo" })).to eq(Hiera::Util.var_dir % { :environment => "foo"})
 
         Config.load({:rspec => {}})
-        Backend.datadir(:rspec, { "environment" => "foo" }).should == Hiera::Util.var_dir % { :environment => "foo"}
+        expect(Backend.datadir(:rspec, { "environment" => "foo" })).to eq(Hiera::Util.var_dir % { :environment => "foo"})
       end
 
       it "fails when the datadir is an array" do
@@ -44,13 +44,13 @@ class Hiera
       it "translates a non-existant datafile into nil" do
         Hiera.expects(:debug).with("Cannot find datafile /nonexisting/test.yaml, skipping")
         Backend.expects(:datadir).returns("/nonexisting")
-        Backend.datafile(:yaml, {}, "test", "yaml").should == nil
+        expect(Backend.datafile(:yaml, {}, "test", "yaml")).to eq(nil)
       end
 
       it "concatenates the datadir and datafile and format to produce the full datafile filename" do
         Backend.expects(:datadir).returns("/nonexisting")
         File.expects(:exist?).with("/nonexisting/test.yaml").returns(true)
-        Backend.datafile(:yaml, {}, "test", "yaml").should == "/nonexisting/test.yaml"
+        expect(Backend.datafile(:yaml, {}, "test", "yaml")).to eq("/nonexisting/test.yaml")
       end
     end
 
@@ -58,17 +58,17 @@ class Hiera
       it "iterates over the datasources in the order of the given hierarchy" do
         expected = ["one", "two"]
         Backend.datasources({}, nil, ["one", "two"]) do |backend|
-          backend.should == expected.delete_at(0)
+          expect(backend).to eq(expected.delete_at(0))
         end
 
-        expected.empty?.should == true
+        expect(expected.empty?).to eq(true)
       end
 
       it "uses the configured hierarchy no specific hierarchy is given" do
         Config.load(:hierarchy => "test")
 
         Backend.datasources({}) do |backend|
-          backend.should == "test"
+          expect(backend).to eq("test")
         end
       end
 
@@ -76,7 +76,7 @@ class Hiera
         Config.load({})
 
         Backend.datasources({}) do |backend|
-          backend.should == "common"
+          expect(backend).to eq("common")
         end
       end
 
@@ -85,10 +85,10 @@ class Hiera
 
         expected = ["override", "common"]
         Backend.datasources({}, "override") do |backend|
-          backend.should == expected.delete_at(0)
+          expect(backend).to eq(expected.delete_at(0))
         end
 
-        expected.empty?.should == true
+        expect(expected.empty?).to eq(true)
       end
 
       it "parses the names of the hierarchy levels using the given scope" do
@@ -102,29 +102,29 @@ class Hiera
 
         expected = ["common"]
         Backend.datasources({}, "%{rspec}") do |backend|
-          backend.should == expected.delete_at(0)
+          expect(backend).to eq(expected.delete_at(0))
         end
 
-        expected.empty?.should == true
+        expect(expected.empty?).to eq(true)
       end
     end
 
     describe "#parse_string" do
       it "passes nil through untouched" do
-        Backend.parse_string(nil, {}).should == nil
+        expect(Backend.parse_string(nil, {})).to eq(nil)
       end
 
       it "does not modify the input data" do
         data = "%{value}"
         Backend.parse_string(data, { "value" => "replacement" })
 
-        data.should == "%{value}"
+        expect(data).to eq("%{value}")
       end
 
       it "passes non-string data through untouched" do
         input = { "not a" => "string" }
 
-        Backend.parse_string(input, {}).should == input
+        expect(Backend.parse_string(input, {})).to eq(input)
       end
 
       @scope_interpolation_tests = {
@@ -138,18 +138,18 @@ class Hiera
         it "replaces interpolations with data looked up in the scope" do
           scope = {"part1" => "value of part1", "part2" => "value of part2"}
 
-          Backend.parse_string(input, scope).should == expected
+          expect(Backend.parse_string(input, scope)).to eq(expected)
         end
       end
 
       it "replaces interpolations with data looked up in extra_data when scope does not contain the value" do
         input = "test_%{rspec}_test"
-        Backend.parse_string(input, {}, {"rspec" => "extra"}).should == "test_extra_test"
+        expect(Backend.parse_string(input, {}, {"rspec" => "extra"})).to eq("test_extra_test")
       end
 
       it "prefers data from scope over data from extra_data" do
         input = "test_%{rspec}_test"
-        Backend.parse_string(input, {"rspec" => "test"}, {"rspec" => "fail"}).should == "test_test_test"
+        expect(Backend.parse_string(input, {"rspec" => "test"}, {"rspec" => "fail"})).to eq("test_test_test")
       end
 
       @interprets_nil_in_scope_tests = {
@@ -159,7 +159,7 @@ class Hiera
 
       @interprets_nil_in_scope_tests.each do |input, expected|
         it "interprets nil in scope as a non-value" do
-          Backend.parse_string(input, {"rspec" => nil}).should == expected
+          expect(Backend.parse_string(input, {"rspec" => nil})).to eq(expected)
         end
       end
 
@@ -171,18 +171,18 @@ class Hiera
       @interprets_false_in_scope_tests.each do |input, expected|
         it "interprets false in scope as a real value" do
           input = "test_%{scope('rspec')}_test"
-          Backend.parse_string(input, {"rspec" => false}).should == expected
+          expect(Backend.parse_string(input, {"rspec" => false})).to eq(expected)
         end
       end
 
       it "interprets false in extra_data as a real value" do
         input = "test_%{rspec}_test"
-        Backend.parse_string(input, {}, {"rspec" => false}).should == "test_false_test"
+        expect(Backend.parse_string(input, {}, {"rspec" => false})).to eq("test_false_test")
       end
 
       it "interprets nil in extra_data as a non-value" do
         input = "test_%{rspec}_test"
-        Backend.parse_string(input, {}, {"rspec" => nil}).should == "test__test"
+        expect(Backend.parse_string(input, {}, {"rspec" => nil})).to eq("test__test")
       end
 
       @interprets_undefined_in_scope_tests = {
@@ -197,7 +197,7 @@ class Hiera
 
       @exact_lookup_tests.each do |input, expected|
         it "looks up the interpolated value exactly as it appears in the input" do
-          Backend.parse_string(input, {"::rspec::data" => "value"}).should == expected
+          expect(Backend.parse_string(input, {"::rspec::data" => "value"})).to eq(expected)
         end
       end
 
@@ -207,7 +207,7 @@ class Hiera
       }
       @surrounding_whitespace_tests.each do |input, expected|
         it "does not remove any surrounding whitespace when parsing the key to lookup" do
-          Backend.parse_string(input, {"\trspec::data " => "value"}).should == expected
+          expect(Backend.parse_string(input, {"\trspec::data " => "value"})).to eq(expected)
         end
       end
 
@@ -218,7 +218,7 @@ class Hiera
 
       @leading_double_colon_tests.each do |input, expected|
         it "does not try removing leading :: when a full lookup fails (#17434)" do
-          Backend.parse_string(input, {"rspec::data" => "value"}).should == expected
+          expect(Backend.parse_string(input, {"rspec::data" => "value"})).to eq(expected)
         end
       end
 
@@ -228,19 +228,19 @@ class Hiera
       }
       @double_colon_key_tests.each do |input, expected|
         it "does not try removing leading sections separated by :: when a full lookup fails (#17434)" do
-          Backend.parse_string(input, {"data" => "value"}).should == expected
+          expect(Backend.parse_string(input, {"data" => "value"})).to eq(expected)
         end
       end
 
       it "does not try removing unknown, preceeding characters when looking up values" do
         input = "test_%{$var}_test"
-        Backend.parse_string(input, {"$var" => "value"}).should == "test_value_test"
+        expect(Backend.parse_string(input, {"$var" => "value"})).to eq("test_value_test")
       end
 
       it "looks up recursively" do
         scope = {"rspec" => "%{first}", "first" => "%{last}", "last" => "final"}
         input = "test_%{rspec}_test"
-        Backend.parse_string(input, scope).should == "test_final_test"
+        expect(Backend.parse_string(input, scope)).to eq("test_final_test")
       end
 
       it "raises an error if the recursive lookup results in an infinite loop" do
@@ -254,7 +254,7 @@ class Hiera
       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"
+        expect(Backend.parse_string(input, scope)).to eq("it replaces value and value")
       end
 
       it "replaces hiera interpolations with data looked up in hiera" do
@@ -264,7 +264,7 @@ class Hiera
         Config.load_backends
         Backend::Yaml_backend.any_instance.stubs(:lookup).with("key1", scope, nil, :priority, instance_of(Hash)).returns("answer")
 
-        Backend.parse_string(input, scope).should == "answer"
+        expect(Backend.parse_string(input, scope)).to eq("answer")
       end
 
       it "interpolation passes the order_override back into the backend" do
@@ -275,39 +275,39 @@ class Hiera
       it "replaces literal interpolations with their argument" do
         scope = {}
         input = "%{literal('%')}{rspec::data}"
-        Backend.parse_string(input, scope).should == "%{rspec::data}"
+        expect(Backend.parse_string(input, scope)).to eq("%{rspec::data}")
       end
     end
 
     describe "#parse_answer" do
       it "interpolates values in strings" do
         input = "test_%{rspec}_test"
-        Backend.parse_answer(input, {"rspec" => "test"}).should == "test_test_test"
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq("test_test_test")
       end
 
       it "interpolates each string in an array" do
         input = ["test_%{rspec}_test", "test_%{rspec}_test", ["test_%{rspec}_test"]]
-        Backend.parse_answer(input, {"rspec" => "test"}).should == ["test_test_test", "test_test_test", ["test_test_test"]]
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq(["test_test_test", "test_test_test", ["test_test_test"]])
       end
 
       it "interpolates each string in a hash" do
         input = {"foo" => "test_%{rspec}_test", "bar" => "test_%{rspec}_test"}
-        Backend.parse_answer(input, {"rspec" => "test"}).should == {"foo"=>"test_test_test", "bar"=>"test_test_test"}
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq({"foo"=>"test_test_test", "bar"=>"test_test_test"})
       end
 
       it "interpolates string in hash keys" do
         input = {"%{rspec}" => "test"}
-        Backend.parse_answer(input, {"rspec" => "foo"}).should == {"foo"=>"test"}
+        expect(Backend.parse_answer(input, {"rspec" => "foo"})).to eq({"foo"=>"test"})
       end
 
       it "interpolates strings in nested hash keys" do
         input = {"topkey" => {"%{rspec}" => "test"}}
-        Backend.parse_answer(input, {"rspec" => "foo"}).should == {"topkey"=>{"foo" => "test"}}
+        expect(Backend.parse_answer(input, {"rspec" => "foo"})).to eq({"topkey"=>{"foo" => "test"}})
       end
 
       it "interpolates strings in a mixed structure of arrays and hashes" do
         input = {"foo" => "test_%{rspec}_test", "bar" => ["test_%{rspec}_test", "test_%{rspec}_test"]}
-        Backend.parse_answer(input, {"rspec" => "test"}).should == {"foo"=>"test_test_test", "bar"=>["test_test_test", "test_test_test"]}
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq({"foo"=>"test_test_test", "bar"=>["test_test_test", "test_test_test"]})
       end
 
       it "interpolates hiera lookups values in strings" do
@@ -316,7 +316,7 @@ class Hiera
         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")
-        Backend.parse_answer(input, scope).should == "test_test_test"
+        expect(Backend.parse_answer(input, scope)).to eq("test_test_test")
       end
 
       it "interpolates alias lookups with non-string types" do
@@ -325,7 +325,7 @@ class Hiera
         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']
+        expect(Backend.parse_answer(input, scope)).to eq(['test', 'test'])
       end
 
       it 'fails if alias interpolation is attempted in a string context with a prefix' do
@@ -335,7 +335,7 @@ class Hiera
         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']
+          expect(Backend.parse_answer(input, scope)).to eq(['test', 'test'])
         end.to raise_error(Hiera::InterpolationInvalidValue, 'Cannot call alias in the string context')
       end
 
@@ -346,7 +346,7 @@ class Hiera
         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']
+          expect(Backend.parse_answer(input, scope)).to eq(['test', 'test'])
         end.to raise_error(Hiera::InterpolationInvalidValue, 'Cannot call alias in the string context')
       end
 
@@ -356,7 +356,7 @@ class Hiera
         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")
-        Backend.parse_answer(input, scope).should == ["test_test_test", "test_test_test", ["test_test_test"]]
+        expect(Backend.parse_answer(input, scope)).to eq(["test_test_test", "test_test_test", ["test_test_test"]])
       end
 
       it "interpolates hiera lookups in each string in a hash" do
@@ -365,7 +365,7 @@ class Hiera
         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")
-        Backend.parse_answer(input, scope).should == {"foo"=>"test_test_test", "bar"=>"test_test_test"}
+        expect(Backend.parse_answer(input, scope)).to eq({"foo"=>"test_test_test", "bar"=>"test_test_test"})
       end
 
       it "interpolates hiera lookups in string in hash keys" do
@@ -374,7 +374,7 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
         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"}
+        expect(Backend.parse_answer(input, scope)).to eq({"foo"=>"test"})
       end
 
       it "interpolates hiera lookups in strings in nested hash keys" do
@@ -383,7 +383,7 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
         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"}}
+        expect(Backend.parse_answer(input, scope)).to eq({"topkey"=>{"foo" => "test"}})
       end
 
       it "interpolates hiera lookups in strings in a mixed structure of arrays and hashes" do
@@ -392,7 +392,7 @@ class Hiera
         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")
-        Backend.parse_answer(input, scope).should == {"foo"=>"test_test_test", "bar"=>["test_test_test", "test_test_test"]}
+        expect(Backend.parse_answer(input, scope)).to eq({"foo"=>"test_test_test", "bar"=>["test_test_test", "test_test_test"]})
       end
 
       it "interpolates hiera lookups and scope lookups in the same string" do
@@ -401,7 +401,7 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
         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"}
+        expect(Backend.parse_answer(input, scope)).to eq({"foo"=>"test_hiera_rspec_test", "bar"=>"test_scope_rspec_test"})
       end
 
       it "interpolates hiera and scope lookups with the same lookup query in a single string" do
@@ -410,43 +410,43 @@ class Hiera
         Config.load({:yaml => {:datadir => "/tmp"}})
         Config.load_backends
         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"
+        expect(Backend.parse_answer(input, scope)).to eq("test_hiera_rspec_test_scope_rspec")
       end
 
       it "passes integers unchanged" do
         input = 1
-        Backend.parse_answer(input, {"rspec" => "test"}).should == 1
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq(1)
       end
 
       it "passes floats unchanged" do
         input = 0.233
-        Backend.parse_answer(input, {"rspec" => "test"}).should == 0.233
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq(0.233)
       end
 
       it "passes the boolean true unchanged" do
         input = true
-        Backend.parse_answer(input, {"rspec" => "test"}).should == true
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq(true)
       end
 
       it "passes the boolean false unchanged" do
         input = false
-        Backend.parse_answer(input, {"rspec" => "test"}).should == false
+        expect(Backend.parse_answer(input, {"rspec" => "test"})).to eq(false)
       end
 
       it "interpolates lookups using single or double quotes" do
         input =  "test_%{scope(\"rspec\")}_test_%{scope('rspec')}"
         scope = {"rspec" => "scope_rspec"}
-        Backend.parse_answer(input, scope).should == "test_scope_rspec_test_scope_rspec"
+        expect(Backend.parse_answer(input, scope)).to eq("test_scope_rspec_test_scope_rspec")
       end
     end
 
     describe "#resolve_answer" do
       it "flattens and removes duplicate values from arrays during an array lookup" do
-        Backend.resolve_answer(["foo", ["foo", "foo"], "bar"], :array).should == ["foo", "bar"]
+        expect(Backend.resolve_answer(["foo", ["foo", "foo"], "bar"], :array)).to eq(["foo", "bar"])
       end
 
       it "returns the data unchanged during a priority lookup" do
-        Backend.resolve_answer(["foo", ["foo", "foo"], "bar"], :priority).should == ["foo", ["foo", "foo"], "bar"]
+        expect(Backend.resolve_answer(["foo", ["foo", "foo"], "bar"], :priority)).to eq(["foo", ["foo", "foo"], "bar"])
       end
     end
 
@@ -473,7 +473,7 @@ class Hiera
 
         Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil, instance_of(Hash)).returns("answer")
 
-        Backend.lookup("key", "default", {}, nil, nil).should == "answer"
+        expect(Backend.lookup("key", "default", {}, nil, nil)).to eq("answer")
       end
 
       it "retains the datatypes as returned by the backend" do
@@ -484,9 +484,9 @@ class Hiera
         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
-        Backend.lookup("numericval", "default", {}, nil, nil).should == 1
+        expect(Backend.lookup("stringval", "default", {}, nil, nil)).to eq("string")
+        expect(Backend.lookup("boolval", "default", {}, nil, nil)).to eq(false)
+        expect(Backend.lookup("numericval", "default", {}, nil, nil)).to eq(1)
       end
 
       it "calls to all backends till an answer is found" do
@@ -498,7 +498,7 @@ class Hiera
         #Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, nil)
         Backend.expects(:constants).returns(["Yaml_backend", "Rspec_backend"]).twice
 
-        Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil).should == "answer"
+        expect(Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil)).to eq("answer")
       end
 
       it "calls to all backends till an answer is found when doing array lookups" do
@@ -509,7 +509,7 @@ class Hiera
         Backend.instance_variable_set("@backends", {"rspec" => backend})
         Backend.expects(:constants).returns(["Yaml_backend", "Rspec_backend"]).twice
 
-        Backend.lookup("key", "notfound", {"rspec" => "test"}, nil, :array).should == ["answer"]
+        expect(Backend.lookup("key", "notfound", {"rspec" => "test"}, nil, :array)).to eq(["answer"])
       end
 
       it "calls to all backends till an answer is found when doing hash lookups" do
@@ -521,7 +521,7 @@ class Hiera
         Backend.instance_variable_set("@backends", {"rspec" => backend})
         Backend.expects(:constants).returns(["Yaml_backend", "Rspec_backend"]).twice
 
-        Backend.lookup("key", "notfound", {"rspec" => "test"}, nil, :hash).should == thehash
+        expect(Backend.lookup("key", "notfound", {"rspec" => "test"}, nil, :hash)).to eq(thehash)
       end
 
       it "builds a merged hash from all backends for hash searches" do
@@ -532,7 +532,7 @@ class Hiera
         Backend.instance_variable_set("@backends", {"first" => backend1, "second" => backend2})
         Backend.stubs(:constants).returns(["First_backend", "Second_backend"])
 
-        Backend.lookup("key", {}, {"rspec" => "test"}, nil, :hash).should == {"a" => "answer", "b" => "bnswer"}
+        expect(Backend.lookup("key", {}, {"rspec" => "test"}, nil, :hash)).to eq({"a" => "answer", "b" => "bnswer"})
       end
 
       it "builds an array from all backends for array searches" do
@@ -543,7 +543,7 @@ class Hiera
         Backend.instance_variable_set("@backends", {"first" => backend1, "second" => backend2})
         Backend.stubs(:constants).returns(["First_backend", "Second_backend"])
 
-        Backend.lookup("key", {}, {"rspec" => "test"}, nil, :array).should == ["a", "b", "c", "d"]
+        expect(Backend.lookup("key", {}, {"rspec" => "test"}, nil, :array)).to eq(["a", "b", "c", "d"])
       end
 
       it "uses the earliest backend result for priority searches" do
@@ -556,7 +556,7 @@ class Hiera
         Backend.instance_variable_set("@backends", {"first" => backend1, "second" => backend2})
         Backend.stubs(:constants).returns(["First_backend", "Second_backend"])
 
-        Backend.lookup("key", {}, {"rspec" => "test"}, nil, :priority).should == ["a", "b"]
+        expect(Backend.lookup("key", {}, {"rspec" => "test"}, nil, :priority)).to eq(["a", "b"])
       end
 
       it "parses the answers based on resolution_type" do
@@ -566,7 +566,7 @@ class Hiera
         Backend.expects(:resolve_answer).with("test_test", :priority).returns("parsed")
         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"
+        expect(Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, :priority)).to eq("parsed")
       end
 
       it "returns the default with variables parsed if nothing is found" do
@@ -575,7 +575,7 @@ class Hiera
 
         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"
+        expect(Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil)).to eq("test_test")
       end
 
       it "returns nil instead of the default when key is found with a nil value" do
@@ -584,42 +584,42 @@ class Hiera
 
         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
+        expect(Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil)).to eq(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, instance_of(Hash)).throws(:no_such_key)
-        Backend.lookup("key", "test", {}, nil, nil).should == "test"
+        expect(Backend.lookup("key", "test", {}, nil, nil)).to eq("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, instance_of(Hash)).throws(:no_such_key)
-        Backend.lookup("key", ["test"], {}, nil, :array).should == ["test"]
+        expect(Backend.lookup("key", ["test"], {}, nil, :array)).to eq(["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, instance_of(Hash)).throws(:no_such_key)
-        Backend.lookup("key", {"test" => "value"}, {}, nil, :hash).should == {"test" => "value"}
+        expect(Backend.lookup("key", {"test" => "value"}, {}, nil, :hash)).to eq({"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'
+        expect(Backend.lookup('key.test', 'dflt', {}, nil, nil)).to eq('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'
+        expect(Backend.lookup('key.1', 'dflt', {}, nil, nil)).to eq('second')
       end
 
       it 'will fail when qualified key is partially found but not expected hash' do
@@ -647,7 +647,7 @@ class Hiera
         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'
+        expect(Backend.lookup('key.test', 'dflt', {}, nil, :priority)).to eq('value')
       end
 
       it 'will fail when qualified key is partially found but not expected array' do
@@ -663,14 +663,14 @@ class Hiera
         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'
+        expect(Backend.lookup('key.test', 'dflt', {}, nil, nil)).to eq('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'
+        expect(Backend.lookup('key.33', 'dflt', {}, nil, nil)).to eq('dflt')
       end
 
       it 'can use qualified key in interpolation to lookup value in hash' do
@@ -678,7 +678,7 @@ class Hiera
         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'
+        expect(Backend.lookup('key', 'dflt', {}, nil, nil)).to eq('value')
       end
 
       it 'can use qualified key in interpolated default and scope' do
@@ -686,7 +686,7 @@ class Hiera
         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'
+        expect(Backend.lookup('key.notfound', '%{some.test}', scope, nil, nil)).to eq('value')
       end
 
       it "handles older backend with 4 argument lookup" do
@@ -694,7 +694,7 @@ class Hiera
         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"]
+        expect(Backend.lookup("key", {}, {"rspec" => "test"}, nil, :priority)).to eq(["a", "b"])
       end
     end
 
@@ -708,36 +708,36 @@ class Hiera
       it "uses Hash.merge when configured with :merge_behavior => :native" do
         Config.load({:merge_behavior => :native})
         Hash.any_instance.expects(:merge).with({"b" => "bnswer"}).returns({"a" => "answer", "b" => "bnswer"})
-        Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}).should == {"a" => "answer", "b" => "bnswer"}
+        expect(Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"})).to eq({"a" => "answer", "b" => "bnswer"})
       end
 
       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"})
-        Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}).should == {"a" => "answer", "b" => "bnswer"}
+        expect(Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"})).to eq({"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"})
-        Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}).should == {"a" => "answer", "b" => "bnswer"}
+        expect(Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"})).to eq({"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"}
+        expect(Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}, {:behavior => 'deeper' })).to eq({"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"}
+        expect(Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"}, {:behavior => 'deeper', :knockout_prefix => '-'})).to eq({"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"}
+        expect(Backend.merge_answer({"a" => "answer"},{"b" => "bnswer"})).to eq({"a" => "answer", "b" => "bnswer"})
       end
     end
   end

data/spec/unit/config_spec.rb

@@ -12,10 +12,6 @@ class Hiera
         }
       end
 
-      it "should treat string sources as a filename" do
-        expect { Config.load("/nonexisting") }.to raise_error
-      end
-
       it "should raise an error for missing config files" do
         File.expects(:exist?).with("/nonexisting").returns(false)
         YAML.expects(:load_file).with("/nonexisting").never
@@ -34,23 +30,23 @@ class Hiera
         File.expects(:exist?).with("/nonexisting").returns(true)
         YAML.expects(:load_file).with("/nonexisting").returns(YAML.load(""))
 
-        Config.load("/nonexisting").should == default_config
+        expect(Config.load("/nonexisting")).to eq(default_config)
       end
 
       it "should use hash data as source if supplied" do
         config = Config.load({"rspec" => "test"})
-        config["rspec"].should == "test"
+        expect(config["rspec"]).to eq("test")
       end
 
       it "should merge defaults with the loaded or supplied config" do
         config = Config.load({})
-        config.should == {:backends => ["yaml"], :hierarchy => ['nodes/%{::trusted.certname}', 'common'],
-          :logger => "console", :merge_behavior=>:native}
+        expect(config).to eq({:backends => ["yaml"], :hierarchy => ['nodes/%{::trusted.certname}', 'common'],
+          :logger => "console", :merge_behavior=>:native})
       end
 
       it "should force :backends to be a flattened array" do
-        Config.load({:backends => [["foo", ["bar"]]]}).should == {:backends => ["foo", "bar"],
-          :hierarchy => ['nodes/%{::trusted.certname}', 'common'], :logger => "console", :merge_behavior=>:native}
+        expect(Config.load({:backends => [["foo", ["bar"]]]})).to eq({:backends => ["foo", "bar"],
+          :hierarchy => ['nodes/%{::trusted.certname}', 'common'], :logger => "console", :merge_behavior=>:native})
       end
 
       it "should load the supplied logger" do
@@ -112,8 +108,8 @@ class Hiera
     describe "#include?" do
       it "should correctly report inclusion" do
         Config.load({})
-        Config.include?(:foo).should == false
-        Config.include?(:logger).should == true
+        expect(Config.include?(:foo)).to eq(false)
+        expect(Config.include?(:logger)).to eq(true)
       end
     end
   end

data/spec/unit/fallback_logger_spec.rb

@@ -11,7 +11,7 @@ describe Hiera::FallbackLogger do
 
     logger.warn("the message")
 
-    InMemoryLogger.warnings.should == ["the message"]
+    expect(InMemoryLogger.warnings).to eq(["the message"])
   end
 
   it "delegates #debug to the logger implemenation" do
@@ -19,7 +19,7 @@ describe Hiera::FallbackLogger do
 
     logger.debug("the message")
 
-    InMemoryLogger.debugs.should == ["the message"]
+    expect(InMemoryLogger.debugs).to eq(["the message"])
   end
 
   it "chooses the first logger that is suitable" do
@@ -27,7 +27,7 @@ describe Hiera::FallbackLogger do
 
     logger.warn("for the suitable logger")
 
-    SuitableLogger.warnings.should include("for the suitable logger")
+    expect(SuitableLogger.warnings).to include("for the suitable logger")
   end
 
   it "raises an error if no implementation is suitable" do
@@ -39,9 +39,9 @@ describe Hiera::FallbackLogger do
   it "issues a warning for each implementation that is not suitable" do
     Hiera::FallbackLogger.new(UnsuitableLogger, UnsuitableLogger, SuitableLogger)
 
-    SuitableLogger.warnings.should == [
+    expect(SuitableLogger.warnings).to eq([
       "Not using UnsuitableLogger. It does not report itself to be suitable.",
-      "Not using UnsuitableLogger. It does not report itself to be suitable."]
+      "Not using UnsuitableLogger. It does not report itself to be suitable."])
   end
 
   # Preserves log messages in memory

data/spec/unit/filecache_spec.rb

@@ -19,7 +19,7 @@ class Hiera
           file = File.join(dir, "testing")
           write_file(file, "my data")
 
-          @cache.read(file).should == "my data"
+          expect(@cache.read(file)).to eq("my data")
         end
       end
 
@@ -27,10 +27,10 @@ class Hiera
         Dir.mktmpdir do |dir|
           file = File.join(dir, "testing")
           write_file(file, "my data")
-          @cache.read(file).should == "my data"
+          expect(@cache.read(file)).to eq("my data")
 
           write_file(file, "changed data")
-          @cache.read(file).should == "changed data"
+          expect(@cache.read(file)).to eq("changed data")
         end
       end
 
@@ -43,7 +43,7 @@ class Hiera
             "a string"
           end
 
-          data.should == { :testing => "hash" }
+          expect(data).to eq({ :testing => "hash" })
         end
       end
 
@@ -56,7 +56,7 @@ class Hiera
             raise ArgumentError, "testing error"
           end
 
-          data.should == { :testing => "hash" }
+          expect(data).to eq({ :testing => "hash" })
         end
       end
 
@@ -80,7 +80,7 @@ class Hiera
           file = File.join(dir, "testing")
           write_file(file, "my data")
 
-          @cache.read_file(file).should == "my data"
+          expect(@cache.read_file(file)).to eq("my data")
         end
       end
 
@@ -88,10 +88,10 @@ class Hiera
         Dir.mktmpdir do |dir|
           file = File.join(dir, "testing")
           write_file(file, "my data")
-          @cache.read_file(file).should == "my data"
+          expect(@cache.read_file(file)).to eq("my data")
 
           write_file(file, "changed data")
-          @cache.read_file(file).should == "changed data"
+          expect(@cache.read_file(file)).to eq("changed data")
         end
       end
 
@@ -113,9 +113,9 @@ class Hiera
           file = File.join(dir, "testing")
           write_file(file, "my data")
 
-          @cache.read_file(file, Hash) do |data|
+          expect(@cache.read_file(file, Hash) do |data|
             { :data => data }
-          end.should == { :data => "my data" }
+          end).to eq({ :data => "my data" })
         end
       end
 

data/spec/unit/hiera_spec.rb

@@ -18,7 +18,7 @@ describe "Hiera" do
 
       Hiera.logger = "no_such_logger"
 
-      Hiera.logger.should be Hiera::Console_logger
+      expect(Hiera.logger).to be Hiera::Console_logger
     end
 
     it "falls back to the Console logger when the logger class could not be found" do
@@ -27,7 +27,7 @@ describe "Hiera" do
 
       Hiera.logger = "no_constant"
 
-      Hiera.logger.should be Hiera::Console_logger
+      expect(Hiera.logger).to be Hiera::Console_logger
     end
   end
 

data/spec/unit/puppet_logger_spec.rb

@@ -4,13 +4,13 @@ describe Hiera::Puppet_logger do
   it "is not suitable when Puppet is not defined" do
     ensure_puppet_not_defined
 
-    Hiera::Puppet_logger.suitable?.should == false
+    expect(Hiera::Puppet_logger.suitable?).to eq(false)
   end
 
   it "is suitable when Puppet is defined" do
     ensure_puppet_defined
 
-    Hiera::Puppet_logger.suitable?.should == true
+    expect(Hiera::Puppet_logger.suitable?).to eq(true)
   end
 
   after :each do

data/spec/unit/util_spec.rb

@@ -4,45 +4,45 @@ describe Hiera::Util do
   describe 'Hiera::Util.posix?' do
     it 'should return true on posix systems' do
       Etc.expects(:getpwuid).with(0).returns(true)
-      Hiera::Util.posix?.should be_true
+      expect(Hiera::Util.posix?).to be_truthy
     end
 
     it 'should return false on non posix systems' do
       Etc.expects(:getpwuid).with(0).returns(nil)
-      Hiera::Util.posix?.should be_false
+      expect(Hiera::Util.posix?).to be_falsey
     end
   end
 
   describe 'Hiera::Util.microsoft_windows?' do
     it 'should return false on posix systems' do
       Hiera::Util.expects(:file_alt_separator).returns(nil)
-      Hiera::Util.microsoft_windows?.should be_false
+      expect(Hiera::Util.microsoft_windows?).to be_falsey
     end
   end
 
   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/puppetlabs/code'
+      expect(Hiera::Util.config_dir).to eq('/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/code'
+      expect(Hiera::Util.config_dir).to eq('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 == '/etc/puppetlabs/code/environments/%{environment}/hieradata'
+      expect(Hiera::Util.var_dir).to eq('/etc/puppetlabs/code/environments/%{environment}/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/code/environments/%{environment}/hieradata'
+      expect(Hiera::Util.var_dir).to eq('C:\\ProgramData/PuppetLabs/code/environments/%{environment}/hieradata')
     end
   end
 end

data/spec/unit/version_spec.rb

@@ -19,11 +19,11 @@ describe "Hiera.version Public API" do
     end
 
     it "is Hiera::VERSION" do
-      subject.version.should == Hiera::VERSION
+      expect(subject.version).to eq(Hiera::VERSION)
     end
     it "respects the version= setter" do
       subject.version = '1.2.3'
-      subject.version.should == '1.2.3'
+      expect(subject.version).to eq('1.2.3')
     end
   end
 
@@ -34,11 +34,11 @@ describe "Hiera.version Public API" do
         pathname.basename.to_s == "VERSION"
       end.returns('1.2.1-9-g9fda440')
 
-      subject.version.should == '1.2.1-9-g9fda440'
+      expect(subject.version).to eq('1.2.1-9-g9fda440')
     end
     it "respects the version= setter" do
       subject.version = '1.2.3'
-      subject.version.should == '1.2.3'
+      expect(subject.version).to eq('1.2.3')
     end
   end
 end

metadata

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: hiera
 version: !ruby/object:Gem::Version
-  version: 3.0.1
-  prerelease: 
+  version: 3.0.5
 platform: ruby
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-23 00:00:00.000000000 Z
+date: 2015-11-16 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,84 +32,83 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/hiera
-- lib/hiera/version.rb
-- lib/hiera/noop_logger.rb
-- lib/hiera/error.rb
-- lib/hiera/fallback_logger.rb
-- lib/hiera/recursive_guard.rb
-- lib/hiera/backend/yaml_backend.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/error.rb
+- lib/hiera/fallback_logger.rb
 - lib/hiera/filecache.rb
 - lib/hiera/interpolate.rb
-- lib/hiera/console_logger.rb
+- lib/hiera/noop_logger.rb
 - lib/hiera/puppet_logger.rb
+- lib/hiera/recursive_guard.rb
 - lib/hiera/util.rb
-- lib/hiera/backend.rb
+- lib/hiera/version.rb
 - lib/hiera.rb
 - COPYING
 - README.md
 - LICENSE
-- spec/unit/interpolate_spec.rb
-- spec/unit/fixtures/override/config/hiera.yaml
-- spec/unit/fixtures/override/data/alternate.yaml
-- spec/unit/fixtures/override/data/common.yaml
-- spec/unit/fixtures/interpolate/config/hiera.yaml
-- spec/unit/fixtures/interpolate/data/niltest.yaml
-- spec/unit/fixtures/interpolate/data/recursive.yaml
+- 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/config_spec.rb
-- spec/unit/backend/yaml_backend_spec.rb
-- spec/unit/backend/json_backend_spec.rb
-- spec/unit/puppet_logger_spec.rb
 - spec/unit/console_logger_spec.rb
-- spec/unit/version_spec.rb
 - spec/unit/fallback_logger_spec.rb
-- spec/unit/util_spec.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/spec_helper.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/interpolate_spec.rb
-- spec/unit/fixtures/override/config/hiera.yaml
-- spec/unit/fixtures/override/data/alternate.yaml
-- spec/unit/fixtures/override/data/common.yaml
-- spec/unit/fixtures/interpolate/config/hiera.yaml
-- spec/unit/fixtures/interpolate/data/niltest.yaml
-- spec/unit/fixtures/interpolate/data/recursive.yaml
+- 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/config_spec.rb
-- spec/unit/backend/yaml_backend_spec.rb
-- spec/unit/backend/json_backend_spec.rb
-- spec/unit/puppet_logger_spec.rb
 - spec/unit/console_logger_spec.rb
-- spec/unit/version_spec.rb
 - spec/unit/fallback_logger_spec.rb
-- spec/unit/util_spec.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/spec_helper.rb
+- spec/unit/interpolate_spec.rb
+- spec/unit/puppet_logger_spec.rb
+- spec/unit/util_spec.rb
+- spec/unit/version_spec.rb