puppet 3.8.7 → 4.0.0

data/spec/unit/confine/variable_spec.rb

@@ -5,19 +5,19 @@ require 'puppet/confine/variable'
 
 describe Puppet::Confine::Variable do
   it "should be named :variable" do
-    Puppet::Confine::Variable.name.should == :variable
+    expect(Puppet::Confine::Variable.name).to eq(:variable)
   end
 
   it "should require a value" do
-    lambda { Puppet::Confine::Variable.new }.should raise_error(ArgumentError)
+    expect { Puppet::Confine::Variable.new }.to raise_error(ArgumentError)
   end
 
   it "should always convert values to an array" do
-    Puppet::Confine::Variable.new("/some/file").values.should be_instance_of(Array)
+    expect(Puppet::Confine::Variable.new("/some/file").values).to be_instance_of(Array)
   end
 
   it "should have an accessor for its name" do
-    Puppet::Confine::Variable.new(:bar).should respond_to(:name)
+    expect(Puppet::Confine::Variable.new(:bar)).to respond_to(:name)
   end
 
   describe "when testing values" do
@@ -41,39 +41,39 @@ describe Puppet::Confine::Variable do
     it "should be valid if the value matches the facter value" do
       @confine.expects(:test_value).returns "foo"
 
-      @confine.should be_valid
+      expect(@confine).to be_valid
     end
 
     it "should return false if the value does not match the facter value" do
       @confine.expects(:test_value).returns "fee"
 
-      @confine.should_not be_valid
+      expect(@confine).not_to be_valid
     end
 
     it "should be case insensitive" do
       @confine.expects(:test_value).returns "FOO"
 
-      @confine.should be_valid
+      expect(@confine).to be_valid
     end
 
     it "should not care whether the value is a string or symbol" do
       @confine.expects(:test_value).returns "FOO"
 
-      @confine.should be_valid
+      expect(@confine).to be_valid
     end
 
     it "should produce a message that the fact value is not correct" do
       @confine = Puppet::Confine::Variable.new(%w{bar bee})
       @confine.name = "eh"
       message = @confine.message("value")
-      message.should be_include("facter")
-      message.should be_include("bar,bee")
+      expect(message).to be_include("facter")
+      expect(message).to be_include("bar,bee")
     end
 
     it "should be valid if the test value matches any of the provided values" do
       @confine = Puppet::Confine::Variable.new(%w{bar bee})
       @confine.expects(:test_value).returns "bee"
-      @confine.should be_valid
+      expect(@confine).to be_valid
     end
   end
 
@@ -89,7 +89,7 @@ describe Puppet::Confine::Variable do
       c3.name = "tres"
       c3.expects(:valid?).returns false
 
-      Puppet::Confine::Variable.summarize([c1, c2, c3]).should == {"uno" => %w{one}, "tres" => %w{three}}
+      expect(Puppet::Confine::Variable.summarize([c1, c2, c3])).to eq({"uno" => %w{one}, "tres" => %w{three}})
     end
 
     it "should combine the values of multiple confines with the same fact" do
@@ -100,7 +100,7 @@ describe Puppet::Confine::Variable do
       c2.name = "uno"
       c2.expects(:valid?).returns false
 
-      Puppet::Confine::Variable.summarize([c1, c2]).should == {"uno" => %w{one two}}
+      expect(Puppet::Confine::Variable.summarize([c1, c2])).to eq({"uno" => %w{one two}})
     end
   end
 end

data/spec/unit/confine_collection_spec.rb

@@ -5,15 +5,15 @@ require 'puppet/confine_collection'
 
 describe Puppet::ConfineCollection do
   it "should be able to add confines" do
-    Puppet::ConfineCollection.new("label").should respond_to(:confine)
+    expect(Puppet::ConfineCollection.new("label")).to respond_to(:confine)
   end
 
   it "should require a label at initialization" do
-    lambda { Puppet::ConfineCollection.new }.should raise_error(ArgumentError)
+    expect { Puppet::ConfineCollection.new }.to raise_error(ArgumentError)
   end
 
   it "should make its label available" do
-    Puppet::ConfineCollection.new("mylabel").label.should == "mylabel"
+    expect(Puppet::ConfineCollection.new("mylabel").label).to eq("mylabel")
   end
 
   describe "when creating confine instances" do
@@ -56,7 +56,7 @@ describe Puppet::ConfineCollection do
   end
 
   it "should be valid if no confines are present" do
-    Puppet::ConfineCollection.new("label").should be_valid
+    expect(Puppet::ConfineCollection.new("label")).to be_valid
   end
 
   it "should be valid if all confines pass" do
@@ -69,7 +69,7 @@ describe Puppet::ConfineCollection do
     confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
 
-    confiner.should be_valid
+    expect(confiner).to be_valid
   end
 
   it "should not be valid if any confines fail" do
@@ -82,7 +82,7 @@ describe Puppet::ConfineCollection do
     confiner = Puppet::ConfineCollection.new("label")
     confiner.confine :true => :bar, :false => :bee
 
-    confiner.should_not be_valid
+    expect(confiner).not_to be_valid
   end
 
   describe "when providing a summary" do
@@ -91,11 +91,11 @@ describe Puppet::ConfineCollection do
     end
 
     it "should return a hash" do
-      @confiner.summary.should be_instance_of(Hash)
+      expect(@confiner.summary).to be_instance_of(Hash)
     end
 
     it "should return an empty hash if the confiner is valid" do
-      @confiner.summary.should == {}
+      expect(@confiner.summary).to eq({})
     end
 
     it "should add each test type's summary to the hash" do
@@ -103,7 +103,7 @@ describe Puppet::ConfineCollection do
       Puppet::Confine.test(:true).expects(:summarize).returns :tsumm
       Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
-      @confiner.summary.should == {:true => :tsumm, :false => :fsumm}
+      expect(@confiner.summary).to eq({:true => :tsumm, :false => :fsumm})
     end
 
     it "should not include tests that return 0" do
@@ -111,7 +111,7 @@ describe Puppet::ConfineCollection do
       Puppet::Confine.test(:true).expects(:summarize).returns 0
       Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
-      @confiner.summary.should == {:false => :fsumm}
+      expect(@confiner.summary).to eq({:false => :fsumm})
     end
 
     it "should not include tests that return empty arrays" do
@@ -119,7 +119,7 @@ describe Puppet::ConfineCollection do
       Puppet::Confine.test(:true).expects(:summarize).returns []
       Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
-      @confiner.summary.should == {:false => :fsumm}
+      expect(@confiner.summary).to eq({:false => :fsumm})
     end
 
     it "should not include tests that return empty hashes" do
@@ -127,7 +127,7 @@ describe Puppet::ConfineCollection do
       Puppet::Confine.test(:true).expects(:summarize).returns({})
       Puppet::Confine.test(:false).expects(:summarize).returns :fsumm
 
-      @confiner.summary.should == {:false => :fsumm}
+      expect(@confiner.summary).to eq({:false => :fsumm})
     end
   end
 end

data/spec/unit/confine_spec.rb

@@ -5,31 +5,31 @@ require 'puppet/confine'
 
 describe Puppet::Confine do
   it "should require a value" do
-    lambda { Puppet::Confine.new }.should raise_error(ArgumentError)
+    expect { Puppet::Confine.new }.to raise_error(ArgumentError)
   end
 
   it "should always convert values to an array" do
-    Puppet::Confine.new("/some/file").values.should be_instance_of(Array)
+    expect(Puppet::Confine.new("/some/file").values).to be_instance_of(Array)
   end
 
   it "should have a 'true' test" do
-    Puppet::Confine.test(:true).should be_instance_of(Class)
+    expect(Puppet::Confine.test(:true)).to be_instance_of(Class)
   end
 
   it "should have a 'false' test" do
-    Puppet::Confine.test(:false).should be_instance_of(Class)
+    expect(Puppet::Confine.test(:false)).to be_instance_of(Class)
   end
 
   it "should have a 'feature' test" do
-    Puppet::Confine.test(:feature).should be_instance_of(Class)
+    expect(Puppet::Confine.test(:feature)).to be_instance_of(Class)
   end
 
   it "should have an 'exists' test" do
-    Puppet::Confine.test(:exists).should be_instance_of(Class)
+    expect(Puppet::Confine.test(:exists)).to be_instance_of(Class)
   end
 
   it "should have a 'variable' test" do
-    Puppet::Confine.test(:variable).should be_instance_of(Class)
+    expect(Puppet::Confine.test(:variable)).to be_instance_of(Class)
   end
 
   describe "when testing all values" do
@@ -41,12 +41,12 @@ describe Puppet::Confine do
     it "should be invalid if any values fail" do
       @confine.stubs(:pass?).returns true
       @confine.expects(:pass?).with("b").returns false
-      @confine.should_not be_valid
+      expect(@confine).not_to be_valid
     end
 
     it "should be valid if all values pass" do
       @confine.stubs(:pass?).returns true
-      @confine.should be_valid
+      expect(@confine).to be_valid
     end
 
     it "should short-cut at the first failing value" do
@@ -71,7 +71,7 @@ describe Puppet::Confine do
       @confine.expects(:pass?).with("b").returns false
       @confine.expects(:pass?).with("d").returns false
 
-      @confine.result.should == [true, false, true, false]
+      expect(@confine.result).to eq([true, false, true, false])
     end
   end
 end

data/spec/unit/confiner_spec.rb

@@ -10,15 +10,15 @@ describe Puppet::Confiner do
   end
 
   it "should have a method for defining confines" do
-    @object.should respond_to(:confine)
+    expect(@object).to respond_to(:confine)
   end
 
   it "should have a method for returning its confine collection" do
-    @object.should respond_to(:confine_collection)
+    expect(@object).to respond_to(:confine_collection)
   end
 
   it "should have a method for testing suitability" do
-    @object.should respond_to(:suitable?)
+    expect(@object).to respond_to(:suitable?)
   end
 
   it "should delegate its confine method to its confine collection" do
@@ -31,11 +31,11 @@ describe Puppet::Confiner do
   it "should create a new confine collection if one does not exist" do
     Puppet::ConfineCollection.expects(:new).with("mylabel").returns "mycoll"
     @object.expects(:to_s).returns "mylabel"
-    @object.confine_collection.should == "mycoll"
+    expect(@object.confine_collection).to eq("mycoll")
   end
 
   it "should reuse the confine collection" do
-    @object.confine_collection.should equal(@object.confine_collection)
+    expect(@object.confine_collection).to equal(@object.confine_collection)
   end
 
   describe "when testing suitability" do
@@ -46,17 +46,17 @@ describe Puppet::Confiner do
 
     it "should return true if the confine collection is valid" do
       @coll.expects(:valid?).returns true
-      @object.should be_suitable
+      expect(@object).to be_suitable
     end
 
     it "should return false if the confine collection is invalid" do
       @coll.expects(:valid?).returns false
-      @object.should_not be_suitable
+      expect(@object).not_to be_suitable
     end
 
     it "should return the summary of the confine collection if a long result is asked for" do
       @coll.expects(:summary).returns "myresult"
-      @object.suitable?(false).should == "myresult"
+      expect(@object.suitable?(false)).to eq("myresult")
     end
   end
 end

data/spec/unit/context/trusted_information_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+require 'puppet/context/trusted_information'
+
 describe Puppet::Context::TrustedInformation do
   let(:key) do
     key = Puppet::SSL::Key.new("myname")
@@ -19,7 +21,12 @@ describe Puppet::Context::TrustedInformation do
   end
 
   let(:cert) do
-    Puppet::SSL::Certificate.from_instance(Puppet::SSL::CertificateFactory.build('ca', csr, csr.content, 1))
+    cert = Puppet::SSL::Certificate.from_instance(Puppet::SSL::CertificateFactory.build('ca', csr, csr.content, 1))
+
+    # The cert must be signed so that it can be successfully be DER-decoded later
+    signer = Puppet::SSL::CertificateSigner.new
+    signer.sign(cert.content, key.content)
+    cert
   end
 
   context "when remote" do
@@ -97,7 +104,7 @@ describe Puppet::Context::TrustedInformation do
       unfrozen_items(actual).empty?
     end
 
-    failure_message_for_should do |actual|
+    failure_message do |actual|
       "expected all items to be frozen but <#{unfrozen_items(actual).join(', ')}> was not"
     end
 

data/spec/unit/daemon_spec.rb

@@ -27,8 +27,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
   end
 
-  let(:server) { stub("Server", :start => nil, :wait_for_shutdown => nil) }
   let(:agent) { Puppet::Agent.new(TestClient.new, false) }
+  let(:server) { stub("Server", :start => nil, :wait_for_shutdown => nil) }
 
   let(:pidfile) { stub("PidFile", :lock => true, :unlock => true, :file_path => 'fake.pid') }
   let(:scheduler) { RecordingScheduler.new }
@@ -44,27 +44,16 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     daemon.reopen_logs
   end
 
-  let(:server) { stub("Server", :start => nil, :wait_for_shutdown => nil) }
-
   describe "when setting signal traps" do
-    [:INT, :TERM].each do |signal|
-      it "logs a notice and exits when sent #{signal}" do
-        Signal.stubs(:trap).with(signal).yields
-        Puppet.expects(:notice).with("Caught #{signal}; exiting")
-        daemon.expects(:stop)
+    signals = {:INT => :stop, :TERM => :stop }
+    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}) unless Puppet.features.microsoft_windows?
+    signals.each do |signal, method|
+      it "should log and call #{method} when it receives #{signal}" do
+        Signal.expects(:trap).with(signal).yields
 
-        daemon.set_signal_traps
-      end
-    end
-
-    {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
-      it "logs a notice and remembers to call #{method} when it receives #{signal}" do
-        Signal.stubs(:trap).with(signal).yields
-        Puppet.expects(:notice).with("Caught #{signal}; storing #{method}")
+        Puppet.expects(:notice)
 
         daemon.set_signal_traps
-
-        expect(daemon.signals).to eq([method])
       end
     end
   end
@@ -106,7 +95,7 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
       daemon.start
 
-      scheduler.jobs[0].should_not be_enabled
+      expect(scheduler.jobs[0]).not_to be_enabled
     end
 
     it "disables the agent run when there is no agent" do
@@ -115,7 +104,7 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
       daemon.start
 
-      scheduler.jobs[1].should_not be_enabled
+      expect(scheduler.jobs[1]).not_to be_enabled
     end
 
     it "waits for the server to shutdown when there is one" do
@@ -242,7 +231,7 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
     it "should fail if no argv values are available" do
       daemon.expects(:argv).returns nil
-      lambda { daemon.reexec }.should raise_error(Puppet::DevError)
+      expect { daemon.reexec }.to raise_error(Puppet::DevError)
     end
 
     it "should shut down without exiting" do

data/spec/unit/data_binding_spec.rb

@@ -5,7 +5,7 @@ describe Puppet::DataBinding do
   describe "when indirecting" do
     it "should default to the 'hiera' data_binding terminus" do
       Puppet::DataBinding.indirection.reset_terminus_class
-      Puppet::DataBinding.indirection.terminus_class.should == :hiera
+      expect(Puppet::DataBinding.indirection.terminus_class).to eq(:hiera)
     end
   end
 end

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -0,0 +1,96 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "when using function data provider" do
+  include PuppetSpec::Compiler
+
+  # There is a fully configured environment in fixtures in this location
+  let(:environmentpath) { parent_fixture('environments') }
+
+  around(:each) do |example|
+    # Initialize settings to get a full compile as close as possible to a real
+    # environment load
+    Puppet.settings.initialize_global_settings
+    # Initialize loaders based on the environmentpath. It does not work to
+    # just set the setting environmentpath for some reason - this achieves the same:
+    # - first a loader is created, loading directory environments from the fixture (there is
+    # one such environment, 'production', which will be loaded since the node references this
+    # environment by name).
+    # - secondly, the created env loader is set as 'environments' in the puppet context.
+    #
+    loader = Puppet::Environments::Directories.new(environmentpath, [])
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  # The environment configured in the fixture has one module called 'abc'. Its class abc, includes
+  # a class called 'def'. This class has three parameters test1, test2, and test3 and it creates
+  # three notify with name set to the value of the three parameters.
+  #
+  # Since the abc class does not provide any parameter values to its def class, it attempts to
+  # get them from data lookup. The fixture has an environment that is configured to load data from
+  # a function called environment::data, this data sets test1, and test2.
+  # The module 'abc' is configured to get data by calling the function abc::data(), this function
+  # returns data for all three parameters test1-test3, now with the prefix 'module'.
+  #
+  # The result should be that the data set in the environment wins over those set in the
+  # module.
+  #
+  it 'it gets data from module and environment functions and combines them with env having higher precedence' do
+    Puppet[:code] = 'include abc'
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
+    compiler = Puppet::Parser::Compiler.new(node)
+    catalog = compiler.compile()
+    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]"]
+    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+  end
+
+  it 'raises an error if the environment data function does not return a hash' do
+    Puppet[:code] = 'include abc'
+    # find the loaders to patch with faulty function
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
+
+    compiler = Puppet::Parser::Compiler.new(node)
+    loaders = compiler.loaders()
+    env_loader = loaders.private_environment_loader()
+    f = Puppet::Functions.create_function('environment::data') do
+      def data()
+        'this is not a hash'
+      end
+    end
+    env_loader.add_entry(:function, 'environment::data', f.new(compiler.topscope, env_loader), nil)
+    expect do
+      compiler.compile()
+    end.to raise_error(/Expected 'environment::data' function to return a Hash/)
+  end
+
+  it 'raises an error if the module data function does not return a hash' do
+    Puppet[:code] = 'include abc'
+    # find the loaders to patch with faulty function
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
+
+    compiler = Puppet::Parser::Compiler.new(node)
+    loaders = compiler.loaders()
+    module_loader = loaders.public_loader_for_module('abc')
+    f = Puppet::Functions.create_function('abc::data') do
+      def data()
+        'this is not a hash'
+      end
+    end
+    module_loader.add_entry(:function, 'abc::data', f.new(compiler.topscope, module_loader), nil)
+    expect do
+      compiler.compile()
+    end.to raise_error(/Expected 'abc::data' function to return a Hash/)
+  end
+
+  def parent_fixture(dir_name)
+    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
+  end
+
+  def resources_in(catalog)
+    catalog.resources.map(&:ref)
+  end
+
+end

data/spec/unit/data_providers/sample_data_provider_spec.rb

@@ -0,0 +1,52 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "when using a sample data provider from an external module" do
+  include PuppetSpec::Compiler
+
+  # There is a fully configured 'sample' environment in fixtures at this location
+  let(:environmentpath) { parent_fixture('environments') }
+
+  around(:each) do |example|
+    # Initialize settings to get a full compile as close as possible to a real
+    # environment load
+    Puppet.settings.initialize_global_settings
+    # Initialize loaders based on the environmentpath. It does not work to
+    # just set the setting environmentpath for some reason - this achieves the same:
+    # - first a loader is created, loading directory environments from the fixture (there is
+    # one environment, 'sample', which will be loaded since the node references this
+    # environment by name).
+    # - secondly, the created env loader is set as 'environments' in the puppet context.
+    #
+    loader = Puppet::Environments::Directories.new(environmentpath, [])
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  it 'the environment data loader is used to set parameters' do
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample')
+    compiler = Puppet::Parser::Compiler.new(node)
+    catalog = compiler.compile()
+    resources_created_in_fixture = ["Notify[env data param_a is 10, env data param_b is 20, 3]"]
+    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+  end
+
+  it 'the module and environment data loader is used to set parameters' do
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample')
+    compiler = Puppet::Parser::Compiler.new(node)
+    catalog = compiler.compile()
+    resources_created_in_fixture = ["Notify[module data param_a is 100, module data param_b is 200, env data param_c is 300]"]
+    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+  end
+
+  def parent_fixture(dir_name)
+    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
+  end
+
+  def resources_in(catalog)
+    catalog.resources.map(&:ref)
+  end
+
+end

data/spec/unit/defaults_spec.rb

@@ -12,7 +12,7 @@ describe "Defaults" do
           Facter.stubs(:value).with(:kernelmajversion).returns("5300")
         end
         it "should be empty" do
-          Puppet.default_diffargs.should == ""
+          expect(Puppet.default_diffargs).to eq("")
         end
       end
       [ "",
@@ -26,7 +26,7 @@ describe "Defaults" do
           end
 
           it "should be '-u'" do
-            Puppet.default_diffargs.should == "-u"
+            expect(Puppet.default_diffargs).to eq("-u")
           end
         end
       end
@@ -37,7 +37,7 @@ describe "Defaults" do
       end
 
       it "should be '-u'" do
-        Puppet.default_diffargs.should == "-u"
+        expect(Puppet.default_diffargs).to eq("-u")
       end
     end
   end
@@ -49,18 +49,18 @@ describe "Defaults" do
     end
 
     it 'should default to false' do
-      Puppet.settings[:cfacter].should be_false
+      expect(Puppet.settings[:cfacter]).to be_falsey
     end
 
     it 'should raise an error if cfacter is not installed' do
       Puppet.features.stubs(:cfacter?).returns false
-      lambda { Puppet.settings[:cfacter] = true }.should raise_exception ArgumentError, 'cfacter version 0.2.0 or later is not installed.'
+      expect { Puppet.settings[:cfacter] = true }.to raise_exception ArgumentError, 'cfacter version 0.2.0 or later is not installed.'
     end
 
     it 'should raise an error if facter has already evaluated facts' do
       Facter[:facterversion]
       Puppet.features.stubs(:cfacter?).returns true
-      lambda { Puppet.settings[:cfacter] = true }.should raise_exception ArgumentError, 'facter has already evaluated facts.'
+      expect { Puppet.settings[:cfacter] = true }.to raise_exception ArgumentError, 'facter has already evaluated facts.'
     end
 
     it 'should initialize cfacter when set to true' do

data/spec/unit/environments_spec.rb

@@ -489,7 +489,7 @@ config_version=$vardir/random/scripts
         env = Puppet::Node::Environment.create(:cached, [])
         mocked_loader = mock('loader')
         mocked_loader.expects(:get).with(:cached).returns(env).once
-        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env,'current', 20)).once
+        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
 
         cached = Puppet::Environments::Cached.new(mocked_loader)
 
@@ -515,7 +515,7 @@ config_version=$vardir/random/scripts
         env = Puppet::Node::Environment.create(:cached, [])
         mocked_loader = mock('loader')
         mocked_loader.expects(:get).with(:cached).returns(env).once
-        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env,'current', 20)).once
+        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
 
         cached = Puppet::Environments::Cached.new(mocked_loader)
 
@@ -574,7 +574,7 @@ config_version=$vardir/random/scripts
         (@config_version ? " with config_version #{@config_version}" : "")
     end
 
-    failure_message_for_should do |env|
+    failure_message do |env|
       "expected <#{env.name}: modulepath = [#{env.full_modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}> to be #{description}"
     end
   end
@@ -600,7 +600,7 @@ config_version=$vardir/random/scripts
         (@global_module_path ? " with global_module_path [#{@global_module_path.join(', ')}]" : "")
     end
 
-    failure_message_for_should do |env_conf|
+    failure_message do |env_conf|
       "expected #{env_conf.inspect} to be #{description}"
     end
   end
@@ -642,8 +642,6 @@ config_version=$vardir/random/scripts
     end
 
     def expired?(env_name)
-      # make expired? idempotent
-      return true if @expired_envs.include? (env_name)
       @expired_envs << env_name
       @expiration_sequence.pop
     end