puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/configurer/downloader_spec.rb

@@ -11,18 +11,18 @@ describe Puppet::Configurer::Downloader do
   let(:source) { 'puppet://puppet/plugins' }
 
   it "should require a name" do
-    lambda { Puppet::Configurer::Downloader.new }.should raise_error(ArgumentError)
+    expect { Puppet::Configurer::Downloader.new }.to raise_error(ArgumentError)
   end
 
   it "should require a path and a source at initialization" do
-    lambda { Puppet::Configurer::Downloader.new("name") }.should raise_error(ArgumentError)
+    expect { Puppet::Configurer::Downloader.new("name") }.to raise_error(ArgumentError)
   end
 
   it "should set the name, path and source appropriately" do
     dler = Puppet::Configurer::Downloader.new("facts", "path", "source")
-    dler.name.should == "facts"
-    dler.path.should == "path"
-    dler.source.should == "source"
+    expect(dler.name).to eq("facts")
+    expect(dler.path).to eq("path")
+    expect(dler.source).to eq("source")
   end
 
   def downloader(options = {})
@@ -55,19 +55,25 @@ describe Puppet::Configurer::Downloader do
     it "should always recurse" do
       file = generate_file_resource
 
-      expect(file[:recurse]).to be_true
+      expect(file[:recurse]).to be_truthy
+    end
+
+    it "should follow links by default" do
+      file = generate_file_resource
+
+      expect(file[:links]).to eq(:follow)
     end
 
     it "should always purge" do
       file = generate_file_resource
 
-      expect(file[:purge]).to be_true
+      expect(file[:purge]).to be_truthy
     end
 
     it "should never be in noop" do
       file = generate_file_resource
 
-      expect(file[:noop]).to be_false
+      expect(file[:noop]).to be_falsey
     end
 
     it "should set source_permissions to ignore by default" do
@@ -82,7 +88,7 @@ describe Puppet::Configurer::Downloader do
       expect(file[:source_permissions]).to eq(:use)
     end
 
-    describe "on POSIX", :as_platform => :posix do
+    describe "on POSIX", :if => Puppet.features.posix? do
       it "should always set the owner to the current UID" do
         Process.expects(:uid).returns 51
 
@@ -98,7 +104,7 @@ describe Puppet::Configurer::Downloader do
       end
     end
 
-    describe "on Windows", :as_platform => :windows do
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
       it "should omit the owner" do
         file = generate_file_resource(:path => 'C:/path')
 
@@ -115,13 +121,13 @@ describe Puppet::Configurer::Downloader do
     it "should always force the download" do
       file = generate_file_resource
 
-      expect(file[:force]).to be_true
+      expect(file[:force]).to be_truthy
     end
 
     it "should never back up when downloading" do
       file = generate_file_resource
 
-      expect(file[:backup]).to be_false
+      expect(file[:backup]).to be_falsey
     end
 
     it "should support providing an 'ignore' parameter" do
@@ -145,13 +151,13 @@ describe Puppet::Configurer::Downloader do
 
     it "should create a catalog and add the file to it" do
       catalog = @dler.catalog
-      catalog.resources.size.should == 1
-      catalog.resources.first.class.should == Puppet::Type::File
-      catalog.resources.first.name.should == @path
+      expect(catalog.resources.size).to eq(1)
+      expect(catalog.resources.first.class).to eq(Puppet::Type::File)
+      expect(catalog.resources.first.name).to eq(@path)
     end
 
     it "should specify that it is not managing a host catalog" do
-      @dler.catalog.host_config.should == false
+      expect(@dler.catalog.host_config).to eq(false)
     end
 
   end
@@ -169,7 +175,7 @@ describe Puppet::Configurer::Downloader do
       Puppet[:tags] = 'maytag'
       @dler.evaluate
 
-      Puppet::FileSystem.exist?(@dl_name).should be_true
+      expect(Puppet::FileSystem.exist?(@dl_name)).to be_truthy
     end
 
     it "should log that it is downloading" do
@@ -190,7 +196,7 @@ describe Puppet::Configurer::Downloader do
 
       trans.expects(:changed?).returns([resource])
 
-      @dler.evaluate.should == %w{/changed/file}
+      expect(@dler.evaluate).to eq(%w{/changed/file})
     end
 
     it "should yield the resources if a block is given" do
@@ -207,7 +213,7 @@ describe Puppet::Configurer::Downloader do
 
       yielded = nil
       @dler.evaluate { |r| yielded = r }
-      yielded.should == resource
+      expect(yielded).to eq(resource)
     end
 
     it "should catch and log exceptions" do
@@ -216,7 +222,7 @@ describe Puppet::Configurer::Downloader do
       # that it is possible to stub for the purpose of generating a puppet error
       Puppet::Resource::Catalog.any_instance.stubs(:apply).raises(Puppet::Error, "testing")
 
-      lambda { @dler.evaluate }.should_not raise_error
+      expect { @dler.evaluate }.not_to raise_error
     end
   end
 end

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