puppet 6.4.1-x86-mingw32 → 6.4.2-x86-mingw32

data/spec/unit/provider/package/puppet_gem_spec.rb

@@ -15,70 +15,58 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
   end
 
   if Puppet::Util::Platform.windows?
-    let(:puppet_gem) { 'gem' }
+    let(:provider_gem_cmd) { 'gem' }
   else
-    let(:puppet_gem) { '/opt/puppetlabs/puppet/bin/gem' }
+    let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
   end
 
+  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
+
   before :each do
     resource.provider = provider
+    allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
   end
 
   context "when installing" do
-    it "should use the path to the gem" do
-      expect(described_class).to receive(:which).with(puppet_gem).and_return(puppet_gem)
-      expect(provider).to receive(:execute) do |args|
-        expect(args[0]).to eq(puppet_gem)
-        ''
-      end
+    before :each do
+      allow(provider).to receive(:rubygem_version).and_return('1.9.9')
+    end
+
+    it "should use the path to the gem command" do
+      allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+      expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
       provider.install
     end
 
     it "should not append install_options by default" do
-      expect(provider).to receive(:execute) do |args|
-        expect(args.length).to eq(5)
-        ''
-      end
+      expect(described_class).to receive(:execute_gem_command).with(%w{install --no-rdoc --no-ri myresource}).and_return('')
       provider.install
     end
 
     it "should allow setting an install_options parameter" do
       resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(provider).to receive(:execute) do |args|
-        expect(args[2]).to eq('--force')
-        expect(args[3]).to eq('--bindir=/usr/bin')
-        ''
-      end
+      expect(described_class).to receive(:execute_gem_command).with(%w{install --force --bindir=/usr/bin --no-rdoc --no-ri myresource}).and_return('')
       provider.install
     end
   end
 
   context "when uninstalling" do
-    it "should use the path to the gem" do
-      expect(described_class).to receive(:which).with(puppet_gem).and_return(puppet_gem)
-      expect(provider).to receive(:execute) do |args|
-        expect(args[0]).to eq(puppet_gem)
-        ''
-      end
-      provider.install
+    it "should use the path to the gem command" do
+      allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+      expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
+      provider.uninstall
     end
 
     it "should not append uninstall_options by default" do
-      expect(provider).to receive(:execute) do |args|
-        expect(args.length).to eq(5)
-        ''
-      end
+      expect(described_class).to receive(:execute_gem_command).with(%w{uninstall --executables --all myresource}).and_return('')
       provider.uninstall
     end
 
     it "should allow setting an uninstall_options parameter" do
       resource[:uninstall_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(provider).to receive(:execute) do |args|
-        expect(args[5]).to eq('--force')
-        expect(args[6]).to eq('--bindir=/usr/bin')
-        ''
-      end
+      expect(described_class).to receive(:execute_gem_command).with(%w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
       provider.uninstall
     end
   end
+
 end

data/spec/unit/provider/package/yum_spec.rb

@@ -12,6 +12,40 @@ describe Puppet::Type.type(:package).provider(:yum) do
     expect(described_class.specificity).to be < 200
   end
 
+  describe "should have logical defaults" do
+    [2, 2018].each do |ver|
+      it "should be the default provider on Amazon Linux #{ver}" do
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return('amazon')
+        allow(Facter).to receive(:value).with(:osfamily).and_return('redhat')
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(ver)
+        expect(described_class).to be_default
+      end
+    end
+
+    Array(4..7).each do |ver|
+      it "should be default for redhat #{ver}" do
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return('redhat')
+        allow(Facter).to receive(:value).with(:osfamily).and_return('redhat')
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(ver.to_s)
+        expect(described_class).to be_default
+      end
+    end
+
+    it "should not be default for redhat 8" do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('redhat')
+      allow(Facter).to receive(:value).with(:osfamily).and_return('redhat')
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('8')
+      expect(described_class).not_to be_default
+    end
+
+    it "should not be default for Ubuntu 16.04" do
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return('ubuntu')
+      allow(Facter).to receive(:value).with(:osfamily).and_return('ubuntu')
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('16.04')
+      expect(described_class).not_to be_default
+    end
+  end
+
   describe "when supplied the source param" do
     let(:name) { 'baz' }
 

data/spec/unit/provider/user/directoryservice_spec.rb

@@ -294,7 +294,7 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     before :each do
       # Stub out all calls to dscl with default values from above
       defaults.each do |key, val|
-        allow(provider).to receive(:merge_attribute_with_dscl).with('Users', username, key, val)
+        allow(provider).to receive(:create_attribute_with_dscl).with('Users', username, key, val)
       end
 
       # Mock the rest of the dscl calls. We can't assume that our Linux
@@ -327,11 +327,41 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     it 'should convert group names into integers' do
       resource[:gid] = 'somegroup'
       expect(Puppet::Util).to receive(:gid).with('somegroup').and_return(21)
-      expect(provider).to receive(:merge_attribute_with_dscl).with('Users', username, 'PrimaryGroupID', 21)
+      expect(provider).to receive(:create_attribute_with_dscl).with('Users', username, 'PrimaryGroupID', 21)
       provider.create
     end
   end
 
+  describe 'Update existing user' do
+    describe 'home=' do
+      context 'on OS X 10.14' do
+        before do
+          provider.instance_variable_set(:@property_hash, { home: 'value' })
+          allow(provider.class).to receive(:get_os_version).and_return('10.14')
+        end
+
+        it 'raises error' do
+          expect { provider.home = 'new' }.to \
+            raise_error(Puppet::Error, "OS X version 10.14 does not allow changing home using puppet")
+        end
+      end
+  end
+
+  describe 'uid=' do
+    context 'on OS X 10.14' do
+      before do
+        provider.instance_variable_set(:@property_hash, { uid: 'value' })
+        allow(provider.class).to receive(:get_os_version).and_return('10.14')
+      end
+
+      it 'raises error' do
+        expect { provider.uid = 'new' }.to \
+          raise_error(Puppet::Error, "OS X version 10.14 does not allow changing uid using puppet")
+      end
+    end
+  end
+end
+
   describe 'self#instances' do
     it 'should create an array of provider instances' do
       expect(provider.class).to receive(:get_all_users).and_return(['foo', 'bar'])
@@ -988,6 +1018,13 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     end
   end
 
+  describe '#create_attribute_with_dscl' do
+    it 'should raise an error if a dscl command raises an error' do
+      expect(provider).to receive(:dscl).with('.', '-create', user_path, 'GeneratedUID', 'GUID').and_raise(Puppet::ExecutionFailure, 'boom')
+      expect { provider.create_attribute_with_dscl('Users', username, 'GeneratedUID', 'GUID') }.to raise_error Puppet::Error, /Could not set the dscl GeneratedUID key with value: GUID/
+    end
+  end
+
   describe '#get_users_plist' do
     let(:test_hash) do
       {

data/spec/unit/ssl/validator_spec.rb

@@ -185,6 +185,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
       allow(subject).to receive(:ssl_certificates_are_present?).and_return(true)
       connection = double('Net::HTTP')
 
+      allow(connection).to receive(:address).and_return('puppet.com')
       expect(connection).to receive(:cert_store=).with(ssl_host.ssl_store)
       expect(connection).to receive(:ca_file=).with(ca_path)
       expect(connection).to receive(:cert=).with(ssl_host.certificate.content)
@@ -200,6 +201,7 @@ describe Puppet::SSL::Validator::DefaultValidator, unless: Puppet::Util::Platfor
         allow(subject).to receive(:ssl_certificates_are_present?).and_return(false)
         connection = double('Net::HTTP')
 
+        allow(connection).to receive(:address).and_return('puppet.com')
         expect(connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
 
         subject.setup_connection(connection, ssl_host)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 6.4.1
+  version: 6.4.2
 platform: x86-mingw32
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-11 00:00:00.000000000 Z
+date: 2019-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter
@@ -1163,7 +1163,6 @@ files:
 - lib/puppet/resource/status.rb
 - lib/puppet/resource/type.rb
 - lib/puppet/resource/type_collection.rb
-- lib/puppet/rest/client.rb
 - lib/puppet/rest/errors.rb
 - lib/puppet/rest/response.rb
 - lib/puppet/rest/route.rb
@@ -1869,7 +1868,6 @@ files:
 - spec/integration/reports_spec.rb
 - spec/integration/resource/catalog_spec.rb
 - spec/integration/resource/type_collection_spec.rb
-- spec/integration/rest/client_spec.rb
 - spec/integration/ssl/certificate_request_spec.rb
 - spec/integration/ssl/host_spec.rb
 - spec/integration/ssl/key_spec.rb
@@ -2480,7 +2478,6 @@ files:
 - spec/unit/resource/type_collection_spec.rb
 - spec/unit/resource/type_spec.rb
 - spec/unit/resource_spec.rb
-- spec/unit/rest/client_spec.rb
 - spec/unit/rest/route_spec.rb
 - spec/unit/scheduler/job_spec.rb
 - spec/unit/scheduler/scheduler_spec.rb
@@ -3107,7 +3104,6 @@ test_files:
 - spec/integration/reports_spec.rb
 - spec/integration/resource/catalog_spec.rb
 - spec/integration/resource/type_collection_spec.rb
-- spec/integration/rest/client_spec.rb
 - spec/integration/ssl/certificate_request_spec.rb
 - spec/integration/ssl/host_spec.rb
 - spec/integration/ssl/key_spec.rb
@@ -3718,7 +3714,6 @@ test_files:
 - spec/unit/resource/type_collection_spec.rb
 - spec/unit/resource/type_spec.rb
 - spec/unit/resource_spec.rb
-- spec/unit/rest/client_spec.rb
 - spec/unit/rest/route_spec.rb
 - spec/unit/scheduler/job_spec.rb
 - spec/unit/scheduler/scheduler_spec.rb

data/lib/puppet/rest/client.rb

@@ -1,87 +0,0 @@
-require 'httpclient'
-
-require 'puppet'
-require 'puppet/rest/response'
-require 'puppet/rest/errors'
-require 'puppet/util/ssl'
-
-module Puppet::Rest
-  class Client
-    attr_reader :dns_resolver
-
-    # Create a new HTTP client for querying the given API.
-    # @param [Puppet::SSL::SSLContext] ssl_context the SSL configuration for this client
-    # @param [Integer] receive_timeout how long in seconds this client will wait
-    #                  for a response after making a request
-    # @param [HTTPClient] client the third-party HTTP client wrapped by this
-    #                     class. This param is only used for testing.
-    def initialize(ssl_context:,
-                   receive_timeout: Puppet[:http_read_timeout],
-                   client: HTTPClient.new(agent_name: nil,
-                                          default_header: {
-                                            'User-Agent' => Puppet[:http_user_agent],
-                                            'X-PUPPET-VERSION' => Puppet::PUPPETVERSION
-                                          }))
-      @client = client
-      @client.tcp_keepalive = true
-      @client.connect_timeout = Puppet[:http_connect_timeout]
-      @client.receive_timeout = receive_timeout
-      @client.transparent_gzip_decompression = true
-
-      if Puppet[:http_debug]
-        @client.debug_dev = $stderr
-      end
-
-      @ca_path = Puppet[:ssl_client_ca_auth] || Puppet[:localcacert]
-      @verifier = Puppet::SSL::Validator::DefaultValidator.new(@ca_path)
-      configure_verify_mode(ssl_context)
-
-      @dns_resolver = Puppet::Network::Resolver.new
-    end
-
-    # Make a GET request to the specified URL with the specified params.
-    # @param [URI::HTTPS] url the full path to query
-    # @param [Hash] query any URL params to add to send to the endpoint
-    # @param [Hash] header any additional entries to add to the default header
-    # @yields [String] chunks of the response body
-    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
-    def get(url, query: nil, header: nil, &block)
-      begin
-        @client.get_content(url.to_s, { query: query, header: header }) do |chunk|
-          block.call(chunk)
-        end
-      rescue HTTPClient::BadResponseError => e
-        raise Puppet::Rest::ResponseError.new(e.message, Puppet::Rest::Response.new(e.res))
-      rescue OpenSSL::OpenSSLError => e
-        Puppet::Util::SSL.handle_connection_error(e, @verifier, url.host)
-      end
-    end
-
-    # Make a PUT request to the specified URL with the specified params.
-    # @param [URI::HTTPS] url the full path to query
-    # @param [String/Hash] body the contents of the PUT request
-    # @param [Hash] query any URL params to add to send to the endpoint
-    # @param [Hash] header any additional entries to add to the default header
-    # @return [Puppet::Rest::Response]
-    def put(url, body:, query: nil, header: nil)
-      begin
-        response = @client.put(url.to_s, body: body, query: query, header: header)
-        Puppet::Rest::Response.new(response)
-      rescue OpenSSL::OpenSSLError => e
-        Puppet::Util::SSL.handle_connection_error(e, @verifier, url.host)
-      end
-    end
-
-    private
-
-    def configure_verify_mode(ssl_context)
-      @client.ssl_config.verify_callback = @verifier
-      @client.ssl_config.cert_store = ssl_context[:store]
-      @client.ssl_config.verify_mode = if !ssl_context[:verify_peer]
-                                         OpenSSL::SSL::VERIFY_NONE
-                                       else
-                                         OpenSSL::SSL::VERIFY_PEER
-                                       end
-    end
-  end
-end

data/spec/integration/rest/client_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/https'
-require 'puppet_spec/files'
-require 'puppet/rest/client'
-
-describe Puppet::Rest::Client, unless: Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-
-  before :all do
-    WebMock.disable!
-  end
-
-  after :all do
-    WebMock.enable!
-  end
-
-  let(:hostname) { '127.0.0.1' }
-  let(:wrong_hostname) { 'localhost' }
-  let(:server) { PuppetSpec::HTTPSServer.new }
-  let(:ssl) { Puppet::SSL::SSLProvider.new }
-  let(:ssl_context) { ssl.create_root_context(cacerts: [server.ca_cert], crls: [server.ca_crl]) }
-  let(:client) { Puppet::Rest::Client.new(ssl_context: ssl_context) }
-
-  before(:each) do
-    localcacert = tmpfile('rest_client')
-    File.write(localcacert, server.ca_cert.to_pem)
-    Puppet[:ssl_client_ca_auth] = localcacert
-
-    # make sure we don't take too long
-    Puppet[:http_connect_timeout] = '5s'
-  end
-
-  it "connects over SSL" do
-    server.start_server do |port|
-      uri = URI.parse("https://#{hostname}:#{port}/blah")
-      expect { |b|
-        client.get(uri, &b)
-      }.to yield_with_args('OK')
-    end
-  end
-
-  it 'provides a meaningful error message when cert validation fails' do
-    ssl_context = ssl.create_root_context(
-      cacerts: [cert_fixture('netlock-arany-utf8.pem')]
-    )
-    client = Puppet::Rest::Client.new(ssl_context: ssl_context)
-
-    server.start_server do |port|
-      uri = URI.parse("https://#{hostname}:#{port}/blah")
-      expect {
-        client.get(uri)
-      }.to raise_error(Puppet::Error,
-                       %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
-    end
-  end
-
-  it 'provides valuable error message when cert names do not match' do
-    server.start_server do |port|
-      uri = URI.parse("https://#{wrong_hostname}:#{port}/blah")
-      expect {
-        client.get(uri)
-      }.to raise_error do |error|
-        pending("PUP-8213") if RUBY_VERSION.to_f >= 2.4 && !Puppet::Util::Platform.jruby?
-
-        expect(error).to be_instance_of(Puppet::SSL::CertMismatchError)
-        expect(error.message).to match(/\AServer hostname '#{wrong_hostname}' did not match server certificate; expected one of (.+)/)
-
-        md = error.message.match(/expected one of (.+)/)
-        expect(md[1].split(', ')).to contain_exactly('127.0.0.1', 'DNS:127.0.0.1', 'DNS:127.0.0.2')
-      end
-    end
-  end
-end

data/spec/unit/rest/client_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/rest/client'
-require 'puppet_spec/validators'
-require 'puppet_spec/ssl'
-
-describe Puppet::Rest::Client do
-  # Follows closely with spec/unit/network/http/connection_spec's
-  # 'ssl verifier' shared context
-  shared_examples 'connection error handling' do
-    let(:uri) { URI.parse('https://foo.com/blah') }
-
-    it 'provides a meaningful error message when cert validation fails' do
-      client.instance_variable_set(:@verifier,
-                                   ConstantErrorValidator.new(
-                                     error_string: 'foo'))
-
-      expect(http).to receive(:get_content).with(uri.to_s, query: nil, header: nil)
-        .and_raise(OpenSSL::OpenSSLError.new('certificate verify failed'))
-      expect{ client.get(uri) }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-        expect(error.message).to include('foo')
-      end
-    end
-
-    it 'provides valuable error message when cert names do not match' do
-      cert = PuppetSpec::SSL.self_signed_ca(PuppetSpec::SSL.create_private_key,
-                                              '/CN=bar.com')
-      client.instance_variable_set(:@verifier,
-                                   ConstantErrorValidator.new(
-                                     peer_certs: [cert]))
-      expect(http).to receive(:get_content).with(uri.to_s, query: nil, header: nil)
-        .and_raise(OpenSSL::OpenSSLError.new('hostname does not match with server certificate'))
-      expect { client.get(uri) }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-        expect(error.message).to include("Server hostname 'foo.com' did not match")
-        expect(error.message).to include('expected bar.com')
-      end
-    end
-
-    it 're-raises errors it does not understand' do
-      expect(http).to receive(:get_content).with(uri.to_s, query: nil, header: nil)
-        .and_raise(OpenSSL::OpenSSLError.new('other ssl error'))
-      expect{ client.get(uri) }.to raise_error do |error|
-        expect(error).to be_a(OpenSSL::OpenSSLError)
-        expect(error.message).to include('other ssl error')
-      end
-    end
-  end
-
-  context 'when creating a new client' do
-    let(:ssl_store) { double('store') }
-    let(:ssl_config) do
-      double(
-        'ssl config',
-        :cert_store= => nil,
-        :verify_callback= => nil,
-        :verify_mode= => nil,
-      )
-    end
-    let(:http) do
-      double(
-        'http',
-        :connect_timeout= => nil,
-        :receive_timeout= => nil,
-        :ssl_config => ssl_config,
-        :tcp_keepalive= => nil,
-        :transparent_gzip_decompression= => nil,
-      )
-    end
-
-    it 'initializes itself with basic defaults' do
-      expect(HTTPClient).to receive(:new).and_return(http)
-      # Configure connection with HTTP settings
-      Puppet[:http_read_timeout] = 120
-      Puppet[:http_connect_timeout] = 10
-      Puppet[:http_debug] = true
-
-      expect(http).to receive(:connect_timeout=).with(10)
-      expect(http).to receive(:receive_timeout=).with(120)
-      expect(http).to receive(:debug_dev=).with($stderr)
-
-      # Configure verify mode with SSL settings
-      expect(ssl_config).to receive(:cert_store=).with(ssl_store)
-      Puppet[:ssl_client_ca_auth] = '/fake/path'
-      Puppet[:hostcert] = '/fake/cert/path'
-      expect(ssl_config).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
-
-      Puppet::Rest::Client.new(ssl_context: Puppet::SSL::SSLContext.new(verify_peer: false, store: ssl_store))
-    end
-
-    it 'uses a given client and SSL store when provided' do
-      expect(ssl_config).to receive(:cert_store=).with(ssl_store)
-      Puppet::Rest::Client.new(client: http,
-                               ssl_context: Puppet::SSL::SSLContext.new(verify_peer: true, store: ssl_store))
-    end
-
-    it 'configures a receive timeout when provided' do
-      expect(http).to receive(:receive_timeout=).with(10)
-      Puppet::Rest::Client.new(ssl_context: Puppet::SSL::SSLContext.new(verify_peer: false),
-                               client: http, receive_timeout: 10)
-    end
-  end
-
-  context 'when making requests' do
-    let(:ssl_config) do
-      double(
-        'ssl config',
-        :cert_store= => nil,
-        :verify_callback= => nil,
-        :verify_mode= => nil,
-      )
-    end
-    let(:http) do
-      double(
-        'http',
-        :connect_timeout= => nil,
-        :receive_timeout= => nil,
-        :ssl_config => ssl_config,
-        :tcp_keepalive= => nil,
-        :transparent_gzip_decompression= => nil,
-      )
-    end
-    let(:client) { Puppet::Rest::Client.new(ssl_context: Puppet::SSL::SSLContext.new(verify_peer: false), client: http) }
-    let(:url) { 'https://myserver.com:555/data' }
-
-    describe "#get" do
-      it 'makes a GET request given a URL, query hash, header hash, and streaming block' do
-        query = { 'environment' => 'production' }
-        header = { 'Accept' => 'text/plain' }
-        response_string = ''
-        chunk_processing = lambda { |chunk| response_string = chunk }
-        expect(http).to receive(:get_content).with(url, { query: query, header: header }).and_yield('response')
-        client.get(url, query: query, header: header, &chunk_processing)
-        expect(response_string).to eq('response')
-      end
-
-      it 'throws an exception when the response to the GET is not OK' do
-        fake_response = double('resp', :status => HTTP::Status::BAD_REQUEST)
-        expect(http).to receive(:get_content).with(url, query: nil, header: nil)
-            .and_raise(HTTPClient::BadResponseError.new('failed request', fake_response))
-        expect { client.get(url) }.to raise_error do |error|
-          expect(error.message).to eq('failed request')
-          expect(error.response).to be_a(Puppet::Rest::Response)
-          expect(error.response.status_code).to eq(400)
-        end
-      end
-
-      include_examples 'connection error handling'
-    end
-
-    describe "#put" do
-      it 'makes a PUT request given a URL, string body, query hash, and header hash' do
-        body = 'send to server'
-        query = { 'environment' => 'production' }
-        header = { 'Accept' => 'text/plain' }
-        expect(http).to receive(:put).with(url, { body: body, query: query, header: header })
-        client.put(url, body: body, query: query, header: header)
-      end
-
-      include_examples 'connection error handling'
-    end
-  end
-end