puppet 3.8.7 → 4.0.0

data/spec/unit/configurer/fact_handler_spec.rb

@@ -7,6 +7,12 @@ require 'matchers/json'
 class FactHandlerTester
   include Puppet::Configurer::FactHandler
 
+  attr_accessor :environment
+
+  def initialize(environment)
+    self.environment = environment
+  end
+
   def reload_facter
     # don't want to do this in tests
   end
@@ -15,8 +21,9 @@ end
 describe Puppet::Configurer::FactHandler do
   include JSONMatchers
 
+  let(:facthandler) { FactHandlerTester.new('production') }
+
   before :each do
-    @facthandler = FactHandlerTester.new
     Puppet::Node::Facts.indirection.terminus_class = :memory
   end
 
@@ -29,7 +36,7 @@ describe Puppet::Configurer::FactHandler do
       Puppet[:certname] = 'foo'
       Puppet[:node_name_value] = 'bar'
 
-      @facthandler.find_facts.should == bar_facts
+      expect(facthandler.find_facts).to eq(bar_facts)
     end
 
     it "should set the facts name based on the node_name_fact" do
@@ -37,7 +44,7 @@ describe Puppet::Configurer::FactHandler do
       Puppet::Node::Facts.indirection.save(facts)
       Puppet[:node_name_fact] = 'my_name_fact'
 
-      @facthandler.find_facts.name.should == 'other_node_name'
+      expect(facthandler.find_facts.name).to eq('other_node_name')
     end
 
     it "should set the node_name_value based on the node_name_fact" do
@@ -45,44 +52,44 @@ describe Puppet::Configurer::FactHandler do
       Puppet::Node::Facts.indirection.save(facts)
       Puppet[:node_name_fact] = 'my_name_fact'
 
-      @facthandler.find_facts
+      facthandler.find_facts
 
-      Puppet[:node_name_value].should == 'other_node_name'
+      expect(Puppet[:node_name_value]).to eq('other_node_name')
     end
 
     it "should fail if finding facts fails" do
       Puppet::Node::Facts.indirection.expects(:find).raises RuntimeError
 
-      expect { @facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
+      expect { facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
     end
 
     it "should only load fact plugins once" do
       Puppet::Node::Facts.indirection.expects(:find).once
-      @facthandler.find_facts
+      facthandler.find_facts
     end
   end
 
   it "should serialize and CGI escape the fact values for uploading" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
-    text = CGI.escape(@facthandler.find_facts.render(:pson))
+    text = CGI.escape(facthandler.find_facts.render(:pson))
 
-    @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
+    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
   end
 
   it "should properly accept facts containing a '+'" do
     facts = Puppet::Node::Facts.new('foo', 'afact' => 'a+b')
     Puppet::Node::Facts.indirection.save(facts)
-    text = CGI.escape(@facthandler.find_facts.render(:pson))
+    text = CGI.escape(facthandler.find_facts.render(:pson))
 
-    @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
+    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
   end
 
   it "should generate valid facts data against the facts schema" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
 
-    expect(CGI.unescape(@facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
+    expect(CGI.unescape(facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
   end
 
 end

data/spec/unit/configurer_spec.rb

@@ -13,7 +13,7 @@ describe Puppet::Configurer do
   end
 
   it "should include the Fact Handler module" do
-    Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::FactHandler)
+    expect(Puppet::Configurer.ancestors).to be_include(Puppet::Configurer::FactHandler)
   end
 
   describe "when executing a pre-run hook" do
@@ -35,7 +35,7 @@ describe Puppet::Configurer do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
 
-      @agent.execute_prerun_command.should be_false
+      expect(@agent.execute_prerun_command).to be_falsey
     end
   end
 
@@ -58,7 +58,7 @@ describe Puppet::Configurer do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
 
-      @agent.execute_postrun_command.should be_false
+      expect(@agent.execute_postrun_command).to be_falsey
     end
   end
 
@@ -103,7 +103,7 @@ describe Puppet::Configurer do
     it "should carry on when it can't fetch its node definition" do
       error = Net::HTTPError.new(400, 'dummy server communication error')
       Puppet::Node.indirection.expects(:find).raises(error)
-      @agent.run.should == 0
+      expect(@agent.run).to eq(0)
     end
 
     it "applies a cached catalog when it can't connect to the master" do
@@ -113,7 +113,7 @@ describe Puppet::Configurer do
       Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_cache => true)).raises(error)
       Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_terminus => true)).returns(@catalog)
 
-      @agent.run.should == 0
+      expect(@agent.run).to eq(0)
     end
 
     it "should initialize a transaction report if one is not provided" do
@@ -130,7 +130,7 @@ describe Puppet::Configurer do
       report = Puppet::Transaction::Report.new("apply")
 
       @agent.run(:report => report)
-      report.host.should == 'node_name_from_fact'
+      expect(report.host).to eq('node_name_from_fact')
     end
 
     it "should pass the new report to the catalog" do
@@ -185,7 +185,7 @@ describe Puppet::Configurer do
     end
 
     it "should benchmark how long it takes to apply the catalog" do
-      @agent.expects(:benchmark).with(:notice, "Finished catalog run")
+      @agent.expects(:benchmark).with(:notice, instance_of(String))
 
       @agent.expects(:retrieve_catalog).returns @catalog
 
@@ -204,8 +204,8 @@ describe Puppet::Configurer do
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
-      report.environment.should == "test"
-      report.transaction_uuid.should == "aaaa"
+      expect(report.environment).to eq("test")
+      expect(report.transaction_uuid).to eq("aaaa")
 
       @agent.run
     end
@@ -217,8 +217,8 @@ describe Puppet::Configurer do
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
-      report.environment.should == "test"
-      report.transaction_uuid.should == "aaaa"
+      expect(report.environment).to eq("test")
+      expect(report.transaction_uuid).to eq("aaaa")
 
       @agent.run
     end
@@ -230,10 +230,10 @@ describe Puppet::Configurer do
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
-      report.environment.should == "test"
-      report.transaction_uuid.should == "aaaa"
+      expect(report.environment).to eq("test")
+      expect(report.transaction_uuid).to eq("aaaa")
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should remove the report as a log destination when the run is finished" do
@@ -242,7 +242,7 @@ describe Puppet::Configurer do
 
       @agent.run
 
-      Puppet::Util::Log.destinations.should_not include(report)
+      expect(Puppet::Util::Log.destinations).not_to include(report)
     end
 
     it "should return the report exit_status as the result of the run" do
@@ -250,7 +250,7 @@ describe Puppet::Configurer do
       Puppet::Transaction::Report.expects(:new).returns(report)
       report.expects(:exit_status).returns(1234)
 
-      @agent.run.should == 1234
+      expect(@agent.run).to eq(1234)
     end
 
     it "should send the transaction report even if the pre-run command fails" do
@@ -261,7 +261,7 @@ describe Puppet::Configurer do
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
       @agent.expects(:send_report).with(report)
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should include the pre-run command failure in the report" do
@@ -271,8 +271,8 @@ describe Puppet::Configurer do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
 
-      @agent.run.should be_nil
-      report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }.should be
+      expect(@agent.run).to be_nil
+      expect(report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }).to be
     end
 
     it "should send the transaction report even if the post-run command fails" do
@@ -283,7 +283,7 @@ describe Puppet::Configurer do
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
       @agent.expects(:send_report).with(report)
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should include the post-run command failure in the report" do
@@ -295,7 +295,7 @@ describe Puppet::Configurer do
 
       report.expects(:<<).with { |log| log.message.include?("Could not run command from postrun_command") }
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should execute post-run command even if the pre-run command fails" do
@@ -304,7 +304,7 @@ describe Puppet::Configurer do
       Puppet::Util::Execution.expects(:execute).with(["/my/precommand"]).raises(Puppet::ExecutionFailure, "Failed")
       Puppet::Util::Execution.expects(:execute).with(["/my/postcommand"])
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should finalize the report" do
@@ -325,7 +325,7 @@ describe Puppet::Configurer do
       @catalog.expects(:apply).never()
       @agent.expects(:send_report)
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
@@ -338,12 +338,12 @@ describe Puppet::Configurer do
       @catalog.expects(:apply)
       @agent.expects(:send_report)
 
-      @agent.run.should be_nil
+      expect(@agent.run).to be_nil
     end
 
     it "should refetch the catalog if the server specifies a new environment in the catalog" do
-      @catalog.stubs(:environment).returns("second_env")
-      @agent.expects(:retrieve_catalog).returns(@catalog).twice
+      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
+      @agent.expects(:retrieve_catalog).returns(catalog).twice
 
       @agent.run
     end
@@ -353,7 +353,7 @@ describe Puppet::Configurer do
 
       @agent.run
 
-      @agent.environment.should == "second_env"
+      expect(@agent.environment).to eq("second_env")
     end
 
     it "should fix the report if the server specifies a new environment in the catalog" do
@@ -366,7 +366,7 @@ describe Puppet::Configurer do
 
       @agent.run
 
-      report.environment.should == "second_env"
+      expect(report.environment).to eq("second_env")
     end
 
     it "should clear the global caches" do
@@ -374,7 +374,7 @@ describe Puppet::Configurer do
 
       @agent.run
 
-      $env_module_directories.should == nil
+      expect($env_module_directories).to eq(nil)
     end
 
     describe "when not using a REST terminus for catalogs" do
@@ -464,7 +464,7 @@ describe Puppet::Configurer do
       Puppet::Transaction::Report.indirection.expects(:save).raises("whatever")
 
       Puppet.expects(:err)
-      lambda { @configurer.send_report(@report) }.should_not raise_error
+      expect { @configurer.send_report(@report) }.not_to raise_error
     end
   end
 
@@ -482,13 +482,13 @@ describe Puppet::Configurer do
 
     it "should write the last run file" do
       @configurer.save_last_run_summary(@report)
-      Puppet::FileSystem.exist?(Puppet[:lastrunfile]).should be_true
+      expect(Puppet::FileSystem.exist?(Puppet[:lastrunfile])).to be_truthy
     end
 
     it "should write the raw summary as yaml" do
       @report.expects(:raw_summary).returns("summary")
       @configurer.save_last_run_summary(@report)
-      File.read(Puppet[:lastrunfile]).should == YAML.dump("summary")
+      expect(File.read(Puppet[:lastrunfile])).to eq(YAML.dump("summary"))
     end
 
     it "should log but not fail if saving the last run summary fails" do
@@ -516,7 +516,7 @@ describe Puppet::Configurer do
       else
         mode = Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode
       end
-      (mode & 0777).should == 0664
+      expect(mode & 0777).to eq(0664)
     end
 
     it "should report invalid last run file permissions" do
@@ -555,14 +555,14 @@ describe Puppet::Configurer do
         Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
         Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
 
-        @agent.retrieve_catalog({}).should == @catalog
+        expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
 
       it "should compile a new catalog if none is found in the cache" do
         Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
         Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
-        @agent.retrieve_catalog({}).should == @catalog
+        expect(@agent.retrieve_catalog({})).to eq(@catalog)
       end
     end
 
@@ -583,7 +583,7 @@ describe Puppet::Configurer do
     it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
-      @agent.retrieve_catalog({}).should == @catalog
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
     it "should log and return the cached catalog when no catalog can be retrieved from the server" do
@@ -592,21 +592,21 @@ describe Puppet::Configurer do
 
       Puppet.expects(:notice)
 
-      @agent.retrieve_catalog({}).should == @catalog
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
     it "should not look in the cache for a catalog if one is returned from the server" do
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
 
-      @agent.retrieve_catalog({}).should == @catalog
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
     it "should return the cached catalog when retrieving the remote catalog throws an exception" do
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
-      @agent.retrieve_catalog({}).should == @catalog
+      expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
     it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
@@ -615,27 +615,27 @@ describe Puppet::Configurer do
 
       Puppet.expects(:warning)
 
-      @agent.retrieve_catalog({}).should be_nil
+      expect(@agent.retrieve_catalog({})).to be_nil
     end
 
     it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
       Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
-      @agent.retrieve_catalog({}).should be_nil
+      expect(@agent.retrieve_catalog({})).to be_nil
     end
 
     it "should convert the catalog before returning" do
       Puppet::Resource::Catalog.indirection.stubs(:find).returns @catalog
 
       @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
-      @agent.retrieve_catalog({}).should == "converted catalog"
+      expect(@agent.retrieve_catalog({})).to eq("converted catalog")
     end
 
     it "should return nil if there is an error while retrieving the catalog" do
       Puppet::Resource::Catalog.indirection.expects(:find).at_least_once.raises "eh"
 
-      @agent.retrieve_catalog({}).should be_nil
+      expect(@agent.retrieve_catalog({})).to be_nil
     end
   end
 
@@ -650,7 +650,7 @@ describe Puppet::Configurer do
     it "should convert the catalog to a RAL-formed catalog" do
       @oldcatalog.expects(:to_ral).returns @catalog
 
-      @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
+      expect(@agent.convert_catalog(@oldcatalog, 10)).to equal(@catalog)
     end
 
     it "should finalize the catalog" do

data/spec/unit/confine/exists_spec.rb

@@ -10,14 +10,14 @@ describe Puppet::Confine::Exists do
   end
 
   it "should be named :exists" do
-    Puppet::Confine::Exists.name.should == :exists
+    expect(Puppet::Confine::Exists.name).to eq(:exists)
   end
   
   it "should not pass if exists is nil" do
     confine = Puppet::Confine::Exists.new(nil)
     confine.label = ":exists => nil"
     confine.expects(:pass?).with(nil)
-    confine.should_not be_valid
+    expect(confine).not_to be_valid
   end
 
   it "should use the 'pass?' method to test validity" do
@@ -26,21 +26,21 @@ describe Puppet::Confine::Exists do
   end
 
   it "should return false if the value is false" do
-    @confine.pass?(false).should be_false
+    expect(@confine.pass?(false)).to be_falsey
   end
 
   it "should return false if the value does not point to a file" do
     Puppet::FileSystem.expects(:exist?).with("/my/file").returns false
-    @confine.pass?("/my/file").should be_false
+    expect(@confine.pass?("/my/file")).to be_falsey
   end
 
   it "should return true if the value points to a file" do
     Puppet::FileSystem.expects(:exist?).with("/my/file").returns true
-    @confine.pass?("/my/file").should be_true
+    expect(@confine.pass?("/my/file")).to be_truthy
   end
 
   it "should produce a message saying that a file is missing" do
-    @confine.message("/my/file").should be_include("does not exist")
+    expect(@confine.message("/my/file")).to be_include("does not exist")
   end
 
   describe "and the confine is for binaries" do
@@ -52,12 +52,12 @@ describe Puppet::Confine::Exists do
 
     it "should return false if no executable can be found" do
       @confine.expects(:which).with("/my/file").returns nil
-      @confine.pass?("/my/file").should be_false
+      expect(@confine.pass?("/my/file")).to be_falsey
     end
 
     it "should return true if the executable can be found" do
       @confine.expects(:which).with("/my/file").returns "/my/file"
-      @confine.pass?("/my/file").should be_true
+      expect(@confine.pass?("/my/file")).to be_truthy
     end
   end
 
@@ -67,7 +67,7 @@ describe Puppet::Confine::Exists do
     Puppet::FileSystem.expects(:exist?).with("/four").returns false
 
     confine = Puppet::Confine::Exists.new %w{/one /two /three /four}
-    confine.summary.should == %w{/two /four}
+    expect(confine.summary).to eq(%w{/two /four})
   end
 
   it "should summarize multiple instances by returning a flattened array of their summaries" do
@@ -75,6 +75,6 @@ describe Puppet::Confine::Exists do
     c2 = mock '2', :summary => %w{two}
     c3 = mock '3', :summary => %w{three}
 
-    Puppet::Confine::Exists.summarize([c1, c2, c3]).should == %w{one two three}
+    expect(Puppet::Confine::Exists.summarize([c1, c2, c3])).to eq(%w{one two three})
   end
 end

data/spec/unit/confine/false_spec.rb

@@ -5,11 +5,11 @@ require 'puppet/confine/false'
 
 describe Puppet::Confine::False do
   it "should be named :false" do
-    Puppet::Confine::False.name.should == :false
+    expect(Puppet::Confine::False.name).to eq(:false)
   end
 
   it "should require a value" do
-    lambda { Puppet::Confine.new }.should raise_error(ArgumentError)
+    expect { Puppet::Confine.new }.to raise_error(ArgumentError)
   end
 
   describe "when testing values" do
@@ -23,23 +23,23 @@ describe Puppet::Confine::False do
     end
 
     it "should return true if the value is false" do
-      @confine.pass?(false).should be_true
+      expect(@confine.pass?(false)).to be_truthy
     end
 
     it "should return false if the value is not false" do
-      @confine.pass?("else").should be_false
+      expect(@confine.pass?("else")).to be_falsey
     end
 
     it "should produce a message that a value is true" do
       @confine = Puppet::Confine::False.new("foo")
-      @confine.message("eh").should be_include("true")
+      expect(@confine.message("eh")).to be_include("true")
     end
   end
 
   it "should be able to produce a summary with the number of incorrectly true values" do
     confine = Puppet::Confine::False.new %w{one two three four}
     confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
-    confine.summary.should == 2
+    expect(confine.summary).to eq(2)
   end
 
   it "should summarize multiple instances by summing their summaries" do
@@ -47,6 +47,6 @@ describe Puppet::Confine::False do
     c2 = mock '2', :summary => 2
     c3 = mock '3', :summary => 3
 
-    Puppet::Confine::False.summarize([c1, c2, c3]).should == 6
+    expect(Puppet::Confine::False.summarize([c1, c2, c3])).to eq(6)
   end
 end

data/spec/unit/confine/feature_spec.rb

@@ -5,15 +5,15 @@ require 'puppet/confine/feature'
 
 describe Puppet::Confine::Feature do
   it "should be named :feature" do
-    Puppet::Confine::Feature.name.should == :feature
+    expect(Puppet::Confine::Feature.name).to eq(:feature)
   end
 
   it "should require a value" do
-    lambda { Puppet::Confine::Feature.new }.should raise_error(ArgumentError)
+    expect { Puppet::Confine::Feature.new }.to raise_error(ArgumentError)
   end
 
   it "should always convert values to an array" do
-    Puppet::Confine::Feature.new("/some/file").values.should be_instance_of(Array)
+    expect(Puppet::Confine::Feature.new("/some/file").values).to be_instance_of(Array)
   end
 
   describe "when testing values" do
@@ -29,16 +29,16 @@ describe Puppet::Confine::Feature do
 
     it "should return true if the feature is present" do
       Puppet.features.add(:myfeature) do true end
-      @confine.pass?("myfeature").should be_true
+      expect(@confine.pass?("myfeature")).to be_truthy
     end
 
     it "should return false if the value is false" do
       Puppet.features.add(:myfeature) do false end
-      @confine.pass?("myfeature").should be_false
+      expect(@confine.pass?("myfeature")).to be_falsey
     end
 
     it "should log that a feature is missing" do
-      @confine.message("myfeat").should be_include("missing")
+      expect(@confine.message("myfeat")).to be_include("missing")
     end
   end
 
@@ -52,6 +52,6 @@ describe Puppet::Confine::Feature do
     features.stub_everything
     Puppet.stubs(:features).returns features
 
-    Puppet::Confine::Feature.summarize(confines).sort.should == %w{one two three four}.sort
+    expect(Puppet::Confine::Feature.summarize(confines).sort).to eq(%w{one two three four}.sort)
   end
 end

data/spec/unit/confine/true_spec.rb

@@ -5,11 +5,11 @@ require 'puppet/confine/true'
 
 describe Puppet::Confine::True do
   it "should be named :true" do
-    Puppet::Confine::True.name.should == :true
+    expect(Puppet::Confine::True.name).to eq(:true)
   end
 
   it "should require a value" do
-    lambda { Puppet::Confine::True.new }.should raise_error(ArgumentError)
+    expect { Puppet::Confine::True.new }.to raise_error(ArgumentError)
   end
 
   describe "when testing values" do
@@ -24,22 +24,22 @@ describe Puppet::Confine::True do
     end
 
     it "should return true if the value is not false" do
-      @confine.pass?("else").should be_true
+      expect(@confine.pass?("else")).to be_truthy
     end
 
     it "should return false if the value is false" do
-      @confine.pass?(nil).should be_false
+      expect(@confine.pass?(nil)).to be_falsey
     end
 
     it "should produce the message that a value is false" do
-      @confine.message("eh").should be_include("false")
+      expect(@confine.message("eh")).to be_include("false")
     end
   end
 
   it "should produce the number of false values when asked for a summary" do
     @confine = Puppet::Confine::True.new %w{one two three four}
     @confine.expects(:pass?).times(4).returns(true).returns(false).returns(true).returns(false)
-    @confine.summary.should == 2
+    expect(@confine.summary).to eq(2)
   end
 
   it "should summarize multiple instances by summing their summaries" do
@@ -47,6 +47,6 @@ describe Puppet::Confine::True do
     c2 = mock '2', :summary => 2
     c3 = mock '3', :summary => 3
 
-    Puppet::Confine::True.summarize([c1, c2, c3]).should == 6
+    expect(Puppet::Confine::True.summarize([c1, c2, c3])).to eq(6)
   end
 end