puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

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

@@ -15,7 +15,7 @@ describe Puppet::Network::HTTP::Error do
   end
 
   describe Puppet::Network::HTTP::Error::HTTPServerError do
-    it "should serialize to JSON that matches the error schema and has a deprecated stacktrace property" do
+    it "should serialize to JSON that matches the error schema" do
       begin
         raise Exception, "a wild Exception appeared!"
       rescue Exception => e
@@ -24,7 +24,6 @@ describe Puppet::Network::HTTP::Error do
       error = Puppet::Network::HTTP::Error::HTTPServerError.new(culpable)
 
       expect(error.to_json).to validate_against('api/schemas/error.json')
-      expect(error.to_json).to match(/The 'stacktrace' property is deprecated/)
     end
   end
 

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

@@ -78,49 +78,20 @@ describe Puppet::Network::HTTP::Factory do
 
       expect(conn.proxy_port).to eq(proxy_port)
     end
-  end
-
-  context 'socket timeouts' do
-    it 'sets open timeout' do
-      Puppet[:http_connect_timeout] = "10s"
-      conn = create_connection(site)
-
-      expect(conn.open_timeout).to eq(10)
-    end
-
-    it 'sets read timeout' do
-      Puppet[:http_read_timeout] = "2m"
-      conn = create_connection(site)
-
-      expect(conn.read_timeout).to eq(120)
-    end
-  end
-
-  it "disables ruby's http_keepalive_timeout on Ruby 2" do
-    skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
-    conn = create_connection(site)
-
-    expect(conn.keep_alive_timeout).to eq(2147483647)
-  end
 
-  context 'source address' do
-    it 'defaults to system-defined' do
-      skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
-      conn = create_connection(site)
+    context 'socket timeouts' do
+      it 'sets open timeout' do
+        Puppet[:http_connect_timeout] = "10s"
+        conn = create_connection(site)
 
-      expect(conn.local_host).to be(nil)
-    end
+        expect(conn.open_timeout).to eq(10)
+      end
 
-    it 'sets the local_host address' do
-      Puppet[:sourceaddress] = "127.0.0.1"
-      if RUBY_VERSION.to_i >= 2
+      it 'sets read timeout' do
+        Puppet[:http_read_timeout] = "2m"
         conn = create_connection(site)
 
-        expect(conn.local_host).to eq('127.0.0.1')
-      else
-        expect {
-          create_connection(site)
-        }.to raise_error(ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP.")
+        expect(conn.read_timeout).to eq(120)
       end
     end
   end

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

@@ -18,8 +18,8 @@ describe Puppet::Network::HTTP::Handler do
 
   def a_request(method = "HEAD", path = "/production/#{indirection.name}/unknown")
     {
-      :accept_header => "pson",
-      :content_type_header => "text/pson",
+      :accept_header => "application/json",
+      :content_type_header => "application/json",
       :method => method,
       :path => path,
       :params => {},
@@ -68,7 +68,7 @@ describe Puppet::Network::HTTP::Handler do
 
       res_body = JSON(res[:body])
 
-      expect(res[:content_type_header]).to eq("application/json")
+      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
       expect(res_body["issue_kind"]).to eq("HANDLER_NOT_FOUND")
       expect(res_body["message"]).to eq("Not Found: No route for GET /vtest/foo")
       expect(res[:status]).to eq(404)
@@ -92,12 +92,9 @@ describe Puppet::Network::HTTP::Handler do
 
       res_body = JSON(res[:body])
 
-      expect(res[:content_type_header]).to eq("application/json")
+      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
       expect(res_body["issue_kind"]).to eq(Puppet::Network::HTTP::Issues::RUNTIME_ERROR.to_s)
       expect(res_body["message"]).to eq("Server Error: the sky is falling!")
-      expect(res_body["stacktrace"].is_a?(Array) && !res_body["stacktrace"].empty?).to be_truthy
-      expect(res_body["stacktrace"][0]).to match(/The 'stacktrace' property is deprecated/)
-      expect(res_body["stacktrace"] & original_stacktrace).to be_empty
       expect(res[:status]).to eq(500)
     end
 
@@ -142,16 +139,16 @@ describe Puppet::Network::HTTP::Handler do
     it "should still find the correct format if content type contains charset information" do
       request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
                                                    {}, 'GET', '/', nil)
-      expect(request.format).to eq("s")
+      expect(request.formatter.name).to eq(:s)
     end
 
     # PUP-3272
     # This used to be for YAML, and doing a to_yaml on an array.
-    # The result with to_pson is something different, the result is a string
+    # The result with to_json is something different, the result is a string
     # Which seems correct. Looks like this was some kind of nesting option "yaml inside yaml" ?
     # Removing the test
-#    it "should deserialize PSON parameters" do
-#      params = {'my_param' => [1,2,3].to_pson}
+#    it "should deserialize JSON parameters" do
+#      params = {'my_param' => [1,2,3].to_json}
 #
 #      decoded_params = handler.send(:decode_params, params)
 #
@@ -159,7 +156,6 @@ describe Puppet::Network::HTTP::Handler do
 #    end
   end
 
-
   describe "when resolving node" do
     it "should use a look-up from the ip address" do
       Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")

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

@@ -0,0 +1,110 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet_spec/network'
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Request do
+  include PuppetSpec::Network
+
+  let(:json_formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:pson_formatter) { Puppet::Network::FormatHandler.format(:pson) }
+
+  def headers
+    {
+      'accept' => 'application/json',
+      'content-type' => 'application/json'
+    }
+  end
+
+  def a_request(headers, body = "")
+    described_class.from_hash(
+      :method => "PUT",
+      :path   => "/path/to/endpoint",
+      :body   => body,
+      :headers => headers
+    )
+  end
+
+  context "when resolving the formatter for the request body" do
+    it "returns the formatter for that Content-Type" do
+      request = a_request(headers.merge("content-type" => "application/json"))
+      expect(request.formatter).to eq(json_formatter)
+    end
+
+    it "raises HTTP 400 if Content-Type is missing" do
+      request = a_request({})
+      expect {
+        request.formatter
+      }.to raise_error(bad_request_error, /No Content-Type header was received, it isn't possible to unserialize the request/)
+    end
+
+    it "raises HTTP 415 if Content-Type is unsupported" do
+      request = a_request(headers.merge('content-type' => 'application/ogg'))
+      expect {
+        request.formatter
+      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(application\/ogg\) that doesn't correspond to a format we support/)
+    end
+
+    it "raises HTTP 415 if Content-Type is unsafe yaml" do
+      request = a_request(headers.merge('content-type' => 'yaml'))
+      expect {
+        request.formatter
+      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(yaml\) that doesn't correspond to a format we support/)
+    end
+
+    it "raises HTTP 415 if Content-Type is unsafe b64_zlib_yaml" do
+      request = a_request(headers.merge('content-type' => 'b64_zlib_yaml'))
+      expect {
+        request.formatter
+      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(b64_zlib_yaml\) that doesn't correspond to a format we support/)
+    end
+  end
+
+  context "when resolving the formatter for the response body" do
+    context "when the client doesn't specify an Accept header" do
+      it "raises HTTP 400 if the server doesn't specify a default" do
+        request = a_request({})
+        expect {
+          request.response_formatters_for([:json])
+        }.to raise_error(bad_request_error, /Missing required Accept header/)
+      end
+
+      it "uses the server default" do
+        request = a_request({})
+        expect(request.response_formatters_for([:json], 'application/json')).to eq([json_formatter])
+      end
+    end
+
+    it "returns accepted and supported formats, in the accepted order" do
+      request = a_request(headers.merge('accept' => 'application/json, application/x-msgpack, text/pson'))
+      expect(request.response_formatters_for([:pson, :json])).to eq([json_formatter, pson_formatter])
+    end
+
+    it "selects the second format if the first one isn't supported by the server" do
+      request = a_request(headers.merge('accept' => 'application/json, text/pson'))
+      expect(request.response_formatters_for([:pson])).to eq([pson_formatter])
+    end
+
+    it "raises HTTP 406 if Accept doesn't include any server-supported formats" do
+      request = a_request(headers.merge('accept' => 'application/ogg'))
+      expect {
+        request.response_formatters_for([:json])
+      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: application\/ogg\)/)
+    end
+
+    it "raises HTTP 406 if Accept resolves to unsafe yaml" do
+      request = a_request(headers.merge('accept' => 'yaml'))
+      expect {
+        request.response_formatters_for([:json])
+      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: yaml\)/)
+    end
+
+    it "raises HTTP 406 if Accept resolves to unsafe b64_zlib_yaml" do
+      request = a_request(headers.merge('accept' => 'b64_zlib_yaml'))
+      expect {
+        request.response_formatters_for([:json])
+      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: b64_zlib_yaml\)/)
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/handler'
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Response do
+  include PuppetSpec::Files
+
+  let(:handler) { PuppetSpec::Handler.new }
+  let(:response) { {} }
+  let(:subject) { described_class.new(handler, response) }
+  let(:body_utf8) { JSON.dump({ "foo" => "bar"}).encode('UTF-8') }
+  let(:body_shift_jis) { [130, 174].pack('C*').force_encoding(Encoding::Shift_JIS) }
+  let(:invalid_shift_jis) { "\xC0\xFF".force_encoding(Encoding::Shift_JIS) }
+
+  context "when passed a response body" do
+    it "passes the status code and body to the handler" do
+      handler.expects(:set_response).with(response, body_utf8, 200)
+
+      subject.respond_with(200, 'application/json', body_utf8)
+    end
+
+    it "accepts a File body" do
+      file = tmpfile('response_spec')
+      handler.expects(:set_response).with(response, file, 200)
+
+      subject.respond_with(200, 'application/octet-stream', file)
+    end
+  end
+
+  context "when passed a content type" do
+    it "accepts a mime string" do
+      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+
+      subject.respond_with(200, 'application/json', body_utf8)
+    end
+
+    it "accepts a format object" do
+      formatter = Puppet::Network::FormatHandler.format(:json)
+      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+
+      subject.respond_with(200, formatter, body_utf8)
+    end
+  end
+
+  context "when resolving charset" do
+    context "with binary content" do
+      it "omits the charset" do
+        body_binary = [0xDEADCAFE].pack('L')
+
+        formatter = Puppet::Network::FormatHandler.format(:binary)
+        handler.expects(:set_content_type).with(response, 'application/octet-stream')
+
+        subject.respond_with(200, formatter, body_binary)
+      end
+    end
+
+    context "with text/plain content" do
+      let(:formatter) { Puppet::Network::FormatHandler.format(:s) }
+
+      it "sets the charset to UTF-8 for content already in that format" do
+        body_pem = "BEGIN CERTIFICATE".encode('UTF-8')
+
+        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+
+        subject.respond_with(200, formatter, body_pem)
+      end
+
+      it "encodes the content to UTF-8 for content not already in UTF-8" do
+        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+
+        subject.respond_with(200, formatter, body_shift_jis)
+      end
+
+      it "raises an exception if transcoding fails" do
+        expect {
+          subject.respond_with(200, formatter, invalid_shift_jis)
+        }.to raise_error(EncodingError, /"\\xFF" on Shift_JIS/)
+      end
+    end
+
+    context "with application/json content" do
+      let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+
+      it "sets the charset to UTF-8 for content already in that format" do
+        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+
+        subject.respond_with(200, formatter, body_utf8)
+      end
+
+      it "encodes the content to UTF-8 for content not already in UTF-8" do
+        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+
+        subject.respond_with(200, formatter, body_shift_jis)
+      end
+
+      it "raises an exception if transcoding fails" do
+        expect {
+          subject.respond_with(200, formatter, invalid_shift_jis)
+        }.to raise_error(EncodingError, /"\\xFF" on Shift_JIS/)
+      end
+    end
+  end
+end

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

@@ -14,37 +14,31 @@ describe Puppet::Network::HTTP::WEBrick do
 
   let(:address) { '127.0.0.1' }
   let(:port) { 31337 }
-  let(:server) { Puppet::Network::HTTP::WEBrick.new }
-  let(:localcacert) { make_absolute("/ca/crt") }
-  let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
-  let(:key) { stub 'key', :content => "mykey" }
-  let(:cert) { stub 'cert', :content => "mycert" }
-  let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
+
+  let(:server) do
+    s = Puppet::Network::HTTP::WEBrick.new
+    s.stubs(:setup_logger).returns(Hash.new)
+    s.stubs(:setup_ssl).returns(Hash.new)
+    s
+  end
 
   let(:mock_ssl_context) do
     stub('ssl_context', :ciphers= => nil)
   end
 
-  let(:socket) { mock('socket') }
   let(:mock_webrick) do
-    server = stub('webrick',
-                  :[] => {},
-                  :listeners => [],
-                  :status => :Running,
-                  :mount => nil,
-                  :shutdown => nil,
-                  :ssl_context => mock_ssl_context)
-    server.stubs(:start).yields(socket)
-    IO.stubs(:select).with([socket], nil, nil, anything).returns(true)
-    socket.stubs(:accept)
-    server.stubs(:run).with(socket)
-    server
+    stub('webrick',
+         :[] => {},
+         :listeners => [],
+         :status => :Running,
+         :mount => nil,
+         :start => nil,
+         :shutdown => nil,
+         :ssl_context => mock_ssl_context)
   end
 
   before :each do
     WEBrick::HTTPServer.stubs(:new).returns(mock_webrick)
-    Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
-    Puppet::SSL::Host.stubs(:localhost).returns host
   end
 
   describe "when turning on listening" do
@@ -94,13 +88,6 @@ describe Puppet::Network::HTTP::WEBrick do
       expect(server).to be_listening
     end
 
-    it "is passed a yet to be accepted socket" do
-      socket.expects(:accept)
-
-      server.listen(address, port)
-      server.unlisten
-    end
-
     describe "when the REST protocol is requested" do
       it "should register the REST handler at /" do
         # We don't care about the options here.
@@ -205,6 +192,18 @@ describe Puppet::Network::HTTP::WEBrick do
   end
 
   describe "when configuring ssl" do
+    let(:server) { Puppet::Network::HTTP::WEBrick.new }
+    let(:localcacert) { make_absolute("/ca/crt") }
+    let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
+    let(:key) { stub 'key', :content => "mykey" }
+    let(:cert) { stub 'cert', :content => "mycert" }
+    let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
+
+    before :each do
+      Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
+      Puppet::SSL::Host.stubs(:localhost).returns host
+    end
+
     it "should use the key from the localhost SSL::Host instance" do
       Puppet::SSL::Host.expects(:localhost).returns host
       host.expects(:key).returns key
@@ -237,8 +236,8 @@ describe Puppet::Network::HTTP::WEBrick do
       expect(server.setup_ssl[:SSLCACertificateFile]).to eq(ssl_server_ca_auth)
     end
 
-    it "should not start ssl immediately" do
-      expect(server.setup_ssl[:SSLStartImmediately]).to eq(false)
+    it "should start ssl immediately" do
+      expect(server.setup_ssl[:SSLStartImmediately]).to be_truthy
     end
 
     it "should enable ssl" do