puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

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

@@ -1,12 +1,61 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/files'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/catalog/json'
 
 describe Puppet::Resource::Catalog::Json do
-  # This is it for local functionality: we don't *do* anything else.
+  include PuppetSpec::Files
+
+  # This is it for local functionality
   it "should be registered with the catalog store indirection" do
     expect(Puppet::Resource::Catalog.indirection.terminus(:json)).
       to be_an_instance_of described_class
   end
+
+  describe "when handling requests" do
+    let(:binary) { "\xC0\xFF".force_encoding(Encoding::BINARY) }
+    let(:key)    { 'foo' }
+    let(:file)   { subject.path(key) }
+    let(:catalog) do
+      catalog = Puppet::Resource::Catalog.new(key, Puppet::Node::Environment.create(:testing, []))
+      catalog.add_resource(Puppet::Resource.new(:file, '/tmp/a_file', :parameters => { :content => binary }))
+      catalog
+    end
+
+    before :each do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      Puppet[:server_datadir] = tmpdir('jsondir')
+      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
+    end
+
+    it 'saves a catalog containing binary content' do
+      request = subject.indirection.request(:save, key, catalog)
+
+      subject.save(request)
+    end
+
+    it 'finds a catalog containing binary content' do
+      request = subject.indirection.request(:save, key, catalog)
+      subject.save(request)
+
+      request = subject.indirection.request(:find, key, nil)
+      parsed_catalog = subject.find(request)
+
+      content = parsed_catalog.resource(:file, '/tmp/a_file')[:content]
+      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+    end
+
+    it 'searches for catalogs contains binary content' do
+      request = subject.indirection.request(:save, key, catalog)
+      subject.save(request)
+
+      request = subject.indirection.request(:search, '*', nil)
+      parsed_catalogs = subject.search(request)
+
+      expect(parsed_catalogs.size).to eq(1)
+      content = parsed_catalogs.first.resource(:file, '/tmp/a_file')[:content]
+      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+    end
+  end
 end

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

@@ -51,9 +51,8 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
-    it 'should include external facts when feature is present' do
+    it 'should include external facts' do
       reset = sequence 'reset'
-      Puppet.features.stubs(:external_facts?).returns true
       Facter.expects(:reset).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_external_search_paths).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)

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

@@ -41,16 +41,16 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       end
 
       it "fails if the contents collide with existing contents" do
-        # This is the shortest known MD5 collision (little endian). See https://eprint.iacr.org/2010/643.pdf
+        # This is the shortest known MD5 collision. See https://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("V" * 16)
+                          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("V" * 16)
+                              0x6d658673,0xa4341f7d,0x8fd75920,0xefd18d5a].pack("I" * 16)
 
         checksum_value = save_bucket_file(first_contents, "/foo/bar")
 
@@ -166,7 +166,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
             # 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} #{date_pattern} foo/bar1\\n#{checksum3} #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+            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
 
           it "should fail in an informative way when provided dates are not in the right format" do

data/spec/unit/indirector/file_server_spec.rb

@@ -249,6 +249,7 @@ describe Puppet::Indirector::FileServer do
       @configuration.stubs(:split_path).with(@request).returns([@mount, "rel/path"])
       @request.stubs(:node).returns("mynode")
       @request.stubs(:ip).returns("myip")
+      @mount.stubs(:name).returns "myname"
       @mount.stubs(:allowed?).with("mynode", "myip").returns "something"
     end
 
@@ -274,8 +275,22 @@ describe Puppet::Indirector::FileServer do
       expect(@file_server).not_to be_authorized(@request)
     end
 
-    it "should return the results of asking the mount whether the node and IP are authorized" do
-      expect(@file_server.authorized?(@request)).to eq("something")
+    it "should return true when no auth directives are defined for the mount point" do
+      @mount.stubs(:empty?).returns true
+      @mount.stubs(:globalallow?).returns nil
+      expect(@file_server).to be_authorized(@request)
+    end
+
+    it "should return true when a global allow directive is defined for the mount point" do
+      @mount.stubs(:empty?).returns false
+      @mount.stubs(:globalallow?).returns true
+      expect(@file_server).to be_authorized(@request)
+    end
+
+    it "should return false when a non-global allow directive is defined for the mount point" do
+      @mount.stubs(:empty?).returns false
+      @mount.stubs(:globalallow?).returns false
+      expect(@file_server).not_to be_authorized(@request)
     end
   end
 end

data/spec/unit/indirector/indirection_spec.rb

@@ -14,42 +14,7 @@ shared_examples_for "Indirection Delegator" do
     @indirection.send(@method, "mystuff", :one => :two)
   end
 
-  it "should let the :select_terminus method choose the terminus using the created request if the :select_terminus method is available" do
-    # Define the method, so our respond_to? hook matches.
-    class << @indirection
-      def select_terminus(request)
-      end
-    end
-
-    request = Puppet::Indirector::Request.new(:indirection, :find, "me", nil)
-
-    @indirection.stubs(:request).returns request
-
-    @indirection.expects(:select_terminus).with(request).returns :test_terminus
-
-    @indirection.stubs(:check_authorization)
-    @terminus.expects(@method)
-
-    @indirection.send(@method, "me")
-  end
-
-  it "should fail if the :select_terminus hook does not return a terminus name" do
-    # Define the method, so our respond_to? hook matches.
-    class << @indirection
-      def select_terminus(request)
-      end
-    end
-
-    request = Puppet::Indirector::Request.new(:indirection, :find, "me", nil)
-
-    @indirection.stubs(:request).returns request
-
-    @indirection.expects(:select_terminus).with(request).returns nil
-
-    expect { @indirection.send(@method, "me") }.to raise_error(ArgumentError)
-  end
-
-  it "should choose the terminus returned by the :terminus_class method if no :select_terminus method is available" do
+  it "should choose the terminus returned by the :terminus_class" do
     @indirection.expects(:terminus_class).returns :test_terminus
 
     @terminus.expects(@method)
@@ -294,14 +259,6 @@ describe Puppet::Indirector::Indirection do
           @indirection.find("/my/key", :ignore_cache => true)
         end
 
-        it "should not save to the cache if told to skip updating the cache" do
-          @terminus.expects(:find).returns @instance
-          @cache.expects(:find).returns nil
-          @cache.expects(:save).never
-
-          @indirection.find("/my/key", :ignore_cache_save => true)
-        end
-
         it "should only look in the cache if the request specifies not to use the terminus" do
           @terminus.expects(:find).never
           @cache.expects(:find)
@@ -502,7 +459,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should return the result of saving to the terminus" do
-          request = stub 'request', :instance => @instance, :node => nil, :ignore_cache_save? => false
+          request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
@@ -512,7 +469,7 @@ describe Puppet::Indirector::Indirection do
         end
 
         it "should use a request to save the object to the cache" do
-          request = stub 'request', :instance => @instance, :node => nil, :ignore_cache_save? => false
+          request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
@@ -530,13 +487,6 @@ describe Puppet::Indirector::Indirection do
           @terminus.expects(:save).raises "eh"
           expect { @indirection.save(@instance) }.to raise_error(RuntimeError, /eh/)
         end
-
-        it "should not save to the cache if told to ignore saving to the cache" do
-          @terminus.expects(:save)
-          @cache.expects(:save).never
-
-          @indirection.save(@instance, '/my/key', :ignore_cache_save => true)
-        end
       end
     end
 
@@ -672,13 +622,6 @@ describe Puppet::Indirector::Indirection do
           @indirection.expire("/my/key")
         end
 
-        it "does not expire an instance if told to skip cache saving" do
-          @indirection.cache.expects(:find).never
-          @indirection.cache.expects(:save).never
-
-          @indirection.expire("/my/key", :ignore_cache_save => true)
-        end
-
         it "should use a request to save the expired resource to the cache" do
           @cache.expects(:find).returns @cached
 

data/spec/unit/indirector/json_spec.rb

@@ -60,7 +60,7 @@ describe Puppet::Indirector::JSON do
 
     def with_content(text)
       FileUtils.mkdir_p(File.dirname(file))
-      File.open(file, 'w') {|f| f.puts text }
+      File.binwrite(file, text)
       yield if block_given?
     end
 
@@ -77,11 +77,11 @@ describe Puppet::Indirector::JSON do
       end
 
       it "raises a descriptive error when the file can't be read" do
-        with_content(model.new('foo').to_pson) do
+        with_content(model.new('foo').to_json) do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          Puppet::FileSystem.expects(:read).with(file).raises(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file, anything).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read JSON/
         end
@@ -94,8 +94,18 @@ describe Puppet::Indirector::JSON do
         end
       end
 
+      it "raises if the content contains binary" do
+        binary = "\xC0\xFF".force_encoding(Encoding::BINARY)
+
+        with_content(binary) do
+          expect {
+            subject.find(request)
+          }.to raise_error Puppet::Error, /Could not parse JSON data/
+        end
+      end
+
       it "should return an instance of the indirected object when valid" do
-        with_content(model.new(1).to_pson) do
+        with_content(model.new(1).to_json) do
           instance = subject.find(request)
           expect(instance).to be_an_instance_of model
           expect(instance.value).to eq(1)
@@ -160,8 +170,8 @@ describe Puppet::Indirector::JSON do
     end
 
     def create_file(name, value = 12)
-      File.open(subject.path(name, ''), 'w') do |f|
-        f.puts Puppet::IndirectorTesting.new(value).to_pson
+      File.open(subject.path(name, ''), 'wb') do |f|
+        f.puts Puppet::IndirectorTesting.new(value).to_json
       end
     end
 
@@ -188,5 +198,16 @@ describe Puppet::Indirector::JSON do
       create_file('foo.json~', 'foo-backup')
       expect(subject.search(request('f*')).map(&:value)).to eq(['foo-json'])
     end
+
+    it "raises if the content contains binary" do
+      binary = "\xC0\xFF".force_encoding(Encoding::BINARY)
+
+      File.binwrite(subject.path('foo.json', ''), "foo-json")
+      File.binwrite(subject.path("foo#{binary}.bin", ''), "foo-binary")
+
+      expect {
+        subject.search(request('*'))
+      }.to raise_error Puppet::Error, /Could not parse JSON data/
+    end
   end
 end

data/spec/unit/indirector/node/exec_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::Node::Exec do
   describe "when handling the results of the command" do
     let(:testing_env) { Puppet::Node::Environment.create(:testing, []) }
     let(:other_env) { Puppet::Node::Environment.create(:other, []) }
-
+    let(:request) { Puppet::Indirector::Request.new(:node, :find, @name, nil) }
     before do
       @name = "yay"
       @node = Puppet::Node.new(@name)
@@ -38,8 +38,6 @@ describe Puppet::Node::Exec do
       @searcher.meta_def(:execute) do |command, arguments|
         return YAML.dump(result)
       end
-
-      @request = Puppet::Indirector::Request.new(:node, :find, @name, nil)
     end
 
     around do |example|
@@ -52,35 +50,37 @@ describe Puppet::Node::Exec do
 
     it "should translate the YAML into a Node instance" do
       # Use an empty hash
-      expect(@searcher.find(@request)).to equal(@node)
+      expect(@searcher.find(request)).to equal(@node)
     end
 
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
-      @searcher.find(@request)
+      @searcher.find(request)
       expect(@node.parameters).to eq({"a" => "b", "c" => "d"})
     end
 
     it "should set the resulting classes as the node classes" do
       @result[:classes] = %w{one two}
-      @searcher.find(@request)
+      @searcher.find(request)
       expect(@node.classes).to eq([ 'one', 'two' ])
     end
 
-    it "should merge the node's facts with its parameters" do
-      @node.expects(:fact_merge)
-      @searcher.find(@request)
+    it "should merge facts from the request if supplied" do
+      facts = Puppet::Node::Facts.new('test', 'foo' => 'bar')
+      request.options[:facts] = facts
+      @node.expects(:fact_merge).with(facts)
+      @searcher.find(request)
     end
 
     it "should set the node's environment if one is provided" do
       @result[:environment] = "testing"
-      @searcher.find(@request)
+      @searcher.find(request)
       expect(@node.environment.name).to eq(:testing)
     end
 
     it "should set the node's environment based on the request if not otherwise provided" do
-      @request.environment = "other"
-      @searcher.find(@request)
+      request.environment = "other"
+      @searcher.find(request)
       expect(@node.environment.name).to eq(:other)
     end
   end

data/spec/unit/indirector/node/ldap_spec.rb

@@ -191,15 +191,36 @@ describe Puppet::Node::Ldap do
         expect(node_indirection.find(request).parameters).to include({"one" => false})
       end
 
-      it "should merge the node's facts after the parameters from ldap are assigned" do
-        # Make sure we've got data to start with, so the parameters are actually set.
-        params = {"one" => "yay", "two" => "hooray"}
-        @result[:parameters] = params
+      context("when merging facts") do
+        let(:request_facts) { Puppet::Node::Facts.new('test', 'foo' => 'bar') }
+        let(:indirection_facts) { Puppet::Node::Facts.new('test', 'baz' => 'qux') }
+
+        it "should merge facts from the request if supplied" do
+          request.options[:facts] = request_facts
+          Puppet::Node::Facts.stubs(:find) { indirection_facts }
+
+          expect(node_indirection.find(request).parameters).to include(request_facts.values)
+          expect(node_indirection.find(request).facts).to eq(request_facts)
+        end
+
+        it "should find facts if none are supplied" do
+          Puppet::Node::Facts.indirection.stubs(:find).with(nodename, :environment => environment).returns(indirection_facts)
+          request.options.delete(:facts)
 
-        # Node implements its own merge so that an existing param takes
-        # precedence over facts. We get the same result here by merging params
-        # into facts
-        expect(node_indirection.find(request).parameters).to eq(facts.values.merge(params))
+          expect(node_indirection.find(request).parameters).to include(indirection_facts.values)
+          expect(node_indirection.find(request).facts).to eq(indirection_facts)
+        end
+
+        it "should merge the node's facts after the parameters from ldap are assigned" do
+          # Make sure we've got data to start with, so the parameters are actually set.
+          params = {"one" => "yay", "two" => "hooray"}
+          @result[:parameters] = params
+
+          # Node implements its own merge so that an existing param takes
+          # precedence over facts. We get the same result here by merging params
+          # into facts
+          expect(node_indirection.find(request).parameters).to eq(facts.values.merge(params))
+        end
       end
 
       describe "and a parent node is specified" do

data/spec/unit/indirector/node/plain_spec.rb

@@ -5,18 +5,28 @@ require 'puppet/indirector/node/plain'
 
 describe Puppet::Node::Plain do
   let(:nodename) { "mynode" }
-  let(:fact_values) { {:afact => "a value"} }
-  let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
+  let(:indirection_fact_values) { {:afact => "a value"} }
+  let(:indirection_facts) { Puppet::Node::Facts.new(nodename, indirection_fact_values) }
+  let(:request_fact_values) { {:foo => "bar" } }
+  let(:request_facts) { Puppet::Node::Facts.new(nodename, request_fact_values)}
   let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
   let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
   let(:node_indirection) { Puppet::Node::Plain.new }
 
-  before do
-    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(facts)
+  it "should merge facts from the request if supplied" do
+    Puppet::Node::Facts.indirection.expects(:find).never
+    request.options[:facts] = request_facts
+    node = node_indirection.find(request)
+    expect(node.parameters).to include(request_fact_values)
+    expect(node.facts).to eq(request_facts)
   end
 
-  it "merges facts into the node" do
-    expect(node_indirection.find(request).parameters).to include(fact_values)
+  it "should find facts if none are supplied" do
+    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(indirection_facts)
+    request.options.delete(:facts)
+    node = node_indirection.find(request)
+    expect(node.parameters).to include(indirection_fact_values)
+    expect(node.facts).to eq(indirection_facts)
   end
 
   it "should set the node environment from the request" do