puppet 3.8.7 → 4.0.0

data/spec/shared_contexts/checksum.rb

@@ -0,0 +1,62 @@
+# Shared contexts for testing against all supported checksum types.
+#
+# These helpers define nested rspec example groups to test code against all our
+# supported checksum types. Example groups that need to be run against all
+# types should use the `with_checksum_types` helper which will
+# create a new example group for each types and will run the given block
+# in each example group.
+
+CHECKSUM_PLAINTEXT = "1\r\n"*4000
+CHECKSUM_TYPES_TO_TRY = [
+  ['md5', 'a7a169ac84bb863b30484d0aa03139c1'],
+  ['md5lite', '22b4182363e81b326e98231fde616782'],
+  ['sha256', '47fcae62967db2fb5cba2fc0d9cf3e6767035d763d825ecda535a7b1928b9746'],
+  ['sha256lite', 'fd50217a2b0286ba25121bf2297bbe6c197933992de67e4e568f19861444ecf8']
+]
+
+CHECKSUM_STAT_TIME = Time.now
+TIME_TYPES_TO_TRY = [
+  ['ctime', "#{CHECKSUM_STAT_TIME}"],
+  ['mtime', "#{CHECKSUM_STAT_TIME}"]
+]
+
+shared_context('with supported checksum types') do
+  def self.with_checksum_types(path, file, &block)
+    def checksum_valid(checksum_type, expected_checksum, actual_checksum_signature)
+      case checksum_type
+      when 'mtime', 'ctime'
+        expect(DateTime.parse(actual_checksum_signature)).to be >= DateTime.parse(expected_checksum)
+      else
+        expect(actual_checksum_signature).to eq("{#{checksum_type}}#{expected_checksum}")
+      end
+    end
+
+    def expect_correct_checksum(meta, checksum_type, checksum, type)
+      expect(meta).to_not be_nil
+      expect(meta).to be_instance_of(type)
+      expect(meta.checksum_type).to eq(checksum_type)
+      expect(checksum_valid(checksum_type, checksum, meta.checksum)).to be_truthy
+    end
+
+    (CHECKSUM_TYPES_TO_TRY + TIME_TYPES_TO_TRY).each do |checksum_type, checksum|
+      describe("when checksum_type is #{checksum_type}") do
+        let(:checksum_type) { checksum_type }
+        let(:plaintext) { CHECKSUM_PLAINTEXT }
+        let(:checksum) { checksum }
+        let(:env_path) { tmpfile(path) }
+        let(:checksum_file) { File.join(env_path, file) }
+
+        def digest(content)
+          Puppet::Util::Checksums.send(checksum_type, content)
+        end
+
+        before(:each) do
+          FileUtils.mkdir_p(File.dirname(checksum_file))
+          File.open(checksum_file, "wb") { |f| f.write plaintext }
+        end
+
+        instance_eval(&block)
+      end
+    end
+  end
+end

data/spec/shared_contexts/{checksums.rb → digests.rb}

@@ -2,14 +2,14 @@
 #
 # These helpers define nested rspec example groups to test code against all our
 # supported digest algorithms. Example groups that need to be run against all
-# algorithms should use the `using_checksums_describe` helper which will
+# algorithms should use the `with_digest_algorithms` helper which will
 # create a new example group for each algorithm and will run the given block
 # in each example group.
 #
 # For each algorithm a shared context is defined for the given algorithm that
 # has precomputed checksum values and paths. These contexts are included
 # automatically based on the rspec metadata selected with
-# `using_checksums_describe`.
+# `with_digest_algorithms`.
 
 DIGEST_ALGORITHMS_TO_TRY = ['md5', 'sha256']
 

data/spec/spec_helper.rb

@@ -14,8 +14,10 @@ rescue LoadError
 end
 
 require 'puppet'
-gem 'rspec', '>=2.0.0'
+gem 'rspec', '>=3.1.0'
 require 'rspec/expectations'
+require 'rspec/its'
+require 'rspec/collection_matchers'
 
 # So everyone else doesn't have to include this base constant.
 module PuppetSpec
@@ -31,8 +33,6 @@ require 'puppet_spec/files'
 require 'puppet_spec/settings'
 require 'puppet_spec/fixtures'
 require 'puppet_spec/matchers'
-require 'puppet_spec/database'
-require 'monkey_patches/alias_should_to_must'
 require 'puppet/test/test_helper'
 
 Pathname.glob("#{dir}/shared_contexts/*.rb") do |file|
@@ -99,7 +99,7 @@ RSpec.configure do |config|
     Puppet::Test::TestHelper.after_all_tests()
   end
 
-  config.before :each do
+  config.before :each do |test|
     # Disabling garbage collection inside each test, and only running it at
     # the end of each block, gives us an ~ 15 percent speedup, and more on
     # some platforms *cough* windows *cough* that are a little slower.
@@ -121,6 +121,14 @@ RSpec.configure do |config|
     # redirecting logging away from console, because otherwise the test output will be
     #  obscured by all of the log output
     @logs = []
+    if ENV["PUPPET_TEST_LOG_LEVEL"]
+      Puppet::Util::Log.level = ENV["PUPPET_TEST_LOG_LEVEL"].intern
+    end
+    if ENV["PUPPET_TEST_LOG"]
+      Puppet::Util::Log.newdestination(ENV["PUPPET_TEST_LOG"])
+      m = test.metadata
+      Puppet.notice("*** BEGIN TEST #{m[:file_path]}:#{m[:line_number]}")
+    end
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
 
     @log_level = Puppet::Util::Log.level
@@ -128,6 +136,7 @@ RSpec.configure do |config|
     base = PuppetSpec::Files.tmpdir('tmp_settings')
     Puppet[:vardir] = File.join(base, 'var')
     Puppet[:confdir] = File.join(base, 'etc')
+    Puppet[:codedir] = File.join(base, 'code')
     Puppet[:logdir] = "$vardir/log"
     Puppet[:rundir] = "$vardir/run"
     Puppet[:hiera_config] = File.join(base, 'hiera')
@@ -175,7 +184,7 @@ RSpec.configure do |config|
 
     def profile
       result = RubyProf.profile { yield }
-      name = example.metadata[:full_description].downcase.gsub(/[^a-z0-9_-]/, "-").gsub(/-+/, "-")
+      name = RSpec.current_example.metadata[:full_description].downcase.gsub(/[^a-z0-9_-]/, "-").gsub(/-+/, "-")
       printer = RubyProf::CallTreePrinter.new(result)
       open(File.join(ENV['PROFILEOUT'],"callgrind.#{name}.#{Time.now.to_i}.trace"), "w") do |f|
         printer.print(f)

data/spec/unit/agent/disabler_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Agent::Disabler do
   ##  the tests. --cprice 2012-04-16
 
   it "should use an JsonLockfile instance as its disable_lockfile" do
-    @disabler.send(:disable_lockfile).should be_instance_of(Puppet::Util::JsonLockfile)
+    expect(@disabler.send(:disable_lockfile)).to be_instance_of(Puppet::Util::JsonLockfile)
   end
 
   it "should use puppet's :agent_disabled_lockfile' setting to determine its lockfile path" do
@@ -33,7 +33,7 @@ describe Puppet::Agent::Disabler do
   end
 
   it "should reuse the same lock file each time" do
-    @disabler.send(:disable_lockfile).should equal(@disabler.send(:disable_lockfile))
+    expect(@disabler.send(:disable_lockfile)).to equal(@disabler.send(:disable_lockfile))
   end
 
   it "should lock the file when disabled" do
@@ -59,6 +59,6 @@ describe Puppet::Agent::Disabler do
 
     msg = "I'm busy, go away"
     @disabler.disable(msg)
-    @disabler.disable_message.should == msg
+    expect(@disabler.disable_message).to eq(msg)
   end
 end

data/spec/unit/agent/locker_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Agent::Locker do
   ##  the tests.   --cprice 2012-04-16
 
   it "should use a Pidlock instance as its lockfile" do
-    @locker.send(:lockfile).should be_instance_of(Puppet::Util::Pidlock)
+    expect(@locker.send(:lockfile)).to be_instance_of(Puppet::Util::Pidlock)
   end
 
   it "should use puppet's agent_catalog_run_lockfile' setting to determine its lockfile path" do
@@ -35,11 +35,11 @@ describe Puppet::Agent::Locker do
   it "#lockfile_path provides the path to the lockfile" do
     lockfile = File.expand_path("/my/lock")
     Puppet[:agent_catalog_run_lockfile] = lockfile
-    @locker.lockfile_path.should == File.expand_path("/my/lock")
+    expect(@locker.lockfile_path).to eq(File.expand_path("/my/lock"))
   end
 
   it "should reuse the same lock file each time" do
-    @locker.send(:lockfile).should equal(@locker.send(:lockfile))
+    expect(@locker.send(:lockfile)).to equal(@locker.send(:lockfile))
   end
 
   it "should have a method that yields when a lock is attained" do
@@ -49,19 +49,19 @@ describe Puppet::Agent::Locker do
     @locker.lock do
       yielded = true
     end
-    yielded.should be_true
+    expect(yielded).to be_truthy
   end
 
   it "should return the block result when the lock method successfully locked" do
     @locker.send(:lockfile).expects(:lock).returns true
 
-    @locker.lock { :result }.should == :result
+    expect(@locker.lock { :result }).to eq(:result)
   end
 
   it "should return nil when the lock method does not receive the lock" do
     @locker.send(:lockfile).expects(:lock).returns false
 
-    @locker.lock {}.should be_nil
+    expect(@locker.lock {}).to be_nil
   end
 
   it "should not yield when the lock method does not receive the lock" do
@@ -69,7 +69,7 @@ describe Puppet::Agent::Locker do
 
     yielded = false
     @locker.lock { yielded = true }
-    yielded.should be_false
+    expect(yielded).to be_falsey
   end
 
   it "should not unlock when a lock was not received" do
@@ -90,11 +90,11 @@ describe Puppet::Agent::Locker do
     @locker.send(:lockfile).stubs(:lock).returns true
     @locker.send(:lockfile).expects(:unlock)
 
-    lambda { @locker.lock { raise "foo" } }.should raise_error(RuntimeError)
+    expect { @locker.lock { raise "foo" } }.to raise_error(RuntimeError)
   end
 
   it "should be considered running if the lockfile is locked" do
     @locker.send(:lockfile).expects(:locked?).returns true
-    @locker.should be_running
+    expect(@locker).to be_running
   end
 end

data/spec/unit/agent_spec.rb

@@ -45,11 +45,11 @@ describe Puppet::Agent do
   end
 
   it "should set its client class at initialization" do
-    Puppet::Agent.new("foo", false).client_class.should == "foo"
+    expect(Puppet::Agent.new("foo", false).client_class).to eq("foo")
   end
 
   it "should include the Locker module" do
-    Puppet::Agent.ancestors.should be_include(Puppet::Agent::Locker)
+    expect(Puppet::Agent.ancestors).to be_include(Puppet::Agent::Locker)
   end
 
   it "should create an instance of its client class and run it when asked to run" do
@@ -69,7 +69,7 @@ describe Puppet::Agent do
     @agent.expects(:lockfile).returns(lockfile)
     lockfile.expects(:locked?).returns true
 
-    @agent.should be_running
+    expect(@agent).to be_running
   end
 
   describe "when being run" do
@@ -149,7 +149,7 @@ describe Puppet::Agent do
       client = AgentTestClient.new
       AgentTestClient.expects(:new).returns client
 
-      client.expects(:run).with { @agent.client.should equal(client); true }
+      client.expects(:run).with { expect(@agent.client).to equal(client); true }
       @agent.run
     end
 
@@ -166,10 +166,10 @@ describe Puppet::Agent do
       AgentTestClient.expects(:new).returns client
 
       @agent.expects(:lock).returns(:result)
-      @agent.run.should == :result
+      expect(@agent.run).to eq(:result)
     end
 
-    describe "when should_fork is true", :as_platform => :posix do
+    describe "when should_fork is true", :if => Puppet.features.posix? do
       before do
         @agent = Puppet::Agent.new(AgentTestClient, true)
 
@@ -204,17 +204,17 @@ describe Puppet::Agent do
 
       it "should re-raise exit happening in the child" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -1)]
-        lambda { @agent.run }.should raise_error(SystemExit)
+        expect { @agent.run }.to raise_error(SystemExit)
       end
 
       it "should re-raise NoMoreMemory happening in the child" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -2)]
-        lambda { @agent.run }.should raise_error(NoMemoryError)
+        expect { @agent.run }.to raise_error(NoMemoryError)
       end
 
       it "should return the child exit code" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 777)]
-        @agent.run.should == 777
+        expect(@agent.run).to eq(777)
       end
 
       it "should return the block exit code as the child exit code" do
@@ -226,10 +226,10 @@ describe Puppet::Agent do
       end
     end
 
-    describe "on Windows", :as_platform => :windows do
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
       it "should never fork" do
         agent = Puppet::Agent.new(AgentTestClient, true)
-        expect(agent.should_fork).to be_false
+        expect(agent.should_fork).to be_falsey
       end
     end
   end
@@ -268,7 +268,7 @@ describe Puppet::Agent do
     it "should mark that it has splayed" do
       @agent.stubs(:sleep)
       @agent.splay
-      @agent.should be_splayed
+      expect(@agent).to be_splayed
     end
   end
 
@@ -282,11 +282,11 @@ describe Puppet::Agent do
       end
 
       it 'should be false for :stopping?' do
-        @agent.stopping?.should be_false
+        expect(@agent.stopping?).to be_falsey
       end
 
       it 'should be false for :needing_restart?' do
-        @agent.needing_restart?.should be_false
+        expect(@agent.needing_restart?).to be_falsey
       end
     end
 
@@ -299,11 +299,11 @@ describe Puppet::Agent do
       end
 
       it 'should be true for :stopping?' do
-        @agent.stopping?.should be_true
+        expect(@agent.stopping?).to be_truthy
       end
 
       it 'should be false for :needing_restart?' do
-        @agent.needing_restart?.should be_false
+        expect(@agent.needing_restart?).to be_falsey
       end
     end
 
@@ -316,11 +316,11 @@ describe Puppet::Agent do
       end
 
       it 'should be false for :stopping?' do
-        @agent.stopping?.should be_false
+        expect(@agent.stopping?).to be_falsey
       end
 
       it 'should be true for :needing_restart?' do
-        @agent.needing_restart?.should be_true
+        expect(@agent.needing_restart?).to be_truthy
       end
     end
   end

data/spec/unit/application/agent_spec.rb

@@ -38,23 +38,23 @@ describe Puppet::Application::Agent do
   end
 
   it "should operate in agent run_mode" do
-    @puppetd.class.run_mode.name.should == :agent
+    expect(@puppetd.class.run_mode.name).to eq(:agent)
   end
 
   it "should declare a main command" do
-    @puppetd.should respond_to(:main)
+    expect(@puppetd).to respond_to(:main)
   end
 
   it "should declare a onetime command" do
-    @puppetd.should respond_to(:onetime)
+    expect(@puppetd).to respond_to(:onetime)
   end
 
   it "should declare a fingerprint command" do
-    @puppetd.should respond_to(:fingerprint)
+    expect(@puppetd).to respond_to(:fingerprint)
   end
 
   it "should declare a preinit block" do
-    @puppetd.should respond_to(:preinit)
+    expect(@puppetd).to respond_to(:preinit)
   end
 
   describe "in preinit" do
@@ -64,40 +64,34 @@ describe Puppet::Application::Agent do
       @puppetd.preinit
     end
 
-    it "should init client to true" do
-      @puppetd.preinit
-
-      @puppetd.options[:client].should be_true
-    end
-
     it "should init fqdn to nil" do
       @puppetd.preinit
 
-      @puppetd.options[:fqdn].should be_nil
+      expect(@puppetd.options[:fqdn]).to be_nil
     end
 
     it "should init serve to []" do
       @puppetd.preinit
 
-      @puppetd.options[:serve].should == []
+      expect(@puppetd.options[:serve]).to eq([])
     end
 
     it "should use SHA256 as default digest algorithm" do
       @puppetd.preinit
 
-      @puppetd.options[:digest].should == 'SHA256'
+      expect(@puppetd.options[:digest]).to eq('SHA256')
     end
 
     it "should not fingerprint by default" do
       @puppetd.preinit
 
-      @puppetd.options[:fingerprint].should be_false
+      expect(@puppetd.options[:fingerprint]).to be_falsey
     end
 
     it "should init waitforcert to nil" do
       @puppetd.preinit
 
-      @puppetd.options[:waitforcert].should be_nil
+      expect(@puppetd.options[:waitforcert]).to be_nil
     end
   end
 
@@ -108,13 +102,13 @@ describe Puppet::Application::Agent do
 
     [:enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
       it "should declare handle_#{option} method" do
-        @puppetd.should respond_to("handle_#{option}".to_sym)
+        expect(@puppetd).to respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @puppetd.send("handle_#{option}".to_sym, 'arg')
 
-        @puppetd.options[option].should == 'arg'
+        expect(@puppetd.options[option]).to eq('arg')
       end
     end
 
@@ -122,22 +116,16 @@ describe Puppet::Application::Agent do
       it "should set disable to true" do
         @puppetd.handle_disable('')
 
-        @puppetd.options[:disable].should == true
+        expect(@puppetd.options[:disable]).to eq(true)
       end
 
       it "should store disable message" do
         @puppetd.handle_disable('message')
 
-        @puppetd.options[:disable_message].should == 'message'
+        expect(@puppetd.options[:disable_message]).to eq('message')
       end
     end
 
-    it "should set client to false with --no-client" do
-      @puppetd.handle_no_client(nil)
-
-      @puppetd.options[:client].should be_false
-    end
-
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       @agent.stubs(:run).returns(2)
       Puppet[:onetime] = true
@@ -179,7 +167,7 @@ describe Puppet::Application::Agent do
     it "should put the setdest options to true" do
       @puppetd.handle_logdest("console")
 
-      @puppetd.options[:setdest].should == true
+      expect(@puppetd.options[:setdest]).to eq(true)
     end
 
     it "should parse the log destination from the command line" do
@@ -193,7 +181,7 @@ describe Puppet::Application::Agent do
     it "should store the waitforcert options with --waitforcert" do
       @puppetd.handle_waitforcert("42")
 
-      @puppetd.options[:waitforcert].should == 42
+      expect(@puppetd.options[:waitforcert]).to eq(42)
     end
   end
 
@@ -220,17 +208,17 @@ describe Puppet::Application::Agent do
       it "should set options[:verbose] to true" do
         @puppetd.setup_test
 
-        @puppetd.options[:verbose].should == true
+        expect(@puppetd.options[:verbose]).to eq(true)
       end
       it "should set options[:onetime] to true" do
         Puppet[:onetime] = false
         @puppetd.setup_test
-        Puppet[:onetime].should == true
+        expect(Puppet[:onetime]).to eq(true)
       end
       it "should set options[:detailed_exitcodes] to true" do
         @puppetd.setup_test
 
-        @puppetd.options[:detailed_exitcodes].should == true
+        expect(@puppetd.options[:detailed_exitcodes]).to eq(true)
       end
     end
 
@@ -247,13 +235,13 @@ describe Puppet::Application::Agent do
       it "should set log level to debug if --debug was passed" do
         @puppetd.options[:debug] = true
         @puppetd.setup_logs
-        Puppet::Util::Log.level.should == :debug
+        expect(Puppet::Util::Log.level).to eq(:debug)
       end
 
       it "should set log level to info if --verbose was passed" do
         @puppetd.options[:verbose] = true
         @puppetd.setup_logs
-        Puppet::Util::Log.level.should == :info
+        expect(Puppet::Util::Log.level).to eq(:info)
       end
 
       [:verbose, :debug].each do |level|
@@ -325,12 +313,12 @@ describe Puppet::Application::Agent do
 
     it "should default catalog_terminus setting to 'rest'" do
       @puppetd.initialize_app_defaults
-      Puppet[:catalog_terminus].should ==  :rest
+      expect(Puppet[:catalog_terminus]).to eq(:rest)
     end
 
     it "should default node_terminus setting to 'rest'" do
       @puppetd.initialize_app_defaults
-      Puppet[:node_terminus].should ==  :rest
+      expect(Puppet[:node_terminus]).to eq(:rest)
     end
 
     it "has an application default :catalog_cache_terminus setting of 'json'" do
@@ -358,7 +346,7 @@ describe Puppet::Application::Agent do
 
     it "should default facts_terminus setting to 'facter'" do
       @puppetd.initialize_app_defaults
-      Puppet[:facts_terminus].should == :facter
+      expect(Puppet[:facts_terminus]).to eq(:facter)
     end
 
     it "should create an agent" do
@@ -407,15 +395,7 @@ describe Puppet::Application::Agent do
 
       execute_agent
 
-      @daemon.agent.should == @agent
-    end
-
-    it "should not inform the daemon about our agent if :client is set to 'false'" do
-      @puppetd.options[:client] = false
-
-      execute_agent
-
-      @daemon.agent.should be_nil
+      expect(@daemon.agent).to eq(@agent)
     end
 
     it "should daemonize if needed" do
@@ -449,43 +429,6 @@ describe Puppet::Application::Agent do
       execute_agent
     end
 
-    describe "when setting up listen" do
-      before :each do
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:rest_authconfig]).returns(true)
-        @puppetd.options[:serve] = []
-        @server = stub_everything 'server'
-        Puppet::Network::Server.stubs(:new).returns(@server)
-      end
-
-
-      it "should exit if no authorization file" do
-        Puppet[:listen] = true
-        Puppet.stubs(:err)
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:rest_authconfig]).returns(false)
-
-        expect do
-          execute_agent
-        end.to exit_with 14
-      end
-
-      it "should use puppet default port" do
-        Puppet[:puppetport] = 32768
-        Puppet[:listen] = true
-
-        Puppet::Network::Server.expects(:new).with(anything, 32768)
-
-        execute_agent
-      end
-
-      it "should issue a warning that listen is deprecated" do
-        Puppet[:listen] = true
-
-        Puppet.expects(:warning).with() { |msg| msg =~ /kick is deprecated/ }
-
-        execute_agent
-      end
-    end
-
     describe "when setting up for fingerprint" do
       before(:each) do
         @puppetd.options[:fingerprint] = true
@@ -558,15 +501,6 @@ describe Puppet::Application::Agent do
         Puppet[:onetime] = true
         @puppetd.options[:client] = :client
         @puppetd.options[:detailed_exitcodes] = false
-        Puppet.stubs(:newservice)
-      end
-
-      it "should exit if no defined --client" do
-        @puppetd.options[:client] = nil
-
-        Puppet.expects(:err).with('onetime is specified but there is no client')
-
-        expect { execute_agent }.to exit_with 43
       end
 
       it "should setup traps" do
@@ -638,7 +572,6 @@ describe Puppet::Application::Agent do
     describe "without --onetime and --fingerprint" do
       before :each do
         Puppet.stubs(:notice)
-        @puppetd.options[:client] = nil
       end
 
       it "should start our daemon" do