puppet 8.4.0-x64-mingw32 → 8.5.1-x64-mingw32

data/spec/unit/http/proxy_spec.rb

@@ -1,347 +0,0 @@
-require 'uri'
-require 'spec_helper'
-require 'puppet/http'
-
-describe Puppet::HTTP::Proxy do
-  before(:all) do
-    ENV['http_proxy'] = nil
-    ENV['HTTP_PROXY'] = nil
-  end
-
-  host, port, user, password = 'some.host', 1234, 'user1', 'pAssw0rd'
-
-  def expects_direct_connection_to(http, www)
-    expect(http.address).to eq(www.host)
-    expect(http.port).to eq(www.port)
-
-    expect(http.proxy_address).to be_nil
-    expect(http.proxy_port).to be_nil
-    expect(http.proxy_user).to be_nil
-    expect(http.proxy_pass).to be_nil
-  end
-
-  def expects_proxy_connection_via(http, www, host, port, user, password)
-    expect(http.address).to eq(www.host)
-    expect(http.port).to eq(www.port)
-
-    expect(http.proxy_address).to eq(host)
-    expect(http.proxy_port).to eq(port)
-    expect(http.proxy_user).to eq(user)
-    expect(http.proxy_pass).to eq(password)
-  end
-
-  describe '.proxy' do
-    let(:www) { URI::HTTP.build(host: 'www.example.com', port: 80) }
-
-    it 'uses a proxy' do
-      Puppet[:http_proxy_host] = host
-      Puppet[:http_proxy_port] = port
-      Puppet[:http_proxy_user] = user
-      Puppet[:http_proxy_password] = password
-
-      http = subject.proxy(www)
-      expects_proxy_connection_via(http, www, host, port, user, password)
-    end
-
-    it 'connects directly to the server' do
-      http = subject.proxy(www)
-      expects_direct_connection_to(http, www)
-    end
-
-    it 'connects directly to the server when HTTP_PROXY environment variable is set, but server matches no_proxy setting' do
-      Puppet[:http_proxy_host] = host
-      Puppet[:http_proxy_port] = port
-      Puppet[:no_proxy] = www.host
-
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-    end
-
-    context 'when setting no_proxy' do
-      before :each do
-        Puppet[:http_proxy_host] = host
-        Puppet[:http_proxy_port] = port
-      end
-
-      it 'connects directly to the server when HTTP_PROXY environment variable is set, but server matches no_proxy setting' do
-        Puppet[:no_proxy] = www.host
-
-        Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-          http = subject.proxy(www)
-          expects_direct_connection_to(http, www)
-        end
-      end
-
-      it 'connects directly to the server when no_proxy matches wildcard domain' do
-        Puppet[:no_proxy] = '*.example.com'
-
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-
-      it 'connects directly to the server when no_proxy matches dotted domain' do
-        Puppet[:no_proxy] = '.example.com'
-
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-
-      it 'connects directly to the server when no_proxy matches a domain suffix like ruby does' do
-        Puppet[:no_proxy] = 'example.com'
-
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-
-      it 'connects directly to the server when no_proxy matches a partial suffix like ruby does' do
-        Puppet[:no_proxy] = 'ample.com'
-
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-
-      it 'connects directly to the server when it is a subdomain of no_proxy' do
-        Puppet[:no_proxy] = '*.com'
-
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-
-      it 'connects directly to the server when no_proxy is *' do
-        Puppet[:no_proxy] = '*'
-
-        http = subject.proxy(www)
-        expects_direct_connection_to(http, www)
-      end
-    end
-  end
-
-  describe ".http_proxy_env" do
-    it "should return nil if no environment variables" do
-      expect(subject.http_proxy_env).to eq(nil)
-    end
-
-    it "should return a URI::HTTP object if http_proxy env variable is set" do
-      Puppet::Util.withenv('HTTP_PROXY' => host) do
-        expect(subject.http_proxy_env).to eq(URI.parse(host))
-      end
-    end
-
-    it "should return a URI::HTTP object if HTTP_PROXY env variable is set" do
-      Puppet::Util.withenv('HTTP_PROXY' => host) do
-        expect(subject.http_proxy_env).to eq(URI.parse(host))
-      end
-    end
-
-    it "should return a URI::HTTP object with .host and .port if URI is given" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        expect(subject.http_proxy_env).to eq(URI.parse("http://#{host}:#{port}"))
-      end
-    end
-
-    it "should return nil if proxy variable is malformed" do
-      Puppet::Util.withenv('HTTP_PROXY' => 'this is not a valid URI') do
-        expect(subject.http_proxy_env).to eq(nil)
-      end
-    end
-  end
-
-  describe ".http_proxy_host" do
-    it "should return nil if no proxy host in config or env" do
-      expect(subject.http_proxy_host).to eq(nil)
-    end
-
-    it "should return a proxy host if set in config" do
-      Puppet.settings[:http_proxy_host] = host
-      expect(subject.http_proxy_host).to eq(host)
-    end
-
-    it "should return nil if set to `none` in config" do
-      Puppet.settings[:http_proxy_host] = 'none'
-      expect(subject.http_proxy_host).to eq(nil)
-    end
-
-    it "uses environment variable before puppet settings" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        Puppet.settings[:http_proxy_host] = 'not.correct'
-        expect(subject.http_proxy_host).to eq(host)
-      end
-    end
-  end
-
-  describe ".http_proxy_port" do
-    it "should return a proxy port if set in environment" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        expect(subject.http_proxy_port).to eq(port)
-      end
-    end
-
-    it "should return a proxy port if set in config" do
-      Puppet.settings[:http_proxy_port] = port
-      expect(subject.http_proxy_port).to eq(port)
-    end
-
-    it "uses environment variable before puppet settings" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
-        Puppet.settings[:http_proxy_port] = 7456
-        expect(subject.http_proxy_port).to eq(port)
-      end
-    end
-
-  end
-
-  describe ".http_proxy_user" do
-    it "should return a proxy user if set in environment" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
-        expect(subject.http_proxy_user).to eq(user)
-      end
-    end
-
-    it "should return a proxy user if set in config" do
-      Puppet.settings[:http_proxy_user] = user
-      expect(subject.http_proxy_user).to eq(user)
-    end
-
-    it "should use environment variable before puppet settings" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
-        Puppet.settings[:http_proxy_user] = 'clownpants'
-        expect(subject.http_proxy_user).to eq(user)
-      end
-    end
-
-  end
-
-  describe ".http_proxy_password" do
-    it "should return a proxy password if set in environment" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
-        expect(subject.http_proxy_password).to eq(password)
-      end
-    end
-
-    it "should return a proxy password if set in config" do
-      Puppet.settings[:http_proxy_user] = user
-      Puppet.settings[:http_proxy_password] = password
-      expect(subject.http_proxy_password).to eq(password)
-    end
-
-    it "should use environment variable before puppet settings" do
-      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
-        Puppet.settings[:http_proxy_password] = 'clownpants'
-        expect(subject.http_proxy_password).to eq(password)
-      end
-    end
-
-  end
-
-  describe ".no_proxy" do
-    no_proxy = '127.0.0.1, localhost'
-    it "should use a no_proxy list if set in environment" do
-      Puppet::Util.withenv('NO_PROXY' => no_proxy) do
-        expect(subject.no_proxy).to eq(no_proxy)
-      end
-    end
-
-    it "should use a no_proxy list if set in config" do
-      Puppet.settings[:no_proxy] = no_proxy
-      expect(subject.no_proxy).to eq(no_proxy)
-    end
-
-    it "should use environment variable before puppet settings" do
-      no_proxy_puppet_setting = '10.0.0.1, localhost'
-      Puppet::Util.withenv('NO_PROXY' => no_proxy) do
-        Puppet.settings[:no_proxy] = no_proxy_puppet_setting
-        expect(subject.no_proxy).to eq(no_proxy)
-      end
-    end
-  end
-
-  describe ".no_proxy?" do
-    no_proxy = '127.0.0.1, localhost, mydomain.com, *.otherdomain.com, oddport.com:8080, *.otheroddport.com:8080, .anotherdomain.com, .anotheroddport.com:8080'
-
-    it "should return false if no_proxy does not exist in environment or puppet settings" do
-      Puppet::Util.withenv('no_proxy' => nil) do
-        dest = 'https://puppetlabs.com'
-        expect(subject.no_proxy?(dest)).to be false
-      end
-    end
-
-    it "should return false if the dest does not match any element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'https://puppetlabs.com'
-        expect(subject.no_proxy?(dest)).to be false
-      end
-    end
-
-    it "should return true if the dest as an IP does match any element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://127.0.0.1'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return true if the dest as single word does match any element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://localhost'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return true if the dest as standard domain word does match any element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://mydomain.com'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return true if the dest as standard domain with port does match any element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://oddport.com:8080'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return false if the dest is standard domain not matching port" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://oddport.com'
-        expect(subject.no_proxy?(dest)).to be false
-      end
-    end
-
-    it "should return true if the dest does match any wildcarded element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://sub.otherdomain.com'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return true if the dest does match any wildcarded element with port in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://sub.otheroddport.com:8080'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return true if the dest does match any domain level (no wildcard) element in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://sub.anotherdomain.com'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should return true if the dest does match any domain level (no wildcard) element with port in the no_proxy list" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = 'http://sub.anotheroddport.com:8080'
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-
-    it "should work if passed a URI object" do
-      Puppet::Util.withenv('no_proxy' => no_proxy) do
-        dest = URI.parse('http://sub.otheroddport.com:8080')
-        expect(subject.no_proxy?(dest)).to be true
-      end
-    end
-  end
-end

data/spec/unit/http/resolver_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-require 'puppet/http'
-
-describe Puppet::HTTP::Resolver do
-  let(:ssl_context) { Puppet::SSL::SSLContext.new }
-  let(:client) { Puppet::HTTP::Client.new(ssl_context: ssl_context) }
-  let(:session) { client.create_session }
-  let(:uri) { URI.parse('https://www.example.com') }
-
-  context 'when resolving using settings' do
-    let(:subject) { Puppet::HTTP::Resolver::Settings.new(client) }
-
-    it 'returns a service based on the current ca_server and ca_port settings' do
-      Puppet[:ca_server] = 'ca.example.com'
-      Puppet[:ca_port] = 8141
-
-      service = subject.resolve(session, :ca)
-      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
-    end
-  end
-
-  context 'when resolving using server_list' do
-    let(:subject) { Puppet::HTTP::Resolver::ServerList.new(client, server_list_setting: Puppet.settings.setting(:server_list), default_port: 8142, services: Puppet::HTTP::Service::SERVICE_NAMES) }
-
-    before :each do
-      Puppet[:server_list] = 'ca.example.com:8141,apple.example.com'
-    end
-
-    it 'returns a service based on the current server_list setting' do
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 200)
-
-      service = subject.resolve(session, :ca)
-      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
-    end
-
-    it 'returns a service based on the current server_list setting if the server returns any success codes' do
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 202)
-
-      service = subject.resolve(session, :ca)
-      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-      expect(service.url.to_s).to eq("https://ca.example.com:8141/puppet-ca/v1")
-    end
-
-    it 'includes extra http headers' do
-      Puppet[:http_extra_headers] = 'region:us-west'
-
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server")
-        .with(headers: {'Region' => 'us-west'})
-
-      subject.resolve(session, :ca)
-    end
-
-    it 'uses the provided ssl context during resolution' do
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 200)
-
-      other_ctx = Puppet::SSL::SSLContext.new
-      expect(client).to receive(:connect).with(URI("https://ca.example.com:8141/status/v1/simple/server"), options: {ssl_context: other_ctx}).and_call_original
-
-      subject.resolve(session, :ca, ssl_context: other_ctx)
-    end
-
-    it 'logs unsuccessful HTTP 500 responses' do
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: [500, 'Internal Server Error'])
-      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 200)
-
-      subject.resolve(session, :ca)
-
-      expect(@logs.map(&:message)).to include(/Puppet server ca.example.com:8141 is unavailable: 500 Internal Server Error/)
-    end
-
-    it 'cancels resolution if no servers in server_list are accessible' do
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 503)
-      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 503)
-
-      canceled = false
-      canceled_handler = lambda { |cancel| canceled = cancel }
-
-      expect(subject.resolve(session, :ca, canceled_handler: canceled_handler)).to eq(nil)
-      expect(canceled).to eq(true)
-    end
-
-    it 'cycles through server_list until a valid server is found' do
-      stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 503)
-      stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 200)
-
-      service = subject.resolve(session, :ca)
-      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet-ca/v1")
-    end
-
-    it 'resolves once per session' do
-      failed = stub_request(:get, "https://ca.example.com:8141/status/v1/simple/server").to_return(status: 503)
-      passed = stub_request(:get, "https://apple.example.com:8142/status/v1/simple/server").to_return(status: 200)
-
-      service = subject.resolve(session, :puppet)
-      expect(service).to be_a(Puppet::HTTP::Service::Compiler)
-      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
-
-      service = subject.resolve(session, :fileserver)
-      expect(service).to be_a(Puppet::HTTP::Service::FileServer)
-      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
-
-      service = subject.resolve(session, :report)
-      expect(service).to be_a(Puppet::HTTP::Service::Report)
-      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
-
-      expect(failed).to have_been_requested
-      expect(passed).to have_been_requested
-    end
-  end
-
-  context 'when resolving using SRV' do
-    let(:dns) { double('dns') }
-    let(:subject) { Puppet::HTTP::Resolver::SRV.new(client, domain: 'example.com', dns: dns) }
-
-    def stub_srv(host, port)
-      srv = Resolv::DNS::Resource::IN::SRV.new(0, 0, port, host)
-      srv.instance_variable_set :@ttl, 3600
-
-      allow(dns).to receive(:getresources).with("_x-puppet-ca._tcp.example.com", Resolv::DNS::Resource::IN::SRV).and_return([srv])
-    end
-
-    it 'returns a service based on an SRV record' do
-      stub_srv('ca1.example.com', 8142)
-
-      service = subject.resolve(session, :ca)
-      expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
-      expect(service.url.to_s).to eq("https://ca1.example.com:8142/puppet-ca/v1")
-    end
-  end
-end

data/spec/unit/http/response_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'puppet/http'
-
-describe Puppet::HTTP::Response do
-  let(:uri) { URI.parse('https://www.example.com') }
-  let(:client) { Puppet::HTTP::Client.new }
-
-  it "returns the request URL" do
-    stub_request(:get, uri)
-
-    response = client.get(uri)
-    expect(response.url).to eq(uri)
-  end
-
-  it "returns the HTTP code" do
-    stub_request(:get, uri)
-
-    response = client.get(uri)
-    expect(response.code).to eq(200)
-  end
-
-  it "returns the HTTP reason string" do
-    stub_request(:get, uri).to_return(status: [418, "I'm a teapot"])
-
-    response = client.get(uri)
-    expect(response.reason).to eq("I'm a teapot")
-  end
-
-  it "returns the response body" do
-    stub_request(:get, uri).to_return(status: 200, body: "I'm the body")
-
-    response = client.get(uri)
-    expect(response.body).to eq("I'm the body")
-  end
-
-  it "streams the response body" do
-    stub_request(:get, uri).to_return(status: 200, body: "I'm the streaming body")
-
-    content = StringIO.new
-    client.get(uri) do |response|
-      response.read_body do |data|
-        content << data
-      end
-    end
-    expect(content.string).to eq("I'm the streaming body")
-  end
-
-  it "raises if a block isn't given when streaming" do
-    stub_request(:get, uri).to_return(status: 200, body: "")
-
-    expect {
-      client.get(uri) do |response|
-        response.read_body
-      end
-    }.to raise_error(Puppet::HTTP::HTTPError, %r{Request to https://www.example.com failed after .* seconds: A block is required})
-  end
-
-  it "returns success for all 2xx codes" do
-    stub_request(:get, uri).to_return(status: 202)
-
-    expect(client.get(uri)).to be_success
-  end
-
-  it "returns a header value" do
-    stub_request(:get, uri).to_return(status: 200, headers: { 'Content-Encoding' => 'gzip' })
-
-    expect(client.get(uri)['Content-Encoding']).to eq('gzip')
-  end
-
-  it "enumerates headers" do
-    stub_request(:get, uri).to_return(status: 200, headers: { 'Content-Encoding' => 'gzip' })
-
-    expect(client.get(uri).each_header.to_a).to eq([['content-encoding', 'gzip']])
-  end
-end