From f2dfee6e2f8731bb0b04a0dfc1e1b3b4146a4289 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Sat, 8 Jan 2011 22:15:32 +0100
Subject: (#5814) cron_spec shouldn't depend on cron provider

if cron is not installed the specs will throw errors abould not finding
a default provider. Because the spec doesn't test provider features it
shouldn't depend on any providers.

Add stubs to let cron_spec work with no suitable provider
---
 spec/unit/type/cron_spec.rb | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 03817d20e..1fe654d5a 100755
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -4,7 +4,18 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
 
 describe Puppet::Type.type(:cron) do
   before do
-    @cron = Puppet::Type.type(:cron).new( :name => "foo" )
+    @class = Puppet::Type.type(:cron)
+
+    # Init a fake provider
+    @provider_class = stub 'provider_class', :ancestors => [], :name => 'fake', :suitable? => true, :supports_parameter? => true
+    @class.stubs(:defaultprovider).returns @provider_class
+    @class.stubs(:provider).returns @provider_class
+
+    @provider = stub 'provider', :class => @provider_class, :clean => nil
+    @provider.stubs(:is_a?).returns false
+    @provider_class.stubs(:new).returns @provider
+
+    @cron = @class.new( :name => "foo" )
   end
 
   it "it should accept an :environment that looks like a path" do
-- 
cgit 


From fddc16535b16f81665b4a07dc03325af7e51c087 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Sun, 9 Jan 2011 10:18:37 +0100
Subject: (#5814) Improved cron type specs

Add specs to test value validation for minute, hour, weekday, month
and monthday
---
 spec/unit/type/cron_spec.rb | 471 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 454 insertions(+), 17 deletions(-)

diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 1fe654d5a..f985cdd09 100755
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -18,27 +18,464 @@ describe Puppet::Type.type(:cron) do
     @cron = @class.new( :name => "foo" )
   end
 
-  it "it should accept an :environment that looks like a path" do
-    lambda do
-      @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
-    end.should_not raise_error
+  it "should have :name be its namevar" do
+    @class.key_attributes.should == [:name]
   end
 
-  it "should not accept environment variables that do not contain '='" do
-    lambda do
-      @cron[:environment] = "INVALID"
-    end.should raise_error(Puppet::Error)
-  end
+  describe "when validating attributes" do
+
+    [:name, :provider].each do |param|
+      it "should have a #{param} parameter" do
+        @class.attrtype(param).should == :param
+      end
+    end
+
+    [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
+      it "should have a #{property} property" do
+        @class.attrtype(property).should == :property
+      end
+    end
+
+    [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
+      it "should have #{cronparam} of type CronParam" do
+        @class.attrclass(cronparam).ancestors.should include CronParam
+      end
+    end
 
-  it "should accept empty environment variables that do not contain '='" do
-    lambda do
-      @cron[:environment] = "MAILTO="
-    end.should_not raise_error(Puppet::Error)
   end
 
-  it "should accept 'absent'" do
-    lambda do
-      @cron[:environment] = 'absent'
-    end.should_not raise_error(Puppet::Error)
+
+  describe "when validating attribute" do
+
+    describe "ensure" do
+      it "should support present as a value for ensure" do
+        proc { @class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+      end
+
+      it "should support absent as a value for ensure" do
+        proc { @class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+      end
+    end
+
+    describe "minute" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :minute => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
+      end
+
+      it "should support valid single values" do
+        proc { @class.new(:name => 'foo', :minute => '0') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => '59') }.should_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        proc { @class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+
+        proc { @class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "hour" do
+
+     it "should support absent" do
+        proc { @class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :hour => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
+      end
+
+      it "should support valid single values" do
+        proc { @class.new(:name => 'foo', :hour => '0') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '11') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '12') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '13') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '23') }.should_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        proc { @class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+        proc { @class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+   describe "weekday" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
+      end
+
+      it "should support valid numeric weekdays" do
+        proc { @class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
+        # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
+        proc { @class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
+      end
+
+      it "should support valid weekdays as words (3 character version)" do
+        proc { @class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
+      end
+
+      it "should support valid weekdays as words (3 character version)" do
+        proc { @class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
+      end
+
+      it "should not support numeric values out of range" do
+        proc { @class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support invalid weekday names" do
+        proc { @class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "month" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :month => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :month => '*')[:month].should == :absent
+      end
+
+      it "should support valid numeric values" do
+        proc { @class.new(:name => 'foo', :month => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => '12') }.should_not raise_error
+      end
+
+      it "should support valid months as words" do
+        proc { @class.new(:name => 'foo', :month => 'January') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'February') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'March') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'April') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'June') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'July') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'August') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'September') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'October') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'November') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'December') }.should_not raise_error
+      end
+
+      it "should support valid months as words (3 character short version)" do
+        proc { @class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
+      end
+
+      it "should not support numeric values out of range" do
+        proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support words that are not valid months" do
+        proc { @class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+
+        proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "monthday" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
+      end
+
+      it "should support valid single values" do
+        proc { @class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        proc { @class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+        proc { @class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "environment" do
+
+      it "it should accept an :environment that looks like a path" do
+        lambda do
+          @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
+        end.should_not raise_error
+      end
+
+      it "should not accept environment variables that do not contain '='" do
+        lambda do
+          @cron[:environment] = "INVALID"
+        end.should raise_error(Puppet::Error)
+      end
+
+      it "should accept empty environment variables that do not contain '='" do
+        lambda do
+          @cron[:environment] = "MAILTO="
+        end.should_not raise_error(Puppet::Error)
+      end
+
+      it "should accept 'absent'" do
+        lambda do
+          @cron[:environment] = 'absent'
+        end.should_not raise_error(Puppet::Error)
+      end
+
+    end
+
   end
 end
-- 
cgit 


From 6a4d291fa72a3f37f88e3c18c97f919830761863 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Mar 2011 11:22:23 -0700
Subject: (#4884) Get rid of open3 require since it wasn't being used

Paired-with: Max Martin
---
 lib/puppet/type/exec.rb | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/puppet/type/exec.rb b/lib/puppet/type/exec.rb
index 5ed2b104c..387c592a6 100755
--- a/lib/puppet/type/exec.rb
+++ b/lib/puppet/type/exec.rb
@@ -23,10 +23,8 @@ module Puppet
       you are doing a lot of work with `exec`, please at least notify
       us at Puppet Labs what you are doing, and hopefully we can work with
       you to get a native resource type for the work you are doing.
-      
-      **Autorequires:** If Puppet is managing an exec's cwd or the executable file used in an exec's command, the exec resource will autorequire those files. If Puppet is managing the user that an exec should run as, the exec resource will autorequire that user."
 
-    require 'open3'
+      **Autorequires:** If Puppet is managing an exec's cwd or the executable file used in an exec's command, the exec resource will autorequire those files. If Puppet is managing the user that an exec should run as, the exec resource will autorequire that user."
 
     # Create a new check mechanism.  It's basically just a parameter that
     # provides one extra 'check' method.
-- 
cgit 


From acc99ba8f87cc3731102f8d3ad33c25e2aa0c65b Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Mar 2011 11:25:07 -0700
Subject: (#4884) Fix whitespace

Paired-with: Max Martin
---
 spec/integration/transaction_spec.rb | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/spec/integration/transaction_spec.rb b/spec/integration/transaction_spec.rb
index d5478d7a7..2c12b3d5f 100755
--- a/spec/integration/transaction_spec.rb
+++ b/spec/integration/transaction_spec.rb
@@ -107,29 +107,23 @@ describe Puppet::Transaction do
     file1 = tmpfile("file1")
     file2 = tmpfile("file2")
 
-          file = Puppet::Type.type(:file).new(
-                
-      :path => path,
-        
+    file = Puppet::Type.type(:file).new(
+      :path   => path,
       :ensure => "file"
     )
 
-          exec1 = Puppet::Type.type(:exec).new(
-                
-      :path => ENV["PATH"],
+    exec1 = Puppet::Type.type(:exec).new(
+      :path    => ENV["PATH"],
       :command => "touch #{file1}",
       :refreshonly => true,
-        
-      :subscribe => Puppet::Resource.new(:file, path)
+      :subscribe   => Puppet::Resource.new(:file, path)
     )
 
-          exec2 = Puppet::Type.type(:exec).new(
-                
-      :path => ENV["PATH"],
-      :command => "touch #{file2}",
+    exec2 = Puppet::Type.type(:exec).new(
+      :path        => ENV["PATH"],
+      :command     => "touch #{file2}",
       :refreshonly => true,
-        
-      :subscribe => Puppet::Resource.new(:file, path)
+      :subscribe   => Puppet::Resource.new(:file, path)
     )
 
     catalog = mk_catalog(file, exec1, exec2)
-- 
cgit 


From 7ec90576d396392a1005808136842cd8e0bfc961 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Tue, 15 Mar 2011 11:30:27 -0700
Subject: (#4884) Autorequire shared behaviors and method to silence warnings

with_verbose_disabled allows you to run tests that muck with constans
without getting spammy warnings.

Reviewed-by: Max Martin and Matt Robinson
---
 spec/lib/puppet_spec/verbose.rb | 9 +++++++++
 spec/spec_helper.rb             | 6 ++++++
 2 files changed, 15 insertions(+)
 create mode 100644 spec/lib/puppet_spec/verbose.rb

diff --git a/spec/lib/puppet_spec/verbose.rb b/spec/lib/puppet_spec/verbose.rb
new file mode 100644
index 000000000..d9834f2d7
--- /dev/null
+++ b/spec/lib/puppet_spec/verbose.rb
@@ -0,0 +1,9 @@
+# Support code for running stuff with warnings disabled.
+module Kernel
+  def with_verbose_disabled
+    verbose, $VERBOSE = $VERBOSE, nil
+    result = yield
+    $VERBOSE = verbose
+    return result
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index ae4edb2d9..505a8f973 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -23,10 +23,16 @@ end
 module PuppetTest
 end
 
+require 'pathname'
+require 'lib/puppet_spec/verbose'
 require 'lib/puppet_spec/files'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/publicize_methods'
 
+Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
+  require behaviour.relative_path_from(Pathname.new(dir))
+end
+
 RSpec.configure do |config|
   config.mock_with :mocha
 
-- 
cgit 


From 77fbf7fdd3d17c169057a17e8d5829907975d169 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Mar 2011 11:38:07 -0700
Subject: (#4884) Add expand_path to requiring the spec_helper

Paired-with: Max Martin
---
 spec/unit/type_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec/unit/type_spec.rb b/spec/unit/type_spec.rb
index b7a08977e..0adedf2a5 100755
--- a/spec/unit/type_spec.rb
+++ b/spec/unit/type_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path(File.join(File.dirname(__FILE__), '/../spec_helper'))
 
 describe Puppet::Type do
   it "should include the Cacher module" do
-- 
cgit 


From c86a980fe9b2f2e109fe7956a1be2705f3fc2ade Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Tue, 15 Mar 2011 11:45:02 -0700
Subject: (#4884) Add consistent path validation and behavior

Many path parameters were implementing their own inconsistent validation
and behavior.  Now those parameters can have a parent class that makes
things a lot more consistent.

Reviewed-by: Matt Robinson and Max Martin
---
 lib/puppet/parameter.rb                   |   2 +
 lib/puppet/parameter/path.rb              |  42 +++++++
 spec/shared_behaviours/path_parameters.rb | 185 ++++++++++++++++++++++++++++++
 spec/unit/parameter/path_spec.rb          |  24 ++++
 4 files changed, 253 insertions(+)
 create mode 100644 lib/puppet/parameter/path.rb
 create mode 100644 spec/shared_behaviours/path_parameters.rb
 create mode 100644 spec/unit/parameter/path_spec.rb

diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index ff7cab22b..29d60fc66 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -300,3 +300,5 @@ class Puppet::Parameter
     name.to_s
   end
 end
+
+require 'puppet/parameter/path'
diff --git a/lib/puppet/parameter/path.rb b/lib/puppet/parameter/path.rb
new file mode 100644
index 000000000..44886afd0
--- /dev/null
+++ b/lib/puppet/parameter/path.rb
@@ -0,0 +1,42 @@
+require 'puppet/parameter'
+
+class Puppet::Parameter::Path < Puppet::Parameter
+  def self.accept_arrays(bool = true)
+    @accept_arrays = !!bool
+  end
+  def self.arrays?
+    @accept_arrays
+  end
+
+  def validate_path(paths)
+    if paths.is_a?(Array) and ! self.class.arrays? then
+      fail "#{name} only accepts a single path, not an array of paths"
+    end
+
+    # We *always* support Unix path separators, as Win32 does now too.
+    absolute = "[/#{::Regexp.quote(::File::SEPARATOR)}]"
+    win32    = Puppet.features.microsoft_windows?
+
+    Array(paths).each do |path|
+      next if path =~ %r{^#{absolute}}
+      next if win32 and path =~ %r{^(?:[a-zA-Z]:)?#{absolute}}
+      fail("#{name} must be a fully qualified path")
+    end
+
+    paths
+  end
+
+  # This will be overridden if someone uses the validate option, which is why
+  # it just delegates to the other, useful, method.
+  def unsafe_validate(paths)
+    validate_path(paths)
+  end
+
+  # Likewise, this might be overridden, but by default...
+  def unsafe_munge(paths)
+    if paths.is_a?(Array) and ! self.class.arrays? then
+      fail "#{name} only accepts a single path, not an array of paths"
+    end
+    paths
+  end
+end
diff --git a/spec/shared_behaviours/path_parameters.rb b/spec/shared_behaviours/path_parameters.rb
new file mode 100644
index 000000000..b5a907900
--- /dev/null
+++ b/spec/shared_behaviours/path_parameters.rb
@@ -0,0 +1,185 @@
+# In order to use this correctly you must define a method to get an instance
+# of the type being tested, so that this code can remain generic:
+#
+#    it_should_behave_like "all path parameters", :path do
+#      def instance(path)
+#        Puppet::Type.type(:example).new(
+#          :name => 'foo', :require => 'bar', :path_param => path
+#        )
+#      end
+#
+# That method will be invoked for each test to create the instance that we
+# subsequently test through the system; you should ensure that the minimum of
+# possible attributes are set to keep the tests clean.
+#
+# You must also pass the symbolic name of the parameter being tested to the
+# block, and optionally can pass a hash of additional options to the block.
+#
+# The known options are:
+#  :array :: boolean, does this support arrays of paths, default true.
+
+shared_examples_for "all pathname parameters with arrays" do |win32|
+  path_types = {
+    "unix absolute"  => "/foo/bar",
+    "unix relative"  => "foo/bar",
+    "win32 absolute" => %q{\foo\bar},
+    "win32 relative" => %q{foo\bar},
+    "drive absolute" => %q{c:\foo\bar},
+    "drive relative" => %q{c:foo\bar}
+  }
+
+  describe "when given an array of paths" do
+    (1..path_types.length).each do |n|
+      path_types.keys.combination(n) do |set|
+        data = path_types.collect { |k, v| set.member?(k) ? v : nil } .compact
+        reject = true
+        only_absolute = set.find { |k| k =~ /relative/ } .nil?
+        only_unix     = set.reject { |k| k =~ /unix/ } .length == 0
+
+        if only_absolute and (only_unix or win32) then
+          reject = false
+        end
+
+        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")}" do
+          if reject then
+            expect { instance(data) }.
+              should raise_error Puppet::Error, /fully qualified/
+          else
+            instance = instance(data)
+            instance[@param].should == data
+          end
+        end
+
+        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")} doubled" do
+          if reject then
+            expect { instance(data + data) }.
+              should raise_error Puppet::Error, /fully qualified/
+          else
+            instance = instance(data + data)
+            instance[@param].should == (data + data)
+          end
+        end
+      end
+    end
+  end
+end
+
+
+shared_examples_for "all path parameters" do |param, options|
+  # Extract and process options to the block.
+  options ||= {}
+  array = options[:array].nil? ? true : options.delete(:array)
+  if options.keys.length > 0 then
+    fail "unknown options for 'all path parameters': " +
+      options.keys.sort.join(', ')
+  end
+
+  def instance(path)
+    fail "we didn't implement the 'instance(path)' method in the it_should_behave_like block"
+  end
+
+  ########################################################################
+  # The actual testing code...
+  before :all do
+    @param = param
+  end
+
+  before :each do
+    @file_separator = File::SEPARATOR
+  end
+  after :each do
+    with_verbose_disabled do
+      verbose, $VERBOSE = $VERBOSE, nil
+      File::SEPARATOR = @file_separator
+      $VERBOSE = verbose
+    end
+  end
+
+  describe "on a Unix-like platform it" do
+    before :each do
+      with_verbose_disabled do
+        File::SEPARATOR = '/'
+      end
+      Puppet.features.stubs(:microsoft_windows?).returns(false)
+      Puppet.features.stubs(:posix?).returns(true)
+    end
+
+    if array then
+      it_should_behave_like "all pathname parameters with arrays", false
+    end
+
+    it "should accept a fully qualified path" do
+      path = File.join('', 'foo')
+      instance = instance(path)
+      instance[@param].should == path
+    end
+
+    it "should give a useful error when the path is not absolute" do
+      path = 'foo'
+      expect { instance(path) }.
+        should raise_error Puppet::Error, /fully qualified/
+    end
+
+    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
+      %w{q Q a A z Z c C}.sort.each do |drive|
+        it "should reject drive letter '#{drive}' with #{style} path separators" do
+          path = "#{drive}:#{slash}Program Files"
+          expect { instance(path) }.
+            should raise_error Puppet::Error, /fully qualified/
+        end
+      end
+    end
+  end
+
+  describe "on a Windows-like platform it" do
+    before :each do
+      with_verbose_disabled do
+        File::SEPARATOR = '\\'
+      end
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      Puppet.features.stubs(:posix?).returns(false)
+    end
+
+    if array then
+      it_should_behave_like "all pathname parameters with arrays", true
+    end
+
+    it "should accept a fully qualified path" do
+      path = File.join('', 'foo')
+      instance = instance(path)
+      instance[@param].should == path
+    end
+
+    it "should give a useful error when the path is not absolute" do
+      path = 'foo'
+      expect { instance(path) }.
+        should raise_error Puppet::Error, /fully qualified/
+    end
+
+    it "also accepts Unix style path separators" do
+      path = '/Program Files'
+      instance = instance(path)
+      instance[@param].should == path
+    end
+
+    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
+      %w{q Q a A z Z c C}.sort.each do |drive|
+        it "should accept drive letter '#{drive}' with #{style} path separators " do
+          path = "#{drive}:#{slash}Program Files"
+          instance = instance(path)
+          instance[@param].should == path
+        end
+      end
+    end
+
+    { "UNC paths"            => %q{\\foo\bar},
+      "unparsed local paths" => %q{\\?\c:\foo},
+      "unparsed UNC paths"   => %q{\\?\foo\bar}
+    }.each do |name, path|
+      it "should accept #{name} as absolute" do
+        instance = instance(path)
+        instance[@param].should == path
+      end
+    end
+  end
+end
diff --git a/spec/unit/parameter/path_spec.rb b/spec/unit/parameter/path_spec.rb
new file mode 100644
index 000000000..08a26de33
--- /dev/null
+++ b/spec/unit/parameter/path_spec.rb
@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+
+require 'puppet/parameter/path'
+
+[false, true].each do |arrays|
+  describe "Puppet::Parameter::Path with arrays #{arrays}" do
+    it_should_behave_like "all path parameters", :path, :array => arrays do
+      # The new type allows us a test that is guaranteed to go direct to our
+      # validation code, without passing through any "real type" overrides or
+      # whatever on the way.
+      Puppet::newtype(:test_puppet_parameter_path) do
+        newparam(:path, :parent => Puppet::Parameter::Path, :arrays => arrays) do
+          isnamevar
+          accept_arrays arrays
+        end
+      end
+
+      def instance(path)
+        Puppet::Type.type(:test_puppet_parameter_path).new(:path => path)
+      end
+    end
+  end
+end
-- 
cgit 


From fa0cfc60ccf43fcf9b4339b63b748b5f177c1e75 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Tue, 15 Mar 2011 11:50:29 -0700
Subject: (#4884) Break the exec type out to have a posix provider

This is in preparation for allowing other new providers to handle exec
commands differently.

Reviewed-by: Max Martin and Matt Robinson
---
 lib/puppet/provider/exec/posix.rb     | 112 ++++++
 lib/puppet/type/exec.rb               | 179 ++-------
 spec/unit/provider/exec/posix_spec.rb | 115 ++++++
 spec/unit/type/exec_spec.rb           | 674 +++++++++++++++++++++++++++++-----
 4 files changed, 841 insertions(+), 239 deletions(-)
 create mode 100644 lib/puppet/provider/exec/posix.rb
 create mode 100755 spec/unit/provider/exec/posix_spec.rb

diff --git a/lib/puppet/provider/exec/posix.rb b/lib/puppet/provider/exec/posix.rb
new file mode 100644
index 000000000..92dbd8c98
--- /dev/null
+++ b/lib/puppet/provider/exec/posix.rb
@@ -0,0 +1,112 @@
+Puppet::Type.type(:exec).provide :posix do
+  include Puppet::Util::Execution
+
+  confine :feature => :posix
+  defaultfor :feature => :posix
+
+  desc "Execute external binaries directly, on POSIX systems.
+This does not pass through a shell, or perform any interpolation, but
+only directly calls the command with the arguments given."
+
+  def run(command, check = false)
+    output = nil
+    status = nil
+    dir = nil
+
+    checkexe(command)
+
+    if dir = resource[:cwd]
+      unless File.directory?(dir)
+        if check
+          dir = nil
+        else
+          self.fail "Working directory '#{dir}' does not exist"
+        end
+      end
+    end
+
+    dir ||= Dir.pwd
+
+    debug "Executing#{check ? " check": ""} '#{command}'"
+    begin
+      # Do our chdir
+      Dir.chdir(dir) do
+        environment = {}
+
+        environment[:PATH] = resource[:path].join(":") if resource[:path]
+
+        if envlist = resource[:environment]
+          envlist = [envlist] unless envlist.is_a? Array
+          envlist.each do |setting|
+            if setting =~ /^(\w+)=((.|\n)+)$/
+              env_name = $1
+              value = $2
+              if environment.include?(env_name) || environment.include?(env_name.to_sym)
+                warning "Overriding environment setting '#{env_name}' with '#{value}'"
+              end
+              environment[env_name] = value
+            else
+              warning "Cannot understand environment setting #{setting.inspect}"
+            end
+          end
+        end
+
+        withenv environment do
+          Timeout::timeout(resource[:timeout]) do
+            output, status = Puppet::Util::SUIDManager.
+              run_and_capture([command], resource[:user], resource[:group])
+          end
+          # The shell returns 127 if the command is missing.
+          if status.exitstatus == 127
+            raise ArgumentError, output
+          end
+        end
+      end
+    rescue Errno::ENOENT => detail
+      self.fail detail.to_s
+    end
+
+    return output, status
+  end
+
+  # Verify that we have the executable
+  def checkexe(command)
+    exe = extractexe(command)
+
+    if resource[:path]
+      if Puppet.features.posix? and !File.exists?(exe)
+        withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+          exe = which(exe) || raise(ArgumentError,"Could not find command '#{exe}'")
+        end
+      elsif Puppet.features.microsoft_windows? and !File.exists?(exe)
+        resource[:path].each do |path|
+          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
+            file = File.join(path, exe+extension)
+            return if File.exists?(file)
+          end
+        end
+      end
+    end
+
+    raise ArgumentError, "Could not find command '#{exe}'" unless File.exists?(exe)
+    unless File.executable?(exe)
+      raise ArgumentError,
+      "'#{exe}' is not executable"
+    end
+  end
+
+  def extractexe(command)
+    # easy case: command was quoted
+    if command =~ /^"([^"]+)"/
+      $1
+    else
+      command.split(/ /)[0]
+    end
+  end
+
+  def validatecmd(command)
+    exe = extractexe(command)
+    # if we're not fully qualified, require a path
+    self.fail "'#{command}' is not qualified and no path was specified. Please qualify the command or specify a path." if File.expand_path(exe) != exe and resource[:path].nil?
+  end
+end
diff --git a/lib/puppet/type/exec.rb b/lib/puppet/type/exec.rb
index 387c592a6..67d40a7cc 100755
--- a/lib/puppet/type/exec.rb
+++ b/lib/puppet/type/exec.rb
@@ -28,10 +28,10 @@ module Puppet
 
     # Create a new check mechanism.  It's basically just a parameter that
     # provides one extra 'check' method.
-    def self.newcheck(name, &block)
+    def self.newcheck(name, options = {}, &block)
       @checks ||= {}
 
-      check = newparam(name, &block)
+      check = newparam(name, options, &block)
       @checks[name] = check
     end
 
@@ -63,9 +63,11 @@ module Puppet
 
       # First verify that all of our checks pass.
       def retrieve
-        # Default to somethinng
-
-        if @resource.check
+        # We need to return :notrun to trigger evaluation; when that isn't
+        # true, we *LIE* about what happened and return a "success" for the
+        # value, which causes us to be treated as in_sync?, which means we
+        # don't actually execute anything.  I think. --daniel 2011-03-10
+        if @resource.check_all_attributes
           return :notrun
         else
           return self.should
@@ -87,7 +89,7 @@ module Puppet
           tries.times do |try|
             # Only add debug messages for tries > 1 to reduce log spam.
             debug("Exec try #{try+1}/#{tries}") if tries > 1
-            @output, @status = @resource.run(self.resource[:command])
+            @output, @status = provider.run(self.resource[:command])
             break if self.should.include?(@status.exitstatus.to_s)
             if try_sleep > 0 and tries > 1
               debug("Sleeping for #{try_sleep} seconds between tries")
@@ -137,7 +139,7 @@ module Puppet
     newparam(:path) do
       desc "The search path used for command execution.
         Commands must be fully qualified if no path is specified.  Paths
-        can be specified as an array or as a colon-separated list."
+        can be specified as an array or as a colon or semi-colon separated list."
 
       # Support both arrays and colon-separated fields.
       def value=(*values)
@@ -174,21 +176,9 @@ module Puppet
       # Validation is handled by the SUIDManager class.
     end
 
-    newparam(:cwd) do
+    newparam(:cwd, :parent => Puppet::Parameter::Path) do
       desc "The directory from which to run the command.  If
         this directory does not exist, the command will fail."
-
-      validate do |dir|
-        unless dir =~ /^#{File::SEPARATOR}/
-          self.fail("CWD must be a fully qualified path")
-        end
-      end
-
-      munge do |dir|
-        dir = dir[0] if dir.is_a?(Array)
-
-        dir
-      end
     end
 
     newparam(:logoutput) do
@@ -207,7 +197,7 @@ module Puppet
         for refreshing."
 
       validate do |command|
-        @resource.validatecmd(command)
+        provider.validatecmd(command)
       end
     end
 
@@ -331,7 +321,7 @@ module Puppet
       end
     end
 
-    newcheck(:creates) do
+    newcheck(:creates, :parent => Puppet::Parameter::Path) do
       desc "A file that this command creates.  If this
         parameter is provided, then the command will only be run
         if the specified file does not exist:
@@ -344,19 +334,7 @@ module Puppet
 
         "
 
-      # FIXME if they try to set this and fail, then we should probably
-      # fail the entire exec, right?
-      validate do |files|
-        files = [files] unless files.is_a? Array
-
-        files.each do |file|
-          self.fail("'creates' must be set to a fully qualified path") unless file
-
-          unless file =~ %r{^#{File::SEPARATOR}}
-            self.fail "'creates' files must be fully qualified."
-          end
-        end
-      end
+      accept_arrays
 
       # If the file exists, return false (i.e., don't run the command),
       # else return true
@@ -384,15 +362,15 @@ module Puppet
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
 
-        cmds.each do |cmd|
-          @resource.validatecmd(cmd)
+        cmds.each do |command|
+          provider.validatecmd(command)
         end
       end
 
       # Return true if the command does not return 0.
       def check(value)
         begin
-          output, status = @resource.run(value, true)
+          output, status = provider.run(value, true)
         rescue Timeout::Error
           err "Check #{value.inspect} exceeded timeout"
           return false
@@ -426,15 +404,15 @@ module Puppet
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
 
-        cmds.each do |cmd|
-          @resource.validatecmd(cmd)
+        cmds.each do |command|
+          provider.validatecmd(command)
         end
       end
 
       # Return true if the command returns 0.
       def check(value)
         begin
-          output, status = @resource.run(value, true)
+          output, status = provider.run(value, true)
         rescue Timeout::Error
           err "Check #{value.inspect} exceeded timeout"
           return false
@@ -448,7 +426,7 @@ module Puppet
     @isomorphic = false
 
     validate do
-      validatecmd(self[:command])
+      provider.validatecmd(self[:command])
     end
 
     # FIXME exec should autorequire any exec that 'creates' our cwd
@@ -501,7 +479,7 @@ module Puppet
     # Verify that we pass all of the checks.  The argument determines whether
     # we skip the :refreshonly check, which is necessary because we now check
     # within refresh
-    def check(refreshing = false)
+    def check_all_attributes(refreshing = false)
       self.class.checks.each { |check|
         next if refreshing and check == :refreshonly
         if @parameters.include?(check)
@@ -516,32 +494,6 @@ module Puppet
       true
     end
 
-    # Verify that we have the executable
-    def checkexe(cmd)
-      exe = extractexe(cmd)
-
-      if self[:path]
-        if Puppet.features.posix? and !File.exists?(exe)
-          withenv :PATH => self[:path].join(File::PATH_SEPARATOR) do
-            exe = which(exe) || raise(ArgumentError,"Could not find command '#{exe}'")
-          end
-        elsif Puppet.features.microsoft_windows? and !File.exists?(exe)
-          self[:path].each do |path|
-            [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
-              file = File.join(path, exe+extension)
-              return if File.exists?(file)
-            end
-          end
-        end
-      end
-
-      raise ArgumentError, "Could not find executable '#{exe}'" unless FileTest.exists?(exe)
-      unless FileTest.executable?(exe)
-        raise ArgumentError,
-          "'#{exe}' is not executable"
-      end
-    end
-
     def output
       if self.property(:returns).nil?
         return nil
@@ -552,98 +504,13 @@ module Puppet
 
     # Run the command, or optionally run a separately-specified command.
     def refresh
-      if self.check(true)
+      if self.check_all_attributes(true)
         if cmd = self[:refresh]
-          self.run(cmd)
+          provider.run(cmd)
         else
           self.property(:returns).sync
         end
       end
     end
-
-    # Run a command.
-    def run(command, check = false)
-      output = nil
-      status = nil
-
-      dir = nil
-
-      checkexe(command)
-
-      if dir = self[:cwd]
-        unless File.directory?(dir)
-          if check
-            dir = nil
-          else
-            self.fail "Working directory '#{dir}' does not exist"
-          end
-        end
-      end
-
-      dir ||= Dir.pwd
-
-      if check
-        debug "Executing check '#{command}'"
-      else
-        debug "Executing '#{command}'"
-      end
-      begin
-        # Do our chdir
-        Dir.chdir(dir) do
-          environment = {}
-
-          environment[:PATH] = self[:path].join(":") if self[:path]
-
-          if envlist = self[:environment]
-            envlist = [envlist] unless envlist.is_a? Array
-            envlist.each do |setting|
-              if setting =~ /^(\w+)=((.|\n)+)$/
-                name = $1
-                value = $2
-                if environment.include? name
-                  warning(
-                  "Overriding environment setting '#{name}' with '#{value}'"
-                  )
-                end
-                environment[name] = value
-              else
-                warning "Cannot understand environment setting #{setting.inspect}"
-              end
-            end
-          end
-
-          withenv environment do
-            Timeout::timeout(self[:timeout]) do
-              output, status = Puppet::Util::SUIDManager.run_and_capture(
-                [command], self[:user], self[:group]
-              )
-            end
-            # The shell returns 127 if the command is missing.
-            if status.exitstatus == 127
-              raise ArgumentError, output
-            end
-          end
-        end
-      rescue Errno::ENOENT => detail
-        self.fail detail.to_s
-      end
-
-      return output, status
-    end
-
-    def validatecmd(cmd)
-      exe = extractexe(cmd)
-      # if we're not fully qualified, require a path
-      self.fail "'#{cmd}' is not qualified and no path was specified. Please qualify the command or specify a path." if File.expand_path(exe) != exe and self[:path].nil?
-    end
-
-    def extractexe(cmd)
-      # easy case: command was quoted
-      if cmd =~ /^"([^"]+)"/
-        $1
-      else
-        cmd.split(/ /)[0]
-      end
-    end
   end
 end
diff --git a/spec/unit/provider/exec/posix_spec.rb b/spec/unit/provider/exec/posix_spec.rb
new file mode 100755
index 000000000..a9b207533
--- /dev/null
+++ b/spec/unit/provider/exec/posix_spec.rb
@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:exec).provider(:posix)
+
+describe provider_class do
+  before :each do
+    @resource = Puppet::Resource.new(:exec, 'foo')
+    @provider = provider_class.new(@resource)
+  end
+
+  ["posix", "microsoft_windows"].each do |feature|
+    describe "when in #{feature} environment" do
+      before :each do
+        if feature == "microsoft_windows"
+          Puppet.features.stubs(:microsoft_windows?).returns(true)
+          Puppet.features.stubs(:posix?).returns(false)
+        else
+          Puppet.features.stubs(:posix?).returns(true)
+          Puppet.features.stubs(:microsoft_windows?).returns(false)
+        end
+      end
+
+      describe "#validatecmd" do
+        it "should fail if no path is specified and the command is not fully qualified" do
+          lambda { @provider.validatecmd("foo") }.should raise_error(
+            Puppet::Error,
+            "'foo' is not qualified and no path was specified. Please qualify the command or specify a path."
+          )
+        end
+
+        it "should pass if a path is given" do
+          @provider.resource[:path] = ['/bogus/bin']
+          @provider.validatecmd("../foo")
+        end
+
+        it "should pass if command is fully qualifed" do
+          @provider.resource[:path] = ['/bogus/bin']
+          @provider.validatecmd("/bin/blah/foo")
+        end
+      end
+
+      describe "#run" do
+        it "should fail if no path is specified and command does not exist" do
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+
+        it "should fail if the command isn't in the path" do
+          @provider.resource[:path] = ['/bogus/bin']
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+
+        it "should fail if the command isn't executable" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).with("foo").returns(true)
+
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "'foo' is not executable")
+        end
+
+        it "should execute the command if the command given includes arguments or subcommands" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          Puppet::Util.expects(:execute).with(['foo bar --sillyarg=true --blah'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+          @provider.run("foo bar --sillyarg=true --blah")
+        end
+
+        it "should fail if quoted command doesn't exist" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          lambda { @provider.run('"foo bar --sillyarg=true --blah"') }.should raise_error(ArgumentError, "Could not find command 'foo bar --sillyarg=true --blah'")
+        end
+
+        it "should execute the command if it finds it in the path and is executable" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+          Puppet::Util.expects(:execute).with(['foo'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+
+          @provider.run("foo")
+        end
+
+        if feature == "microsoft_windows"
+          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
+            it "should check file extension #{extension} when it can't find the executable" do
+              @provider.resource[:path] = ['/bogus/bin']
+              File.stubs(:exists?).returns(false)
+              File.stubs(:exists?).with("/bogus/bin/foo#{extension}").returns(true)
+              File.stubs(:executable?).with("foo").returns(true)
+              Puppet::Util.expects(:execute).with(['foo'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+
+              @provider.run("foo")
+            end
+          end
+        end
+
+        it "should warn if you're overriding something in environment" do
+          @provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          Puppet::Util.expects(:execute).with(['foo'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+          @provider.run("foo")
+          @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
+        end
+      end
+    end
+  end
+end
diff --git a/spec/unit/type/exec_spec.rb b/spec/unit/type/exec_spec.rb
index e04cfc065..4d691d580 100755
--- a/spec/unit/type/exec_spec.rb
+++ b/spec/unit/type/exec_spec.rb
@@ -1,31 +1,32 @@
 #!/usr/bin/env ruby
-
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:exec) do
-
-  def create_resource(command, output, exitstatus, returns = 0)
-    @user_name = 'some_user_name'
+  def exec_tester(command, exitstatus = 0, rest = {})
+    @user_name  = 'some_user_name'
     @group_name = 'some_group_name'
     Puppet.features.stubs(:root?).returns(true)
-    @execer = Puppet::Type.type(:exec).new(:name => command, :path => @example_path, :user => @user_name, :group => @group_name, :returns => returns)
 
-    status = stub "process"
-    status.stubs(:exitstatus).returns(exitstatus)
+    output = rest.delete(:output) || ''
+    tries  = rest[:tries] || 1
 
-    Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], @user_name, @group_name).returns([output, status])
-  end
+    args = {
+      :name      => command,
+      :path      => @example_path,
+      :user      => @user_name,
+      :group     => @group_name,
+      :logoutput => false,
+      :loglevel  => :err,
+      :returns   => 0
+    }.merge(rest)
 
-  def create_logging_resource(command, output, exitstatus, logoutput, loglevel, returns = 0)
-    create_resource(command, output, exitstatus, returns)
-    @execer[:logoutput] = logoutput
-    @execer[:loglevel] = loglevel
-  end
+    exec = Puppet::Type.type(:exec).new(args)
 
-  def expect_output(output, loglevel)
-    output.split(/\n/).each do |line|
-      @execer.property(:returns).expects(loglevel).with(line)
-    end
+    status = stub "process", :exitstatus => exitstatus
+    Puppet::Util::SUIDManager.expects(:run_and_capture).times(tries).
+      with([command], @user_name, @group_name).returns([output, status])
+
+    return exec
   end
 
   before do
@@ -44,119 +45,626 @@ describe Puppet::Type.type(:exec) do
   end
 
   describe "when execing" do
-
     it "should use the 'run_and_capture' method to exec" do
-      command = "true"
-      create_resource(command, "", 0)
-
-      @execer.refresh.should == :executed_command
+      exec_tester("true").refresh.should == :executed_command
     end
 
     it "should report a failure" do
-      command = "false"
-      create_resource(command, "", 1)
-
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+      proc { exec_tester('false', 1).refresh }.
+        should raise_error(Puppet::Error, /^false returned 1 instead of/)
     end
 
     it "should not report a failure if the exit status is specified in a returns array" do
-      command = "false"
-      create_resource(command, "", 1, [0,1])
-      proc { @execer.refresh }.should_not raise_error(Puppet::Error)
+      proc { exec_tester("false", 1, :returns => [0, 1]).refresh }.should_not raise_error
     end
 
     it "should report a failure if the exit status is not specified in a returns array" do
-      command = "false"
-      create_resource(command, "", 1, [0,100])
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+      proc { exec_tester('false', 1, :returns => [0, 100]).refresh }.
+        should raise_error(Puppet::Error, /^false returned 1 instead of/)
     end
 
     it "should log the output on success" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
       output = "output1\noutput2\n"
-      create_logging_resource(command, output, 0, true, :err)
-      expect_output(output, :err)
-      @execer.refresh
+      exec_tester('false', 0, :output => output, :logoutput => true).refresh
+      output.split("\n").each do |line|
+        log = @logs.shift
+        log.level.should == :err
+        log.message.should == line
+      end
     end
 
     it "should log the output on failure" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
       output = "output1\noutput2\n"
-      create_logging_resource(command, output, 1, true, :err)
-      expect_output(output, :err)
+      proc { exec_tester('false', 1, :output => output, :logoutput => true).refresh }.
+        should raise_error(Puppet::Error)
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+      output.split("\n").each do |line|
+        log = @logs.shift
+        log.level.should == :err
+        log.message.should == line
+      end
     end
-
   end
 
   describe "when logoutput=>on_failure is set" do
-
     it "should log the output on failure" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
       output = "output1\noutput2\n"
-      create_logging_resource(command, output, 1, :on_failure, :err)
-      expect_output(output, :err)
+      proc { exec_tester('false', 1, :output => output, :logoutput => :on_failure).refresh }.
+        should raise_error(Puppet::Error, /^false returned 1 instead of/)
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+      output.split("\n").each do |line|
+        log = @logs.shift
+        log.level.should == :err
+        log.message.should == line
+      end
     end
 
     it "should log the output on failure when returns is specified as an array" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
       output = "output1\noutput2\n"
-      create_logging_resource(command, output, 1, :on_failure, :err, [0, 100])
-      expect_output(output, :err)
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+      proc {
+        exec_tester('false', 1, :output => output, :returns => [0, 100],
+             :logoutput => :on_failure).refresh
+      }.should raise_error(Puppet::Error, /^false returned 1 instead of/)
+
+      output.split("\n").each do |line|
+        log = @logs.shift
+        log.level.should == :err
+        log.message.should == line
+      end
     end
 
     it "shouldn't log the output on success" do
-      #Puppet::Util::Log.newdestination :console
-      command = "true"
-      output = "output1\noutput2\n"
-      create_logging_resource(command, output, 0, :on_failure, :err)
-      @execer.property(:returns).expects(:err).never
-      @execer.refresh
+      exec_tester('true', 0, :output => "a\nb\nc\n", :logoutput => :on_failure).refresh
+      @logs.should == []
     end
   end
 
   it "shouldn't log the output on success when non-zero exit status is in a returns array" do
-    #Puppet::Util::Log.newdestination :console
-    command = "true"
-    output = "output1\noutput2\n"
-    create_logging_resource(command, output, 100, :on_failure, :err, [1,100])
-    @execer.property(:returns).expects(:err).never
-    @execer.refresh
+    exec_tester("true", 100, :output => "a\n", :logoutput => :on_failure, :returns => [1, 100]).refresh
+    @logs.should == []
   end
 
   describe " when multiple tries are set," do
-
     it "should repeat the command attempt 'tries' times on failure and produce an error" do
-      Puppet.features.stubs(:root?).returns(true)
-      command = "false"
-      user = "user"
-      group = "group"
       tries = 5
-      retry_exec = Puppet::Type.type(:exec).new(:name => command, :path => %w{/usr/bin /bin}, :user => user, :group => group, :returns => 0, :tries => tries, :try_sleep => 0)
-      status = stub "process"
-      status.stubs(:exitstatus).returns(1)
-      Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], user, group).times(tries).returns(["", status])
-      proc { retry_exec.refresh }.should raise_error(Puppet::Error)
+      resource = exec_tester("false", 1, :tries => tries, :try_sleep => 0)
+      proc { resource.refresh }.should raise_error(Puppet::Error)
     end
   end
 
   it "should be able to autorequire files mentioned in the command" do
     catalog = Puppet::Resource::Catalog.new
-    catalog.add_resource Puppet::Type.type(:file).new(:name => @executable)
-    @execer = Puppet::Type.type(:exec).new(:name => @command)
-    catalog.add_resource @execer
+    tmp = Puppet::Type.type(:file).new(:name => "/bin/foo")
+    catalog.add_resource tmp
+    execer = Puppet::Type.type(:exec).new(:name => "/bin/foo")
+    catalog.add_resource execer
+
+    catalog.relationship_graph.dependencies(execer).should == [tmp]
+  end
+
+  describe "when handling the path parameter" do
+    expect = %w{one two three four}
+    { "an array"                        => expect,
+      "a colon separated list"          => "one:two:three:four",
+      "a semi-colon separated list"     => "one;two;three;four",
+      "both array and colon lists"      => ["one", "two:three", "four"],
+      "both array and semi-colon lists" => ["one", "two;three", "four"],
+      "colon and semi-colon lists"      => ["one:two", "three;four"]
+    }.each do |test, input|
+      it "should accept #{test}" do
+        type = Puppet::Type.type(:exec).new(:name => @command, :path => input)
+        type[:path].should == expect
+      end
+    end
+  end
+
+  describe "when setting user" do
+    it "should fail if we are not root" do
+      Puppet.features.stubs(:root?).returns(false)
+      expect { Puppet::Type.type(:exec).new(:name => @command, :user => 'input') }.
+        should raise_error Puppet::Error, /Parameter user failed/
+    end
+
+    ['one', 2, 'root', 4294967295, 4294967296].each do |value|
+      it "should accept '#{value}' as user if we are root" do
+        Puppet.features.stubs(:root?).returns(true)
+        type = Puppet::Type.type(:exec).new(:name => @command, :user => value)
+        type[:user].should == value
+      end
+    end
+  end
+
+  describe "when setting group" do
+    shared_examples_for "exec[:group]" do
+      ['one', 2, 'wheel', 4294967295, 4294967296].each do |value|
+        it "should accept '#{value}' without error or judgement" do
+          type = Puppet::Type.type(:exec).new(:name => @command, :group => value)
+          type[:group].should == value
+        end
+      end
+    end
+
+    describe "when running as root" do
+      before :each do Puppet.features.stubs(:root?).returns(true) end
+      it_behaves_like "exec[:group]"
+    end
+
+    describe "when not running as root" do
+      before :each do Puppet.features.stubs(:root?).returns(false) end
+      it_behaves_like "exec[:group]"
+    end
+  end
+
+  describe "when setting cwd" do
+    it_should_behave_like "all path parameters", :cwd, :array => false do
+      def instance(path)
+        Puppet::Type.type(:exec).new(:name => '/bin/true', :cwd => path)
+      end
+    end
+  end
+
+  shared_examples_for "all exec command parameters" do |param|
+    { "relative" => "example", "absolute" => "/bin/example" }.sort.each do |name, command|
+      describe "if command is #{name}" do
+        before :each do
+          @param = param
+        end
+
+        def test(command, valid)
+          if @param == :name then
+            instance = Puppet::Type.type(:exec).new()
+          else
+            instance = Puppet::Type.type(:exec).new(:name => "/bin/true")
+          end
+          if valid then
+            instance.provider.expects(:validatecmd).returns(true)
+          else
+            instance.provider.expects(:validatecmd).raises(Puppet::Error, "from a stub")
+          end
+          instance[@param] = command
+        end
+
+        it "should work if the provider calls the command valid" do
+          expect { test(command, true) }.should_not raise_error
+        end
+
+        it "should fail if the provider calls the command invalid" do
+          expect { test(command, false) }.
+            should raise_error Puppet::Error, /Parameter #{@param} failed: from a stub/
+        end
+      end
+    end
+  end
+
+  shared_examples_for "all exec command parameters that take arrays" do |param|
+    describe "when given an array of inputs" do
+      before :each do
+        @test = Puppet::Type.type(:exec).new(:name => "/bin/true")
+      end
+
+      it "should accept the array when all commands return valid" do
+        input = %w{one two three}
+        @test.provider.expects(:validatecmd).times(input.length).returns(true)
+        @test[param] = input
+        @test[param].should == input
+      end
+
+      it "should reject the array when any commands return invalid" do
+        input = %w{one two three}
+        @test.provider.expects(:validatecmd).with(input.first).returns(false)
+        input[1..-1].each do |cmd|
+          @test.provider.expects(:validatecmd).with(cmd).returns(true)
+        end
+        @test[param] = input
+        @test[param].should == input
+      end
+
+      it "should reject the array when all commands return invalid" do
+        input = %w{one two three}
+        @test.provider.expects(:validatecmd).times(input.length).returns(false)
+        @test[param] = input
+        @test[param].should == input
+      end
+    end
+  end
+
+  describe "when setting refresh" do
+    it_should_behave_like "all exec command parameters", :refresh
+  end
+
+  describe "for simple parameters" do
+    before :each do
+      @exec = Puppet::Type.type(:exec).new(:name => '/bin/true')
+    end
+
+    describe "when setting env" do
+      it "should issue a deprecation warning" do
+        expect { @exec[:env] = 'foo=bar' }.should_not raise_error
+        @logs.first.message.should =~ /deprecate.*environment/
+      end
+
+      it "should update the value of env" do
+        data = ['foo=bar']
+        @exec[:env] = data
+        @exec[:env].should == data
+      end
+
+      it "should forward to environment" do
+        data = ['foo=bar']
+        @exec[:env] = data
+        @exec[:environment].should == data
+      end
+
+      it "should not override environment if both are set" do
+        pending "can't fix: too disruptive for 2.6, removed in 2.7"
+        # ...so this test is here to validate that we know about the problem.
+        # This ensures correct order of evaluation to trigger the bug; don't
+        # count on this happening in the constructor. --daniel 2011-03-01
+        @exec[:environment] = 'environment=true'
+        @exec[:env]         = 'env=true'
+
+        @exec[:environment].should == "environment=true"
+      end
+    end
+
+    describe "when setting environment" do
+      { "single values"   => "foo=bar",
+        "multiple values" => ["foo=bar", "baz=quux"],
+      }.each do |name, data|
+        it "should accept #{name}" do
+          @exec[:environment] = data
+          @exec[:environment].should == data
+        end
+      end
+
+      { "single values" => "foo",
+        "only values"   => ["foo", "bar"],
+        "any values"    => ["foo=bar", "baz"]
+      }.each do |name, data|
+        it "should reject #{name} without assignment" do
+          expect { @exec[:environment] = data }.
+            should raise_error Puppet::Error, /Invalid environment setting/
+        end
+      end
+    end
+
+    describe "when setting timeout" do
+      [-3.5, -1, 0, 0.1, 1, 10, 4294967295].each do |valid|
+        it "should accept '#{valid}' as valid" do
+          @exec[:timeout] = valid
+          @exec[:timeout].should == valid
+        end
+
+        it "should accept '#{valid}' in an array as valid" do
+          @exec[:timeout] = [valid]
+          @exec[:timeout].should == valid
+        end
+      end
+
+      ['1/2', '1_000_000', '+12', '', 'foo'].each do |invalid|
+        it "should reject '#{invalid}' as invalid" do
+          expect { @exec[:timeout] = invalid }.
+            should raise_error Puppet::Error, /The timeout must be a number/
+        end
+
+        it "should reject '#{invalid}' in an array as invalid" do
+          expect { @exec[:timeout] = [invalid] }.
+            should raise_error Puppet::Error, /The timeout must be a number/
+        end
+      end
+
+      it "should fail if timeout is exceeded" do
+        File.stubs(:exists?).with('/bin/sleep').returns(true)
+        sleep_exec = Puppet::Type.type(:exec).new(:name => 'sleep 1', :path => ['/bin'], :timeout => '0.2')
+        lambda { sleep_exec.refresh }.should raise_error Puppet::Error, "Command exceeded timeout"
+      end
+    end
+
+    describe "when setting tries" do
+      [1, 10, 4294967295].each do |valid|
+        it "should accept '#{valid}' as valid" do
+          @exec[:tries] = valid
+          @exec[:tries].should == valid
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should accept '#{valid}' in an array as valid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            @exec[:tries] = [valid]
+            @exec[:tries].should == valid
+          end
+        end
+      end
+
+      [-3.5, -1, 0, 0.2, '1/2', '1_000_000', '+12', '', 'foo'].each do |invalid|
+        it "should reject '#{invalid}' as invalid" do
+          expect { @exec[:tries] = invalid }.
+            should raise_error Puppet::Error, /Tries must be an integer/
+        end
 
-    rels = @execer.autorequire
-    rels[0].should be_instance_of(Puppet::Relationship)
-    rels[0].target.should equal(@execer)
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should reject '#{invalid}' in an array as invalid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            expect { @exec[:tries] = [invalid] }.
+              should raise_error Puppet::Error, /Tries must be an integer/
+          end
+        end
+      end
+    end
+
+    describe "when setting try_sleep" do
+      [0, 0.2, 1, 10, 4294967295].each do |valid|
+        it "should accept '#{valid}' as valid" do
+          @exec[:try_sleep] = valid
+          @exec[:try_sleep].should == valid
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should accept '#{valid}' in an array as valid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            @exec[:try_sleep] = [valid]
+            @exec[:try_sleep].should == valid
+          end
+        end
+      end
+
+      { -3.5        => "cannot be a negative number",
+        -1          => "cannot be a negative number",
+        '1/2'       => 'must be a number',
+        '1_000_000' => 'must be a number',
+        '+12'       => 'must be a number',
+        ''          => 'must be a number',
+        'foo'       => 'must be a number',
+      }.each do |invalid, error|
+        it "should reject '#{invalid}' as invalid" do
+          expect { @exec[:try_sleep] = invalid }.
+            should raise_error Puppet::Error, /try_sleep #{error}/
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should reject '#{invalid}' in an array as invalid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            expect { @exec[:try_sleep] = [invalid] }.
+              should raise_error Puppet::Error, /try_sleep #{error}/
+          end
+        end
+      end
+    end
+
+    describe "when setting refreshonly" do
+      [:true, :false].each do |value|
+        it "should accept '#{value}'" do
+          @exec[:refreshonly] = value
+          @exec[:refreshonly].should == value
+        end
+      end
+
+      [1, 0, "1", "0", "yes", "y", "no", "n"].each do |value|
+        it "should reject '#{value}'" do
+          expect { @exec[:refreshonly] = value }.
+            should raise_error(Puppet::Error,
+              /Invalid value #{value.inspect}\. Valid values are true, false/
+            )
+        end
+      end
+    end
+
+    describe "when setting creates" do
+      it_should_behave_like "all path parameters", :creates, :array => true do
+        def instance(path)
+          Puppet::Type.type(:exec).new(:name => '/bin/true', :creates => path)
+        end
+      end
+    end
+  end
+
+  describe "when setting unless" do
+    it_should_behave_like "all exec command parameters", :unless
+    it_should_behave_like "all exec command parameters that take arrays", :unless
+  end
+
+  describe "when setting onlyif" do
+    it_should_behave_like "all exec command parameters", :onlyif
+    it_should_behave_like "all exec command parameters that take arrays", :onlyif
+  end
+
+  describe "#check" do
+    before :each do
+      @test = Puppet::Type.type(:exec).new(:name => "/bin/true")
+    end
+
+    describe ":refreshonly" do
+      { :true => false, :false => true }.each do |input, result|
+        it "should return '#{result}' when given '#{input}'" do
+          @test[:refreshonly] = input
+          @test.check_all_attributes.should == result
+        end
+      end
+    end
+
+    describe ":creates" do
+      before :all do
+        @exist   = "/"
+        @unexist = "/this/path/should/never/exist"
+        while FileTest.exist?(@unexist) do @unexist += "/foo" end
+      end
+
+      context "with a single item" do
+        it "should run when the item does not exist" do
+          @test[:creates] = @unexist
+          @test.check_all_attributes.should == true
+        end
+
+        it "should not run when the item exists" do
+          @test[:creates] = @exist
+          @test.check_all_attributes.should == false
+        end
+      end
+
+      context "with an array with one item" do
+        it "should run when the item does not exist" do
+          @test[:creates] = [@unexist]
+          @test.check_all_attributes.should == true
+        end
+
+        it "should not run when the item exists" do
+          @test[:creates] = [@exist]
+          @test.check_all_attributes.should == false
+        end
+      end
+
+      context "with an array with multiple items" do
+        it "should run when all items do not exist" do
+          @test[:creates] = [@unexist] * 3
+          @test.check_all_attributes.should == true
+        end
+
+        it "should not run when one item exists" do
+          @test[:creates] = [@unexist, @exist, @unexist]
+          @test.check_all_attributes.should == false
+        end
+
+        it "should not run when all items exist" do
+          @test[:creates] = [@exist] * 3
+        end
+      end
+    end
+
+    { :onlyif => { :pass => false, :fail => true  },
+      :unless => { :pass => true,  :fail => false },
+    }.each do |param, sense|
+      describe ":#{param}" do
+        before :each do
+          @pass = "/magic/pass"
+          @fail = "/magic/fail"
+
+          @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
+          @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
+
+          @test.provider.stubs(:checkexe).returns(true)
+          [true, false].each do |check|
+            @test.provider.stubs(:run).with(@pass, check).
+              returns(['test output', @pass_status])
+            @test.provider.stubs(:run).with(@fail, check).
+              returns(['test output', @fail_status])
+          end
+        end
+
+        context "with a single item" do
+          it "should run if the command exits non-zero" do
+            @test[param] = @fail
+            @test.check_all_attributes.should == true
+          end
+
+          it "should not run if the command exits zero" do
+            @test[param] = @pass
+            @test.check_all_attributes.should == false
+          end
+        end
+
+        context "with an array with a single item" do
+          it "should run if the command exits non-zero" do
+            @test[param] = [@fail]
+            @test.check_all_attributes.should == true
+          end
+
+          it "should not run if the command exits zero" do
+            @test[param] = [@pass]
+            @test.check_all_attributes.should == false
+          end
+        end
+
+        context "with an array with multiple items" do
+          it "should run if all the commands exits non-zero" do
+            @test[param] = [@fail] * 3
+            @test.check_all_attributes.should == true
+          end
+
+          it "should not run if one command exits zero" do
+            @test[param] = [@pass, @fail, @pass]
+            @test.check_all_attributes.should == false
+          end
+
+          it "should not run if all command exits zero" do
+            @test[param] = [@pass] * 3
+            @test.check_all_attributes.should == false
+          end
+        end
+      end
+    end
+  end
+
+  describe "#retrieve" do
+    before :each do
+      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+    end
+
+    it "should return :notrun when check_all_attributes returns true" do
+      @exec_resource.stubs(:check_all_attributes).returns true
+      @exec_resource.retrieve[:returns].should == :notrun
+    end
+
+    it "should return default exit code 0 when check_all_attributes returns false" do
+      @exec_resource.stubs(:check_all_attributes).returns false
+      @exec_resource.retrieve[:returns].should == ['0']
+    end
+
+    it "should return the specified exit code when check_all_attributes returns false" do
+      @exec_resource.stubs(:check_all_attributes).returns false
+      @exec_resource[:returns] = 42
+      @exec_resource.retrieve[:returns].should == ["42"]
+    end
+  end
+
+  describe "#output" do
+    before :each do
+      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+    end
+
+    it "should return the provider's run output" do
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
+
+      @exec_resource.refresh
+      @exec_resource.output.should == 'silly output'
+    end
+  end
+
+  describe "#refresh" do
+    before :each do
+      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+    end
+
+    it "should call provider run with the refresh parameter if it is set" do
+      provider = stub 'provider'
+      @exec_resource.stubs(:provider).returns(provider)
+      @exec_resource.stubs(:[]).with(:refresh).returns('/myother/bogus/cmd')
+      provider.expects(:run).with('/myother/bogus/cmd')
+
+      @exec_resource.refresh
+    end
+
+    it "should call provider run with the specified command if the refresh parameter is not set" do
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).with('/bogus/cmd').returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
+
+      @exec_resource.refresh
+    end
+
+    it "should not run the provider if check_all_attributes is false" do
+      @exec_resource.stubs(:check_all_attributes).returns false
+      provider = stub 'provider'
+      provider.expects(:run).never
+      @exec_resource.stubs(:provider).returns(provider)
+
+      @exec_resource.refresh
+    end
   end
 end
-- 
cgit 


From d2e911a1f9dae2cda025bc0f2cbc973cdcff309b Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Mar 2011 11:39:18 -0700
Subject: (#4884) Fix Test::Unit exec tests

Mostly this is whitespace cleanup, but other than that it's changing a
couple method names and calling run on the new exec providers instead of
the types.

We started moving these tests into spec, but they weren't very self
contained so were hard to map over cleanly.  For now leaving them since
they serve as a more integration level set of tests.

Paired-with: Max Martin
---
 test/ral/type/exec.rb | 263 +++++++++++++++++---------------------------------
 1 file changed, 87 insertions(+), 176 deletions(-)

diff --git a/test/ral/type/exec.rb b/test/ral/type/exec.rb
index 5b26a98a2..dd42ae61f 100755
--- a/test/ral/type/exec.rb
+++ b/test/ral/type/exec.rb
@@ -34,10 +34,8 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "echo",
-
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin"
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin"
       )
     }
     assert_nothing_raised {
@@ -48,10 +46,8 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "/bin/echo",
-
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin"
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin"
       )
     }
   end
@@ -60,30 +56,24 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "mkdir /this/directory/does/not/exist",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 1
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "touch /etc",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 1
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "thiscommanddoesnotexist",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 127
       )
     }
@@ -98,11 +88,9 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "pwd",
-        :cwd => dir,
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :cwd     => dir,
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 0
       )
     }
@@ -117,11 +105,9 @@ class TestExec < Test::Unit::TestCase
     @@tmpfiles.push tmpfile
     trans = nil
 
-      file = Puppet::Type.type(:file).new(
-
-        :path => tmpfile,
-
-        :content => "yay"
+    file = Puppet::Type.type(:file).new(
+      :path    => tmpfile,
+      :content => "yay"
     )
     # Get the file in sync
     assert_apply(file)
@@ -129,13 +115,10 @@ class TestExec < Test::Unit::TestCase
     # Now make an exec
     maker = tempfile
     assert_nothing_raised {
-
       cmd = Puppet::Type.type(:exec).new(
-
-        :command => "touch #{maker}",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-        :subscribe => file,
-
+        :command     => "touch #{maker}",
+        :path        => "/usr/bin:/bin:/usr/sbin:/sbin",
+        :subscribe   => file,
         :refreshonly => true
       )
     }
@@ -143,7 +126,7 @@ class TestExec < Test::Unit::TestCase
     assert(cmd, "did not make exec")
 
     assert_nothing_raised do
-      assert(! cmd.check, "Check passed when refreshonly is set")
+      assert(! cmd.check_all_attributes, "Check passed when refreshonly is set")
     end
 
     assert_events([], file, cmd)
@@ -158,25 +141,22 @@ class TestExec < Test::Unit::TestCase
   def test_refreshonly
     cmd = true
     assert_nothing_raised {
-
       cmd = Puppet::Type.type(:exec).new(
-
-        :command => "pwd",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :command     => "pwd",
+        :path        => "/usr/bin:/bin:/usr/sbin:/sbin",
         :refreshonly => true
       )
     }
 
     # Checks should always fail when refreshonly is enabled
-    assert(!cmd.check, "Check passed with refreshonly true")
+    assert(!cmd.check_all_attributes, "Check passed with refreshonly true")
 
     # Now make sure it passes if we pass in "true"
-    assert(cmd.check(true), "Check failed with refreshonly true while refreshing")
+    assert(cmd.check_all_attributes(true), "Check failed with refreshonly true while refreshing")
 
     # Now set it to false
     cmd[:refreshonly] = false
-    assert(cmd.check, "Check failed with refreshonly false")
+    assert(cmd.check_all_attributes, "Check failed with refreshonly false")
   end
 
   def test_creates
@@ -186,10 +166,8 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "touch #{file}",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :creates => file
       )
     }
@@ -206,21 +184,15 @@ class TestExec < Test::Unit::TestCase
     sh = %x{which sh}
     File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
-
-      file = Puppet::Type.type(:file).new(
-
-        :path => oexe,
-        :source => exe,
-
-        :mode => 0755
+    file = Puppet::Type.type(:file).new(
+      :path => oexe,
+      :source => exe,
+      :mode => 0755
     )
 
-
-      exec = Puppet::Type.type(:exec).new(
-
-        :command => oexe,
-
-        :require => Puppet::Resource.new(:file, oexe)
+    exec = Puppet::Type.type(:exec).new(
+      :command => oexe,
+      :require => Puppet::Resource.new(:file, oexe)
     )
 
     comp = mk_catalog("Testing", file, exec)
@@ -236,47 +208,36 @@ class TestExec < Test::Unit::TestCase
     File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
 
-      file = Puppet::Type.type(:file).new(
-
-        :path => oexe,
-        :source => exe,
-
-        :mode => 755
+    file = Puppet::Type.type(:file).new(
+      :path => oexe,
+      :source => exe,
+      :mode => 755
     )
 
     basedir = File.dirname(oexe)
 
-      baseobj = Puppet::Type.type(:file).new(
-
-        :path => basedir,
-        :source => exe,
-
-        :mode => 755
+    baseobj = Puppet::Type.type(:file).new(
+      :path   => basedir,
+      :source => exe,
+      :mode   => 755
     )
 
 
-      ofile = Puppet::Type.type(:file).new(
-
-        :path => exe,
-
-        :mode => 755
+    ofile = Puppet::Type.type(:file).new(
+      :path => exe,
+      :mode => 755
     )
 
 
-      exec = Puppet::Type.type(:exec).new(
-
-        :command => oexe,
-        :path => ENV["PATH"],
-
-        :cwd => basedir
+    exec = Puppet::Type.type(:exec).new(
+      :command => oexe,
+      :path => ENV["PATH"],
+      :cwd => basedir
     )
 
-
-      cat = Puppet::Type.type(:exec).new(
-
-        :command => "cat #{exe} #{oexe}",
-
-        :path => ENV["PATH"]
+    cat = Puppet::Type.type(:exec).new(
+      :command => "cat #{exe} #{oexe}",
+      :path => ENV["PATH"]
     )
 
     catalog = mk_catalog(file, baseobj, ofile, exec, cat)
@@ -311,11 +272,9 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "touch #{bfile}",
-        :onlyif => "test -f #{afile}",
-
-        :path => ENV['PATH']
+        :onlyif  => "test -f #{afile}",
+        :path    => ENV['PATH']
       )
     }
 
@@ -333,12 +292,9 @@ class TestExec < Test::Unit::TestCase
 
     exec = nil
     assert_nothing_raised {
-
       exec = Puppet::Type.type(:exec).new(
-
         :command => "touch #{bfile}",
         :unless => "test -f #{afile}",
-
         :path => ENV['PATH']
       )
     }
@@ -417,13 +373,10 @@ class TestExec < Test::Unit::TestCase
   def test_logoutput
     exec = nil
     assert_nothing_raised {
-
       exec = Puppet::Type.type(:exec).new(
-
-        :title => "logoutputesting",
-        :path => "/usr/bin:/bin",
-        :command => "echo logoutput is false",
-
+        :title     => "logoutputesting",
+        :path      => "/usr/bin:/bin",
+        :command   => "echo logoutput is false",
         :logoutput => false
       )
     }
@@ -453,24 +406,19 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
-
-        :title => "mkdir",
-        :path => "/usr/bin:/bin",
+        :title   => "mkdir",
+        :path    => "/usr/bin:/bin",
         :creates => basedir,
-
         :command => "mkdir #{basedir}; touch #{path}"
-
       )
     }
 
     assert_nothing_raised {
 
       file = Puppet::Type.type(:file).new(
-
-        :path => basedir,
+        :path    => basedir,
         :recurse => true,
-        :mode => "755",
-
+        :mode    => "755",
         :require => Puppet::Resource.new("exec", "mkdir")
       )
     }
@@ -507,12 +455,9 @@ class TestExec < Test::Unit::TestCase
     file = tempfile
 
     assert_nothing_raised {
-
       exec1 = Puppet::Type.type(:exec).new(
-
-        :title => "one",
-        :path => ENV["PATH"],
-
+        :title   => "one",
+        :path    => ENV["PATH"],
         :command => "mkdir #{dir}"
       )
     }
@@ -520,12 +465,10 @@ class TestExec < Test::Unit::TestCase
     assert_nothing_raised("Could not create exec w/out existing cwd") {
 
       exec2 = Puppet::Type.type(:exec).new(
-
-        :title => "two",
-        :path => ENV["PATH"],
+        :title   => "two",
+        :path    => ENV["PATH"],
         :command => "touch #{file}",
-
-        :cwd => dir
+        :cwd     => dir
       )
     }
 
@@ -555,11 +498,8 @@ class TestExec < Test::Unit::TestCase
     test = "test -f #{file}"
 
     assert_nothing_raised {
-
       exec = Puppet::Type.type(:exec).new(
-
-        :path => ENV["PATH"],
-
+        :path    => ENV["PATH"],
         :command => "touch #{file}"
       )
     }
@@ -569,7 +509,7 @@ class TestExec < Test::Unit::TestCase
     }
 
     assert_nothing_raised {
-      assert(exec.check, "Check did not pass")
+      assert(exec.check_all_attributes, "Check did not pass")
     }
 
     assert_nothing_raised {
@@ -582,13 +522,13 @@ class TestExec < Test::Unit::TestCase
     }
 
     assert_nothing_raised {
-      assert(exec.check, "Check did not pass")
+      assert(exec.check_all_attributes, "Check did not pass")
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
-      assert(! exec.check, "Check passed")
+      assert(! exec.check_all_attributes, "Check passed")
     }
   end
 
@@ -597,33 +537,29 @@ class TestExec < Test::Unit::TestCase
     return if Facter.value(:operatingsystem) == "Solaris"
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "echo true",
-        :path => ENV["PATH"],
-
-        :onlyif => "/bin/nosuchthingexists"
-          )
+        :path    => ENV["PATH"],
+        :onlyif  => "/bin/nosuchthingexists"
+      )
 
     assert_raise(ArgumentError, "Missing command did not raise error") {
-      exec.run("/bin/nosuchthingexists")
+      exec.provider.run("/bin/nosuchthingexists")
     }
   end
 
   def test_envparam
 
     exec = Puppet::Type.newexec(
-
       :command => "echo $envtest",
-      :path => ENV["PATH"],
-
-      :env => "envtest=yayness"
+      :path    => ENV["PATH"],
+      :env     => "envtest=yayness"
     )
 
     assert(exec, "Could not make exec")
 
     output = status = nil
     assert_nothing_raised {
-      output, status = exec.run("echo $envtest")
+      output, status = exec.provider.run("echo $envtest")
     }
 
     assert_equal("yayness\n", output)
@@ -636,7 +572,7 @@ and stuff"
 
   output = status = nil
   assert_nothing_raised {
-    output, status = exec.run('echo "$envtest"')
+    output, status = exec.provider.run('echo "$envtest"')
     }
     assert_equal("a list of things\nand stuff\n", output)
 
@@ -647,7 +583,7 @@ and stuff"
 
     output = status = nil
     assert_nothing_raised {
-      output, status = exec.run('echo "$funtest" "$yaytest"')
+      output, status = exec.provider.run('echo "$funtest" "$yaytest"')
     }
     assert_equal("A B\n", output)
   end
@@ -655,10 +591,8 @@ and stuff"
   def test_environmentparam
 
     exec = Puppet::Type.newexec(
-
-      :command => "echo $environmenttest",
-      :path => ENV["PATH"],
-
+      :command     => "echo $environmenttest",
+      :path        => ENV["PATH"],
       :environment => "environmenttest=yayness"
     )
 
@@ -666,7 +600,7 @@ and stuff"
 
     output = status = nil
     assert_nothing_raised {
-      output, status = exec.run("echo $environmenttest")
+      output, status = exec.provider.run("echo $environmenttest")
     }
 
     assert_equal("yayness\n", output)
@@ -679,7 +613,7 @@ and stuff"
 
   output = status = nil
   assert_nothing_raised {
-    output, status = exec.run('echo "$environmenttest"')
+    output, status = exec.provider.run('echo "$environmenttest"')
     }
     assert_equal("a list of things\nand stuff\n", output)
 
@@ -690,36 +624,20 @@ and stuff"
 
     output = status = nil
     assert_nothing_raised {
-      output, status = exec.run('echo "$funtest" "$yaytest"')
+      output, status = exec.provider.run('echo "$funtest" "$yaytest"')
     }
     assert_equal("A B\n", output)
   end
 
-  def test_timeout
-    exec = Puppet::Type.type(:exec).new(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
-    time = Time.now
-
-    assert_raise(Timeout::Error) {
-      exec.run("sleep 1")
-    }
-    Puppet.info "#{Time.now.to_f - time.to_f} seconds, vs a timeout of #{exec[:timeout]}"
-
-
-    assert_apply(exec)
-  end
-
   # Testing #470
   def test_run_as_created_user
     exec = nil
     if Process.uid == 0
       user = "nosuchuser"
       assert_nothing_raised("Could not create exec with non-existent user") do
-
         exec = Puppet::Type.type(:exec).new(
-
           :command => "/bin/echo yay",
-
-          :user => user
+          :user    => user
         )
       end
     end
@@ -729,10 +647,8 @@ and stuff"
     assert_nothing_raised("Could not create exec with non-existent user") do
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "/bin/echo yay",
-
-        :group => group
+        :group   => group
       )
     end
   end
@@ -759,12 +675,10 @@ and stuff"
     file = tempfile
     maker = tempfile
 
-      exec = Puppet::Type.type(:exec).new(
-
-        :title => "maker",
-        :command => "touch #{maker}",
-
-        :path => ENV["PATH"]
+    exec = Puppet::Type.type(:exec).new(
+      :title   => "maker",
+      :command => "touch #{maker}",
+      :path    => ENV["PATH"]
     )
 
     # Make sure it runs normally
@@ -801,12 +715,10 @@ and stuff"
     refresher = tempfile
     maker = tempfile
 
-      exec = Puppet::Type.type(:exec).new(
-
-        :title => "maker",
-        :command => "touch #{maker}",
-
-        :path => ENV["PATH"]
+    exec = Puppet::Type.type(:exec).new(
+      :title => "maker",
+      :command => "touch #{maker}",
+      :path => ENV["PATH"]
     )
 
     # Call refresh normally
@@ -844,4 +756,3 @@ and stuff"
     end
   end
 end
-
-- 
cgit 


From 0d2d6f3f005ee99658ff86b79749f0ba7949beab Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Mar 2011 11:52:10 -0700
Subject: (#4884) Add an shell provider for execs

This makes it possible to use shell builtins when the exec is inline
bash commands.

Paired-with: Max Martin
---
 lib/puppet/provider/exec/shell.rb     | 17 ++++++++++++++
 spec/unit/provider/exec/shell_spec.rb | 44 +++++++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)
 create mode 100644 lib/puppet/provider/exec/shell.rb
 create mode 100644 spec/unit/provider/exec/shell_spec.rb

diff --git a/lib/puppet/provider/exec/shell.rb b/lib/puppet/provider/exec/shell.rb
new file mode 100644
index 000000000..98f309e8f
--- /dev/null
+++ b/lib/puppet/provider/exec/shell.rb
@@ -0,0 +1,17 @@
+Puppet::Type.type(:exec).provide :shell, :parent => :posix do
+  include Puppet::Util::Execution
+
+  confine :feature => :posix
+
+  desc "Execute external binaries directly, on POSIX systems.
+passing through a shell so that shell built ins are available."
+
+  def run(command, check = false)
+    command = %Q{/bin/sh -c "#{command.gsub(/"/,'\"')}"}
+    super(command, check)
+  end
+
+  def validatecmd(command)
+    true
+  end
+end
diff --git a/spec/unit/provider/exec/shell_spec.rb b/spec/unit/provider/exec/shell_spec.rb
new file mode 100644
index 000000000..44390ff08
--- /dev/null
+++ b/spec/unit/provider/exec/shell_spec.rb
@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:exec).provider(:shell)
+
+describe provider_class do
+  before :each do
+    @resource = Puppet::Resource.new(:exec, 'foo')
+    @provider = provider_class.new(@resource)
+  end
+
+  describe "#run" do
+    it "should be able to run builtin shell commands" do
+      output, status = @provider.run("echo foo")
+      status.exitstatus.should == 0
+      output.should == "foo\n"
+    end
+
+    it "should be able to run commands with single quotes in them" do
+      output, status = @provider.run("echo 'foo bar'")
+      status.exitstatus.should == 0
+      output.should == "foo bar\n"
+    end
+
+    it "should be able to run commands with double quotes in them" do
+      output, status = @provider.run("echo 'foo bar'")
+      status.exitstatus.should == 0
+      output.should == "foo bar\n"
+    end
+
+    it "should be able to read values from the environment parameter" do
+      @resource[:environment] = "FOO=bar"
+      output, status = @provider.run("echo $FOO")
+      status.exitstatus.should == 0
+      output.should == "bar\n"
+    end
+  end
+
+  describe "#validatecmd" do
+    it "should always return true because builtins don't need path or to be fully qualified" do
+      @provider.validatecmd('whateverdoesntmatter').should == true
+    end
+  end
+end
-- 
cgit 


From ec1aa192825f17afbe4dc12be1e0f2d644d74155 Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Thu, 17 Mar 2011 12:14:49 -0700
Subject: (#4884) Revise new exec tests, add a few more

Revised a few of the new tests for the exec type and provider to
ensure that they were testing what they meant to, and added in a
couple of new tests.

Reviewed-by:Daniel Pittman
---
 lib/puppet/type/exec.rb               |  2 +-
 spec/unit/provider/exec/posix_spec.rb | 13 +++++++++----
 spec/unit/provider/exec/shell_spec.rb | 18 ++++++++++++------
 3 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/lib/puppet/type/exec.rb b/lib/puppet/type/exec.rb
index 67d40a7cc..4458bf081 100755
--- a/lib/puppet/type/exec.rb
+++ b/lib/puppet/type/exec.rb
@@ -139,7 +139,7 @@ module Puppet
     newparam(:path) do
       desc "The search path used for command execution.
         Commands must be fully qualified if no path is specified.  Paths
-        can be specified as an array or as a colon or semi-colon separated list."
+        can be specified as an array or as a colon separated list."
 
       # Support both arrays and colon-separated fields.
       def value=(*values)
diff --git a/spec/unit/provider/exec/posix_spec.rb b/spec/unit/provider/exec/posix_spec.rb
index a9b207533..d02099250 100755
--- a/spec/unit/provider/exec/posix_spec.rb
+++ b/spec/unit/provider/exec/posix_spec.rb
@@ -57,13 +57,18 @@ describe provider_class do
           lambda { @provider.run("foo") }.should raise_error(ArgumentError, "'foo' is not executable")
         end
 
+        it "should not be able to execute shell builtins" do
+          @provider.resource[:path] = ['/bin']
+          lambda { @provider.run("cd ..") }.should raise_error(ArgumentError, "Could not find command 'cd'")
+        end
+
         it "should execute the command if the command given includes arguments or subcommands" do
           @provider.resource[:path] = ['/bogus/bin']
           File.stubs(:exists?).returns(false)
           File.stubs(:exists?).with("foo").returns(true)
           File.stubs(:executable?).with("foo").returns(true)
 
-          Puppet::Util.expects(:execute).with(['foo bar --sillyarg=true --blah'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo bar --sillyarg=true --blah']) && (arguments.is_a? Hash) }
           @provider.run("foo bar --sillyarg=true --blah")
         end
 
@@ -80,7 +85,7 @@ describe provider_class do
           @provider.resource[:path] = ['/bogus/bin']
           File.stubs(:exists?).with("foo").returns(true)
           File.stubs(:executable?).with("foo").returns(true)
-          Puppet::Util.expects(:execute).with(['foo'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
 
           @provider.run("foo")
         end
@@ -92,7 +97,7 @@ describe provider_class do
               File.stubs(:exists?).returns(false)
               File.stubs(:exists?).with("/bogus/bin/foo#{extension}").returns(true)
               File.stubs(:executable?).with("foo").returns(true)
-              Puppet::Util.expects(:execute).with(['foo'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+              Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
 
               @provider.run("foo")
             end
@@ -105,7 +110,7 @@ describe provider_class do
           File.stubs(:exists?).with("foo").returns(true)
           File.stubs(:executable?).with("foo").returns(true)
 
-          Puppet::Util.expects(:execute).with(['foo'], {:uid => nil, :gid => nil, :combine => true, :failonfail => false})
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
           @provider.run("foo")
           @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
         end
diff --git a/spec/unit/provider/exec/shell_spec.rb b/spec/unit/provider/exec/shell_spec.rb
index 44390ff08..a9b1f06ba 100644
--- a/spec/unit/provider/exec/shell_spec.rb
+++ b/spec/unit/provider/exec/shell_spec.rb
@@ -11,21 +11,27 @@ describe provider_class do
 
   describe "#run" do
     it "should be able to run builtin shell commands" do
-      output, status = @provider.run("echo foo")
+      output, status = @provider.run("if [ 1 == 1 ]; then echo 'blah'; fi")
       status.exitstatus.should == 0
-      output.should == "foo\n"
+      output.should == "blah\n"
     end
 
     it "should be able to run commands with single quotes in them" do
-      output, status = @provider.run("echo 'foo bar'")
+      output, status = @provider.run("echo 'foo  bar'")
       status.exitstatus.should == 0
-      output.should == "foo bar\n"
+      output.should == "foo  bar\n"
     end
 
     it "should be able to run commands with double quotes in them" do
-      output, status = @provider.run("echo 'foo bar'")
+      output, status = @provider.run('echo "foo  bar"')
       status.exitstatus.should == 0
-      output.should == "foo bar\n"
+      output.should == "foo  bar\n"
+    end
+
+    it "should be able to run multiple commands separated by a semicolon" do
+      output, status = @provider.run("echo 'foo' ; echo 'bar'")
+      status.exitstatus.should == 0
+      output.should == "foo\nbar\n"
     end
 
     it "should be able to read values from the environment parameter" do
-- 
cgit 


From f2c771be399713e5288ad58ba7c7ac128f7b4902 Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Thu, 17 Mar 2011 15:04:21 -0700
Subject: (#4884) Modify tests to pass on non-OS X systems

Fixed problems with the spec tests for the new exec type and
providers that were causing failures on non-OS X systems. This
involved rearranging some of the tests and their describe blocks,
which makes the diff look more dramatic than it really is.

Paired-with:Matt Robinson, Jacob Helwig
---
 spec/unit/provider/exec/shell_spec.rb |   2 +-
 spec/unit/type/exec_spec.rb           | 155 ++++++++++++++++++----------------
 2 files changed, 82 insertions(+), 75 deletions(-)

diff --git a/spec/unit/provider/exec/shell_spec.rb b/spec/unit/provider/exec/shell_spec.rb
index a9b1f06ba..4bae354c9 100644
--- a/spec/unit/provider/exec/shell_spec.rb
+++ b/spec/unit/provider/exec/shell_spec.rb
@@ -11,7 +11,7 @@ describe provider_class do
 
   describe "#run" do
     it "should be able to run builtin shell commands" do
-      output, status = @provider.run("if [ 1 == 1 ]; then echo 'blah'; fi")
+      output, status = @provider.run("if [ 1 = 1 ]; then echo 'blah'; fi")
       status.exitstatus.should == 0
       output.should == "blah\n"
     end
diff --git a/spec/unit/type/exec_spec.rb b/spec/unit/type/exec_spec.rb
index 4d691d580..978c4bab0 100755
--- a/spec/unit/type/exec_spec.rb
+++ b/spec/unit/type/exec_spec.rb
@@ -30,106 +30,112 @@ describe Puppet::Type.type(:exec) do
   end
 
   before do
-    @executable = Puppet.features.posix? ? '/bin/true' : 'C:/Program Files/something.exe'
     @command = Puppet.features.posix? ? '/bin/true whatever' : '"C:/Program Files/something.exe" whatever'
-    File.stubs(:exists?).returns false
-    File.stubs(:exists?).with(@executable).returns true
-    @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
-    File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
-    File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
   end
 
-  it "should return :executed_command as its event" do
-    resource = Puppet::Type.type(:exec).new :command => @command
-    resource.parameter(:returns).event.name.should == :executed_command
-  end
-
-  describe "when execing" do
-    it "should use the 'run_and_capture' method to exec" do
-      exec_tester("true").refresh.should == :executed_command
+  describe "when not stubbing the provider" do
+    before do
+      @executable = Puppet.features.posix? ? '/bin/foo' : 'C:/Program Files/something.exe'
+      File.stubs(:exists?).returns false
+      File.stubs(:exists?).with(@executable).returns true
+      File.stubs(:exists?).with('/bin/false').returns true
+      @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
+      File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
+      File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
     end
 
-    it "should report a failure" do
-      proc { exec_tester('false', 1).refresh }.
-        should raise_error(Puppet::Error, /^false returned 1 instead of/)
+    it "should return :executed_command as its event" do
+      resource = Puppet::Type.type(:exec).new :command => @command
+      resource.parameter(:returns).event.name.should == :executed_command
     end
 
-    it "should not report a failure if the exit status is specified in a returns array" do
-      proc { exec_tester("false", 1, :returns => [0, 1]).refresh }.should_not raise_error
-    end
+    describe "when execing" do
+      it "should use the 'run_and_capture' method to exec" do
+        exec_tester("true").refresh.should == :executed_command
+      end
 
-    it "should report a failure if the exit status is not specified in a returns array" do
-      proc { exec_tester('false', 1, :returns => [0, 100]).refresh }.
-        should raise_error(Puppet::Error, /^false returned 1 instead of/)
-    end
+      it "should report a failure" do
+        proc { exec_tester('false', 1).refresh }.
+          should raise_error(Puppet::Error, /^false returned 1 instead of/)
+      end
 
-    it "should log the output on success" do
-      output = "output1\noutput2\n"
-      exec_tester('false', 0, :output => output, :logoutput => true).refresh
-      output.split("\n").each do |line|
-        log = @logs.shift
-        log.level.should == :err
-        log.message.should == line
+      it "should not report a failure if the exit status is specified in a returns array" do
+        proc { exec_tester("false", 1, :returns => [0, 1]).refresh }.should_not raise_error
       end
-    end
 
-    it "should log the output on failure" do
-      output = "output1\noutput2\n"
-      proc { exec_tester('false', 1, :output => output, :logoutput => true).refresh }.
-        should raise_error(Puppet::Error)
+      it "should report a failure if the exit status is not specified in a returns array" do
+        proc { exec_tester('false', 1, :returns => [0, 100]).refresh }.
+          should raise_error(Puppet::Error, /^false returned 1 instead of/)
+      end
 
-      output.split("\n").each do |line|
-        log = @logs.shift
-        log.level.should == :err
-        log.message.should == line
+      it "should log the output on success" do
+        output = "output1\noutput2\n"
+        exec_tester('false', 0, :output => output, :logoutput => true).refresh
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
       end
-    end
-  end
 
-  describe "when logoutput=>on_failure is set" do
-    it "should log the output on failure" do
-      output = "output1\noutput2\n"
-      proc { exec_tester('false', 1, :output => output, :logoutput => :on_failure).refresh }.
-        should raise_error(Puppet::Error, /^false returned 1 instead of/)
+      it "should log the output on failure" do
+        output = "output1\noutput2\n"
+        proc { exec_tester('false', 1, :output => output, :logoutput => true).refresh }.
+          should raise_error(Puppet::Error)
 
-      output.split("\n").each do |line|
-        log = @logs.shift
-        log.level.should == :err
-        log.message.should == line
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
       end
     end
 
-    it "should log the output on failure when returns is specified as an array" do
-      output = "output1\noutput2\n"
+    describe "when logoutput=>on_failure is set" do
+      it "should log the output on failure" do
+        output = "output1\noutput2\n"
+        proc { exec_tester('false', 1, :output => output, :logoutput => :on_failure).refresh }.
+          should raise_error(Puppet::Error, /^false returned 1 instead of/)
 
-      proc {
-        exec_tester('false', 1, :output => output, :returns => [0, 100],
-             :logoutput => :on_failure).refresh
-      }.should raise_error(Puppet::Error, /^false returned 1 instead of/)
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
+      end
+
+      it "should log the output on failure when returns is specified as an array" do
+        output = "output1\noutput2\n"
 
-      output.split("\n").each do |line|
-        log = @logs.shift
-        log.level.should == :err
-        log.message.should == line
+        proc {
+          exec_tester('false', 1, :output => output, :returns => [0, 100],
+               :logoutput => :on_failure).refresh
+        }.should raise_error(Puppet::Error, /^false returned 1 instead of/)
+
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
+      end
+
+      it "shouldn't log the output on success" do
+        exec_tester('true', 0, :output => "a\nb\nc\n", :logoutput => :on_failure).refresh
+        @logs.should == []
       end
     end
 
-    it "shouldn't log the output on success" do
-      exec_tester('true', 0, :output => "a\nb\nc\n", :logoutput => :on_failure).refresh
+    it "shouldn't log the output on success when non-zero exit status is in a returns array" do
+      exec_tester("true", 100, :output => "a\n", :logoutput => :on_failure, :returns => [1, 100]).refresh
       @logs.should == []
     end
-  end
 
-  it "shouldn't log the output on success when non-zero exit status is in a returns array" do
-    exec_tester("true", 100, :output => "a\n", :logoutput => :on_failure, :returns => [1, 100]).refresh
-    @logs.should == []
-  end
-
-  describe " when multiple tries are set," do
-    it "should repeat the command attempt 'tries' times on failure and produce an error" do
-      tries = 5
-      resource = exec_tester("false", 1, :tries => tries, :try_sleep => 0)
-      proc { resource.refresh }.should raise_error(Puppet::Error)
+    describe " when multiple tries are set," do
+      it "should repeat the command attempt 'tries' times on failure and produce an error" do
+        tries = 5
+        resource = exec_tester("false", 1, :tries => tries, :try_sleep => 0)
+        proc { resource.refresh }.should raise_error(Puppet::Error)
+      end
     end
   end
 
@@ -356,6 +362,7 @@ describe Puppet::Type.type(:exec) do
 
       it "should fail if timeout is exceeded" do
         File.stubs(:exists?).with('/bin/sleep').returns(true)
+        File.stubs(:exists?).with('sleep').returns(false)
         sleep_exec = Puppet::Type.type(:exec).new(:name => 'sleep 1', :path => ['/bin'], :timeout => '0.2')
         lambda { sleep_exec.refresh }.should raise_error Puppet::Error, "Command exceeded timeout"
       end
-- 
cgit 


From 08115c0742024426cd7570742868915694eea61a Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Fri, 18 Mar 2011 11:04:27 -0700
Subject: (#4884) Remove typo from spec test

One of the stubs was accidentally stubbing for /bin/foo instead of
/bin/true.

Reviewed-by:Nick Lewis
---
 spec/unit/type/exec_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec/unit/type/exec_spec.rb b/spec/unit/type/exec_spec.rb
index 978c4bab0..07ad1df4c 100755
--- a/spec/unit/type/exec_spec.rb
+++ b/spec/unit/type/exec_spec.rb
@@ -35,7 +35,7 @@ describe Puppet::Type.type(:exec) do
 
   describe "when not stubbing the provider" do
     before do
-      @executable = Puppet.features.posix? ? '/bin/foo' : 'C:/Program Files/something.exe'
+      @executable = Puppet.features.posix? ? '/bin/true' : 'C:/Program Files/something.exe'
       File.stubs(:exists?).returns false
       File.stubs(:exists?).with(@executable).returns true
       File.stubs(:exists?).with('/bin/false').returns true
-- 
cgit 


From cf873c63f8aad942776d27900dc35470d2508ae8 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Wed, 16 Mar 2011 20:37:46 -0700
Subject: maint: Silence test output in the spec run

There was a test that output 'false' in the middle of the spec run.
This fixes that and makes the test a little stronger, because we
actually assert what puts is writing to standard out.

Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 spec/unit/application/agent_spec.rb | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index cc745d1fc..804057868 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -268,8 +268,9 @@ describe Puppet::Application::Agent do
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
-      Puppet[:configprint] = "pluginsync"
-
+      Puppet[:modulepath] = '/my/path'
+      Puppet[:configprint] = "modulepath"
+      Puppet::Util::Settings.any_instance.expects(:puts).with('/my/path')
       lambda { @puppetd.setup }.should raise_error(SystemExit)
     end
 
-- 
cgit 


From df20513122354deccd4ee4477a15cb70c5d605c6 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Fri, 18 Mar 2011 16:04:42 -0700
Subject: (#6658) Propagate ENC connection errors to the agent

When the master failed to run the External Node Classifier script it
would log an error on the master, but the agent didn't get back the full
error or the stack trace for it's logs.  By raising when there's an ENC
script problem on the master, this causes the error messages to
propagate to the agent.

Paired-with: Jacob Helwig <jacob@puppetlabs.com>
---
 lib/puppet/indirector/exec.rb     | 3 +--
 spec/unit/indirector/exec_spec.rb | 5 ++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/lib/puppet/indirector/exec.rb b/lib/puppet/indirector/exec.rb
index fa789442b..4683eda0f 100644
--- a/lib/puppet/indirector/exec.rb
+++ b/lib/puppet/indirector/exec.rb
@@ -35,8 +35,7 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     begin
       output = execute(external_command)
     rescue Puppet::ExecutionFailure => detail
-      Puppet.err "Failed to find #{name} via exec: #{detail}"
-      return nil
+      raise Puppet::Error, "Failed to find #{name} via exec: #{detail}"
     end
 
     if output =~ /\A\s*\Z/ # all whitespace
diff --git a/spec/unit/indirector/exec_spec.rb b/spec/unit/indirector/exec_spec.rb
index acad1ea93..de37f2775 100755
--- a/spec/unit/indirector/exec_spec.rb
+++ b/spec/unit/indirector/exec_spec.rb
@@ -47,10 +47,9 @@ describe Puppet::Indirector::Exec do
     @searcher.find(@request).should be_nil
   end
 
-  it "should return nil and log an error if there's an execution failure" do
+  it "should raise an exception if there's an execution failure" do
     @searcher.expects(:execute).with(%w{/echo foo}).raises(Puppet::ExecutionFailure.new("message"))
 
-    Puppet.expects(:err)
-    @searcher.find(@request).should be_nil
+    lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end
-- 
cgit 


From 66a4f361502864e8ea6ca3a11181851b7c313664 Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Thu, 3 Mar 2011 06:54:19 +1100
Subject: Fixed #6555 - Ruby 1.9.x warning: class variable access from toplevel

This came from the use of the @@colormap class variable.

The variables has been changed to a constant.
---
 lib/puppet/util/log/destinations.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/puppet/util/log/destinations.rb b/lib/puppet/util/log/destinations.rb
index dd0d996bf..9550e2c3b 100644
--- a/lib/puppet/util/log/destinations.rb
+++ b/lib/puppet/util/log/destinations.rb
@@ -96,7 +96,7 @@ Puppet::Util::Log.newdesttype :console do
   HWHITE  = {:console => "", :html => "FFFFFF"}
   RESET   = {:console => "",    :html => ""      }
 
-  @@colormap = {
+  Colormap = {
     :debug => WHITE,
     :info => GREEN,
     :notice => CYAN,
@@ -117,11 +117,11 @@ Puppet::Util::Log.newdesttype :console do
   end
 
   def console_color(level, str)
-    @@colormap[level][:console] + str + RESET[:console]
+    Colormap[level][:console] + str + RESET[:console]
   end
 
   def html_color(level, str)
-    %{<span style="color: %s">%s</span>} % [@@colormap[level][:html], str]
+    %{<span style="color: %s">%s</span>} % [Colormap[level][:html], str]
   end
 
   def initialize
-- 
cgit 


From 923d613bb5d96b1898a718bc37842531124b9b89 Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Thu, 3 Mar 2011 06:57:17 +1100
Subject: Fixed #6555 - Ruby 1.9.x returning Invalid next (SyntaxError)

The kick application has the option to ping hosts. On 1.9.x this
code was returning "Invalid next". The next in this code has been
replaced with an exit. Testing has confirmed this doesn't change the
behavior of puppet kick.
---
 lib/puppet/application/kick.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/puppet/application/kick.rb b/lib/puppet/application/kick.rb
index 604132818..da93c0182 100644
--- a/lib/puppet/application/kick.rb
+++ b/lib/puppet/application/kick.rb
@@ -245,7 +245,7 @@ License
       out = %x{ping -c 1 #{host}}
       unless $CHILD_STATUS == 0
         $stderr.print "Could not contact #{host}\n"
-        next
+        exit($CHILD_STATUS)
       end
     end
 
-- 
cgit 


From 0844a17f695b7db098f7a9e59da6f4559dc9131e Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Thu, 3 Mar 2011 10:30:02 +1100
Subject: Fixed #6555 - Fixed two more when then colon issues

Ruby 1.9.x doesn't support when foo:

Replaced in the launchd provider and the Oracle rails ORM
---
 lib/puppet/provider/service/launchd.rb | 2 +-
 lib/puppet/rails.rb                    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/puppet/provider/service/launchd.rb b/lib/puppet/provider/service/launchd.rb
index 07c549a8b..9d813bd5a 100644
--- a/lib/puppet/provider/service/launchd.rb
+++ b/lib/puppet/provider/service/launchd.rb
@@ -211,7 +211,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     job_path, job_plist = plist_from_label(resource[:name])
     job_plist_disabled = job_plist["Disabled"] if job_plist.has_key?("Disabled")
 
-    if self.class.get_macosx_version_major == "10.6":
+    if self.class.get_macosx_version_major == "10.6"
       if FileTest.file?(Launchd_Overrides) and overrides = self.class.read_plist(Launchd_Overrides)
         if overrides.has_key?(resource[:name])
           overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
diff --git a/lib/puppet/rails.rb b/lib/puppet/rails.rb
index 74805bb6f..f74e63f20 100644
--- a/lib/puppet/rails.rb
+++ b/lib/puppet/rails.rb
@@ -58,7 +58,7 @@ module Puppet::Rails
 
       socket          = Puppet[:dbsocket]
       args[:socket]   = socket unless socket.to_s.empty?
-    when "oracle_enhanced":
+    when "oracle_enhanced"
       args[:database] = Puppet[:dbname] unless Puppet[:dbname].to_s.empty?
       args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
       args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
-- 
cgit 


From ad8cc54d8022de6213a4141d4c8ba9387ce4c62e Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 00:11:38 -0700
Subject: (#6555) Fix another ruby 1.9 incompatible case statement

---
 lib/puppet/parser/lexer.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/puppet/parser/lexer.rb b/lib/puppet/parser/lexer.rb
index 9a25263f6..4050adeb8 100644
--- a/lib/puppet/parser/lexer.rb
+++ b/lib/puppet/parser/lexer.rb
@@ -532,7 +532,7 @@ class Puppet::Parser::Lexer
         when 'n'; "\n"
         when 't'; "\t"
         when 's'; " "
-        when "\n": ''
+        when "\n"; ''
         else      ch
         end
       else
-- 
cgit 


From 517fd2f3d354fb2c411d872187de12a92c992456 Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Thu, 3 Mar 2011 09:25:01 +1100
Subject: Fixed #6566 Replace ftools with filetuils in rake gem task

ftools is used in the rake gem rasks. It is deprecated in
Ruby 1.9.x and so we've replaced it with FileUtils.
---
 tasks/rake/gem.rake | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/tasks/rake/gem.rake b/tasks/rake/gem.rake
index d654886ae..efea73882 100644
--- a/tasks/rake/gem.rake
+++ b/tasks/rake/gem.rake
@@ -1,4 +1,4 @@
-require 'ftools'
+require 'fileutils'
 
 GEM_FILES = FileList[
     '[A-Z]*',
@@ -44,7 +44,7 @@ end
 desc "Prepare binaries for gem creation"
 task :prepare_gem do
     SBIN.each do |f|
-      File.copy(f,"bin")
+      FileUtils.copy(f,"bin")
     end
 end
 
@@ -52,8 +52,9 @@ desc "Create the gem"
 task :create_gem => :prepare_gem do
     Dir.mkdir("pkg") rescue nil
     Gem::Builder.new(spec).build
-    File.move("puppet-#{Puppet::PUPPETVERSION}.gem", "pkg")
+    FileUtils.move("puppet-#{Puppet::PUPPETVERSION}.gem", "pkg")
     SBIN.each do |f|
-       File.unlink("bin/" + f.gsub(/sbin\//, ''))
+       fn = f.gsub(/sbin\/(.*)/, '\1')
+       FileUtils.rm_r "bin/" + fn
     end
 end
-- 
cgit 


From d448763f6e94709b688e12f2a0edc589cf38e6fa Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 00:54:09 -0700
Subject: (#6566) Fix ruby 1.9 incompatible case statement

Once the futils area of the Rakefile was fixed, running `rake spec`
turned up this problem.
---
 tasks/rake/git_workflow.rake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tasks/rake/git_workflow.rake b/tasks/rake/git_workflow.rake
index 1ba57c1aa..68a4d4a59 100644
--- a/tasks/rake/git_workflow.rake
+++ b/tasks/rake/git_workflow.rake
@@ -6,8 +6,8 @@ def find_start(start)
 # This is a case statement, as we might want to map certain
 # git tags to starting points that are not currently in git.
 	case start
-		when nil?:
-		when @next_release: return "master"
+		when nil?;
+		when @next_release; return "master"
 		else return start
 	end
 end
-- 
cgit 


From 4156edc25b3ad95df6ed0eaa302ec06db2ba303b Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 00:55:31 -0700
Subject: (#6566) Replace tabs with spaces

---
 tasks/rake/git_workflow.rake | 100 +++++++++++++++++++++----------------------
 1 file changed, 50 insertions(+), 50 deletions(-)

diff --git a/tasks/rake/git_workflow.rake b/tasks/rake/git_workflow.rake
index 68a4d4a59..75dc8833a 100644
--- a/tasks/rake/git_workflow.rake
+++ b/tasks/rake/git_workflow.rake
@@ -5,82 +5,82 @@
 def find_start(start)
 # This is a case statement, as we might want to map certain
 # git tags to starting points that are not currently in git.
-	case start
-		when nil?;
-		when @next_release; return "master"
-		else return start
-	end
+  case start
+    when nil?;
+    when @next_release; return "master"
+    else return start
+  end
 end
 
 desc "Set up git for working with Puppet"
 task :git_setup do
-	# This should be changed as new versions get released
-	@next_release = '0.26.x'
-	@remote = {}
-	default_remote = {}
-	default_remote[:url] = 'git://github.com/reductivelabs/puppet'
-	default_remote[:name] = 'origin'
-	@remote[:name] = %x{git config puppet.defaultremote}.chomp
-	@remote[:name] = @remote[:name].empty? ? default_remote[:name] : @remote[:name]
-	@remote[:url] = default_remote[:url] if @remote[:name] == default_remote[:name]
-	default_fetch = '+refs/heads/*:refs/remotes/puppet/*'
-	@remote[:fetch] = %x{git config puppet.#{@remote[:name]}.fetch}.chomp
-	@remote[:fetch] = @remote[:fetch].empty? ?  default_fetch : @remote[:fetch]
+  # This should be changed as new versions get released
+  @next_release = '0.26.x'
+  @remote = {}
+  default_remote = {}
+  default_remote[:url] = 'git://github.com/reductivelabs/puppet'
+  default_remote[:name] = 'origin'
+  @remote[:name] = %x{git config puppet.defaultremote}.chomp
+  @remote[:name] = @remote[:name].empty? ? default_remote[:name] : @remote[:name]
+  @remote[:url] = default_remote[:url] if @remote[:name] == default_remote[:name]
+  default_fetch = '+refs/heads/*:refs/remotes/puppet/*'
+  @remote[:fetch] = %x{git config puppet.#{@remote[:name]}.fetch}.chomp
+  @remote[:fetch] = @remote[:fetch].empty? ?  default_fetch : @remote[:fetch]
 end
 
 desc "Start work on a feature"
 task :start_feature, [:feature,:remote,:branch] => :git_setup do |t, args|
-	args.with_defaults(:remote => @remote[:name])
-	args.with_defaults(:branch => @next_release)
-	start_at = find_start(args.branch)
-	branch = "feature/#{start_at}/#{args.feature}"
-	sh "git checkout -b #{branch} #{start_at}" do |ok, res|
-		if ! ok
-			raise <<EOS
+  args.with_defaults(:remote => @remote[:name])
+  args.with_defaults(:branch => @next_release)
+  start_at = find_start(args.branch)
+  branch = "feature/#{start_at}/#{args.feature}"
+  sh "git checkout -b #{branch} #{start_at}" do |ok, res|
+    if ! ok
+      raise <<EOS
 Was not able to create branch for #{args.feature} on branch #{args.branch}, starting at #{start_at}: error code was: #{res.exitstatus}
 EOS
-		end
-	end
-	sh "git config branch.#{branch}.remote #{args.remote}" do |ok, res|
-		raise "Could not set remote: #{$?}" unless ok
-	end
-
-	sh "git config branch.#{branch}.merge refs/heads/#{branch}" do |ok, res|
-		raise "Could not configure merge: #{$?}" unless ok
-	end
+    end
+  end
+  sh "git config branch.#{branch}.remote #{args.remote}" do |ok, res|
+    raise "Could not set remote: #{$?}" unless ok
+  end
+
+  sh "git config branch.#{branch}.merge refs/heads/#{branch}" do |ok, res|
+    raise "Could not configure merge: #{$?}" unless ok
+  end
 end
 
 desc "Do git prep to start work on a Redmine ticket"
 task :start_ticket, [:ticket, :remote, :branch] => :git_setup do |t, args|
-	args.with_defaults(:remote => @remote[:name])
-	args.with_defaults(:branch => @next_release)
-	start_at = find_start(args.branch)
-	branch = "tickets/#{start_at}/#{args.ticket}"
-	sh "git checkout -b #{branch} #{start_at}" do |ok, res|
-		unless ok
-			raise <<EOS
+  args.with_defaults(:remote => @remote[:name])
+  args.with_defaults(:branch => @next_release)
+  start_at = find_start(args.branch)
+  branch = "tickets/#{start_at}/#{args.ticket}"
+  sh "git checkout -b #{branch} #{start_at}" do |ok, res|
+    unless ok
+      raise <<EOS
 Was not able to create branch for ticket #{args.ticket} on branch #{args.branch}, starting at #{start_at}: error code was: #{$?}
 Git command used was: #{command}
 EOS
-		end
-	end
+    end
+  end
     sh "git config branch.#{branch}.remote #{args.remote}" do |ok, res|
-    	raise "Could not set remote: #{$?}" unless ok
-	end
+      raise "Could not set remote: #{$?}" unless ok
+  end
 
     sh "git config branch.#{branch}.merge refs/heads/#{branch}" do |ok, res|
-    	raise "Could not configure merge: #{$?}" unless ok
-	end
+      raise "Could not configure merge: #{$?}" unless ok
+  end
 end
 
 # This isn't very useful by itself, but we might enhance it later, or use it
 # in a dependency for a more complex task.
 desc "Push out changes"
 task :push_changes, [:remote] do |t, arg|
-	branch = %x{git branch | grep "^" | awk '{print $2}'}
-	sh "git push #{arg.remote} #{branch}" do |ok, res|
-		raise "Unable to push to #{arg.remote}" unless ok
-	end
+  branch = %x{git branch | grep "^" | awk '{print $2}'}
+  sh "git push #{arg.remote} #{branch}" do |ok, res|
+    raise "Unable to push to #{arg.remote}" unless ok
+  end
 end
 
 desc "Send patch information to the puppet-dev list"
-- 
cgit 


From a29c7fd408b8b1e00410f5bbd82ff5e626381667 Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Thu, 3 Mar 2011 07:03:51 +1100
Subject: Fixed #6562 - Minor kick documentation fix

---
 lib/puppet/util/command_line/puppetrun | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/puppet/util/command_line/puppetrun b/lib/puppet/util/command_line/puppetrun
index 7eba3b2c4..3437405b0 100755
--- a/lib/puppet/util/command_line/puppetrun
+++ b/lib/puppet/util/command_line/puppetrun
@@ -107,7 +107,6 @@
 #   option requires LDAP support at this point.
 #
 # ping::
-#
 #   Do a ICMP echo against the target host. Skip hosts that don't respond to ping.
 #
 # = Example
-- 
cgit 


From 307df20d7dfd4f5a2a3b67fc2587491560ee951c Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 01:28:45 -0700
Subject: Fix error "invalid multibyte char (US-ASCII)" under Ruby 1.9

Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/type/macauthorization.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/puppet/type/macauthorization.rb b/lib/puppet/type/macauthorization.rb
index e89aa7c89..b16ab6dde 100644
--- a/lib/puppet/type/macauthorization.rb
+++ b/lib/puppet/type/macauthorization.rb
@@ -2,7 +2,7 @@ Puppet::Type.newtype(:macauthorization) do
 
   @doc = "Manage the Mac OS X authorization database.
     See the [Apple developer site](http://developer.apple.com/documentation/Security/Conceptual/Security_Overview/Security_Services/chapter_4_section_5.html) for more information.
-    
+
     **Autorequires:** If Puppet is managing the `/etc/authorization` file, each
     macauthorization resource will autorequire it."
 
@@ -33,8 +33,8 @@ Puppet::Type.newtype(:macauthorization) do
     desc "The name of the right or rule to be managed.
     Corresponds to 'key' in Authorization Services. The key is the name
     of a rule. A key uses the same naming conventions as a right. The
-    Security Server uses a rule’s key to match the rule with a right.
-    Wildcard keys end with a ‘.’. The generic rule has an empty key value.
+    Security Server uses a rule's key to match the rule with a right.
+    Wildcard keys end with a '.'. The generic rule has an empty key value.
     Any rights that do not match a specific rule use the generic rule."
 
     isnamevar
-- 
cgit 


From f6da3339f59bbd9243a03dc1e417b1fed7955c7e Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 11:31:14 -0700
Subject: maint: Change code for finding spec_helper to work with Ruby 1.9

Running the specs under Ruby 1.9 didn't work using the lambda to recurse
down directories to find the spec_helper.  Standardizing the way to find
spec_helper like the rest of specs seemed like the way to go.

Here's the command line perl I used to make the change:

perl -p -i -e "s/Dir.chdir.*lambda.*spec_helper.*$/require
File.expand_path(File.dirname(__FILE__) + '\/..\/..\/spec_helper')/"
`find spec -name "*_spec.rb"`

Then I fixed the number of dots for files that weren't two levels from
the spec dir and whose tests failed.

Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 spec/integration/indirector/catalog/compiler_spec.rb | 2 +-
 spec/integration/indirector/catalog/queue_spec.rb    | 2 +-
 spec/integration/provider/package_spec.rb            | 2 +-
 spec/integration/provider/service/init_spec.rb       | 3 +--
 spec/integration/reference/providers_spec.rb         | 2 +-
 spec/integration/util/autoload_spec.rb               | 2 +-
 spec/integration/util/feature_spec.rb                | 2 +-
 spec/integration/util/file_locking_spec.rb           | 2 +-
 spec/integration/util/rdoc/parser_spec.rb            | 2 +-
 spec/unit/indirector/file_bucket_file/rest_spec.rb   | 2 +-
 spec/unit/indirector/resource/rest_spec.rb           | 2 +-
 spec/unit/indirector/status/rest_spec.rb             | 2 +-
 spec/unit/network/http/api/v1_spec.rb                | 2 +-
 spec/unit/network/xmlrpc/client_spec.rb              | 2 +-
 spec/unit/property/ensure_spec.rb                    | 2 +-
 spec/unit/property/keyvalue_spec.rb                  | 2 +-
 spec/unit/property/list_spec.rb                      | 2 +-
 spec/unit/property/ordered_list_spec.rb              | 2 +-
 spec/unit/provider/package/apt_spec.rb               | 2 +-
 spec/unit/provider/package/dpkg_spec.rb              | 2 +-
 spec/unit/provider/package/pkg_spec.rb               | 2 +-
 spec/unit/provider/package/pkgdmg_spec.rb            | 2 +-
 spec/unit/provider/selboolean_spec.rb                | 2 +-
 spec/unit/provider/selmodule_spec.rb                 | 2 +-
 spec/unit/reports/http_spec.rb                       | 2 +-
 spec/unit/reports/rrdgraph_spec.rb                   | 2 +-
 spec/unit/reports/store_spec.rb                      | 2 +-
 spec/unit/reports/tagmail_spec.rb                    | 2 +-
 spec/unit/type/cron_spec.rb                          | 2 +-
 spec/unit/type/file/checksum_spec.rb                 | 2 +-
 spec/unit/type/file/content_spec.rb                  | 2 +-
 spec/unit/type/file/ctime.rb                         | 2 +-
 spec/unit/type/file/ensure_spec.rb                   | 2 +-
 spec/unit/type/file/group_spec.rb                    | 2 +-
 spec/unit/type/file/mtime.rb                         | 2 +-
 spec/unit/type/file/owner_spec.rb                    | 2 +-
 spec/unit/type/file/selinux_spec.rb                  | 2 +-
 spec/unit/type/file/source_spec.rb                   | 2 +-
 spec/unit/type/file/type.rb                          | 2 +-
 spec/unit/type/maillist_spec.rb                      | 2 +-
 spec/unit/type/selboolean_spec.rb                    | 2 +-
 spec/unit/type/selmodule_spec.rb                     | 2 +-
 spec/unit/type/zfs_spec.rb                           | 2 +-
 spec/unit/type/zone_spec.rb                          | 2 +-
 spec/unit/type/zpool_spec.rb                         | 2 +-
 spec/unit/util/autoload_spec.rb                      | 2 +-
 spec/unit/util/command_line_spec.rb                  | 2 +-
 spec/unit/util/errors_spec.rb                        | 2 +-
 spec/unit/util/feature_spec.rb                       | 2 +-
 spec/unit/util/file_locking_spec.rb                  | 2 +-
 spec/unit/util/filetype_spec.rb                      | 2 +-
 spec/unit/util/inline_docs_spec.rb                   | 2 +-
 spec/unit/util/log_spec.rb                           | 2 +-
 spec/unit/util/logging_spec.rb                       | 2 +-
 spec/unit/util/metric_spec.rb                        | 2 +-
 spec/unit/util/monkey_patches_spec.rb                | 2 +-
 spec/unit/util/posix_spec.rb                         | 2 +-
 spec/unit/util/pson_spec.rb                          | 2 +-
 spec/unit/util/rdoc/parser_spec.rb                   | 2 +-
 spec/unit/util/rdoc_spec.rb                          | 2 +-
 spec/unit/util/user_attr_spec.rb                     | 2 +-
 spec/unit/util/zaml_spec.rb                          | 2 +-
 62 files changed, 62 insertions(+), 63 deletions(-)

diff --git a/spec/integration/indirector/catalog/compiler_spec.rb b/spec/integration/indirector/catalog/compiler_spec.rb
index dcb7eb425..1146c20b0 100755
--- a/spec/integration/indirector/catalog/compiler_spec.rb
+++ b/spec/integration/indirector/catalog/compiler_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/resource/catalog'
 
diff --git a/spec/integration/indirector/catalog/queue_spec.rb b/spec/integration/indirector/catalog/queue_spec.rb
index 4581e3062..237e489f9 100755
--- a/spec/integration/indirector/catalog/queue_spec.rb
+++ b/spec/integration/indirector/catalog/queue_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/resource/catalog'
 
diff --git a/spec/integration/provider/package_spec.rb b/spec/integration/provider/package_spec.rb
index 472662d6b..cc03c57a7 100755
--- a/spec/integration/provider/package_spec.rb
+++ b/spec/integration/provider/package_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe "Package Provider" do
   Puppet::Type.type(:package).providers.each do |name|
diff --git a/spec/integration/provider/service/init_spec.rb b/spec/integration/provider/service/init_spec.rb
index 2e2505bd4..c74ce29fe 100755
--- a/spec/integration/provider/service/init_spec.rb
+++ b/spec/integration/provider/service/init_spec.rb
@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-# Find and load the spec file.
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 provider = Puppet::Type.type(:service).provider(:init)
 
diff --git a/spec/integration/reference/providers_spec.rb b/spec/integration/reference/providers_spec.rb
index c2b1e17c5..d6e19cb59 100755
--- a/spec/integration/reference/providers_spec.rb
+++ b/spec/integration/reference/providers_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/reference'
 
diff --git a/spec/integration/util/autoload_spec.rb b/spec/integration/util/autoload_spec.rb
index 8a5d66232..f9b913502 100755
--- a/spec/integration/util/autoload_spec.rb
+++ b/spec/integration/util/autoload_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/autoload'
 require 'fileutils'
diff --git a/spec/integration/util/feature_spec.rb b/spec/integration/util/feature_spec.rb
index f1ada9057..b038cf308 100755
--- a/spec/integration/util/feature_spec.rb
+++ b/spec/integration/util/feature_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/feature'
 require 'puppet_spec/files'
diff --git a/spec/integration/util/file_locking_spec.rb b/spec/integration/util/file_locking_spec.rb
index 50613448b..1914fadf7 100755
--- a/spec/integration/util/file_locking_spec.rb
+++ b/spec/integration/util/file_locking_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/file_locking'
 
diff --git a/spec/integration/util/rdoc/parser_spec.rb b/spec/integration/util/rdoc/parser_spec.rb
index 7d3b0ec3e..9cb0c9e4a 100755
--- a/spec/integration/util/rdoc/parser_spec.rb
+++ b/spec/integration/util/rdoc/parser_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/resource/type_collection'
 require 'puppet/util/rdoc/parser'
diff --git a/spec/unit/indirector/file_bucket_file/rest_spec.rb b/spec/unit/indirector/file_bucket_file/rest_spec.rb
index 960f60ae7..d0f714751 100755
--- a/spec/unit/indirector/file_bucket_file/rest_spec.rb
+++ b/spec/unit/indirector/file_bucket_file/rest_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/indirector/file_bucket_file/rest'
 
diff --git a/spec/unit/indirector/resource/rest_spec.rb b/spec/unit/indirector/resource/rest_spec.rb
index 351aee33b..1285d338a 100755
--- a/spec/unit/indirector/resource/rest_spec.rb
+++ b/spec/unit/indirector/resource/rest_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/indirector/resource/rest'
 
diff --git a/spec/unit/indirector/status/rest_spec.rb b/spec/unit/indirector/status/rest_spec.rb
index 5eed5fc93..436c86881 100755
--- a/spec/unit/indirector/status/rest_spec.rb
+++ b/spec/unit/indirector/status/rest_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/indirector/status/rest'
 
diff --git a/spec/unit/network/http/api/v1_spec.rb b/spec/unit/network/http/api/v1_spec.rb
index 25f6d8fe2..257eec5de 100644
--- a/spec/unit/network/http/api/v1_spec.rb
+++ b/spec/unit/network/http/api/v1_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../../spec_helper')
 
 require 'puppet/network/http/api/v1'
 
diff --git a/spec/unit/network/xmlrpc/client_spec.rb b/spec/unit/network/xmlrpc/client_spec.rb
index 8440d39fa..7498ca4cf 100755
--- a/spec/unit/network/xmlrpc/client_spec.rb
+++ b/spec/unit/network/xmlrpc/client_spec.rb
@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require 'puppet/network/client'
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe Puppet::Network::XMLRPCClient do
   describe "when performing the rpc call" do
diff --git a/spec/unit/property/ensure_spec.rb b/spec/unit/property/ensure_spec.rb
index f2722de89..d3029c658 100644
--- a/spec/unit/property/ensure_spec.rb
+++ b/spec/unit/property/ensure_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/property/ensure'
 
diff --git a/spec/unit/property/keyvalue_spec.rb b/spec/unit/property/keyvalue_spec.rb
index a44d891d7..a0175cfa3 100644
--- a/spec/unit/property/keyvalue_spec.rb
+++ b/spec/unit/property/keyvalue_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/property/keyvalue'
 
diff --git a/spec/unit/property/list_spec.rb b/spec/unit/property/list_spec.rb
index c6c5db10e..704fbe3d9 100644
--- a/spec/unit/property/list_spec.rb
+++ b/spec/unit/property/list_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/property/list'
 
diff --git a/spec/unit/property/ordered_list_spec.rb b/spec/unit/property/ordered_list_spec.rb
index 7c8eceb0d..460bec79d 100644
--- a/spec/unit/property/ordered_list_spec.rb
+++ b/spec/unit/property/ordered_list_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/property/ordered_list'
 
diff --git a/spec/unit/provider/package/apt_spec.rb b/spec/unit/provider/package/apt_spec.rb
index 3c6bf62af..b0ce4f799 100755
--- a/spec/unit/provider/package/apt_spec.rb
+++ b/spec/unit/provider/package/apt_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 provider = Puppet::Type.type(:package).provider(:apt)
 
diff --git a/spec/unit/provider/package/dpkg_spec.rb b/spec/unit/provider/package/dpkg_spec.rb
index 47ac9766e..444fb31c1 100755
--- a/spec/unit/provider/package/dpkg_spec.rb
+++ b/spec/unit/provider/package/dpkg_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 provider = Puppet::Type.type(:package).provider(:dpkg)
 
diff --git a/spec/unit/provider/package/pkg_spec.rb b/spec/unit/provider/package/pkg_spec.rb
index 1544b8b7e..3455c4c40 100644
--- a/spec/unit/provider/package/pkg_spec.rb
+++ b/spec/unit/provider/package/pkg_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 provider = Puppet::Type.type(:package).provider(:pkg)
 
diff --git a/spec/unit/provider/package/pkgdmg_spec.rb b/spec/unit/provider/package/pkgdmg_spec.rb
index 1fd5b4ac4..86631e596 100755
--- a/spec/unit/provider/package/pkgdmg_spec.rb
+++ b/spec/unit/provider/package/pkgdmg_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 provider = Puppet::Type.type(:package).provider(:pkgdmg)
 
diff --git a/spec/unit/provider/selboolean_spec.rb b/spec/unit/provider/selboolean_spec.rb
index b37b44b45..02a39f2a7 100755
--- a/spec/unit/provider/selboolean_spec.rb
+++ b/spec/unit/provider/selboolean_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 provider_class = Puppet::Type.type(:selboolean).provider(:getsetsebool)
 
diff --git a/spec/unit/provider/selmodule_spec.rb b/spec/unit/provider/selmodule_spec.rb
index fda6d0d78..cb143e993 100755
--- a/spec/unit/provider/selmodule_spec.rb
+++ b/spec/unit/provider/selmodule_spec.rb
@@ -5,7 +5,7 @@
 # with version 1.5.0.  The provided selmodule-example.pp is the first
 # 256 bytes taken from /usr/share/selinux/targeted/nagios.pp on Fedora 9
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 provider_class = Puppet::Type.type(:selmodule).provider(:semodule)
 
diff --git a/spec/unit/reports/http_spec.rb b/spec/unit/reports/http_spec.rb
index 70742f7dc..a62793ed5 100644
--- a/spec/unit/reports/http_spec.rb
+++ b/spec/unit/reports/http_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/reports'
 
diff --git a/spec/unit/reports/rrdgraph_spec.rb b/spec/unit/reports/rrdgraph_spec.rb
index ce2cf7905..5215f1dcc 100644
--- a/spec/unit/reports/rrdgraph_spec.rb
+++ b/spec/unit/reports/rrdgraph_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/reports'
 
diff --git a/spec/unit/reports/store_spec.rb b/spec/unit/reports/store_spec.rb
index 9d9042386..d48f6a846 100644
--- a/spec/unit/reports/store_spec.rb
+++ b/spec/unit/reports/store_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/reports'
 require 'time'
diff --git a/spec/unit/reports/tagmail_spec.rb b/spec/unit/reports/tagmail_spec.rb
index fa8990ebb..716bcbc04 100755
--- a/spec/unit/reports/tagmail_spec.rb
+++ b/spec/unit/reports/tagmail_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/reports'
 
diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 03817d20e..4d224c64b 100755
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Puppet::Type.type(:cron) do
   before do
diff --git a/spec/unit/type/file/checksum_spec.rb b/spec/unit/type/file/checksum_spec.rb
index 8b9138b78..16e8e99e1 100644
--- a/spec/unit/type/file/checksum_spec.rb
+++ b/spec/unit/type/file/checksum_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 checksum = Puppet::Type.type(:file).attrclass(:checksum)
 describe checksum do
diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index bd2b2adaf..7abc7c433 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 content = Puppet::Type.type(:file).attrclass(:content)
 describe content do
diff --git a/spec/unit/type/file/ctime.rb b/spec/unit/type/file/ctime.rb
index 6145cbfdc..9fb892aed 100644
--- a/spec/unit/type/file/ctime.rb
+++ b/spec/unit/type/file/ctime.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe Puppet::Type.type(:file).attrclass(:ctime) do
   require 'puppet_spec/files'
diff --git a/spec/unit/type/file/ensure_spec.rb b/spec/unit/type/file/ensure_spec.rb
index dbb3a1053..c5351309e 100755
--- a/spec/unit/type/file/ensure_spec.rb
+++ b/spec/unit/type/file/ensure_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 property = Puppet::Type.type(:file).attrclass(:ensure)
 
diff --git a/spec/unit/type/file/group_spec.rb b/spec/unit/type/file/group_spec.rb
index 956cd57e7..37a6872bd 100755
--- a/spec/unit/type/file/group_spec.rb
+++ b/spec/unit/type/file/group_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 property = Puppet::Type.type(:file).attrclass(:group)
 
diff --git a/spec/unit/type/file/mtime.rb b/spec/unit/type/file/mtime.rb
index 043156ceb..fa61bc343 100644
--- a/spec/unit/type/file/mtime.rb
+++ b/spec/unit/type/file/mtime.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe Puppet::Type.type(:file).attrclass(:mtime) do
   require 'puppet_spec/files'
diff --git a/spec/unit/type/file/owner_spec.rb b/spec/unit/type/file/owner_spec.rb
index bcb8e07d6..375faa237 100755
--- a/spec/unit/type/file/owner_spec.rb
+++ b/spec/unit/type/file/owner_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 property = Puppet::Type.type(:file).attrclass(:owner)
 
diff --git a/spec/unit/type/file/selinux_spec.rb b/spec/unit/type/file/selinux_spec.rb
index a2444acd9..45e8b3b14 100644
--- a/spec/unit/type/file/selinux_spec.rb
+++ b/spec/unit/type/file/selinux_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 
 [:seluser, :selrole, :seltype, :selrange].each do |param|
diff --git a/spec/unit/type/file/source_spec.rb b/spec/unit/type/file/source_spec.rb
index c07963a50..bb83e7531 100755
--- a/spec/unit/type/file/source_spec.rb
+++ b/spec/unit/type/file/source_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 source = Puppet::Type.type(:file).attrclass(:source)
 describe Puppet::Type.type(:file).attrclass(:source) do
diff --git a/spec/unit/type/file/type.rb b/spec/unit/type/file/type.rb
index e46f0e0b0..0d38b64cd 100644
--- a/spec/unit/type/file/type.rb
+++ b/spec/unit/type/file/type.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe Puppet::Type.type(:file).attrclass(:type) do
   require 'puppet_spec/files'
diff --git a/spec/unit/type/maillist_spec.rb b/spec/unit/type/maillist_spec.rb
index 04acea7dd..7e96b4760 100755
--- a/spec/unit/type/maillist_spec.rb
+++ b/spec/unit/type/maillist_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 maillist = Puppet::Type.type(:maillist)
 
diff --git a/spec/unit/type/selboolean_spec.rb b/spec/unit/type/selboolean_spec.rb
index 3b31f4306..41b254f25 100755
--- a/spec/unit/type/selboolean_spec.rb
+++ b/spec/unit/type/selboolean_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Puppet::Type.type(:selboolean), "when validating attributes" do
   [:name, :persistent].each do |param|
diff --git a/spec/unit/type/selmodule_spec.rb b/spec/unit/type/selmodule_spec.rb
index 3d126256c..37453d8ed 100755
--- a/spec/unit/type/selmodule_spec.rb
+++ b/spec/unit/type/selmodule_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Puppet::Type.type(:selmodule), "when validating attributes" do
   [:name, :selmoduledir, :selmodulepath].each do |param|
diff --git a/spec/unit/type/zfs_spec.rb b/spec/unit/type/zfs_spec.rb
index 6b0b17f3a..88193fca3 100755
--- a/spec/unit/type/zfs_spec.rb
+++ b/spec/unit/type/zfs_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 zfs = Puppet::Type.type(:zfs)
 
diff --git a/spec/unit/type/zone_spec.rb b/spec/unit/type/zone_spec.rb
index a3e748bde..e479fb1e9 100755
--- a/spec/unit/type/zone_spec.rb
+++ b/spec/unit/type/zone_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 zone = Puppet::Type.type(:zone)
 
diff --git a/spec/unit/type/zpool_spec.rb b/spec/unit/type/zpool_spec.rb
index be8cb12ba..96e7d548c 100755
--- a/spec/unit/type/zpool_spec.rb
+++ b/spec/unit/type/zpool_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 zpool = Puppet::Type.type(:zpool)
 
diff --git a/spec/unit/util/autoload_spec.rb b/spec/unit/util/autoload_spec.rb
index eb0b705f4..808885dd7 100755
--- a/spec/unit/util/autoload_spec.rb
+++ b/spec/unit/util/autoload_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/autoload'
 
diff --git a/spec/unit/util/command_line_spec.rb b/spec/unit/util/command_line_spec.rb
index 98ddb92f6..a7d261dcf 100755
--- a/spec/unit/util/command_line_spec.rb
+++ b/spec/unit/util/command_line_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 
 require 'puppet/util/command_line'
diff --git a/spec/unit/util/errors_spec.rb b/spec/unit/util/errors_spec.rb
index 2500403d0..da1b8b0bd 100755
--- a/spec/unit/util/errors_spec.rb
+++ b/spec/unit/util/errors_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/errors'
 
diff --git a/spec/unit/util/feature_spec.rb b/spec/unit/util/feature_spec.rb
index 8cedade7d..365428752 100755
--- a/spec/unit/util/feature_spec.rb
+++ b/spec/unit/util/feature_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/feature'
 
diff --git a/spec/unit/util/file_locking_spec.rb b/spec/unit/util/file_locking_spec.rb
index 8fafb1d52..e9dbe9d7b 100755
--- a/spec/unit/util/file_locking_spec.rb
+++ b/spec/unit/util/file_locking_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/file_locking'
 
diff --git a/spec/unit/util/filetype_spec.rb b/spec/unit/util/filetype_spec.rb
index 68ef9d6eb..012631b91 100644
--- a/spec/unit/util/filetype_spec.rb
+++ b/spec/unit/util/filetype_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/filetype'
 
diff --git a/spec/unit/util/inline_docs_spec.rb b/spec/unit/util/inline_docs_spec.rb
index edfa405a1..75afb57cb 100755
--- a/spec/unit/util/inline_docs_spec.rb
+++ b/spec/unit/util/inline_docs_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/inline_docs'
 
diff --git a/spec/unit/util/log_spec.rb b/spec/unit/util/log_spec.rb
index 29df0787a..3c8577493 100755
--- a/spec/unit/util/log_spec.rb
+++ b/spec/unit/util/log_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/log'
 
diff --git a/spec/unit/util/logging_spec.rb b/spec/unit/util/logging_spec.rb
index 411cd17a9..97ffc0b25 100755
--- a/spec/unit/util/logging_spec.rb
+++ b/spec/unit/util/logging_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/logging'
 
diff --git a/spec/unit/util/metric_spec.rb b/spec/unit/util/metric_spec.rb
index 600b88f85..425812297 100755
--- a/spec/unit/util/metric_spec.rb
+++ b/spec/unit/util/metric_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/metric'
 
diff --git a/spec/unit/util/monkey_patches_spec.rb b/spec/unit/util/monkey_patches_spec.rb
index 049ed1044..8bfcd900e 100644
--- a/spec/unit/util/monkey_patches_spec.rb
+++ b/spec/unit/util/monkey_patches_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/monkey_patches'
 
diff --git a/spec/unit/util/posix_spec.rb b/spec/unit/util/posix_spec.rb
index dbc90d9d0..6d7351220 100755
--- a/spec/unit/util/posix_spec.rb
+++ b/spec/unit/util/posix_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/posix'
 
diff --git a/spec/unit/util/pson_spec.rb b/spec/unit/util/pson_spec.rb
index 474ddafa4..08758ee38 100755
--- a/spec/unit/util/pson_spec.rb
+++ b/spec/unit/util/pson_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/pson'
 
diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index 8545def54..ab54c8cd3 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/resource/type_collection'
 require 'puppet/util/rdoc/parser'
diff --git a/spec/unit/util/rdoc_spec.rb b/spec/unit/util/rdoc_spec.rb
index 93c4f9bfa..3b5248528 100755
--- a/spec/unit/util/rdoc_spec.rb
+++ b/spec/unit/util/rdoc_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/rdoc'
 require 'rdoc/rdoc'
diff --git a/spec/unit/util/user_attr_spec.rb b/spec/unit/util/user_attr_spec.rb
index 61312ef19..5acdaee58 100644
--- a/spec/unit/util/user_attr_spec.rb
+++ b/spec/unit/util/user_attr_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/user_attr'
 
diff --git a/spec/unit/util/zaml_spec.rb b/spec/unit/util/zaml_spec.rb
index 358c6aa11..804aa8e58 100755
--- a/spec/unit/util/zaml_spec.rb
+++ b/spec/unit/util/zaml_spec.rb
@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/util/monkey_patches'
 
-- 
cgit 


From af42367dce6ab1ad18a1a8d10e4d54b5accae449 Mon Sep 17 00:00:00 2001
From: Richard Crowley <r@rcrowley.org>
Date: Tue, 1 Mar 2011 20:44:11 +0000
Subject: (#6527) Added pip package provider.

Python's pip package manager is analogous to RubyGems and should be included in Puppet.

Reviewed-by: Matt Robinson <matt@puppetlabs.com>
---
 lib/puppet/provider/package/pip.rb     | 115 ++++++++++++++++++++
 spec/unit/provider/package/pip_spec.rb | 190 +++++++++++++++++++++++++++++++++
 2 files changed, 305 insertions(+)
 create mode 100644 lib/puppet/provider/package/pip.rb
 create mode 100644 spec/unit/provider/package/pip_spec.rb

diff --git a/lib/puppet/provider/package/pip.rb b/lib/puppet/provider/package/pip.rb
new file mode 100644
index 000000000..00797563a
--- /dev/null
+++ b/lib/puppet/provider/package/pip.rb
@@ -0,0 +1,115 @@
+# Puppet package provider for Python's `pip` package management frontend.
+# <http://pip.openplans.org/>
+
+require 'puppet/provider/package'
+require 'xmlrpc/client'
+
+Puppet::Type.type(:package).provide :pip,
+  :parent => ::Puppet::Provider::Package do
+
+  desc "Python packages via `pip`."
+
+  has_feature :installable, :uninstallable, :upgradeable, :versionable
+
+  # Parse lines of output from `pip freeze`, which are structured as
+  # _package_==_version_.
+  def self.parse(line)
+    if line.chomp =~ /^([^=]+)==([^=]+)$/
+      {:ensure => $2, :name => $1, :provider => name}
+    else
+      nil
+    end
+  end
+
+  # Return an array of structured information about every installed package
+  # that's managed by `pip` or an empty array if `pip` is not available.
+  def self.instances
+    packages = []
+    execpipe "#{command :pip} freeze" do |process|
+      process.collect do |line|
+        next unless options = parse(line)
+        packages << new(options)
+      end
+    end
+    packages
+  rescue Puppet::DevError
+    []
+  end
+
+  # Return structured information about a particular package or `nil` if
+  # it is not installed or `pip` itself is not available.
+  def query
+    execpipe "#{command :pip} freeze" do |process|
+      process.each do |line|
+        options = self.class.parse(line)
+        return options if options[:name] == @resource[:name]
+      end
+    end
+    nil
+  rescue Puppet::DevError
+    nil
+  end
+
+  # Ask the PyPI API for the latest version number.  There is no local
+  # cache of PyPI's package list so this operation will always have to
+  # ask the web service.
+  def latest
+    client = XMLRPC::Client.new2("http://pypi.python.org/pypi")
+    client.http_header_extra = {"Content-Type" => "text/xml"}
+    result = client.call("package_releases", @resource[:name])
+    result.first
+  end
+
+  # Install a package.  The ensure parameter may specify installed,
+  # latest, a version number, or, in conjunction with the source
+  # parameter, an SCM revision.  In that case, the source parameter
+  # gives the fully-qualified URL to the repository.
+  def install
+    args = %w{install -q}
+    if @resource[:source]
+      args << "-e"
+      if String === @resource[:ensure]
+        args << "#{@resource[:source]}@#{@resource[:ensure]}#egg=#{
+          @resource[:name]}"
+      else
+        args << "#{@resource[:source]}#egg=#{@resource[:name]}"
+      end
+    else
+      case @resource[:ensure]
+      when String
+        args << "#{@resource[:name]}==#{@resource[:ensure]}"
+      when :latest
+        args << "--upgrade" << @resource[:name]
+      else
+        args << @resource[:name]
+      end
+    end
+    lazy_pip *args
+  end
+
+  # Uninstall a package.  Uninstall won't work reliably on Debian/Ubuntu
+  # unless this issue gets fixed.
+  # <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544>
+  def uninstall
+    lazy_pip "uninstall", "-y", "-q", @resource[:name]
+  end
+
+  def update
+    install
+  end
+
+  # Execute a `pip` command.  If Puppet doesn't yet know how to do so,
+  # try to teach it and if even that fails, raise the error.
+  private
+  def lazy_pip(*args)
+    pip *args
+  rescue NoMethodError => e
+    if pathname = `which pip`.chomp
+      self.class.commands :pip => pathname
+      pip *args
+    else
+      raise e
+    end
+  end
+
+end
diff --git a/spec/unit/provider/package/pip_spec.rb b/spec/unit/provider/package/pip_spec.rb
new file mode 100644
index 000000000..ad8201aa0
--- /dev/null
+++ b/spec/unit/provider/package/pip_spec.rb
@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+provider_class = Puppet::Type.type(:package).provider(:pip)
+
+describe provider_class do
+
+  before do
+    @resource = stub("resource")
+    @provider = provider_class.new
+    @provider.instance_variable_set(:@resource, @resource)
+  end
+
+  describe "parse" do
+
+    it "should return a hash on valid input" do
+      provider_class.parse("Django==1.2.5").should == {
+        :ensure => "1.2.5",
+        :name => "Django",
+        :provider => :pip,
+      }
+    end
+
+    it "should return nil on invalid input" do
+      provider_class.parse("foo").should == nil
+    end
+
+  end
+
+  describe "instances" do
+
+    it "should return an array when pip is present" do
+      provider_class.expects(:command).with(:pip).returns("/fake/bin/pip")
+      p = stub("process")
+      p.expects(:collect).yields("Django==1.2.5")
+      provider_class.expects(:execpipe).with("/fake/bin/pip freeze").yields(p)
+      provider_class.instances
+    end
+
+    it "should return an empty array when pip is missing" do
+      provider_class.expects(:command).with(:pip).raises(
+        Puppet::DevError.new("Pretend pip isn't installed."))
+      provider_class.instances.should == []
+    end
+
+  end
+
+  describe "query" do
+
+    before do
+      @resource.stubs(:[]).with(:name).returns("Django")
+    end
+
+    it "should return a hash when pip and the package are present" do
+      @provider.expects(:command).with(:pip).returns("/fake/bin/pip")
+      p = stub("process")
+      p.expects(:each).yields("Django==1.2.5")
+      @provider.expects(:execpipe).with("/fake/bin/pip freeze").yields(p)
+      @provider.query.should == {
+        :ensure => "1.2.5",
+        :name => "Django",
+        :provider => :pip,
+      }
+    end
+
+    it "should return nil when pip is missing" do
+      @provider.expects(:command).with(:pip).raises(
+        Puppet::DevError.new("Pretend pip isn't installed."))
+      @provider.query.should == nil
+    end
+
+    it "should return nil when the package is missing" do
+      @provider.expects(:command).with(:pip).returns("/fake/bin/pip")
+      p = stub("process")
+      p.expects(:each).yields("sdsfdssdhdfyjymdgfcjdfjxdrssf==0.0.0")
+      @provider.expects(:execpipe).with("/fake/bin/pip freeze").yields(p)
+      @provider.query.should == nil
+    end
+
+  end
+
+  describe "latest" do
+
+    it "should find a version number for Django" do
+      @resource.stubs(:[]).with(:name).returns "Django"
+      @provider.latest.should_not == nil
+    end
+
+    it "should not find a version number for sdsfdssdhdfyjymdgfcjdfjxdrssf" do
+      @resource.stubs(:[]).with(:name).returns "sdsfdssdhdfyjymdgfcjdfjxdrssf"
+      @provider.latest.should == nil
+    end
+
+  end
+
+  describe "install" do
+
+    before do
+      @resource.stubs(:[]).with(:name).returns("sdsfdssdhdfyjymdgfcjdfjxdrssf")
+      @url = "git+https://example.com/sdsfdssdhdfyjymdgfcjdfjxdrssf.git"
+    end
+
+    it "should install" do
+      @resource.stubs(:[]).with(:ensure).returns(:installed)
+      @resource.stubs(:[]).with(:source).returns(nil)
+      @provider.expects(:lazy_pip).with do |*args|
+        "install" == args[0] && "sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
+      end.returns nil
+      @provider.install
+    end
+
+    it "should install from SCM" do
+      @resource.stubs(:[]).with(:ensure).returns(:installed)
+      @resource.stubs(:[]).with(:source).returns(@url)
+      @provider.expects(:lazy_pip).with do |*args|
+        "#{@url}#egg=sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
+      end.returns nil
+      @provider.install
+    end
+
+    it "should install a particular revision" do
+      @resource.stubs(:[]).with(:ensure).returns("0123456")
+      @resource.stubs(:[]).with(:source).returns(@url)
+      @provider.expects(:lazy_pip).with do |*args|
+        "#{@url}@0123456#egg=sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
+      end.returns nil
+      @provider.install
+    end
+
+    it "should install a particular version" do
+      @resource.stubs(:[]).with(:ensure).returns("0.0.0")
+      @resource.stubs(:[]).with(:source).returns(nil)
+      @provider.expects(:lazy_pip).with do |*args|
+        "sdsfdssdhdfyjymdgfcjdfjxdrssf==0.0.0" == args[-1]
+      end.returns nil
+      @provider.install
+    end
+
+    it "should upgrade" do
+      @resource.stubs(:[]).with(:ensure).returns(:latest)
+      @resource.stubs(:[]).with(:source).returns(nil)
+      @provider.expects(:lazy_pip).with do |*args|
+        "--upgrade" == args[-2] && "sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
+      end.returns nil
+      @provider.install
+    end
+
+  end
+
+  describe "uninstall" do
+
+    it "should uninstall" do
+      @resource.stubs(:[]).with(:name).returns("sdsfdssdhdfyjymdgfcjdfjxdrssf")
+      @provider.expects(:lazy_pip).returns(nil)
+      @provider.uninstall
+    end
+
+  end
+
+  describe "update" do
+
+    it "should just call install" do
+      @provider.expects(:install).returns(nil)
+      @provider.update
+    end
+
+  end
+
+  describe "lazy_pip" do
+
+    it "should succeed if pip is present" do
+      @provider.stubs(:pip).returns(nil)
+      @provider.method(:lazy_pip).call "freeze"
+    end
+
+    it "should retry if pip has not yet been found" do
+      @provider.stubs(:pip).raises(NoMethodError).returns("/fake/bin/pip")
+      @provider.method(:lazy_pip).call "freeze"
+    end
+
+    it "should fail if pip is missing" do
+      @provider.stubs(:pip).twice.raises(NoMethodError)
+      expect { @provider.method(:lazy_pip).call("freeze") }.to \
+        raise_error(NoMethodError)
+    end
+
+  end
+
+end
-- 
cgit 


From 0170cebba039378597fdf9f0086339c2766df408 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 15:28:52 -0700
Subject: (#6527) Fix uninstall problem and refactor

Uninstall wasn't working properly because the instances method relied on
the pip command having been defined by calling lazy_pip.  This lazy_pip
pattern is a nice way of getting around Puppet's problem of
disqualifying providers at the beginning of a run because the command
doesn't yet exist even though part way through the run the command might
exist.

Really, we need to fix puppet to lazily evaluate a provider
command for validity only at the time the provider is needed.

The refactoring also pointed out that query could just reuse the logic
from instances.

The tests were also refactored to use real resources instead of stubbed
ones, and they reflect the implementation changes to instances.

Paired-with: Richard Crowley <r@rcrowley.org>
---
 lib/puppet/provider/package/pip.rb     | 18 +++----
 spec/unit/provider/package/pip_spec.rb | 98 +++++++++++++++-------------------
 2 files changed, 48 insertions(+), 68 deletions(-)

diff --git a/lib/puppet/provider/package/pip.rb b/lib/puppet/provider/package/pip.rb
index 00797563a..5abbc135a 100644
--- a/lib/puppet/provider/package/pip.rb
+++ b/lib/puppet/provider/package/pip.rb
@@ -25,29 +25,23 @@ Puppet::Type.type(:package).provide :pip,
   # that's managed by `pip` or an empty array if `pip` is not available.
   def self.instances
     packages = []
-    execpipe "#{command :pip} freeze" do |process|
+    pip_cmd = which('pip') or return []
+    execpipe "#{pip_cmd} freeze" do |process|
       process.collect do |line|
         next unless options = parse(line)
         packages << new(options)
       end
     end
     packages
-  rescue Puppet::DevError
-    []
   end
 
   # Return structured information about a particular package or `nil` if
   # it is not installed or `pip` itself is not available.
   def query
-    execpipe "#{command :pip} freeze" do |process|
-      process.each do |line|
-        options = self.class.parse(line)
-        return options if options[:name] == @resource[:name]
-      end
+    self.class.instances.each do |provider_pip|
+      return provider_pip.properties if @resource[:name] == provider_pip.name
     end
-    nil
-  rescue Puppet::DevError
-    nil
+    return nil
   end
 
   # Ask the PyPI API for the latest version number.  There is no local
@@ -104,7 +98,7 @@ Puppet::Type.type(:package).provide :pip,
   def lazy_pip(*args)
     pip *args
   rescue NoMethodError => e
-    if pathname = `which pip`.chomp
+    if pathname = which('pip')
       self.class.commands :pip => pathname
       pip *args
     else
diff --git a/spec/unit/provider/package/pip_spec.rb b/spec/unit/provider/package/pip_spec.rb
index ad8201aa0..6809d3f90 100644
--- a/spec/unit/provider/package/pip_spec.rb
+++ b/spec/unit/provider/package/pip_spec.rb
@@ -7,17 +7,16 @@ provider_class = Puppet::Type.type(:package).provider(:pip)
 describe provider_class do
 
   before do
-    @resource = stub("resource")
-    @provider = provider_class.new
-    @provider.instance_variable_set(:@resource, @resource)
+    @resource = Puppet::Resource.new(:package, "sdsfdssdhdfyjymdgfcjdfjxdrssf")
+    @provider = provider_class.new(@resource)
   end
 
   describe "parse" do
 
     it "should return a hash on valid input" do
       provider_class.parse("Django==1.2.5").should == {
-        :ensure => "1.2.5",
-        :name => "Django",
+        :ensure   => "1.2.5",
+        :name     => "Django",
         :provider => :pip,
       }
     end
@@ -31,7 +30,7 @@ describe provider_class do
   describe "instances" do
 
     it "should return an array when pip is present" do
-      provider_class.expects(:command).with(:pip).returns("/fake/bin/pip")
+      provider_class.expects(:which).with('pip').returns("/fake/bin/pip")
       p = stub("process")
       p.expects(:collect).yields("Django==1.2.5")
       provider_class.expects(:execpipe).with("/fake/bin/pip freeze").yields(p)
@@ -39,8 +38,7 @@ describe provider_class do
     end
 
     it "should return an empty array when pip is missing" do
-      provider_class.expects(:command).with(:pip).raises(
-        Puppet::DevError.new("Pretend pip isn't installed."))
+      provider_class.expects(:which).with('pip').returns nil
       provider_class.instances.should == []
     end
 
@@ -49,32 +47,25 @@ describe provider_class do
   describe "query" do
 
     before do
-      @resource.stubs(:[]).with(:name).returns("Django")
+      @resource[:name] = "Django"
     end
 
     it "should return a hash when pip and the package are present" do
-      @provider.expects(:command).with(:pip).returns("/fake/bin/pip")
-      p = stub("process")
-      p.expects(:each).yields("Django==1.2.5")
-      @provider.expects(:execpipe).with("/fake/bin/pip freeze").yields(p)
+      provider_class.expects(:instances).returns [provider_class.new({
+        :ensure   => "1.2.5",
+        :name     => "Django",
+        :provider => :pip,
+      })]
+
       @provider.query.should == {
-        :ensure => "1.2.5",
-        :name => "Django",
+        :ensure   => "1.2.5",
+        :name     => "Django",
         :provider => :pip,
       }
     end
 
-    it "should return nil when pip is missing" do
-      @provider.expects(:command).with(:pip).raises(
-        Puppet::DevError.new("Pretend pip isn't installed."))
-      @provider.query.should == nil
-    end
-
     it "should return nil when the package is missing" do
-      @provider.expects(:command).with(:pip).returns("/fake/bin/pip")
-      p = stub("process")
-      p.expects(:each).yields("sdsfdssdhdfyjymdgfcjdfjxdrssf==0.0.0")
-      @provider.expects(:execpipe).with("/fake/bin/pip freeze").yields(p)
+      provider_class.expects(:instances).returns []
       @provider.query.should == nil
     end
 
@@ -83,12 +74,12 @@ describe provider_class do
   describe "latest" do
 
     it "should find a version number for Django" do
-      @resource.stubs(:[]).with(:name).returns "Django"
+      @resource[:name] = "Django"
       @provider.latest.should_not == nil
     end
 
     it "should not find a version number for sdsfdssdhdfyjymdgfcjdfjxdrssf" do
-      @resource.stubs(:[]).with(:name).returns "sdsfdssdhdfyjymdgfcjdfjxdrssf"
+      @resource[:name] = "sdsfdssdhdfyjymdgfcjdfjxdrssf"
       @provider.latest.should == nil
     end
 
@@ -97,52 +88,46 @@ describe provider_class do
   describe "install" do
 
     before do
-      @resource.stubs(:[]).with(:name).returns("sdsfdssdhdfyjymdgfcjdfjxdrssf")
+      @resource[:name] = "sdsfdssdhdfyjymdgfcjdfjxdrssf"
       @url = "git+https://example.com/sdsfdssdhdfyjymdgfcjdfjxdrssf.git"
     end
 
     it "should install" do
-      @resource.stubs(:[]).with(:ensure).returns(:installed)
-      @resource.stubs(:[]).with(:source).returns(nil)
-      @provider.expects(:lazy_pip).with do |*args|
-        "install" == args[0] && "sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
-      end.returns nil
+      @resource[:ensure] = :installed
+      @resource[:source] = nil
+      @provider.expects(:lazy_pip).
+        with("install", '-q', "sdsfdssdhdfyjymdgfcjdfjxdrssf")
       @provider.install
     end
 
     it "should install from SCM" do
-      @resource.stubs(:[]).with(:ensure).returns(:installed)
-      @resource.stubs(:[]).with(:source).returns(@url)
-      @provider.expects(:lazy_pip).with do |*args|
-        "#{@url}#egg=sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
-      end.returns nil
+      @resource[:ensure] = :installed
+      @resource[:source] = @url
+      @provider.expects(:lazy_pip).
+        with("install", '-q', '-e', "#{@url}#egg=sdsfdssdhdfyjymdgfcjdfjxdrssf")
       @provider.install
     end
 
-    it "should install a particular revision" do
-      @resource.stubs(:[]).with(:ensure).returns("0123456")
-      @resource.stubs(:[]).with(:source).returns(@url)
-      @provider.expects(:lazy_pip).with do |*args|
-        "#{@url}@0123456#egg=sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
-      end.returns nil
+    it "should install a particular SCM revision" do
+      @resource[:ensure] = "0123456"
+      @resource[:source] = @url
+      @provider.expects(:lazy_pip).
+        with("install", "-q", "-e", "#{@url}@0123456#egg=sdsfdssdhdfyjymdgfcjdfjxdrssf")
       @provider.install
     end
 
     it "should install a particular version" do
-      @resource.stubs(:[]).with(:ensure).returns("0.0.0")
-      @resource.stubs(:[]).with(:source).returns(nil)
-      @provider.expects(:lazy_pip).with do |*args|
-        "sdsfdssdhdfyjymdgfcjdfjxdrssf==0.0.0" == args[-1]
-      end.returns nil
+      @resource[:ensure] = "0.0.0"
+      @resource[:source] = nil
+      @provider.expects(:lazy_pip).with("install", "-q", "sdsfdssdhdfyjymdgfcjdfjxdrssf==0.0.0")
       @provider.install
     end
 
     it "should upgrade" do
-      @resource.stubs(:[]).with(:ensure).returns(:latest)
-      @resource.stubs(:[]).with(:source).returns(nil)
-      @provider.expects(:lazy_pip).with do |*args|
-        "--upgrade" == args[-2] && "sdsfdssdhdfyjymdgfcjdfjxdrssf" == args[-1]
-      end.returns nil
+      @resource[:ensure] = :latest
+      @resource[:source] = nil
+      @provider.expects(:lazy_pip).
+        with("install", "-q", "--upgrade", "sdsfdssdhdfyjymdgfcjdfjxdrssf")
       @provider.install
     end
 
@@ -151,8 +136,9 @@ describe provider_class do
   describe "uninstall" do
 
     it "should uninstall" do
-      @resource.stubs(:[]).with(:name).returns("sdsfdssdhdfyjymdgfcjdfjxdrssf")
-      @provider.expects(:lazy_pip).returns(nil)
+      @resource[:name] = "sdsfdssdhdfyjymdgfcjdfjxdrssf"
+      @provider.expects(:lazy_pip).
+        with('uninstall', '-y', '-q', 'sdsfdssdhdfyjymdgfcjdfjxdrssf')
       @provider.uninstall
     end
 
-- 
cgit 


From 61803976a835a039784cb199fe1e3957fd9cb64a Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 16:40:51 -0700
Subject: (#6527) Fix pip tests

The testing of lazypip forgot to stub which, so they worked when pip was
installed, but didn't work when it wasn't.  Appropriate stubbing has
been put in place, and stubs changed to expects for some stronger
assertions about what's happening.

Reviewed-by: Jesse Wolfe <jesse@puppetlabs.com>
---
 spec/unit/provider/package/pip_spec.rb | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/spec/unit/provider/package/pip_spec.rb b/spec/unit/provider/package/pip_spec.rb
index 6809d3f90..8953b4b2c 100644
--- a/spec/unit/provider/package/pip_spec.rb
+++ b/spec/unit/provider/package/pip_spec.rb
@@ -161,14 +161,15 @@ describe provider_class do
     end
 
     it "should retry if pip has not yet been found" do
-      @provider.stubs(:pip).raises(NoMethodError).returns("/fake/bin/pip")
+      @provider.expects(:pip).twice.with('freeze').raises(NoMethodError).then.returns(nil)
+      @provider.expects(:which).with('pip').returns("/fake/bin/pip")
       @provider.method(:lazy_pip).call "freeze"
     end
 
     it "should fail if pip is missing" do
-      @provider.stubs(:pip).twice.raises(NoMethodError)
-      expect { @provider.method(:lazy_pip).call("freeze") }.to \
-        raise_error(NoMethodError)
+      @provider.expects(:pip).with('freeze').raises(NoMethodError)
+      @provider.expects(:which).with('pip').returns(nil)
+      expect { @provider.method(:lazy_pip).call("freeze") }.to raise_error(NoMethodError)
     end
 
   end
-- 
cgit 


From 3d43d866d6629863d91861f29638c1a31750ba57 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 22:28:27 -0700
Subject: (#2782) Fix constant_defined?

Thanks to Al Hoang for the bit of code for choosing how to use
constant_defined? depending on the version of Ruby.

In Ruby 1.9 const_defined? has a new parameter for inherit (from Ruby docs)

mod.const_defined?(sym, inherit=true) -> true or false
Returns true if a constant with the given name is defined by mod, or its
ancestors if inherit is not false.

Unfortunately, the documentation isn't terribly clear about the behavior
if inherit=false.  In Ruby 1.8 the inherit parameter doesn't exist.  It
appears that setting inherit=false makes it behave like it used to in
Ruby 1.8, but there may be sublties of autoloading that prove this wrong
or ways in which were setting constants that changed and cause problems
regardless of the behavior of const_defined?

Ruby 1.8.7:
irb(main):001:0> module Foo
irb(main):002:1>   end
=> nil
irb(main):003:0> A = 'find_me?'
=> "find_me?"
irb(main):004:0> Foo.const_defined?('A')
=> false

Ruby 1.9.2:
ruby-1.9.2-p136 :001 > module Foo
ruby-1.9.2-p136 :002?>   end
=> nil
ruby-1.9.2-p136 :003 > A = 'find_me?'
=> "find_me?"
ruby-1.9.2-p136 :004 > Foo.const_defined?('A')
=> true
ruby-1.9.2-p136 :005 > Foo.const_defined?('A', false)
=> false

Also noteworthy is that something about constants behavior changed
between 1.9.1 and 1.9.2, though not in regard to the little test above,
but we should only be testing against 1.9.2 anyway.

At least with this change in we'll be able to start debugging test
failures instead of just getting failures at the level of syntax errors.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 lib/puppet/util/classgen.rb | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/lib/puppet/util/classgen.rb b/lib/puppet/util/classgen.rb
index ed69c5878..1e99aa873 100644
--- a/lib/puppet/util/classgen.rb
+++ b/lib/puppet/util/classgen.rb
@@ -124,11 +124,23 @@ module Puppet::Util::ClassGen
     klass
   end
 
+  # const_defined? in Ruby 1.9 behaves differently in terms
+  # of which class hierarchy it polls for nested namespaces
+  #
+  # See http://redmine.ruby-lang.org/issues/show/1915
+  def is_constant_defined?(const)
+    if ::RUBY_VERSION =~ /1.9/
+      const_defined?(const, false)
+    else
+      const_defined?(const)
+    end
+  end
+
   # Handle the setting and/or removing of the associated constant.
   def handleclassconst(klass, name, options)
     const = genconst_string(name, options)
 
-    if const_defined?(const)
+    if is_constant_defined?(const)
       if options[:overwrite]
         Puppet.info "Redefining #{name} in #{self}"
         remove_const(const)
-- 
cgit 


From 341654ea16e662e31bb97ca260397939ac34692e Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 22:31:47 -0700
Subject: (#6820) Fix invalid next that should be a return

The old code under ruby 1.8.7 if it was hit would result in:

unexpected next (LocalJumpError)

In Ruby 1.9 it doesn't even give you the chance to run the code since
you get:

compile error (SyntaxError)

The code isn't tested so the intented behavior isn't clear, but in
context this looks like the right change.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 lib/puppet/provider/service/daemontools.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/puppet/provider/service/daemontools.rb b/lib/puppet/provider/service/daemontools.rb
index bbb962a71..f5a073329 100644
--- a/lib/puppet/provider/service/daemontools.rb
+++ b/lib/puppet/provider/service/daemontools.rb
@@ -67,7 +67,7 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
     path = self.defpath
     unless FileTest.directory?(path)
       Puppet.notice "Service path #{path} does not exist"
-      next
+      return
     end
 
     # reject entries that aren't either a directory
-- 
cgit 


From 7a4fcf2835ac414fe3c5b1b4e4b16c13a2c92d09 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 22:48:17 -0700
Subject: (#6820) Fix RDOC parser to work with Ruby 1.9

Lovely RDOC changed where it put everything in Ruby 1.9.  Now there's
some conditional logic depending on Ruby version to determine which
files to requrie. The tests still fail, but at least they run now.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 lib/puppet/util/rdoc/parser.rb | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/lib/puppet/util/rdoc/parser.rb b/lib/puppet/util/rdoc/parser.rb
index 0f746e2ea..762ce25f0 100644
--- a/lib/puppet/util/rdoc/parser.rb
+++ b/lib/puppet/util/rdoc/parser.rb
@@ -7,13 +7,19 @@
 require "rdoc/code_objects"
 require "puppet/util/rdoc/code_objects"
 require "rdoc/tokenstream"
-require "rdoc/markup/simple_markup/preprocess"
-require "rdoc/parsers/parserfactory"
+
+if ::RUBY_VERSION =~ /1.9/
+	require "rdoc/markup/preprocess"
+	require "rdoc/parser"
+else
+	require "rdoc/markup/simple_markup/preprocess"
+	require "rdoc/parsers/parserfactory"
+end
 
 module RDoc
 
 class Parser
-  extend ParserFactory
+  extend ParserFactory unless ::RUBY_VERSION =~ /1.9/
 
   SITE = "__site__"
 
-- 
cgit 


From 054eac6a66113eca3704f26a341aa873162782bb Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 22:51:34 -0700
Subject: (#6820) Fix Invalid multibyte character
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

puppet/spec/unit/network/authstore_spec.rb:89:
invalid multibyte char (US-ASCII)
puppet/spec/unit/network/authstore_spec.rb:89:
syntax error, unexpected $end, expecting ']'
    " 2001:0000:1234:0000:0000:C1C0:ABCD:0876  0",
                                                   ^

There was a non-breaking space (HEX A0) in that line because according
to Markus (who made the original commit), these test lines were copy
pasted from a web page.  The intent wasn't to test non-breaking speace
chacters for IPV6.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 spec/unit/network/authstore_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec/unit/network/authstore_spec.rb b/spec/unit/network/authstore_spec.rb
index 0b4dd21de..d477ee301 100644
--- a/spec/unit/network/authstore_spec.rb
+++ b/spec/unit/network/authstore_spec.rb
@@ -86,7 +86,7 @@ describe Puppet::Network::AuthStore::Declaration do
   [
     "02001:0000:1234:0000:0000:C1C0:ABCD:0876",
     "2001:0000:1234:0000:00001:C1C0:ABCD:0876",
-    " 2001:0000:1234:0000:0000:C1C0:ABCD:0876  0",
+    " 2001:0000:1234:0000:0000:C1C0:ABCD:0876  0",
     "2001:0000:1234: 0000:0000:C1C0:ABCD:0876",
     "3ffe:0b00:0000:0001:0000:0000:000a",
     "FF02:0000:0000:0000:0000:0000:0000:0000:0001",
-- 
cgit 


From 8c32db76f68148b2e58ba744b965a3c8cd8f1663 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 22:56:46 -0700
Subject: (#6820) Fix nagios parser to use proper hash syntax for Ruby 1.9

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 lib/puppet/external/nagios/parser.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/puppet/external/nagios/parser.rb b/lib/puppet/external/nagios/parser.rb
index 5504f5818..17db5e307 100644
--- a/lib/puppet/external/nagios/parser.rb
+++ b/lib/puppet/external/nagios/parser.rb
@@ -753,7 +753,7 @@ module_eval <<'.,.,', 'grammar.ry', 40
 
 module_eval <<'.,.,', 'grammar.ry', 42
   def _reduce_10( val, _values, result )
-result = {val[0],val[1]}
+result = {val[0] => val[1]}
   result
 end
 .,.,
-- 
cgit 


From 36a5665f3e0aeb8b9141cb8be2f69f8568078986 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 22 Mar 2011 23:07:56 -0700
Subject: (#6820) Fix File class lookup in the file type for Ruby 1.9

Was getting the following error when we simply called File.dirname

err: Got an uncaught exception of type NoMethodError: undefined method
`dirname' for Puppet::Type::File:Class

The constant lookup has changed in Ruby 1.9 to look at local scopes
first, so we need to make it clearer that File is the Ruby File class
and not something scoped in Puppet.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 lib/puppet/type/file.rb | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/lib/puppet/type/file.rb b/lib/puppet/type/file.rb
index 16b1f962d..1a6d0c3ac 100644
--- a/lib/puppet/type/file.rb
+++ b/lib/puppet/type/file.rb
@@ -44,7 +44,7 @@ Puppet::Type.newtype(:file) do
     # convert the current path in an index into the collection and the last
     # path name. The aim is to use less storage for all common paths in a hierarchy
     munge do |value|
-      path, name = File.split(value.gsub(/\/+/,'/'))
+      path, name = ::File.split(value.gsub(/\/+/,'/'))
       { :index => Puppet::FileCollection.collection.index(path), :name => name }
     end
 
@@ -55,7 +55,7 @@ Puppet::Type.newtype(:file) do
       if value[:name] == '/'
         basedir
       else
-        File.join( basedir, value[:name] )
+        ::File.join( basedir, value[:name] )
       end
     end
   end
@@ -248,7 +248,7 @@ Puppet::Type.newtype(:file) do
 
   # Autorequire any parent directories.
   autorequire(:file) do
-    basedir = File.dirname(self[:path])
+    basedir = ::File.dirname(self[:path])
     if basedir != self[:path]
       basedir
     else
@@ -309,7 +309,7 @@ Puppet::Type.newtype(:file) do
   def asuser
     if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
       writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
-        FileTest.writable?(File.dirname(self[:path]))
+        FileTest.writable?(::File.dirname(self[:path]))
       }
 
       # If the parent directory is writeable, then we execute
@@ -412,7 +412,7 @@ Puppet::Type.newtype(:file) do
   # Create a new file or directory object as a child to the current
   # object.
   def newchild(path)
-    full_path = File.join(self[:path], path)
+    full_path = ::File.join(self[:path], path)
 
     # Add some new values to our original arguments -- these are the ones
     # set at initialization.  We specifically want to exclude any param
@@ -486,16 +486,16 @@ Puppet::Type.newtype(:file) do
   # not likely to have many actual conflicts, which is good, because
   # this is a pretty inefficient implementation.
   def remove_less_specific_files(files)
-    mypath = self[:path].split(File::Separator)
+    mypath = self[:path].split(::File::Separator)
     other_paths = catalog.vertices.
       select  { |r| r.is_a?(self.class) and r[:path] != self[:path] }.
-      collect { |r| r[:path].split(File::Separator) }.
+      collect { |r| r[:path].split(::File::Separator) }.
       select  { |p| p[0,mypath.length]  == mypath }
 
     return files if other_paths.empty?
 
     files.reject { |file|
-      path = file[:path].split(File::Separator)
+      path = file[:path].split(::File::Separator)
       other_paths.any? { |p| path[0,p.length] == p }
       }
   end
@@ -612,7 +612,7 @@ Puppet::Type.newtype(:file) do
       end
     when "link", "file"
       debug "Removing existing #{s.ftype} for replacement with #{should}"
-      File.unlink(self[:path])
+      ::File.unlink(self[:path])
     else
       self.fail "Could not back up files of type #{s.ftype}"
     end
@@ -677,7 +677,7 @@ Puppet::Type.newtype(:file) do
     path = self[:path]
 
     begin
-      File.send(method, self[:path])
+      ::File.send(method, self[:path])
     rescue Errno::ENOENT => error
       return nil
     rescue Errno::EACCES => error
@@ -703,7 +703,7 @@ Puppet::Type.newtype(:file) do
     use_temporary_file = write_temporary_file?
     if use_temporary_file
       path = "#{self[:path]}.puppettmp_#{rand(10000)}"
-      path = "#{self[:path]}.puppettmp_#{rand(10000)}" while File.exists?(path) or File.symlink?(path)
+      path = "#{self[:path]}.puppettmp_#{rand(10000)}" while ::File.exists?(path) or ::File.symlink?(path)
     else
       path = self[:path]
     end
@@ -712,18 +712,18 @@ Puppet::Type.newtype(:file) do
     umask = mode ? 000 : 022
     mode_int = mode ? mode.to_i(8) : nil
 
-    content_checksum = Puppet::Util.withumask(umask) { File.open(path, 'w', mode_int ) { |f| write_content(f) } }
+    content_checksum = Puppet::Util.withumask(umask) { ::File.open(path, 'w', mode_int ) { |f| write_content(f) } }
 
     # And put our new file in place
     if use_temporary_file # This is only not true when our file is empty.
       begin
         fail_if_checksum_is_wrong(path, content_checksum) if validate_checksum?
-        File.rename(path, self[:path])
+        ::File.rename(path, self[:path])
       rescue => detail
         fail "Could not rename temporary file #{path} to #{self[:path]}: #{detail}"
       ensure
         # Make sure the created file gets removed
-        File.unlink(path) if FileTest.exists?(path)
+        ::File.unlink(path) if FileTest.exists?(path)
       end
     end
 
-- 
cgit