puppet 6.11.1-universal-darwin → 6.16.0-universal-darwin

data/spec/unit/face/module/search_spec.rb

@@ -211,4 +211,21 @@ describe "puppet module search" do
       end
     end
   end
+
+  it "should include a deprecation warning" do
+    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
+
+    subject.search("puppetlabs-apache")
+
+    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /This action has been deprecated. Please use the Puppet Forge to search for modules./))
+  end
+
+  it "omits the warning when deprecations are disabled" do
+    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
+
+    Puppet[:disable_warnings] = 'deprecations'
+    subject.search("puppetlabs-apache")
+
+    expect(@logs).not_to include(an_object_having_attributes(level: :warning))
+  end
 end

data/spec/unit/face/plugin_spec.rb

@@ -10,9 +10,10 @@ describe Puppet::Face[:plugin, :current] do
   end
 
   context "download" do
-    before :each do
-      #Server_agent version needs to be at 5.3.4 in order to mount locales
-      Puppet.push_context({:server_agent_version => "5.3.4"})
+    around do |example|
+      Puppet.override(server_agent_version: "5.3.4") do
+        example.run
+      end
     end
 
     it "downloads plugins, external facts, and locales" do
@@ -61,9 +62,10 @@ describe Puppet::Face[:plugin, :current] do
   end
 
   context "download when server_agent_version is 5.3.3" do
-    before :each do
-      #Server_agent version needs to be at 5.3.4 in order to mount locales
-      Puppet.push_context({:server_agent_version => "5.3.3"})
+    around do |example|
+      Puppet.override(server_agent_version: "5.3.3") do
+        example.run
+      end
     end
 
     it "downloads plugins, and external facts, but not locales" do
@@ -87,10 +89,10 @@ describe Puppet::Face[:plugin, :current] do
   end
 
   context "download when server_agent_version is blank" do
-    before :each do
-      #Server_agent version needs to be at 5.3.4 in order to mount locales
-      #A blank version will default to 0.0
-      Puppet.push_context({:server_agent_version => ""})
+    around do |example|
+      Puppet.override(server_agent_version: "") do
+        example.run
+      end
     end
 
     it "downloads plugins, and external facts, but not locales" do

data/spec/unit/file_system/uniquefile_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Puppet::FileSystem::Uniquefile do
+  include PuppetSpec::Files
+
   it "makes the name of the file available" do
     Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
       expect(file.path).to match(/foo/)
@@ -73,6 +75,15 @@ describe Puppet::FileSystem::Uniquefile do
     Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
   end
 
+  it "reports when a parent directory does not exist" do
+    dir = tmpdir('uniquefile')
+    lock = File.join(dir, 'path', 'to', 'lock')
+
+    expect {
+      Puppet::FileSystem::Uniquefile.open_tmp(lock) { |tmp| }
+    }.to raise_error(Errno::ENOENT, %r{No such file or directory - A directory component in .* does not exist or is a dangling symbolic link})
+  end
+
   context "Ruby 1.9.3 Tempfile tests" do
     # the remaining tests in this file are ported directly from the ruby 1.9.3 source,
     # since most of this file was ported from there

data/spec/unit/file_system_spec.rb

@@ -970,6 +970,16 @@ describe "Puppet::FileSystem" do
           mode = Puppet::FileSystem.stat(dest).mode
           expect(mode & 07777).to eq(0400)
         end
+
+        it 'preserves file ownership' do
+          allow(Puppet::FileSystem).to receive(:lstat)
+            .with(Puppet::FileSystem.pathname(dest))
+            .and_return(double(uid: 1, gid: 2))
+
+          expect(FileUtils).to receive(:chown).with(1, 2, /#{dest}/)
+
+          Puppet::FileSystem.replace_file(dest, 0644) { |f| f.write(content) }
+        end
       end
 
       context 'on windows', if: Puppet::Util::Platform.windows? do
@@ -988,7 +998,7 @@ describe "Puppet::FileSystem" do
         it 'rejects unsupported modes' do
           expect {
             Puppet::FileSystem.replace_file(dest, 0755) { |_| }
-          }.to raise_error(ArgumentError, /Only modes 0644, 0640 and 0600 are allowed/)
+          }.to raise_error(ArgumentError, /Only modes 0644, 0640, 0660, and 0440 are allowed/)
         end
       end
     end
@@ -1065,12 +1075,26 @@ describe "Puppet::FileSystem" do
           end
         end
 
-        it 'applies the specified mode' do
+        it 'applies 0644 mode' do
           Puppet::FileSystem.replace_file(dest, 0644) { |f| f.write(content) }
 
           expects_public_file(dest)
         end
 
+        [0660, 0640, 0600, 0440].each do |mode|
+          it "applies #{mode} mode" do
+            Puppet::FileSystem.replace_file(dest, mode) { |f| f.write(content) }
+            current_sid = Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name)
+            sd = Puppet::Util::Windows::Security.get_security_descriptor(dest)
+
+            expect(sd.dacl).to contain_exactly(
+              an_object_having_attributes(sid: Puppet::Util::Windows::SID::LocalSystem, mask: 0x1f01ff),
+              an_object_having_attributes(sid: Puppet::Util::Windows::SID::BuiltinAdministrators, mask: 0x1f01ff),
+              an_object_having_attributes(sid: current_sid, mask: 0x1f01ff),
+            )
+          end
+        end
+
         it 'raises Errno::EACCES if access is denied' do
           allow(Puppet::Util::Windows::Security).to receive(:get_security_descriptor).and_raise(Puppet::Util::Windows::Error.new('access denied', 5))
 

data/spec/unit/forge/errors_spec.rb

@@ -41,7 +41,7 @@ Could not connect to http://fake.com:1111
 
   describe 'ResponseError' do
     subject { Puppet::Forge::Errors::ResponseError }
-    let(:response) { double(:body => '{}', :code => '404', :message => "not found") }
+    let(:response) { double(:body => '{}', :code => '404', :reason => "not found") }
 
     context 'without message' do
       let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module') }

data/spec/unit/forge/forge_spec.rb

@@ -10,9 +10,8 @@ describe Puppet::Forge do
     ENV['HTTP_PROXY'] = nil
   end
 
-  let(:host) { 'fake.com' }
-  let(:forge) { Puppet::Forge.new("http://#{host}") }
-  # creates a repository like Puppet::Forge::Repository.new('http://fake.com', USER_AGENT)
+  let(:host) { 'http://fake.com' }
+  let(:forge) { Puppet::Forge.new(host) }
 
   # different UTF-8 widths
   # 1-byte A
@@ -22,49 +21,37 @@ describe Puppet::Forge do
   let (:mixed_utf8_query_param) { "foo + A\u06FF\u16A0\u{2070E}" } # Aۿᚠ
   let (:mixed_utf8_query_param_encoded) { "foo%20%2B%20A%DB%BF%E1%9A%A0%F0%A0%9C%8E"}
   let (:empty_json) { '{ "results": [], "pagination" : { "next" : null } }' }
-  let (:ok_response) { double('response', :code => '200', :body => empty_json) }
 
   describe "making a" do
     before :each do
-      proxy_settings_of("proxy", 1234)
+      Puppet[:http_proxy_host] = "proxy"
+      Puppet[:http_proxy_port] = 1234
     end
 
     context "search request" do
       it "includes any defined module_groups, ensuring to only encode them once in the URI" do
         Puppet[:module_groups] = 'base+pe'
-
-        # ignores Puppet::Forge::Repository#read_response, provides response to search
-        performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}&module_groups=base%20pe"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
-        end
+        encoded_uri = "#{host}/v3/modules?query=#{mixed_utf8_query_param_encoded}&module_groups=base%20pe"
+        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
 
         forge.search(mixed_utf8_query_param)
       end
 
       it "single encodes the search term in the URI" do
-        # ignores Puppet::Forge::Repository#read_response, provides response to search
-        performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/modules?query=#{mixed_utf8_query_param_encoded}"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
-        end
+        encoded_uri = "#{host}/v3/modules?query=#{mixed_utf8_query_param_encoded}"
+        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
 
         forge.search(mixed_utf8_query_param)
       end
     end
 
     context "fetch request" do
-
       it "includes any defined module_groups, ensuring to only encode them once in the URI" do
         Puppet[:module_groups] = 'base+pe'
         module_name = 'puppetlabs-acl'
         exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
-
-        # ignores Puppet::Forge::Repository#read_response, provides response to fetch
-        performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&exclude_fields=#{exclusions}&module_groups=base%20pe"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
-        end
+        encoded_uri = "#{host}/v3/releases?module=#{module_name}&sort_by=version&exclude_fields=#{exclusions}&module_groups=base%20pe"
+        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
 
         forge.fetch(module_name)
       end
@@ -72,40 +59,11 @@ describe Puppet::Forge do
       it "single encodes the module name term in the URI" do
         module_name = "puppetlabs-#{mixed_utf8_query_param}"
         exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
-
-        # ignores Puppet::Forge::Repository#read_response, provides response to fetch
-        performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version&exclude_fields=#{exclusions}"
-          expect(http).to receive(:request).with(have_attributes(path: encoded_uri))
-        end
+        encoded_uri = "#{host}/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version&exclude_fields=#{exclusions}"
+        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
 
         forge.fetch(module_name)
       end
     end
-
-    def performs_an_http_request(result = nil, &block)
-      proxy_args = ["proxy", 1234, nil, nil]
-      mock_proxy(80, proxy_args, result, &block)
-    end
-  end
-
-  def proxy_settings_of(host, port)
-    Puppet[:http_proxy_host] = host
-    Puppet[:http_proxy_port] = port
-  end
-
-  def mock_proxy(port, proxy_args, result, &block)
-    http = double("http client")
-    proxy = double("http proxy")
-
-    expect(Net::HTTP).to receive(:new).with(host, port, *proxy_args).and_return(proxy)
-
-    expect(proxy).to receive(:open_timeout=)
-    expect(proxy).to receive(:read_timeout=)
-
-    expect(proxy).to receive(:start).and_yield(http).and_return(result)
-    yield http
-
-    proxy
   end
 end

data/spec/unit/forge/module_release_spec.rb

@@ -3,8 +3,11 @@ require 'spec_helper'
 require 'puppet/forge'
 require 'net/http'
 require 'puppet/module_tool'
+require 'puppet_spec/files'
 
 describe Puppet::Forge::ModuleRelease do
+  include PuppetSpec::Files
+
   let(:agent) { "Test/1.0" }
   let(:repository) { Puppet::Forge::Repository.new('http://fake.com', agent) }
   let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', agent) }
@@ -27,6 +30,8 @@ describe Puppet::Forge::ModuleRelease do
 
   let(:mock_dir) { '/tmp' }
 
+  let(:destination) { tmpfile('forge_module_release') }
+
   shared_examples 'a module release' do
     def mock_digest_file_with_md5(md5)
       allow(Digest::MD5).to receive(:file).and_return(double(:hexdigest => md5))
@@ -40,16 +45,24 @@ describe Puppet::Forge::ModuleRelease do
     end
 
     describe '#download' do
-      it 'should call make_http_request with correct params' do
-        # valid URI comes from file_uri in JSON blob above
-        expect(ssl_repository).to receive(:make_http_request).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file).and_return(double(:body => '{}', :code => '200'))
+      it 'should download a file' do
+        stub_request(:get, "https://fake.com/#{api_version}/files/#{module_full_name_versioned}.tar.gz").to_return(status: 200, body: '{}')
 
-        release.send(:download, "/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
+        File.open(destination, 'wb') do |fh|
+          release.send(:download, "/#{api_version}/files/#{module_full_name_versioned}.tar.gz", fh)
+        end
+
+        expect(File.read(destination)).to eq("{}")
       end
 
       it 'should raise a response error when it receives an error from forge' do
-        allow(ssl_repository).to receive(:make_http_request).and_return(double(:body => '{"errors": ["error"]}', :code => '500', :message => 'server error'))
-        expect { release.send(:download, "/some/path", mock_file)}.to raise_error Puppet::Forge::Errors::ResponseError
+        stub_request(:get, "https://fake.com/some/path").to_return(
+          status: [500, 'server error'],
+          body: '{"error":"invalid module"}'
+        )
+        expect {
+          release.send(:download, "/some/path", StringIO.new)
+        }.to raise_error Puppet::Forge::Errors::ResponseError
       end
     end
 

data/spec/unit/forge/repository_spec.rb

@@ -13,7 +13,6 @@ describe Puppet::Forge::Repository do
   end
   let(:agent) { "Test/1.0" }
   let(:repository) { Puppet::Forge::Repository.new('http://fake.com', agent) }
-  let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', agent) }
 
   it "retrieve accesses the cache" do
     path = '/module/foo.tar.gz'
@@ -34,215 +33,122 @@ describe Puppet::Forge::Repository do
   end
 
   describe "making a request" do
-    before :each do
-      proxy_settings_of("proxy", 1234)
-    end
+    let(:uri) { "http://fake.com/the_path" }
 
-    it "returns the result object from the request" do
-      result = "#{Object.new}"
+    it "returns the response object from the request" do
+      stub_request(:get, uri)
 
-      performs_an_http_request result do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
-      end
+      expect(repository.make_http_request("/the_path")).to be_a_kind_of(Puppet::HTTP::Response)
+    end
 
-      expect(repository.make_http_request("the_path")).to eq(result)
+    it "requires path to have a leading slash" do
+      expect {
+        repository.make_http_request("the_path")
+      }.to raise_error(ArgumentError, 'Path must start with forward slash')
     end
 
     it "merges forge URI and path specified" do
-      result = "#{Object.new}"
-
-      performs_an_http_request result do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "/test/the_path/"))
-      end
+      stub_request(:get, "http://fake.com/test/the_path/")
 
       repository = Puppet::Forge::Repository.new('http://fake.com/test', agent)
-      expect(repository.make_http_request("/the_path/")).to eq(result)
+      repository.make_http_request("/the_path/")
     end
 
     it "handles trailing slashes when merging URI and path" do
-      result = "#{Object.new}"
-
-      performs_an_http_request result do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "/test/the_path"))
-      end
+      stub_request(:get, "http://fake.com/test/the_path")
 
       repository = Puppet::Forge::Repository.new('http://fake.com/test/', agent)
-      expect(repository.make_http_request("/the_path")).to eq(result)
-    end
-
-    it 'returns the result object from a request with ssl' do
-      result = "#{Object.new}"
-      performs_an_https_request result do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
-      end
-
-      expect(ssl_repository.make_http_request("the_path")).to eq(result)
-    end
-
-    it 'return a valid exception when there is an SSL verification problem' do
-      performs_an_https_request "#{Object.new}" do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(OpenSSL::SSL::SSLError.new("certificate verify failed"))
-      end
-
-      expect { ssl_repository.make_http_request("the_path") }.to raise_error Puppet::Forge::Errors::SSLVerifyError, 'Unable to verify the SSL certificate at https://fake.com'
+      repository.make_http_request("/the_path")
     end
 
     it 'return a valid exception when there is a communication problem' do
-      performs_an_http_request "#{Object.new}" do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(SocketError)
-      end
+      stub_request(:get, uri).to_raise(SocketError.new('getaddrinfo: Name or service not known'))
 
-      expect { repository.make_http_request("the_path") }.
-        to raise_error Puppet::Forge::Errors::CommunicationError,
-        'Unable to connect to the server at http://fake.com. Detail: SocketError.'
+      expect {
+        repository.make_http_request("/the_path")
+      }.to raise_error(Puppet::Forge::Errors::CommunicationError,
+                       %r{Unable to connect to the server at http://fake.com. Detail: Request to http://fake.com/the_path failed after .* seconds: getaddrinfo: Name or service not known.})
     end
 
     it "sets the user agent for the request" do
-      path = 'the_path'
-
-      request = repository.get_request_object(path)
+      stub_request(:get, uri).with do |request|
+        expect(request.headers['User-Agent']).to match(/#{agent} #{Regexp.escape(Puppet[:http_user_agent])}/)
+      end
 
-      expect(request['User-Agent']).to match(/\b#{agent}\b/)
-      expect(request['User-Agent']).to match(/\bPuppet\b/)
-      expect(request['User-Agent']).to match(/\bRuby\b/)
+      repository.make_http_request("/the_path")
     end
 
-    it "Does not set Authorization header by default" do
+    it "does not set Authorization header by default" do
       allow(Puppet.features).to receive(:pe_license?).and_return(false)
       Puppet[:forge_authorization] = nil
-      request = repository.get_request_object("the_path")
-      expect(request['Authorization']).to eq(nil)
-    end
 
-    it "Sets Authorization header from config" do
-      token = 'bearer some token'
-      Puppet[:forge_authorization] = token
-      request = repository.get_request_object("the_path")
-      expect(request['Authorization']).to eq(token)
-    end
-
-    it "encodes the received URI" do
-      unescaped_uri = "héllo world !! ç à"
-      performs_an_http_request do |http|
-        expect(http).to receive(:request).with(have_attributes(path: Puppet::Util.uri_encode(unescaped_uri)))
+      stub_request(:get, uri).with do |request|
+        expect(request.headers).to_not include('Authorization')
       end
 
-      repository.make_http_request(unescaped_uri)
+      repository.make_http_request("/the_path")
     end
 
-    def performs_an_http_request(result = nil, &block)
-      proxy_args = ["proxy", 1234, nil, nil]
-      mock_proxy(80, proxy_args, result, &block)
-    end
+    it "sets Authorization header from config" do
+      token = 'bearer some token'
+      Puppet[:forge_authorization] = token
 
-    def performs_an_https_request(result = nil, &block)
-      proxy_args = ["proxy", 1234, nil, nil]
-      proxy = mock_proxy(443, proxy_args, result, &block)
-      expect(proxy).to receive(:use_ssl=).with(true)
-      expect(proxy).to receive(:cert_store=)
-      expect(proxy).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-    end
-  end
+      stub_request(:get, uri).with(headers: {'Authorization' => token})
 
-  describe "making a request against an authentiated proxy" do
-    before :each do
-      authenticated_proxy_settings_of("proxy", 1234, 'user1', 'password')
+      repository.make_http_request("/the_path")
     end
 
-    it "returns the result object from the request" do
-      result = "#{Object.new}"
+    it "sets Authorization header from PE license" do
+      allow(Puppet.features).to receive(:pe_license?).and_return(true)
+      stub_const("PELicense", double(load_license_key: double(authorization_token: "opensesame")))
 
-      performs_an_authenticated_http_request result do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
-      end
+      stub_request(:get, uri).with(headers: {'Authorization' => "opensesame"})
 
-      expect(repository.make_http_request("the_path")).to eq(result)
+      repository.make_http_request("/the_path")
     end
 
-    it 'returns the result object from a request with ssl' do
-      result = "#{Object.new}"
-      performs_an_authenticated_https_request result do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path"))
-      end
+    it "sets basic authentication if there isn't forge authorization or PE license" do
+      stub_request(:get, uri).with(basic_auth: ['user1', 'password'])
 
-      expect(ssl_repository.make_http_request("the_path")).to eq(result)
+      repository = Puppet::Forge::Repository.new('http://user1:password@fake.com', agent)
+      repository.make_http_request("/the_path")
     end
 
-    it 'return a valid exception when there is an SSL verification problem' do
-      performs_an_authenticated_https_request "#{Object.new}" do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(OpenSSL::SSL::SSLError.new("certificate verify failed"))
-      end
+    it "omits basic authentication if there is a forge authorization" do
+      token = 'bearer some token'
+      Puppet[:forge_authorization] = token
+      stub_request(:get, uri).with(headers: {'Authorization' => token})
 
-      expect { ssl_repository.make_http_request("the_path") }.to raise_error Puppet::Forge::Errors::SSLVerifyError, 'Unable to verify the SSL certificate at https://fake.com'
+      repository = Puppet::Forge::Repository.new('http://user1:password@fake.com', agent)
+      repository.make_http_request("/the_path")
     end
 
-    it 'return a valid exception when there is a communication problem' do
-      performs_an_authenticated_http_request "#{Object.new}" do |http|
-        expect(http).to receive(:request).with(have_attributes(path: "the_path")).and_raise(SocketError)
-      end
+    it "encodes the URI path" do
+      stub_request(:get, "http://fake.com/h%C3%A9llo%20world%20!!%20%C3%A7%20%C3%A0")
 
-      expect { repository.make_http_request("the_path") }.
-        to raise_error Puppet::Forge::Errors::CommunicationError,
-        'Unable to connect to the server at http://fake.com. Detail: SocketError.'
+      repository.make_http_request("/héllo world !! ç à")
     end
 
-    it "sets the user agent for the request" do
-      path = 'the_path'
+    it "connects via proxy" do
+      Puppet[:http_proxy_host] = 'proxy'
+      Puppet[:http_proxy_port] = 1234
 
-      request = repository.get_request_object(path)
+      stub_request(:get, uri)
+      expect(Net::HTTP).to receive(:new).with(anything, anything, 'proxy', 1234, nil, nil).and_call_original
 
-      expect(request['User-Agent']).to match(/\b#{agent}\b/)
-      expect(request['User-Agent']).to match(/\bPuppet\b/)
-      expect(request['User-Agent']).to match(/\bRuby\b/)
+      repository.make_http_request("/the_path")
     end
 
-    it "encodes the received URI" do
-      unescaped_uri = "héllo world !! ç à"
-      performs_an_authenticated_http_request do |http|
-        expect(http).to receive(:request).with(have_attributes(path: Puppet::Util.uri_encode(unescaped_uri)))
-      end
+    it "connects via authenticating proxy" do
+      Puppet[:http_proxy_host] = 'proxy'
+      Puppet[:http_proxy_port] = 1234
+      Puppet[:http_proxy_user] = 'user1'
+      Puppet[:http_proxy_password] = 'password'
 
-      repository.make_http_request(unescaped_uri)
-    end
+      stub_request(:get, uri)
+      expect(Net::HTTP).to receive(:new).with(anything, anything, 'proxy', 1234, "user1", "password").and_call_original
 
-    def performs_an_authenticated_http_request(result = nil, &block)
-      proxy_args = ["proxy", 1234, 'user1', 'password']
-      mock_proxy(80, proxy_args, result, &block)
+      repository.make_http_request("/the_path")
     end
-
-    def performs_an_authenticated_https_request(result = nil, &block)
-      proxy_args = ["proxy", 1234, 'user1', 'password']
-      proxy = mock_proxy(443, proxy_args, result, &block)
-      expect(proxy).to receive(:use_ssl=).with(true)
-      expect(proxy).to receive(:cert_store=)
-      expect(proxy).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-    end
-  end
-
-  def proxy_settings_of(host, port)
-    Puppet[:http_proxy_host] = host
-    Puppet[:http_proxy_port] = port
-  end
-
-  def authenticated_proxy_settings_of(host, port, user, password)
-    Puppet[:http_proxy_host] = host
-    Puppet[:http_proxy_port] = port
-    Puppet[:http_proxy_user] = user
-    Puppet[:http_proxy_password] = password
-  end
-
-  def mock_proxy(port, proxy_args, result, &block)
-    http = double("http client")
-    proxy = double("http proxy")
-
-    expect(Net::HTTP).to receive(:new).with("fake.com", port, *proxy_args).and_return(proxy)
-
-    expect(proxy).to receive(:open_timeout=)
-    expect(proxy).to receive(:read_timeout=)
-
-    expect(proxy).to receive(:start).and_yield(http).and_return(result)
-    yield http
-
-    proxy
   end
 end