puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/type/exec_spec.rb

@@ -318,6 +318,17 @@ describe Puppet::Type.type(:exec) do
     end
   end
 
+  describe "when setting command" do
+    subject { described_class.new(:name => @command) }
+    it "fails when passed an Array" do
+      expect { subject[:command] = [] }.to raise_error Puppet::Error, /Command must be a String/
+    end
+
+    it "fails when passed a Hash" do
+      expect { subject[:command] = {} }.to raise_error Puppet::Error, /Command must be a String/
+    end
+  end
+
   describe "when setting refresh" do
     it_should_behave_like "all exec command parameters", :refresh
   end

data/spec/unit/type/file/content_spec.rb

@@ -162,36 +162,36 @@ describe content do
     describe "and the file exists" do
       before do
         @resource.stubs(:stat).returns mock("stat")
+        @content.should = "some content"
       end
 
       it "should return false if the current contents are different from the desired content" do
-        @content.should = "some content"
         @content.should_not be_safe_insync("other content")
       end
 
       it "should return true if the sum for the current contents is the same as the sum for the desired content" do
-        @content.should = "some content"
         @content.must be_safe_insync("{md5}" + Digest::MD5.hexdigest("some content"))
       end
 
-      describe "and Puppet[:show_diff] is set" do
-        before do
-          Puppet[:show_diff] = true
-        end
-
-        it "should display a diff if the current contents are different from the desired content" do
-          @content.should = "some content"
-          @content.expects(:diff).returns("my diff").once
-          @content.expects(:notice).with("\nmy diff").once
-
-          @content.safe_insync?("other content")
-        end
-
-        it "should not display a diff if the sum for the current contents is the same as the sum for the desired content" do
-          @content.should = "some content"
-          @content.expects(:diff).never
-
-          @content.safe_insync?("{md5}" + Digest::MD5.hexdigest("some content"))
+      [true, false].product([true, false]).each do |cfg, param|
+        describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
+          before do
+            Puppet[:show_diff] = cfg
+            @resource.stubs(:show_diff?).returns param
+          end
+
+          if cfg and param
+            it "should display a diff" do
+              @content.expects(:diff).returns("my diff").once
+              @content.expects(:notice).with("\nmy diff").once
+              @content.should_not be_safe_insync("other content")
+            end
+          else
+            it "should not display a diff" do
+              @content.expects(:diff).never
+              @content.should_not be_safe_insync("other content")
+            end
+          end
         end
       end
     end

data/spec/unit/type/file/mode_spec.rb

@@ -138,5 +138,11 @@ describe Puppet::Type.type(:file).attrclass(:mode) do
         mode.is_to_s('1755').should == '1755'
       end
     end
+
+    describe 'when passed :absent' do
+      it 'returns :absent' do
+        mode.is_to_s(:absent).should == :absent
+      end
+    end
   end
 end

data/spec/unit/type/file/source_spec.rb

@@ -93,6 +93,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
   describe "when returning the metadata" do
     before do
       @metadata = stub 'metadata', :source= => nil
+      @resource.stubs(:[]).with(:links).returns :manage
     end
 
     it "should return already-available metadata" do
@@ -108,22 +109,22 @@ describe Puppet::Type.type(:file).attrclass(:source) do
 
     it "should collect its metadata using the Metadata class if it is not already set" do
       @source = source.new(:resource => @resource, :value => @foobar)
-      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment).returns @metadata
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment, :links => :manage).returns @metadata
       @source.metadata
     end
 
     it "should use the metadata from the first found source" do
       metadata = stub 'metadata', :source= => nil
       @source = source.new(:resource => @resource, :value => [@foobar, @feebooz])
-      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment).returns nil
-      Puppet::FileServing::Metadata.indirection.expects(:find).with(@feebooz_uri, :environment => @environment).returns metadata
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment, :links => :manage).returns nil
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@feebooz_uri, :environment => @environment, :links => :manage).returns metadata
       @source.metadata.should equal(metadata)
     end
 
     it "should store the found source as the metadata's source" do
       metadata = mock 'metadata'
       @source = source.new(:resource => @resource, :value => @foobar)
-      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment).returns metadata
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment, :links => :manage).returns metadata
 
       metadata.expects(:source=).with(@foobar_uri)
       @source.metadata
@@ -131,7 +132,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
 
     it "should fail intelligently if an exception is encountered while querying for metadata" do
       @source = source.new(:resource => @resource, :value => @foobar)
-      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment).raises RuntimeError
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment, :links => :manage).raises RuntimeError
 
       @source.expects(:fail).raises ArgumentError
       lambda { @source.metadata }.should raise_error(ArgumentError)
@@ -139,7 +140,7 @@ describe Puppet::Type.type(:file).attrclass(:source) do
 
     it "should fail if no specified sources can be found" do
       @source = source.new(:resource => @resource, :value => @foobar)
-      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment).returns nil
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(@foobar_uri, :environment => @environment, :links => :manage).returns nil
 
       @source.expects(:fail).raises RuntimeError
 
@@ -321,7 +322,8 @@ describe Puppet::Type.type(:file).attrclass(:source) do
       before(:each) do
         metadata = Puppet::FileServing::Metadata.new(path, :source => uri, 'type' => 'file')
         #metadata = stub('remote', :ftype => "file", :source => uri)
-        Puppet::FileServing::Metadata.indirection.stubs(:find).with(uri, has_key(:environment)).returns metadata
+        Puppet::FileServing::Metadata.indirection.stubs(:find).
+          with(uri,all_of(has_key(:environment), has_key(:links))).returns metadata
         resource[:source] = uri
       end
 

data/spec/unit/type/file_spec.rb

@@ -856,20 +856,39 @@ describe Puppet::Type.type(:file) do
 
   describe "#remove_existing" do
     it "should do nothing if the file doesn't exist" do
-      file.remove_existing(:file).should == nil
+      file.remove_existing(:file).should == false
     end
 
     it "should fail if it can't backup the file" do
-      file.stubs(:stat).returns stub('stat')
+      file.stubs(:stat).returns stub('stat', :ftype => 'file')
       file.stubs(:perform_backup).returns false
 
       expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up; will not replace/)
     end
 
+    describe "backing up directories" do
+      it "should not backup directories if force is false" do
+        file[:force] = false
+        file.stubs(:stat).returns stub('stat', :ftype => 'directory')
+        file.expects(:perform_backup).never
+        file.remove_existing(:file).should == false
+      end
+
+      it "should backup directories if force is true" do
+        file[:force] = true
+        FileUtils.expects(:rmtree).with(file[:path])
+
+        file.stubs(:stat).returns stub('stat', :ftype => 'directory')
+        file.expects(:perform_backup).once.returns(true)
+
+        file.remove_existing(:file).should == true
+      end
+    end
+
     it "should not do anything if the file is already the right type and not a link" do
       file.stubs(:stat).returns stub('stat', :ftype => 'file')
 
-      file.remove_existing(:file).should == nil
+      file.remove_existing(:file).should == false
     end
 
     it "should not remove directories and should not invalidate the stat unless force is set" do

data/spec/unit/type/service_spec.rb

@@ -49,47 +49,60 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     svc.should(:ensure).should == :stopped
   end
 
-  it "should support :true as a value to :enable" do
-    Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
-  end
+  describe "the enable property" do
+    before :each do
+      @provider.class.stubs(:supports_parameter?).returns true
+    end
+    it "should support :true as a value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
+      srv.should(:enable).should == :true
+    end
 
-  it "should support :false as a value to :enable" do
-    Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
-  end
+    it "should support :false as a value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
+      srv.should(:enable).should == :false
+    end
 
-  it "should support :manual as a value to :enable on Windows" do
-    Puppet.features.stubs(:microsoft_windows?).returns true
+    it "should support :manual as a value on Windows" do
+      Puppet.features.stubs(:microsoft_windows?).returns true
 
-    Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
-  end
+      srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
+      srv.should(:enable).should == :manual
+    end
 
-  it "should not support :manual as a value to :enable when not on Windows" do
-    Puppet.features.stubs(:microsoft_windows?).returns false
+    it "should not support :manual as a value when not on Windows" do
+      Puppet.features.stubs(:microsoft_windows?).returns false
 
-    expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
-      Puppet::Error,
-      /Setting enable to manual is only supported on Microsoft Windows\./
-    )
+      expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
+        Puppet::Error,
+        /Setting enable to manual is only supported on Microsoft Windows\./
+      )
+    end
   end
 
   it "should support :true as a value to :hasstatus" do
-    Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
+    srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
+    srv[:hasstatus].should == :true
   end
 
   it "should support :false as a value to :hasstatus" do
-    Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
+    srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
+    srv[:hasstatus].should == :false
   end
 
   it "should specify :true as the default value of hasstatus" do
-    Puppet::Type.type(:service).new(:name => "yay")[:hasstatus].should == :true
+    srv = Puppet::Type.type(:service).new(:name => "yay")
+    srv[:hasstatus].should == :true
   end
 
   it "should support :true as a value to :hasrestart" do
-    Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
+    srv = Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
+    srv[:hasrestart].should == :true
   end
 
   it "should support :false as a value to :hasrestart" do
-    Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :false)
+    srv = Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :false)
+    srv[:hasrestart].should == :false
   end
 
   it "should allow setting the :enable parameter if the provider has the :enableable feature" do

data/spec/unit/type_spec.rb

@@ -356,7 +356,23 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should fail if any invalid attributes have been provided" do
-      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error)
+      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error, /Invalid parameter/)
+    end
+
+    context "when an attribute fails validation" do
+      it "should fail with Puppet::ResourceError when PuppetError raised" do
+        expect { Puppet::Type.type(:file).new(:title => "/foo", :source => "unknown:///") }.to raise_error(Puppet::ResourceError, /Parameter source failed on File\[.*foo\]/)
+      end
+
+      it "should fail with Puppet::ResourceError when ArgumentError raised" do
+        expect { Puppet::Type.type(:file).new(:title => "/foo", :mode => "abcdef") }.to raise_error(Puppet::ResourceError, /Parameter mode failed on File\[.*foo\]/)
+      end
+
+      it "should include the file/line in the error" do
+        Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
+        Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
+        expect { Puppet::Type.type(:file).new(:title => "/foo", :source => "unknown:///") }.to raise_error(Puppet::ResourceError, /example.pp:42/)
+      end
     end
 
     it "should set its name to the resource's title if the resource does not have a :name or namevar parameter set" do
@@ -419,6 +435,35 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     it "should delete the name via the namevar from the originally provided parameters" do
       Puppet::Type.type(:file).new(:name => make_absolute('/foo')).original_parameters[:path].should be_nil
     end
+
+    context "when validating the resource" do
+      it "should call the type's validate method if present" do
+        Puppet::Type.type(:file).any_instance.expects(:validate)
+        Puppet::Type.type(:file).new(:name => make_absolute('/foo'))
+      end
+
+      it "should raise Puppet::ResourceError with resource name when Puppet::Error raised" do
+        expect do
+          Puppet::Type.type(:file).new(
+            :name => make_absolute('/foo'),
+            :source => "puppet:///",
+            :content => "foo"
+          )
+        end.to raise_error(Puppet::ResourceError, /Validation of File\[.*foo.*\]/)
+      end
+
+      it "should raise Puppet::ResourceError with manifest file and line on failure" do
+        Puppet::Type.type(:file).any_instance.stubs(:file).returns("example.pp")
+        Puppet::Type.type(:file).any_instance.stubs(:line).returns(42)
+        expect do
+          Puppet::Type.type(:file).new(
+            :name => make_absolute('/foo'),
+            :source => "puppet:///",
+            :content => "foo"
+          )
+        end.to raise_error(Puppet::ResourceError, /Validation.*example.pp:42/)
+      end
+    end
   end
 
   it "should have a class method for converting a hash into a Puppet::Resource instance" do

data/spec/unit/util/backups_spec.rb

@@ -66,7 +66,7 @@ describe Puppet::Util::Backups do
 
       it "should fail when the old backup can't be removed" do
         File.expects(:lstat).with(backup).returns stub("stat", :ftype => "file")
-        File.expects(:unlink).raises ArgumentError
+        File.expects(:unlink).with(backup).raises ArgumentError
         FileUtils.expects(:cp_r).never
         FileTest.expects(:exists?).with(path).returns(true)
 
@@ -75,7 +75,7 @@ describe Puppet::Util::Backups do
 
       it "should not try to remove backups that don't exist" do
         File.expects(:lstat).with(backup).raises(Errno::ENOENT)
-        File.expects(:unlink).never
+        File.expects(:unlink).with(backup).never
         FileUtils.stubs(:cp_r)
         FileTest.expects(:exists?).with(path).returns(true)
 

data/spec/unit/util/execution_spec.rb

@@ -44,6 +44,9 @@ describe Puppet::Util::Execution do
         Puppet::Util::SUIDManager.stubs(:change_user)
         Puppet::Util::SUIDManager.stubs(:change_group)
 
+        # ensure that we don't really close anything!
+        (0..256).each {|n| IO.stubs(:new) }
+
         $stdin.stubs(:reopen)
         $stdout.stubs(:reopen)
         $stderr.stubs(:reopen)
@@ -576,7 +579,7 @@ describe Puppet::Util::Execution do
       it "should raise an error if a nil option is specified" do
         expect {
           Puppet::Util::Execution.execute('fail command', nil)
-        }.to raise_error(TypeError, /can\'t convert nil into Hash/)
+        }.to raise_error(TypeError, /(can\'t convert|no implicit conversion of) nil into Hash/)
       end
     end
   end

data/spec/unit/util/filetype_spec.rb

@@ -100,6 +100,12 @@ describe Puppet::Util::FileType do
       type.should_not be_nil
     end
 
+    # make Puppet::Util::SUIDManager return something deterministic, not the
+    # uid of the user running the tests, except where overridden below.
+    before :each do
+      Puppet::Util::SUIDManager.stubs(:uid).returns 1234
+    end
+
     describe "#read" do
       it "should run crontab -l as the target user" do
         Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).returns crontab

data/spec/unit/util/monkey_patches_spec.rb

@@ -94,6 +94,24 @@ describe Array do
       [1,2,3].drop(3).should == []
     end
   end
+
+  describe "#respond_to?" do
+    it "should return true for a standard method (each)" do
+      [].respond_to?(:each).should be_true
+    end
+
+    it "should return false for to_hash" do
+      [].respond_to?(:to_hash).should be_false
+    end
+
+    it "should accept one argument" do
+      lambda { [].respond_to?(:each) }.should_not raise_error
+    end
+
+    it "should accept two arguments" do
+      lambda { [].respond_to?(:each, false) }.should_not raise_error
+    end
+  end
 end
 
 describe IO do

data/spec/unit/util/network_device/cisco/device_spec.rb

@@ -2,6 +2,7 @@
 require 'spec_helper'
 
 require 'puppet/util/network_device/cisco/device'
+require 'puppet/util/network_device/transport/telnet'
 
 describe Puppet::Util::NetworkDevice::Cisco::Device do
   before(:each) do
@@ -16,10 +17,46 @@ describe Puppet::Util::NetworkDevice::Cisco::Device do
       cisco.enable_password.should == "enable_password"
     end
 
+    describe "decoding the enable password" do
+      it "should not parse a password if no query is given" do
+        cisco = described_class.new("telnet://user:password@localhost:23")
+        cisco.enable_password.should be_nil
+      end
+
+      it "should not parse a password if no enable param is given" do
+        cisco = described_class.new("telnet://user:password@localhost:23/?notenable=notapassword")
+        cisco.enable_password.should be_nil
+      end
+      it "should decode sharps" do
+        cisco = described_class.new("telnet://user:password@localhost:23/?enable=enable_password%23with_a_sharp")
+        cisco.enable_password.should == "enable_password#with_a_sharp"
+      end
+
+      it "should decode spaces" do
+        cisco = described_class.new("telnet://user:password@localhost:23/?enable=enable_password%20with_a_space")
+        cisco.enable_password.should == "enable_password with_a_space"
+      end
+
+      it "should only use the query parameter" do
+        cisco = described_class.new("telnet://enable=:password@localhost:23/?enable=enable_password&notenable=notapassword")
+        cisco.enable_password.should == "enable_password"
+      end
+    end
+
     it "should find the enable password from the options" do
       cisco = Puppet::Util::NetworkDevice::Cisco::Device.new("telnet://user:password@localhost:23/?enable=enable_password", :enable_password => "mypass")
       cisco.enable_password.should == "mypass"
     end
+
+    it "should find the debug mode from the options" do
+      Puppet::Util::NetworkDevice::Transport::Telnet.expects(:new).with(true).returns(@transport)
+      cisco = Puppet::Util::NetworkDevice::Cisco::Device.new("telnet://user:password@localhost:23", :debug => true)
+    end
+
+    it "should set the debug mode to nil by default" do
+      Puppet::Util::NetworkDevice::Transport::Telnet.expects(:new).with(nil).returns(@transport)
+      cisco = Puppet::Util::NetworkDevice::Cisco::Device.new("telnet://user:password@localhost:23")
+    end
   end
 
   describe "when connecting to the physical device" do