puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/unit/network/http/factory_spec.rb

@@ -0,0 +1,82 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Factory do
+  before :each do
+    Puppet::SSL::Key.indirection.terminus_class = :memory
+    Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
+  end
+
+  let(:site) { Puppet::Network::HTTP::Site.new('https', 'www.example.com', 443) }
+  def create_connection(site)
+    factory = Puppet::Network::HTTP::Factory.new
+
+    factory.create_connection(site)
+  end
+
+  it 'creates a connection for the site' do
+    conn = create_connection(site)
+
+    expect(conn.use_ssl?).to be_true
+    expect(conn.address).to eq(site.host)
+    expect(conn.port).to eq(site.port)
+  end
+
+  it 'creates a connection that has not yet been started' do
+    conn = create_connection(site)
+
+    expect(conn).to_not be_started
+  end
+
+  it 'creates a connection supporting at least HTTP 1.1' do
+    conn = create_connection(site)
+
+    expect(any_of(conn.class.version_1_1?, conn.class.version_1_1?)).to be_true
+  end
+
+  context "proxy settings" do
+    let(:proxy_host) { 'myhost' }
+    let(:proxy_port) { 432 }
+
+    it "should not set a proxy if the value is 'none'" do
+      Puppet[:http_proxy_host] = 'none'
+      conn = create_connection(site)
+
+      expect(conn.proxy_address).to be_nil
+    end
+
+    it 'sets proxy_address' do
+      Puppet[:http_proxy_host] = proxy_host
+      conn = create_connection(site)
+
+      expect(conn.proxy_address).to eq(proxy_host)
+    end
+
+    it 'sets proxy address and port' do
+      Puppet[:http_proxy_host] = proxy_host
+      Puppet[:http_proxy_port] = proxy_port
+      conn = create_connection(site)
+
+      expect(conn.proxy_port).to eq(proxy_port)
+    end
+
+    context 'socket timeouts' do
+      let(:timeout) { 5 }
+
+      it 'sets open timeout' do
+        Puppet[:configtimeout] = timeout
+        conn = create_connection(site)
+
+        expect(conn.open_timeout).to eq(timeout)
+      end
+
+      it 'sets read timeout' do
+        Puppet[:configtimeout] = timeout
+        conn = create_connection(site)
+
+        expect(conn.read_timeout).to eq(timeout)
+      end
+    end
+  end
+end

data/spec/unit/network/http/handler_spec.rb

@@ -103,31 +103,30 @@ describe Puppet::Network::HTTP::Handler do
       handler.stubs(:warn_if_near_expiration)
     end
 
-    it "should check the client certificate for upcoming expiration" do
-      request = a_request
-      cert = mock 'cert'
-      handler.expects(:client_cert).returns(cert).with(request)
-      handler.expects(:warn_if_near_expiration).with(cert)
-
-      handler.process(request, response)
-    end
-
     it "should setup a profiler when the puppet-profiling header exists" do
       request = a_request
       request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"
 
-      handler.process(request, response)
+      p = HandlerTestProfiler.new
+
+      Puppet::Util::Profiler.expects(:add_profiler).with { |profiler|
+        profiler.is_a? Puppet::Util::Profiler::WallClock
+      }.returns(p)
 
-      Puppet::Util::Profiler.current.should be_kind_of(Puppet::Util::Profiler::WallClock)
+      Puppet::Util::Profiler.expects(:remove_profiler).with { |profiler|
+        profiler == p
+      }
+
+      handler.process(request, response)
     end
 
     it "should not setup profiler when the profile parameter is missing" do
       request = a_request
       request[:params] = { }
 
-      handler.process(request, response)
+      Puppet::Util::Profiler.expects(:add_profiler).never
 
-      Puppet::Util::Profiler.current.should == Puppet::Util::Profiler::NONE
+      handler.process(request, response)
     end
 
     it "should raise an error if the request is formatted in an unknown format" do
@@ -219,4 +218,15 @@ describe Puppet::Network::HTTP::Handler do
       request[:headers] || {}
     end
   end
+
+  class HandlerTestProfiler
+    def start(metric, description)
+    end
+
+    def finish(context, metric, description)
+    end
+
+    def shutdown()
+    end
+  end
 end

data/spec/unit/network/http/nocache_pool_spec.rb

@@ -0,0 +1,43 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/network/http'
+require 'puppet/network/http/connection'
+
+describe Puppet::Network::HTTP::NoCachePool do
+  let(:site) { Puppet::Network::HTTP::Site.new('https', 'rubygems.org', 443) }
+  let(:verify) { stub('verify', :setup_connection => nil) }
+
+  it 'yields a connection' do
+    http  = stub('http')
+
+    factory = Puppet::Network::HTTP::Factory.new
+    factory.stubs(:create_connection).returns(http)
+    pool = Puppet::Network::HTTP::NoCachePool.new(factory)
+
+    expect { |b|
+      pool.with_connection(site, verify, &b)
+    }.to yield_with_args(http)
+  end
+
+  it 'yields a new connection each time' do
+    http1  = stub('http1')
+    http2  = stub('http2')
+
+    factory = Puppet::Network::HTTP::Factory.new
+    factory.stubs(:create_connection).returns(http1).then.returns(http2)
+    pool = Puppet::Network::HTTP::NoCachePool.new(factory)
+
+    expect { |b|
+      pool.with_connection(site, verify, &b)
+    }.to yield_with_args(http1)
+
+    expect { |b|
+      pool.with_connection(site, verify, &b)
+    }.to yield_with_args(http2)
+  end
+
+  it 'has a close method' do
+    Puppet::Network::HTTP::NoCachePool.new.close
+  end
+end

data/spec/unit/network/http/pool_spec.rb

@@ -0,0 +1,269 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'openssl'
+require 'puppet/network/http'
+require 'puppet/network/http_pool'
+
+describe Puppet::Network::HTTP::Pool do
+  before :each do
+    Puppet::SSL::Key.indirection.terminus_class = :memory
+    Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
+  end
+
+  let(:site) do
+    Puppet::Network::HTTP::Site.new('https', 'rubygems.org', 443)
+  end
+
+  let(:different_site) do
+    Puppet::Network::HTTP::Site.new('https', 'github.com', 443)
+  end
+
+  let(:verify) do
+    stub('verify', :setup_connection => nil)
+  end
+
+  def create_pool
+    Puppet::Network::HTTP::Pool.new
+  end
+
+  def create_pool_with_connections(site, *connections)
+    pool = Puppet::Network::HTTP::Pool.new
+    connections.each do |conn|
+      pool.release(site, conn)
+    end
+    pool
+  end
+
+  def create_pool_with_expired_connections(site, *connections)
+    # setting keepalive timeout to -1 ensures any newly added
+    # connections have already expired
+    pool = Puppet::Network::HTTP::Pool.new(-1)
+    connections.each do |conn|
+      pool.release(site, conn)
+    end
+    pool
+  end
+
+  def create_connection(site)
+    stub(site.addr, :started? => false, :start => nil, :finish => nil, :use_ssl? => true, :verify_mode => OpenSSL::SSL::VERIFY_PEER)
+  end
+
+  context 'when yielding a connection' do
+    it 'yields a connection' do
+      conn = create_connection(site)
+      pool = create_pool_with_connections(site, conn)
+
+      expect { |b|
+        pool.with_connection(site, verify, &b)
+      }.to yield_with_args(conn)
+    end
+
+    it 'returns the connection to the pool' do
+      conn = create_connection(site)
+      pool = create_pool
+      pool.release(site, conn)
+
+      pool.with_connection(site, verify) { |c| }
+
+      expect(pool.pool[site].first.connection).to eq(conn)
+    end
+
+    it 'can yield multiple connections to the same site' do
+      lru_conn = create_connection(site)
+      mru_conn = create_connection(site)
+      pool = create_pool_with_connections(site, lru_conn, mru_conn)
+
+      pool.with_connection(site, verify) do |a|
+        expect(a).to eq(mru_conn)
+
+        pool.with_connection(site, verify) do |b|
+          expect(b).to eq(lru_conn)
+        end
+      end
+    end
+
+    it 'propagates exceptions' do
+      conn = create_connection(site)
+      pool = create_pool
+      pool.release(site, conn)
+
+      expect {
+        pool.with_connection(site, verify) do |c|
+          raise IOError, 'connection reset'
+        end
+      }.to raise_error(IOError, 'connection reset')
+    end
+
+    it 'does not re-cache connections when an error occurs' do
+      # we're not distinguishing between network errors that would
+      # suggest we close the socket, and other errors
+      conn = create_connection(site)
+      pool = create_pool
+      pool.release(site, conn)
+
+      pool.expects(:release).with(site, conn).never
+
+      pool.with_connection(site, verify) do |c|
+        raise IOError, 'connection reset'
+      end rescue nil
+    end
+
+    context 'when releasing connections' do
+      it 'releases HTTP connections' do
+        conn = create_connection(site)
+        conn.expects(:use_ssl?).returns(false)
+
+        pool = create_pool_with_connections(site, conn)
+        pool.expects(:release).with(site, conn)
+
+        pool.with_connection(site, verify) {|c| }
+      end
+
+      it 'releases secure HTTPS connections' do
+        conn = create_connection(site)
+        conn.expects(:use_ssl?).returns(true)
+        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_PEER)
+
+        pool = create_pool_with_connections(site, conn)
+        pool.expects(:release).with(site, conn)
+
+        pool.with_connection(site, verify) {|c| }
+      end
+
+      it 'closes insecure HTTPS connections' do
+        conn = create_connection(site)
+        conn.expects(:use_ssl?).returns(true)
+        conn.expects(:verify_mode).returns(OpenSSL::SSL::VERIFY_NONE)
+
+        pool = create_pool_with_connections(site, conn)
+
+        pool.expects(:release).with(site, conn).never
+
+        pool.with_connection(site, verify) {|c| }
+      end
+    end
+  end
+
+  context 'when borrowing' do
+    it 'returns a new connection if the pool is empty' do
+      conn = create_connection(site)
+      pool = create_pool
+      pool.factory.expects(:create_connection).with(site).returns(conn)
+
+      expect(pool.borrow(site, verify)).to eq(conn)
+    end
+
+    it 'returns a matching connection' do
+      conn = create_connection(site)
+      pool = create_pool_with_connections(site, conn)
+
+      pool.factory.expects(:create_connection).never
+
+      expect(pool.borrow(site, verify)).to eq(conn)
+    end
+
+    it 'returns a new connection if there are no matching sites' do
+      different_conn = create_connection(different_site)
+      pool = create_pool_with_connections(different_site, different_conn)
+
+      conn = create_connection(site)
+      pool.factory.expects(:create_connection).with(site).returns(conn)
+
+      expect(pool.borrow(site, verify)).to eq(conn)
+    end
+
+    it 'returns started connections' do
+      conn = create_connection(site)
+      conn.expects(:start)
+
+      pool = create_pool
+      pool.factory.expects(:create_connection).with(site).returns(conn)
+
+      expect(pool.borrow(site, verify)).to eq(conn)
+    end
+
+    it "doesn't start a cached connection" do
+      conn = create_connection(site)
+      conn.expects(:start).never
+
+      pool = create_pool_with_connections(site, conn)
+      pool.borrow(site, verify)
+    end
+
+    it 'returns the most recently used connection from the pool' do
+      least_recently_used = create_connection(site)
+      most_recently_used = create_connection(site)
+
+      pool = create_pool_with_connections(site, least_recently_used, most_recently_used)
+      expect(pool.borrow(site, verify)).to eq(most_recently_used)
+    end
+
+    it 'finishes expired connections' do
+      conn = create_connection(site)
+      conn.expects(:finish)
+
+      pool = create_pool_with_expired_connections(site, conn)
+      pool.factory.expects(:create_connection => stub('conn', :start => nil))
+
+      pool.borrow(site, verify)
+    end
+
+    it 'logs an exception if it fails to close an expired connection' do
+      Puppet.expects(:log_exception).with(is_a(IOError), "Failed to close connection for #{site}: read timeout")
+
+      conn = create_connection(site)
+      conn.expects(:finish).raises(IOError, 'read timeout')
+
+      pool = create_pool_with_expired_connections(site, conn)
+      pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
+
+      pool.borrow(site, verify)
+    end
+  end
+
+  context 'when releasing a connection' do
+    it 'adds the connection to an empty pool' do
+      conn = create_connection(site)
+
+      pool = create_pool
+      pool.release(site, conn)
+
+      expect(pool.pool[site].first.connection).to eq(conn)
+    end
+
+    it 'adds the connection to a pool with a connection for the same site' do
+      pool = create_pool
+      pool.release(site, create_connection(site))
+      pool.release(site, create_connection(site))
+
+      expect(pool.pool[site].count).to eq(2)
+    end
+
+    it 'adds the connection to a pool with a connection for a different site' do
+      pool = create_pool
+      pool.release(site, create_connection(site))
+      pool.release(different_site, create_connection(different_site))
+
+      expect(pool.pool[site].count).to eq(1)
+      expect(pool.pool[different_site].count).to eq(1)
+    end
+  end
+
+  context 'when closing' do
+    it 'clears the pool' do
+      pool = create_pool
+      pool.close
+
+      expect(pool.pool).to be_empty
+    end
+
+    it 'closes all cached connections' do
+      conn = create_connection(site)
+      conn.expects(:finish)
+
+      pool = create_pool_with_connections(site, conn)
+      pool.close
+    end
+  end
+end