puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -32,7 +32,7 @@ describe "Puppet::Network::HTTP::Rack", :if => Puppet.features.rack? do
 
     it "should catch unhandled exceptions from RackREST" do
       Puppet::Network::HTTP::RackREST.any_instance.expects(:process).raises(ArgumentError, 'test error')
-      Proc.new { @linted.call(@env) }.should_not raise_error
+      expect { @linted.call(@env) }.not_to raise_error
     end
 
     it "should finish() the Response" do

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

@@ -22,7 +22,7 @@ describe Puppet::Network::HTTP::Route do
   describe "an HTTP Route" do
     it "can match a request" do
       route = Puppet::Network::HTTP::Route.path(%r{^/vtest})
-      expect(route.matches?(req)).to be_true
+      expect(route.matches?(req)).to be_truthy
     end
 
     it "will raise a Method Not Allowed error when no handler for the request's method is given" do
@@ -34,7 +34,7 @@ describe Puppet::Network::HTTP::Route do
 
     it "can match any HTTP method" do
       route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).any(respond("used"))
-      expect(route.matches?(req)).to be_true
+      expect(route.matches?(req)).to be_truthy
 
       route.process(req, res)
 
@@ -75,7 +75,7 @@ describe Puppet::Network::HTTP::Route do
       expect do
         route.process(req, res)
       end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAuthorizedError)
-      expect(ignored_called).to be_false
+      expect(ignored_called).to be_falsey
     end
 
     it "chains to other routes after calling its handlers" do

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

@@ -15,7 +15,7 @@ describe Puppet::Network::HTTP::Session do
   it 'provides access to its connection' do
     session = create_session(connection)
 
-    session.connection.should == connection
+    expect(session.connection).to eq(connection)
   end
 
   it 'expires a connection whose expiration time is in the past' do
@@ -23,14 +23,14 @@ describe Puppet::Network::HTTP::Session do
     past = now - 1
 
     session = create_session(connection, past)
-    session.expired?(now).should be_true
+    expect(session.expired?(now)).to be_truthy
   end
 
   it 'expires a connection whose expiration time is now' do
     now = Time.now
 
     session = create_session(connection, now)
-    session.expired?(now).should be_true
+    expect(session.expired?(now)).to be_truthy
   end
 
   it 'does not expire a connection whose expiration time is in the future' do
@@ -38,6 +38,6 @@ describe Puppet::Network::HTTP::Session do
     future = now + 1
 
     session = create_session(connection, future)
-    session.expired?(now).should be_false
+    expect(session.expired?(now)).to be_falsey
   end
 end

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

@@ -55,7 +55,7 @@ describe Puppet::Network::HTTP::Site do
 
     another_site = create_site(scheme, host, port)
 
-    expect(sites.include?(another_site)).to be_true
+    expect(sites.include?(another_site)).to be_truthy
   end
 
   it 'computes the same hash code for equivalent objects' do

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

@@ -6,12 +6,16 @@ require 'puppet/network/http/webrick/rest'
 
 describe Puppet::Network::HTTP::WEBrickREST do
   it "should include the Puppet::Network::HTTP::Handler module" do
-    Puppet::Network::HTTP::WEBrickREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
+    expect(Puppet::Network::HTTP::WEBrickREST.ancestors).to be_include(Puppet::Network::HTTP::Handler)
   end
 
   describe "when receiving a request" do
     before do
-      @request     = stub('webrick http request', :query => {}, :peeraddr => %w{eh boo host ip}, :client_cert => nil)
+      @request     = stub('webrick http request', :query => {},
+                          :query_string => 'environment=production',
+                          :peeraddr => %w{eh boo host ip},
+                          :request_method => 'GET',
+                          :client_cert => nil)
       @response    = mock('webrick http response')
       @model_class = stub('indirected model class')
       @webrick     = stub('webrick http server', :mount => true, :[] => {})
@@ -21,7 +25,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
     it "should delegate its :service method to its :process method" do
       @handler.expects(:process).with(@request, @response).returns "stuff"
-      @handler.service(@request, @response).should == "stuff"
+      expect(@handler.service(@request, @response)).to eq("stuff")
     end
 
     describe "#headers" do
@@ -34,24 +38,25 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
       it "should return a hash with downcased header names" do
         result = @handler.headers(fake_request)
-        result.should == fake_request.inject({}) { |m,(k,v)| m[k.downcase] = v; m }
+        expect(result).to eq(fake_request.inject({}) { |m,(k,v)| m[k.downcase] = v; m })
       end
     end
 
     describe "when using the Handler interface" do
       it "should use the request method as the http method" do
         @request.expects(:request_method).returns "FOO"
-        @handler.http_method(@request).should == "FOO"
+        expect(@handler.http_method(@request)).to eq("FOO")
       end
 
       it "should return the request path as the path" do
         @request.expects(:path).returns "/foo/bar"
-        @handler.path(@request).should == "/foo/bar"
+        expect(@handler.path(@request)).to eq("/foo/bar")
       end
 
       it "should return the request body as the body" do
+        @request.stubs(:request_method).returns "POST"
         @request.expects(:body).returns "my body"
-        @handler.body(@request).should == "my body"
+        expect(@handler.body(@request)).to eq("my body")
       end
 
       it "should set the response's 'content-type' header when setting the content type" do
@@ -62,7 +67,6 @@ describe Puppet::Network::HTTP::WEBrickREST do
       it "should set the status and body on the response when setting the response for a successful query" do
         @response.expects(:status=).with 200
         @response.expects(:body=).with "mybody"
-        @response.expects(:[]=).with('connection', 'close') if RUBY_VERSION[0,3] == '1.8'
 
         @handler.set_response(@response, "mybody", 200)
       end
@@ -75,7 +79,6 @@ describe Puppet::Network::HTTP::WEBrickREST do
         @response.expects(:[]=).with('content-length', 100)
         @response.expects(:status=).with 200
         @response.expects(:body=).with @file
-        @response.expects(:[]=).with('connection', 'close') if RUBY_VERSION[0,3] == '1.8'
 
         @handler.set_response(@response, @file, 200)
       end
@@ -83,26 +86,9 @@ describe Puppet::Network::HTTP::WEBrickREST do
       it "should set the status and message on the response when setting the response for a failed query" do
         @response.expects(:status=).with 400
         @response.expects(:body=).with "mybody"
-        @response.expects(:[]=).with('connection', 'close') if RUBY_VERSION[0,3] == '1.8'
 
         @handler.set_response(@response, "mybody", 400)
       end
-
-      it "omits the 'Connection: close' header on ruby 1.9 and up", :if => RUBY_VERSION[0,3] != '1.8' do
-        @response.expects(:status=).with 200
-        @response.expects(:body=).with "mybody"
-        @response.expects(:[]=).with('connection', 'close').never
-
-        @handler.set_response(@response, "mybody", 200)
-      end
-
-      it "closes the connection on ruby 1.8", :if => RUBY_VERSION[0,3] == '1.8' do
-        @response.expects(:status=).with 200
-        @response.expects(:body=).with "mybody"
-        @response.expects(:[]=).with('connection', 'close')
-
-        @handler.set_response(@response, "mybody", 200)
-      end
     end
 
     describe "and determining the request parameters" do
@@ -128,15 +114,21 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         result = @handler.params(@request)
 
-        result.keys.sort.should == only_server_side_information
+        expect(result.keys.sort).to eq(only_server_side_information)
+      end
+
+      it "should prefer duplicate params from the body over the query string" do
+        @request.stubs(:request_method).returns "PUT"
+        @request.stubs(:query).returns(WEBrick::HTTPUtils.parse_query("foo=bar&environment=posted_env"))
+        expect(@handler.params(@request)[:environment]).to eq("posted_env")
       end
 
       it "should include the HTTP request parameters, with the keys as symbols" do
         request = a_request_querying("foo" => "baz", "bar" => "xyzzy")
         result = @handler.params(request)
 
-        result[:foo].should == "baz"
-        result[:bar].should == "xyzzy"
+        expect(result[:foo]).to eq("baz")
+        expect(result[:bar]).to eq("xyzzy")
       end
 
       it "should handle parameters with no value" do
@@ -144,7 +136,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         result = @handler.params(request)
 
-        result[:foo].should == ""
+        expect(result[:foo]).to eq("")
       end
 
       it "should convert the string 'true' to the boolean" do
@@ -152,7 +144,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         result = @handler.params(request)
 
-        result[:foo].should == true
+        expect(result[:foo]).to eq(true)
       end
 
       it "should convert the string 'false' to the boolean" do
@@ -160,7 +152,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         result = @handler.params(request)
 
-        result[:foo].should == false
+        expect(result[:foo]).to eq(false)
       end
 
       it "should reconstruct arrays" do
@@ -168,7 +160,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         result = @handler.params(request)
 
-        result[:foo].should == ["a", "b", "c"]
+        expect(result[:foo]).to eq(["a", "b", "c"])
       end
 
       it "should convert values inside arrays into primitive types" do
@@ -176,58 +168,47 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         result = @handler.params(request)
 
-        result[:foo].should == [true, false, 1, 1.2]
+        expect(result[:foo]).to eq([true, false, 1, 1.2])
       end
 
-      it "should YAML-load values that are YAML-encoded" do
+      it "should treat YAML-load values that are YAML-encoded as any other String" do
         request = a_request_querying('foo' => YAML.dump(%w{one two}))
-
-        result = @handler.params(request)
-
-        result[:foo].should == %w{one two}
-      end
-
-      it "should YAML-load that are YAML-encoded" do
-        request = a_request_querying('foo' => YAML.dump(%w{one two}))
-
-        result = @handler.params(request)
-
-        result[:foo].should == %w{one two}
+        expect(@handler.params(request)[:foo]).to eq("---\n- one\n- two\n")
       end
 
       it "should not allow clients to set the node via the request parameters" do
         request = a_request_querying("node" => "foo")
         @handler.stubs(:resolve_node)
 
-        @handler.params(request)[:node].should be_nil
+        expect(@handler.params(request)[:node]).to be_nil
       end
 
       it "should not allow clients to set the IP via the request parameters" do
         request = a_request_querying("ip" => "foo")
 
-        @handler.params(request)[:ip].should_not == "foo"
+        expect(@handler.params(request)[:ip]).not_to eq("foo")
       end
 
       it "should pass the client's ip address to model find" do
         @request.stubs(:peeraddr).returns(%w{noidea dunno hostname ipaddress})
-        @handler.params(@request)[:ip].should == "ipaddress"
+        expect(@handler.params(@request)[:ip]).to eq("ipaddress")
       end
 
       it "should set 'authenticated' to true if a certificate is present" do
         cert = stub 'cert', :subject => [%w{CN host.domain.com}]
         @request.stubs(:client_cert).returns cert
-        @handler.params(@request)[:authenticated].should be_true
+        expect(@handler.params(@request)[:authenticated]).to be_truthy
       end
 
       it "should set 'authenticated' to false if no certificate is present" do
         @request.stubs(:client_cert).returns nil
-        @handler.params(@request)[:authenticated].should be_false
+        expect(@handler.params(@request)[:authenticated]).to be_falsey
       end
 
       it "should pass the client's certificate name to model method if a certificate is present" do
         @request.stubs(:client_cert).returns(certificate_with_subject("/CN=host.domain.com"))
 
-        @handler.params(@request)[:node].should == "host.domain.com"
+        expect(@handler.params(@request)[:node]).to eq("host.domain.com")
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
@@ -235,7 +216,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         @handler.expects(:resolve_node).returns(:resolved_node)
 
-        @handler.params(@request)[:node].should == :resolved_node
+        expect(@handler.params(@request)[:node]).to eq(:resolved_node)
       end
 
       it "should resolve the node name with an ip address look-up if CN parsing fails" do
@@ -243,7 +224,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
 
         @handler.expects(:resolve_node).returns(:resolved_node)
 
-        @handler.params(@request)[:node].should == :resolved_node
+        expect(@handler.params(@request)[:node]).to eq(:resolved_node)
       end
     end
   end

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

@@ -5,7 +5,7 @@ require 'puppet/network/http/webrick'
 
 describe Puppet::Network::HTTP::WEBrick, "after initializing" do
   it "should not be listening" do
-    Puppet::Network::HTTP::WEBrick.new.should_not be_listening
+    expect(Puppet::Network::HTTP::WEBrick.new).not_to be_listening
   end
 end
 
@@ -85,7 +85,7 @@ describe Puppet::Network::HTTP::WEBrick do
 
     it "should be listening" do
       server.listen(address, port)
-      server.should be_listening
+      expect(server).to be_listening
     end
 
     describe "when the REST protocol is requested" do
@@ -112,7 +112,7 @@ describe Puppet::Network::HTTP::WEBrick do
     it "should no longer be listening" do
       server.listen(address, port)
       server.unlisten
-      server.should_not be_listening
+      expect(server).not_to be_listening
     end
   end
 
@@ -132,8 +132,7 @@ describe Puppet::Network::HTTP::WEBrick do
       server.setup_logger
     end
 
-    it "should use the masterhttplog if the run_mode is master" do
-      Puppet.run_mode.stubs(:master?).returns(true)
+    it "should use the masterhttplog" do
       log = make_absolute("/master/log")
       Puppet[:masterhttplog] = log
 
@@ -142,16 +141,6 @@ describe Puppet::Network::HTTP::WEBrick do
       server.setup_logger
     end
 
-    it "should use the httplog if the run_mode is not master" do
-      Puppet.run_mode.stubs(:master?).returns(false)
-      log = make_absolute("/other/log")
-      Puppet[:httplog] = log
-
-      File.expects(:open).with(log, "a+").returns @filehandle
-
-      server.setup_logger
-    end
-
     describe "and creating the logging filehandle" do
       it "should set the close-on-exec flag if supported" do
         if defined? Fcntl::FD_CLOEXEC
@@ -188,17 +177,17 @@ describe Puppet::Network::HTTP::WEBrick do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
-      server.setup_logger[:Logger].should == logger
+      expect(server.setup_logger[:Logger]).to eq(logger)
     end
 
     it "should return the logger as the access log using both the Common and Referer log format" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
-      server.setup_logger[:AccessLog].should == [
+      expect(server.setup_logger[:AccessLog]).to eq([
         [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT],
         [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT]
-      ]
+      ])
     end
   end
 
@@ -219,11 +208,11 @@ describe Puppet::Network::HTTP::WEBrick do
       Puppet::SSL::Host.expects(:localhost).returns host
       host.expects(:key).returns key
 
-      server.setup_ssl[:SSLPrivateKey].should == "mykey"
+      expect(server.setup_ssl[:SSLPrivateKey]).to eq("mykey")
     end
 
     it "should configure the certificate" do
-      server.setup_ssl[:SSLCertificate].should == "mycert"
+      expect(server.setup_ssl[:SSLCertificate]).to eq("mycert")
     end
 
     it "should fail if no CA certificate can be found" do
@@ -236,7 +225,7 @@ describe Puppet::Network::HTTP::WEBrick do
       Puppet.settings[:hostcrl] = 'false'
       Puppet.settings[:localcacert] = localcacert
 
-      server.setup_ssl[:SSLCACertificateFile].should == localcacert
+      expect(server.setup_ssl[:SSLCACertificateFile]).to eq(localcacert)
     end
 
     it "should specify the path to the CA certificate" do
@@ -244,15 +233,15 @@ describe Puppet::Network::HTTP::WEBrick do
       Puppet.settings[:localcacert] = localcacert
       Puppet.settings[:ssl_server_ca_auth] = ssl_server_ca_auth
 
-      server.setup_ssl[:SSLCACertificateFile].should == ssl_server_ca_auth
+      expect(server.setup_ssl[:SSLCACertificateFile]).to eq(ssl_server_ca_auth)
     end
 
     it "should start ssl immediately" do
-      server.setup_ssl[:SSLStartImmediately].should be_true
+      expect(server.setup_ssl[:SSLStartImmediately]).to be_truthy
     end
 
     it "should enable ssl" do
-      server.setup_ssl[:SSLEnable].should be_true
+      expect(server.setup_ssl[:SSLEnable]).to be_truthy
     end
 
     it "should reject SSLv2" do
@@ -268,17 +257,17 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "should configure the verification method as 'OpenSSL::SSL::VERIFY_PEER'" do
-      server.setup_ssl[:SSLVerifyClient].should == OpenSSL::SSL::VERIFY_PEER
+      expect(server.setup_ssl[:SSLVerifyClient]).to eq(OpenSSL::SSL::VERIFY_PEER)
     end
 
     it "should add an x509 store" do
       host.expects(:ssl_store).returns "mystore"
 
-      server.setup_ssl[:SSLCertificateStore].should == "mystore"
+      expect(server.setup_ssl[:SSLCertificateStore]).to eq("mystore")
     end
 
     it "should set the certificate name to 'nil'" do
-      server.setup_ssl[:SSLCertName].should be_nil
+      expect(server.setup_ssl[:SSLCertName]).to be_nil
     end
 
     it "specifies the allowable ciphers" do