puppet 6.13.0-x86-mingw32 → 6.18.0-x86-mingw32

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

@@ -1,6 +1,5 @@
 # coding: utf-8
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Service::Compiler do
@@ -12,6 +11,7 @@ describe Puppet::HTTP::Service::Compiler do
   let(:node) { Puppet::Node.new(certname) }
   let(:facts) { Puppet::Node::Facts.new(certname) }
   let(:catalog) { Puppet::Resource::Catalog.new(certname) }
+  let(:status) { Puppet::Status.new }
   let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
 
   before :each do
@@ -30,16 +30,7 @@ describe Puppet::HTTP::Service::Compiler do
         expect(request.headers).to_not include('X-Puppet-Profiling')
       end.to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })
 
-      subject.get_catalog(certname, environment: environment, facts: facts)
-    end
-
-    it 'includes the X-Puppet-Profiling header in requests when Puppet[:profile] is true' do
-      stub_request(:post, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./, 'X-Puppet-Profiling' => 'true'})
-        .to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })
-
-      Puppet[:profile] = true
-
-      subject.get_catalog(certname, environment: environment, facts: facts)
+      subject.post_catalog(certname, environment: environment, facts: facts)
     end
   end
 
@@ -51,7 +42,7 @@ describe Puppet::HTTP::Service::Compiler do
       stub_request(:post, "https://compiler2.example.com:8141/puppet/v3/catalog/ziggy?environment=testing")
         .to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })
 
-      subject.get_catalog(certname, environment: environment, facts: facts)
+      subject.post_catalog(certname, environment: environment, facts: facts)
     end
   end
 
@@ -59,12 +50,22 @@ describe Puppet::HTTP::Service::Compiler do
     let(:uri) { %r{/puppet/v3/catalog/ziggy} }
     let(:catalog_response) { { body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime } } }
 
+    it 'includes puppet headers set via the :http_extra_headers and :profile settings' do
+      stub_request(:post, uri).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'}).
+        to_return(body: formatter.render(catalog), headers: {'Content-Type' => formatter.mime })
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.post_catalog(certname, environment: environment, facts: facts)
+    end
+
     it 'submits facts as application/json by default' do
       stub_request(:post, uri)
         .with(body: hash_including("facts_format" => /application\/json/))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: environment, facts: facts)
+      subject.post_catalog(certname, environment: environment, facts: facts)
     end
 
     it 'submits facts as pson if set as the preferred format' do
@@ -74,7 +75,7 @@ describe Puppet::HTTP::Service::Compiler do
         .with(body: hash_including("facts_format" => /pson/))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: environment, facts: facts)
+      subject.post_catalog(certname, environment: environment, facts: facts)
     end
 
     it 'includes environment as a query parameter AND in the POST body' do
@@ -83,7 +84,7 @@ describe Puppet::HTTP::Service::Compiler do
               body: hash_including("environment" => 'outerspace'))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: 'outerspace', facts: facts)
+      subject.post_catalog(certname, environment: 'outerspace', facts: facts)
     end
 
     it 'includes configured_environment' do
@@ -91,7 +92,7 @@ describe Puppet::HTTP::Service::Compiler do
         .with(body: hash_including("configured_environment" => 'agent_specified'))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: 'production', facts: facts, configured_environment: 'agent_specified')
+      subject.post_catalog(certname, environment: 'production', facts: facts, configured_environment: 'agent_specified')
     end
 
     it 'includes transaction_uuid' do
@@ -101,7 +102,7 @@ describe Puppet::HTTP::Service::Compiler do
         .with(body: hash_including("transaction_uuid" => uuid))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: 'production', facts: facts, transaction_uuid: uuid)
+      subject.post_catalog(certname, environment: 'production', facts: facts, transaction_uuid: uuid)
     end
 
     it 'includes job_uuid' do
@@ -111,7 +112,7 @@ describe Puppet::HTTP::Service::Compiler do
         .with(body: hash_including("job_uuid" => uuid))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: 'production', facts: facts, job_uuid: uuid)
+      subject.post_catalog(certname, environment: 'production', facts: facts, job_uuid: uuid)
     end
 
     it 'includes static_catalog' do
@@ -119,7 +120,7 @@ describe Puppet::HTTP::Service::Compiler do
         .with(body: hash_including("static_catalog" => "false"))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: 'production', facts: facts, static_catalog: false)
+      subject.post_catalog(certname, environment: 'production', facts: facts, static_catalog: false)
     end
 
     it 'includes dot-separated list of checksum_types' do
@@ -127,24 +128,32 @@ describe Puppet::HTTP::Service::Compiler do
         .with(body: hash_including("checksum_type" => "sha256.sha384"))
         .to_return(**catalog_response)
 
-      subject.get_catalog(certname, environment: 'production', facts: facts, checksum_type: %w[sha256 sha384])
+      subject.post_catalog(certname, environment: 'production', facts: facts, checksum_type: %w[sha256 sha384])
     end
 
     it 'returns a deserialized catalog' do
       stub_request(:post, uri)
         .to_return(**catalog_response)
 
-      cat = subject.get_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"])
 
       expect {
-        subject.get_catalog(certname, environment: 'production', facts: facts)
+        subject.post_catalog(certname, environment: 'production', facts: facts)
       }.to raise_error do |err|
         expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
         expect(err.message).to eq('Server Error')
@@ -157,7 +166,7 @@ describe Puppet::HTTP::Service::Compiler do
         .to_return(body: "content-type is missing")
 
       expect {
-        subject.get_catalog(certname, environment: 'production', facts: facts)
+        subject.post_catalog(certname, environment: 'production', facts: facts)
       }.to raise_error(Puppet::HTTP::ProtocolError, /No content type in http response; cannot parse/)
     end
 
@@ -166,7 +175,7 @@ describe Puppet::HTTP::Service::Compiler do
         .to_return(body: "this isn't valid JSON", headers: {'Content-Type' => 'application/json'})
 
       expect {
-        subject.get_catalog(certname, environment: 'production', facts: facts)
+        subject.post_catalog(certname, environment: 'production', facts: facts)
       }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize Puppet::Resource::Catalog from json/)
     end
 
@@ -194,7 +203,7 @@ describe Puppet::HTTP::Service::Compiler do
             .with(body: hash_including("facts" => /#{test_fact[:encoded]}/))
             .to_return(**catalog_response)
 
-          subject.get_catalog(certname, environment: environment, facts: facts)
+          subject.post_catalog(certname, environment: environment, facts: facts)
         end
       end
     end
@@ -204,6 +213,16 @@ describe Puppet::HTTP::Service::Compiler do
     let(:uri) { %r{/puppet/v3/node/ziggy} }
     let(:node_response) { { body: formatter.render(node), headers: {'Content-Type' => formatter.mime } } }
 
+    it 'includes custom headers set via the :http_extra_headers and :profile settings' do
+      stub_request(:get, uri).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'}).
+        to_return(**node_response)
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.get_node(certname, environment: 'production')
+    end
+
     it 'includes environment' do
       stub_request(:get, uri)
           .with(query: hash_including("environment" => "outerspace"))
@@ -234,11 +253,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"])
@@ -271,9 +298,79 @@ describe Puppet::HTTP::Service::Compiler do
     end
   end
 
+  context 'when getting facts' do
+    let(:uri) { %r{/puppet/v3/facts/ziggy} }
+    let(:facts_response) { { body: formatter.render(facts), headers: {'Content-Type' => formatter.mime } } }
+
+    it 'includes environment' do
+      stub_request(:get, uri)
+          .with(query: hash_including("environment" => "outerspace"))
+          .to_return(**facts_response)
+
+      subject.get_facts(certname, environment: 'outerspace')
+    end
+
+    it 'returns a deserialized facts object' do
+      stub_request(:get, uri)
+        .to_return(**facts_response)
+
+      _, 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"])
+
+      expect {
+        subject.get_facts(certname, environment: 'production')
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq('Server Error')
+        expect(err.response.code).to eq(500)
+      end
+    end
+
+    it 'raises a protocol error if the content-type header is missing' do
+      stub_request(:get, uri)
+        .to_return(body: "content-type is missing")
+
+      expect {
+        subject.get_facts(certname, environment: 'production')
+      }.to raise_error(Puppet::HTTP::ProtocolError, /No content type in http response; cannot parse/)
+    end
+
+    it 'raises a serialization error if the content is invalid' do
+      stub_request(:get, uri)
+        .to_return(body: "this isn't valid JSON", headers: {'Content-Type' => 'application/json'})
+
+      expect {
+        subject.get_facts(certname, environment: 'production')
+      }.to raise_error(Puppet::HTTP::SerializationError, /Failed to deserialize Puppet::Node::Facts from json/)
+    end
+  end
+
   context 'when putting facts' do
     let(:uri) { %r{/puppet/v3/facts/ziggy} }
 
+    it 'includes custom headers set the :http_extra_headers and :profile settings' do
+      stub_request(:put, uri).with(headers: {'Example-Header' => 'real-thing', 'another' => 'thing', 'X-Puppet-Profiling' => 'true'})
+
+      Puppet[:http_extra_headers] = 'Example-Header:real-thing,another:thing'
+      Puppet[:profile] = true
+
+      subject.put_facts(certname, environment: environment, facts: facts)
+    end
+
     it 'serializes facts in the body' do
       facts = Puppet::Node::Facts.new(certname, { 'domain' => 'zork'})
       Puppet::Node::Facts.indirection.save(facts)
@@ -291,12 +388,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
@@ -319,4 +416,211 @@ describe Puppet::HTTP::Service::Compiler do
       }.to raise_error(Puppet::HTTP::SerializationError, /Failed to serialize Puppet::Node::Facts to json: "\\xE2" from ASCII-8BIT to UTF-8/)
     end
   end
+
+  context 'when getting status' do
+    let(:uri) { %r{/puppet/v3/status/ziggy} }
+    let(:status_response) { { body: formatter.render(status), headers: {'Content-Type' => formatter.mime } } }
+
+    it 'always sends production' do
+      stub_request(:get, uri)
+          .with(query: hash_including("environment" => "production"))
+          .to_return(**status_response)
+
+      subject.get_status(certname)
+    end
+
+    it 'returns a deserialized status' do
+      stub_request(:get, uri)
+        .to_return(**status_response)
+
+      _, 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"])
+
+      expect {
+        subject.get_status(certname)
+      }.to raise_error do |err|
+        expect(err).to be_an_instance_of(Puppet::HTTP::ResponseError)
+        expect(err.message).to eq('Server Error')
+        expect(err.response.code).to eq(500)
+      end
+    end
+
+    it 'raises a protocol error if the content-type header is missing' do
+      stub_request(:get, uri)
+        .to_return(body: "content-type is missing")
+
+      expect {
+        subject.get_status(certname)
+      }.to raise_error(Puppet::HTTP::ProtocolError, /No content type in http response; cannot parse/)
+    end
+
+    it 'raises a serialization error if the content is invalid' do
+      stub_request(:get, uri)
+        .to_return(body: "this isn't valid JSON", headers: {'Content-Type' => 'application/json'})
+
+      expect {
+        subject.get_status(certname)
+      }.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