puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

data/spec/unit/indirector/report/rest_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/report/rest'
@@ -32,10 +33,10 @@ describe Puppet::Transaction::Report::Rest do
   end
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http 200 ok', :code => code.to_s, :body => body)
-    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
-    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
-    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
+    obj = stub('http 200 ok', :code => code.to_s, :body => body)
+    obj.stubs(:[]).with('content-type').returns(content_type)
+    obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 
@@ -45,18 +46,18 @@ describe Puppet::Transaction::Report::Rest do
 
   describe "#save" do
     let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
     let(:body) { ["store", "http"].to_pson }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it "deserializes the response as an array of report processor names" do
       response = mock_response('200', body, 'text/pson')
-      expect(connection).to receive(:put).and_return(response)
+      connection.expects(:put).returns response
 
       expect(terminus.save(request)).to eq(["store", "http"])
     end
@@ -67,8 +68,8 @@ describe Puppet::Transaction::Report::Rest do
           Puppet[:preferred_serialization_format] = "json"
 
           response = mock_response('500', '{}', 'text/pson')
-          allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
-          expect(connection).to receive(:put).and_return(response)
+          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+          connection.expects(:put).returns response
 
           expect {
             terminus.save(request)
@@ -79,8 +80,8 @@ describe Puppet::Transaction::Report::Rest do
           Puppet[:preferred_serialization_format] = "pson"
 
           response = mock_response('500', '{}', 'text/pson')
-          allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
-          expect(connection).to receive(:put).and_return(response)
+          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+          connection.expects(:put).returns response
 
           expect {
             terminus.save(request)

data/spec/unit/indirector/report/yaml_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/transaction/report'

data/spec/unit/indirector/request_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
@@ -19,7 +20,7 @@ describe Puppet::Indirector::Request do
     end
 
     it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
-      instance = double('instance', :name => "mykey")
+      instance = mock 'instance', :name => "mykey"
       request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
       expect(request.key).to eq("mykey")
       expect(request.instance).to equal(instance)
@@ -194,25 +195,25 @@ describe Puppet::Indirector::Request do
   end
 
   it "should look use the Indirection class to return the appropriate indirection" do
-    ind = double('indirection')
-    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(ind)
+    ind = mock 'indirection'
+    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     expect(request.indirection).to equal(ind)
   end
 
   it "should use its indirection to look up the appropriate model" do
-    ind = double('indirection')
-    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(ind)
+    ind = mock 'indirection'
+    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
-    expect(ind).to receive(:model).and_return("mymodel")
+    ind.expects(:model).returns "mymodel"
 
     expect(request.model).to eq("mymodel")
   end
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
-    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(nil)
+    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     expect { request.model }.to raise_error(ArgumentError)
@@ -441,8 +442,8 @@ describe Puppet::Indirector::Request do
 
       context "when SRV returns servers" do
         before :each do
-          @dns_mock = double('dns')
-          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
+          @dns_mock = mock('dns')
+          Resolv::DNS.expects(:new).returns(@dns_mock)
 
           @port = 7205
           @target = 'example.com'
@@ -450,9 +451,9 @@ describe Puppet::Indirector::Request do
           record.instance_variable_set(:@ttl, 10)
           @srv_records = [record]
 
-          expect(@dns_mock).to receive(:getresources).
+          @dns_mock.expects(:getresources).
             with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
-            and_return(@srv_records)
+            returns(@srv_records)
         end
 
         it "yields a request using the server and port from the SRV record" do

data/spec/unit/indirector/resource/ral_spec.rb

@@ -1,40 +1,43 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/type/user'
 require 'puppet/indirector/resource/ral'
 
 describe "Puppet::Resource::Ral" do
+
   it "disallows remote requests" do
     expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(false)
   end
 
   describe "find" do
     before do
-      @request = double('request', :key => "user/root")
+      @request = stub 'request', :key => "user/root"
     end
 
     it "should find an existing instance" do
-      my_resource    = double("my user resource")
+      my_resource    = stub "my user resource"
 
-      wrong_instance = double("wrong user", :name => "bob")
-      my_instance    = double("my user",    :name => "root", :to_resource => my_resource)
+      wrong_instance = stub "wrong user", :name => "bob"
+      my_instance    = stub "my user",    :name => "root", :to_resource => my_resource
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
+      require 'puppet/type/user'
+      Puppet::Type::User.expects(:instances).returns([ wrong_instance, my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.find(@request)).to eq(my_resource)
     end
 
     it "should produce Puppet::Error instead of ArgumentError" do
-      @bad_request = double('thiswillcauseanerror', :key => "thiswill/causeanerror")
+      @bad_request = stub 'thiswillcauseanerror', :key => "thiswill/causeanerror"
       expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
     end
 
     it "if there is no instance, it should create one" do
-      wrong_instance = double("wrong user", :name => "bob")
-      root = double("Root User")
-      root_resource = double("Root Resource")
+      wrong_instance = stub "wrong user", :name => "bob"
+      root = mock "Root User"
+      root_resource = mock "Root Resource"
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
-      expect(Puppet::Type::User).to receive(:new).with(hash_including(name: "root")).and_return(root)
-      expect(root).to receive(:to_resource).and_return(root_resource)
+      require 'puppet/type/user'
+      Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
+      Puppet::Type::User.expects(:new).with(has_entry(:name => "root")).returns(root)
+      root.expects(:to_resource).returns(root_resource)
 
       result = Puppet::Resource::Ral.new.find(@request)
 
@@ -44,68 +47,72 @@ describe "Puppet::Resource::Ral" do
 
   describe "search" do
     before do
-      @request = double('request', :key => "user/", :options => {})
+      @request = stub 'request', :key => "user/", :options => {}
     end
 
     it "should convert ral resources into regular resources" do
-      my_resource = double("my user resource")
-      my_instance = double("my user", :name => "root", :to_resource => my_resource)
+      my_resource = stub "my user resource"
+      my_instance = stub "my user", :name => "root", :to_resource => my_resource
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance ])
+      require 'puppet/type/user'
+      Puppet::Type::User.expects(:instances).returns([ my_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource = double("my user resource")
-      allow(my_resource).to receive(:to_resource).and_return(my_resource)
-      allow(my_resource).to receive(:[]).with(:name).and_return("root")
+      my_resource    = stub "my user resource"
+      my_resource.stubs(:to_resource).returns(my_resource)
+      my_resource.stubs(:[]).with(:name).returns("root")
 
-      wrong_resource = double("wrong resource")
-      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
-      allow(wrong_resource).to receive(:[]).with(:name).and_return("bad")
+      wrong_resource = stub "wrong resource"
+      wrong_resource.stubs(:to_resource).returns(wrong_resource)
+      wrong_resource.stubs(:[]).with(:name).returns("bad")
 
-      my_instance    = double("my user",    :to_resource => my_resource)
-      wrong_instance = double("wrong user", :to_resource => wrong_resource)
+      my_instance    = stub "my user",    :to_resource => my_resource
+      wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
-      @request = double('request', :key => "user/root", :options => {})
+      @request = stub 'request', :key => "user/root", :options => {}
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      require 'puppet/type/user'
+      Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = double("my user resource")
-      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
-      allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
+      wrong_resource = stub "my user resource"
+      wrong_resource.stubs(:to_resource).returns(wrong_resource)
+      wrong_resource.stubs(:[]).with(:name).returns("root")
 
-      my_resource = double("wrong resource")
-      allow(my_resource).to receive(:to_resource).and_return(my_resource)
-      allow(my_resource).to receive(:[]).with(:name).and_return("bob")
+      my_resource = stub "wrong resource"
+      my_resource.stubs(:to_resource).returns(my_resource)
+      my_resource.stubs(:[]).with(:name).returns("bob")
 
-      my_instance    = double("my user",    :to_resource => my_resource)
-      wrong_instance = double("wrong user", :to_resource => wrong_resource)
+      my_instance    = stub "my user",    :to_resource => my_resource
+      wrong_instance = stub "wrong user", :to_resource => wrong_resource
 
-      @request = double('request', :key => "user/", :options => {:name => "bob"})
+      @request = stub 'request', :key => "user/", :options => {:name => "bob"}
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance, wrong_instance ])
+      require 'puppet/type/user'
+      Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should return sorted results" do
-      a_resource = double("alice resource")
-      allow(a_resource).to receive(:to_resource).and_return(a_resource)
-      allow(a_resource).to receive(:title).and_return("alice")
+      a_resource = stub "alice resource"
+      a_resource.stubs(:to_resource).returns(a_resource)
+      a_resource.stubs(:title).returns("alice")
 
-      b_resource = double("bob resource")
-      allow(b_resource).to receive(:to_resource).and_return(b_resource)
-      allow(b_resource).to receive(:title).and_return("bob")
+      b_resource = stub "bob resource"
+      b_resource.stubs(:to_resource).returns(b_resource)
+      b_resource.stubs(:title).returns("bob")
 
-      a_instance = double("alice user", :to_resource => a_resource)
-      b_instance = double("bob user",   :to_resource => b_resource)
+      a_instance = stub "alice user", :to_resource => a_resource
+      b_instance = stub "bob user",   :to_resource => b_resource
 
-      @request = double('request', :key => "user/", :options => {})
+      @request = stub 'request', :key => "user/", :options => {}
 
-      expect(Puppet::Type::User).to receive(:instances).and_return([ b_instance, a_instance ])
+      require 'puppet/type/user'
+      Puppet::Type::User.expects(:instances).returns([ b_instance, a_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([a_resource, b_resource])
     end
   end

data/spec/unit/indirector/resource/store_configs_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource'
 require 'puppet/indirector/memory'

data/spec/unit/indirector/rest_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/json'
 require 'puppet/indirector'
@@ -16,14 +17,14 @@ shared_examples_for "a REST terminus method" do |terminus_method|
     end
 
     it "falls back to pson for future requests" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
       terminus.send(terminus_method, request)
 
       expect(Puppet[:preferred_serialization_format]).to eq("pson")
     end
 
     it "doesn't change the serialization format if the X-Puppet-Version header is missing" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(nil)
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(nil)
 
       terminus.send(terminus_method, request)
 
@@ -31,7 +32,7 @@ shared_examples_for "a REST terminus method" do |terminus_method|
     end
 
     it "doesn't change the serialization format if the server major version is 5" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("5.0.3")
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("5.0.3")
 
       terminus.send(terminus_method, request)
 
@@ -39,7 +40,7 @@ shared_examples_for "a REST terminus method" do |terminus_method|
     end
 
     it "doesn't change the serialization format if the current format is already pson" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
       Puppet[:preferred_serialization_format] = "pson"
       terminus.send(terminus_method, request)
 
@@ -76,7 +77,7 @@ shared_examples_for "a REST terminus method" do |terminus_method|
       end
 
       it "does not attempt to deserialize the response into a model" do
-        expect(model).not_to receive(:convert_from)
+        model.expects(:convert_from).never
 
         expect {
           terminus.send(terminus_method, request)
@@ -85,8 +86,8 @@ shared_examples_for "a REST terminus method" do |terminus_method|
 
       # I'm not sure what this means or if it's used
       it "if the body is empty raises an http error with the response header" do
-        allow(response).to receive(:body).and_return("")
-        allow(response).to receive(:message).and_return("fhqwhgads")
+        response.stubs(:body).returns ""
+        response.stubs(:message).returns "fhqwhgads"
 
         expect {
           terminus.send(terminus_method, request)
@@ -98,7 +99,7 @@ shared_examples_for "a REST terminus method" do |terminus_method|
           compressed_body = Zlib::Deflate.deflate(body)
 
           compressed_response = mock_response(code, compressed_body, 'application/json', 'deflate')
-          expect(connection).to receive(http_method).and_return(compressed_response)
+          connection.expects(http_method).returns(compressed_response)
 
           expect {
             terminus.send(terminus_method, request)
@@ -120,7 +121,7 @@ shared_examples_for "a deserializing terminus method" do |terminus_method|
   end
 
   it "doesn't catch errors in deserialization" do
-    expect(model).to receive(:convert_from).and_raise(Puppet::Error, "Whoa there")
+    model.expects(:convert_from).raises(Puppet::Error, "Whoa there")
 
     expect { terminus.send(terminus_method, request) }.to raise_error(Puppet::Error, "Whoa there")
   end
@@ -181,10 +182,10 @@ describe Puppet::Indirector::REST do
   end
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http 200 ok', :code => code.to_s, :body => body)
-    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
-    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
-    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
+    obj = stub('http 200 ok', :code => code.to_s, :body => body)
+    obj.stubs(:[]).with('content-type').returns(content_type)
+    obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 
@@ -213,13 +214,13 @@ describe Puppet::Indirector::REST do
   end
 
   it "should use any specified setting to pick the server" do
-    expect(terminus_class).to receive(:server_setting).and_return(:ca_server)
+    terminus_class.expects(:server_setting).returns :ca_server
     Puppet[:ca_server] = "myserver"
     expect(terminus_class.server).to eq("myserver")
   end
 
   it "should default to :server for the server setting" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
+    terminus_class.expects(:server_setting).returns nil
     Puppet[:server] = "myserver"
     expect(terminus_class.server).to eq("myserver")
   end
@@ -229,39 +230,39 @@ describe Puppet::Indirector::REST do
   end
 
   it "should use any specified setting to pick the port" do
-    expect(terminus_class).to receive(:port_setting).and_return(:ca_port)
+    terminus_class.expects(:port_setting).returns :ca_port
     Puppet[:ca_port] = "321"
     expect(terminus_class.port).to eq(321)
   end
 
   it "should default to :port for the port setting" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
+    terminus_class.expects(:port_setting).returns nil
     Puppet[:masterport] = "543"
     expect(terminus_class.port).to eq(543)
   end
 
   it "should use a failover-selected server if set" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
+    terminus_class.expects(:server_setting).returns nil
     Puppet.override(:server => "myserver") do
       expect(terminus_class.server).to eq("myserver")
     end
   end
 
   it "should use a failover-selected port if set" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
+    terminus_class.expects(:port_setting).returns nil
     Puppet.override(:serverport => 321) do
       expect(terminus_class.port).to eq(321)
     end
   end
 
   it "should use server_list for server when available" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
+    terminus_class.expects(:server_setting).returns nil
     Puppet[:server_list] = [["foo", "123"]]
     expect(terminus_class.server).to eq("foo")
   end
 
   it "should prefer failover-selected server from server list" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
+    terminus_class.expects(:server_setting).returns nil
     Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
     Puppet.override(:server => "bar") do
       expect(terminus_class.server).to eq("bar")
@@ -269,13 +270,13 @@ describe Puppet::Indirector::REST do
   end
 
   it "should use server_list for port when available" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
+    terminus_class.expects(:port_setting).returns nil
     Puppet[:server_list] = [["foo", "123"]]
     expect(terminus_class.port).to eq(123)
   end
 
   it "should prefer failover-selected port from server list" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
+    terminus_class.expects(:port_setting).returns nil
     Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
     Puppet.override(:serverport => "321") do
       expect(terminus_class.port).to eq(321)
@@ -283,7 +284,7 @@ describe Puppet::Indirector::REST do
   end
 
   it "should use an explicitly specified more-speciic server when failover is active" do
-    expect(terminus_class).to receive(:server_setting).and_return(:ca_server)
+    terminus_class.expects(:server_setting).returns :ca_server
     Puppet[:ca_server] = "myserver"
     Puppet.override(:server => "anotherserver") do
       expect(terminus_class.server).to eq("myserver")
@@ -291,7 +292,7 @@ describe Puppet::Indirector::REST do
   end
 
   it "should use an explicitly specified more-specific port when failover is active" do
-    expect(terminus_class).to receive(:port_setting).and_return(:ca_port)
+    terminus_class.expects(:port_setting).returns :ca_port
     Puppet[:ca_port] = 321
     Puppet.override(:serverport => 543) do
       expect(terminus_class.port).to eq(321)
@@ -299,8 +300,8 @@ describe Puppet::Indirector::REST do
   end
 
   it "should use a default port when a more-specific server is set" do
-    expect(terminus_class).to receive(:server_setting).and_return(:ca_server)
-    expect(terminus_class).to receive(:port_setting).and_return(:ca_port)
+    terminus_class.expects(:server_setting).returns :ca_server
+    terminus_class.expects(:port_setting).returns :ca_port
     Puppet[:ca_server] = "myserver"
     Puppet.override(:server => "anotherserver", :port => 666) do
       expect(terminus_class.port).to eq(8140)
@@ -312,43 +313,43 @@ describe Puppet::Indirector::REST do
   end
 
   it 'excludes yaml from the Accept header' do
-    expect(model).to receive(:supported_formats).and_return([:json, :pson, :yaml, :binary])
+    model.expects(:supported_formats).returns([:json, :pson, :yaml, :binary])
 
     expect(terminus.headers['Accept']).to eq('application/json, text/pson, application/octet-stream')
   end
 
   it 'excludes b64_zlib_yaml from the Accept header' do
-    expect(model).to receive(:supported_formats).and_return([:json, :pson, :b64_zlib_yaml])
+    model.expects(:supported_formats).returns([:json, :pson, :b64_zlib_yaml])
 
     expect(terminus.headers['Accept']).to eq('application/json, text/pson')
   end
 
   it 'excludes dot from the Accept header' do
-    expect(model).to receive(:supported_formats).and_return([:json, :dot])
+    model.expects(:supported_formats).returns([:json, :dot])
 
     expect(terminus.headers['Accept']).to eq('application/json')
   end
 
   describe "when creating an HTTP client" do
     it "should use the class's server and port if the indirection request provides neither" do
-      @request = double('request', :key => "foo", :server => nil, :port => nil)
-      expect(terminus.class).to receive(:port).and_return(321)
-      expect(terminus.class).to receive(:server).and_return("myserver")
-      expect(Puppet::Network::HttpPool).to receive(:http_instance).with("myserver", 321).and_return("myconn")
+      @request = stub 'request', :key => "foo", :server => nil, :port => nil
+      terminus.class.expects(:port).returns 321
+      terminus.class.expects(:server).returns "myserver"
+      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       expect(terminus.network(@request)).to eq("myconn")
     end
 
     it "should use the server from the indirection request if one is present" do
-      @request = double('request', :key => "foo", :server => "myserver", :port => nil)
-      allow(terminus.class).to receive(:port).and_return(321)
-      expect(Puppet::Network::HttpPool).to receive(:http_instance).with("myserver", 321).and_return("myconn")
+      @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
+      terminus.class.stubs(:port).returns 321
+      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       expect(terminus.network(@request)).to eq("myconn")
     end
 
     it "should use the port from the indirection request if one is present" do
-      @request = double('request', :key => "foo", :server => nil, :port => 321)
-      allow(terminus.class).to receive(:server).and_return("myserver")
-      expect(Puppet::Network::HttpPool).to receive(:http_instance).with("myserver", 321).and_return("myconn")
+      @request = stub 'request', :key => "foo", :server => nil, :port => 321
+      terminus.class.stubs(:server).returns "myserver"
+      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
       expect(terminus.network(@request)).to eq("myconn")
     end
   end
@@ -356,11 +357,11 @@ describe Puppet::Indirector::REST do
   describe "#find" do
     let(:http_method) { :get }
     let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :get => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :get => response, :verify_callback= => nil) }
     let(:request) { find_request('foo') }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :find
@@ -382,11 +383,9 @@ describe Puppet::Indirector::REST do
 
         request = find_request('whoa', params)
 
-        expect(connection).to receive(:post) do |_,req,_|
-          expect(req.split("&").flatten).to match_array(params.map {|key,value| "#{key}=#{value}"})
-
-          mock_response(200, 'body')
-        end
+        connection.expects(:post).with do |uri, body|
+            body.split("&").sort == params.map {|key,value| "#{key}=#{value}"}.sort
+        end.returns(mock_response(200, 'body'))
 
         terminus.find(request)
       end
@@ -396,7 +395,7 @@ describe Puppet::Indirector::REST do
       it "calls get on the connection" do
         request = find_request('foo bar')
 
-        expect(connection).to receive(:get).with("#{url_prefix}/test_model/foo%20bar?environment=production&", anything).and_return(mock_response('200', 'response body'))
+        connection.expects(:get).with("#{url_prefix}/test_model/foo%20bar?environment=production&", anything).returns(mock_response('200', 'response body'))
 
         expect(terminus.find(request)).to eq(model.new('foo bar', 'response body'))
       end
@@ -405,14 +404,14 @@ describe Puppet::Indirector::REST do
     it "returns nil on 404" do
       response = mock_response('404', nil)
 
-      expect(connection).to receive(:get).and_return(response)
+      connection.expects(:get).returns(response)
 
       expect(terminus.find(request)).to eq(nil)
     end
 
     it 'raises no warning for a 404 (when not asked to do so)' do
       response = mock_response('404', 'this is the notfound you are looking for')
-      expect(connection).to receive(:get).and_return(response)
+      connection.expects(:get).returns(response)
       expect{terminus.find(request)}.to_not raise_error()
     end
 
@@ -420,7 +419,7 @@ describe Puppet::Indirector::REST do
       it 'raises an error for a 404 when asked to do so' do
         request = find_request('foo', :fail_on_404 => true)
         response = mock_response('404', 'this is the notfound you are looking for')
-        expect(connection).to receive(:get).and_return(response)
+        connection.expects(:get).returns(response)
 
         expect do
           terminus.find(request)
@@ -432,7 +431,7 @@ describe Puppet::Indirector::REST do
       it 'truncates the URI when it is very long' do
         request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
         response = mock_response('404', 'this is the notfound you are looking for')
-        expect(connection).to receive(:get).and_return(response)
+        connection.expects(:get).returns(response)
 
         expect do
           terminus.find(request)
@@ -445,7 +444,7 @@ describe Puppet::Indirector::REST do
         Puppet.debug = true
         request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
         response = mock_response('404', 'this is the notfound you are looking for')
-        expect(connection).to receive(:get).and_return(response)
+        connection.expects(:get).returns(response)
 
         expect do
           terminus.find(request)
@@ -456,9 +455,9 @@ describe Puppet::Indirector::REST do
     end
 
     it "asks the model to deserialize the response body and sets the name on the resulting object to the find key" do
-      expect(connection).to receive(:get).and_return(response)
+      connection.expects(:get).returns response
 
-      expect(model).to receive(:convert_from).with(response['content-type'], response.body).and_return(
+      model.expects(:convert_from).with(response['content-type'], response.body).returns(
         model.new('overwritten', 'decoded body')
       )
 
@@ -466,44 +465,42 @@ describe Puppet::Indirector::REST do
     end
 
     it "doesn't require the model to support name=" do
-      class Puppet::TestModel2 < Puppet::TestModel
-        undef_method :name=
-      end
-
-      expect(connection).to receive(:get).and_return(response)
-      instance = Puppet::TestModel2.new('name', 'decoded body')
+      connection.expects(:get).returns response
+      instance = model.new('name', 'decoded body')
 
-      expect(model).to receive(:convert_from).with(response['content-type'], response.body).and_return(instance)
+      model.expects(:convert_from).with(response['content-type'], response.body).returns(instance)
+      instance.expects(:respond_to?).with(:name=).returns(false)
+      instance.expects(:name=).never
 
       expect(terminus.find(request)).to eq(model.new('name', 'decoded body'))
     end
 
     it "provides an Accept header containing the list of supported mime types joined with commas" do
-      expect(connection).to receive(:get).with(anything, hash_including("Accept" => "application/json, text/pson")).and_return(response)
+      connection.expects(:get).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      expect(terminus.model).to receive(:supported_formats).and_return([:json, :pson])
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.find(request)
     end
 
     it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:get).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
+      connection.expects(:get).with(anything, has_entry(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).returns(response)
 
       terminus.find(request)
     end
 
     it "adds an Accept-Encoding header" do
-      expect(terminus).to receive(:add_accept_encoding).and_return({"accept-encoding" => "gzip"})
+      terminus.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
 
-      expect(connection).to receive(:get).with(anything, hash_including("accept-encoding" => "gzip")).and_return(response)
+      connection.expects(:get).with(anything, has_entry("accept-encoding" => "gzip")).returns(response)
 
       terminus.find(request)
     end
 
     it "uses only the mime-type from the content-type header when asking the model to deserialize" do
       response = mock_response('200', 'mydata', "text/plain; charset=utf-8")
-      expect(connection).to receive(:get).and_return(response)
+      connection.expects(:get).returns(response)
 
-      expect(model).to receive(:convert_from).with("text/plain", "mydata").and_return("myobject")
+      model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
 
       expect(terminus.find(request)).to eq("myobject")
     end
@@ -513,9 +510,9 @@ describe Puppet::Indirector::REST do
       compressed_body = Zlib::Deflate.deflate(uncompressed_body)
 
       response = mock_response('200', compressed_body, 'text/plain', 'deflate')
-      expect(connection).to receive(:get).and_return(response)
+      connection.expects(:get).returns(response)
 
-      expect(model).to receive(:convert_from).with("text/plain", uncompressed_body).and_return("myobject")
+      model.expects(:convert_from).with("text/plain", uncompressed_body).returns "myobject"
 
       expect(terminus.find(request)).to eq("myobject")
     end
@@ -524,29 +521,29 @@ describe Puppet::Indirector::REST do
   describe "#head" do
     let(:http_method) { :head }
     let(:response) { mock_response(200, nil) }
-    let(:connection) { double('mock http connection', :head => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :head => response, :verify_callback= => nil) }
     let(:request) { head_request('foo') }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :head
 
     it "returns true if there was a successful http response" do
-      expect(connection).to receive(:head).and_return(mock_response('200', nil))
+      connection.expects(:head).returns mock_response('200', nil)
 
       expect(terminus.head(request)).to eq(true)
     end
 
     it "returns false on a 404 response" do
-      expect(connection).to receive(:head).and_return(mock_response('404', nil))
+      connection.expects(:head).returns mock_response('404', nil)
 
       expect(terminus.head(request)).to eq(false)
     end
 
     it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:head).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
+      connection.expects(:head).with(anything, has_entry(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).returns(response)
 
       terminus.head(request)
     end
@@ -555,18 +552,18 @@ describe Puppet::Indirector::REST do
   describe "#search" do
     let(:http_method) { :get }
     let(:response) { mock_response(200, 'data1,data2,data3') }
-    let(:connection) { double('mock http connection', :get => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :get => response, :verify_callback= => nil) }
     let(:request) { search_request('foo') }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :search
     it_behaves_like 'a deserializing terminus method', :search
 
     it "should call the GET http method on a network connection" do
-      expect(connection).to receive(:get).with("#{url_prefix}/test_models/foo?environment=production&", hash_including('Accept' => anything)).and_return(mock_response(200, 'data3, data4'))
+      connection.expects(:get).with("#{url_prefix}/test_models/foo?environment=production&", has_key('Accept')).returns mock_response(200, 'data3, data4')
 
       terminus.search(request)
     end
@@ -574,7 +571,7 @@ describe Puppet::Indirector::REST do
     it "returns an empty list on 404" do
       response = mock_response('404', nil)
 
-      expect(connection).to receive(:get).and_return(response)
+      connection.expects(:get).returns(response)
 
       expect(terminus.search(request)).to eq([])
     end
@@ -584,20 +581,20 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      expect(connection).to receive(:get).with(anything, hash_including("Accept" => "application/json, text/pson")).and_return(mock_response(200, ''))
+      connection.expects(:get).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(mock_response(200, ''))
 
-      expect(terminus.model).to receive(:supported_formats).and_return([:json, :pson])
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.search(request)
     end
 
     it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:get).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(mock_response(200, ''))
+      connection.expects(:get).with(anything, has_entry(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).returns(mock_response(200, ''))
 
       terminus.search(request)
     end
 
     it "should return an empty array if serialization returns nil" do
-      allow(model).to receive(:convert_from_multiple).and_return(nil)
+      model.stubs(:convert_from_multiple).returns nil
 
       expect(terminus.search(request)).to eq([])
     end
@@ -606,18 +603,18 @@ describe Puppet::Indirector::REST do
   describe "#destroy" do
     let(:http_method) { :delete }
     let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :delete => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :delete => response, :verify_callback= => nil) }
     let(:request) { delete_request('foo') }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :destroy
     it_behaves_like 'a deserializing terminus method', :destroy
 
     it "should call the DELETE http method on a network connection" do
-      expect(connection).to receive(:delete).with("#{url_prefix}/test_model/foo?environment=production&", hash_including('Accept' => anything)).and_return(response)
+      connection.expects(:delete).with("#{url_prefix}/test_model/foo?environment=production&", has_key('Accept')).returns(response)
 
       terminus.destroy(request)
     end
@@ -629,7 +626,7 @@ describe Puppet::Indirector::REST do
     end
 
     it "should deserialize and return the http response" do
-      expect(connection).to receive(:delete).and_return(response)
+      connection.expects(:delete).returns response
 
       expect(terminus.destroy(request)).to eq(model.new('', 'body'))
     end
@@ -637,20 +634,20 @@ describe Puppet::Indirector::REST do
     it "returns nil on 404" do
       response = mock_response('404', nil)
 
-      expect(connection).to receive(:delete).and_return(response)
+      connection.expects(:delete).returns(response)
 
       expect(terminus.destroy(request)).to eq(nil)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      expect(connection).to receive(:delete).with(anything, hash_including("Accept" => "application/json, text/pson")).and_return(response)
+      connection.expects(:delete).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      expect(terminus.model).to receive(:supported_formats).and_return([:json, :pson])
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.destroy(request)
     end
 
     it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:delete).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
+      connection.expects(:delete).with(anything, has_entry(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).returns(response)
 
       terminus.destroy(request)
     end
@@ -659,18 +656,18 @@ describe Puppet::Indirector::REST do
   describe "#save" do
     let(:http_method) { :put }
     let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it_behaves_like 'a REST terminus method', :save
 
     it "should call the PUT http method on a network connection" do
-      expect(connection).to receive(:put).with("#{url_prefix}/test_model/the%20thing?environment=production&", anything, hash_including("Content-Type")).and_return(response)
+      connection.expects(:put).with("#{url_prefix}/test_model/the%20thing?environment=production&", anything, has_key("Content-Type")).returns response
 
       terminus.save(request)
     end
@@ -682,8 +679,8 @@ describe Puppet::Indirector::REST do
     end
 
     it "should serialize the instance using the default format and pass the result as the body of the request" do
-      expect(instance).to receive(:render).and_return("serial_instance")
-      expect(connection).to receive(:put).with(anything, "serial_instance", anything).and_return(response)
+      instance.expects(:render).returns "serial_instance"
+      connection.expects(:put).with(anything, "serial_instance", anything).returns response
 
       terminus.save(request)
     end
@@ -691,36 +688,36 @@ describe Puppet::Indirector::REST do
     it "returns nil on 404" do
       response = mock_response('404', nil)
 
-      expect(connection).to receive(:put).and_return(response)
+      connection.expects(:put).returns(response)
 
       expect(terminus.save(request)).to eq(nil)
     end
 
     it "returns nil" do
-      expect(connection).to receive(:put).and_return(response)
+      connection.expects(:put).returns response
 
       expect(terminus.save(request)).to be_nil
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      expect(connection).to receive(:put).with(anything, anything, hash_including("Accept" => "application/json, text/pson")).and_return(response)
+      connection.expects(:put).with(anything, anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      expect(instance).to receive(:render).and_return('')
-      expect(model).to receive(:supported_formats).and_return([:json, :pson])
-      expect(instance).to receive(:mime).and_return("supported")
+      instance.expects(:render).returns('')
+      model.expects(:supported_formats).returns [:json, :pson]
+      instance.expects(:mime).returns "supported"
 
       terminus.save(request)
     end
 
     it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:put).with(anything, anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
+      connection.expects(:put).with(anything, anything, has_entry(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).returns(response)
 
       terminus.save(request)
     end
 
     it "should provide a Content-Type header containing the mime-type of the sent object" do
-      expect(instance).to receive(:mime).and_return("mime")
-      expect(connection).to receive(:put).with(anything, anything, hash_including('Content-Type' => "mime")).and_return(response)
+      instance.expects(:mime).returns "mime"
+      connection.expects(:put).with(anything, anything, has_entry('Content-Type' => "mime")).returns(response)
 
       terminus.save(request)
     end
@@ -729,31 +726,31 @@ describe Puppet::Indirector::REST do
   describe '#handle_response' do
     # There are multiple request types to choose from, this may not be the one I want for this situation
     let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
+    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
 
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      terminus.stubs(:network).returns(connection)
     end
 
     it 'adds server_agent_version to the context if not already set' do
-      expect(Puppet).to receive(:push_context).with(:server_agent_version => Puppet.version)
+      Puppet.expects(:push_context).with(:server_agent_version => Puppet.version)
       terminus.handle_response(request, response)
     end
 
     it 'does not add server_agent_version to the context if it is already set' do
       Puppet.override(:server_agent_version => "5.3.4") do
-        expect(Puppet).not_to receive(:push_context)
+        Puppet.expects(:push_context).never
         terminus.handle_response(request, response)
       end
     end
 
     it 'downgrades to pson and emits a warning' do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return('4.2.8')
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns('4.2.8')
       Puppet[:preferred_serialization_format] = 'other'
 
-      expect(Puppet).to receive(:warning).with('Downgrading to PSON for future requests')
+      Puppet.expects(:warning).with('Downgrading to PSON for future requests')
 
       terminus.handle_response(request, response)
 
@@ -781,7 +778,7 @@ describe Puppet::Indirector::REST do
         request = Puppet::Indirector::Request.new(:indirection, method, 'key', nil)
         stub_response = mock_response('200', 'body')
 
-        expect(request).to receive(:do_request).with(terminus.class.srv_service, terminus.class.server, terminus.class.port).and_return(stub_response)
+        request.expects(:do_request).with(terminus.class.srv_service, terminus.class.server, terminus.class.port).returns(stub_response)
 
         terminus.send(method, request)
       end