puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

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

data/spec/unit/rest/route_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/rest/route'
 
 describe Puppet::Rest::Route do
   describe '#with_base_url'do
-    let(:dns_resolver) { double('dns resolver') }
+    let(:dns_resolver) { stub_everything('dns resolver') }
 
     context 'when not using SRV records' do
       before :each do
@@ -81,8 +81,8 @@ describe Puppet::Rest::Route do
           Puppet.settings[:use_srv_records] = true
           Puppet.settings[:srv_domain]      = 'example.com'
 
-          @dns_mock = double('dns')
-          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
+          @dns_mock = mock('dns')
+          Resolv::DNS.expects(:new).returns(@dns_mock)
 
           @port = 7502
           @target = 'example.com'
@@ -90,9 +90,9 @@ describe Puppet::Rest::Route do
           record.instance_variable_set(:@ttl, 10)
           @srv_records = [record]
 
-          expect(@dns_mock).to receive(:getresources).
-            with("_x-puppet-test_service._tcp.example.com", Resolv::DNS::Resource::IN::SRV).
-            and_return(@srv_records)
+          @dns_mock.expects(:getresources).
+            with("_x-puppet._tcp.test_service", Resolv::DNS::Resource::IN::SRV).
+            returns(@srv_records)
         end
 
         it "yields a URL using the server and port from the SRV record" do

data/spec/unit/scheduler/job_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 

data/spec/unit/scheduler/scheduler_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 

data/spec/unit/scheduler/splay_job_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 
@@ -28,7 +29,7 @@ describe Puppet::Scheduler::SplayJob do
 
   it "is not immediately ready if splayed" do
     job.start_time = start_time
-    expect(job).to receive(:splay).and_return(6)
+    job.expects(:splay).returns(6)
     expect(job.ready?(start_time)).not_to be
   end
 end

data/spec/unit/settings/array_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/array_setting'
 
 describe Puppet::Settings::ArraySetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
+  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
 
   it "is of type :array" do
     expect(subject.type).to eq :array

data/spec/unit/settings/autosign_setting_spec.rb

@@ -6,11 +6,11 @@ require 'puppet/type/file'
 
 describe Puppet::Settings::AutosignSetting do
   let(:settings) do
-    s = double('settings')
-    allow(s).to receive(:[]).with(:mkusers).and_return(true)
-    allow(s).to receive(:[]).with(:user).and_return('puppet')
-    allow(s).to receive(:[]).with(:group).and_return('puppet')
-    allow(s).to receive(:[]).with(:manage_internal_file_permissions).and_return(true)
+    s = stub('settings')
+    s.stubs(:[]).with(:mkusers).returns true
+    s.stubs(:[]).with(:user).returns 'puppet'
+    s.stubs(:[]).with(:group).returns 'puppet'
+    s.stubs(:[]).with(:manage_internal_file_permissions).returns true
     s
   end
 
@@ -74,9 +74,9 @@ describe Puppet::Settings::AutosignSetting do
   describe "converting the setting to a resource" do
     it "converts the file path to a file resource", :if => !Puppet::Util::Platform.windows? do
       path = File.expand_path('/path/to/autosign.conf')
-      allow(settings).to receive(:value).with('autosign', nil, false).and_return(path)
-      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      expect(Puppet.features).to receive(:root?).and_return(true)
+      settings.stubs(:value).with('autosign', nil, false).returns(path)
+      Puppet::FileSystem.stubs(:exist?).with(path).returns true
+      Puppet.features.expects(:root?).returns(true)
 
       setting.mode = '0664'
       setting.owner = 'service'
@@ -92,7 +92,7 @@ describe Puppet::Settings::AutosignSetting do
     end
 
     it "returns nil when the setting is a boolean" do
-      allow(settings).to receive(:value).with('autosign', nil, false).and_return('true')
+      settings.stubs(:value).with('autosign', nil, false).returns 'true'
 
       setting.mode = '0664'
       setting.owner = 'service'

data/spec/unit/settings/certificate_revocation_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/certificate_revocation_setting'
 
 describe Puppet::Settings::CertificateRevocationSetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
+  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
 
   it "is of type :certificate_revocation" do
     expect(subject.type).to eq :certificate_revocation

data/spec/unit/settings/config_file_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/settings/config_file'
 

data/spec/unit/settings/directory_setting_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -14,14 +15,18 @@ describe Puppet::Settings::DirectorySetting do
 
   describe "when being converted to a resource" do
     before do
-      @settings = double('settings')
+      @settings = mock 'settings'
       @dir = Puppet::Settings::DirectorySetting.new(
           :settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
-      allow(@settings).to receive(:value).with(:mydir).and_return(@basepath)
+      @settings.stubs(:value).with(:mydir).returns @basepath
     end
 
     it "should return :directory as its type" do
       expect(@dir.type).to eq(:directory)
     end
+
+
+
   end
 end
+

data/spec/unit/settings/duration_setting_spec.rb

@@ -1,10 +1,11 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
 require 'puppet/settings/duration_setting'
 
 describe Puppet::Settings::DurationSetting do
-  subject { described_class.new(:settings => double('settings'), :desc => "test") }
+  subject { described_class.new(:settings => mock('settings'), :desc => "test") }
 
   describe "when munging the setting" do
     it "should return the same value if given an integer" do

data/spec/unit/settings/enum_setting_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::Settings::EnumSetting do
   end
 
   def enum_setting_allowing(*values)
-    Puppet::Settings::EnumSetting.new(:settings => double('settings'),
+    Puppet::Settings::EnumSetting.new(:settings => mock('settings'),
                                       :name => "testing",
                                       :desc => "description of testing",
                                       :values => values)

data/spec/unit/settings/environment_conf_spec.rb

@@ -5,14 +5,14 @@ describe Puppet::Settings::EnvironmentConf do
 
   def setup_environment_conf(config, conf_hash)
     conf_hash.each do |setting,value|
-      expect(config).to receive(:setting).with(setting).and_return(
-        double('setting', :value => value)
+      config.expects(:setting).with(setting).returns(
+        mock('setting', :value => value)
       )
     end
   end
 
   context "with config" do
-    let(:config) { double('config') }
+    let(:config) { stub('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     it "reads a modulepath from config and does not include global_module_path" do
@@ -91,10 +91,12 @@ describe Puppet::Settings::EnvironmentConf do
   end
 
   describe "with disable_per_environment_manifest" do
-    let(:config) { double('config') }
+
+    let(:config) { stub('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     context "set true" do
+
       before(:each) do
         Puppet[:default_manifest] = File.expand_path('/default/manifest')
         Puppet[:disable_per_environment_manifest] = true

data/spec/unit/settings/file_setting_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/settings'
@@ -18,13 +19,13 @@ describe Puppet::Settings::FileSetting do
         :service_group_available? => false
       }.merge(wanted_values)
 
-      settings = double("settings")
+      settings = mock("settings")
 
-      allow(settings).to receive(:[]).with(:user).and_return(real_values[:user])
-      allow(settings).to receive(:[]).with(:group).and_return(real_values[:group])
-      allow(settings).to receive(:[]).with(:mkusers).and_return(real_values[:mkusers])
-      allow(settings).to receive(:service_user_available?).and_return(real_values[:service_user_available?])
-      allow(settings).to receive(:service_group_available?).and_return(real_values[:service_group_available?])
+      settings.stubs(:[]).with(:user).returns real_values[:user]
+      settings.stubs(:[]).with(:group).returns real_values[:group]
+      settings.stubs(:[]).with(:mkusers).returns real_values[:mkusers]
+      settings.stubs(:service_user_available?).returns real_values[:service_user_available?]
+      settings.stubs(:service_group_available?).returns real_values[:service_group_available?]
 
       settings
     end
@@ -119,16 +120,16 @@ describe Puppet::Settings::FileSetting do
   end
 
   it "should be able to be converted into a resource" do
-    expect(FileSetting.new(:settings => double("settings"), :desc => "eh")).to respond_to(:to_resource)
+    expect(FileSetting.new(:settings => mock("settings"), :desc => "eh")).to respond_to(:to_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @basepath = make_absolute("/somepath")
-      @settings = double('settings')
+      @settings = mock 'settings'
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
-      allow(@file).to receive(:create_files?).and_return(true)
-      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(@basepath)
+      @file.stubs(:create_files?).returns true
+      @settings.stubs(:value).with(:myfile, nil, false).returns @basepath
     end
 
     it "should return :file as its type" do
@@ -136,29 +137,29 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should skip non-existent files if 'create_files' is not enabled" do
-      expect(@file).to receive(:create_files?).and_return(false)
-      expect(@file).to receive(:type).and_return(:file)
-      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(false)
+      @file.expects(:create_files?).returns false
+      @file.expects(:type).returns :file
+      Puppet::FileSystem.expects(:exist?).with(@basepath).returns false
       expect(@file.to_resource).to be_nil
     end
 
     it "should manage existent files even if 'create_files' is not enabled" do
-      expect(@file).to receive(:create_files?).and_return(false)
-      expect(@file).to receive(:type).and_return(:file)
-      allow(Puppet::FileSystem).to receive(:exist?)
-      expect(Puppet::FileSystem).to receive(:exist?).with(@basepath).and_return(true)
+      @file.expects(:create_files?).returns false
+      @file.expects(:type).returns :file
+      Puppet::FileSystem.stubs(:exist?)
+      Puppet::FileSystem.expects(:exist?).with(@basepath).returns true
       expect(@file.to_resource).to be_instance_of(Puppet::Resource)
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
-        allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("/dev/file")
+        @settings.stubs(:value).with(:myfile, nil, false).returns "/dev/file"
         expect(@file.to_resource).to be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
-      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return(:foo)
+      @settings.stubs(:value).with(:myfile, nil, false).returns :foo
       expect(@file.to_resource).to be_nil
     end
 
@@ -175,7 +176,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should fully qualified returned files if necessary (#795)" do
-      allow(@settings).to receive(:value).with(:myfile, nil, false).and_return("myfile")
+      @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
       path = File.expand_path('myfile')
       expect(@file.to_resource.title).to eq(path)
     end
@@ -197,81 +198,82 @@ describe Puppet::Settings::FileSetting do
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
 
-      allow(@file).to receive(:mode).and_return(0755)
+      @file.stubs(:mode).returns(0755)
 
       expect(@file.to_resource[:mode]).to eq(nil)
     end
 
     it "should set the owner if running as root and the owner is provided" do
       Puppet[:manage_internal_file_permissions] = true
-      expect(Puppet.features).to receive(:root?).and_return(true)
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-      allow(@file).to receive(:owner).and_return("foo")
+      Puppet.features.expects(:root?).returns true
+      Puppet::Util::Platform.stubs(:windows?).returns false
+      @file.stubs(:owner).returns "foo"
 
       expect(@file.to_resource[:owner]).to eq("foo")
     end
 
     it "should not set the owner if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
-      allow(Puppet.features).to receive(:root?).and_return(true)
-      allow(@file).to receive(:owner).and_return("foo")
+      Puppet.features.stubs(:root?).returns true
+      @file.stubs(:owner).returns "foo"
 
       expect(@file.to_resource[:owner]).to eq(nil)
     end
 
     it "should set the group if running as root and the group is provided" do
       Puppet[:manage_internal_file_permissions] = true
-      expect(Puppet.features).to receive(:root?).and_return(true)
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-      allow(@file).to receive(:group).and_return("foo")
+      Puppet.features.expects(:root?).returns true
+      Puppet::Util::Platform.stubs(:windows?).returns false
+      @file.stubs(:group).returns "foo"
 
       expect(@file.to_resource[:group]).to eq("foo")
     end
 
     it "should not set the group if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
-      allow(Puppet.features).to receive(:root?).and_return(true)
-      allow(@file).to receive(:group).and_return("foo")
+      Puppet.features.stubs(:root?).returns true
+      @file.stubs(:group).returns "foo"
 
       expect(@file.to_resource[:group]).to eq(nil)
     end
 
+
     it "should not set owner if not running as root" do
       Puppet[:manage_internal_file_permissions] = true
-      expect(Puppet.features).to receive(:root?).and_return(false)
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-      allow(@file).to receive(:owner).and_return("foo")
+      Puppet.features.expects(:root?).returns false
+      Puppet::Util::Platform.stubs(:windows?).returns false
+      @file.stubs(:owner).returns "foo"
 
       expect(@file.to_resource[:owner]).to be_nil
     end
 
     it "should not set group if not running as root" do
       Puppet[:manage_internal_file_permissions] = true
-      expect(Puppet.features).to receive(:root?).and_return(false)
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-      allow(@file).to receive(:group).and_return("foo")
+      Puppet.features.expects(:root?).returns false
+      Puppet::Util::Platform.stubs(:windows?).returns false
+      @file.stubs(:group).returns "foo"
 
       expect(@file.to_resource[:group]).to be_nil
     end
 
     describe "on Microsoft Windows systems" do
       before :each do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
+        Puppet::Util::Platform.stubs(:windows?).returns true
       end
 
       it "should not set owner" do
-        allow(@file).to receive(:owner).and_return("foo")
+        @file.stubs(:owner).returns "foo"
         expect(@file.to_resource[:owner]).to be_nil
       end
 
       it "should not set group" do
-        allow(@file).to receive(:group).and_return("foo")
+        @file.stubs(:group).returns "foo"
         expect(@file.to_resource[:group]).to be_nil
       end
     end
 
     it "should set :ensure to the file type" do
-      expect(@file).to receive(:type).and_return(:directory)
+      @file.expects(:type).returns :directory
       expect(@file.to_resource[:ensure]).to eq(:directory)
     end
 
@@ -284,7 +286,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should tag the resource with the settings section" do
-      expect(@file).to receive(:section).and_return("mysect")
+      @file.expects(:section).returns "mysect"
       expect(@file.to_resource).to be_tagged("mysect")
     end
 
@@ -303,7 +305,7 @@ describe Puppet::Settings::FileSetting do
 
   describe "#munge" do
     it 'does not expand the path of the special value :memory: so we can set dblocation to an in-memory database' do
-      filesetting = FileSetting.new(:settings => double("settings"), :desc => "eh")
+      filesetting = FileSetting.new(:settings => mock("settings"), :desc => "eh")
       expect(filesetting.munge(':memory:')).to eq(':memory:')
     end
   end
@@ -314,7 +316,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     let(:setting) do
-      settings = double("settings", :value => path)
+      settings = mock("settings", :value => path)
       FileSetting.new(:name => :mysetting, :desc => "creates a file", :settings => settings)
     end