puppet 5.5.22 → 6.0.0

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device'
@@ -24,11 +25,11 @@ end
 
 describe Puppet::Node::Facts::NetworkDevice do
   before :each do
-    @remote_device = double('remote_device', :facts => {})
-    allow(Puppet::Util::NetworkDevice).to receive(:current).and_return(@remote_device)
+    @remote_device = stub 'remote_device', :facts => {}
+    Puppet::Util::NetworkDevice.stubs(:current).returns(@remote_device)
     @device = Puppet::Node::Facts::NetworkDevice.new
     @name = "me"
-    @request = double('request', :key => @name)
+    @request = stub 'request', :key => @name
   end
 
   describe Puppet::Node::Facts::NetworkDevice, " when finding facts" do
@@ -41,23 +42,23 @@ describe Puppet::Node::Facts::NetworkDevice do
     end
 
     it "should return the device facts as the values in the Facts instance" do
-      expect(@remote_device).to receive(:facts).and_return("one" => "two")
+      @remote_device.expects(:facts).returns("one" => "two")
       facts = @device.find(@request)
       expect(facts.values["one"]).to eq("two")
     end
 
     it "should add local facts" do
       facts = Puppet::Node::Facts.new("foo")
-      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
-      expect(facts).to receive(:add_local_facts)
+      Puppet::Node::Facts.expects(:new).returns facts
+      facts.expects(:add_local_facts)
 
       @device.find(@request)
     end
 
     it "should sanitize facts" do
       facts = Puppet::Node::Facts.new("foo")
-      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
-      expect(facts).to receive(:sanitize)
+      Puppet::Node::Facts.expects(:new).returns facts
+      facts.expects(:sanitize)
 
       @device.find(@request)
     end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/facts/rest'
@@ -11,29 +12,29 @@ describe Puppet::Node::Facts::Rest do
   before(:each) { model.indirection.terminus_class = :rest }
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http response', :code => code.to_s, :body => body)
-    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
-    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
-    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
+    obj = stub('http response', :code => code.to_s, :body => body)
+    obj.stubs(:[]).with('content-type').returns(content_type)
+    obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 
   describe '#save' do
     subject { model.indirection.terminus(:rest) }
 
-    let(:connection) { double('mock http connection', :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :verify_callback= => nil) }
     let(:node_name) { 'puppet.node.test' }
     let(:data) { model.new(node_name, {test_fact: 'test value'}) }
     let(:request) { Puppet::Indirector::Request.new(:facts, :save, node_name, data) }
 
     before :each do
-      allow(subject).to receive(:network).and_return(connection)
+      subject.stubs(:network).returns(connection)
     end
 
     context 'when a 404 response is received' do
       let(:response) { mock_response(404, '{}', 'test/json') }
 
-      before(:each) { expect(connection).to receive(:put).and_return(response) }
+      before(:each) { connection.expects(:put).returns response }
 
       it 'riases with HTTP 404' do
         expect{ subject.save(request) }.to raise_error(Net::HTTPError,

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/node'
 require 'puppet/indirector/memory'

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

@@ -1,9 +1,25 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/node/facts'
 require 'puppet/indirector/facts/yaml'
 
+def dir_containing_facts(hash)
+  yamldir = tmpdir('yaml_facts')
+
+  Puppet[:clientyamldir] = yamldir
+  dir = File.join(yamldir, 'facts')
+  Dir.mkdir(dir)
+  hash.each_pair do |file, facts|
+    File.open(File.join(dir, file), 'wb') do |f|
+      f.write(YAML.dump(facts))
+    end
+  end
+end
+
 describe Puppet::Node::Facts::Yaml do
+  include PuppetSpec::Files
+
   it "should be a subclass of the Yaml terminus" do
     expect(Puppet::Node::Facts::Yaml.superclass).to equal(Puppet::Indirector::Yaml)
   end
@@ -32,25 +48,22 @@ describe Puppet::Node::Facts::Yaml do
     def assert_search_matches(matching, nonmatching, query)
       request = Puppet::Indirector::Request.new(:inventory, :search, nil, nil, query)
 
-      allow(Dir).to receive(:glob).and_return(matching.keys + nonmatching.keys)
-      [matching, nonmatching].each do |examples|
-        examples.each do |key, value|
-          allow(YAML).to receive(:load_file).with(key).and_return(value)
-        end
-      end
-      expect(Puppet::Node::Facts::Yaml.new.search(request)).to match_array(matching.values.map {|facts| facts.name})
+      dir_containing_facts(matching.merge(nonmatching))
+
+      results = Puppet::Node::Facts::Yaml.new.search(request)
+      expect(results).to match_array(matching.values.map {|facts| facts.name})
     end
 
     it "should return node names that match the search query options" do
       assert_search_matches({
-          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
-          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
+          'matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
+          'matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
         },
         {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
-          "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
         },
         {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
       )
@@ -58,10 +71,10 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should return empty array when no nodes match the search query options" do
       assert_search_matches({}, {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
-          "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
+          "nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
         },
         {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
       )
@@ -69,13 +82,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should return node names that match the search query options with the greater than operator" do
       assert_search_matches({
-          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
-          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
+          'matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
         },
         {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
         },
         {'facts.processor_count.gt' => '4'}
       )
@@ -83,13 +96,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should return node names that match the search query options with the less than operator" do
       assert_search_matches({
-          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
-          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
+          'matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
         },
         {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
         },
         {'facts.processor_count.lt' => '50'}
       )
@@ -97,13 +110,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should return node names that match the search query options with the less than or equal to operator" do
       assert_search_matches({
-          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
-          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+          'matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
         },
         {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
         },
         {'facts.processor_count.le' => '50'}
       )
@@ -111,13 +124,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should return node names that match the search query options with the greater than or equal to operator" do
       assert_search_matches({
-          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
-          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+          'matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
+          'matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
         },
         {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
         },
         {'facts.processor_count.ge' => '50'}
       )
@@ -125,13 +138,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should return node names that match the search query options with the not equal operator" do
       assert_search_matches({
-          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
-          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
+          'matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
+          'matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
         },
         {
-          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
-          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
-          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
+          "nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
+          "nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
+          "nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
         },
         {'facts.architecture.ne' => 'i386'}
       )
@@ -144,13 +157,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp.gt" do
       assert_search_matches({
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
         },
         {
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {'meta.timestamp.gt' => '2010-10-15'}
       )
@@ -158,13 +171,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp.le" do
       assert_search_matches({
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
         },
         {'meta.timestamp.le' => '2010-10-15'}
       )
@@ -172,13 +185,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp.lt" do
       assert_search_matches({
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
         },
         {
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {'meta.timestamp.lt' => '2010-10-15'}
       )
@@ -186,13 +199,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp.ge" do
       assert_search_matches({
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
         },
         {'meta.timestamp.ge' => '2010-10-15'}
       )
@@ -200,13 +213,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp.eq" do
       assert_search_matches({
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
         },
         {'meta.timestamp.eq' => '2010-10-15'}
       )
@@ -214,13 +227,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp" do
       assert_search_matches({
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
         },
         {'meta.timestamp' => '2010-10-15'}
       )
@@ -228,13 +241,13 @@ describe Puppet::Node::Facts::Yaml do
 
     it "should be able to query based on meta.timestamp.ne" do
       assert_search_matches({
-          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
         },
         {
-          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+          '2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
         },
         {'meta.timestamp.ne' => '2010-10-15'}
       )

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/file'
@@ -22,7 +23,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         expect(result.contents).to be_empty
       end
 
-      it "deals with multiple processes saving at the same time", :unless => Puppet::Util::Platform.windows? do
+      it "deals with multiple processes saving at the same time", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
         bucket_file = Puppet::FileBucket::File.new("contents")
 
         children = []
@@ -54,7 +55,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         checksum_value = save_bucket_file(first_contents, "/foo/bar")
 
         # We expect Puppet to log an error with the path to the file
-        expect(Puppet).to receive(:err).with(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/)
+        Puppet.expects(:err).with(regexp_matches(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/))
 
         # But the exception should not contain it
         expect do
@@ -79,7 +80,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
 
         it "issues a warning that the backup will be overwritten" do
-          expect(Puppet).to receive(:warning).with(/Existing backup does not match its expected sum, #{bucket_file.checksum}/)
+          Puppet.expects(:warning).with(regexp_matches(/Existing backup does not match its expected sum, #{bucket_file.checksum}/))
           Puppet::FileBucket::File.indirection.save(bucket_file)
         end
 
@@ -109,8 +110,9 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true 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")
+                # save it twice
+                save_bucket_file(plaintext, "/foo/bar")
+                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")
@@ -121,8 +123,8 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true 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")
+                save_bucket_file(plaintext, "/foo/bar")
+                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")
@@ -280,12 +282,13 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       end
     end
 
-    describe "when diffing files", :unless => Puppet.features.microsoft_windows? do
+    describe "when diffing files", :unless => Puppet::Util::Platform.windows? do
       with_digest_algorithms do
         let(:not_bucketed_plaintext) { "other stuff" }
         let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
 
         it "should generate an empty string if there is no diff" do
+          skip("usage of fork(1) no supported on this platform") if RUBY_PLATFORM == 'java'
           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
@@ -295,6 +298,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
 
         it "should generate a proper diff if there is a diff" do
+          skip("usage of fork(1) no supported on this platform") if RUBY_PLATFORM == 'java'
           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
@@ -337,7 +341,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         describe "when #{supply_path ? 'supplying' : 'not supplying'} a path" do
           with_digest_algorithms do
             before :each do
-              allow(Puppet.settings).to receive(:use)
+              Puppet.settings.stubs(:use)
               @store = Puppet::FileBucketFile::File.new
 
               @bucket_top_dir = tmpdir("bucket")