puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

data/spec/unit/functions/module_directory_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the module_directory function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  it 'returns first found module from one or more given names' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { module_directory('one', 'two'):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(mod)
+    expect(compiler.compile()).to have_resource("Notify[expected_path]")
+  end
+
+  it 'returns first found module from one or more given names in an array' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { module_directory(['one', 'two']):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(mod)
+    expect(compiler.compile()).to have_resource("Notify[expected_path]")
+  end
+
+  it 'returns undef when none of the modules were found' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { String(type(module_directory('one', 'two'))):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(nil)
+    expect(compiler.compile()).to have_resource("Notify[Undef]")
+  end
+end

data/spec/unit/functions/new_spec.rb

@@ -28,7 +28,7 @@ describe 'the new function' do
       $x = Integer.new(undef)
       notify { "one${x}word": }
     MANIFEST
-    )}.to raise_error(Puppet::Error, /expects an Integer value, got Undef/)
+    )}.to raise_error(Puppet::Error, /of type Undef cannot be converted to Integer/)
   end
 
   it 'errors if converted value is not assignable to the type' do
@@ -294,11 +294,11 @@ describe 'the new function' do
         '+ 0XGG'=> :error,
         '- 0XGG'=> :error,
       }.each do |str, result|
-        it "errors when given the non octal value compliant string '#{str}'" do
+        it "errors when given the non hexadecimal value compliant string '#{str}'" do
           expect{compile_to_catalog(<<-"MANIFEST"
             $x = Integer.new("#{str}", 8)
           MANIFEST
-        )}.to raise_error(Puppet::Error, /invalid value/)
+        )}.to raise_error(Puppet::Error, /The string '#{Regexp.escape(str)}' cannot be converted to Integer/)
         end
       end
     end
@@ -321,7 +321,7 @@ describe 'the new function' do
         '0b10'  => :error,
         '0B10'  => :error,
       }.each do |str, result|
-        it "errors when given the non octal value compliant string '#{str}'" do
+        it "errors when given the non binary value compliant string '#{str}'" do
           expect{compile_to_catalog(<<-"MANIFEST"
             $x = Integer.new("#{str}", 10)
           MANIFEST
@@ -352,28 +352,28 @@ describe 'the new function' do
         expect{compile_to_catalog(<<-"MANIFEST"
           $x = Integer.new('10', 3)
         MANIFEST
-      )}.to raise_error(Puppet::Error, /rejected: parameter 'radix'/m)
+      )}.to raise_error(Puppet::Error, /Illegal radix/)
       end
 
       it 'radix is wrong and when given in long form' do
         expect{compile_to_catalog(<<-"MANIFEST"
           $x = Integer.new({from =>'10', radix=>3})
         MANIFEST
-      )}.to raise_error(Puppet::Error, /rejected: parameter 'hash_args' entry 'radix'/m)
+      )}.to raise_error(Puppet::Error, /Illegal radix/)
       end
 
       it 'value is not numeric and given directly' do
         expect{compile_to_catalog(<<-"MANIFEST"
           $x = Integer.new('eleven', 10)
         MANIFEST
-      )}.to raise_error(Puppet::Error, /invalid value/)
+      )}.to raise_error(Puppet::Error, /The string 'eleven' cannot be converted to Integer/)
       end
 
       it 'value is not numeric and given in long form' do
         expect{compile_to_catalog(<<-"MANIFEST"
       $x = Integer.new({from => 'eleven', radix => 10})
         MANIFEST
-      )}.to raise_error(Puppet::Error, /invalid value/)
+      )}.to raise_error(Puppet::Error, /The string 'eleven' cannot be converted to Integer/)
       end
     end
   end
@@ -538,14 +538,14 @@ describe 'the new function' do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Boolean.new('hello')
       MANIFEST
-      )}.to raise_error(Puppet::Error, /cannot be converted to Boolean/)
+      )}.to raise_error(Puppet::Error, /The string 'hello' cannot be converted to Boolean/)
     end
 
     it "does not convert an undef (as may be expected, but is handled as every other undef)" do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Boolean.new(undef)
       MANIFEST
-      )}.to raise_error(Puppet::Error, /expects a Boolean value, got Undef/)
+      )}.to raise_error(Puppet::Error, /of type Undef cannot be converted to Boolean/)
     end
   end
 
@@ -566,8 +566,8 @@ describe 'the new function' do
     end
 
     {
-      true          => /cannot be converted to Array/,
-      42.3          => /cannot be converted to Array/,
+      true          => /of type Boolean cannot be converted to Array/,
+      42.3          => /of type Float cannot be converted to Array/,
     }.each do |input, error_match|
       it "errors when given an non convertible #{input.inspect} when wrap is not given" do
         expect{compile_to_catalog(<<-"MANIFEST"
@@ -650,7 +650,7 @@ describe 'the new function' do
       end
     end
 
-    { true             => /cannot be converted to Hash/,
+    { true             => /Value of type Boolean cannot be converted to Hash/,
       [1,2,3]          => /odd number of arguments for Hash/,
     }.each do |input, error_match|
       it "errors when given an non convertible #{input.inspect}" do
@@ -714,7 +714,7 @@ describe 'the new function' do
       expect{compile_to_catalog(<<-"MANIFEST"
         $x = Struct[{a => Integer[2]}].new({a => 0})
       MANIFEST
-      )}.to raise_error(Puppet::Error, /entry 'a' expects an Integer\[2, default\]/)
+      )}.to raise_error(Puppet::Error, /entry 'a' expects an Integer\[2\]/)
     end
   end
 

data/spec/unit/functions/require_spec.rb

@@ -80,4 +80,6 @@ describe 'The "require" function' do
 
   it_should_behave_like 'all functions transforming relative to absolute names', :require
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
+  it_should_behave_like 'an inclusion function, when --tasks is on,', :require
+
 end

data/spec/unit/functions/shared.rb

@@ -83,3 +83,15 @@ shared_examples_for 'an inclusion function, regardless of the type of class refe
     end
 
 end
+
+shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
+  it "is not available when --tasks is on" do
+    Puppet[:tasks] = true
+    expect do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        #{function}(bar)
+      MANIFEST
+    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
+  end
+end
+

data/spec/unit/functions/step_spec.rb

@@ -52,7 +52,7 @@ describe 'the step method' do
       compile_to_catalog(<<-MANIFEST)
         [1].step(0) |$x| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /'step' expects an Integer\[1, default\] value, got Integer\[0, 0\]/)
+    end.to raise_error(Puppet::Error, /'step' expects an Integer\[1\] value, got Integer\[0, 0\]/)
   end
 
   it 'raises an error when step is not an integer' do

data/spec/unit/functions4_spec.rb

@@ -56,7 +56,7 @@ describe 'the 4x function api' do
   it 'refuses to create functions that are not based on the Function class' do
     expect do
       Puppet::Functions.create_function('testing', Object) {}
-    end.to raise_error(ArgumentError, 'Functions must be based on Puppet::Pops::Functions::Function. Got Object')
+    end.to raise_error(ArgumentError, /function 'testing'.*Functions must be based on Puppet::Pops::Functions::Function. Got Object/)
   end
 
   it 'refuses to create functions with parameters that are not named with a symbol' do
@@ -212,15 +212,18 @@ describe 'the 4x function api' do
     end
 
     it 'a function can not be created with parameters declared after a repeated parameter' do
-      expect { create_function_with_param_after_repeated }.to raise_error(ArgumentError, 'Parameters cannot be added after a repeated parameter')
+      expect { create_function_with_param_after_repeated }.to raise_error(ArgumentError, 
+        /function 't1'.*Parameters cannot be added after a repeated parameter/)
     end
 
     it 'a function can not be created with required parameters declared after optional ones' do
-      expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 'A required parameter cannot be added after an optional parameter')
+      expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 
+        /function 't1'.*A required parameter cannot be added after an optional parameter/)
     end
 
     it 'a function can not be created with required repeated parameters declared after optional ones' do
-      expect { create_function_with_rq_repeated_after_opt }.to raise_error(ArgumentError, 'A required repeated parameter cannot be added after an optional parameter')
+      expect { create_function_with_rq_repeated_after_opt }.to raise_error(ArgumentError,
+        /function 't1'.*A required repeated parameter cannot be added after an optional parameter/)
     end
 
     it 'an error is raised with reference to multiple methods when called with mis-matched arguments' do
@@ -467,6 +470,48 @@ describe 'the 4x function api' do
       end
     end
 
+    context 'reports meaningful errors' do
+      let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+
+      it 'syntax error in local type is reported with puppet source, puppet location, and ruby file containing function' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        expect do
+          fc = eval(<<-CODE, here)
+            Puppet::Functions.create_function('testing::test') do
+              local_types do
+                type 'MyType += Array[Integer]'
+              end
+              dispatch :test do
+                param 'MyType', :x
+              end
+              def test(x)
+                x
+              end
+            end
+          CODE
+        end.to raise_error(/MyType \+\= Array.*<Syntax error at '\+\=' \(line: 1, column: [0-9]+\)>.*functions4_spec\.rb.*/m)
+        # Note that raised error reports this spec file as the function source since the function is defined here
+      end
+
+      it 'syntax error in param type is reported with puppet source, puppet location, and ruby file containing function' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        expect do
+          fc = eval(<<-CODE, here)
+            Puppet::Functions.create_function('testing::test') do
+              dispatch :test do
+                param 'Array[1+=1]', :x
+              end
+              def test(x)
+                x
+              end
+            end
+          CODE
+        end.to raise_error(/Parsing of type string '"Array\[1\+=1\]"' failed with message: <Syntax error at '\]' \(line: 1, column: [0-9]+\)>/m)
+      end
+
+    end
     context 'can use a loader when parsing types in function dispatch, and' do
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
 

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

@@ -226,12 +226,12 @@ describe Puppet::Resource::Catalog::Compiler do
     it "errors if checksum_type contains no shared checksum types" do
       Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
-      @request.options[:checksum_type] = 'atime.sha512'
+      @request.options[:checksum_type] = 'atime.md2'
       @request.options[:code_id] = 'some_code_id'
       node.environment.stubs(:static_catalogs?).returns true
 
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
-        "Unable to find a common checksum type between agent 'atime.sha512' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :mtime, :ctime, :none]'."
+        "Unable to find a common checksum type between agent 'atime.md2' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
 
     it "errors if checksum_type contains no shared checksum types" do
@@ -242,7 +242,7 @@ describe Puppet::Resource::Catalog::Compiler do
       node.environment.stubs(:static_catalogs?).returns true
 
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
-        "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :mtime, :ctime, :none]'."
+        "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
   end
 

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

@@ -92,44 +92,59 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
       describe "when supplying a path" do
         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"
-            expect(Puppet::FileSystem.binread(contents_file)).to eq(plaintext)
-            expect(Puppet::FileSystem.read(paths_file)).to eq("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}"
-            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
-            expect(File.read("#{dir_path}/paths")).to eq("foo/bar\n")
-          end
-
-          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(plaintext, "/foo/baz")
-
-            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
-            expect(File.read("#{dir_path}/paths")).to eq("foo/bar\nfoo/baz\n")
-          end
+            it "should store the path if not already stored" do
+              if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+              else
+                checksum = save_bucket_file(plaintext, "/foo/bar")
+  
+                dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+                contents_file = "#{dir_path}/contents"
+                paths_file = "#{dir_path}/paths"
+                expect(Puppet::FileSystem.binread(contents_file)).to eq(plaintext)
+                expect(Puppet::FileSystem.read(paths_file)).to eq("foo/bar\n")
+              end
+            end
+  
+            it "should leave the paths file alone if the path is already stored" do
+              if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+              else
+                checksum = save_bucket_file(plaintext, "/foo/bar")
+                checksum = save_bucket_file(plaintext, "/foo/bar")
+                dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+                expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+                expect(File.read("#{dir_path}/paths")).to eq("foo/bar\n")
+              end
+            end
+  
+            it "should store an additional path if the new path differs from those already stored" do
+              if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+              else
+                checksum = save_bucket_file(plaintext, "/foo/bar")
+                checksum = save_bucket_file(plaintext, "/foo/baz")
+                dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+                expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+                expect(File.read("#{dir_path}/paths")).to eq("foo/bar\nfoo/baz\n")
+              end
+            end
+          # end
         end
       end
 
       describe "when not supplying a path" do
         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]}/#{bucket_dir}"
-            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
-            expect(File.read("#{dir_path}/paths")).to eq("")
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              checksum = save_bucket_file(plaintext, "")
+  
+              dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+              expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+              expect(File.read("#{dir_path}/paths")).to eq("")
+            end
           end
         end
       end
@@ -157,37 +172,45 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           end
 
           it "should return the list of bucketed files in a human readable way" do
-            checksum1 = save_bucket_file("I'm the contents of a file", '/foo/bar1')
-            checksum2 = save_bucket_file("I'm the contents of another file", '/foo/bar2')
-            checksum3 = save_bucket_file("I'm the modified content of a existing file", '/foo/bar1')
-
-            # Use the first checksum as we know it's stored in the bucket
-            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}/foo/bar1", :list_all => true)
-
-            # The list is sort order from date and file name, so first and third checksums come before the second
-            date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
-            expect(find_result.to_s).to match(Regexp.new("^(#{checksum1}|#{checksum3}) #{date_pattern} foo/bar1\\n(#{checksum3}|#{checksum1}) #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              checksum1 = save_bucket_file("I'm the contents of a file", '/foo/bar1')
+              checksum2 = save_bucket_file("I'm the contents of another file", '/foo/bar2')
+              checksum3 = save_bucket_file("I'm the modified content of a existing file", '/foo/bar1')
+  
+              # Use the first checksum as we know it's stored in the bucket
+              find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}/foo/bar1", :list_all => true)
+  
+              # The list is sort order from date and file name, so first and third checksums come before the second
+              date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+              expect(find_result.to_s).to match(Regexp.new("^(#{checksum1}|#{checksum3}) #{date_pattern} foo/bar1\\n(#{checksum3}|#{checksum1}) #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+            end
           end
 
           it "should fail in an informative way when provided dates are not in the right format" do
-            contents = "I'm the contents of a file"
-            save_bucket_file(contents, '/foo/bar1')
-            expect {
-              Puppet::FileBucket::File.indirection.find(
-                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
-                :list_all => true,
-                :todate => "0:0:0 1-1-1970",
-                :fromdate => "WEIRD"
-              )
-            }.to raise_error(Puppet::Error, /fromdate/)
-            expect {
-              Puppet::FileBucket::File.indirection.find(
-                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
-                :list_all => true,
-                :todate => "WEIRD",
-                :fromdate => Time.now
-              )
-            }.to raise_error(Puppet::Error, /todate/)
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              contents = "I'm the contents of a file"
+              save_bucket_file(contents, '/foo/bar1')
+              expect {
+                Puppet::FileBucket::File.indirection.find(
+                  "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                  :list_all => true,
+                  :todate => "0:0:0 1-1-1970",
+                  :fromdate => "WEIRD"
+                )
+              }.to raise_error(Puppet::Error, /fromdate/)
+              expect {
+                Puppet::FileBucket::File.indirection.find(
+                  "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                  :list_all => true,
+                  :todate => "WEIRD",
+                  :fromdate => Time.now
+                )
+              }.to raise_error(Puppet::Error, /todate/)
+            end
           end
         end
 
@@ -198,21 +221,30 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           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')
 
-            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(false)
-            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(nil)
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              checksum = save_bucket_file("I'm the contents of a file", '/foo/bar')
+  
+              expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(false)
+              expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(nil)
+            end
           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')
-
-            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar")).to eq(true)
-            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/bar")
-            expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
-            expect(find_result.to_s).to eq(contents)
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              contents = "I'm the contents of a file"
+  
+              checksum = save_bucket_file(contents, '/foo/bar')
+  
+              expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar")).to eq(true)
+              find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/bar")
+              expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+              expect(find_result.to_s).to eq(contents)
+            end
           end
         end
 
@@ -227,16 +259,21 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
               end
 
               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')
-
-                expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}")).to eq(true)
-                find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}#{trailing_string}")
-                expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
-                expect(find_result.to_s).to eq(contents)
+                if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                  skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+                else
+                  contents = "I'm the contents of a file"
+  
+                  checksum = save_bucket_file(contents, '/foo/bar')
+  
+                  expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}")).to eq(true)
+                  find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}#{trailing_string}")
+                  expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+                  expect(find_result.to_s).to eq(contents)
+                end
               end
             end
           end
@@ -250,30 +287,46 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
 
         it "should generate an empty string if there is no diff" do
-          checksum = save_bucket_file("I'm the contents of a file")
-          expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum)).to eq('')
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum = save_bucket_file("I'm the contents of a file")
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum)).to eq('')
+          end
         end
 
         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("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
-          expect(diff).to include("-bar\n+biz\n")
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum1 = save_bucket_file("foo\nbar\nbaz")
+            checksum2 = save_bucket_file("foo\nbiz\nbaz")
+  
+            diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
+            expect(diff).to include("-bar\n+biz\n")
+          end
         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}"
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            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
         end
 
         it "should return nil if the hash to diff from isn't found" do
-          checksum = save_bucket_file("whatever")
-
-          expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum)).to eq(nil)
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum = save_bucket_file("whatever")
+  
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum)).to eq(nil)
+          end
         end
       end
     end
@@ -343,6 +396,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
             describe "when saving files" do
               it "should save the contents to the calculated path" do
+                skip("Windows Long File Name support is incomplete PUP-8257, this doesn't fail reliably so it should be skipped.") if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
                 options = {}
                 if override_bucket_path
                   options[:bucket_path] = @bucket_top_dir