puppet 2.7.9 → 2.7.11

data/spec/unit/util/rdoc/parser_spec.rb

@@ -135,7 +135,7 @@ describe RDoc::Parser, :'fails_on_ruby_1.9.2' => true do
 
   describe "when finding modules from filepath" do
     before :each do
-      Puppet::Module.stubs(:modulepath).returns("/path/to/modules")
+      Puppet::Node::Environment.any_instance.stubs(:modulepath).returns("/path/to/modules")
     end
 
     it "should return the module name for modulized puppet manifests" do

data/spec/unit/util/reference_spec.rb

@@ -8,20 +8,30 @@ describe Puppet::Util::Reference do
     Puppet::Util::Reference.newreference :testreference, :doc => "A peer of the type and configuration references, but with no useful information" do
       my_term = "A term"
       my_definition = <<-EOT
-The definition of this term.
-We should be able to handle multi-line definitions.
+        The definition of this term, marked by a colon and a space.
+        We should be able to handle multi-line definitions. Each subsequent
+        line should left-align with the first word character after the colon
+        used as the definition marker.
 
-We should be able to handle multi-paragraph definitions.
+        We should be able to handle multi-paragraph definitions.
+
+        Leading indentation should be stripped from the definition, which allows
+        us to indent the source string for cosmetic purposes.
       EOT
       my_fragment = markdown_definitionlist(my_term, my_definition)
     end
     Puppet::Util::Reference.reference(:testreference).send(:to_markdown, true)
     my_fragment.should == <<-EOT
 A term
-: The definition of this term.
-    We should be able to handle multi-line definitions.
+: The definition of this term, marked by a colon and a space.
+  We should be able to handle multi-line definitions. Each subsequent
+  line should left-align with the first word character after the colon
+  used as the definition marker.
+
+  We should be able to handle multi-paragraph definitions.
 
-    We should be able to handle multi-paragraph definitions.
+  Leading indentation should be stripped from the definition, which allows
+  us to indent the source string for cosmetic purposes.
 
     EOT
   end

data/spec/unit/util/retryaction_spec.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/retryaction'
+
+describe Puppet::Util::RetryAction do
+  let (:exceptions) {{ Puppet::Error => 'Puppet Error Exception' }}
+
+  it 'should retry on any exception if no acceptable exceptions given' do
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 2) -1) * 0.1) )
+
+    expect do
+      Puppet::Util::RetryAction.retry_action( :retries => 2 ) do
+        raise ArgumentError, 'Fake Failure'
+      end
+    end.to raise_exception(Puppet::Util::RetryAction::RetryException::RetriesExceeded)
+  end
+
+  it 'should retry on acceptable exceptions' do
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
+    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 2) -1) * 0.1) )
+
+    expect do
+      Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
+        raise Puppet::Error, 'Fake Failure'
+      end
+    end.to raise_exception(Puppet::Util::RetryAction::RetryException::RetriesExceeded)
+  end
+
+  it 'should not retry on unacceptable exceptions' do
+    Puppet::Util::RetryAction.expects(:sleep).never
+
+    expect do
+      Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
+        raise ArgumentError
+      end
+    end.to raise_exception(ArgumentError)
+  end
+
+  it 'should succeed if nothing is raised' do
+    Puppet::Util::RetryAction.expects(:sleep).never
+
+    Puppet::Util::RetryAction.retry_action( :retries => 2) do
+      true
+    end
+  end
+
+  it 'should succeed if an expected exception is raised retried and succeeds' do
+    should_retry = nil
+    Puppet::Util::RetryAction.expects(:sleep).once
+
+    Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
+      if should_retry
+        true
+      else
+        should_retry = true
+        raise Puppet::Error, 'Fake error'
+      end
+    end
+  end
+end

data/spec/unit/util/suidmanager_spec.rb

@@ -13,10 +13,18 @@ describe Puppet::Util::SUIDManager do
 
   before :each do
     Puppet::Util::SUIDManager.stubs(:convert_xid).returns(42)
-    Puppet::Util::SUIDManager.stubs(:initgroups)
+    pwent = stub('pwent', :name => 'fred', :uid => 42, :gid => 42)
+    Etc.stubs(:getpwuid).with(42).returns(pwent)
 
     [:euid, :egid, :uid, :gid, :groups].each do |id|
-      Process.stubs("#{id}=").with {|value| xids[id] = value}
+      Process.stubs("#{id}=").with {|value| xids[id] = value }
+    end
+  end
+
+  describe "#initgroups" do
+    it "should use the primary group of the user as the 'basegid'" do
+      Process.expects(:initgroups).with('fred', 42)
+      described_class.initgroups(42)
     end
   end
 
@@ -31,40 +39,88 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#asuser" do
-    it "should set euid/egid when root" do
-      Process.stubs(:uid).returns(0)
+    it "should not get or set euid/egid when not root" do
       Puppet.features.stubs(:microsoft_windows?).returns(false)
+      Process.stubs(:uid).returns(1)
 
       Process.stubs(:egid).returns(51)
       Process.stubs(:euid).returns(50)
 
-      Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
-      Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
+      Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
-      yielded = false
-      Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) do
-        xids[:egid].should == user[:gid]
-        xids[:euid].should == user[:uid]
-        yielded = true
+      xids.should be_empty
+    end
+
+    context "when root and not windows" do
+      before :each do
+        Process.stubs(:uid).returns(0)
+        Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
-      xids[:egid].should == 51
-      xids[:euid].should == 50
+      it "should set euid/egid when root" do
+        Process.stubs(:uid).returns(0)
 
-      # It's possible asuser could simply not yield, so the assertions in the
-      # block wouldn't fail. So verify those actually got checked.
-      yielded.should be_true
-    end
+        Process.stubs(:egid).returns(51)
+        Process.stubs(:euid).returns(50)
 
-    it "should not get or set euid/egid when not root" do
-      Process.stubs(:uid).returns(1)
+        Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
+        Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
+        Puppet::Util::SUIDManager.stubs(:initgroups).returns([])
 
-      Process.stubs(:egid).returns(51)
-      Process.stubs(:euid).returns(50)
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) do
+          xids[:egid].should == user[:gid]
+          xids[:euid].should == user[:uid]
+          yielded = true
+        end
 
-      Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
+        xids[:egid].should == 51
+        xids[:euid].should == 50
 
-      xids.should be_empty
+        # It's possible asuser could simply not yield, so the assertions in the
+        # block wouldn't fail. So verify those actually got checked.
+        yielded.should be_true
+      end
+
+      it "should just yield if user and group are nil" do
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(nil, nil) { yielded = true }
+        yielded.should be_true
+        xids.should == {}
+      end
+
+      it "should just change group if only group is given" do
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(nil, 42) { yielded = true }
+        yielded.should be_true
+        xids.should == { :egid => 42 }
+      end
+
+      it "should change gid to the primary group of uid by default" do
+        Process.stubs(:initgroups)
+
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(42) { yielded = true }
+        yielded.should be_true
+        xids.should == { :euid => 42, :egid => 42 }
+      end
+
+      it "should change both uid and gid if given" do
+        # I don't like the sequence, but it is the only way to assert on the
+        # internal behaviour in a reliable fashion, given we need multiple
+        # sequenced calls to the same methods. --daniel 2012-02-05
+        horror = sequence('of user and group changes')
+        Puppet::Util::SUIDManager.expects(:change_group).with(43, false).in_sequence(horror)
+        Puppet::Util::SUIDManager.expects(:change_user).with(42, false).in_sequence(horror)
+        Puppet::Util::SUIDManager.expects(:change_group).
+          with(Puppet::Util::SUIDManager.egid, false).in_sequence(horror)
+        Puppet::Util::SUIDManager.expects(:change_user).
+          with(Puppet::Util::SUIDManager.euid, false).in_sequence(horror)
+
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(42, 43) { yielded = true }
+        yielded.should be_true
+      end
     end
 
     it "should not get or set euid/egid on Windows" do
@@ -78,7 +134,7 @@ describe Puppet::Util::SUIDManager do
 
   describe "#change_group" do
     describe "when changing permanently" do
-      it "should try to change_privilege if it is supported" do
+      it "should change_privilege" do
         Process::GID.expects(:change_privilege).with do |gid|
           Process.gid = gid
           Process.egid = gid
@@ -89,15 +145,6 @@ describe Puppet::Util::SUIDManager do
         xids[:egid].should == 42
         xids[:gid].should == 42
       end
-
-      it "should change both egid and gid if change_privilege isn't supported" do
-        Process::GID.stubs(:change_privilege).raises(NotImplementedError)
-
-        Puppet::Util::SUIDManager.change_group(42, true)
-
-        xids[:egid].should == 42
-        xids[:gid].should == 42
-      end
     end
 
     describe "when changing temporarily" do
@@ -112,21 +159,12 @@ describe Puppet::Util::SUIDManager do
 
   describe "#change_user" do
     describe "when changing permanently" do
-      it "should try to change_privilege if it is supported" do
+      it "should change_privilege" do
         Process::UID.expects(:change_privilege).with do |uid|
           Process.uid = uid
           Process.euid = uid
         end
 
-        Puppet::Util::SUIDManager.change_user(42, true)
-
-        xids[:euid].should == 42
-        xids[:uid].should == 42
-      end
-
-      it "should change euid and uid and groups if change_privilege isn't supported" do
-        Process::UID.stubs(:change_privilege).raises(NotImplementedError)
-
         Puppet::Util::SUIDManager.expects(:initgroups).with(42)
 
         Puppet::Util::SUIDManager.change_user(42, true)
@@ -138,6 +176,7 @@ describe Puppet::Util::SUIDManager do
 
     describe "when changing temporarily" do
       it "should change only euid and groups" do
+        Puppet::Util::SUIDManager.stubs(:initgroups).returns([])
         Puppet::Util::SUIDManager.change_user(42, false)
 
         xids[:euid].should == 42
@@ -174,46 +213,6 @@ describe Puppet::Util::SUIDManager do
       Kernel.system '' if $CHILD_STATUS.nil?
     end
 
-    describe "with #system" do
-      it "should set euid/egid when root" do
-        Process.stubs(:uid).returns(0)
-        Puppet.features.stubs(:microsoft_windows?).returns(false)
-
-        Process.stubs(:egid).returns(51)
-        Process.stubs(:euid).returns(50)
-
-        Puppet::Util::SUIDManager.stubs(:convert_xid).with(:gid, 51).returns(51)
-        Puppet::Util::SUIDManager.stubs(:convert_xid).with(:uid, 50).returns(50)
-
-        Puppet::Util::SUIDManager.expects(:change_group).with(user[:uid])
-        Puppet::Util::SUIDManager.expects(:change_user).with(user[:uid])
-
-        Puppet::Util::SUIDManager.expects(:change_group).with(51)
-        Puppet::Util::SUIDManager.expects(:change_user).with(50)
-
-        Kernel.expects(:system).with('blah')
-        Puppet::Util::SUIDManager.system('blah', user[:uid], user[:gid])
-      end
-
-      it "should not get or set euid/egid when not root" do
-        Process.stubs(:uid).returns(1)
-        Kernel.expects(:system).with('blah')
-
-        Puppet::Util::SUIDManager.system('blah', user[:uid], user[:gid])
-
-        xids.should be_empty
-      end
-
-      it "should not get or set euid/egid on Windows" do
-        Puppet.features.stubs(:microsoft_windows?).returns true
-        Kernel.expects(:system).with('blah')
-
-        Puppet::Util::SUIDManager.system('blah', user[:uid], user[:gid])
-
-        xids.should be_empty
-      end
-    end
-
     describe "with #run_and_capture" do
       it "should capture the output and return process status" do
         Puppet::Util.
@@ -308,3 +307,22 @@ describe Puppet::Util::SUIDManager do
     end
   end
 end
+
+describe 'Puppet::Util::SUIDManager#groups=' do
+  subject do
+    Puppet::Util::SUIDManager
+  end
+
+
+  it "(#3419) should rescue Errno::EINVAL on OS X" do
+    Process.expects(:groups=).raises(Errno::EINVAL, 'blew up')
+    subject.expects(:osx_maj_ver).returns('10.7').twice
+    subject.groups = ['list', 'of', 'groups']
+  end
+
+  it "(#3419) should fail if an Errno::EINVAL is raised NOT on OS X" do
+    Process.expects(:groups=).raises(Errno::EINVAL, 'blew up')
+    subject.expects(:osx_maj_ver).returns(false)
+    expect { subject.groups = ['list', 'of', 'groups'] }.should raise_error(Errno::EINVAL)
+  end
+end

data/spec/unit/util/symbolic_file_mode_spec.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/symbolic_file_mode'
+
+describe Puppet::Util::SymbolicFileMode do
+  include Puppet::Util::SymbolicFileMode
+
+  describe "#valid_symbolic_mode?" do
+    %w{
+         0  0000  1  1  7  11  77  111  777  11
+         0 00000 01 01 07 011 077 0111 0777 011
+         = - + u= g= o= a= u+ g+ o+ a+ u- g- o- a- ugo= ugoa= ugugug=
+         a=,u=,g= a=,g+
+         =rwx +rwx -rwx
+         644 go-w =rw,+X +X 755 u=rwx,go=rx u=rwx,go=u-w go= g=u-w
+         755 0755
+    }.each do |input|
+      it "should treat #{input.inspect} as valid" do
+        valid_symbolic_mode?(input).should be_true
+      end
+    end
+
+    [0000, 0111, 0640, 0755, 0777].each do |input|
+      it "should treat the int #{input.to_s(8)} as value" do
+        valid_symbolic_mode?(input).should be_true
+      end
+    end
+
+    %w{
+          -1  -8  8  9  18  19  91  81  000000  11111  77777
+         0-1 0-8 08 09 018 019 091 081 0000000 011111 077777
+         u g o a ug uo ua ag
+    }.each do |input|
+      it "should treat #{input.inspect} as invalid" do
+        valid_symbolic_mode?(input).should be_false
+      end
+    end
+  end
+
+  describe "#normalize_symbolic_mode" do
+    it "should turn an int into a string" do
+      normalize_symbolic_mode(12).should be_an_instance_of String
+    end
+
+    it "should not add a leading zero to an int" do
+      normalize_symbolic_mode(12).should_not =~ /^0/
+    end
+
+    it "should not add a leading zero to a string with a number" do
+      normalize_symbolic_mode("12").should_not =~ /^0/
+    end
+
+    it "should string a leading zero from a number" do
+      normalize_symbolic_mode("012").should == '12'
+    end
+
+    it "should pass through any other string" do
+      normalize_symbolic_mode("u=rwx").should == 'u=rwx'
+    end
+  end
+
+  describe "#symbolic_mode_to_int" do
+    {
+      "0654"            => 00654,
+      "u+r"             => 00400,
+      "g+r"             => 00040,
+      "a+r"             => 00444,
+      "a+x"             => 00111,
+      "o+t"             => 01000,
+      "o+t"             => 01000,
+      ["o-t", 07777]    => 06777,
+      ["a-x", 07777]    => 07666,
+      ["a-rwx", 07777]  => 07000,
+      ["ug-rwx", 07777] => 07007,
+      "a+x,ug-rwx"      => 00001,
+      # My experimentation on debian suggests that +g ignores the sgid flag
+      ["a+g", 02060]    => 02666,
+      # My experimentation on debian suggests that -g ignores the sgid flag
+      ["a-g", 02666]    => 02000,
+      "g+x,a+g"         => 00111,
+      # +X without exec set in the original should not set anything
+      "u+x,g+X"         => 00100,
+      "g+X"             => 00000,
+      # +X only refers to the original, *unmodified* file mode!
+      ["u+x,a+X", 0600] => 00700,
+      # Examples from the MacOS chmod(1) manpage
+      "0644"            => 00644,
+      ["go-w", 07777]   => 07755,
+      ["=rw,+X", 07777] => 07777,
+      ["=rw,+X", 07766] => 07777,
+      ["=rw,+X", 07676] => 07777,
+      ["=rw,+X", 07667] => 07777,
+      ["=rw,+X", 07666] => 07666,
+      "0755"            => 00755,
+      "u=rwx,go=rx"     => 00755,
+      "u=rwx,go=u-w"    => 00755,
+      ["go=", 07777]    => 07700,
+      ["g=u-w", 07777]  => 07757,
+      ["g=u-w", 00700]  => 00750,
+      ["g=u-w", 00600]  => 00640,
+      ["g=u-w", 00500]  => 00550,
+      ["g=u-w", 00400]  => 00440,
+      ["g=u-w", 00300]  => 00310,
+      ["g=u-w", 00200]  => 00200,
+      ["g=u-w", 00100]  => 00110,
+      ["g=u-w", 00000]  => 00000,
+      # Cruel, but legal, use of the action set.
+      ["g=u+r-w", 0300] => 00350,
+      # Empty assignments.
+      ["u=",  00000]    => 00000,
+      ["u=",  00600]    => 00000,
+      ["ug=", 00000]    => 00000,
+      ["ug=", 00600]    => 00000,
+      ["ug=", 00660]    => 00000,
+      ["ug=", 00666]    => 00006,
+      ["=",   00000]    => 00000,
+      ["=",   00666]    => 00000,
+      ["+",   00000]    => 00000,
+      ["+",   00124]    => 00124,
+      ["-",   00000]    => 00000,
+      ["-",   00124]    => 00124,
+    }.each do |input, result|
+      from = input.is_a?(Array) ? "#{input[0]}, 0#{input[1].to_s(8)}" : input
+      it "should map #{from.inspect} to #{result.inspect}" do
+        symbolic_mode_to_int(*input).should == result
+      end
+    end
+
+    # Now, test some failure modes.
+    it "should fail if no mode is given" do
+      expect { symbolic_mode_to_int('') }.
+        to raise_error Puppet::Error, /empty mode string/
+    end
+
+    %w{u g o ug uo go ugo a uu u/x u!x u=r,,g=r}.each do |input|
+      it "should fail if no (valid) action is given: #{input.inspect}" do
+        expect { symbolic_mode_to_int(input) }.
+          to raise_error Puppet::Error, /Missing action/
+      end
+    end
+
+    %w{u+q u-rwF u+rw,g+rw,o+RW}.each do |input|
+      it "should fail with unknown op #{input.inspect}" do
+        expect { symbolic_mode_to_int(input) }.
+          to raise_error Puppet::Error, /Unknown operation/
+      end
+    end
+
+    it "should refuse to subtract the conditional execute op" do
+      expect { symbolic_mode_to_int("o-rwX") }.
+        to raise_error Puppet::Error, /only works with/
+    end
+
+    it "should refuse to set to the conditional execute op" do
+      expect { symbolic_mode_to_int("o=rwX") }.
+        to raise_error Puppet::Error, /only works with/
+    end
+
+    %w{8 08 9 09 118 119}.each do |input|
+      it "should fail for decimal modes: #{input.inspect}" do
+        expect { symbolic_mode_to_int(input) }.
+          to raise_error Puppet::Error, /octal/
+      end
+    end
+
+    it "should set the execute bit on a directory, without exec in original" do
+      symbolic_mode_to_int("u+X", 0444, true).to_s(8).should == "544"
+      symbolic_mode_to_int("g+X", 0444, true).to_s(8).should == "454"
+      symbolic_mode_to_int("o+X", 0444, true).to_s(8).should == "445"
+      symbolic_mode_to_int("+X",  0444, true).to_s(8).should == "555"
+    end
+
+    it "should set the execute bit on a file with exec in the original" do
+      symbolic_mode_to_int("+X", 0544).to_s(8).should == "555"
+    end
+
+    it "should not set the execute bit on a file without exec on the original even if set by earlier DSL" do
+      symbolic_mode_to_int("u+x,go+X", 0444).to_s(8).should == "544"
+    end
+  end
+end