puppet 4.1.0 → 4.10.0

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

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 require 'puppet/network/http'
+require 'puppet_spec/network'
 
 describe Puppet::Network::HTTP::API::Master::V3 do
+  include PuppetSpec::Network
+
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
   let(:master_url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3" }
   let(:master_routes) {
@@ -19,6 +22,21 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     expect(response.code).to eq(200)
   end
 
+  it "mounts the environment endpoint" do
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/environment/production")
+    master_routes.process(request, response)
+
+    expect(response.code).to eq(200)
+  end
+
+  it "matches only complete routes" do
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/foo/environments")
+    expect { master_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/foo/environment/production")
+    expect { master_routes.process(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+  end
+
   it "mounts indirected routes" do
     request = Puppet::Network::HTTP::Request.
         from_hash(:path => "#{master_url_prefix}/node/foo",
@@ -29,11 +47,11 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     expect(response.code).to eq(200)
   end
 
-  it "responds to unknown paths with a 404" do
+  it "responds to unknown paths by raising not_found_error" 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'")
+    expect {
+      master_routes.process(request, response)
+    }.to raise_error(not_found_error)
   end
 end

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

@@ -86,17 +86,48 @@ describe "http compression" do
         expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
 
-      it "should use a GzipReader with 'gzip' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('gzip')
+      context "with 'gzip' content-encoding" do
+        it "should use a GzipReader" do
+          @response.stubs(:[]).with('content-encoding').returns('gzip')
 
-        io = stub 'io'
-        StringIO.expects(:new).with("mydata").returns io
+          io = stub 'io'
+          StringIO.expects(:new).with("mydata").returns io
 
-        reader = stub 'gzip reader'
-        Zlib::GzipReader.expects(:new).with(io).returns(reader)
-        reader.expects(:read).returns "uncompresseddata"
+          reader = stub 'gzip reader'
+          Zlib::GzipReader.expects(:new).with(io, :encoding => Encoding::BINARY).returns(reader)
+          reader.expects(:read).returns "uncompresseddata"
 
-        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+          expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+        end
+
+        it "should correctly decompress PSON containing UTF-8 in Binary Encoding" do
+          # Simulate a compressed response body containing PSON containing UTF-8
+          # using different UTF-8 widths:
+
+          # \u06ff - ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+          # \u16A0 - ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+          # \u{2070E} - 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+
+          pson = "foo\u06ff\u16A0\u{2070E}".to_pson # unicode expression eqivalent of "foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\" per above
+          writer = Zlib::GzipWriter.new(StringIO.new)
+          writer.write(pson)
+          compressed_body = writer.close.string
+
+          begin
+            default_external = Encoding.default_external
+            Encoding.default_external = Encoding::ISO_8859_1
+
+            @response.stubs(:[]).with('content-encoding').returns('gzip')
+            @response.stubs(:body).returns(compressed_body)
+
+            uncompressed = @uncompressor.uncompress_body(@response)
+            # By default Zlib::GzipReader decompresses into Encoding.default_external, and we want to ensure our result is BINARY too
+            expect(uncompressed.encoding).to eq(Encoding::BINARY)
+            expect(uncompressed).to eq("\"foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\"".force_encoding(Encoding::BINARY))
+          ensure
+            Encoding.default_external = default_external
+          end
+        end
       end
     end
 
@@ -173,7 +204,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)
-        expect { @adapter.uncompress("chunk") }.to raise_error
+        expect { @adapter.uncompress("chunk") }.to raise_error(Zlib::DataError, /not a zlib stream/)
       end
 
       it "should finish the stream on close" do

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

@@ -42,31 +42,18 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when methods that accept a block are called with a block" do
-    let (:host) { "my_server" }
+  context "when handling requests", :vcr do
+    let (:host) { "my-server" }
     let (:port) { 8140 }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
 
-    before :each do
-      httpok.stubs(:body).returns ""
-
-      # This stubbing relies a bit more on knowledge of the internals of Net::HTTP
-      # than I would prefer, but it works on ruby 1.8.7 and 1.9.3, and it seems
-      # valuable enough to have tests for blocks that this is probably warranted.
-      socket = stub_everything("socket")
-      TCPSocket.stubs(:open).returns(socket)
-
-      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Head.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
-      Net::HTTPResponse.stubs(:read_new).returns(httpok)
-    end
-
-    [:request_get, :request_head, :request_post].each do |method|
+    { :request_get  => {},
+      :request_head => {},
+      :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
           block_executed = false
-          subject.send(method, "/foo", {}) do |response|
+          subject.send(method, "/foo", body) do |response|
             block_executed = true
           end
           expect(block_executed).to eq(true)
@@ -118,6 +105,14 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
 
+    before :all do
+      WebMock.disable!
+    end
+
+    after :all do
+      WebMock.enable!
+    end
+
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,
@@ -168,6 +163,7 @@ describe Puppet::Network::HTTP::Connection do
 
       Net::HTTP.any_instance.stubs(:start)
       Net::HTTP.any_instance.stubs(:request).returns(httpok)
+      Puppet::Network::HTTP::Pool.any_instance.stubs(:setsockopts)
 
       connection.get('request')
     end
@@ -300,4 +296,14 @@ describe Puppet::Network::HTTP::Connection do
       expect(request['authorization']).to match(/^Basic/)
     end.returns(httpok)
   end
+
+  it "sets HTTP User-Agent header" do
+    puppet_ua = "Puppet/#{Puppet.version} Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+
+    Net::HTTP.any_instance.expects(:request).with do |request|
+      expect(request['User-Agent']).to eq(puppet_ua)
+    end.returns(httpok)
+
+    subject.get('/path')
+  end
 end

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 the optional stacktrace property" do
+    it "should serialize to JSON that matches the error schema and has a deprecated stacktrace property" do
       begin
         raise Exception, "a wild Exception appeared!"
       rescue Exception => e
@@ -24,6 +24,7 @@ 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

@@ -1,8 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
+require 'puppet/util/http_proxy'
 
 describe Puppet::Network::HTTP::Factory do
+  before(:all) do
+    ENV['http_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+  end
   before :each do
     Puppet::SSL::Key.indirection.terminus_class = :memory
     Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
@@ -41,13 +46,25 @@ describe Puppet::Network::HTTP::Factory do
 
     it "should not set a proxy if the value is 'none'" do
       Puppet[:http_proxy_host] = 'none'
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
+      conn = create_connection(site)
+
+      expect(conn.proxy_address).to be_nil
+    end
+
+    it 'should not set a proxy if a no_proxy env var matches the destination' do
+      Puppet[:http_proxy_host] = proxy_host
+      Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
+      expect(conn.proxy_port).to be_nil
     end
 
     it 'sets proxy_address' do
       Puppet[:http_proxy_host] = proxy_host
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_address).to eq(proxy_host)
@@ -56,6 +73,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'sets proxy address and port' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_port).to eq(proxy_port)

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

@@ -74,9 +74,16 @@ describe Puppet::Network::HTTP::Handler do
       expect(res[:status]).to eq(404)
     end
 
-    it "returns a structured error response with a stacktrace when the server encounters an internal error" do
+    it "returns a structured error response when the server encounters an internal error" do
+      error = StandardError.new("the sky is falling!")
+      original_stacktrace = ['a.rb', 'b.rb']
+      error.set_backtrace(original_stacktrace)
+
       handler = PuppetSpec::Handler.new(
-        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise StandardError.new("the sky is falling!")}))
+        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise error}))
+
+      # Stacktraces should be included in logs
+      Puppet.expects(:err).with("Server Error: the sky is falling!\na.rb\nb.rb")
 
       req = a_request("GET", "/vtest/foo")
       res = {}
@@ -89,7 +96,8 @@ describe Puppet::Network::HTTP::Handler do
       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("spec/unit/network/http/handler_spec.rb")
+      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
 
@@ -131,11 +139,6 @@ describe Puppet::Network::HTTP::Handler do
       handler.process(request, response)
     end
 
-    it "should raise an error if the request is formatted in an unknown format" do
-      handler.stubs(:content_type_header).returns "unknown format"
-      expect { handler.request_format(request) }.to raise_error
-    end
-
     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)

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

@@ -109,6 +109,31 @@ describe Puppet::Network::HTTP::Pool do
       end rescue nil
     end
 
+    it 'sets keepalive bit on network socket' do
+      pool = create_pool
+      s = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM)
+      pool.setsockopts(Net::BufferedIO.new(s))
+
+      # On windows, Socket.getsockopt() doesn't return exactly the same data
+      # as an equivalent Socket::Option.new() statement, so we strip off the
+      # unrelevant bits only on this platform.
+      #
+      # To make sure we're not voiding the test case by doing this, we check
+      # both with and without the keepalive bit set.
+      #
+      # This workaround can be removed once all the ruby versions we care about
+      # have the patch from https://bugs.ruby-lang.org/issues/11958 applied.
+      #
+      if Puppet::Util::Platform.windows?
+        keepalive   = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, true).data[0]
+        nokeepalive = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, false).data[0]
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to eq(keepalive)
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to_not eq(nokeepalive)
+      else
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).bool).to eq(true)
+      end
+    end
+
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
@@ -150,6 +175,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -169,6 +195,7 @@ describe Puppet::Network::HTTP::Pool do
 
       conn = create_connection(site)
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -179,6 +206,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -205,6 +233,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end
@@ -217,6 +246,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end

data/spec/unit/network/http/rack/rest_spec.rb

@@ -65,6 +65,13 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         expect(@handler.path(req)).to eq("/foo/bar")
       end
 
+      it "should return the unescaped path for an escaped request path" do
+        unescaped_path = '/foo/bar baz'
+        escaped_path = URI.escape(unescaped_path)
+        req = mk_req(escaped_path)
+        expect(@handler.path(req)).to eq(unescaped_path)
+      end
+
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
         expect(@handler.body(req)).to eq("mybody")

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

@@ -136,7 +136,7 @@ describe Puppet::Network::HTTP::WEBrick do
       log = make_absolute("/master/log")
       Puppet[:masterhttplog] = log
 
-      File.expects(:open).with(log, "a+").returns @filehandle
+      File.expects(:open).with(log, "a+:UTF-8").returns @filehandle
 
       server.setup_logger
     end

data/spec/unit/network/rights_spec.rb

@@ -24,12 +24,12 @@ describe Puppet::Network::Rights do
       rights = Puppet::Network::Rights.new
       why_forbidden = rights.is_request_forbidden_and_why?(:head, "/indirection_name/key", {})
       expect(why_forbidden).to be_instance_of(Puppet::Network::AuthorizationError)
-      expect(why_forbidden.to_s).to eq("Forbidden request:  access to /indirection_name/key [find]")
+      expect(why_forbidden.to_s).to eq("Forbidden request: /indirection_name/key [find]")
     end
   end
 
   it "should throw an error if type can't be determined" do
-    expect { @right.newright("name") }.to raise_error
+    expect { @right.newright("name") }.to raise_error(ArgumentError, /Unknown right type/)
   end
 
   describe "when creating new path ACLs" do
@@ -40,7 +40,7 @@ describe Puppet::Network::Rights do
     end
 
     it "should throw an error if the acl uri path is not absolute" do
-      expect { @right.newright("name")}.to raise_error
+      expect { @right.newright("name")}.to raise_error(ArgumentError, /Unknown right type/)
     end
 
     it "should create a new ACL with the correct path" do
@@ -351,7 +351,7 @@ describe Puppet::Network::Rights do
     it "should raise an error if the method is already filtered" do
       @acl.restrict_method(:save)
 
-      expect { @acl.restrict_method(:save) }.to raise_error
+      expect { @acl.restrict_method(:save) }.to raise_error(ArgumentError, /'save' is already in the '\/path'/)
     end
 
     it "should allow setting an environment filters" do

data/spec/unit/node/environment_spec.rb

@@ -428,6 +428,16 @@ describe Puppet::Node::Environment do
     end
 
     describe "when performing initial import" do
+      let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+      around :each do |example|
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          example.run
+          Puppet::Pops::Loaders.clear
+        end
+      end
+
       it "loads from Puppet[:code]" do
         Puppet[:code] = "define foo {}"
         krt = env.known_resource_types

data/spec/unit/node_spec.rb

@@ -86,6 +86,41 @@ describe Puppet::Node do
                              )
       expect(node.to_pson).to validate_against('api/schemas/node.json')
     end
+
+    it "should allow its environment parameter to be set by attribute after initialization" do
+      node = Puppet::Node.new("foo", { :parameters => { 'environment' => :foo } })
+      node.environment_name = :foo
+      node.environment = :bar
+      expect(node.environment_name).to eq(:bar)
+      expect(node.parameters['environment']).to eq('bar')
+    end
+  end
+
+  describe "when serializing using yaml" do
+    before do
+      @node = Puppet::Node.new("mynode")
+    end
+
+    it "a node can roundtrip" do
+      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+    end
+
+    it "limits the serialization of environment to be just the name" do
+      # it is something like 138 when serializing everything in a default environment
+      expect(@node.to_yaml.size).to be < 70
+    end
+  end
+
+  describe "when serializing using yaml and values classes and parameters are missing in deserialized hash" do
+    it "a node can roundtrip" do
+      @node = Puppet::Node.from_data_hash({'name' => "mynode"})
+      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+    end
+
+    it "errors if name is nil" do
+      expect { Puppet::Node.from_data_hash({ })}.to raise_error(ArgumentError, /No name provided in serialized data/)
+    end
+
   end
 
   describe "when converting to json" do

data/spec/unit/parameter_spec.rb

@@ -190,4 +190,15 @@ describe Puppet::Parameter do
       )).to eq("{'1' => 'foo', 'bar' => ['2', '3', '4'], 'baz' => {'quux' => 'two', 'qux' => '1'}}")
     end
   end
+
+  describe 'formatting messages' do
+    it "formats messages as-is when the parameter is not sensitive" do
+      expect(@parameter.format("hello %s", "world")).to eq("hello world")
+    end
+
+    it "formats messages with redacted values when the parameter is not sensitive" do
+      @parameter.sensitive = true
+      expect(@parameter.format("hello %s", "world")).to eq("hello [redacted]")
+    end
+  end
 end

data/spec/unit/parser/ast/leaf_spec.rb

@@ -93,7 +93,7 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should raise an error if hostname is not valid" do
-    expect { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.to raise_error
+    expect { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.to raise_error(Puppet::DevError, /'not a hostname!' is not a valid hostname/)
   end
 
   it "should not raise an error if hostname is a regex" do