puppet 5.5.22-x64-mingw32 → 6.0.0-x64-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

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+require 'puppet/rest/route'
+
+describe Puppet::Rest::Route do
+  describe '#with_base_url'do
+    let(:dns_resolver) { stub_everything('dns resolver') }
+
+    context 'when not using SRV records' do
+      before :each do
+        Puppet.settings[:use_srv_records] = false
+      end
+
+      it "yields a base URL with the values from the specified settings" do
+        Puppet[:ca_server] = 'testserver'
+        Puppet[:ca_port] = 555
+        ca_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
+                                           server_setting: :ca_server,
+                                           port_setting: :ca_port,
+                                           srv_service: :test_service)
+        count = 0
+        rval = ca_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://testserver:555/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+
+      it "yields a base URL with Puppet's configured server and port when no defaults are specified" do
+        Puppet[:server] = 'configured.net'
+        Puppet[:masterport] = 8140
+        fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
+        count = 0
+        rval = fallback_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://configured.net:8140/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+
+      it 'yields the first entry in the server list when server_list is in use' do
+        Puppet[:server_list] = [['one.net', 111], ['two.net', 222]]
+        fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
+        count = 0
+        rval = fallback_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://one.net:111/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+
+      it 'falls back to :server and :masterport if nil is passed' do
+        Puppet[:server] = 'one.net'
+        Puppet[:masterport] = 111
+        nil_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
+                                            server_setting: nil,
+                                            port_setting: nil)
+        count = 0
+        rval = nil_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://one.net:111/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+    end
+
+    context 'when using SRV records' do
+      context "when SRV returns servers" do
+        let(:route) { Puppet::Rest::Route.new(api: '/fakeapi/v1/',
+                                              srv_service: :test_service) }
+
+        before :each do
+          Puppet.settings[:use_srv_records] = true
+          Puppet.settings[:srv_domain]      = 'example.com'
+
+          @dns_mock = mock('dns')
+          Resolv::DNS.expects(:new).returns(@dns_mock)
+
+          @port = 7502
+          @target = 'example.com'
+          record = Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @target)
+          record.instance_variable_set(:@ttl, 10)
+          @srv_records = [record]
+
+          @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
+          count = 0
+          rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|
+            count += 1
+            expect(url.to_s).to eq('https://example.com:7502/fakeapi/v1/')
+            'Block return value'
+          end
+          expect(count).to eq(1)
+
+          expect(rval).to eq('Block return value')
+        end
+
+        it "should fall back to the default server when the block raises a SystemCallError" do
+          Puppet[:server] = "testserver"
+          Puppet[:masterport] = 555
+
+          count = 0
+          rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|
+            count += 1
+            if url.to_s =~ /example.com/ then
+              raise SystemCallError, "example failure"
+            else
+              expect(url.to_s).to eq('https://testserver:555/fakeapi/v1/')
+            end
+
+            'Block return value'
+          end
+
+          expect(count).to eq(2)
+          expect(rval).to eq('Block return value')
+        end
+      end
+    end
+  end
+end

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'
 
@@ -144,5 +145,14 @@ badline
                             with_section(Section.new(:main).
                                          with_setting(:mode, "value", NO_META)))
   end
+
+  it "accepts non-UTF8 encoded text" do
+    result = the_parse_of("var = value".encode("UTF-16LE"))
+
+    expect(result).to eq(Conf.new.
+                           with_section(Section.new(:main).
+                                          with_setting(:var, "value", NO_META)))
+
+    end
 end
 

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