puppet 7.30.0-x86-mingw32 → 8.0.1-x86-mingw32

data/spec/unit/http/proxy_spec.rb

@@ -0,0 +1,347 @@
+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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,75 @@
+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