puppet 6.14.0-x64-mingw32 → 6.15.0-x64-mingw32

data/spec/unit/http/external_client_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+require 'puppet/http'
+
+# Simple "external" client to make get & post requests. This is used
+# to test the old HTTP API, such as requiring use_ssl and basic_auth
+# to be passed as options.
+class Puppet::HTTP::TestExternal
+  def initialize(host, port, options = {})
+    @host = host
+    @port = port
+    @options = options
+    @factory = Puppet::Network::HTTP::Factory.new
+  end
+
+  def get(path, headers = {}, options = {})
+    request = Net::HTTP::Get.new(path, headers)
+    do_request(request, options)
+  end
+
+  def post(path, data, headers = nil, options = {})
+    request = Net::HTTP::Post.new(path, headers)
+    do_request(request, options)
+  end
+
+  def do_request(request, options)
+    if options[:basic_auth]
+      request.basic_auth(options[:basic_auth][:user], options[:basic_auth][:password])
+    end
+
+    site = Puppet::Network::HTTP::Site.new(@options[:use_ssl] ? 'https' : 'http', @host, @port)
+    http = @factory.create_connection(site)
+    http.start
+    begin
+      http.request(request)
+    ensure
+      http.finish
+    end
+  end
+end
+
+describe Puppet::HTTP::ExternalClient do
+  let(:uri) { URI.parse('https://www.example.com') }
+  let(:http_client_class) { Puppet::HTTP::TestExternal }
+  let(:client) { described_class.new(http_client_class) }
+  let(:credentials) { ['user', 'pass'] }
+
+  context "for GET requests" do
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:get, uri).with(query: "foo=bar%3Dbaz")
+
+      client.get(uri, params: {:foo => "bar=baz"})
+    end
+
+    it "fails if a user passes in an invalid param type" do
+      environment = Puppet::Node::Environment.create(:testing, [])
+
+      expect{client.get(uri, params: {environment: environment})}.to raise_error(Puppet::HTTP::SerializationError, /HTTP REST queries cannot handle values of type/)
+    end
+
+    it "returns the response" do
+      stub_request(:get, uri)
+
+      response = client.get(uri)
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "returns the entire response body" do
+      stub_request(:get, uri).to_return(body: "abc")
+
+      expect(client.get(uri).body).to eq("abc")
+    end
+
+    it "streams the response body when a block is given" do
+      stub_request(:get, uri).to_return(body: "abc")
+
+      io = StringIO.new
+      client.get(uri) do |response|
+        response.read_body do |data|
+          io.write(data)
+        end
+      end
+
+      expect(io.string).to eq("abc")
+    end
+
+    context 'when connecting' do
+      it 'accepts an ssl context' do
+        stub_request(:get, uri).to_return(body: "abc")
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        client.get(uri, options: {ssl_context: other_context})
+      end
+
+      it 'accepts include_system_store' do
+        stub_request(:get, uri).to_return(body: "abc")
+
+        client.get(uri, options: {include_system_store: true})
+      end
+    end
+  end
+
+  context "for POST requests" do
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:post, "https://www.example.com").with(query: "foo=bar%3Dbaz")
+
+      client.post(uri, "", params: {:foo => "bar=baz"}, headers: {'Content-Type' => 'text/plain'})
+    end
+
+    it "returns the response" do
+      stub_request(:post, uri)
+
+      response = client.post(uri, "", headers: {'Content-Type' => 'text/plain'})
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "sets content-type for the body" do
+      stub_request(:post, uri).with(headers: {"Content-Type" => "text/plain"})
+
+      client.post(uri, "hello", headers: {'Content-Type' => 'text/plain'})
+    end
+
+    it "streams the response body when a block is given" do
+      stub_request(:post, uri).to_return(body: "abc")
+
+      io = StringIO.new
+      client.post(uri, "", headers: {'Content-Type' => 'text/plain'}) do |response|
+        response.read_body do |data|
+          io.write(data)
+        end
+      end
+
+      expect(io.string).to eq("abc")
+    end
+
+    it 'raises an ArgumentError if `body` is missing' do
+      expect {
+        client.post(uri, nil, headers: {'Content-Type' => 'text/plain'})
+      }.to raise_error(ArgumentError, /'post' requires a string 'body' argument/)
+    end
+
+    context 'when connecting' do
+      it 'accepts an ssl context' do
+        stub_request(:post, uri)
+
+        other_context = Puppet::SSL::SSLContext.new
+
+        client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: other_context})
+      end
+
+      it 'accepts include_system_store' do
+        stub_request(:post, uri)
+
+        client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {include_system_store: true})
+      end
+    end
+  end
+
+  context "Basic Auth" do
+    it "submits credentials for GET requests" do
+      stub_request(:get, uri).with(basic_auth: credentials)
+
+      client.get(uri, options: {user: 'user', password: 'pass'})
+    end
+
+    it "submits credentials for POST requests" do
+      stub_request(:post, uri).with(basic_auth: credentials)
+
+      client.post(uri, "", options: {content_type: 'text/plain', user: 'user', password: 'pass'})
+    end
+
+    it "returns response containing access denied" do
+      stub_request(:get, uri).with(basic_auth: credentials).to_return(status: [403, "Ye Shall Not Pass"])
+
+      response = client.get(uri, options: {user: 'user', password: 'pass'})
+      expect(response.code).to eq(403)
+      expect(response.reason).to eq("Ye Shall Not Pass")
+      expect(response).to_not be_success
+    end
+
+    it 'omits basic auth if user is nil' do
+      stub_request(:get, uri).with do |req|
+        expect(req.headers).to_not include('Authorization')
+      end
+
+      client.get(uri, options: {user: nil, password: 'pass'})
+    end
+
+    it 'omits basic auth if password is nil' do
+      stub_request(:get, uri).with do |req|
+        expect(req.headers).to_not include('Authorization')
+      end
+
+      client.get(uri, options: {user: 'user', password: nil})
+    end
+  end
+end

data/spec/unit/http/resolver_spec.rb

@@ -70,6 +70,26 @@ describe Puppet::HTTP::Resolver do
       expect(service).to be_an_instance_of(Puppet::HTTP::Service::Ca)
       expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet-ca/v1")
     end
+
+    it 'resolves once per session' do
+      failed = stub_request(:get, "https://ca.example.com:8141/status/v1/simple/master").to_return(status: 503)
+      passed = stub_request(:get, "https://apple.example.com:8142/status/v1/simple/master").to_return(status: 200)
+
+      service = subject.resolve(session, :puppet)
+      expect(service).to be_a(Puppet::HTTP::Service::Compiler)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
+
+      service = subject.resolve(session, :fileserver)
+      expect(service).to be_a(Puppet::HTTP::Service::FileServer)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
+
+      service = subject.resolve(session, :report)
+      expect(service).to be_a(Puppet::HTTP::Service::Report)
+      expect(service.url.to_s).to eq("https://apple.example.com:8142/puppet/v3")
+
+      expect(failed).to have_been_requested
+      expect(passed).to have_been_requested
+    end
   end
 
   context 'when resolving using SRV' do

data/spec/unit/http/service/ca_spec.rb

@@ -68,7 +68,15 @@ describe Puppet::HTTP::Service::Ca do
     it 'gets a certificate from the "certificate" endpoint' do
       stub_request(:get, url).to_return(body: pem)
 
-      expect(subject.get_certificate('ca')).to eq(pem)
+      _, body = subject.get_certificate('ca')
+      expect(body).to eq(pem)
+    end
+
+    it 'returns the request response' do
+      stub_request(:get, url).to_return(body: pem)
+
+      resp, _ = subject.get_certificate('ca')
+      expect(resp).to be_a(Puppet::HTTP::Response)
     end
 
     it 'accepts text/plain responses' do
@@ -107,7 +115,15 @@ describe Puppet::HTTP::Service::Ca do
     it 'gets a CRL from "certificate_revocation_list" endpoint' do
       stub_request(:get, url).to_return(body: pem)
 
-      expect(subject.get_certificate_revocation_list).to eq(pem)
+      _, body = subject.get_certificate_revocation_list
+      expect(body).to eq(pem)
+    end
+
+    it 'returns the request response' do
+      stub_request(:get, url).to_return(body: pem)
+
+      resp, _ = subject.get_certificate_revocation_list
+      expect(resp).to be_a(Puppet::HTTP::Response)
     end
 
     it 'accepts text/plain responses' do
@@ -161,6 +177,13 @@ describe Puppet::HTTP::Service::Ca do
       subject.put_certificate_request('infinity', request)
     end
 
+    it 'returns the request response' do
+      stub_request(:put, url).with(body: pem, headers: { 'Content-Type' => 'text/plain' })
+
+      resp = subject.put_certificate_request('infinity', request)
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises response error if unsuccessful' do
       stub_request(:put, url).to_return(status: [400, 'Bad Request'])
 

data/spec/unit/http/service/compiler_spec.rb

@@ -136,11 +136,19 @@ describe Puppet::HTTP::Service::Compiler do
       stub_request(:post, uri)
         .to_return(**catalog_response)
 
-      cat = subject.post_catalog(certname, environment: 'production', facts: facts)
+      _, cat = subject.post_catalog(certname, environment: 'production', facts: facts)
       expect(cat).to be_a(Puppet::Resource::Catalog)
       expect(cat.name).to eq(certname)
     end
 
+    it 'returns the request response' do
+      stub_request(:post, uri)
+        .to_return(**catalog_response)
+
+      resp, _ = subject.post_catalog(certname, environment: 'production', facts: facts)
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises a response error if unsuccessful' do
       stub_request(:post, uri)
         .to_return(status: [500, "Server Error"])
@@ -246,11 +254,19 @@ describe Puppet::HTTP::Service::Compiler do
       stub_request(:get, uri)
         .to_return(**node_response)
 
-      n = subject.get_node(certname, environment: 'production')
+      _, n = subject.get_node(certname, environment: 'production')
       expect(n).to be_a(Puppet::Node)
       expect(n.name).to eq(certname)
     end
 
+    it 'returns the request response' do
+      stub_request(:get, uri)
+        .to_return(**node_response)
+
+      resp, _ = subject.get_node(certname, environment: 'production')
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises a response error if unsuccessful' do
       stub_request(:get, uri)
         .to_return(status: [500, "Server Error"])
@@ -299,11 +315,19 @@ describe Puppet::HTTP::Service::Compiler do
       stub_request(:get, uri)
         .to_return(**facts_response)
 
-      n = subject.get_facts(certname, environment: 'production')
+      _, n = subject.get_facts(certname, environment: 'production')
       expect(n).to be_a(Puppet::Node::Facts)
       expect(n.name).to eq(certname)
     end
 
+    it 'returns the request response' do
+      stub_request(:get, uri)
+        .to_return(**facts_response)
+
+      resp, _ = subject.get_facts(certname, environment: 'production')
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises a response error if unsuccessful' do
       stub_request(:get, uri)
         .to_return(status: [500, "Server Error"])
@@ -365,12 +389,12 @@ describe Puppet::HTTP::Service::Compiler do
       subject.put_facts(certname, environment: 'outerspace', facts: facts)
     end
 
-    it 'returns true' do
+    it 'returns the request response' do
       # the REST API returns the filename, good grief
       stub_request(:put, uri)
         .to_return(status: 200, body: "/opt/puppetlabs/server/data/puppetserver/yaml/facts/#{certname}.yaml")
 
-      expect(subject.put_facts(certname, environment: environment, facts: facts)).to eq(true)
+      expect(subject.put_facts(certname, environment: environment, facts: facts)).to be_a(Puppet::HTTP::Response)
     end
 
     it 'raises a response error if unsuccessful' do
@@ -410,11 +434,19 @@ describe Puppet::HTTP::Service::Compiler do
       stub_request(:get, uri)
         .to_return(**status_response)
 
-      s = subject.get_status(certname)
+      _, s = subject.get_status(certname)
       expect(s).to be_a(Puppet::Status)
       expect(s.status).to eq("is_alive" => true)
     end
 
+    it 'returns the request response' do
+      stub_request(:get, uri)
+        .to_return(**status_response)
+
+      resp, _ = subject.get_status(certname)
+      expect(resp).to be_a(Puppet::HTTP::Response)
+    end
+
     it 'raises a response error if unsuccessful' do
       stub_request(:get, uri)
         .to_return(status: [500, "Server Error"])
@@ -446,4 +478,150 @@ describe Puppet::HTTP::Service::Compiler do
       }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize Puppet::Status from json/)
     end
   end
+
+  context 'filebucket' do
+    let(:filebucket_file) { Puppet::FileBucket::File.new('file to store') }
+    let(:formatter) { Puppet::Network::FormatHandler.format(:binary) }
+    let(:path) { "md5/4aabe1257043bd03ce4c3319c155bc55" }
+    let(:uri) { %r{/puppet/v3/file_bucket_file/#{path}} }
+
+    context 'when getting a file' do
+      let(:status_response) { { body: formatter.render(filebucket_file), headers: {'Content-Type' => 'application/octet-stream' }}}
+
+      it 'includes default HTTP headers' do
+        stub_request(:get, uri).with do |request|
+          expect(request.headers).to include({
+            'X-Puppet-Version' => /./,
+            'User-Agent' => /./,
+            'Accept' => 'application/octet-stream'
+            })
+          expect(request.headers).to_not include('X-Puppet-Profiling')
+        end.to_return(**status_response)
+
+        subject.get_filebucket_file(path, environment: 'production')
+      end
+
+      it 'always the environment as a parameter' do
+        stub_request(:get, uri).with(query: hash_including('environment' => 'production')).to_return(**status_response)
+
+        subject.get_filebucket_file(path, environment: 'production')
+      end
+
+      {bucket_path: 'path', diff_with: '4aabe1257043bd0', list_all: 'true', fromdate: '20200404', todate: '20200404'}.each do |param, val|
+        it "includes #{param} as a parameter in the request if #{param} is set" do
+          stub_request(:get, uri).with(query: hash_including(param => val)).to_return(**status_response)
+
+          options = { param => val }
+          subject.get_filebucket_file(path, environment: 'production', **options)
+        end
+      end
+
+      it "doesn't include :diff_with as a query param if :bucket_path is nil" do
+        stub_request(:get, uri).with do |request|
+          expect(request.uri.query).not_to match(/diff_with/)
+        end.to_return(**status_response)
+
+        subject.get_filebucket_file(path, environment: 'production', diff_with: nil)
+      end
+
+      it 'returns a deserialized response' do
+        stub_request(:get, uri)
+        .to_return(**status_response)
+
+        _, s = subject.get_filebucket_file(path, environment: 'production')
+        expect(s).to be_a(Puppet::FileBucket::File)
+        expect(s.contents).to eq('file to store')
+      end
+
+      it 'returns the request response' do
+        stub_request(:get, uri)
+        .to_return(**status_response)
+
+        resp, _ = subject.get_filebucket_file(path, environment: 'production')
+        expect(resp).to be_a(Puppet::HTTP::Response)
+      end
+    end
+
+    context 'when putting a file' do
+      let(:status_response) { { status: 200, body: '' } }
+
+      it 'includes default HTTP headers' do
+        stub_request(:put, uri).with do |request|
+          expect(request.headers).to include({
+            'X-Puppet-Version' => /./,
+            'User-Agent' => /./,
+            'Accept' => 'application/octet-stream',
+            'Content-Type' => 'application/octet-stream'
+            })
+          expect(request.headers).to_not include('X-Puppet-Profiling')
+        end.to_return(**status_response)
+
+        subject.put_filebucket_file(path, body: filebucket_file.contents, environment: 'production')
+      end
+
+      it 'always the environment as a parameter' do
+        stub_request(:put, uri).with(query: hash_including('environment' => 'production')).to_return(**status_response)
+
+        subject.put_filebucket_file(path, body: filebucket_file.contents, environment: 'production')
+      end
+
+      it 'sends the file contents as the request body' do
+        stub_request(:put, uri).with(body: filebucket_file.contents).to_return(**status_response)
+
+        subject.put_filebucket_file(path, body: filebucket_file.contents, environment: 'production')
+      end
+
+      it 'returns the request response' do
+        stub_request(:put, uri)
+        .to_return(**status_response)
+
+        s = subject.put_filebucket_file(path, body: filebucket_file.contents, environment: 'production')
+        expect(s).to be_a(Puppet::HTTP::Response)
+      end
+    end
+
+    context 'when heading a file' do
+      let(:status_response) {{ status: 200 }}
+
+      it 'includes default HTTP headers' do
+        stub_request(:head, uri).with do |request|
+          expect(request.headers).to include({
+            'X-Puppet-Version' => /./,
+            'User-Agent' => /./,
+            'Accept' => 'application/octet-stream',
+            })
+          expect(request.headers).to_not include('X-Puppet-Profiling')
+        end.to_return(**status_response)
+
+        subject.head_filebucket_file(path, environment: 'production')
+      end
+
+      it 'always the environment as a parameter' do
+        stub_request(:head, uri).with(query: hash_including('environment' => 'production')).to_return(**status_response)
+
+        subject.head_filebucket_file(path, environment: 'production')
+      end
+
+      it "includes :bucket_path as a parameter in the request if :bucket_path is set" do
+        stub_request(:head, uri).with(query: hash_including(:bucket_path => 'some/path')).to_return(**status_response)
+
+        subject.head_filebucket_file(path, environment: 'production', bucket_path: 'some/path')
+      end
+
+      it "doesn't include :bucket_path as a query param if :bucket_path is nil" do
+        stub_request(:head, uri).with do |request|
+          expect(request.uri.query).not_to match(/bucket_path/)
+        end.to_return(**status_response)
+
+        subject.head_filebucket_file(path, environment: 'production', bucket_path: nil)
+      end
+
+      it "returns the request response" do
+        stub_request(:head, uri).with(query: hash_including(:bucket_path => 'some/path')).to_return(**status_response)
+
+        resp = subject.head_filebucket_file(path, environment: 'production', bucket_path: 'some/path')
+        expect(resp).to be_a(Puppet::HTTP::Response)
+      end
+    end
+  end
 end