puppet 3.8.7 → 4.0.0.rc1

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

@@ -18,7 +18,7 @@ describe Puppet::Network::HTTP::Factory do
   it 'creates a connection for the site' do
     conn = create_connection(site)
 
-    expect(conn.use_ssl?).to be_true
+    expect(conn.use_ssl?).to be_truthy
     expect(conn.address).to eq(site.host)
     expect(conn.port).to eq(site.port)
   end
@@ -32,7 +32,7 @@ describe Puppet::Network::HTTP::Factory do
   it 'creates a connection supporting at least HTTP 1.1' do
     conn = create_connection(site)
 
-    expect(any_of(conn.class.version_1_1?, conn.class.version_1_1?)).to be_true
+    expect(any_of(conn.class.version_1_1?, conn.class.version_1_1?)).to be_truthy
   end
 
   context "proxy settings" do
@@ -62,20 +62,18 @@ describe Puppet::Network::HTTP::Factory do
     end
 
     context 'socket timeouts' do
-      let(:timeout) { 5 }
-
       it 'sets open timeout' do
-        Puppet[:configtimeout] = timeout
+        Puppet[:http_connect_timeout] = "10s"
         conn = create_connection(site)
 
-        expect(conn.open_timeout).to eq(timeout)
+        expect(conn.open_timeout).to eq(10)
       end
 
       it 'sets read timeout' do
-        Puppet[:configtimeout] = timeout
+        Puppet[:http_read_timeout] = "2m"
         conn = create_connection(site)
 
-        expect(conn.read_timeout).to eq(timeout)
+        expect(conn.read_timeout).to eq(120)
       end
     end
   end

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

@@ -1,9 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+
+require 'puppet_spec/handler'
+
 require 'puppet/indirector_testing'
 
 require 'puppet/network/authorization'
-require 'puppet/network/authentication'
 
 require 'puppet/network/http'
 
@@ -17,8 +19,8 @@ describe Puppet::Network::HTTP::Handler do
   def a_request(method = "HEAD", path = "/production/#{indirection.name}/unknown")
     {
       :accept_header => "pson",
-      :content_type_header => "text/yaml",
-      :http_method => method,
+      :content_type_header => "text/pson",
+      :method => method,
       :path => path,
       :params => {},
       :client_cert => nil,
@@ -27,7 +29,7 @@ describe Puppet::Network::HTTP::Handler do
     }
   end
 
-  let(:handler) { TestingHandler.new() }
+  let(:handler) { PuppetSpec::Handler.new() }
 
   describe "the HTTP Handler" do
     def respond(text)
@@ -35,7 +37,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "hands the request to the first route that matches the request path" do
-      handler = TestingHandler.new(
+      handler = PuppetSpec::Handler.new(
         Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("skipped")),
         Puppet::Network::HTTP::Route.path(%r{^/vtest}).get(respond("used")),
         Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(respond("ignored")))
@@ -50,14 +52,14 @@ describe Puppet::Network::HTTP::Handler do
 
     it "raises an error if multiple routes with the same path regex are registered" do
       expect do
-        handler = TestingHandler.new(
+        handler = PuppetSpec::Handler.new(
           Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("ignored")),
           Puppet::Network::HTTP::Route.path(%r{^/foo}).post(respond("also ignored")))
       end.to raise_error(ArgumentError)
     end
 
     it "raises an HTTP not found error if no routes match" do
-      handler = TestingHandler.new
+      handler = PuppetSpec::Handler.new
 
       req = a_request("GET", "/vtest/foo")
       res = {}
@@ -73,8 +75,8 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "returns a structured error response with a stacktrace when the server encounters an internal error" do
-      handler = TestingHandler.new(
-        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise Exception.new("the sky is falling!")}))
+      handler = PuppetSpec::Handler.new(
+        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise StandardError.new("the sky is falling!")}))
 
       req = a_request("GET", "/vtest/foo")
       res = {}
@@ -86,7 +88,7 @@ describe Puppet::Network::HTTP::Handler do
       expect(res[:content_type_header]).to eq("application/json")
       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_true
+      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[:status]).to eq(500)
     end
@@ -107,7 +109,7 @@ describe Puppet::Network::HTTP::Handler do
       request = a_request
       request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"
 
-      p = HandlerTestProfiler.new
+      p = PuppetSpec::HandlerProfiler.new
 
       Puppet::Util::Profiler.expects(:add_profiler).with { |profiler|
         profiler.is_a? Puppet::Util::Profiler::WallClock
@@ -131,30 +133,27 @@ describe Puppet::Network::HTTP::Handler do
 
     it "should raise an error if the request is formatted in an unknown format" do
       handler.stubs(:content_type_header).returns "unknown format"
-      lambda { handler.request_format(request) }.should raise_error
+      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)
-      request.format.should == "s"
-    end
-
-    it "should deserialize YAML parameters" do
-      params = {'my_param' => [1,2,3].to_yaml}
-
-      decoded_params = handler.send(:decode_params, params)
-
-      decoded_params.should == {:my_param => [1,2,3]}
-    end
-
-    it "should ignore tags on YAML parameters" do
-      params = {'my_param' => "--- !ruby/object:Array {}"}
-
-      decoded_params = handler.send(:decode_params, params)
-
-      decoded_params[:my_param].should be_a(Hash)
-    end
+      expect(request.format).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
+    # 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}
+#
+#      decoded_params = handler.send(:decode_params, params)
+#
+#      decoded_params.should == {:my_param => [1,2,3]}
+#    end
   end
 
 
@@ -168,65 +167,13 @@ describe Puppet::Network::HTTP::Handler do
     it "should return the look-up result" do
       Resolv.stubs(:getname).with("1.2.3.4").returns("host.domain.com")
 
-      handler.resolve_node(:ip => "1.2.3.4").should == "host.domain.com"
+      expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("host.domain.com")
     end
 
     it "should return the ip address if resolving fails" do
       Resolv.stubs(:getname).with("1.2.3.4").raises(RuntimeError, "no such host")
 
-      handler.resolve_node(:ip => "1.2.3.4").should == "1.2.3.4"
-    end
-  end
-
-  class TestingHandler
-    include Puppet::Network::HTTP::Handler
-
-    def initialize(* routes)
-      register(routes)
-    end
-
-    def set_content_type(response, format)
-     response[:content_type_header] = format
-    end
-
-    def set_response(response, body, status = 200)
-      response[:body] = body
-      response[:status] = status
-    end
-
-    def http_method(request)
-      request[:http_method]
-    end
-
-    def path(request)
-      request[:path]
-    end
-
-    def params(request)
-      request[:params]
-    end
-
-    def client_cert(request)
-      request[:client_cert]
-    end
-
-    def body(request)
-      request[:body]
-    end
-
-    def headers(request)
-      request[:headers] || {}
-    end
-  end
-
-  class HandlerTestProfiler
-    def start(metric, description)
-    end
-
-    def finish(context, metric, description)
-    end
-
-    def shutdown()
+      expect(handler.resolve_node(:ip => "1.2.3.4")).to eq("1.2.3.4")
     end
   end
 end

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

@@ -5,7 +5,7 @@ require 'puppet/network/http/rack/rest'
 
 describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
   it "should include the Puppet::Network::HTTP::Handler module" do
-    Puppet::Network::HTTP::RackREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
+    expect(Puppet::Network::HTTP::RackREST.ancestors).to be_include(Puppet::Network::HTTP::Handler)
   end
 
   describe "when serving a request" do
@@ -43,31 +43,31 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         req = mk_req('/', {'HTTP_Accept' => 'myaccept',
                            'HTTP_X_Custom_Header' => 'mycustom',
                            'NOT_HTTP_foo' => 'not an http header'})
-        @handler.headers(req).should == {"accept" => 'myaccept',
+        expect(@handler.headers(req)).to eq({"accept" => 'myaccept',
                                          "x-custom-header" => 'mycustom',
-                                         "content-type" => nil }
+                                         "content-type" => nil })
       end
     end
 
     describe "and using the HTTP Handler interface" do
       it "should return the CONTENT_TYPE parameter as the content type header" do
         req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
-        @handler.headers(req)['content-type'].should == "mycontent"
+        expect(@handler.headers(req)['content-type']).to eq("mycontent")
       end
 
       it "should use the REQUEST_METHOD as the http method" do
         req = mk_req('/', :method => 'MYMETHOD')
-        @handler.http_method(req).should == "MYMETHOD"
+        expect(@handler.http_method(req)).to eq("MYMETHOD")
       end
 
       it "should return the request path as the path" do
         req = mk_req('/foo/bar')
-        @handler.path(req).should == "/foo/bar"
+        expect(@handler.path(req)).to eq("/foo/bar")
       end
 
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
-        @handler.body(req).should == "mybody"
+        expect(@handler.body(req)).to eq("mybody")
       end
 
       it "should return the an Puppet::SSL::Certificate instance as the client_cert" do
@@ -78,7 +78,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       it "returns nil when SSL_CLIENT_CERT is empty" do
         req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => '')
 
-        @handler.client_cert(req).should be_nil
+        expect(@handler.client_cert(req)).to be_nil
       end
 
       it "should set the response's content-type header when setting the content type" do
@@ -129,7 +129,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         req = mk_req('/production/report/foo')
         req.body.expects(:read).with(1)
 
-        @handler.stubs(:headers).raises(Exception)
+        @handler.stubs(:headers).raises(StandardError)
 
         @handler.process(req, @response)
       end
@@ -139,85 +139,84 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       it "should include the HTTP request parameters, with the keys as symbols" do
         req = mk_req('/?foo=baz&bar=xyzzy')
         result = @handler.params(req)
-        result[:foo].should == "baz"
-        result[:bar].should == "xyzzy"
+        expect(result[:foo]).to eq("baz")
+        expect(result[:bar]).to eq("xyzzy")
       end
 
       it "should return multi-values params as an array of the values" do
         req = mk_req('/?foo=baz&foo=xyzzy')
         result = @handler.params(req)
-        result[:foo].should == ["baz", "xyzzy"]
+        expect(result[:foo]).to eq(["baz", "xyzzy"])
       end
 
       it "should return parameters from the POST body" do
         req = mk_req("/", :method => 'POST', :input => 'foo=baz&bar=xyzzy')
         result = @handler.params(req)
-        result[:foo].should == "baz"
-        result[:bar].should == "xyzzy"
+        expect(result[:foo]).to eq("baz")
+        expect(result[:bar]).to eq("xyzzy")
       end
 
       it "should not return multi-valued params in a POST body as an array of values" do
         req = mk_req("/", :method => 'POST', :input => 'foo=baz&foo=xyzzy')
         result = @handler.params(req)
-        result[:foo].should be_one_of("baz", "xyzzy")
+        expect(result[:foo]).to be_one_of("baz", "xyzzy")
       end
 
       it "should CGI-decode the HTTP parameters" do
         encoding = CGI.escape("foo bar")
         req = mk_req("/?foo=#{encoding}")
         result = @handler.params(req)
-        result[:foo].should == "foo bar"
+        expect(result[:foo]).to eq("foo bar")
       end
 
       it "should convert the string 'true' to the boolean" do
         req = mk_req("/?foo=true")
         result = @handler.params(req)
-        result[:foo].should be_true
+        expect(result[:foo]).to be_truthy
       end
 
       it "should convert the string 'false' to the boolean" do
         req = mk_req("/?foo=false")
         result = @handler.params(req)
-        result[:foo].should be_false
+        expect(result[:foo]).to be_falsey
       end
 
       it "should convert integer arguments to Integers" do
         req = mk_req("/?foo=15")
         result = @handler.params(req)
-        result[:foo].should == 15
+        expect(result[:foo]).to eq(15)
       end
 
       it "should convert floating point arguments to Floats" do
         req = mk_req("/?foo=1.5")
         result = @handler.params(req)
-        result[:foo].should == 1.5
+        expect(result[:foo]).to eq(1.5)
       end
 
-      it "should YAML-load and CGI-decode values that are YAML-encoded" do
+      it "should treat YAML encoded parameters like it was any string" do
         escaping = CGI.escape(YAML.dump(%w{one two}))
         req = mk_req("/?foo=#{escaping}")
-        result = @handler.params(req)
-        result[:foo].should == %w{one two}
+        expect(@handler.params(req)[:foo]).to eq("---\n- one\n- two\n")
       end
 
       it "should not allow the client to set the node via the query string" do
         req = mk_req("/?node=foo")
-        @handler.params(req)[:node].should be_nil
+        expect(@handler.params(req)[:node]).to be_nil
       end
 
       it "should not allow the client to set the IP address via the query string" do
         req = mk_req("/?ip=foo")
-        @handler.params(req)[:ip].should be_nil
+        expect(@handler.params(req)[:ip]).to be_nil
       end
 
       it "should pass the client's ip address to model find" do
         req = mk_req("/", 'REMOTE_ADDR' => 'ipaddress')
-        @handler.params(req)[:ip].should == "ipaddress"
+        expect(@handler.params(req)[:ip]).to eq("ipaddress")
       end
 
       it "should set 'authenticated' to false if no certificate is present" do
         req = mk_req('/')
-        @handler.params(req)[:authenticated].should be_false
+        expect(@handler.params(req)[:authenticated]).to be_falsey
       end
     end
 
@@ -225,54 +224,54 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       it "should retrieve the hostname by finding the CN given in :ssl_client_header, in the format returned by Apache (RFC2253)" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "O=Foo\\, Inc,CN=host.domain.com")
-        @handler.params(req)[:node].should == "host.domain.com"
+        expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
       it "should retrieve the hostname by finding the CN given in :ssl_client_header, in the format returned by nginx" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "/CN=host.domain.com")
-        @handler.params(req)[:node].should == "host.domain.com"
+        expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
       it "should retrieve the hostname by finding the CN given in :ssl_client_header, ignoring other fields" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => 'ST=Denial,CN=host.domain.com,O=Domain\\, Inc.')
-        @handler.params(req)[:node].should == "host.domain.com"
+        expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet[:ssl_client_header] = "certheader"
         Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "CN=host.domain.com")
-        @handler.params(req)[:authenticated].should be_true
+        expect(@handler.params(req)[:authenticated]).to be_truthy
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet[:ssl_client_header] = "certheader"
         Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => "whatever", "certheader" => "CN=host.domain.com")
-        @handler.params(req)[:authenticated].should be_false
+        expect(@handler.params(req)[:authenticated]).to be_falsey
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet[:ssl_client_header] = "certheader"
         Puppet[:ssl_client_verify_header] = "myheader"
         req = mk_req('/', "myheader" => nil, "certheader" => "CN=host.domain.com")
-        @handler.params(req)[:authenticated].should be_false
+        expect(@handler.params(req)[:authenticated]).to be_falsey
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => nil)
         @handler.expects(:resolve_node).returns("host.domain.com")
-        @handler.params(req)[:node].should == "host.domain.com"
+        expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
       it "should resolve the node name with an ip address look-up if a certificate without a CN is present" do
         Puppet[:ssl_client_header] = "myheader"
         req = mk_req('/', "myheader" => "O=no CN")
         @handler.expects(:resolve_node).returns("host.domain.com")
-        @handler.params(req)[:node].should == "host.domain.com"
+        expect(@handler.params(req)[:node]).to eq("host.domain.com")
       end
 
       it "should not allow authentication via the verify header if there is no CN available" do
@@ -282,7 +281,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
 
         @handler.expects(:resolve_node).returns("host.domain.com")
 
-        @handler.params(req)[:authenticated].should be_false
+        expect(@handler.params(req)[:authenticated]).to be_falsey
       end
     end
   end
@@ -296,20 +295,20 @@ describe Puppet::Network::HTTP::RackREST::RackFile do
   end
 
   it "should have an each method" do
-    @rackfile.should be_respond_to(:each)
+    expect(@rackfile).to be_respond_to(:each)
   end
 
   it "should yield file chunks by chunks" do
     @file.expects(:read).times(3).with(8192).returns("1", "2", nil)
     i = 1
     @rackfile.each do |chunk|
-      chunk.to_i.should == i
+      expect(chunk.to_i).to eq(i)
       i += 1
     end
   end
 
   it "should have a close method" do
-    @rackfile.should be_respond_to(:close)
+    expect(@rackfile).to be_respond_to(:close)
   end
 
   it "should delegate close to File close" do