puppet 7.27.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/indirector/request_spec.rb

@@ -1,295 +0,0 @@
-require 'spec_helper'
-require 'matchers/json'
-require 'puppet/indirector/request'
-
-describe Puppet::Indirector::Request do
-  include JSONMatchers
-
-  describe "when initializing" do
-    it "should always convert the indirection name to a symbol" do
-      expect(Puppet::Indirector::Request.new("ind", :method, "mykey", nil).indirection_name).to eq(:ind)
-    end
-
-    it "should use provided value as the key if it is a string" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, "mykey", nil).key).to eq("mykey")
-    end
-
-    it "should use provided value as the key if it is a symbol" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :mykey, nil).key).to eq(:mykey)
-    end
-
-    it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
-      instance = double('instance', :name => "mykey")
-      request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
-      expect(request.key).to eq("mykey")
-      expect(request.instance).to equal(instance)
-    end
-
-    it "should support options specified as a hash" do
-      expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, :one => :two) }.to_not raise_error
-    end
-
-    it "should support nil options" do
-      expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil) }.to_not raise_error
-    end
-
-    it "should support unspecified options" do
-      expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.to_not raise_error
-    end
-
-    it "should use an empty options hash if nil was provided" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil).options).to eq({})
-    end
-
-    it "should default to a nil node" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil).node).to be_nil
-    end
-
-    it "should set its node attribute if provided in the options" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "foo.com").node).to eq("foo.com")
-    end
-
-    it "should default to a nil ip" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip).to be_nil
-    end
-
-    it "should set its ip attribute if provided in the options" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ip => "192.168.0.1").ip).to eq("192.168.0.1")
-    end
-
-    it "should default to being unauthenticated" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil)).not_to be_authenticated
-    end
-
-    it "should set be marked authenticated if configured in the options" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :authenticated => "eh")).to be_authenticated
-    end
-
-    it "should keep its options as a hash even if a node is specified" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "eh").options).to be_instance_of(Hash)
-    end
-
-    it "should keep its options as a hash even if another option is specified" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :foo => "bar").options).to be_instance_of(Hash)
-    end
-
-    it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :server => "bar").options[:server]).to eq("bar")
-    end
-
-    it "should normalize options to use symbols as keys" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, "foo" => "bar").options[:foo]).to eq("bar")
-    end
-
-    describe "and the request key is a URI" do
-      let(:file) { File.expand_path("/my/file with spaces") }
-      let(:an_environment) { Puppet::Node::Environment.create(:an_environment, []) }
-      let(:env_loaders) { Puppet::Environments::Static.new(an_environment) }
-
-      around(:each) do |example|
-        Puppet.override({ :environments => env_loaders }, "Static environment loader for specs") do
-          example.run
-        end
-      end
-
-      describe "and the URI is a 'file' URI" do
-        before do
-          @request = Puppet::Indirector::Request.new(:ind, :method, "#{Puppet::Util.uri_unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
-        end
-
-        it "should set the request key to the unescaped full file path" do
-          expect(@request.key).to eq(file)
-        end
-
-        it "should not set the protocol" do
-          expect(@request.protocol).to be_nil
-        end
-
-        it "should not set the port" do
-          expect(@request.port).to be_nil
-        end
-
-        it "should not set the server" do
-          expect(@request.server).to be_nil
-        end
-      end
-
-      it "should set the protocol to the URI scheme" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).protocol).to eq("http")
-      end
-
-      it "should set the server if a server is provided" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).server).to eq("host")
-      end
-
-      it "should set the server and port if both are provided" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/", nil).port).to eq(543)
-      end
-
-      it "should default to the serverport if the URI scheme is 'puppet'" do
-        Puppet[:serverport] = "321"
-        expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/", nil).port).to eq(321)
-      end
-
-      it "should use the provided port if the URI scheme is not 'puppet'" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).port).to eq(80)
-      end
-
-      it "should set the request key to the unescaped path from the URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff with spaces", nil).key).to eq("stuff with spaces")
-      end
-
-      it "should set the request key to the unescaped path from the URI, in UTF-8 encoding" do
-        path = "\u4e07"
-        uri = "http://host/#{path}"
-        request = Puppet::Indirector::Request.new(:ind, :method, uri, nil)
-
-        expect(request.key).to eq(path)
-        expect(request.key.encoding).to eq(Encoding::UTF_8)
-      end
-
-      it "should set the request key properly given a UTF-8 URI" do
-        # different UTF-8 widths
-        # 1-byte A
-        # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-        # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-        # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-        mixed_utf8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ<U+070E>
-
-        key = "a/path/stu ff/#{mixed_utf8}"
-        req = Puppet::Indirector::Request.new(:ind, :method, "http:///#{key}", nil)
-        expect(req.key).to eq(key)
-        expect(req.key.encoding).to eq(Encoding::UTF_8)
-        expect(req.uri).to eq("http:///#{key}")
-      end
-
-      it "should set the :uri attribute to the full URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http:///a/path/stu ff", nil).uri).to eq('http:///a/path/stu ff')
-      end
-
-      it "should not parse relative URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "foo/bar", nil).uri).to be_nil
-      end
-
-      it "should not parse opaque URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "mailto:joe", nil).uri).to be_nil
-      end
-    end
-
-    it "should allow indication that it should not read a cached instance" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_cache => true)).to be_ignore_cache
-    end
-
-    it "should default to not ignoring the cache" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil)).not_to be_ignore_cache
-    end
-
-    it "should allow indication that it should not not read an instance from the terminus" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_terminus => true)).to be_ignore_terminus
-    end
-
-    it "should default to not ignoring the terminus" do
-      expect(Puppet::Indirector::Request.new(:ind, :method, :key, nil)).not_to be_ignore_terminus
-    end
-  end
-
-  it "should look use the Indirection class to return the appropriate indirection" do
-    ind = double('indirection')
-    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(ind)
-    request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
-
-    expect(request.indirection).to equal(ind)
-  end
-
-  it "should use its indirection to look up the appropriate model" do
-    ind = double('indirection')
-    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(ind)
-    request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
-
-    expect(ind).to receive(:model).and_return("mymodel")
-
-    expect(request.model).to eq("mymodel")
-  end
-
-  it "should fail intelligently when asked to find a model but the indirection cannot be found" do
-    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(nil)
-    request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
-
-    expect { request.model }.to raise_error(ArgumentError)
-  end
-
-  it "should have a method for determining if the request is plural or singular" do
-    expect(Puppet::Indirector::Request.new(:myind, :method, :key, nil)).to respond_to(:plural?)
-  end
-
-  it "should be considered plural if the method is 'search'" do
-    expect(Puppet::Indirector::Request.new(:myind, :search, :key, nil)).to be_plural
-  end
-
-  it "should not be considered plural if the method is not 'search'" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, :key, nil)).not_to be_plural
-  end
-
-  it "should use its uri, if it has one, as its description" do
-    Puppet.override(
-      { :environments => Puppet::Environments::Static.new(Puppet::Node::Environment.create(:baz, [])) },
-      "Static loader for spec"
-    ) do
-      expect(Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).description).to eq("foo://bar/baz")
-    end
-  end
-
-  it "should use its indirection name and key, if it has no uri, as its description" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, "key", nil).description).to eq("/myind/key")
-  end
-
-  it "should set its environment to an environment instance when a string is specified as its environment" do
-    env = Puppet::Node::Environment.create(:foo, [])
-
-    Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
-      expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment).to eq(env)
-    end
-  end
-
-  it "should use any passed in environment instances as its environment" do
-    env = Puppet::Node::Environment.create(:foo, [])
-
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment).to equal(env)
-  end
-
-  it "should use the current environment when none is provided" do
-    Puppet[:environment] = "foo"
-
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).environment).to eq(Puppet.lookup(:current_environment))
-  end
-
-  it "should support converting its options to a hash" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil )).to respond_to(:to_hash)
-  end
-
-  it "should include all of its attributes when its options are converted to a hash" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node]).to eq('foo')
-  end
-
-  describe "#remote?" do
-    def request(options = {})
-      Puppet::Indirector::Request.new('node', 'find', 'localhost', nil, options)
-    end
-
-    it "should not be unless node or ip is set" do
-      expect(request).not_to be_remote
-    end
-
-    it "should be remote if node is set" do
-      expect(request(:node => 'example.com')).to be_remote
-    end
-
-    it "should be remote if ip is set" do
-      expect(request(:ip => '127.0.0.1')).to be_remote
-    end
-
-    it "should be remote if node and ip are set" do
-      expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-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
-
-  it "disallows remote requests" do
-    expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(false)
-  end
-
-  describe "find" do
-    it "should find an existing instance" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
-
-      actual_resource = described_class.indirection.find('user/root')
-      expect(actual_resource.name).to eq('User/root')
-    end
-
-    it "should produce Puppet::Error instead of ArgumentError" do
-      expect{described_class.indirection.find('thiswill/causeanerror')}.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])
-
-      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
-    end
-  end
-
-  describe "search" do
-    it "should convert ral resources into regular resources" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
-
-      actual = described_class.indirection.search('user')
-      expect(actual).to contain_exactly(an_instance_of(Puppet::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 ])
-
-      actual = described_class.indirection.search('user/root')
-      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/root'))
-    end
-
-    it "should filter results by query parameters" do
-      allow(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
-
-      actual = described_class.indirection.search('user', name: 'bob')
-      expect(actual).to contain_exactly(an_object_having_attributes(name: 'User/bob'))
-    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 ])
-
-      expect(described_class.indirection.search('user').map(&:title)).to eq(['alice', 'bob'])
-    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")
-
-      applied_resource, report = described_class.indirection.save(resource, nil, environment: Puppet::Node::Environment.remote(:testing))
-
-      expect(applied_resource.title).to eq("the title")
-      expect(report.environment).to eq("testing")
-      expect(report.resource_statuses["Notify[the title]"].changed).to eq(true)
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'puppet/resource'
-require 'puppet/indirector/memory'
-require 'puppet/indirector/resource/store_configs'
-
-class Puppet::Resource::StoreConfigsTesting < Puppet::Indirector::Memory
-end
-
-describe Puppet::Resource::StoreConfigs do
-  it_should_behave_like "a StoreConfigs terminus"
-
-  before :each do
-    Puppet[:storeconfigs] = true
-    Puppet[:storeconfigs_backend] = "store_configs_testing"
-  end
-
-  it "disallows remote requests" do
-    expect(Puppet::Resource::StoreConfigs.new.allow_remote_requests?).to eq(false)
-  end
-end

data/spec/unit/indirector/rest_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/rest'
-
-class Puppet::TestModel
-  extend Puppet::Indirector
-  indirects :test_model
-end
-
-# The subclass must not be all caps even though the superclass is
-class Puppet::TestModel::Rest < Puppet::Indirector::REST
-end
-
-class Puppet::FailingTestModel
-  extend Puppet::Indirector
-  indirects :failing_test_model
-end
-
-# The subclass must not be all caps even though the superclass is
-class Puppet::FailingTestModel::Rest < Puppet::Indirector::REST
-  def find(request)
-    http = Puppet.runtime[:http]
-    response = http.get(URI('http://puppet.example.com:8140/puppet/v3/failing_test_model'))
-
-    if response.code == 404
-      return nil unless request.options[:fail_on_404]
-
-      _, body = parse_response(response)
-      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(response.url.path, 100), body: body }
-      raise Puppet::Error, msg
-    else
-      raise convert_to_http_error(response)
-    end
-  end
-end
-
-describe Puppet::Indirector::REST do
-  before :each do
-    Puppet::TestModel.indirection.terminus_class = :rest
-  end
-
-  it "raises when find is called" do
-    expect {
-      Puppet::TestModel.indirection.find('foo')
-    }.to raise_error(NotImplementedError)
-  end
-
-  it "raises when head is called" do
-    expect {
-      Puppet::TestModel.indirection.head('foo')
-    }.to raise_error(NotImplementedError)
-  end
-
-  it "raises when search is called" do
-    expect {
-      Puppet::TestModel.indirection.search('foo')
-    }.to raise_error(NotImplementedError)
-  end
-
-  it "raises when save is called" do
-    expect {
-      Puppet::TestModel.indirection.save(Puppet::TestModel.new, 'foo')
-    }.to raise_error(NotImplementedError)
-  end
-
-  it "raises when destroy is called" do
-    expect {
-      Puppet::TestModel.indirection.destroy('foo')
-    }.to raise_error(NotImplementedError)
-  end
-
-  context 'when parsing the response error' do
-    before :each do
-      Puppet::FailingTestModel.indirection.terminus_class = :rest
-    end
-
-    it 'returns nil if 404 is returned and fail_on_404 is omitted' do
-      stub_request(:get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model').to_return(status: 404)
-
-      expect(Puppet::FailingTestModel.indirection.find('foo')).to be_nil
-    end
-
-    it 'raises if 404 is returned and fail_on_404 is true' do
-      stub_request(
-        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model',
-      ).to_return(status: 404,
-                  headers: { 'Content-Type' => 'text/plain' },
-                  body: 'plaintext')
-
-      expect {
-        Puppet::FailingTestModel.indirection.find('foo', fail_on_404: true)
-      }.to raise_error(Puppet::Error, 'Find /puppet/v3/failing_test_model resulted in 404 with the message: plaintext')
-    end
-
-    it 'returns the HTTP reason if the response body is empty' do
-      stub_request(:get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model').to_return(status: [500, 'Internal Server Error'])
-
-      expect {
-        Puppet::FailingTestModel.indirection.find('foo')
-      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: Internal Server Error')
-    end
-
-    it 'parses the response body as text' do
-      stub_request(
-        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
-      ).to_return(status: [500, 'Internal Server Error'],
-                  headers: { 'Content-Type' => 'text/plain' },
-                  body: 'plaintext')
-
-      expect {
-        Puppet::FailingTestModel.indirection.find('foo')
-      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: plaintext')
-    end
-
-    it 'parses the response body as json and returns the "message"' do
-      stub_request(
-        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
-      ).to_return(status: [500, 'Internal Server Error'],
-                  headers: { 'Content-Type' => 'application/json' },
-                  body: JSON.dump({'status' => false, 'message' => 'json error'}))
-
-      expect {
-        Puppet::FailingTestModel.indirection.find('foo')
-      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: json error')
-    end
-
-    it 'parses the response body as pson and returns the "message"' do
-      stub_request(
-        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
-      ).to_return(status: [500, 'Internal Server Error'],
-                  headers: { 'Content-Type' => 'application/pson' },
-                  body: PSON.dump({'status' => false, 'message' => 'pson error'}))
-
-      expect {
-        Puppet::FailingTestModel.indirection.find('foo')
-      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: pson error')
-    end
-
-    it 'returns the response body if no content-type given' do
-      stub_request(
-        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
-      ).to_return(status: [500, 'Internal Server Error'],
-                  body: 'unknown text')
-
-      expect {
-        Puppet::FailingTestModel.indirection.find('foo')
-      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: unknown text')
-    end
-  end
-end