puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -128,7 +128,7 @@ describe Puppet::Resource::Catalog::StaticCompiler do
     options[:request] ||= request
 
     # Build a catalog suitable for the static compiler to operate on
-    catalog = Puppet::Resource::Catalog.new("#{options[:request].key}")
+    catalog = Puppet::Resource::Catalog.new("#{options[:request].key}", Puppet::Node::Environment.remote(:testing))
 
     # Mock out the fileserver, otherwise converting the catalog to a
     fake_fileserver_metadata = fileserver_metadata(options)
@@ -139,7 +139,7 @@ describe Puppet::Resource::Catalog::StaticCompiler do
       indirection.stubs(:find).with do |uri, opts|
         expect(uri).to eq options[:source].sub('puppet:///','')
         expect(opts[:links]).to eq :manage
-        expect(opts[:environment]).to eq nil
+        expect(opts[:environment]).to eq "testing"
       end.returns(fake_fileserver_metadata)
 
     # I want a resource that all the file resources require and another

data/spec/unit/indirector/facts/facter_spec.rb

@@ -3,7 +3,10 @@ require 'spec_helper'
 
 require 'puppet/indirector/facts/facter'
 
+module PuppetNodeFactsFacter
 describe Puppet::Node::Facts::Facter do
+  FS = Puppet::FileSystem
+
   it "should be a subclass of the Code terminus" do
     Puppet::Node::Facts::Facter.superclass.should equal(Puppet::Indirector::Code)
   end
@@ -173,8 +176,6 @@ describe Puppet::Node::Facts::Facter do
     it "should load all facts from the modules" do
       Puppet::Node::Facts::Facter.stubs(:load_facts_in_dir)
 
-      Puppet[:modulepath] = [one, two].join(File::PATH_SEPARATOR)
-
       Dir.stubs(:glob).returns []
       Dir.expects(:glob).with("#{one}/*/lib/facter").returns %w{oneA oneB}
       Dir.expects(:glob).with("#{two}/*/lib/facter").returns %w{twoA twoB}
@@ -184,7 +185,11 @@ describe Puppet::Node::Facts::Facter do
       Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with("twoA")
       Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with("twoB")
 
-      Puppet::Node::Facts::Facter.load_fact_plugins
+      FS.overlay(FS::MemoryFile.a_directory(one), FS::MemoryFile.a_directory(two)) do
+        Puppet.override(:current_environment => Puppet::Node::Environment.create(:testing, [one, two], "")) do
+          Puppet::Node::Facts::Facter.load_fact_plugins
+        end
+      end
     end
 
     it "should include module plugin facts when present", :if => Puppet.features.external_facts? do
@@ -195,3 +200,4 @@ describe Puppet::Node::Facts::Facter do
     end
   end
 end
+end

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

@@ -4,16 +4,12 @@ require 'spec_helper'
 require 'puppet/indirector/file_bucket_file/file'
 require 'puppet/util/platform'
 
-describe Puppet::FileBucketFile::File do
+describe Puppet::FileBucketFile::File, :uses_checksums => true do
   include PuppetSpec::Files
 
   describe "non-stubbing tests" do
     include PuppetSpec::Files
 
-    before do
-      Puppet[:bucketdir] = tmpdir('bucketdir')
-    end
-
     def save_bucket_file(contents, path = "/who_cares")
       bucket_file = Puppet::FileBucket::File.new(contents)
       Puppet::FileBucket::File.indirection.save(bucket_file, "#{bucket_file.name}#{path}")
@@ -64,93 +60,102 @@ describe Puppet::FileBucketFile::File do
       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"
-          contents_file = "#{dir_path}/contents"
-          paths_file = "#{dir_path}/paths"
-          Puppet::FileSystem.binread(contents_file).should == "stuff\r\n"
-          Puppet::FileSystem.read(paths_file).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")
+        with_digest_algorithms do
+          it "should store the path if not already stored" do
+            checksum = save_bucket_file(plaintext, "/foo/bar")
+
+            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+            contents_file = "#{dir_path}/contents"
+            paths_file = "#{dir_path}/paths"
+            Puppet::FileSystem.binread(contents_file).should == plaintext
+            Puppet::FileSystem.read(paths_file).should == "foo/bar\n"
+          end
 
-          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"
-        end
+          it "should leave the paths file alone if the path is already stored" do
+            checksum = save_bucket_file(plaintext, "/foo/bar")
+            checksum = save_bucket_file(plaintext, "/foo/bar")
+            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+            Puppet::FileSystem.binread("#{dir_path}/contents").should == plaintext
+            File.read("#{dir_path}/paths").should == "foo/bar\n"
+          end
 
-        it "should store an additional path if the new path differs from those already stored" do
-          checksum = save_bucket_file("stuff", "/foo/bar")
+          it "should store an additional path if the new path differs from those already stored" do
+            checksum = save_bucket_file(plaintext, "/foo/bar")
 
-          checksum = save_bucket_file("stuff", "/foo/baz")
+            checksum = save_bucket_file(plaintext, "/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"
+            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+            Puppet::FileSystem.binread("#{dir_path}/contents").should == plaintext
+            File.read("#{dir_path}/paths").should == "foo/bar\nfoo/baz\n"
+          end
         end
       end
 
       describe "when not supplying a path" do
-        it "should save the file and create an empty paths file" do
-          checksum = save_bucket_file("stuff", "")
+        with_digest_algorithms do
+          it "should save the file and create an empty paths file" do
+            checksum = save_bucket_file(plaintext, "")
 
-          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 == ""
+            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+            Puppet::FileSystem.binread("#{dir_path}/contents").should == plaintext
+            File.read("#{dir_path}/paths").should == ""
+          end
         end
       end
     end
 
     describe "when servicing a head/find request" do
-      describe "when supplying a path" do
-        it "should return false/nil if the file isn't bucketed" do
-          Puppet::FileBucket::File.indirection.head("md5/0ae2ec1980410229885fe72f7b44fe55/foo/bar").should == false
-          Puppet::FileBucket::File.indirection.find("md5/0ae2ec1980410229885fe72f7b44fe55/foo/bar").should == nil
-        end
+      with_digest_algorithms do
+        let(:not_bucketed_plaintext) { "other stuff" }
+        let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
+
+        describe "when supplying a path" do
+          it "should return false/nil if the file isn't bucketed" do
+            Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar").should == false
+            Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar").should == nil
+          end
 
-        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')
+          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
+            Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz").should == false
+            Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{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"
+          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')
+            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.checksum.should == "{md5}#{checksum}"
-          find_result.to_s.should == contents
+            Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar").should == true
+            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/bar")
+            find_result.checksum.should == "{#{digest_algorithm}}#{checksum}"
+            find_result.to_s.should == contents
+          end
         end
-      end
 
-      describe "when not supplying a path" do
-        [false, true].each do |trailing_slash|
-          describe "#{trailing_slash ? 'with' : 'without'} a trailing slash" do
-            trailing_string = trailing_slash ? '/' : ''
+        describe "when not supplying a path" do
+          [false, true].each do |trailing_slash|
+            describe "#{trailing_slash ? 'with' : 'without'} a trailing slash" do
+              trailing_string = trailing_slash ? '/' : ''
 
-            it "should return false/nil if the file isn't bucketed" do
-              Puppet::FileBucket::File.indirection.head("md5/0ae2ec1980410229885fe72f7b44fe55#{trailing_string}").should == false
-              Puppet::FileBucket::File.indirection.find("md5/0ae2ec1980410229885fe72f7b44fe55#{trailing_string}").should == nil
-            end
+              it "should return false/nil if the file isn't bucketed" do
+                Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}#{trailing_string}").should == false
+                Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}#{trailing_string}").should == nil
+              end
 
-            it "should return true/file if the file is already bucketed" do
-              contents = "I'm the contents of a file"
+              it "should return true/file if the file is already bucketed" do
+                # this one replaces most of the lets in the "when
+                # digest_digest_algorithm is set..." shared context, but it still needs digest_algorithm
+                contents = "I'm the contents of a file"
 
-              checksum = save_bucket_file(contents, '/foo/bar')
+                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.checksum.should == "{md5}#{checksum}"
-              find_result.to_s.should == contents
+                Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}").should == true
+                find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}#{trailing_string}")
+                find_result.checksum.should == "{#{digest_algorithm}}#{checksum}"
+                find_result.to_s.should == contents
+              end
             end
           end
         end
@@ -158,124 +163,120 @@ describe Puppet::FileBucketFile::File do
     end
 
     describe "when diffing files", :unless => Puppet.features.microsoft_windows? do
-      it "should generate an empty string if there is no diff" do
-        checksum = save_bucket_file("I'm the contents of a file")
-        Puppet::FileBucket::File.indirection.find("md5/#{checksum}", :diff_with => checksum).should == ''
-      end
+      with_digest_algorithms do
+        let(:not_bucketed_plaintext) { "other stuff" }
+        let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
 
-      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
-< bar
----
-> biz
-HERE
-      end
+        it "should generate an empty string if there is no diff" do
+          checksum = save_bucket_file("I'm the contents of a file")
+          Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum).should == ''
+        end
 
-      it "should raise an exception if the hash to diff against isn't found" do
-        bogus_checksum = "d1bf072d0e2c6e20e3fbd23f022089a1"
-        checksum = save_bucket_file("whatever")
+        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")
 
-        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
+          diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
+          diff.should == "2c2\n< bar\n---\n> biz\n"
+        end
+
+        it "should raise an exception if the hash to diff against isn't found" do
+          checksum = save_bucket_file("whatever")
+
+          expect do
+            Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => not_bucketed_checksum)
+          end.to raise_error "could not find diff_with #{not_bucketed_checksum}"
+        end
 
-      it "should return nil if the hash to diff from isn't found" do
-        bogus_checksum = "d1bf072d0e2c6e20e3fbd23f022089a1"
-        checksum = save_bucket_file("whatever")
+        it "should return nil if the hash to diff from isn't found" do
+          checksum = save_bucket_file("whatever")
 
-        Puppet::FileBucket::File.indirection.find("md5/#{bogus_checksum}", :diff_with => checksum).should == nil
+          Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum).should == nil
+        end
       end
     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
+    describe "when bucket path #{override_bucket_path ? 'is' : 'is not'} overridden" do
       [true, false].each do |supply_path|
         describe "when #{supply_path ? 'supplying' : 'not supplying'} a path" do
-          before :each do
-            Puppet.settings.stubs(:use)
-            @store = Puppet::FileBucketFile::File.new
-            @contents = "my content"
+          with_digest_algorithms do
+            before :each do
+              Puppet.settings.stubs(:use)
+              @store = Puppet::FileBucketFile::File.new
 
-            @digest = "f2bfa7fc155c4f42cb91404198dda01f"
-            @digest.should == Digest::MD5.hexdigest(@contents)
+              @bucket_top_dir = tmpdir("bucket")
 
-            @bucket_dir = tmpdir("bucket")
+              if override_bucket_path
+                Puppet[:bucketdir] = "/bogus/path" # should not be used
+              else
+                Puppet[:bucketdir] = @bucket_top_dir
+              end
 
-            if override_bucket_path
-              Puppet[:bucketdir] = "/bogus/path" # should not be used
-            else
-              Puppet[:bucketdir] = @bucket_dir
+              @dir = "#{@bucket_top_dir}/#{bucket_dir}"
+              @contents_path = "#{@dir}/contents"
             end
 
-            @dir = "#{@bucket_dir}/f/2/b/f/a/7/f/c/f2bfa7fc155c4f42cb91404198dda01f"
-            @contents_path = "#{@dir}/contents"
-          end
+            describe "when retrieving files" do
+              before :each do
 
-          describe "when retrieving files" do
-            before :each do
+                request_options = {}
+                if override_bucket_path
+                  request_options[:bucket_path] = @bucket_top_dir
+                end
 
-              request_options = {}
-              if override_bucket_path
-                request_options[:bucket_path] = @bucket_dir
-              end
+                key = "#{digest_algorithm}/#{checksum}"
+                if supply_path
+                  key += "/path/to/file"
+                end
 
-              key = "md5/#{@digest}"
-              if supply_path
-                key += "/path/to/file"
+                @request = Puppet::Indirector::Request.new(:indirection_name, :find, key, nil, request_options)
               end
 
-              @request = Puppet::Indirector::Request.new(:indirection_name, :find, key, nil, request_options)
-            end
-
-            def make_bucketed_file
-              FileUtils.mkdir_p(@dir)
-              File.open(@contents_path, 'w') { |f| f.write @contents }
-            end
-
-            it "should return an instance of Puppet::FileBucket::File created with the content if the file exists" do
-              make_bucketed_file
+              def make_bucketed_file
+                FileUtils.mkdir_p(@dir)
+                File.open(@contents_path, 'wb') { |f| f.write plaintext }
+              end
 
-              if supply_path
-                @store.find(@request).should == nil
-                @store.head(@request).should == false # because path didn't match
-              else
-                bucketfile = @store.find(@request)
-                bucketfile.should be_a(Puppet::FileBucket::File)
-                bucketfile.contents.should == @contents
-                @store.head(@request).should == true
+              it "should return an instance of Puppet::FileBucket::File created with the content if the file exists" do
+                make_bucketed_file
+
+                if supply_path
+                  @store.find(@request).should == nil
+                  @store.head(@request).should == false # because path didn't match
+                else
+                  bucketfile = @store.find(@request)
+                  bucketfile.should be_a(Puppet::FileBucket::File)
+                  bucketfile.contents.should == plaintext
+                  @store.head(@request).should == true
+                end
               end
-            end
 
-            it "should return nil if no file is found" do
-              @store.find(@request).should be_nil
-              @store.head(@request).should == false
+              it "should return nil if no file is found" do
+                @store.find(@request).should be_nil
+                @store.head(@request).should == false
+              end
             end
-          end
 
-          describe "when saving files" do
-            it "should save the contents to the calculated path" do
-              options = {}
-              if override_bucket_path
-                options[:bucket_path] = @bucket_dir
-              end
+            describe "when saving files" do
+              it "should save the contents to the calculated path" do
+                options = {}
+                if override_bucket_path
+                  options[:bucket_path] = @bucket_top_dir
+                end
 
-              key = "md5/#{@digest}"
-              if supply_path
-                key += "//path/to/file"
-              end
+                key = "#{digest_algorithm}/#{checksum}"
+                if supply_path
+                  key += "//path/to/file"
+                end
 
-              file_instance = Puppet::FileBucket::File.new(@contents, options)
-              request = Puppet::Indirector::Request.new(:indirection_name, :save, key, file_instance)
+                file_instance = Puppet::FileBucket::File.new(plaintext, options)
+                request = Puppet::Indirector::Request.new(:indirection_name, :save, key, file_instance)
 
-              @store.save(request)
-              File.read("#{@dir}/contents").should == @contents
+                @store.save(request)
+                Puppet::FileSystem.binread("#{@dir}/contents").should == plaintext
+              end
             end
           end
         end

data/spec/unit/indirector/rest_spec.rb

@@ -277,6 +277,14 @@ describe Puppet::Indirector::REST do
       terminus.find(request).should == nil
     end
 
+    it 'raises a warning for a 404' do
+      response = mock_response('404', 'this is the notfound you are looking for')
+      connection.expects(:get).returns(response)
+      expected_message = 'Find /production/test_model/foo? resulted in 404 with the message: this is the notfound you are looking for'
+      Puppet::Util::Warnings.expects(:maybe_log).with(expected_message, Puppet::TestModel::Rest)
+      terminus.find(request)
+    end
+
     it "asks the model to deserialize the response body and sets the name on the resulting object to the find key" do
       connection.expects(:get).returns response