puppet 5.3.4 → 6.29.0

data/spec/unit/resource_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource'
 
@@ -8,8 +7,13 @@ describe Puppet::Resource do
   let(:basepath) { make_absolute("/somepath") }
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
-  def expect_lookup(key)
-    Puppet::Pops::Lookup::GlobalDataProvider.any_instance.expects(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_parameters)
+  def expect_lookup(key, options = {})
+    expectation = receive(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_args)
+    expectation = expectation.and_throw(options[:throws]) if options[:throws]
+    expectation = expectation.and_raise(*options[:raises]) if options[:raises]
+    expectation = expectation.and_return(options[:returns]) if options[:returns]
+
+    expect_any_instance_of(Puppet::Pops::Lookup::GlobalDataProvider).to expectation
   end
 
   [:catalog, :file, :line].each do |attr|
@@ -279,12 +283,12 @@ describe Puppet::Resource do
     let(:scope)    { Puppet::Parser::Scope.new(compiler) }
 
     def ast_leaf(value)
-      Puppet::Parser::AST::Leaf.new({:value => value})
+      Puppet::Parser::AST::Leaf.new(value: value)
     end
 
     it "should fail when asked to set default values and it is not a parser resource" do
       environment.known_resource_types.add(
-      Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_leaf("default")})
       )
       resource = Puppet::Resource.new("default_param", "name", :environment => environment)
       expect { resource.set_default_parameters(scope) }.to raise_error(Puppet::DevError)
@@ -317,7 +321,7 @@ describe Puppet::Resource do
 
     describe "when the resource type is :hostclass" do
       let(:environment_name) { "testing env" }
-      let(:fact_values) { { :a => 1 } }
+      let(:fact_values) { { 'a' => 1 } }
       let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
 
       def inject_and_set_defaults(resource, scope)
@@ -326,10 +330,7 @@ describe Puppet::Resource do
 
       before do
         environment.known_resource_types.add(apache)
-
-        scope.stubs(:host).returns('host')
-        scope.stubs(:environment).returns(environment)
-        scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
+        scope.set_facts(fact_values)
       end
 
       context 'with a default value expression' do
@@ -341,14 +342,14 @@ describe Puppet::Resource do
           end
 
           it "should query the data_binding terminus using a namespaced key" do
-            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('lookup_options', throws: :no_such_key)
             expect_lookup('apache::port')
             inject_and_set_defaults(resource, scope)
           end
 
           it "should use the value from the data_binding terminus" do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').returns('443')
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', returns: '443')
 
             inject_and_set_defaults(resource, scope)
 
@@ -356,8 +357,8 @@ describe Puppet::Resource do
           end
 
           it 'should use the default value if no value is found using the data_binding terminus' do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').throws(:no_such_key)
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', throws: :no_such_key)
 
             inject_and_set_defaults(resource, scope)
 
@@ -365,8 +366,8 @@ describe Puppet::Resource do
           end
 
           it 'should use the default value if an undef value is found using the data_binding terminus' do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').returns(nil)
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', returns: nil)
 
             inject_and_set_defaults(resource, scope)
 
@@ -374,8 +375,8 @@ describe Puppet::Resource do
           end
 
           it "should fail with error message about data binding on a hiera failure" do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', raises: [Puppet::DataBinding::LookupError, 'Forgettabotit'])
             expect {
               inject_and_set_defaults(resource, scope)
             }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
@@ -385,7 +386,7 @@ describe Puppet::Resource do
         context "when a value is provided" do
           let(:port_parameter) do
             Puppet::Parser::Resource::Param.new(
-              { :name => 'port', :value => '8080' }
+              name: 'port', value: '8080'
             )
           end
 
@@ -395,22 +396,22 @@ describe Puppet::Resource do
           end
 
           it "should not query the data_binding terminus" do
-            Puppet::DataBinding.indirection.expects(:find).never
+            expect(Puppet::DataBinding.indirection).not_to receive(:find)
             inject_and_set_defaults(resource, scope)
           end
 
           it "should use the value provided" do
-            Puppet::DataBinding.indirection.expects(:find).never
+            expect(Puppet::DataBinding.indirection).not_to receive(:find)
             expect(resource.set_default_parameters(scope)).to eq([])
             expect(resource[:port]).to eq('8080')
           end
 
           it "should use the value from the data_binding terminus when provided value is undef" do
-            expect_lookup('lookup_options').throws(:no_such_key)
-            expect_lookup('apache::port').returns('443')
+            expect_lookup('lookup_options', throws: :no_such_key)
+            expect_lookup('apache::port', returns: '443')
 
             rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+              :parameters => [Puppet::Parser::Resource::Param.new(name: 'port', value: nil)])
 
             rs.resource_type.set_resource_parameters(rs, scope)
             expect(rs[:port]).to eq('443')
@@ -423,8 +424,8 @@ describe Puppet::Resource do
         let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
 
         it "should use the value from the data_binding terminus" do
-          expect_lookup('lookup_options').throws(:no_such_key)
-          expect_lookup('apache::port').returns('443')
+          expect_lookup('lookup_options', throws: :no_such_key)
+          expect_lookup('apache::port', returns: '443')
 
           inject_and_set_defaults(resource, scope)
 
@@ -432,8 +433,8 @@ describe Puppet::Resource do
         end
 
         it "should use an undef value from the data_binding terminus" do
-          expect_lookup('lookup_options').throws(:no_such_key)
-          expect_lookup('apache::port').returns(nil)
+          expect_lookup('lookup_options', throws: :no_such_key)
+          expect_lookup('apache::port', returns: nil)
 
           inject_and_set_defaults(resource, scope)
 
@@ -533,14 +534,14 @@ describe Puppet::Resource do
 
     it "should set the namevar when asked to set the name" do
       resource = Puppet::Resource.new("user", "bob")
-      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
+      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
       resource[:name] = "bob"
       expect(resource[:myvar]).to eq("bob")
     end
 
     it "should return the namevar when asked to return the name" do
       resource = Puppet::Resource.new("user", "bob")
-      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
+      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
       resource[:myvar] = "test"
       expect(resource[:name]).to eq("test")
     end
@@ -619,15 +620,19 @@ describe Puppet::Resource do
 
     it "should use the title as the namevar to the hash if no namevar is present" do
       resource = Puppet::Resource.new("user", "bob")
-      Puppet::Type.type(:user).stubs(:key_attributes).returns [:myvar]
+      allow(Puppet::Type.type(:user)).to receive(:key_attributes).and_return([:myvar])
       expect(resource.to_hash[:myvar]).to eq("bob")
     end
 
-    it "should set :name to the title if :name is not present for non-builtin types" do
-      krt = Puppet::Resource::TypeCollection.new("myenv")
-      krt.add Puppet::Resource::Type.new(:definition, :foo)
-      resource = Puppet::Resource.new :foo, "bar"
-      resource.stubs(:known_resource_types).returns krt
+    it "should set :name to the title if :name is not present for non-existent types" do
+      resource = Puppet::Resource.new :doesnotexist, "bar"
+      expect(resource.to_hash[:name]).to eq("bar")
+    end
+
+    it "should set :name to the title if :name is not present for a definition" do
+      type = Puppet::Resource::Type.new(:definition, :foo)
+      environment.known_resource_types.add(type)
+      resource = Puppet::Resource.new :foo, "bar", :environment => environment
       expect(resource.to_hash[:name]).to eq("bar")
     end
   end
@@ -679,7 +684,7 @@ describe Puppet::Resource do
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
 
-    it 'to_data_hash returns value that is instance of to Data' do
+    it 'to_data_hash returns value that is instance of Data' do
       Puppet::Pops::Types::TypeAsserter.assert_instance_of('', Puppet::Pops::Types::TypeFactory.data, @resource.to_data_hash)
       expect(Puppet::Pops::Types::TypeFactory.data.instance?(@resource.to_data_hash)).to be_truthy
     end
@@ -689,19 +694,68 @@ describe Puppet::Resource do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
+
       expect(result).to be_instance_of(Puppet::Type.type(:file))
       expect(result[:path]).to eq(basepath+"/my/file")
     end
 
-    it "should convert to a component instance if the resource type is not of a builtin type" do
+    it "should convert to a component instance if the resource is not a compilable_type" do
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
       expect(result).to be_instance_of(Puppet::Type.type(:component))
       expect(result.title).to eq("Foobar[somename]")
     end
-  end
 
+    it "should convert to a component instance if the resource is a class" do
+      resource = Puppet::Resource.new("Class", "somename")
+      result = resource.to_ral
+
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+      expect(result.title).to eq("Class[Somename]")
+    end
+
+    it "should convert to component when the resource is a defined_type" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'defined_type')
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+    end
+
+    it "should raise if a resource type is a compilable_type and it wasn't found" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
+
+      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should use the old behaviour when the catalog_format is equal to 1" do
+      resource = Puppet::Resource.new("Unknown", "type")
+      catalog = Puppet::Resource::Catalog.new("mynode")
+
+      resource.catalog = catalog
+      resource.catalog.catalog_format = 1
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:component))
+    end
+
+    it "should use the new behaviour and fail when the catalog_format is greater than 1" do
+      resource = Puppet::Resource.new("Unknown", "type", :kind => 'compilable_type')
+      catalog = Puppet::Resource::Catalog.new("mynode")
+
+      resource.catalog = catalog
+      resource.catalog.catalog_format = 2
+
+      expect { resource.to_ral }.to raise_error(Puppet::Error, "Resource type 'Unknown' was not found")
+    end
+
+    it "should use the resource type when the resource doesn't respond to kind and the resource type can be found" do
+      resource = Puppet::Resource.new("file", basepath+"/my/file")
+
+      result = resource.to_ral
+      expect(result).to be_instance_of(Puppet::Type.type(:file))
+    end
+  end
   describe "when converting to puppet code" do
     before do
       @resource = Puppet::Resource.new("one::two", "/my/file",
@@ -719,7 +773,7 @@ describe Puppet::Resource do
           :ensure => 'present',
         }
       )
-      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+      expect(singlequote_resource.to_manifest).to eq(<<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, ''))
         one::two { '/my/file\\'b\\'a\\'r':
           ensure => 'present',
         }
@@ -728,7 +782,7 @@ describe Puppet::Resource do
     end
 
     it "should align, sort and add trailing commas to attributes with ensure first" do
-      expect(@resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+      expect(@resource.to_manifest).to eq(<<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, ''))
         one::two { '/my/file':
           ensure => 'present',
           foo    => ['one', 'two'],
@@ -743,21 +797,47 @@ describe Puppet::Resource do
       @resource = Puppet::Resource.new("one::two", "/my/file",
         :parameters => {
           :noop => true,
-          :foo => %w{one two},
+          :foo => [:one, "two"],
+          :bar => 'a\'b',
           :ensure => 'present',
         }
       )
     end
 
     it "should align and sort to attributes with ensure first" do
-      expect(@resource.to_hierayaml).to eq <<-HEREDOC.gsub(/^\s{8}/, '')
+      expect(@resource.to_hierayaml).to eq(<<-HEREDOC.gsub(/^\s{8}/, ''))
           /my/file:
             ensure: 'present'
+            bar   : 'a\\'b'
             foo   : ['one', 'two']
             noop  : true
       HEREDOC
     end
+
+    it "should convert some types to String" do
+      expect(@resource.to_hiera_hash).to eq(
+        "/my/file" => {
+          'ensure' => "present",
+          'bar'    => "a'b",
+          'foo'    => ["one", "two"],
+          'noop'   => true
+        }
+      )
+    end
+
+    it "accepts symbolic titles" do
+      res = Puppet::Resource.new(:file, "/my/file", :parameters => { 'ensure' => "present" })
+
+      expect(res.to_hiera_hash.keys).to eq(["/my/file"])
+    end
+
+    it "emits an empty parameters hash" do
+      res = Puppet::Resource.new(:file, "/my/file")
+
+      expect(res.to_hiera_hash).to eq({"/my/file" => {}})
+    end
   end
+
   describe "when converting to json" do
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
@@ -791,6 +871,13 @@ describe Puppet::Resource do
       expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).line).to eq(50)
     end
 
+    it "should include the kind if one is set" do
+      resource = Puppet::Resource.new("File", "/foo")
+      resource.kind = 'im_a_file'
+
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).kind).to eq('im_a_file')
+    end
+
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
@@ -817,7 +904,7 @@ describe Puppet::Resource do
     it "should set sensitive parameters as an array of strings" do
       resource = Puppet::Resource.new("File", "/foo", :sensitive_parameters => [:foo, :fee])
       result = JSON.parse(resource.to_json)
-      expect(result["sensitive_parameters"]).to eq ["foo", "fee"]
+      expect(result["sensitive_parameters"]).to eq(["foo", "fee"])
     end
 
     it "should serialize relationships as reference strings" do
@@ -835,6 +922,46 @@ describe Puppet::Resource do
     end
   end
 
+  describe 'when converting to data_hash with stringified parameters' do
+    before(:each) do
+      Puppet.push_context({:stringify_rich => true}, 'resource_spec.rb')
+    end
+
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    let(:resource) do
+      type = Puppet::Resource::Type.new(:definition, "rich::thing")
+      environment.known_resource_types.add type
+
+      r = Puppet::Resource.new('rich::thing', 'stringified', :environment => environment)
+      r['binary'] = Puppet::Pops::Types::PBinaryType::Binary.from_binary_string('hello')
+      r['timestamp'] = Puppet::Pops::Time::Timestamp.parse('2018-09-03T19:45:33.697066000 UTC')
+      r['reference'] = Puppet::Resource.new('File', 'dummy', :environment => environment)
+      r.resource_type
+      r
+    end
+
+    let(:parameters) do
+      resource.to_data_hash['parameters']
+    end
+
+    it 'has Base64 string content for a binary' do
+      expect(parameters['binary']).to eq('aGVsbG8=')
+    end
+
+    it 'has string content for a timestamp' do
+      expect(parameters['timestamp']).to eq('2018-09-03T19:45:33.697066000 UTC')
+    end
+
+    it 'has string content for a Resource instance' do
+      expect(parameters['reference']).to eq('File[dummy]')
+    end
+
+    # Note: to_stringified_spec.rb has tests for all other data types
+  end
+
   describe "when converting from json" do
     before do
       @data = {
@@ -935,11 +1062,11 @@ describe Puppet::Resource do
 
   describe "when resolving resources with a catalog" do
     it "should resolve all resources using the catalog" do
-      catalog = mock 'catalog'
+      catalog = double('catalog')
       resource = Puppet::Resource.new("foo::bar", "yay")
       resource.catalog = catalog
 
-      catalog.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
+      expect(catalog).to receive(:resource).with("Foo::Bar[yay]").and_return(:myresource)
 
       expect(resource.resolve).to eq(:myresource)
     end
@@ -947,8 +1074,8 @@ describe Puppet::Resource do
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
-      Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
-      Puppet::Type.type(:file).stubs(:title_patterns).returns(
+      allow(Puppet::Type.type(:file)).to receive(:key_attributes).and_return([:myvar, :owner, :path])
+      allow(Puppet::Type.type(:file)).to receive(:title_patterns).and_return(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
@@ -1041,6 +1168,18 @@ describe Puppet::Resource do
         newparam(:admits_to_age)
         newparam(:name)
       end
+
+      Puppet::Type.newtype('brown') do
+        newproperty(:ensure)
+        newparam(:admits_to_dying_hair)
+        newparam(:admits_to_age)
+        newparam(:hair_length)
+        newparam(:name)
+
+        def self.parameters_to_include
+          [:admits_to_dying_hair, :admits_to_age]
+        end
+      end
     end
 
     it "should strip all parameters and strip properties that are nil, empty or absent except for ensure" do
@@ -1083,5 +1222,24 @@ describe Puppet::Resource do
       })
       )
     end
+
+    context "when the resource type has a default set of parameters it wants to include" do
+      it "should leave those parameters alone" do
+        resource = Puppet::Resource.new("brown", "Esmeralda", :parameters => {
+          :admits_to_age        => true,
+          :admits_to_dying_hair => false,
+          :hair_length          => 10
+        })
+
+        pruned_resource = resource.prune_parameters
+        expected_resource = Puppet::Resource.new(
+          "brown",
+          "Esmeralda",
+          :parameters => { :admits_to_age => true, :admits_to_dying_hair => false }
+        )
+  
+        expect(pruned_resource).to eq(expected_resource)
+      end
+    end
   end
 end

data/spec/unit/rest/route_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+require 'puppet/rest/route'
+
+describe Puppet::Rest::Route do
+  describe '#with_base_url'do
+    let(:dns_resolver) { double('dns resolver') }
+
+    context 'when not using SRV records' do
+      before :each do
+        Puppet.settings[:use_srv_records] = false
+      end
+
+      it "yields a base URL with the values from the specified settings" do
+        Puppet[:ca_server] = 'testserver'
+        Puppet[:ca_port] = 555
+        ca_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
+                                           server_setting: :ca_server,
+                                           port_setting: :ca_port,
+                                           srv_service: :test_service)
+        count = 0
+        rval = ca_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://testserver:555/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+
+      it "yields a base URL with Puppet's configured server and port when no defaults are specified" do
+        Puppet[:server] = 'configured.net'
+        Puppet[:serverport] = 8140
+        fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
+        count = 0
+        rval = fallback_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://configured.net:8140/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+
+      it 'yields the first entry in the server list when server_list is in use' do
+        Puppet[:server_list] = [['one.net', 111], ['two.net', 222]]
+        fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
+        count = 0
+        rval = fallback_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://one.net:111/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+
+      it 'falls back to :server and :serverport if nil is passed' do
+        Puppet[:server] = 'one.net'
+        Puppet[:serverport] = 111
+        nil_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
+                                            server_setting: nil,
+                                            port_setting: nil)
+        count = 0
+        rval = nil_route.with_base_url(dns_resolver) do |url|
+          count += 1
+          expect(url.to_s).to eq('https://one.net:111/fakeapi/v1/')
+          'Block return value'
+        end
+        expect(count).to eq(1)
+        expect(rval).to eq('Block return value')
+      end
+    end
+
+    context 'when using SRV records' do
+      context "when SRV returns servers" do
+        let(:route) { Puppet::Rest::Route.new(api: '/fakeapi/v1/',
+                                              srv_service: :test_service) }
+
+        before :each do
+          Puppet.settings[:use_srv_records] = true
+          Puppet.settings[:srv_domain]      = 'example.com'
+
+          @dns_mock = double('dns')
+          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
+
+          @port = 7502
+          @target = 'example.com'
+          record = Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @target)
+          record.instance_variable_set(:@ttl, 10)
+          @srv_records = [record]
+
+          expect(@dns_mock).to receive(:getresources).
+            with("_x-puppet-test_service._tcp.example.com", Resolv::DNS::Resource::IN::SRV).
+            and_return(@srv_records)
+        end
+
+        it "yields a URL using the server and port from the SRV record" do
+          count = 0
+          rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|
+            count += 1
+            expect(url.to_s).to eq('https://example.com:7502/fakeapi/v1/')
+            'Block return value'
+          end
+          expect(count).to eq(1)
+
+          expect(rval).to eq('Block return value')
+        end
+
+        it "should fall back to the default server when the block raises a SystemCallError" do
+          Puppet[:server] = "testserver"
+          Puppet[:serverport] = 555
+
+          count = 0
+          rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|
+            count += 1
+            if url.to_s =~ /example.com/ then
+              raise SystemCallError, "example failure"
+            else
+              expect(url.to_s).to eq('https://testserver:555/fakeapi/v1/')
+            end
+
+            'Block return value'
+          end
+
+          expect(count).to eq(2)
+          expect(rval).to eq('Block return value')
+        end
+      end
+    end
+  end
+end

data/spec/unit/scheduler/job_spec.rb

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

data/spec/unit/scheduler/scheduler_spec.rb

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

data/spec/unit/scheduler/splay_job_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/scheduler'
 
@@ -29,7 +28,7 @@ describe Puppet::Scheduler::SplayJob do
 
   it "is not immediately ready if splayed" do
     job.start_time = start_time
-    job.expects(:splay).returns(6)
+    expect(job).to receive(:splay).and_return(6)
     expect(job.ready?(start_time)).not_to be
   end
 end

data/spec/unit/settings/array_setting_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/settings'
 require 'puppet/settings/array_setting'
 
 describe Puppet::Settings::ArraySetting do
-  subject { described_class.new(:settings => stub('settings'), :desc => "test") }
+  subject { described_class.new(:settings => double('settings'), :desc => "test") }
 
   it "is of type :array" do
     expect(subject.type).to eq :array