puppet 2.7.26 → 3.0.0.rc4

data/spec/shared_behaviours/file_serving_model.rb

@@ -33,9 +33,7 @@ shared_examples_for "a file_serving model" do
 
     describe "when running the apply application" do
       before :each do
-        # Stub this so we can set the 'name' setting
-        Puppet::Util::Settings::ReadOnly.stubs(:include?)
-        Puppet[:name] = 'apply'
+        Puppet[:default_file_terminus] = 'file_server'
       end
 
       {
@@ -54,9 +52,7 @@ shared_examples_for "a file_serving model" do
 
     describe "when running another application" do
       before :each do
-        # Stub this so we can set the 'name' setting
-        Puppet::Util::Settings::ReadOnly.stubs(:include?)
-        Puppet[:name] = 'agent'
+        Puppet[:default_file_terminus] = 'rest'
       end
 
       {

data/spec/shared_contexts/platform.rb

@@ -12,17 +12,13 @@ shared_context "windows", :as_platform => :windows do
 
   around do |example|
     file_alt_separator = File::ALT_SEPARATOR
-    file_path_separator = File::PATH_SEPARATOR
-
     # prevent Ruby from warning about changing a constant
     with_verbose_disabled do
       File::ALT_SEPARATOR = '\\'
-      File::PATH_SEPARATOR = ';'
     end
     example.run
     with_verbose_disabled do
       File::ALT_SEPARATOR = file_alt_separator
-      File::PATH_SEPARATOR = file_path_separator
     end
   end
 end
@@ -35,17 +31,13 @@ shared_context "posix", :as_platform => :posix do
 
   around do |example|
     file_alt_separator = File::ALT_SEPARATOR
-    file_path_separator = File::PATH_SEPARATOR
-
     # prevent Ruby from warning about changing a constant
     with_verbose_disabled do
       File::ALT_SEPARATOR = nil
-      File::PATH_SEPARATOR = ':'
     end
     example.run
     with_verbose_disabled do
       File::ALT_SEPARATOR = file_alt_separator
-      File::PATH_SEPARATOR = file_path_separator
     end
   end
 end

data/spec/spec_helper.rb

@@ -8,6 +8,11 @@ $LOAD_PATH.unshift File.join(dir, 'lib')
 # Don't want puppet getting the command line arguments for rake or autotest
 ARGV.clear
 
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
 require 'puppet'
 gem 'rspec', '>=2.0.0'
 require 'rspec/expectations'
@@ -19,10 +24,10 @@ end
 
 require 'pathname'
 require 'tmpdir'
-require 'fileutils'
 
 require 'puppet_spec/verbose'
 require 'puppet_spec/files'
+require 'puppet_spec/settings'
 require 'puppet_spec/fixtures'
 require 'puppet_spec/matchers'
 require 'puppet_spec/database'
@@ -43,16 +48,6 @@ RSpec.configure do |config|
 
   config.mock_with :mocha
 
-  tmpdir = Dir.mktmpdir("rspecrun")
-  oldtmpdir = Dir.tmpdir()
-  ENV['TMPDIR'] = tmpdir
-
-  if Puppet::Util::Platform.windows?
-    config.output_stream = $stdout
-    config.error_stream = $stderr
-    config.formatters.each { |f| f.instance_variable_set(:@output, $stdout) }
-  end
-
   config.before :all do
     Puppet::Test::TestHelper.before_all_tests()
   end
@@ -112,9 +107,13 @@ RSpec.configure do |config|
   end
 
   config.after :suite do
-    # Clean up switch of TMPDIR, don't know if needed after this, so needs to reset it
-    # to old before removing it
-    ENV['TMPDIR'] = oldtmpdir
-    FileUtils.rm_rf(tmpdir) if File.exists?(tmpdir) && tmpdir.to_s.start_with?(oldtmpdir)
+    # Log the spec order to a file, but only if the LOG_SPEC_ORDER environment variable is
+    #  set.  This should be enabled on Jenkins runs, as it can be used with Nick L.'s bisect
+    #  script to help identify and debug order-dependent spec failures.
+    if ENV['LOG_SPEC_ORDER']
+      File.open("./spec_order.txt", "w") do |logfile|
+        config.instance_variable_get(:@files_to_run).each { |f| logfile.puts f }
+      end
+    end
   end
 end

data/spec/unit/agent/disabler_spec.rb

@@ -0,0 +1,64 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/agent'
+require 'puppet/agent/locker'
+
+class DisablerTester
+  include Puppet::Agent::Disabler
+end
+
+describe Puppet::Agent::Disabler do
+  before do
+    @disabler = DisablerTester.new
+  end
+
+  ## These tests are currently very implementation-specific, and they rely heavily on
+  ##  having access to the "disable_lockfile" method.  However, I've made this method private
+  ##  because it really shouldn't be exposed outside of our implementation... therefore
+  ##  these tests have to use a lot of ".send" calls.  They should probably be cleaned up
+  ##  but for the moment I wanted to make sure not to lose any of the functionality of
+  ##  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)
+  end
+
+  it "should use puppet's :agent_disabled_lockfile' setting to determine its lockfile path" do
+    lockfile = File.expand_path("/my/lock.disabled")
+    Puppet[:agent_disabled_lockfile] = lockfile
+    lock = Puppet::Util::JsonLockfile.new(lockfile)
+    Puppet::Util::JsonLockfile.expects(:new).with(lockfile).returns lock
+
+    @disabler.send(:disable_lockfile)
+  end
+
+  it "should reuse the same lock file each time" do
+    @disabler.send(:disable_lockfile).should equal(@disabler.send(:disable_lockfile))
+  end
+
+  it "should lock the file when disabled" do
+    @disabler.send(:disable_lockfile).expects(:lock)
+
+    @disabler.disable
+  end
+
+  it "should unlock the file when enabled" do
+    @disabler.send(:disable_lockfile).expects(:unlock)
+
+    @disabler.enable
+  end
+
+  it "should check the lock if it is disabled" do
+    @disabler.send(:disable_lockfile).expects(:locked?)
+
+    @disabler.disabled?
+  end
+
+  it "should report the disable message when disabled" do
+    Puppet[:agent_disabled_lockfile] = PuppetSpec::Files.tmpfile("lock")
+
+    msg = "I'm busy, go away"
+    @disabler.disable(msg)
+    @disabler.disable_message.should == msg
+  end
+end

data/spec/unit/agent/locker_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/agent'
 require 'puppet/agent/locker'
@@ -10,39 +10,34 @@ end
 describe Puppet::Agent::Locker do
   before do
     @locker = LockerTester.new
-    @locker.stubs(:lockfile_path).returns "/my/lock"
   end
 
+  ## These tests are currently very implementation-specific, and they rely heavily on
+  ##  having access to the lockfile object.  However, I've made this method private
+  ##  because it really shouldn't be exposed outside of our implementation... therefore
+  ##  these tests have to use a lot of ".send" calls.  They should probably be cleaned up
+  ##  but for the moment I wanted to make sure not to lose any of the functionality of
+  ##  the tests.   --cprice 2012-04-16
+
   it "should use a Pidlock instance as its lockfile" do
-    @locker.lockfile.should be_instance_of(Puppet::Util::Pidlock)
+    @locker.send(:lockfile).should be_instance_of(Puppet::Util::Pidlock)
   end
 
-  it "should use 'lockfile_path' to determine its lockfile path" do
-    @locker.expects(:lockfile_path).returns "/my/lock"
-    lock = Puppet::Util::Pidlock.new("/my/lock")
-    Puppet::Util::Pidlock.expects(:new).with("/my/lock").returns lock
+  it "should use puppet's :agent_pidfile' setting to determine its lockfile path" do
+    lockfile = File.expand_path("/my/lock")
+    Puppet[:agent_pidfile] = lockfile
+    lock = Puppet::Util::Pidlock.new(lockfile)
+    Puppet::Util::Pidlock.expects(:new).with(lockfile).returns lock
 
-    @locker.lockfile
+    @locker.send(:lockfile)
   end
 
   it "should reuse the same lock file each time" do
-    @locker.lockfile.should equal(@locker.lockfile)
-  end
-
-  it "should use the lock file to anonymously lock the process when disabled" do
-    @locker.lockfile.expects(:lock).with(:anonymous => true)
-
-    @locker.disable
-  end
-
-  it "should use the lock file to anonymously unlock the process when enabled" do
-    @locker.lockfile.expects(:unlock).with(:anonymous => true)
-
-    @locker.enable
+    @locker.send(:lockfile).should equal(@locker.send(:lockfile))
   end
 
   it "should have a method that yields when a lock is attained" do
-    @locker.lockfile.expects(:lock).returns true
+    @locker.send(:lockfile).expects(:lock).returns true
 
     yielded = false
     @locker.lock do
@@ -51,20 +46,20 @@ describe Puppet::Agent::Locker do
     yielded.should be_true
   end
 
-  it "should return true when the lock method successfully locked" do
-    @locker.lockfile.expects(:lock).returns true
+  it "should return the block result when the lock method successfully locked" do
+    @locker.send(:lockfile).expects(:lock).returns true
 
-    @locker.lock {}.should be_true
+    @locker.lock { :result }.should == :result
   end
 
-  it "should return true when the lock method does not receive the lock" do
-    @locker.lockfile.expects(:lock).returns false
+  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_false
+    @locker.lock {}.should be_nil
   end
 
   it "should not yield when the lock method does not receive the lock" do
-    @locker.lockfile.expects(:lock).returns false
+    @locker.send(:lockfile).expects(:lock).returns false
 
     yielded = false
     @locker.lock { yielded = true }
@@ -72,28 +67,28 @@ describe Puppet::Agent::Locker do
   end
 
   it "should not unlock when a lock was not received" do
-    @locker.lockfile.expects(:lock).returns false
-    @locker.lockfile.expects(:unlock).never
+    @locker.send(:lockfile).expects(:lock).returns false
+    @locker.send(:lockfile).expects(:unlock).never
 
     @locker.lock {}
   end
 
   it "should unlock after yielding upon obtaining a lock" do
-    @locker.lockfile.stubs(:lock).returns true
-    @locker.lockfile.expects(:unlock)
+    @locker.send(:lockfile).stubs(:lock).returns true
+    @locker.send(:lockfile).expects(:unlock)
 
     @locker.lock {}
   end
 
   it "should unlock after yielding upon obtaining a lock, even if the block throws an exception" do
-    @locker.lockfile.stubs(:lock).returns true
-    @locker.lockfile.expects(:unlock)
+    @locker.send(:lockfile).stubs(:lock).returns true
+    @locker.send(:lockfile).expects(:unlock)
 
     lambda { @locker.lock { raise "foo" } }.should raise_error(RuntimeError)
   end
 
   it "should be considered running if the lockfile is locked" do
-    @locker.lockfile.expects(:locked?).returns true
+    @locker.send(:lockfile).expects(:locked?).returns true
     @locker.should be_running
   end
 end

data/spec/unit/agent_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/agent'
 
@@ -61,33 +61,18 @@ describe Puppet::Agent do
     @agent.run
   end
 
-  it "should determine its lock file path by asking the client class" do
-    AgentTestClient.expects(:lockfile_path).returns "/my/lock"
-    @agent.lockfile_path.should == "/my/lock"
-  end
-
-  it "should be considered running if the lock file is locked and not anonymous" do
+  it "should be considered running if the lock file is locked" do
     lockfile = mock 'lockfile'
 
-    @agent.expects(:lockfile).returns(lockfile).twice
+    @agent.expects(:lockfile).returns(lockfile)
     lockfile.expects(:locked?).returns true
-    lockfile.expects(:anonymous?).returns false
 
     @agent.should be_running
   end
 
-  it "should be considered disabled if the lock file is locked and anonymous" do
-    lockfile = mock 'lockfile'
-
-    @agent.expects(:lockfile).returns(lockfile).at_least_once
-    lockfile.expects(:locked?).returns(true).at_least_once
-    lockfile.expects(:anonymous?).returns(true).at_least_once
-
-    @agent.should be_disabled
-  end
-
   describe "when being run" do
     before do
+      AgentTestClient.stubs(:lockfile_path).returns "/my/lock"
       @agent.stubs(:running?).returns false
       @agent.stubs(:disabled?).returns false
     end
@@ -104,6 +89,12 @@ describe Puppet::Agent do
       @agent.run
     end
 
+    it "should do nothing if disabled" do
+      @agent.expects(:disabled?).returns(true)
+      AgentTestClient.expects(:new).never
+      @agent.run
+    end
+
     it "(#11057) should notify the user about why a run is skipped" do
       Puppet::Application.stubs(:controlled_run).returns(false)
       Puppet::Application.stubs(:run_status).returns('MOCK_RUN_STATUS')
@@ -116,7 +107,8 @@ describe Puppet::Agent do
 
     it "should display an informative message if the agent is administratively disabled" do
       @agent.expects(:disabled?).returns true
-      Puppet.expects(:notice).with(regexp_matches(/Skipping run of .*; administratively disabled/))
+      @agent.expects(:disable_message).returns "foo"
+      Puppet.expects(:notice).with(regexp_matches(/Skipping run of .*; administratively disabled.*\(Reason: 'foo'\)/))
       @agent.run
     end
 
@@ -175,19 +167,80 @@ describe Puppet::Agent do
       client = AgentTestClient.new
       AgentTestClient.expects(:new).returns client
 
-      client.expects(:run).with("testargs")
-      @agent.run("testargs")
+      client.expects(:run).with(:pluginsync => true, :other => :options)
+      @agent.run(:other => :options)
+    end
+
+    it "should return the agent result" do
+      client = AgentTestClient.new
+      AgentTestClient.expects(:new).returns client
+
+      @agent.expects(:lock).returns(:result)
+      @agent.run.should == :result
+    end
+
+    describe "when should_fork is true" do
+      before do
+        @agent.should_fork = true
+        Kernel.stubs(:fork)
+        Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 0)]
+        @agent.stubs(:exit)
+      end
+
+      it "should run the agent in a forked process" do
+        client = AgentTestClient.new
+        AgentTestClient.expects(:new).returns client
+
+        client.expects(:run)
+
+        Kernel.expects(:fork).yields
+        @agent.run
+      end
+
+      it "should exit child process if child exit" do
+        client = AgentTestClient.new
+        AgentTestClient.expects(:new).returns client
+
+        client.expects(:run).raises(SystemExit)
+
+        Kernel.expects(:fork).yields
+        @agent.expects(:exit).with(-1)
+        @agent.run
+      end
+
+      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)
+      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)
+      end
+
+      it "should return the child exit code" do
+        Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 777)]
+        @agent.run.should == 777
+      end
+
+      it "should return the block exit code as the child exit code" do
+        Kernel.expects(:fork).yields
+        @agent.expects(:exit).with(777)
+        @agent.run_in_fork {
+          777
+        }
+      end
     end
   end
 
   describe "when splaying" do
     before do
-      Puppet.settings.stubs(:value).with(:splay).returns true
-      Puppet.settings.stubs(:value).with(:splaylimit).returns "10"
+      Puppet[:splay] = true
+      Puppet[:splaylimit] = "10"
     end
 
     it "should do nothing if splay is disabled" do
-      Puppet.settings.expects(:value).returns false
+      Puppet[:splay] = false
       @agent.expects(:sleep).never
       @agent.splay
     end
@@ -205,7 +258,7 @@ describe Puppet::Agent do
     end
 
     it "should sleep for a random portion of the splaylimit plus 1" do
-      Puppet.settings.expects(:value).with(:splaylimit).returns "50"
+      Puppet[:splaylimit] = "50"
       @agent.expects(:rand).with(51).returns 10
       @agent.expects(:sleep).with(10)
       @agent.splay