puppet 2.7.18 → 2.7.19

data/spec/unit/type/vlan_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::Type.type(:vlan) do
   end
 
   it "should be applied on device" do
-    Puppet::Type.type(:vlan).new(:name => "200").should be_appliable_to_device
+    Puppet::Type.type(:vlan).new(:name => "200").must be_appliable_to_device
   end
 
   it "should have an ensure property" do

data/spec/unit/type_spec.rb

@@ -13,17 +13,17 @@ describe Puppet::Type, :fails_on_windows => true do
       this.sort.should == [a, b, c]
     end
 
-    a.should be < b
-    a.should be < c
-    b.should be > a
-    b.should be < c
-    c.should be > a
-    c.should be > b
+    a.must be < b
+    a.must be < c
+    b.must be > a
+    b.must be < c
+    c.must be > a
+    c.must be > b
 
-    [a, b, c].each {|x| a.should be <= x }
-    [a, b, c].each {|x| c.should be >= x }
+    [a, b, c].each {|x| a.must be <= x }
+    [a, b, c].each {|x| c.must be >= x }
 
-    b.should be_between(a, c)
+    b.must be_between(a, c)
   end
 
   it "should consider a parameter to be valid if it is a valid parameter" do
@@ -63,7 +63,7 @@ describe Puppet::Type, :fails_on_windows => true do
   end
 
   it "should have a method for setting default values for resources" do
-    Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:set_default)
+    Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:set_default)
   end
 
   it "should do nothing for attributes that have no defaults and no specified value" do
@@ -71,7 +71,7 @@ describe Puppet::Type, :fails_on_windows => true do
   end
 
   it "should have a method for adding tags" do
-    Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:tags)
+    Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:tags)
   end
 
   it "should use the tagging module" do
@@ -97,11 +97,11 @@ describe Puppet::Type, :fails_on_windows => true do
   end
 
   it "should have a method to know if the resource is exported" do
-    Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:exported?)
+    Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:exported?)
   end
 
   it "should have a method to know if the resource is virtual" do
-    Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:virtual?)
+    Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:virtual?)
   end
 
   it "should consider its version to be its catalog version" do
@@ -286,7 +286,7 @@ describe Puppet::Type, :fails_on_windows => true do
     describe "and passed a TransObject" do
       it "should fail" do
         trans = Puppet::TransObject.new("/foo", :mount)
-        lambda { Puppet::Type.type(:mount).new(trans) }.should raise_error(Puppet::DevError)
+        expect { Puppet::Type.type(:mount).new(trans) }.to raise_error(Puppet::DevError)
       end
     end
 
@@ -362,7 +362,7 @@ describe Puppet::Type, :fails_on_windows => true do
     end
 
     it "should fail if any invalid attributes have been provided" do
-      lambda { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.should raise_error(Puppet::Error)
+      expect { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.to raise_error(Puppet::Error)
     end
 
     it "should set its name to the resource's title if the resource does not have a :name or namevar parameter set" do
@@ -372,7 +372,7 @@ describe Puppet::Type, :fails_on_windows => true do
     end
 
     it "should fail if no title, name, or namevar are provided" do
-      lambda { Puppet::Type.type(:file).new(:atboot => true) }.should raise_error(Puppet::Error)
+      expect { Puppet::Type.type(:file).new(:atboot => true) }.to raise_error(Puppet::Error)
     end
 
     it "should set the attributes in the order returned by the class's :allattrs method" do
@@ -485,7 +485,7 @@ describe Puppet::Type, :fails_on_windows => true do
     it "should fail if its provider is unsuitable" do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.provider.class.expects(:suitable?).returns false
-      lambda { @resource.retrieve_resource }.should raise_error(Puppet::Error)
+      expect { @resource.retrieve_resource }.to raise_error(Puppet::Error)
     end
 
     it "should return a Puppet::Resource instance with its type and title set appropriately" do
@@ -583,24 +583,21 @@ describe Puppet::Type, :fails_on_windows => true do
 
     it "should be suitable if its type doesn't use providers" do
       type.stubs(:paramclass).with(:provider).returns nil
-
-      resource.should be_suitable
+      resource.must be_suitable
     end
 
     it "should be suitable if it has a provider which is suitable" do
-      resource.should be_suitable
+      resource.must be_suitable
     end
 
     it "should not be suitable if it has a provider which is not suitable" do
       provider.class.stubs(:suitable?).returns false
-
       resource.should_not be_suitable
     end
 
     it "should be suitable if it does not have a provider and there is a default provider" do
       resource.stubs(:provider).returns nil
-
-      resource.should be_suitable
+      resource.must be_suitable
     end
 
     it "should not be suitable if it doesn't have a provider and there is not default provider" do
@@ -626,7 +623,7 @@ describe Puppet::Type, :fails_on_windows => true do
         end
       end
 
-      expect { fake_type.instances }.should_not raise_error
+      expect { fake_type.instances }.to_not raise_error
     end
   end
 
@@ -745,7 +742,7 @@ describe Puppet::Type.metaparamclass(:audit) do
   end
 
   it "should fail if asked to audit an invalid property" do
-    lambda { @resource[:audit] = :foobar }.should raise_error(Puppet::Error)
+    expect { @resource[:audit] = :foobar }.to raise_error(Puppet::Error)
   end
 
   it "should create an attribute instance for each auditable property" do

data/spec/unit/util/autoload_spec.rb

@@ -101,23 +101,29 @@ describe Puppet::Util::Autoload do
   describe "when loading all files" do
     before do
       @autoload.stubs(:searchpath).returns %w{/a}
-      Dir.stubs(:glob).returns "/path/to/file.rb"
-
-      @autoload.class.stubs(:loaded?).returns(false)
+      @filename = rand(10000).to_s + ".rb"
+      Dir.stubs(:glob).returns(@filename)
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
-      it "should die an if a #{error.to_s} exception is thrown", :'fails_on_ruby_1.9.2' => true do
+      it "dies if a #{error.to_s} exception is thrown", :'fails_on_ruby_1.9.2' => true do
         Kernel.expects(:require).raises error
 
-        lambda { @autoload.loadall }.should raise_error(Puppet::Error)
+        expect { @autoload.loadall }.to raise_error(Puppet::Error)
       end
     end
 
-    it "should require the full path to the file", :'fails_on_ruby_1.9.2' => true do
-      Kernel.expects(:require).with("/path/to/file.rb")
+    it "requires the file", :'fails_on_ruby_1.9.2' => true do
+      Kernel.expects(:require).with(@filename)
 
       @autoload.loadall
     end
+
+    it "marks the file as required even if loading fails", :'fails_on_ruby_1.9.2' => true do
+      Dir.stubs(:glob).returns "/this/file/does/not/exist.rb"
+
+      expect { @autoload.loadall }.to raise_error(Puppet::Error)
+      expect { @autoload.loadall }.not_to raise_error
+    end
   end
 end

data/spec/unit/util/backups_spec.rb

@@ -6,152 +6,121 @@ require 'puppet/util/backups'
 describe Puppet::Util::Backups do
   include PuppetSpec::Files
 
-  before do
-    FileTest.stubs(:exists?).returns true
-    @nosuchfile = make_absolute('/no/such/file')
+  let(:bucket) { stub('bucket', :name => "foo") }
+  let!(:file) do
+    f = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
+    f.stubs(:bucket).returns(bucket)
+    f
   end
 
   describe "when backing up a file" do
+    let(:path) { make_absolute('/no/such/file') }
+
     it "should noop if the file does not exist" do
-      FileTest.expects(:exists?).returns false
-      file = Puppet::Type.type(:file).new(:name => @nosuchfile)
+      file = Puppet::Type.type(:file).new(:name => path)
+
       file.expects(:bucket).never
+      FileTest.expects(:exists?).with(path).returns false
 
       file.perform_backup
     end
 
     it "should succeed silently if self[:backup] is false" do
-      file = Puppet::Type.type(:file).new(:name => @nosuchfile, :backup => false)
+      file = Puppet::Type.type(:file).new(:name => path, :backup => false)
+
       file.expects(:bucket).never
       FileTest.expects(:exists?).never
+
       file.perform_backup
     end
 
     it "a bucket should be used when provided" do
-      path = make_absolute('/my/file')
-
       File.stubs(:stat).with(path).returns(mock('stat', :ftype => 'file'))
-
-      file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
-      bucket = stub('bucket', 'name' => 'foo')
-      file.stubs(:bucket).returns bucket
-
       bucket.expects(:backup).with(path).returns("mysum")
+      FileTest.expects(:exists?).with(path).returns(true)
 
       file.perform_backup
     end
 
     it "should propagate any exceptions encountered when backing up to a filebucket" do
-      path = make_absolute('/my/file')
-
       File.stubs(:stat).with(path).returns(mock('stat', :ftype => 'file'))
-
-      file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
-      bucket = stub('bucket', 'name' => 'foo')
-      file.stubs(:bucket).returns bucket
-
       bucket.expects(:backup).raises ArgumentError
+      FileTest.expects(:exists?).with(path).returns(true)
 
       lambda { file.perform_backup }.should raise_error(ArgumentError)
     end
 
-    describe "and no filebucket is configured" do
-      it "should remove any local backup if one exists" do
-        path = make_absolute('/my/file')
-        FileTest.stubs(:exists?).returns true
-
-        backup = path + ".foo"
+    describe "and local backup is configured" do
+      let(:ext) { 'foobkp' }
+      let(:backup) { path + '.' + ext }
+      let(:file) { Puppet::Type.type(:file).new(:name => path, :backup => '.'+ext) }
 
+      it "should remove any local backup if one exists" do
         File.expects(:lstat).with(backup).returns stub("stat", :ftype => "file")
         File.expects(:unlink).with(backup)
-
         FileUtils.stubs(:cp_r)
+        FileTest.expects(:exists?).with(path).returns(true)
 
-        file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
         file.perform_backup
       end
 
       it "should fail when the old backup can't be removed" do
-        path = make_absolute('/my/file')
-        FileTest.stubs(:exists?).returns true
-
-        backup = path + ".foo"
-
         File.expects(:lstat).with(backup).returns stub("stat", :ftype => "file")
         File.expects(:unlink).raises ArgumentError
-
         FileUtils.expects(:cp_r).never
+        FileTest.expects(:exists?).with(path).returns(true)
 
-        file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
         lambda { file.perform_backup }.should raise_error(Puppet::Error)
       end
 
       it "should not try to remove backups that don't exist" do
-        path = make_absolute('/my/file')
-        FileTest.stubs(:exists?).returns true
-
-        backup = path + ".foo"
-
         File.expects(:lstat).with(backup).raises(Errno::ENOENT)
         File.expects(:unlink).never
-
         FileUtils.stubs(:cp_r)
+        FileTest.expects(:exists?).with(path).returns(true)
 
-        file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
         file.perform_backup
       end
 
       it "a copy should be created in the local directory" do
-        path = make_absolute('/my/file')
-        FileTest.stubs(:exists?).with(path).returns true
+        FileUtils.expects(:cp_r).with(path, backup, :preserve => true)
+        FileTest.stubs(:exists?).with(path).returns(true)
 
-        FileUtils.expects(:cp_r).with(path, path + ".foo", :preserve => true)
-
-        file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
         file.perform_backup.should be_true
       end
 
       it "should propagate exceptions if no backup can be created" do
-        path = make_absolute('/my/file')
-        FileTest.stubs(:exists?).with(path).returns true
-
         FileUtils.expects(:cp_r).raises ArgumentError
 
-        file = Puppet::Type.type(:file).new(:name => path, :backup => '.foo')
+        FileTest.stubs(:exists?).with(path).returns(true)
         lambda { file.perform_backup }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when backing up a directory" do
-    it "a bucket should work when provided" do
-      path = make_absolute('/my/dir')
-
-      File.stubs(:file?).returns true
-      Find.expects(:find).with(path).yields(make_absolute("/my/dir/file"))
+    let(:path) { make_absolute('/my/dir') }
+    let(:filename) { File.join(path, 'file') }
 
-      bucket = stub('bucket', :name => "eh")
-      bucket.expects(:backup).with(make_absolute("/my/dir/file")).returns true
+    it "a bucket should work when provided" do
+      File.stubs(:file?).with(filename).returns true
+      Find.expects(:find).with(path).yields(filename)
 
-      file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
-      file.stubs(:bucket).returns bucket
+      bucket.expects(:backup).with(filename).returns true
 
       File.stubs(:stat).with(path).returns(stub('stat', :ftype => 'directory'))
 
+      FileTest.stubs(:exists?).with(path).returns(true)
+      FileTest.stubs(:exists?).with(filename).returns(true)
+
       file.perform_backup
     end
 
     it "should do nothing when recursing" do
-      path = make_absolute('/my/dir')
-
-      bucket = stub('bucket', :name => "eh")
-      bucket.expects(:backup).never
-
       file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo', :recurse => true)
-      file.stubs(:bucket).returns bucket
 
+      bucket.expects(:backup).never
       File.stubs(:stat).with(path).returns(stub('stat', :ftype => 'directory'))
-
       Find.expects(:find).never
 
       file.perform_backup

data/spec/unit/util/storage_spec.rb

@@ -183,13 +183,12 @@ describe Puppet::Util::Storage do
 
   describe "when storing to the state file" do
     before(:each) do
-      @state_file = Tempfile.new('storage_test')
+      @state_file = tmpfile('storage_test')
       @saved_statefile = Puppet[:statefile]
-      Puppet[:statefile] = @state_file.path
+      Puppet[:statefile] = @state_file
     end
 
     it "should create the state file if it does not exist" do
-      @state_file.close!()
       FileTest.exists?(Puppet[:statefile]).should be_false
       Puppet::Util::Storage.cache(:yayness)
 
@@ -198,7 +197,6 @@ describe Puppet::Util::Storage do
     end
 
     it "should raise an exception if the state file is not a regular file" do
-      @state_file.close!()
       Dir.mkdir(Puppet[:statefile])
       Puppet::Util::Storage.cache(:yayness)
 
@@ -224,10 +222,5 @@ describe Puppet::Util::Storage do
       proc { Puppet::Util::Storage.load }.should_not raise_error
       Puppet::Util::Storage.state.should == {:yayness=>{}}
     end
-
-    after(:each) do
-      @state_file.close!()
-      Puppet[:statefile] = @saved_statefile
-    end
   end
 end

data/spec/unit/util/suidmanager_spec.rb

@@ -278,6 +278,6 @@ describe 'Puppet::Util::SUIDManager#groups=' do
   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)
+    expect { subject.groups = ['list', 'of', 'groups'] }.to raise_error(Errno::EINVAL)
   end
 end

data/spec/unit/util_spec.rb

@@ -411,7 +411,7 @@ describe Puppet::Util do
       end
 
       it "should wait for the child process to exit" do
-        Puppet::Util.stubs(:wait_for_output)
+        Puppet::Util.expects(:wait_for_output)
 
         Puppet::Util.execute('test command')
       end
@@ -456,6 +456,16 @@ describe Puppet::Util do
         File.should_not be_exist(path)
       end
 
+      it "should not raise an error if the file is open" do
+        stdout = Tempfile.new('test')
+        Tempfile.stubs(:new).returns(stdout)
+        file = File.new(stdout.path, 'r')
+
+        expect {
+          Puppet::Util.execute('test command')
+        }.to_not raise_error
+      end
+
       it "should raise an error if failonfail is true and the child failed" do
         stub_process_wait(1)
 
@@ -709,20 +719,12 @@ describe Puppet::Util do
         expect { subject.replace_file(target.path, 0600) }.to raise_error /block/
       end
 
-      it "should replace a file when invoked" do
-        # Check that our file has the expected content.
-        File.read(target.path).should == "hello, world\n"
-
-        # Replace the file.
-        subject.replace_file(target.path, 0600) do |fh|
-          fh.puts "I am the passenger..."
-        end
-
-        # ...and check the replacement was complete.
-        File.read(target.path).should == "I am the passenger...\n"
-      end
-
-      [0555, 0600, 0660, 0700, 0770].each do |mode|
+      # When running with the same user and group sid, which is the default,
+      # Windows collapses the owner and group modes into a single ACE, resulting
+      # in set(0600) => get(0660) and so forth. --daniel 2012-03-30
+      modes = [0555, 0660, 0770]
+      modes += [0600, 0700] unless Puppet.features.microsoft_windows?
+      modes.each do |mode|
         it "should copy 0#{mode.to_s(8)} permissions from the target file by default" do
           set_mode(mode, target.path)
 
@@ -735,9 +737,9 @@ describe Puppet::Util do
         end
       end
 
-      it "should copy the permissions of the source file before yielding" do
+      it "should copy the permissions of the source file before yielding on Unix", :if => !Puppet.features.microsoft_windows? do
         set_mode(0555, target.path)
-        inode = File.stat(target.path).ino unless Puppet.features.microsoft_windows?
+        inode = File.stat(target.path).ino
 
         yielded = false
         subject.replace_file(target.path, 0600) do |fh|
@@ -746,9 +748,7 @@ describe Puppet::Util do
         end
         yielded.should be_true
 
-        # We can't check inode on Windows
-        File.stat(target.path).ino.should_not == inode unless Puppet.features.microsoft_windows?
-
+        File.stat(target.path).ino.should_not == inode
         get_mode(target.path).should == 0555
       end
 
@@ -789,13 +789,5 @@ describe Puppet::Util do
         File.read(target.path).should == "hello, world\n"
       end
     end
-
-    describe "on Windows platforms" do
-      it "should fail and complain" do
-        Puppet.features.stubs(:microsoft_windows?).returns true
-
-        expect { Puppet::Util.replace_file("C:/foo", 0644) {} }.to raise_error(Puppet::DevError, "replace_file is non-functional on Windows")
-      end
-    end
   end
 end