puppet 5.5.22 → 6.0.0

data/spec/unit/network/formats_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/formats'
@@ -101,14 +102,14 @@ describe "Puppet Network Format" do
     end
 
     it "should render by calling 'to_yaml' on the instance" do
-      instance = double('instance')
-      expect(instance).to receive(:to_yaml).and_return("foo")
+      instance = mock 'instance'
+      instance.expects(:to_yaml).returns "foo"
       expect(yaml.render(instance)).to eq("foo")
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
-      instances = [double('instance')]
-      expect(instances).to receive(:to_yaml).and_return("foo")
+      instances = [mock('instance')]
+      instances.expects(:to_yaml).returns "foo"
       expect(yaml.render_multiple(instances)).to eq("foo")
     end
 
@@ -149,6 +150,32 @@ describe "Puppet Network Format" do
         yaml.intern_multiple(Puppet::Node, YAML.dump(["hello"]))
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, /did not contain a valid instance/)
     end
+
+    it 'accepts indirected classes' do
+      [
+        Puppet::Node::Facts.new('foo', {}),
+        Puppet::Node.new('foo'),
+        Puppet::Resource.new('File', '/foo'),
+        Puppet::Transaction::Report.new('foo'),
+        Puppet::Resource::Catalog.new
+      ].each { |obj| yaml.intern(obj.class, YAML.dump(obj.to_data_hash)) }
+    end
+
+    it 'raises when interning an instance of an unacceptable indirected type' do
+      obj = Puppet::SSL::Key.new('foo')
+
+      expect {
+        yaml.intern(obj.class, YAML.dump(obj))
+      }.to raise_error(Puppet::Network::FormatHandler::FormatError, /Tried to load unspecified class: Puppet::SSL::Key/)
+    end
+
+    it 'raises when interning multple instances of an unacceptable indirected type' do
+      obj = Puppet::SSL::Key.new('foo')
+
+      expect {
+        yaml.intern_multiple(obj.class, YAML.dump([obj]))
+      }.to raise_error(Puppet::Network::FormatHandler::FormatError, /Tried to load unspecified class: Puppet::SSL::Key/)
+    end
   end
 
   describe "plaintext" do

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -15,7 +16,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    allow(handler).to receive(:warn_if_near_expiration)
+    handler.stubs(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -24,7 +25,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:params) { { :environment => "env" } }
 
     before do
-      allow(handler).to receive(:handler).and_return("foo")
+      handler.stubs(:handler).returns "foo"
     end
 
     around do |example|
@@ -38,27 +39,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if there is no environment specified" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {})
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the environment is not alphanumeric" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"})
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not match the prefix" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not have the correct version" do
-      expect {
-        handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v1/node/bar", params) }).to raise_error(bad_request_error)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
@@ -82,9 +75,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(bad_request_error)
     end
 
     it "should use the remainder of the URI as the indirection key" do
@@ -96,9 +87,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if no indirection key is specified" do
-      expect {
-        handler.uri2indirection("GET", "#{master_url_prefix}/node", params)
-      }.to raise_error(bad_request_error)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(bad_request_error)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
@@ -138,9 +127,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if an indirection method cannot be picked" do
-      expect {
-        handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params)
-      }.to raise_error(method_not_allowed_error)
+      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(method_not_allowed_error)
     end
 
     it "should not URI unescape the indirection key" do
@@ -152,24 +139,28 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "should not unescape the URI passed through in a call to check_authorization" do
       key_escaped = Puppet::Util.uri_encode("foo bar")
       uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
-      expect(handler).to receive(:check_authorization).with(anything, uri_escaped, anything)
-      handler.uri2indirection("GET", uri_escaped, params)
+      handler.expects(:check_authorization).with(anything, uri_escaped, anything)
+      _, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
     end
 
-    it "should not pass through an environment to check_authorization and fail if the environment is unknown" do
-      expect(handler).to receive(:check_authorization) do |_, _, arg|
-        expect(arg).not_to include(:environment)
-      end
-      expect {
-        handler.uri2indirection("GET",
-                                "#{master_url_prefix}/node/bar",
-                                {:environment => 'bogus'})
-      }.to raise_error(not_found_error)
+    it "when the environment is unknown should remove :environment from params passed to check_authorization and therefore fail" do
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 Not(has_key(:environment)))
+      expect(lambda { handler.uri2indirection("GET",
+                                              "#{master_url_prefix}/node/bar",
+                                              {:environment => 'bogus'}) }).to raise_error(not_found_error)
     end
 
     it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
-      expect(handler).to receive(:check_authorization).with(anything, anything, hash_including(environment: be_a(Puppet::Node::Environment).and(have_attributes(name: :env))))
-
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 all_of(
+                                                     has_entry(:environment,
+                                                               is_a(Puppet::Node::Environment)),
+                                                     has_entry(:environment,
+                                                               responds_with(:name,
+                                                                             :env))))
       handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
     end
 
@@ -180,7 +171,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
     before do
-      allow(handler).to receive(:handler).and_return("foo")
+      handler.stubs(:handler).returns "foo"
     end
 
     it "should include the environment in the query string of the URI" do
@@ -188,17 +179,17 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      allow(request).to receive(:indirection_name).and_return("certificate")
+      request.stubs(:indirection_name).returns("certificate")
       expect(handler.class.request_to_uri(request)).to eq("#{ca_url_prefix}/certificate/with%20spaces?environment=myenv&foo=bar")
     end
 
     it "should pluralize the indirection name if the method is 'search'" do
-      allow(request).to receive(:method).and_return(:search)
+      request.stubs(:method).returns :search
       expect(handler.class.request_to_uri(request).split("/")[3]).to eq("foos")
     end
 
     it "should add the query string to the URI" do
-      expect(request).to receive(:query_string).and_return("query")
+      request.expects(:query_string).returns "query"
       expect(handler.class.request_to_uri(request)).to match(/\&query$/)
     end
   end
@@ -221,7 +212,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      allow(request).to receive(:indirection_name).and_return("certificate")
+      request.stubs(:indirection_name).returns("certificate")
       expect(handler.class.request_to_uri_and_body(request).first).to eq("#{ca_url_prefix}/certificate/with%20spaces")
     end
 
@@ -236,7 +227,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       indirection.save(data, "my data")
       request = a_request_that_heads(data)
 
-      expect(handler).to receive(:check_authorization).and_raise(Puppet::Network::AuthorizationError.new("forbidden"))
+      handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
       expect {
         handler.call(request, response)
@@ -246,7 +237,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "should raise not_found_error if the indirection does not support remote requests" do
       request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
-      expect(indirection).to receive(:allow_remote_requests?).and_return(false)
+      indirection.expects(:allow_remote_requests?).returns(false)
 
       expect {
         handler.call(request, response)
@@ -280,7 +271,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "application/json, text/pson")
-      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -292,7 +283,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       data_string = "my data string"
       request = a_request_that_finds(data, :accept_header => "application/json")
-      expect(indirection).to receive(:find).and_return(data_string)
+      indirection.expects(:find).returns(data_string)
 
       handler.call(request, response)
 
@@ -326,7 +317,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
-      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -338,13 +329,12 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
-      allow(data).to receive(:to_json).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
-      allow(data).to receive(:to_pson).and_raise(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      data.stubs(:to_pson).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
 
       expect {
         handler.call(request, response)
-      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError,
-                       %r{No supported formats are acceptable \(Accept: application/json, text/pson\)})
+      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError, /No supported formats are acceptable/)
     end
 
     it "should return [] when searching returns an empty array" do
@@ -358,7 +348,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
     it "should raise not_found_error when searching returns nil" do
       request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, application/json")
-      expect(indirection).to receive(:search).and_return(nil)
+      indirection.expects(:search).returns(nil)
 
       expect {
         handler.call(request, response)

data/spec/unit/network/http/api/master/v3/authorization_spec.rb

@@ -3,23 +3,21 @@ require 'spec_helper'
 require 'puppet/network/http'
 
 describe Puppet::Network::HTTP::API::Master::V3::Authorization do
-  HTTP = Puppet::Network::HTTP
-
-  let(:response) { HTTP::MemoryResponse.new }
-  let(:authz) { HTTP::API::Master::V3::Authorization.new }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+  let(:authz) { Puppet::Network::HTTP::API::Master::V3::Authorization.new }
   let(:noop_handler) {
     lambda do |request, response|
     end
   }
 
   it "accepts v3 api requests that match allowed authconfig entries" do
-    request = HTTP::Request.from_hash({
+    request = Puppet::Network::HTTP::Request.from_hash({
       :path => "/v3/environments",
       :method => "GET",
       :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
-    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
 path /v3/environments
 method find
 allow *
@@ -35,13 +33,13 @@ allow *
   end
 
   it "rejects v3 api requests that are disallowed by authconfig entries" do
-    request = HTTP::Request.from_hash({
+    request = Puppet::Network::HTTP::Request.from_hash({
       :path => "/v3/environments",
       :method => "GET",
       :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
-    allow(authz).to receive(:authconfig).and_return(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
 path /v3/environments
 method find
 auth any
@@ -54,6 +52,6 @@ deny testing
 
     expect do
       handler.call(request, response)
-    end.to raise_error(HTTP::Error::HTTPNotAuthorizedError, /Forbidden request/)
+    end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, /Forbidden request/)
   end
 end

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -9,7 +9,6 @@ describe Puppet::Network::HTTP::API::Master::V3::Environment do
   let(:loader) { Puppet::Environments::Static.new(environment) }
 
   around :each do |example|
-    Puppet[:app_management] = true
     Puppet.override(:environments => loader) do
       Puppet::Type.newtype :sql, :is_capability => true do
         newparam :name, :namevar => true
@@ -176,7 +175,7 @@ describe Puppet::Network::HTTP::API::Master::V3::Environment do
   it "uses code_id from the catalog if it differs from the request" do
     request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
 
-    allow_any_instance_of(Puppet::Resource::Catalog).to receive(:code_id).and_return('67890')
+    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
 
     subject.call(request, response)
 

data/spec/unit/network/http/api/master/v3/environments_spec.rb

@@ -33,11 +33,11 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
+    conf_stub = stub 'conf_stub'
+    conf_stub.expects(:environment_timeout).returns(Float::INFINITY)
     environment = Puppet::Node::Environment.create(:production, [])
     env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
+    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
     handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
@@ -47,11 +47,11 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(1)
+    conf_stub = stub 'conf_stub'
+    conf_stub.expects(:environment_timeout).returns(1)
     environment = Puppet::Node::Environment.create(:production, [])
     env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
+    env_loader.expects(:get_conf).with(:production).returns(conf_stub)
     handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
@@ -59,4 +59,5 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
+
 end

data/spec/unit/network/http/api_spec.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet_spec/handler'
 require 'puppet/network/http'
@@ -37,11 +39,9 @@ describe Puppet::Network::HTTP::API do
 
   describe "Puppet API" do
     let(:handler) { PuppetSpec::Handler.new(Puppet::Network::HTTP::API.master_routes,
-                                            Puppet::Network::HTTP::API.ca_routes,
                                             Puppet::Network::HTTP::API.not_found_upgrade) }
 
     let(:master_prefix) { Puppet::Network::HTTP::MASTER_URL_PREFIX }
-    let(:ca_prefix) { Puppet::Network::HTTP::CA_URL_PREFIX }
 
     it "raises a not-found error for non-CA or master routes and suggests an upgrade" do
       req = Puppet::Network::HTTP::Request.from_hash(:path => "/unknown")
@@ -59,7 +59,6 @@ describe Puppet::Network::HTTP::API do
         expect(res[:status]).to eq(404)
         expect(res[:body]).to include("Puppet version: #{Puppet.version}")
         expect(res[:body]).to include("Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}")
-        expect(res[:body]).to include("Supported /puppet-ca API versions: #{Puppet::Network::HTTP::CA_URL_VERSIONS}")
       end
 
       it "gives an upgrade message for CA routes" do
@@ -69,7 +68,6 @@ describe Puppet::Network::HTTP::API do
         expect(res[:status]).to eq(404)
         expect(res[:body]).to include("Puppet version: #{Puppet.version}")
         expect(res[:body]).to include("Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}")
-        expect(res[:body]).to include("Supported /puppet-ca API versions: #{Puppet::Network::HTTP::CA_URL_VERSIONS}")
       end
     end
 
@@ -99,27 +97,5 @@ describe Puppet::Network::HTTP::API do
         expect(res[:body]).not_to include("Puppet version: #{Puppet.version}")
       end
     end
-
-    describe "when processing CA routes" do
-      it "responds to v1 indirector requests" do
-        allow(Puppet::SSL::Certificate.indirection).to receive(:find).and_return("foo")
-        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{ca_prefix}/v1/certificate/foo",
-                                                       :params => {:environment => "production"},
-                                                       :headers => {'accept' => "s"})
-        res = {}
-        handler.process(req, res)
-        expect(res[:body]).to eq("foo")
-        expect(res[:status]).to eq(200)
-      end
-
-      it "responds with a not found error to non-v1 requests and does not suggest an upgrade" do
-        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{ca_prefix}/unknown")
-        res = {}
-        handler.process(req, res)
-        expect(res[:status]).to eq(404)
-        expect(res[:body]).to include("No route for GET #{ca_prefix}/unknown")
-        expect(res[:body]).not_to include("Puppet version: #{Puppet.version}")
-      end
-    end
   end
 end