puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -2,18 +2,11 @@
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/file'
+require 'puppet/util/platform'
 
 describe Puppet::FileBucketFile::File do
   include PuppetSpec::Files
 
-  it "should be a subclass of the Code terminus class" do
-    Puppet::FileBucketFile::File.superclass.should equal(Puppet::Indirector::Code)
-  end
-
-  it "should have documentation" do
-    Puppet::FileBucketFile::File.doc.should be_instance_of(String)
-  end
-
   describe "non-stubbing tests" do
     include PuppetSpec::Files
 
@@ -23,7 +16,7 @@ describe Puppet::FileBucketFile::File do
 
     def save_bucket_file(contents, path = "/who_cares")
       bucket_file = Puppet::FileBucket::File.new(contents)
-      Puppet::FileBucket::File.indirection.save(bucket_file, "md5/#{Digest::MD5.hexdigest(contents)}#{path}")
+      Puppet::FileBucket::File.indirection.save(bucket_file, "#{bucket_file.name}#{path}")
       bucket_file.checksum_data
     end
 
@@ -34,17 +27,58 @@ describe Puppet::FileBucketFile::File do
         result.contents.should be_empty
       end
 
+      it "deals with multiple processes saving at the same time", :unless => Puppet::Util::Platform.windows? do
+        bucket_file = Puppet::FileBucket::File.new("contents")
+
+        children = []
+        5.times do |count|
+          children << Kernel.fork do
+            save_bucket_file("contents", "/testing")
+            exit(0)
+          end
+        end
+        children.each { |child| Process.wait(child) }
+
+        paths = File.read("#{Puppet[:bucketdir]}/9/8/b/f/7/d/8/c/98bf7d8c15784f0a3d63204441e1e2aa/paths").lines.to_a
+        paths.length.should == 1
+        Puppet::FileBucket::File.indirection.head("#{bucket_file.checksum_type}/#{bucket_file.checksum_data}/testing").should be_true
+      end
+
+      it "fails if the contents collide with existing contents" do
+        # This is the shortest known MD5 collision. See http://eprint.iacr.org/2010/643.pdf
+        first_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
+                          0x6503cf04,0x854f709e,0xfb0fc034,0x874c9c65,
+                          0x2f94cc40,0x15a12deb,0x5c15f4a3,0x490786bb,
+                          0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("I" * 16)
+
+        collision_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
+                              0x6503cf04,0x854f749e,0xfb0fc034,0x874c9c65,
+                              0x2f94cc40,0x15a12deb,0xdc15f4a3,0x490786bb,
+                              0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("I" * 16)
+
+        save_bucket_file(first_contents, "/foo/bar")
+
+        expect do
+          save_bucket_file(collision_contents, "/foo/bar")
+        end.to raise_error(Puppet::FileBucket::BucketError, /Got passed new contents/)
+      end
+
       describe "when supplying a path" do
         it "should store the path if not already stored" do
           checksum = save_bucket_file("stuff\r\n", "/foo/bar")
+
           dir_path = "#{Puppet[:bucketdir]}/f/c/7/7/7/c/0/b/fc777c0bc467e1ab98b4c6915af802ec"
-          IO.binread("#{dir_path}/contents").should == "stuff\r\n"
-          File.read("#{dir_path}/paths").should == "foo/bar\n"
+          contents_file = Puppet::FileSystem::File.new("#{dir_path}/contents")
+          paths_file = Puppet::FileSystem::File.new("#{dir_path}/paths")
+          contents_file.binread.should == "stuff\r\n"
+          paths_file.read.should == "foo/bar\n"
         end
 
         it "should leave the paths file alone if the path is already stored" do
           checksum = save_bucket_file("stuff", "/foo/bar")
+
           checksum = save_bucket_file("stuff", "/foo/bar")
+
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == "foo/bar\n"
@@ -52,7 +86,9 @@ describe Puppet::FileBucketFile::File do
 
         it "should store an additional path if the new path differs from those already stored" do
           checksum = save_bucket_file("stuff", "/foo/bar")
+
           checksum = save_bucket_file("stuff", "/foo/baz")
+
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == "foo/bar\nfoo/baz\n"
@@ -62,6 +98,7 @@ describe Puppet::FileBucketFile::File do
       describe "when not supplying a path" do
         it "should save the file and create an empty paths file" do
           checksum = save_bucket_file("stuff", "")
+
           dir_path = "#{Puppet[:bucketdir]}/c/1/3/d/8/8/c/b/c13d88cb4cb02003daedb8a84e5d272a"
           File.read("#{dir_path}/contents").should == "stuff"
           File.read("#{dir_path}/paths").should == ""
@@ -78,16 +115,18 @@ describe Puppet::FileBucketFile::File do
 
         it "should return false/nil if the file is bucketed but with a different path" do
           checksum = save_bucket_file("I'm the contents of a file", '/foo/bar')
+
           Puppet::FileBucket::File.indirection.head("md5/#{checksum}/foo/baz").should == false
           Puppet::FileBucket::File.indirection.find("md5/#{checksum}/foo/baz").should == nil
         end
 
         it "should return true/file if the file is already bucketed with the given path" do
           contents = "I'm the contents of a file"
+
           checksum = save_bucket_file(contents, '/foo/bar')
+
           Puppet::FileBucket::File.indirection.head("md5/#{checksum}/foo/bar").should == true
           find_result = Puppet::FileBucket::File.indirection.find("md5/#{checksum}/foo/bar")
-          find_result.should be_a(Puppet::FileBucket::File)
           find_result.checksum.should == "{md5}#{checksum}"
           find_result.to_s.should == contents
         end
@@ -105,10 +144,11 @@ describe Puppet::FileBucketFile::File do
 
             it "should return true/file if the file is already bucketed" do
               contents = "I'm the contents of a file"
+
               checksum = save_bucket_file(contents, '/foo/bar')
+
               Puppet::FileBucket::File.indirection.head("md5/#{checksum}#{trailing_string}").should == true
               find_result = Puppet::FileBucket::File.indirection.find("md5/#{checksum}#{trailing_string}")
-              find_result.should be_a(Puppet::FileBucket::File)
               find_result.checksum.should == "{md5}#{checksum}"
               find_result.to_s.should == contents
             end
@@ -126,6 +166,7 @@ describe Puppet::FileBucketFile::File do
       it "should generate a proper diff if there is a diff" do
         checksum1 = save_bucket_file("foo\nbar\nbaz")
         checksum2 = save_bucket_file("foo\nbiz\nbaz")
+
         diff = Puppet::FileBucket::File.indirection.find("md5/#{checksum1}", :diff_with => checksum2)
         diff.should == <<HERE
 2c2
@@ -136,27 +177,23 @@ HERE
       end
 
       it "should raise an exception if the hash to diff against isn't found" do
-        checksum = save_bucket_file("whatever")
         bogus_checksum = "d1bf072d0e2c6e20e3fbd23f022089a1"
-        lambda { Puppet::FileBucket::File.indirection.find("md5/#{checksum}", :diff_with => bogus_checksum) }.should raise_error "could not find diff_with #{bogus_checksum}"
+        checksum = save_bucket_file("whatever")
+
+        expect do
+          Puppet::FileBucket::File.indirection.find("md5/#{checksum}", :diff_with => bogus_checksum)
+        end.to raise_error "could not find diff_with #{bogus_checksum}"
       end
 
       it "should return nil if the hash to diff from isn't found" do
-        checksum = save_bucket_file("whatever")
         bogus_checksum = "d1bf072d0e2c6e20e3fbd23f022089a1"
+        checksum = save_bucket_file("whatever")
+
         Puppet::FileBucket::File.indirection.find("md5/#{bogus_checksum}", :diff_with => checksum).should == nil
       end
     end
   end
 
-  describe "when initializing" do
-    it "should use the filebucket settings section" do
-      Puppet.settings.expects(:use).with(:filebucket)
-      Puppet::FileBucketFile::File.new
-    end
-  end
-
-
   [true, false].each do |override_bucket_path|
     describe "when bucket path #{if override_bucket_path then 'is' else 'is not' end} overridden" do
       [true, false].each do |supply_path|
@@ -245,32 +282,4 @@ HERE
       end
     end
   end
-
-  describe "when verifying identical files" do
-    let(:contents) { "file\r\n contents" }
-    let(:digest) { "8b3702ad1aed1ace7e32bde76ffffb2d" }
-    let(:checksum) { "{md5}#{@digest}" }
-    let(:bucketdir) { tmpdir('file_bucket_file') }
-    let(:destdir) { "#{bucketdir}/8/b/3/7/0/2/a/d/8b3702ad1aed1ace7e32bde76ffffb2d" }
-    let(:bucket) { Puppet::FileBucket::File.new(contents) }
-
-    before :each do
-      Puppet[:bucketdir] = bucketdir
-      FileUtils.mkdir_p(destdir)
-    end
-
-    it "should raise an error if the files don't match" do
-      File.open(File.join(destdir, 'contents'), 'wb') { |f| f.print "corrupt contents" }
-
-      lambda{
-        Puppet::FileBucketFile::File.new.send(:verify_identical_file!, bucket)
-      }.should raise_error(Puppet::FileBucket::BucketError)
-    end
-
-    it "should do nothing if the files match" do
-      File.open(File.join(destdir, 'contents'), 'wb') { |f| f.print contents }
-
-      Puppet::FileBucketFile::File.new.send(:verify_identical_file!, bucket)
-    end
-  end
 end

data/spec/unit/indirector/file_metadata/file_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::Indirector::FileMetadata::File do
       @uri = Puppet::Util.path_to_uri(@path).to_s
       @data = mock 'metadata'
       @data.stubs(:collect)
-      FileTest.expects(:exists?).with(@path).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
 
       @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri, nil)
     end
@@ -42,7 +42,7 @@ describe Puppet::Indirector::FileMetadata::File do
     end
 
     it "should collect the attributes of the instances returned" do
-      FileTest.expects(:exists?).with(@path).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
       @metadata.expects(:path2instances).returns( [mock("one", :collect => nil), mock("two", :collect => nil)] )
       @metadata.search(@request)
     end

data/spec/unit/indirector/file_server_spec.rb

@@ -154,7 +154,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
 
       one = mock 'fileset_one'
       Puppet::FileServing::Fileset.expects(:new).with("/one", @request).returns(one)
@@ -171,7 +171,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
 
@@ -193,7 +193,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
@@ -211,7 +211,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
 
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 

data/spec/unit/indirector/json_spec.rb

@@ -131,20 +131,20 @@ describe Puppet::Indirector::JSON do
         with_content('hello') do
           subject.destroy(request)
         end
-        File.should_not be_exist file
+        Puppet::FileSystem::File.exist?(file).should be_false
       end
 
       it "silently succeeds when files don't exist" do
-        File.unlink(file) rescue nil
+        Puppet::FileSystem::File.unlink(file) rescue nil
         subject.destroy(request).should be_true
       end
 
       it "raises an informative error for other failures" do
-        File.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
+        Puppet::FileSystem::File.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
         with_content('hello') do
           expect { subject.destroy(request) }.to raise_error Puppet::Error
         end
-        File.unstub(:unlink)    # thanks, mocha
+        Puppet::FileSystem::File.unstub(:unlink)    # thanks, mocha
       end
     end
   end

data/spec/unit/indirector/key/file_spec.rb

@@ -64,33 +64,32 @@ describe Puppet::SSL::Key::File do
     end
 
     it "should save the public key when saving the private key" do
-      Puppet.settings.stubs(:writesub)
+      fh = StringIO.new
 
-      fh = mock 'filehandle'
-
-      Puppet.settings.expects(:writesub).with(:publickeydir, @public_key_path).yields fh
+      Puppet.settings.setting(:publickeydir).expects(:open_file).with(@public_key_path, 'w').yields fh
+      Puppet.settings.setting(:privatekeydir).stubs(:open_file)
       @public_key.expects(:to_pem).returns "my pem"
 
-      fh.expects(:print).with "my pem"
-
       @searcher.save(@request)
+
+      expect(fh.string).to eq("my pem")
     end
 
     it "should destroy the public key when destroying the private key" do
-      File.stubs(:unlink).with(@private_key_path)
-      FileTest.stubs(:exist?).with(@private_key_path).returns true
-      FileTest.expects(:exist?).with(@public_key_path).returns true
-      File.expects(:unlink).with(@public_key_path)
+      Puppet::FileSystem::File.stubs(:unlink).with(@private_key_path)
+      Puppet::FileSystem::File.stubs(:exist?).with(@private_key_path).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(@public_key_path).returns true
+      Puppet::FileSystem::File.expects(:unlink).with(@public_key_path)
 
       @searcher.destroy(@request)
     end
 
     it "should not fail if the public key does not exist when deleting the private key" do
-      File.stubs(:unlink).with(@private_key_path)
+      Puppet::FileSystem::File.stubs(:unlink).with(@private_key_path)
 
-      FileTest.stubs(:exist?).with(@private_key_path).returns true
-      FileTest.expects(:exist?).with(@public_key_path).returns false
-      File.expects(:unlink).with(@public_key_path).never
+      Puppet::FileSystem::File.stubs(:exist?).with(@private_key_path).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(@public_key_path).returns false
+      Puppet::FileSystem::File.expects(:unlink).with(@public_key_path).never
 
       @searcher.destroy(@request)
     end

data/spec/unit/indirector/resource/ral_spec.rb

@@ -2,6 +2,13 @@
 require 'spec_helper'
 
 describe "Puppet::Resource::Ral" do
+
+  it "is deprecated on the network, but still allows requests" do
+    Puppet.expects(:deprecation_warning)
+
+    expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(true)
+  end
+
   describe "find" do
     before do
       @request = stub 'request', :key => "user/root"

data/spec/unit/indirector/resource/store_configs_spec.rb

@@ -9,4 +9,15 @@ end
 
 describe Puppet::Resource::StoreConfigs do
   it_should_behave_like "a StoreConfigs terminus"
+
+  before :each do
+    Puppet[:storeconfigs] = true
+    Puppet[:storeconfigs_backend] = "store_configs_testing"
+  end
+
+  it "is deprecated on the network, but still allows requests" do
+    Puppet.expects(:deprecation_warning)
+
+    expect(Puppet::Resource::StoreConfigs.new.allow_remote_requests?).to eq(true)
+  end
 end

data/spec/unit/indirector/rest_spec.rb

@@ -109,6 +109,10 @@ describe Puppet::Indirector::REST do
         string.split(',').collect { |s| convert_from(format, s) }
       end
 
+      def to_data_hash
+        { 'name' => @name, 'data' => @data }
+      end
+
       def ==(other)
         other.is_a? Puppet::TestModel and other.name == name and other.data == data
       end
@@ -205,21 +209,21 @@ describe Puppet::Indirector::REST do
       @request = stub 'request', :key => "foo", :server => nil, :port => nil
       terminus.class.expects(:port).returns 321
       terminus.class.expects(:server).returns "myserver"
-      Puppet::Network::HTTP::Connection.expects(:new).with("myserver", 321).returns "myconn"
+      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       terminus.network(@request).should == "myconn"
     end
 
     it "should use the server from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
       terminus.class.stubs(:port).returns 321
-      Puppet::Network::HTTP::Connection.expects(:new).with("myserver", 321).returns "myconn"
+      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       terminus.network(@request).should == "myconn"
     end
 
     it "should use the port from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => nil, :port => 321
       terminus.class.stubs(:server).returns "myserver"
-      Puppet::Network::HTTP::Connection.expects(:new).with("myserver", 321).returns "myconn"
+      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       terminus.network(@request).should == "myconn"
     end
   end

data/spec/unit/indirector/ssl_file_spec.rb

@@ -121,9 +121,9 @@ describe Puppet::Indirector::SslFile do
     describe "when finding certificates on disk" do
       describe "and no certificate is present" do
         it "should return nil" do
-          FileTest.expects(:exist?).with(@path).returns(true)
+          Puppet::FileSystem::File.expects(:exist?).with(@path).returns(true)
           Dir.expects(:entries).with(@path).returns([])
-          FileTest.expects(:exist?).with(@certpath).returns(false)
+          Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns(false)
 
           @searcher.find(@request).should be_nil
         end
@@ -139,7 +139,7 @@ describe Puppet::Indirector::SslFile do
 
         context "is readable" do
           it "should return an instance of the model, which it should use to read the certificate" do
-            FileTest.expects(:exist?).with(@certpath).returns true
+            Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns true
 
             model.expects(:new).with("myname").returns cert
             cert.expects(:read).with(@certpath)
@@ -150,7 +150,7 @@ describe Puppet::Indirector::SslFile do
 
         context "is unreadable" do
           it "should raise an exception" do
-            FileTest.expects(:exist?).with(@certpath).returns(true)
+            Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns(true)
 
             model.expects(:new).with("myname").returns cert
             cert.expects(:read).with(@certpath).raises(Errno::EACCES)
@@ -171,9 +171,9 @@ describe Puppet::Indirector::SslFile do
         # the support for upper-case certs can be removed around mid-2009.
         it "should rename the existing file to the lower-case path" do
           @path = @searcher.path("myhost")
-          FileTest.expects(:exist?).with(@path).returns(false)
+          Puppet::FileSystem::File.expects(:exist?).with(@path).returns(false)
           dir, file = File.split(@path)
-          FileTest.expects(:exist?).with(dir).returns true
+          Puppet::FileSystem::File.expects(:exist?).with(dir).returns true
           Dir.expects(:entries).with(dir).returns [".", "..", "something.pem", file.upcase]
 
           File.expects(:rename).with(File.join(dir, file.upcase), @path)
@@ -221,7 +221,7 @@ describe Puppet::Indirector::SslFile do
           @searcher.class.store_in @setting
           fh = mock 'filehandle'
           fh.stubs :print
-          Puppet.settings.expects(:writesub).with(@setting, @certpath).yields fh
+          Puppet.settings.setting(@setting).expects(:open_file).with(@certpath, 'w').yields fh
 
           @searcher.save(@request)
         end
@@ -233,7 +233,7 @@ describe Puppet::Indirector::SslFile do
 
           fh = mock 'filehandle'
           fh.stubs :print
-          Puppet.settings.expects(:write).with(@setting).yields fh
+          Puppet.settings.setting(@setting).expects(:open).with('w').yields fh
           @searcher.save(@request)
         end
       end
@@ -246,7 +246,7 @@ describe Puppet::Indirector::SslFile do
 
           fh = mock 'filehandle'
           fh.stubs :print
-          Puppet.settings.expects(:write).with(:cakey).yields fh
+          Puppet.settings.setting(:cakey).expects(:open).with('w').yields fh
           @searcher.stubs(:ca?).returns true
           @searcher.save(@request)
         end
@@ -256,7 +256,7 @@ describe Puppet::Indirector::SslFile do
     describe "when destroying certificates" do
       describe "that do not exist" do
         before do
-          FileTest.expects(:exist?).with(@certpath).returns false
+          Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns false
         end
 
         it "should return false" do
@@ -265,18 +265,15 @@ describe Puppet::Indirector::SslFile do
       end
 
       describe "that exist" do
-        before do
-          FileTest.expects(:exist?).with(@certpath).returns true
-        end
-
         it "should unlink the certificate file" do
-          File.expects(:unlink).with(@certpath)
+          Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns true
+          Puppet::FileSystem::File.expects(:unlink).with(@certpath)
           @searcher.destroy(@request)
         end
 
         it "should log that is removing the file" do
-          File.stubs(:exist?).returns true
-          File.stubs(:unlink)
+          Puppet::FileSystem::File.stubs(:exist?).returns true
+          Puppet::FileSystem::File.stubs(:unlink)
           Puppet.expects(:notice)
           @searcher.destroy(@request)
         end