puppet 5.3.4 → 6.29.0

data/spec/unit/network/formats_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/formats'
@@ -102,14 +101,14 @@ describe "Puppet Network Format" do
     end
 
     it "should render by calling 'to_yaml' on the instance" do
-      instance = mock 'instance'
-      instance.expects(:to_yaml).returns "foo"
+      instance = double('instance')
+      expect(instance).to receive(:to_yaml).and_return("foo")
       expect(yaml.render(instance)).to eq("foo")
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
-      instances = [mock('instance')]
-      instances.expects(:to_yaml).returns "foo"
+      instances = [double('instance')]
+      expect(instances).to receive(:to_yaml).and_return("foo")
       expect(yaml.render_multiple(instances)).to eq("foo")
     end
 
@@ -150,6 +149,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
@@ -333,14 +358,6 @@ describe "Puppet Network Format" do
       expect(json.weight).to eq(15)
     end
 
-    it "should use a native parser implementation" do
-      expect(JSON.parser.name).to eq("JSON::Ext::Parser")
-    end
-
-    it "should use a native generator implementation" do
-      expect(JSON.generator.name).to eq("JSON::Ext::Generator")
-    end
-
     it "should render an instance as JSON" do
       instance = FormatsTest.new("foo")
       expect(json.render(instance)).to eq({"string" => "foo"}.to_json)
@@ -351,21 +368,27 @@ describe "Puppet Network Format" do
       expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
     end
 
+    it "should render multiple instances as a JSON array of hashes when multi_json is not present" do
+      hide_const("MultiJson") if defined?(MultiJson)
+      instances = [FormatsTest.new("foo")]
+      expect(json.render_multiple(instances)).to eq([{"string" => "foo"}].to_json)
+    end
+
     it "should intern an instance from a JSON hash" do
-      text = JSON.dump({"string" => "parsed_json"})
+      text = Puppet::Util::Json.dump({"string" => "parsed_json"})
       instance = json.intern(FormatsTest, text)
       expect(instance.string).to eq("parsed_json")
     end
 
     it "should skip data_to_hash if data is already an instance of the specified class" do
       # The rest terminus for the report indirected type relies on this behavior
-      data = JSON.dump([1, 2])
+      data = Puppet::Util::Json.dump([1, 2])
       instance = json.intern(Array, data)
       expect(instance).to eq([1, 2])
     end
 
     it "should intern multiple instances from a JSON array of hashes" do
-      text = JSON.dump(
+      text = Puppet::Util::Json.dump(
         [
           {
             "string" => "BAR"
@@ -379,7 +402,7 @@ describe "Puppet Network Format" do
     end
 
     it "should reject wrapped data from legacy clients as they've never supported JSON" do
-      text = JSON.dump(
+      text = Puppet::Util::Json.dump(
         {
           "type" => "FormatsTest",
           "data" => {
@@ -394,7 +417,7 @@ describe "Puppet Network Format" do
     it "fails intelligibly when given invalid data" do
       expect do
         json.intern(Puppet::Node, '')
-      end.to raise_error(JSON::ParserError, /A JSON text must at least contain two octets|unexpected token at ''/)
+      end.to raise_error(Puppet::Util::Json::ParseError)
     end
   end
 
@@ -517,4 +540,45 @@ EOT
       end
     end
   end
+
+  describe ":flat format" do
+    let(:flat) { Puppet::Network::FormatHandler.format(:flat) }
+
+    it "should include a flat format" do
+      expect(flat).to be_an_instance_of Puppet::Network::Format
+    end
+
+    [:intern, :intern_multiple].each do |method|
+      it "should not implement #{method}" do
+        expect { flat.send(method, String, 'blah') }.to raise_error NotImplementedError
+      end
+    end
+
+    context "when rendering arrays" do
+      {
+          []                           => "",
+          [1, 2]                       => "0=1\n1=2\n",
+          ["one"]                      => "0=one\n",
+          [{"one" => 1}, {"two" => 2}] => "0.one=1\n1.two=2\n",
+          [['something', 'for'], ['the', 'test']]  => "0=[\"something\", \"for\"]\n1=[\"the\", \"test\"]\n"
+      }.each_pair do |input, output|
+        it "should render #{input.inspect} as one item per line" do
+          expect(flat.render(input)).to eq(output)
+        end
+      end
+    end
+
+    context "when rendering hashes" do
+      {
+          {}                                   => "",
+          {1 => 2}                             => "1=2\n",
+          {"one" => "two"}                     => "one=two\n",
+          {[1,2] => 3, [2,3] => 5, [3,4] => 7} => "[1, 2]=3\n[2, 3]=5\n[3, 4]=7\n",
+      }.each_pair do |input, output|
+        it "should render #{input.inspect}" do
+          expect(flat.render(input)).to eq(output)
+        end
+      end
+    end
+  end
 end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
@@ -6,6 +5,8 @@ require 'puppet/network/http/api/indirected_routes'
 require 'puppet/indirector_testing'
 require 'puppet_spec/network'
 
+RSpec::Matchers.define_negated_matcher :excluding, :include
+
 describe Puppet::Network::HTTP::API::IndirectedRoutes do
   include PuppetSpec::Network
 
@@ -16,7 +17,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    handler.stubs(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
@@ -24,10 +24,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:env_loaders) { Puppet::Environments::Static.new(environment) }
     let(:params) { { :environment => "env" } }
 
-    before do
-      handler.stubs(:handler).returns "foo"
-    end
-
     around do |example|
       Puppet.override(:environments => env_loaders) do
         example.run
@@ -39,19 +35,27 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if there is no environment specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(bad_request_error)
+      expect {
+        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(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(bad_request_error)
+      expect {
+        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(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(bad_request_error)
+      expect {
+        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(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(bad_request_error)
+      expect {
+        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
@@ -75,7 +79,9 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(bad_request_error)
+      expect {
+        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
@@ -87,7 +93,9 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if no indirection key is specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(bad_request_error)
+      expect {
+        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
@@ -106,6 +114,10 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(handler.uri2indirection("GET", "#{master_url_prefix}/nodes/bar", params)[1]).to eq(:search)
     end
 
+    it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
+      expect(handler.uri2indirection("PUT", "#{master_url_prefix}/facts/puppet.node.test", params)[0].name).to eq(:facts)
+    end
+
     it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
       expect(handler.uri2indirection("GET", "#{master_url_prefix}/statuses/bar", params)[0].name).to eq(:status)
     end
@@ -123,40 +135,37 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if an indirection method cannot be picked" do
-      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(method_not_allowed_error)
+      expect {
+        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
       escaped = Puppet::Util.uri_encode("foo bar")
-      indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
+      _, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
       expect(key).to eq(escaped)
     end
 
     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}"
-      handler.expects(:check_authorization).with(anything, uri_escaped, anything)
-      indirection, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
+      expect(handler).to receive(: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
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 Not(has_entry(:environment)))
-      expect(lambda { 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
+      expect(handler).to receive(:check_authorization).with(anything,
+                                                            anything,
+                                                            excluding(:environment))
+      expect { 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
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 all_of(
-                                                     has_entry(:environment,
-                                                               is_a(Puppet::Node::Environment)),
-                                                     has_entry(:environment,
-                                                               responds_with(:name,
-                                                                             :env))))
+      expect(handler).to receive(:check_authorization).with(anything, anything, hash_including(environment: be_a(Puppet::Node::Environment).and(have_attributes(name: :env))))
+
       handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
     end
 
@@ -166,26 +175,22 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
     let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
-    before do
-      handler.stubs(:handler).returns "foo"
-    end
-
     it "should include the environment in the query string of the URI" do
       expect(handler.class.request_to_uri(request)).to eq("#{master_url_prefix}/foo/with%20spaces?environment=myenv&foo=bar")
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      request.stubs(:indirection_name).returns("certificate")
+      allow(request).to receive(:indirection_name).and_return("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
-      request.stubs(:method).returns :search
+      allow(request).to receive(:method).and_return(:search)
       expect(handler.class.request_to_uri(request).split("/")[3]).to eq("foos")
     end
 
     it "should add the query string to the URI" do
-      request.expects(:query_string).returns "query"
+      expect(request).to receive(:query_string).and_return("query")
       expect(handler.class.request_to_uri(request)).to match(/\&query$/)
     end
   end
@@ -208,7 +213,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should include the correct url prefix if it is a ca request" do
-      request.stubs(:indirection_name).returns("certificate")
+      allow(request).to receive(:indirection_name).and_return("certificate")
       expect(handler.class.request_to_uri_and_body(request).first).to eq("#{ca_url_prefix}/certificate/with%20spaces")
     end
 
@@ -223,7 +228,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       indirection.save(data, "my data")
       request = a_request_that_heads(data)
 
-      handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
+      expect(handler).to receive(:check_authorization).and_raise(Puppet::Network::AuthorizationError.new("forbidden"))
 
       expect {
         handler.call(request, response)
@@ -233,7 +238,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"))
 
-      indirection.expects(:allow_remote_requests?).returns(false)
+      expect(indirection).to receive(:allow_remote_requests?).and_return(false)
 
       expect {
         handler.call(request, response)
@@ -267,7 +272,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")
-      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      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')
 
       handler.call(request, response)
 
@@ -279,7 +284,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")
-      indirection.expects(:find).returns(data_string)
+      expect(indirection).to receive(:find).and_return(data_string)
 
       handler.call(request, response)
 
@@ -313,7 +318,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")
-      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      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')
 
       handler.call(request, response)
 
@@ -325,12 +330,13 @@ 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")
-      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')
+      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')
 
       expect {
         handler.call(request, response)
-      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError, /No supported formats are acceptable/)
+      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError,
+                       %r{No supported formats are acceptable \(Accept: application/json, text/pson\)})
     end
 
     it "should return [] when searching returns an empty array" do
@@ -344,7 +350,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")
-      indirection.expects(:search).returns(nil)
+      expect(indirection).to receive(:search).and_return(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" }
     })
 
-    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    allow(authz).to receive(:authconfig).and_return(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" }
     })
 
-    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+    allow(authz).to receive(:authconfig).and_return(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")
 
-    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
+    allow_any_instance_of(Puppet::Resource::Catalog).to receive(:code_id).and_return('67890')
 
     subject.call(request, response)
 

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

@@ -7,13 +7,14 @@ require 'matchers/json'
 describe Puppet::Network::HTTP::API::Master::V3::Environments do
   include JSONMatchers
 
-  it "responds with all of the available environments" do
-    environment = Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+  let(:environment) { Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+  let(:handler) { Puppet::Network::HTTP::API::Master::V3::Environments.new(loader) }
+  let(:request) { Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }) }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+  it "responds with all of the available environments" do
+    handler.call(request, response)
 
     expect(response.code).to eq(200)
     expect(response.type).to eq("application/json")
@@ -33,31 +34,18 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    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)
-    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
+    Puppet[:environment_timeout] = 'unlimited'
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    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)
-    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
+    Puppet[:environment_timeout] = 1
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
-
 end

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

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet_spec/handler'
 require 'puppet/network/http'
@@ -39,11 +37,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")
@@ -61,7 +57,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
@@ -71,7 +66,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
 
@@ -101,27 +95,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
-        Puppet::SSL::Certificate.indirection.stubs(:find).returns "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