puppet 6.13.0-x64-mingw32 → 6.14.0-x64-mingw32

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

@@ -3,42 +3,97 @@ require 'spec_helper'
 require 'puppet/indirector/facts/rest'
 
 describe Puppet::Node::Facts::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::Node::Facts::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/facts/ziggy} }
+  let(:facts) { Puppet::Node::Facts.new(certname, test_fact: 'test value') }
+
+  before do
+    Puppet[:server] = 'compiler.example.com'
+    Puppet[:masterport] = 8140
+
+    described_class.indirection.terminus_class = :rest
   end
 
-  let(:model) { Puppet::Node::Facts }
-  before(:each) { model.indirection.terminus_class = :rest }
+  describe '#find' do
+    let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+
+    def facts_response(facts)
+      { body: formatter.render(facts), headers: {'Content-Type' => formatter.mime } }
+    end
+
+    it 'finds facts' do
+      stub_request(:get, uri).to_return(**facts_response(facts))
+
+      expect(described_class.indirection.find(certname)).to be_a(Puppet::Node::Facts)
+    end
+
+    it "serializes the environment" do
+      stub_request(:get, uri)
+        .with(query: hash_including('environment' => 'outerspace'))
+        .to_return(**facts_response(facts))
+
+      described_class.indirection.find(certname, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    it 'returns nil if the facts do 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/facts/ziggy resulted in 404 with the message: {}})
+    end
+
+    it 'raises Net::HTTPError on 500' do
+      stub_request(:get, uri).to_return(status: 500)
 
-  def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http response', :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
+      expect{
+        described_class.indirection.find(certname)
+      }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
+    end
   end
 
   describe '#save' do
-    subject { model.indirection.terminus(:rest) }
+    it 'returns nil on success' do
+      stub_request(:put, %r{/puppet/v3/facts})
+        .to_return(status: 200, headers: { 'Content-Type' => 'application/json'}, body: '')
 
-    let(:connection) { double('mock http connection', :verify_callback= => nil) }
-    let(:node_name) { 'puppet.node.test' }
-    let(:data) { model.new(node_name, {test_fact: 'test value'}) }
-    let(:request) { Puppet::Indirector::Request.new(:facts, :save, node_name, data) }
+      expect(described_class.indirection.save(facts)).to be_nil
+    end
+
+    it "serializes the environment" do
+      stub_request(:put, uri)
+        .with(query: hash_including('environment' => 'outerspace'))
+        .to_return(status: 200, headers: { 'Content-Type' => 'application/json'}, body: '')
+
+      described_class.indirection.save(facts, nil, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
 
-    before :each do
-      allow(subject).to receive(:network).and_return(connection)
+    it 'raises if options are specified' do
+      expect {
+        described_class.indirection.save(facts, nil, foo: :bar)
+      }.to raise_error(ArgumentError, /PUT does not accept options/)
     end
 
-    context 'when a 404 response is received' do
-      let(:response) { mock_response(404, '{}', 'test/json') }
+    it 'raises with HTTP 404' do
+      stub_request(:put, %r{/puppet/v3/facts}).to_return(status: 404)
+
+      expect {
+        described_class.indirection.save(facts)
+      }.to raise_error(Net::HTTPError, /Error 404 on SERVER/)
+    end
 
-      before(:each) { expect(connection).to receive(:put).and_return(response) }
+    it 'raises with HTTP 500' do
+      stub_request(:put, %r{/puppet/v3/facts}).to_return(status: 500)
 
-      it 'riases with HTTP 404' do
-        expect{ subject.save(request) }.to raise_error(Net::HTTPError,
-                                                       /Error 404 on SERVER/)
-      end
+      expect {
+        described_class.indirection.save(facts)
+      }.to raise_error(Net::HTTPError, /Error 500 on SERVER/)
     end
   end
 end

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

@@ -3,9 +3,60 @@ require 'spec_helper'
 require 'puppet/indirector/file_content/rest'
 
 describe Puppet::Indirector::FileContent::Rest do
-  it "should add the node's cert name to the arguments"
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/file_content/:mount/path/to/file} }
+  let(:key) { "puppet:///:mount/path/to/file" }
 
-  it "should set the content type to text/plain"
+  before :each do
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def file_content_response
+    {body: "some content", headers: { 'Content-Type' => 'application/octet-stream' } }
+  end
+
+  it "returns content as a binary string" do
+    stub_request(:get, uri).to_return(status: 200, **file_content_response)
+
+    file_content = described_class.indirection.find(key)
+    expect(file_content.content.encoding).to eq(Encoding::BINARY)
+    expect(file_content.content).to eq('some content')
+  end
+
+  it "URL encodes special characters" do
+    stub_request(:get, %r{/puppet/v3/file_content/:mount/path%20to%20file}).to_return(status: 200, **file_content_response)
+
+    described_class.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(described_class.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 {
+      described_class.indirection.find(key, fail_on_404: true)
+    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/file_content/: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 {
+      described_class.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_content/:mount/path/to/file})
+      .to_return(status: 200, **file_content_response)
+
+    described_class.indirection.find("puppet://example.com:8140/:mount/path/to/file")
+  end
 
   it "should use the :fileserver SRV service" do
     expect(Puppet::Indirector::FileContent::Rest.srv_service).to eq(:fileserver)

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

@@ -3,8 +3,115 @@ 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) }
+
+  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) { Puppet::FileServing::Metadata.new('/path/to/file') }
+
+    it "returns file metadata" do
+      stub_request(:get, uri)
+        .to_return(status: 200, **metadata_response(metadata))
+
+      result = described_class.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))
+
+      described_class.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(described_class.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 {
+        described_class.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 {
+        described_class.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))
+
+      described_class.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) { [Puppet::FileServing::Metadata.new('/path/to/dir')] }
+
+    it "returns an array of file metadata" do
+      stub_request(:get, uri)
+        .to_return(status: 200, **metadata_response(metadatas))
+
+      result = described_class.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))
+
+      described_class.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(described_class.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(described_class.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 {
+        described_class.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))
+
+      described_class.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