puppet 5.0.0 → 6.0.0

data/spec/unit/puppet_pal_spec.rb

@@ -0,0 +1,4 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/files'
+require_relative 'puppet_pal_2pec'

data/spec/unit/puppet_spec.rb

@@ -24,18 +24,37 @@ describe Puppet do
     expect(ENV["PATH"]).to eq(newpath)
   end
 
-  it "should change $LOAD_PATH when :libdir changes" do
-    one = tmpdir('load-path-one')
-    two = tmpdir('load-path-two')
-    expect(one).not_to eq(two)
-
-    Puppet[:libdir] = one
-    expect($LOAD_PATH).to include one
-    expect($LOAD_PATH).not_to include two
-
-    Puppet[:libdir] = two
-    expect($LOAD_PATH).not_to include one
-    expect($LOAD_PATH).to include two
+  it 'should propagate --modulepath to base environment' do
+    Puppet::Node::Environment.expects(:create).with(
+      is_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
+
+    Puppet.base_context({
+      :environmentpath => '/envs',
+      :basemodulepath => '/base/modules',
+      :modulepath => '/my/modules'
+    })
+  end
+
+  it 'empty modulepath does not override basemodulepath' do
+    Puppet::Node::Environment.expects(:create).with(
+      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+
+    Puppet.base_context({
+      :environmentpath => '/envs',
+      :basemodulepath => '/base/modules',
+      :modulepath => ''
+    })
+  end
+
+  it 'nil modulepath does not override basemodulepath' do
+    Puppet::Node::Environment.expects(:create).with(
+      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+
+    Puppet.base_context({
+      :environmentpath => '/envs',
+      :basemodulepath => '/base/modules',
+      :modulepath => nil
+    })
   end
 
   context "Puppet::OLDEST_RECOMMENDED_RUBY_VERSION" do
@@ -51,11 +70,4 @@ describe Puppet do
       expect(SemanticPuppet::Version).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
     end
   end
-
-  context "newtype" do
-    it "should issue a deprecation warning" do
-      subject.expects(:deprecation_warning).with("Creating sometype via Puppet.newtype is deprecated and will be removed in a future release. Use Puppet::Type.newtype instead.")
-      subject.newtype("sometype")
-    end
-  end
 end

data/spec/unit/resource/capability_finder_spec.rb

@@ -12,26 +12,25 @@ describe Puppet::Resource::CapabilityFinder do
   end
 
   context 'when PuppetDB is configured' do
-    around(:each) do |example|
-      mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
+
+    before(:each) do
+      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+      Puppet.push_context({:loaders => loaders, :current_environment => env})
       if mock_pdb
         module Puppet::Util::Puppetdb
           class Http; end
         end
       end
-      begin
-        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
-        Puppet.override(:loaders => loaders, :current_environment => env) do
-          make_cap_type
-          example.run
-        end
-      ensure
-        Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
-        Puppet::Type.rmtype(:cap)
-        Puppet::Pops::Loaders.clear
-      end
+      make_cap_type
     end
 
+    after(:each) do
+      Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+      Puppet::Type.rmtype(:cap)
+      Puppet.pop_context()
+    end
+
+    let(:mock_pdb) { !Puppet::Util.const_defined?('Puppetdb') }
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
@@ -124,22 +123,21 @@ describe Puppet::Resource::CapabilityFinder do
           expect(result['host']).to eq('chost')
         end
 
-        it 'should return nil if no resource matches code_id' do
+        it 'should fail if no resource matches code_id' do
           Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns []
 
-          result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
-          expect(result).to be_nil
+          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::Error, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if multiple resources match code_id' do
           Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns resources
 
-          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource/)
+          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if no code_id was specified' do
           Puppet::Resource::CapabilityFinder.stubs(:search).with('production', nil, capability).returns resources
-          expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource/)
+          expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
       end
     end

data/spec/unit/resource/catalog_spec.rb

@@ -160,7 +160,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     before do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
-      @original.add_class *%w{four five six}
+      @original.add_class(*%w{four five six})
 
       @top            = Puppet::Resource.new :class, 'top'
       @topobject      = Puppet::Resource.new :file, @basepath+'/topobject'
@@ -233,7 +233,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     before :each do
       @original = Puppet::Resource::Catalog.new("mynode")
       @original.tag(*%w{one two three})
-      @original.add_class *%w{four five six}
+      @original.add_class(*%w{four five six})
 
       @r1 = stub_everything 'r1', :ref => "File[/a]"
       @r1.stubs(:respond_to?).with(:ref).returns(true)
@@ -401,9 +401,9 @@ describe Puppet::Resource::Catalog, "when compiling" do
           expect(error).to be_a Puppet::Resource::Catalog::DuplicateResourceError
 
           expect(error.message).to match %r[Duplicate declaration: Notify\[duplicate-title\] is already declared]
-          expect(error.message).to match %r[in file /path/to/orig/file:42]
+          expect(error.message).to match %r[at \(file: /path/to/orig/file, line: 42\)]
           expect(error.message).to match %r[cannot redeclare]
-          expect(error.message).to match %r[at /path/to/dupe/file:314]
+          expect(error.message).to match %r[\(file: /path/to/dupe/file, line: 314\)]
         }
       end
     end
@@ -438,7 +438,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should optionally support an initialization block and should finalize after such blocks" do
       @one.expects :finish
       @two.expects :finish
-      config = Puppet::Resource::Catalog.new("host") do |conf|
+      Puppet::Resource::Catalog.new("host") do |conf|
         conf.add_resource @one
         conf.add_resource @two
       end
@@ -616,7 +616,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     before :each do
       @catalog = Puppet::Resource::Catalog.new("host")
 
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
       Puppet::Transaction.stubs(:new).returns(@transaction)
       @transaction.stubs(:evaluate)
       @transaction.stubs(:for_network_device=)
@@ -629,6 +629,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.apply
     end
 
+    it "should add a transaction evalution time to the report" do
+      @transaction.report.expects(:add_times).with(:transaction_evaluation, kind_of(Numeric))
+      @catalog.apply
+    end
+
     it "should return the transaction" do
       expect(@catalog.apply).to equal(@transaction)
     end
@@ -658,6 +663,16 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.apply(:ignoreschedules => true)
     end
 
+    it "should detect transaction failure and report it" do
+      @transaction.stubs(:evaluate).raises(RuntimeError, 'transaction failed.')
+      report = Puppet::Transaction::Report.new('apply')
+
+      expect { @catalog.apply(:report => report) }.to raise_error(RuntimeError)
+      report.finalize_report
+
+      expect(report.status).to eq('failed')
+    end
+
     describe "host catalogs" do
 
       # super() doesn't work in the setup method for some reason
@@ -777,7 +792,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.add_edge("one", "two")
 
       text = YAML.dump(@catalog)
-      @newcatalog = YAML.load(text)
+      @newcatalog = Puppet::Util::Yaml.safe_load(text, [Puppet::Resource::Catalog])
     end
 
     it "should get converted back to a catalog" do
@@ -853,12 +868,12 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
   context 'when dealing with parameters that have non-Data values' do
     context 'and rich_data is enabled' do
       before(:each) do
-        Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:environments).get(Puppet[:environment])))
-        Puppet[:rich_data] = true
+        Puppet.push_context(
+          :loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:environments).get(Puppet[:environment])),
+          :rich_data => true)
       end
 
       after(:each) do
-        Puppet[:rich_data] = false
         Puppet.pop_context
       end
 
@@ -867,7 +882,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
 
       it 'should generate rich value hash for parameter values that are not Data' do
         s = catalog_w_regexp.to_json
-        expect(s).to include('"parameters":{"message":{"__pcore_type__":"Regexp","__pcore_value__":"[a-z]+"}}')
+        expect(s).to include('"parameters":{"message":{"__ptype":"Regexp","__pvalue":"[a-z]+"}}')
       end
 
       it 'should read and convert rich value hash containing Regexp from json' do
@@ -936,7 +951,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
 
       it 'should not generate rich value hash for parameter values that are not Data' do
-        expect(catalog_w_regexp.to_json).not_to include('"__pcore_type__"')
+        expect(catalog_w_regexp.to_json).not_to include('"__ptype"')
       end
 
       it 'should convert parameter containing Regexp into strings' do

data/spec/unit/resource/status_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::Resource::Status do
       expect(status.send(attr)).to eq("foo")
     end
 
-    it "should have a boolean method for determining whehter it was #{attr}" do
+    it "should have a boolean method for determining whether it was #{attr}" do
       status.send(attr.to_s + "=", "foo")
       expect(status).to send("be_#{attr}")
     end
@@ -59,7 +59,7 @@ describe Puppet::Resource::Status do
   end
 
   it "should copy the resource's tags" do
-    resource.expects(:tags).returns %w{foo bar}
+    resource.tag('foo', 'bar')
     status = Puppet::Resource::Status.new(resource)
     expect(status).to be_tagged("foo")
     expect(status).to be_tagged("bar")
@@ -70,6 +70,15 @@ describe Puppet::Resource::Status do
     expect(Puppet::Resource::Status.new(resource).resource).to eq("foo")
   end
 
+  it 'should set the provider_used correctly' do
+    expected_name = if Puppet::Util::Platform.windows?
+                      'windows'
+                    else
+                      'posix'
+                    end
+    expect(status.provider_used).to eq(expected_name)
+  end
+
   it "should support tags" do
     expect(Puppet::Resource::Status.ancestors).to include(Puppet::Util::Tagging)
   end
@@ -146,7 +155,7 @@ describe Puppet::Resource::Status do
   context 'when serializing' do
     let(:status) do
       s = Puppet::Resource::Status.new(resource)
-      s.file = "/foo.rb"
+      s.file = '/foo.rb'
       s.line = 27
       s.evaluation_time = 2.7
       s.tags = %w{one two}
@@ -155,10 +164,12 @@ describe Puppet::Resource::Status do
       s.changed = true
       s.out_of_sync = true
       s.skipped = false
+      s.provider_used = 'provider_used_class_name'
+      s.failed_to_restart = false
       s
     end
 
-    it "should round trip through json" do
+    it 'should round trip through json' do
       expect(status.containment_path).to eq(containment_path)
 
       tripped = Puppet::Resource::Status.from_data_hash(JSON.parse(status.to_json))
@@ -169,6 +180,7 @@ describe Puppet::Resource::Status do
       expect(tripped.line).to eq(status.line)
       expect(tripped.resource).to eq(status.resource)
       expect(tripped.resource_type).to eq(status.resource_type)
+      expect(tripped.provider_used).to eq(status.provider_used)
       expect(tripped.evaluation_time).to eq(status.evaluation_time)
       expect(tripped.tags).to eq(status.tags)
       expect(tripped.time).to eq(status.time)
@@ -176,6 +188,7 @@ describe Puppet::Resource::Status do
       expect(tripped.changed).to eq(status.changed)
       expect(tripped.out_of_sync).to eq(status.out_of_sync)
       expect(tripped.skipped).to eq(status.skipped)
+      expect(tripped.failed_to_restart).to eq(status.failed_to_restart)
 
       expect(tripped.change_count).to eq(status.change_count)
       expect(tripped.out_of_sync_count).to eq(status.out_of_sync_count)

data/spec/unit/resource/type_collection_spec.rb

@@ -320,7 +320,10 @@ describe Puppet::Resource::TypeCollection do
       let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
       it "should use the output of the environment's config_version setting if one is provided" do
-        Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/my/foo"])
+          .returns Puppet::Util::Execution::ProcessOutput.new("output\n", 0)
+        expect(@code.version).to be_instance_of(String)
         expect(@code.version).to eq("output")
       end
 

data/spec/unit/resource/type_spec.rb

@@ -524,7 +524,6 @@ describe Puppet::Resource::Type do
       subscope = stub 'subscope', :compiler => @compiler
       @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
 
-      elevel = 876
       subscope.expects(:with_guarded_scope).yields
       subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
       code.expects(:safeevaluate).with(subscope)
@@ -778,7 +777,7 @@ describe Puppet::Resource::Type do
 
   describe "when merging code from another instance" do
     def code(str)
-      factory = Puppet::Pops::Model::Factory.literal(str)
+      Puppet::Pops::Model::Factory.literal(str)
     end
 
     it "should fail unless it is a class" do
@@ -800,18 +799,34 @@ describe Puppet::Resource::Type do
       expect { code.hostclass("b").merge(code.hostclass("d")) }.to raise_error(Puppet::Error)
     end
 
-    it "should fail if it's named 'main' and 'freeze_main' is enabled" do
-      Puppet.settings[:freeze_main] = true
-      code = Puppet::Resource::TypeCollection.new("env")
-      code.add Puppet::Resource::Type.new(:hostclass, "")
-      other = Puppet::Resource::Type.new(:hostclass, "")
-      expect { code.hostclass("").merge(other) }.to raise_error(Puppet::Error)
+    context 'when "freeze_main" is enabled and a merge is done into the main class' do
+      it "an error is raised if there is something other than definitions in the merged class" do
+        Puppet.settings[:freeze_main] = true
+        code = Puppet::Resource::TypeCollection.new("env")
+        code.add Puppet::Resource::Type.new(:hostclass, "")
+        other = Puppet::Resource::Type.new(:hostclass, "")
+        mock = stub
+        mock.expects(:is_definitions_only?).returns(false)
+        other.expects(:code).returns(mock)
+        expect { code.hostclass("").merge(other) }.to raise_error(Puppet::Error)
+      end
+
+      it "an error is not raised if the merged class contains nothing but definitions" do
+        Puppet.settings[:freeze_main] = true
+        code = Puppet::Resource::TypeCollection.new("env")
+        code.add Puppet::Resource::Type.new(:hostclass, "")
+        other = Puppet::Resource::Type.new(:hostclass, "")
+        mock = stub
+        mock.expects(:is_definitions_only?).returns(true)
+        other.expects(:code).at_least_once.returns(mock)
+        expect { code.hostclass("").merge(other) }.not_to raise_error
+      end
     end
 
     it "should copy the other class's parent if it has not parent" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
 
-      parent = Puppet::Resource::Type.new(:hostclass, "parent")
+      Puppet::Resource::Type.new(:hostclass, "parent")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "parent")
       dest.merge(source)
 

data/spec/unit/resource_spec.rb

@@ -679,7 +679,7 @@ describe Puppet::Resource do
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
 
-    it 'to_data_hash returns value that is instance of to Data' do
+    it 'to_data_hash returns value that is instance of Data' do
       Puppet::Pops::Types::TypeAsserter.assert_instance_of('', Puppet::Pops::Types::TypeFactory.data, @resource.to_data_hash)
       expect(Puppet::Pops::Types::TypeFactory.data.instance?(@resource.to_data_hash)).to be_truthy
     end
@@ -719,7 +719,7 @@ describe Puppet::Resource do
           :ensure => 'present',
         }
       )
-      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+      expect(singlequote_resource.to_manifest).to eq(<<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, ''))
         one::two { '/my/file\\'b\\'a\\'r':
           ensure => 'present',
         }
@@ -728,7 +728,7 @@ describe Puppet::Resource do
     end
 
     it "should align, sort and add trailing commas to attributes with ensure first" do
-      expect(@resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+      expect(@resource.to_manifest).to eq(<<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, ''))
         one::two { '/my/file':
           ensure => 'present',
           foo    => ['one', 'two'],
@@ -750,7 +750,7 @@ describe Puppet::Resource do
     end
 
     it "should align and sort to attributes with ensure first" do
-      expect(@resource.to_hierayaml).to eq <<-HEREDOC.gsub(/^\s{8}/, '')
+      expect(@resource.to_hierayaml).to eq(<<-HEREDOC.gsub(/^\s{8}/, ''))
           /my/file:
             ensure: 'present'
             foo   : ['one', 'two']
@@ -758,6 +758,7 @@ describe Puppet::Resource do
       HEREDOC
     end
   end
+
   describe "when converting to json" do
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
@@ -817,7 +818,7 @@ describe Puppet::Resource do
     it "should set sensitive parameters as an array of strings" do
       resource = Puppet::Resource.new("File", "/foo", :sensitive_parameters => [:foo, :fee])
       result = JSON.parse(resource.to_json)
-      expect(result["sensitive_parameters"]).to eq ["foo", "fee"]
+      expect(result["sensitive_parameters"]).to eq(["foo", "fee"])
     end
 
     it "should serialize relationships as reference strings" do
@@ -835,6 +836,46 @@ describe Puppet::Resource do
     end
   end
 
+  describe 'when converting to data_hash with stringified parameters' do
+    before(:each) do
+      Puppet.push_context({:stringify_rich => true}, 'resource_spec.rb')
+    end
+
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    let(:resource) do
+      type = Puppet::Resource::Type.new(:definition, "rich::thing")
+      environment.known_resource_types.add type
+
+      r = Puppet::Resource.new('rich::thing', 'stringified', :environment => environment)
+      r['binary'] = Puppet::Pops::Types::PBinaryType::Binary.from_binary_string('hello')
+      r['timestamp'] = Puppet::Pops::Time::Timestamp.parse('2018-09-03T19:45:33.697066000 UTC')
+      r['reference'] = Puppet::Resource.new('File', 'dummy', :environment => environment)
+      r.resource_type
+      r
+    end
+
+    let(:parameters) do
+      resource.to_data_hash['parameters']
+    end
+
+    it 'has Base64 string content for a binary' do
+      expect(parameters['binary']).to eq('aGVsbG8=')
+    end
+
+    it 'has string content for a timestamp' do
+      expect(parameters['timestamp']).to eq('2018-09-03T19:45:33.697066000 UTC')
+    end
+
+    it 'has string content for a Resource instance' do
+      expect(parameters['reference']).to eq('File[dummy]')
+    end
+
+    # Note: to_stringified_spec.rb has tests for all other data types
+  end
+
   describe "when converting from json" do
     before do
       @data = {

data/spec/unit/rest/client_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+require 'puppet/rest/client'
+require 'puppet/rest/ssl_context'
+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'))
+
+      http.expects(:get_content).with(uri.to_s, query: nil, header: nil)
+        .raises(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]))
+      http.expects(:get_content).with(uri.to_s, query: nil, header: nil)
+        .raises(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
+      http.expects(:get_content).with(uri.to_s, query: nil, header: nil)
+        .raises(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) { mock('store') }
+    let(:ssl_config) { stub_everything('ssl config') }
+    let(:http) { stub_everything('http', :ssl_config => ssl_config) }
+
+    it 'initializes itself with basic defaults' do
+      HTTPClient.expects(:new).returns(http)
+      OpenSSL::X509::Store.stubs(:new).returns(ssl_store)
+      # Configure connection with HTTP settings
+      Puppet[:http_read_timeout] = 120
+      Puppet[:http_connect_timeout] = 10
+      Puppet[:http_debug] = true
+
+      http.expects(:connect_timeout=).with(10)
+      http.expects(:receive_timeout=).with(120)
+      http.expects(:debug_dev=).with($stderr)
+
+      # Configure verify mode with SSL settings
+      ssl_config.expects(:cert_store=).with(ssl_store)
+      Puppet[:ssl_client_ca_auth] = '/fake/path'
+      Puppet[:hostcert] = '/fake/cert/path'
+      ssl_config.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+
+      Puppet::Rest::Client.new(ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_NONE))
+    end
+
+    it 'uses a given client and SSL store when provided' do
+      ssl_config.expects(:cert_store=).with(ssl_store)
+      Puppet::Rest::Client.new(client: http,
+                               ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_PEER, ssl_store))
+    end
+
+    it 'configures a receive timeout when provided' do
+      http.expects(:receive_timeout=).with(10)
+      Puppet::Rest::Client.new(ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_NONE),
+                               client: http, receive_timeout: 10)
+    end
+  end
+
+  context 'when making requests' do
+    let(:ssl_config) { stub_everything('ssl config') }
+    let(:http) { stub_everything('http', :ssl_config => ssl_config) }
+    let(:client) { Puppet::Rest::Client.new(ssl_context: Puppet::Rest::SSLContext.new(OpenSSL::SSL::VERIFY_NONE), 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 }
+        http.expects(:get_content).with(url, { query: query, header: header }).yields('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 = mock('resp', :status => HTTP::Status::BAD_REQUEST)
+        http.expects(:get_content).with(url, query: nil, header: nil)
+            .raises(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' }
+        http.expects(: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