puppet 6.12.0-x86-mingw32 → 6.17.0-x86-mingw32

data/spec/unit/indirector/file_metadata/rest_spec.rb

@@ -3,8 +3,116 @@ require 'spec_helper'
 require 'puppet/indirector/file_metadata'
 require 'puppet/indirector/file_metadata/rest'
 
-describe "Puppet::Indirector::Metadata::Rest" do
-  it "should add the node's cert name to the arguments"
+describe Puppet::Indirector::FileMetadata::Rest do
+  let(:certname) { 'ziggy' }
+  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:model) { described_class.model }
+
+  before :each do
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def metadata_response(metadata)
+    { body: formatter.render(metadata), headers: {'Content-Type' => formatter.mime } }
+  end
+
+  context "when finding" do
+    let(:uri) { %r{/puppet/v3/file_metadata/:mount/path/to/file} }
+    let(:key) { "puppet:///:mount/path/to/file" }
+    let(:metadata) { model.new('/path/to/file') }
+
+    it "returns file metadata" do
+      stub_request(:get, uri)
+        .to_return(status: 200, **metadata_response(metadata))
+
+      result = model.indirection.find(key)
+      expect(result.path).to eq('/path/to/file')
+    end
+
+    it "URL encodes special characters" do
+      stub_request(:get, %r{/puppet/v3/file_metadata/:mount/path%20to%20file})
+        .to_return(status: 200, **metadata_response(metadata))
+
+      model.indirection.find('puppet:///:mount/path to file')
+    end
+
+    it "returns nil if the content doesn't exist" do
+      stub_request(:get, uri).to_return(status: 404)
+
+      expect(model.indirection.find(key)).to be_nil
+    end
+
+    it "raises if fail_on_404 is true" do
+      stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
+
+      expect {
+        model.indirection.find(key, fail_on_404: true)
+      }.to raise_error(Puppet::Error, %r{Find /puppet/v3/file_metadata/:mount/path/to/file resulted in 404 with the message: {}})
+    end
+
+    it "raises an error on HTTP 500" do
+      stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
+
+      expect {
+        model.indirection.find(key)
+      }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
+    end
+
+    it "connects to a specific host" do
+      stub_request(:get, %r{https://example.com:8140/puppet/v3/file_metadata/:mount/path/to/file})
+        .to_return(status: 200, **metadata_response(metadata))
+
+      model.indirection.find("puppet://example.com:8140/:mount/path/to/file")
+    end
+  end
+
+  context "when searching" do
+    let(:uri) { %r{/puppet/v3/file_metadatas/:mount/path/to/dir} }
+    let(:key) { "puppet:///:mount/path/to/dir" }
+    let(:metadatas) { [model.new('/path/to/dir')] }
+
+    it "returns an array of file metadata" do
+      stub_request(:get, uri)
+        .to_return(status: 200, **metadata_response(metadatas))
+
+      result = model.indirection.search(key)
+      expect(result.first.path).to eq('/path/to/dir')
+    end
+
+    it "URL encodes special characters" do
+      stub_request(:get, %r{/puppet/v3/file_metadatas/:mount/path%20to%20dir})
+        .to_return(status: 200, **metadata_response(metadatas))
+
+      model.indirection.search('puppet:///:mount/path to dir')
+    end
+
+    it "returns an empty array if the metadata doesn't exist" do
+      stub_request(:get, uri).to_return(status: 404)
+
+      expect(model.indirection.search(key)).to eq([])
+    end
+
+    it "returns an empty array if the metadata doesn't exist and fail_on_404 is true" do
+      stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
+
+      expect(model.indirection.search(key, fail_on_404: true)).to eq([])
+    end
+
+    it "raises an error on HTTP 500" do
+      stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
+
+      expect {
+        model.indirection.search(key)
+      }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
+    end
+
+    it "connects to a specific host" do
+      stub_request(:get, %r{https://example.com:8140/puppet/v3/file_metadatas/:mount/path/to/dir})
+        .to_return(status: 200, **metadata_response(metadatas))
+
+      model.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
+    end
+  end
 
   it "should use the :fileserver SRV service" do
     expect(Puppet::Indirector::FileMetadata::Rest.srv_service).to eq(:fileserver)

data/spec/unit/indirector/node/rest_spec.rb

@@ -3,9 +3,64 @@ require 'spec_helper'
 require 'puppet/indirector/node/rest'
 
 describe Puppet::Node::Rest do
-  before do
-    @searcher = Puppet::Node::Rest.new
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/node/ziggy} }
+  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:node) { Puppet::Node.new(certname) }
+
+  before :each do
+    Puppet[:server] = 'compiler.example.com'
+    Puppet[:masterport] = 8140
+
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def node_response(node)
+    { body: formatter.render(node), headers: {'Content-Type' => formatter.mime } }
   end
 
+  it 'finds a node' do
+    stub_request(:get, uri).to_return(**node_response(node))
+
+    expect(described_class.indirection.find(certname)).to be_a(Puppet::Node)
+  end
+
+  it "serializes the environment" do
+    stub_request(:get, uri)
+      .with(query: hash_including('environment' => 'outerspace'))
+      .to_return(**node_response(node))
+
+    described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
+  end
+
+  it 'preserves the node environment_name as a symbol' do
+    env = Puppet::Node::Environment.remote('outerspace')
+    node = Puppet::Node.new(certname, environment: env)
+
+    stub_request(:get, uri).to_return(**node_response(node))
 
+    expect(described_class.indirection.find(certname).environment_name).to eq(:outerspace)
+  end
+
+  it 'returns nil if the node does not exist' do
+    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect(described_class.indirection.find(certname)).to be_nil
+  end
+
+  it 'raises if fail_on_404 is specified' do
+    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect{
+      described_class.indirection.find(certname, fail_on_404: true)
+    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/node/ziggy resulted in 404 with the message: {}})
+  end
+
+  it 'raises Net::HTTPError on 500' do
+    stub_request(:get, uri).to_return(status: 500)
+
+    expect{
+      described_class.indirection.find(certname)
+    }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
+  end
 end

data/spec/unit/indirector/report/rest_spec.rb

@@ -3,8 +3,21 @@ require 'spec_helper'
 require 'puppet/indirector/report/rest'
 
 describe Puppet::Transaction::Report::Rest do
-  it "should be a subclass of Puppet::Indirector::REST" do
-    expect(Puppet::Transaction::Report::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/report/ziggy} }
+  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:report) do
+    report = Puppet::Transaction::Report.new
+    report.host = certname
+    report
+  end
+
+  before(:each) do
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def report_response
+    { body: formatter.render(["store", "http"]), headers: {'Content-Type' => formatter.mime } }
   end
 
   it "should use the :report_server setting in preference to :server" do
@@ -22,71 +35,65 @@ describe Puppet::Transaction::Report::Rest do
     expect(Puppet::Transaction::Report::Rest.srv_service).to eq(:report)
   end
 
-  let(:model) { Puppet::Transaction::Report }
-  let(:terminus_class) { Puppet::Transaction::Report::Rest }
-  let(:terminus) { model.indirection.terminus(:rest) }
-  let(:indirection) { model.indirection }
+  it "saves a report " do
+    stub_request(:put, uri)
+      .to_return(status: 200, **report_response)
 
-  before(:each) do
-    Puppet::Transaction::Report.indirection.terminus_class = :rest
+    described_class.indirection.save(report)
   end
 
-  def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http 200 ok', :code => code.to_s, :body => body)
-    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
-    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
-    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
-    obj
+  it "serializes the environment" do
+    stub_request(:put, uri)
+      .with(query: hash_including('environment' => 'outerspace'))
+      .to_return(**report_response)
+
+    described_class.indirection.save(report, nil, environment: Puppet::Node::Environment.remote('outerspace'))
   end
 
-  def save_request(key, instance, options={})
-    Puppet::Indirector::Request.new(:report, :find, key, instance, options)
+  it "deserializes the response as an array of report processor names" do
+    stub_request(:put, %r{/puppet/v3/report})
+      .to_return(status: 200, **report_response)
+
+    expect(described_class.indirection.save(report)).to eq(["store", "http"])
   end
 
-  describe "#save" do
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
-    let(:instance) { model.new('the thing', 'some contents') }
-    let(:request) { save_request(instance.name, instance) }
-    let(:body) { ["store", "http"].to_pson }
+  it "returns nil if the node does not exist" do
+    stub_request(:put, uri)
+      .to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
 
-    before :each do
-      allow(terminus).to receive(:network).and_return(connection)
-    end
+    expect(described_class.indirection.save(report)).to be_nil
+  end
 
-    it "deserializes the response as an array of report processor names" do
-      response = mock_response('200', body, 'text/pson')
-      expect(connection).to receive(:put).and_return(response)
+  it "parses charset from response content-type" do
+    stub_request(:put, uri)
+      .to_return(status: 200, body: JSON.dump(["store"]), headers: { 'Content-Type' => 'application/json;charset=utf-8' })
 
-      expect(terminus.save(request)).to eq(["store", "http"])
-    end
+    expect(described_class.indirection.save(report)).to eq(["store"])
+  end
 
-    describe "when handling the response" do
-      describe "when the server major version is less than 5" do
-        it "raises if the save fails and we're not using pson" do
-          Puppet[:preferred_serialization_format] = "json"
+  describe "when the server major version is less than 5" do
+    it "raises if the save fails and we're not using pson" do
+      Puppet[:preferred_serialization_format] = "json"
 
-          response = mock_response('500', '{}', 'text/pson')
-          allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
-          expect(connection).to receive(:put).and_return(response)
+      stub_request(:put, uri)
+        .to_return(status: 500,
+                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
-          expect {
-            terminus.save(request)
-          }.to raise_error(Puppet::Error, /Server version 4.10.1 does not accept reports in 'json'/)
-        end
+      expect {
+        described_class.indirection.save(report)
+      }.to raise_error(Puppet::Error, /To submit reports to a server running puppetserver 4.10.1, set preferred_serialization_format to pson/)
+    end
 
-        it "raises with HTTP 500 if the save fails and we're already using pson" do
-          Puppet[:preferred_serialization_format] = "pson"
+    it "raises with HTTP 500 if the save fails and we're already using pson" do
+      Puppet[:preferred_serialization_format] = "pson"
 
-          response = mock_response('500', '{}', 'text/pson')
-          allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
-          expect(connection).to receive(:put).and_return(response)
+      stub_request(:put, uri)
+        .to_return(status: 500,
+                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
-          expect {
-            terminus.save(request)
-          }.to raise_error(Net::HTTPError, /Error 500 on SERVER/)
-        end
-      end
+      expect {
+        described_class.indirection.save(report)
+      }.to raise_error(Net::HTTPError, /Error 500 on SERVER/)
     end
   end
 end

data/spec/unit/indirector/request_spec.rb

@@ -94,7 +94,7 @@ describe Puppet::Indirector::Request do
 
       describe "and the URI is a 'file' URI" do
         before do
-          @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
+          @request = Puppet::Indirector::Request.new(:ind, :method, "#{Puppet::Util.uri_unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
         end
 
         it "should set the request key to the unescaped full file path" do

data/spec/unit/indirector/resource/ral_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'puppet/type/user'
 require 'puppet/indirector/resource/ral'
 
 describe "Puppet::Resource::Ral" do
@@ -18,7 +17,7 @@ describe "Puppet::Resource::Ral" do
       wrong_instance = double("wrong user", :name => "bob")
       my_instance    = double("my user",    :name => "root", :to_resource => my_resource)
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.find(@request)).to eq(my_resource)
     end
 
@@ -32,8 +31,8 @@ describe "Puppet::Resource::Ral" do
       root = double("Root User")
       root_resource = double("Root Resource")
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
-      expect(Puppet::Type::User).to receive(:new).with(hash_including(name: "root")).and_return(root)
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:new).with(hash_including(name: "root")).and_return(root)
       expect(root).to receive(:to_resource).and_return(root_resource)
 
       result = Puppet::Resource::Ral.new.find(@request)
@@ -51,7 +50,7 @@ describe "Puppet::Resource::Ral" do
       my_resource = double("my user resource", :title => "my user resource")
       my_instance = double("my user", :name => "root", :to_resource => my_resource)
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
@@ -69,7 +68,7 @@ describe "Puppet::Resource::Ral" do
 
       @request = double('request', :key => "user/root", :options => {})
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
@@ -87,7 +86,7 @@ describe "Puppet::Resource::Ral" do
 
       @request = double('request', :key => "user/", :options => {:name => "bob"})
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
@@ -105,7 +104,7 @@ describe "Puppet::Resource::Ral" do
 
       @request = double('request', :key => "user/", :options => {})
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ b_instance, a_instance ])
+      expect(Puppet::Type.type(:user)).to receive(:instances).and_return([ b_instance, a_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([a_resource, b_resource])
     end
   end

data/spec/unit/indirector/rest_spec.rb

@@ -45,6 +45,19 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
       expect(Puppet[:preferred_serialization_format]).to eq("pson")
     end
+
+    it "logs a deprecation warning" do
+      terminus.send(terminus_method, request)
+
+      expect(@logs).to include(an_object_having_attributes(level: :warning, message: /Puppet::Indirector::Rest##{terminus_method} is deprecated. Use Puppet::HTTP::Client instead./))
+    end
+
+    it "omits the warning when deprecations are disabled" do
+      Puppet[:disable_warnings] = 'deprecations'
+      terminus.send(terminus_method, request)
+
+      expect(@logs).to eq([])
+    end
   end
 
   HTTP_ERROR_CODES.each do |code|

data/spec/unit/indirector/status/rest_spec.rb

@@ -3,7 +3,48 @@ require 'spec_helper'
 require 'puppet/indirector/status/rest'
 
 describe Puppet::Indirector::Status::Rest do
-  it "should be a subclass of Puppet::Indirector::REST" do
-    expect(Puppet::Indirector::Status::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/status/ziggy} }
+  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+
+  before :each do
+    Puppet[:server] = 'compiler.example.com'
+    Puppet[:masterport] = 8140
+
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def status_response(node)
+    { body: formatter.render(node), headers: {'Content-Type' => formatter.mime } }
+  end
+
+  it 'finds server status' do
+    node = Puppet::Status.new(certname)
+
+    stub_request(:get, uri).to_return(**status_response(node))
+
+    expect(described_class.indirection.find(certname)).to be_a(Puppet::Status)
+  end
+
+  it 'returns nil if the node does not exist' do
+    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect(described_class.indirection.find(certname)).to be_nil
+  end
+
+  it 'raises if fail_on_404 is specified' do
+    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json' }, body: "{}")
+
+    expect{
+      described_class.indirection.find(certname, fail_on_404: true)
+    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/status/ziggy resulted in 404 with the message: {}})
+  end
+
+  it 'raises Net::HTTPError on 500' do
+    stub_request(:get, uri).to_return(status: 500)
+
+    expect{
+      described_class.indirection.find(certname)
+    }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
   end
 end