puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/network/http/api/{v2 → master/v3}/authorization_spec.rb

@@ -2,56 +2,58 @@ require 'spec_helper'
 
 require 'puppet/network/http'
 
-describe Puppet::Network::HTTP::API::V2::Authorization do
+describe Puppet::Network::HTTP::API::Master::V3::Authorization do
   HTTP = Puppet::Network::HTTP
 
   let(:response) { HTTP::MemoryResponse.new }
-  let(:authz) { HTTP::API::V2::Authorization.new }
+  let(:authz) { HTTP::API::Master::V3::Authorization.new }
+  let(:noop_handler) {
+    lambda do |request, response|
+    end
+  }
 
-  it "only authorizes GET requests" do
+  it "accepts v3 api requests that match allowed authconfig entries" do
     request = HTTP::Request.from_hash({
-      :method => "POST"
-    })
-
-    expect do
-      authz.call(request, response)
-    end.to raise_error(HTTP::Error::HTTPNotAuthorizedError)
-  end
-
-  it "accepts v2 api requests that match allowed authconfig entries" do
-    request = HTTP::Request.from_hash({
-      :path => "/v2.0/environments",
+      :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)
-path /v2.0/environments
+path /v3/environments
 method find
 allow *
     AUTH
 
+    handler = authz.wrap do
+      noop_handler
+    end
+
     expect do
-      authz.call(request, response)
+      handler.call(request, response)
     end.to_not raise_error
   end
 
-  it "rejects v2 api requests that are disallowed by authconfig entries" do
+  it "rejects v3 api requests that are disallowed by authconfig entries" do
     request = HTTP::Request.from_hash({
-      :path => "/v2.0/environments",
+      :path => "/v3/environments",
       :method => "GET",
-      :params => { :node => "testing", :ip => "127.0.0.1" }
+      :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
     })
 
     authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
-path /v2.0/environments
+path /v3/environments
 method find
 auth any
 deny testing
     AUTH
 
+    handler = authz.wrap do
+      noop_handler
+    end
+
     expect do
-      authz.call(request, response)
+      handler.call(request, response)
     end.to raise_error(HTTP::Error::HTTPNotAuthorizedError, /Forbidden request/)
   end
 end

data/spec/unit/network/http/api/{v2 → master/v3}/environments_spec.rb

@@ -4,13 +4,13 @@ require 'puppet/node/environment'
 require 'puppet/network/http'
 require 'matchers/json'
 
-describe Puppet::Network::HTTP::API::V2::Environments do
+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::V2::Environments.new(loader)
+    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
     handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
@@ -34,11 +34,11 @@ describe Puppet::Network::HTTP::API::V2::Environments do
 
   it "the response conforms to the environments schema for unlimited timeout" do
     conf_stub = stub 'conf_stub'
-    conf_stub.expects(:environment_timeout).returns(1.0 / 0.0)
+    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::V2::Environments.new(env_loader)
+    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
     handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
@@ -52,7 +52,7 @@ describe Puppet::Network::HTTP::API::V2::Environments do
     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::V2::Environments.new(env_loader)
+    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
     response = Puppet::Network::HTTP::MemoryResponse.new
 
     handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)

data/spec/unit/network/http/api/master/v3_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::Master::V3 do
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+  let(:master_url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3" }
+  let(:master_routes) {
+    Puppet::Network::HTTP::Route.
+        path(Regexp.new("#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/")).
+        any.
+        chain(Puppet::Network::HTTP::API::Master::V3.routes)
+  }
+
+  it "mounts the environments endpoint" do
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/environments")
+    master_routes.process(request, response)
+
+    expect(response.code).to eq(200)
+  end
+
+  it "mounts indirected routes" do
+    request = Puppet::Network::HTTP::Request.
+        from_hash(:path => "#{master_url_prefix}/node/foo",
+                  :params => {:environment => "production"},
+                  :headers => {"accept" => "text/pson"})
+    master_routes.process(request, response)
+
+    expect(response.code).to eq(200)
+  end
+
+  it "responds to unknown paths with a 404" do
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/unknown")
+    master_routes.process(request, response)
+
+    expect(response.code).to eq(404)
+    expect(response.body).to match("Not Found: Could not find indirection 'unknown'")
+  end
+end

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

@@ -0,0 +1,127 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet_spec/handler'
+require 'puppet/network/http'
+require 'puppet/version'
+
+describe Puppet::Network::HTTP::API do
+  def respond(text)
+    lambda { |req, res| res.respond_with(200, "text/plain", text) }
+  end
+
+  describe "#not_found" do
+    let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+
+    let(:routes) {
+      Puppet::Network::HTTP::Route.path(Regexp.new("foo")).
+      any.
+      chain(Puppet::Network::HTTP::Route.path(%r{^/bar$}).get(respond("bar")),
+            Puppet::Network::HTTP::API.not_found)
+    }
+
+    it "mounts the chained routes" do
+      request = Puppet::Network::HTTP::Request.from_hash(:path => "foo/bar")
+      routes.process(request, response)
+
+      expect(response.code).to eq(200)
+      expect(response.body).to eq("bar")
+    end
+
+    it "responds to unknown paths with a 404" do
+      request = Puppet::Network::HTTP::Request.from_hash(:path => "foo/unknown")
+
+      expect do
+        routes.process(request, response)
+      end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+    end
+  end
+
+  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")
+      res = {}
+      handler.process(req, res)
+      expect(res[:status]).to eq(404)
+      expect(res[:body]).to include("Puppet version: #{Puppet.version}")
+    end
+
+    describe "when processing Puppet 3 routes" do
+      it "gives an upgrade message for master routes" do
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "/production/node/foo")
+        res = {}
+        handler.process(req, res)
+        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
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "/production/certificate/foo")
+        res = {}
+        handler.process(req, res)
+        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
+
+    describe "when processing master routes" do
+      it "responds to v3 indirector requests" do
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/node/foo",
+                                                       :params => {:environment => "production"},
+                                                       :headers => {'accept' => "pson"})
+        res = {}
+        handler.process(req, res)
+        expect(res[:status]).to eq(200)
+      end
+
+      it "responds to v3 environments requests" do
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/environments")
+        res = {}
+        handler.process(req, res)
+        expect(res[:status]).to eq(200)
+      end
+
+      it "responds with a not found error to non-v3 requests and does not suggest an upgrade" do
+        req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/unknown")
+        res = {}
+        handler.process(req, res)
+        expect(res[:status]).to eq(404)
+        expect(res[:body]).to include("No route for GET #{master_prefix}/unknown")
+        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

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

@@ -16,27 +16,27 @@ describe "http compression" do
     end
 
     it "should have a module function that returns the None underlying module" do
-      Puppet::Network::HTTP::Compression.module.should == Puppet::Network::HTTP::Compression::None
+      expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::None)
     end
 
     it "should not add any Accept-Encoding header" do
-      @uncompressor.add_accept_encoding({}).should == {}
+      expect(@uncompressor.add_accept_encoding({})).to eq({})
     end
 
     it "should not tamper the body" do
       response = stub 'response', :body => "data"
-      @uncompressor.uncompress_body(response).should == "data"
+      expect(@uncompressor.uncompress_body(response)).to eq("data")
     end
 
     it "should yield an identity uncompressor" do
       response = stub 'response'
       @uncompressor.uncompress(response) { |u|
-        u.should be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+        expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
       }
     end
   end
 
-  describe "when zlib is available", :if => Puppet.features.zlib? do
+  describe "when zlib is available" do
     before(:each) do
       Puppet.features.stubs(:zlib?).returns true
 
@@ -49,21 +49,15 @@ describe "http compression" do
     end
 
     it "should have a module function that returns the Active underlying module" do
-      Puppet::Network::HTTP::Compression.module.should == Puppet::Network::HTTP::Compression::Active
+      expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::Active)
     end
 
-    it "should add an Accept-Encoding header when http compression is available" do
-      Puppet[:http_compression] = true
+    it "should add an Accept-Encoding header supporting compression" do
       headers = @uncompressor.add_accept_encoding({})
-      headers.should have_key('accept-encoding')
-      headers['accept-encoding'].should =~ /gzip/
-      headers['accept-encoding'].should =~ /deflate/
-      headers['accept-encoding'].should =~ /identity/
-    end
-
-    it "should add an Accept-Encoding 'identity' header if http compression is disabled" do
-      Puppet[:http_compression] = false
-      @uncompressor.add_accept_encoding({}).should == {'accept-encoding' => 'identity'}
+      expect(headers).to have_key('accept-encoding')
+      expect(headers['accept-encoding']).to match(/gzip/)
+      expect(headers['accept-encoding']).to match(/deflate/)
+      expect(headers['accept-encoding']).to match(/identity/)
     end
 
     describe "when uncompressing response body" do
@@ -74,12 +68,12 @@ describe "http compression" do
       end
 
       it "should return untransformed response body with no content-encoding" do
-        @uncompressor.uncompress_body(@response).should == "mydata"
+        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
       end
 
       it "should return untransformed response body with 'identity' content-encoding" do
         @response.stubs(:[]).with('content-encoding').returns('identity')
-        @uncompressor.uncompress_body(@response).should == "mydata"
+        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
       end
 
       it "should use a Zlib inflater with 'deflate' content-encoding" do
@@ -89,7 +83,7 @@ describe "http compression" do
         Zlib::Inflate.expects(:new).returns(inflater)
         inflater.expects(:inflate).with("mydata").returns "uncompresseddata"
 
-        @uncompressor.uncompress_body(@response).should == "uncompresseddata"
+        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
 
       it "should use a GzipReader with 'gzip' content-encoding" do
@@ -102,7 +96,7 @@ describe "http compression" do
         Zlib::GzipReader.expects(:new).with(io).returns(reader)
         reader.expects(:read).returns "uncompresseddata"
 
-        @uncompressor.uncompress_body(@response).should == "uncompresseddata"
+        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
     end
 
@@ -117,14 +111,14 @@ describe "http compression" do
 
       it "should yield an identity uncompressor with no content-encoding" do
         @uncompressor.uncompress(@response) { |u|
-          u.should be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
         }
       end
 
       it "should yield an identity uncompressor with 'identity' content-encoding" do
         @response.stubs(:[]).with('content-encoding').returns 'identity'
         @uncompressor.uncompress(@response) { |u|
-          u.should be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
         }
       end
 
@@ -132,7 +126,7 @@ describe "http compression" do
         it "should yield a Zlib uncompressor with '#{c}' content-encoding" do
           @response.stubs(:[]).with('content-encoding').returns c
           @uncompressor.uncompress(@response) { |u|
-            u.should be_instance_of(Puppet::Network::HTTP::Compression::Active::ZlibAdapter)
+            expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::Active::ZlibAdapter)
           }
         end
       end
@@ -165,7 +159,7 @@ describe "http compression" do
 
       it "should return the inflated chunk" do
         @inflater.stubs(:inflate).with("chunk").returns("uncompressed")
-        @adapter.uncompress("chunk").should == "uncompressed"
+        expect(@adapter.uncompress("chunk")).to eq("uncompressed")
       end
 
       it "should try a 'regular' inflater on Zlib::DataError" do
@@ -179,7 +173,7 @@ describe "http compression" do
       it "should raise the error the second time" do
         @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
         Zlib::Inflate.expects(:new).with.returns(@inflater)
-        lambda { @adapter.uncompress("chunk") }.should raise_error
+        expect { @adapter.uncompress("chunk") }.to raise_error
       end
 
       it "should finish the stream on close" do

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

@@ -1,7 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http/connection'
-require 'puppet/network/authentication'
 
 describe Puppet::Network::HTTP::Connection do
 
@@ -70,7 +69,7 @@ describe Puppet::Network::HTTP::Connection do
           subject.send(method, "/foo", {}) do |response|
             block_executed = true
           end
-          block_executed.should == true
+          expect(block_executed).to eq(true)
         end
       end
     end
@@ -144,7 +143,7 @@ describe Puppet::Network::HTTP::Connection do
         connection.get('request')
       end.to raise_error(Puppet::Error) do |error|
         error.message =~ /Server hostname 'my_server' did not match server certificate; expected one of (.+)/
-        $1.split(', ').should =~ %w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server]
+        expect($1.split(', ')).to match_array(%w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server])
       end
     end
 
@@ -170,8 +169,6 @@ describe Puppet::Network::HTTP::Connection do
       Net::HTTP.any_instance.stubs(:start)
       Net::HTTP.any_instance.stubs(:request).returns(httpok)
 
-      connection.expects(:warn_if_near_expiration).with(cert)
-
       connection.get('request')
     end
   end