puppet 6.29.0-x86-mingw32 → 7.0.0-x86-mingw32

data/spec/unit/indirector/request_spec.rb

@@ -271,229 +271,6 @@ describe Puppet::Indirector::Request do
     expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node]).to eq('foo')
   end
 
-  describe "when building a query string from its options" do
-    def a_request_with_options(options)
-      Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
-    end
-
-    def the_parsed_query_string_from(request)
-      CGI.parse(request.query_string.sub(/^\?/, ''))
-    end
-
-    it "should return an empty query string if there are no options" do
-      request = a_request_with_options(nil)
-
-      expect(request.query_string).to eq("")
-    end
-
-    it "should return an empty query string if the options are empty" do
-      request = a_request_with_options({})
-
-      expect(request.query_string).to eq("")
-    end
-
-    it "should include all options in the query string, separated by '&'" do
-      request = a_request_with_options(:one => "two", :three => "four")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["two"],
-        "three" => ["four"]
-      })
-    end
-
-    it "should ignore nil options" do
-      request = a_request_with_options(:one => "two", :three => nil)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["two"]
-      })
-    end
-
-    it "should convert 'true' option values into strings" do
-      request = a_request_with_options(:one => true)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["true"]
-      })
-    end
-
-    it "should convert 'false' option values into strings" do
-      request = a_request_with_options(:one => false)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["false"]
-      })
-    end
-
-    it "should convert to a string all option values that are integers" do
-      request = a_request_with_options(:one => 50)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["50"]
-      })
-    end
-
-    it "should convert to a string all option values that are floating point numbers" do
-      request = a_request_with_options(:one => 1.2)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["1.2"]
-      })
-    end
-
-    it "should CGI-escape all option values that are strings" do
-      request = a_request_with_options(:one => "one two")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one two"]
-      })
-    end
-
-    it "should convert an array of values into multiple entries for the same key" do
-      request = a_request_with_options(:one => %w{one two})
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one", "two"]
-      })
-    end
-
-    it "should stringify simple data types inside an array" do
-      request = a_request_with_options(:one => ['one', nil])
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one"]
-      })
-    end
-
-    it "should error if an array contains another array" do
-      request = a_request_with_options(:one => ['one', ["not allowed"]])
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-
-    it "should error if an array contains illegal data" do
-      request = a_request_with_options(:one => ['one', { :not => "allowed" }])
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-
-    it "should convert to a string and CGI-escape all option values that are symbols" do
-      request = a_request_with_options(:one => :"sym bol")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["sym bol"]
-      })
-    end
-
-    it "should fail if options other than booleans or strings are provided" do
-      request = a_request_with_options(:one => { :one => :two })
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-  end
-
-  context '#do_request' do
-    before :each do
-      @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
-    end
-
-    context 'when not using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = false
-      end
-
-      it "yields the request with the default server and port when no server or port were specified on the original request" do
-        count = 0
-        rval = @request.do_request(:puppet, 'puppet.example.com', '90210') do |got|
-          count += 1
-          expect(got.server).to eq('puppet.example.com')
-          expect(got.port).to   eq('90210')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-
-        expect(rval).to eq('Block return value')
-      end
-    end
-
-    context 'when using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = true
-        Puppet.settings[:srv_domain]      = 'example.com'
-      end
-
-      it "yields the request with the original server and port unmodified" do
-        @request.server = 'puppet.example.com'
-        @request.port   = '90210'
-
-        count = 0
-        rval = @request.do_request do |got|
-          count += 1
-          expect(got.server).to eq('puppet.example.com')
-          expect(got.port).to   eq('90210')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-
-        expect(rval).to eq('Block return value')
-      end
-
-      context "when SRV returns servers" do
-        before :each do
-          @dns_mock = double('dns')
-          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
-
-          @port = 7205
-          @target = 'example.com'
-          record = Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @target)
-          record.instance_variable_set(:@ttl, 10)
-          @srv_records = [record]
-
-          expect(@dns_mock).to receive(:getresources).
-            with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
-            and_return(@srv_records)
-        end
-
-        it "yields a request using the server and port from the SRV record" do
-          count = 0
-          rval = @request.do_request do |got|
-            count += 1
-            expect(got.server).to eq('example.com')
-            expect(got.port).to eq(7205)
-
-            @block_return
-          end
-          expect(count).to eq(1)
-
-          expect(rval).to eq(@block_return)
-        end
-
-        it "should fall back to the default server when the block raises a SystemCallError" do
-          count = 0
-          second_pass = nil
-
-          rval = @request.do_request(:puppet, 'puppet', 8140) do |got|
-            count += 1
-
-            if got.server == 'example.com' then
-              raise SystemCallError, "example failure"
-            else
-              second_pass = got
-            end
-
-            @block_return
-          end
-
-          expect(second_pass.server).to eq('puppet')
-          expect(second_pass.port).to   eq(8140)
-          expect(count).to eq(2)
-
-          expect(rval).to eq(@block_return)
-        end
-      end
-    end
-  end
-
   describe "#remote?" do
     def request(options = {})
       Puppet::Indirector::Request.new('node', 'find', 'localhost', nil, options)
@@ -515,45 +292,4 @@ describe Puppet::Indirector::Request do
       expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
     end
   end
-
-  describe "failover" do
-    it "should use the provided failover host and port" do
-      Puppet.override(:server => 'myhost', :serverport => 666) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to eq('myhost')
-          expect(request.port).to eq(666)
-        end
-      end
-    end
-
-    it "should not use raw settings when failover fails" do
-      Puppet.override(:server => nil, :serverport => nil) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to be_nil
-          expect(request.port).to be_nil
-          expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:serverport]).not_to be_nil
-        end
-      end
-    end
-
-    it "should use server_list when set and failover has not occured" do
-      Puppet.settings[:server_list] = [['myhost',666]]
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq('myhost')
-        expect(request.port).to eq(666)
-      end
-    end
-
-    it "should use server when server_list is not set" do
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:serverport])
-      end
-    end
-  end
 end

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

@@ -1,85 +1,120 @@
 require 'spec_helper'
 require 'puppet/indirector/resource/ral'
 
-describe Puppet::Resource::Ral do
-  let(:my_instance) { Puppet::Type.type(:user).new(:name => "root") }
-  let(:wrong_instance) { Puppet::Type.type(:user).new(:name => "bob")}
-
-  def stub_retrieve(*instances)
-    instances.each do |i|
-      allow(i).to receive(:retrieve).and_return(Puppet::Resource.new(i, nil))
-    end
-  end
-
-  before do
-    described_class.indirection.terminus_class = :ral
-
-    # make sure we don't try to retrieve current state
-    allow_any_instance_of(Puppet::Type.type(:user)).to receive(:retrieve).never
-    stub_retrieve(my_instance, wrong_instance)
-  end
-
+describe "Puppet::Resource::Ral" do
   it "disallows remote requests" do
     expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(false)
   end
 
   describe "find" do
+    before do
+      @request = double('request', :key => "user/root")
+    end
+
     it "should find an existing instance" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
+      my_resource    = double("my user resource")
 
-      actual_resource = described_class.indirection.find('user/root')
-      expect(actual_resource.name).to eq('User/root')
+      wrong_instance = double("wrong user", :name => "bob")
+      my_instance    = double("my user",    :name => "root", :to_resource => my_resource)
+
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
+      expect(Puppet::Resource::Ral.new.find(@request)).to eq(my_resource)
     end
 
     it "should produce Puppet::Error instead of ArgumentError" do
-      expect{described_class.indirection.find('thiswill/causeanerror')}.to raise_error(Puppet::Error)
+      @bad_request = double('thiswillcauseanerror', :key => "thiswill/causeanerror")
+      expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
     end
 
     it "if there is no instance, it should create one" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([wrong_instance])
+      wrong_instance = double("wrong user", :name => "bob")
+      root = double("Root User")
+      root_resource = double("Root Resource")
+
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(root)
+      expect(root).to receive(:to_resource).and_return(root_resource)
+
+      result = Puppet::Resource::Ral.new.find(@request)
 
-      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(my_instance)
-      expect(described_class.indirection.find('user/root')).to be
+      expect(result).to eq(root_resource)
     end
   end
 
   describe "search" do
+    before do
+      @request = double('request', :key => "user/", :options => {})
+    end
+
     it "should convert ral resources into regular resources" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
+      my_resource = double("my user resource", :title => "my user resource")
+      my_instance = double("my user", :name => "root", :to_resource => my_resource)
 
-      actual = described_class.indirection.search('user')
-      expect(actual).to contain_exactly(an_instance_of(Puppet::Resource))
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
+      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should filter results by name if there's a name in the key" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      my_resource = double("my user resource", title: "my user resource")
+      allow(my_resource).to receive(:to_resource).and_return(my_resource)
+      allow(my_resource).to receive(:[]).with(:name).and_return("root")
+
+      wrong_resource = double("wrong resource")
+      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
+      allow(wrong_resource).to receive(:[]).with(:name).and_return("bad")
 
-      actual = described_class.indirection.search('user/root')
-      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/root'))
+      my_instance    = double("my user",    :to_resource => my_resource)
+      wrong_instance = double("wrong user", :to_resource => wrong_resource)
+
+      @request = double('request', :key => "user/root", :options => {})
+
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should filter results by query parameters" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      wrong_resource = double("my user resource", title: "my user resource")
+      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
+      allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
+
+      my_resource = double("wrong resource", title: "wrong resource")
+      allow(my_resource).to receive(:to_resource).and_return(my_resource)
+      allow(my_resource).to receive(:[]).with(:name).and_return("bob")
 
-      actual = described_class.indirection.search('user', name: 'bob')
-      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/bob'))
+      my_instance    = double("my user",    :to_resource => my_resource)
+      wrong_instance = double("wrong user", :to_resource => wrong_resource)
+
+      @request = double('request', :key => "user/", :options => {:name => "bob"})
+
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should return sorted results" do
-      a_instance = Puppet::Type.type(:user).new(:name => "alice")
-      b_instance = Puppet::Type.type(:user).new(:name => "bob")
-      stub_retrieve(a_instance, b_instance)
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
+      a_resource = double("alice resource")
+      allow(a_resource).to receive(:to_resource).and_return(a_resource)
+      allow(a_resource).to receive(:title).and_return("alice")
+
+      b_resource = double("bob resource")
+      allow(b_resource).to receive(:to_resource).and_return(b_resource)
+      allow(b_resource).to receive(:title).and_return("bob")
+
+      a_instance = double("alice user", :to_resource => a_resource)
+      b_instance = double("bob user",   :to_resource => b_resource)
+
+      @request = double('request', :key => "user/", :options => {})
 
-      expect(described_class.indirection.search('user').map(&:title)).to eq(['alice', 'bob'])
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
+      expect(Puppet::Resource::Ral.new.search(@request)).to eq([a_resource, b_resource])
     end
   end
 
   describe "save" do
     it "returns a report covering the application of the given resource to the system" do
       resource = Puppet::Resource.new(:notify, "the title")
+      ral = Puppet::Resource::Ral.new
 
-      applied_resource, report = described_class.indirection.save(resource, nil, environment: Puppet::Node::Environment.remote(:testing))
+      applied_resource, report = ral.save(Puppet::Indirector::Request.new(:ral, :save, 'testing', resource, :environment => Puppet::Node::Environment.remote(:testing)))
 
       expect(applied_resource.title).to eq("the title")
       expect(report.environment).to eq("testing")