puppet 4.2.0 → 4.3.0

data/spec/unit/provider/service/systemd_spec.rb

@@ -10,7 +10,6 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     described_class.stubs(:which).with('systemctl').returns '/bin/systemctl'
   end
 
-
   let :provider do
     described_class.new(:name => 'sshd.service')
   end
@@ -19,14 +18,14 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
   osfamily.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      Facter.expects(:value).with(:osfamily).returns(osfamily)
+      Facter.stubs(:value).with(:osfamily).returns(osfamily)
       expect(described_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on rhel7" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:redhat)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("7")
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
     expect(described_class.default?).to be_truthy
   end
 
@@ -36,7 +35,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
       # caused short-circuiting of the logic used by default.all? in the
       # provider. As a workaround we need to use stubs() instead of
       # expects() here.
-      Facter.expects(:value).with(:osfamily).at_least_once.returns(:redhat)
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(described_class.default?).not_to be_truthy
@@ -45,57 +44,64 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
   [ 17, 18, 19, 20, 21 ].each do |ver|
     it "should be the default provider on fedora#{ver}" do
-      Facter.expects(:value).with(:osfamily).at_least_once.returns(:redhat)
-      Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:fedora)
-      Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("#{ver}")
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
       expect(described_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on sles12" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("12")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("12")
     expect(described_class.default?).to be_truthy
   end
 
   it "should be the default provider on opensuse13" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("13")
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("13")
     expect(described_class.default?).to be_truthy
   end
 
-  it "should not be the default provider on sles11" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:suse)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("11")
-    expect(described_class.default?).not_to be_truthy
+  # tumbleweed is a rolling release with date-based major version numbers
+  it "should be the default provider on tumbleweed" do
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("20150829")
+    expect(described_class.default?).to be_truthy
+  end
+
+  # leap is the next generation suse release
+  it "should be the default provider on leap" do
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("42")
+    expect(described_class.default?).to be_truthy
   end
 
   it "should not be the default provider on debian7" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("7")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
     expect(described_class.default?).not_to be_truthy
   end
 
   it "should be the default provider on debian8" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("8")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
     expect(described_class.default?).to be_truthy
   end
 
   it "should not be the default provider on ubuntu14.04" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:ubuntu)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("14.04")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("14.04")
     expect(described_class.default?).not_to be_truthy
   end
 
   it "should be the default provider on ubuntu15.04" do
-    Facter.expects(:value).with(:osfamily).at_least_once.returns(:debian)
-    Facter.expects(:value).with(:operatingsystem).at_least_once.returns(:ubuntu)
-    Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns("15.04")
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("15.04")
     expect(described_class.default?).to be_truthy
   end
 
@@ -132,6 +138,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
     it "should start the service with systemctl start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:systemctl).with('unmask', 'sshd.service')
       provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
@@ -263,6 +270,49 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
+  describe "#debian_enabled?" do
+    [104, 106].each do |status|
+      it "should return true when invoke-rc.d returns #{status}" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.stubs(:system)
+        $CHILD_STATUS.expects(:exitstatus).returns(status)
+        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:true)
+      end
+    end
+
+    [101, 105].each do |status|
+      it "should return true when status is #{status} and there are at least 4 start links" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.stubs(:system)
+        provider.expects(:get_start_link_count).returns(4)
+        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
+        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:true)
+      end
+
+      it "should return false when status is #{status} and there are less than 4 start links" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.stubs(:system)
+        provider.expects(:get_start_link_count).returns(1)
+        $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
+        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:false)
+      end
+    end
+  end
+
+  describe "#get_start_link_count" do
+    it "should strip the '.service' from the search if present in the resource name" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
+      provider.get_start_link_count
+    end
+
+    it "should use the full service name if it does not include '.service'" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.expects(:glob).with("/etc/rc*.d/S??sshd").returns(['files'])
+      provider.get_start_link_count
+    end
+  end
+
   it "(#16451) has command systemctl without being fully qualified" do
     expect(described_class.instance_variable_get(:@commands)).to include(:systemctl => 'systemctl')
   end

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -261,7 +261,7 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
         @resource = Puppet::Type.type(:ssh_authorized_key).new(:name => "foo", :target => "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider = provider_class.new(@resource)
 
-        expect { @provider.flush }.to raise_error
+        expect { @provider.flush }.to raise_error(Puppet::Error, /Cannot write SSH authorized keys without user/)
       end
     end
 

data/spec/unit/provider/sshkey/parsed_spec.rb

@@ -68,4 +68,27 @@ describe "sshkey parsed provider" do
       end
     end
   end
+
+  context 'default ssh_known_hosts target path' do
+    ['9.10', '9.11', '10.10'].each do |version|
+      it 'should be `/etc/ssh_known_hosts` when OSX version 10.10 or older`' do
+        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
+        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(subject.default_target).to eq('/etc/ssh_known_hosts')
+      end
+    end
+
+    ['10.11', '10.13', '11.0', '11.11'].each do |version|
+      it 'should be `/etc/ssh/ssh_known_hosts` when OSX version 10.11 or newer`' do
+        Facter.expects(:value).with(:operatingsystem).returns('Darwin')
+        Facter.expects(:value).with(:macosx_productversion_major).returns(version)
+        expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
+      end
+    end
+
+    it 'should be `/etc/ssh/ssh_known_hosts` on other operating systems' do
+      Facter.expects(:value).with(:operatingsystem).returns('RedHat')
+      expect(subject.default_target).to eq('/etc/ssh/ssh_known_hosts')
+    end
+  end
 end

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -232,7 +232,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:name] = 'DOMAIN\testdomainuser'
       Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
       connection.expects(:Create)
-      connection.expects(:SetPassword)
+      connection.expects(:Get).with('UserFlags')
+      connection.expects(:Put).with('UserFlags', true)
       connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
 
       expect{ provider.create }.to raise_error(

data/spec/unit/provider/zone/solaris_spec.rb

@@ -149,6 +149,25 @@ net:
         })
       end
     end
+    describe "with an invalid or unrecognized config" do
+      it "should produce an error message with provider context when given an invalid config" do
+        erroneous_zone_info =<<-EOF
+          physical: net1'
+        EOF
+
+        provider.expects(:zonecfg).with(:info).returns(erroneous_zone_info)
+        provider.expects('err').with("Ignoring '          physical: net1''")
+        provider.getconfig
+      end
+
+
+      it "should produce a debugging message with provider context when given an unrecognized config" do
+        unrecognized_zone_info = "dummy"
+        provider.expects(:zonecfg).with(:info).returns(unrecognized_zone_info)
+        provider.expects('debug').with("Ignoring zone output 'dummy'")
+        provider.getconfig
+      end
+    end
   end
   context "#flush" do
     it "should correctly execute pending commands" do

data/spec/unit/reports_spec.rb

@@ -43,6 +43,16 @@ describe Puppet::Reports, " when registering report types" do
     Puppet::Reports.register_report(:testing) { }
   end
 
+  it "should allow a successful report to be reloaded" do
+    Puppet::Reports.register_report(:testing) { }
+    Puppet::Reports.register_report(:testing) { }
+  end
+
+  it "should allow a failed report to be reloaded and show the correct exception both times" do
+    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
+    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
+  end
+
   it "should extend the report type with the Puppet::Util::Docs module" do
     mod = stub 'module', :define_method => true
 

data/spec/unit/resource/capability_finder_spec.rb

@@ -0,0 +1,56 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require_relative '../pops/parser/parser_rspec_helper'
+require 'puppet/resource/capability_finder'
+
+describe Puppet::Resource::CapabilityFinder do
+  context 'when PuppetDB is not configured' do
+    it 'should error' do
+      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
+      expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
+    end
+  end
+
+  context 'when PuppetDB is configured' do
+    around(:each) do |example|
+      mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
+      if mock_pdb
+        class Puppet::Util::Puppetdb
+          class Http; end
+        end
+      end
+      begin
+        make_cap_type
+        example.run
+      ensure
+        Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+      end
+    end
+
+    class MockResponse
+      def body
+        '[{"type": "Cap", "title": "cap", "parameters": { "host" : "ahost" }}]'
+      end
+    end
+
+    def make_cap_type
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+    end
+
+    it 'should call Puppet::Util::PuppetDB::Http.action' do
+      Puppet::Util::Puppetdb::Http.expects(:action).returns(MockResponse.new)
+      result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
+      expect(result['host']).to eq('ahost')
+    end
+
+    it 'should use pass code_id in query to Puppet::Util::PuppetDB::Http.action' do
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      Puppet::Util::Puppetdb::Http.expects(:action).with(regexp_matches(Regexp.new(CGI.escape('"=","code_id","' + code_id + "")))).returns(MockResponse.new)
+      result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
+      expect(result['host']).to eq('ahost')
+    end
+  end
+end

data/spec/unit/resource/catalog_spec.rb

@@ -86,6 +86,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
     expect(@catalog.server_version).to eq(5)
   end
 
+  it "defaults code_id to nil" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.code_id).to be_nil
+  end
+
   describe "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
@@ -253,6 +258,16 @@ describe Puppet::Resource::Catalog, "when compiling" do
         r == @r1
       end.edge?(@r1,@r2)).not_to be
     end
+
+    it "copies the version" do
+      @original.version = '123'
+      expect(@original.filter.version).to eq(@original.version)
+    end
+
+    it 'copies the code_id' do
+      @original.code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      expect(@original.filter.code_id).to eq(@original.code_id)
+    end
   end
 
   describe "when functioning as a resource container" do
@@ -782,17 +797,23 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
 
-  def pson_output_should
-    @catalog.class.expects(:from_data_hash).with { |hash| yield hash }.returns(:something)
+  { :name => 'myhost',
+    :version => 42,
+    :code_id => 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+  }.each do |param, value|
+    it "emits a #{param} equal to #{value.inspect}" do
+      @catalog.send(param.to_s + "=", value)
+      pson = PSON.parse(@catalog.to_pson)
+
+      expect(pson[param.to_s]).to eq(@catalog.send(param))
+    end
   end
 
-  [:name, :version, :classes].each do |param|
-    it "should set its #{param} to the #{param} of the resource" do
-      @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
+  it "emits an array of classes" do
+    @catalog.add_class('foo')
+    pson = PSON.parse(@catalog.to_pson)
 
-      pson_output_should { |hash| expect(hash[param.to_s]).to eq(@catalog.send(param)) }
-      Puppet::Resource::Catalog.from_data_hash PSON.parse @catalog.to_pson
-    end
+    expect(pson['classes']).to eq(['foo'])
   end
 
   it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
@@ -831,6 +852,7 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
 
   it "should create it with the provided name" do
     @data['version'] = 50
+    @data['code_id'] = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
     @data['tags'] = %w{one two}
     @data['classes'] = %w{one two}
     @data['edges'] = [Puppet::Relationship.new("File[/foo]", "File[/bar]",
@@ -844,6 +866,7 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
 
     expect(catalog.name).to eq('myhost')
     expect(catalog.version).to eq(@data['version'])
+    expect(catalog.code_id).to eq(@data['code_id'])
     expect(catalog).to be_tagged("one")
     expect(catalog).to be_tagged("two")
 

data/spec/unit/resource/type_collection_spec.rb

@@ -76,16 +76,18 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
-  it "should remove all nodes, classes, and definitions when cleared" do
+  it "should remove all nodes, classes, definitions, and applications when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
+    loader.add Puppet::Resource::Type.new(:application, "application")
 
     loader.clear
     expect(loader.hostclass("class")).to be_nil
     expect(loader.definition("define")).to be_nil
     expect(loader.node("node")).to be_nil
+    expect(loader.node("application")).to be_nil
   end
 
   describe "when looking up names" do
@@ -153,7 +155,8 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  %w{hostclass node definition}.each do |data|
+  KINDS = %w{hostclass node definition application}
+  KINDS.each do |data|
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
@@ -175,6 +178,24 @@ describe Puppet::Resource::TypeCollection do
       it "should return nil when asked for a #{data} that has not been added" do
         expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
+
+      if data != "node"
+        it "should fail if an application with the same name is added" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          instance = Puppet::Resource::Type.new(data, "foo")
+          application = Puppet::Resource::Type.new(:application, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+
+        it "should fail if there is an application with the same name" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          application = Puppet::Resource::Type.new(:application, "foo")
+          instance = Puppet::Resource::Type.new(data, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+      end
     end
   end
 

data/spec/unit/resource/type_spec.rb

@@ -766,7 +766,7 @@ describe Puppet::Resource::Type do
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
-      expect(dest.code.children.collect { |l| l.children[0].value }).to eq(%w{dest source})
+      expect(dest.code.children.map { |c| c.value }).to eq(%w{dest source})
     end
   end
 end

data/spec/unit/resource_spec.rb

@@ -331,13 +331,15 @@ describe Puppet::Resource do
         end
 
         it "should query the data_binding terminus using a namespaced key" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
           Puppet::DataBinding.indirection.expects(:find).with(
             'apache::port', all_of(has_key(:environment), has_key(:variables)))
           resource.set_default_parameters(scope)
         end
 
         it "should use the value from the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).returns('443')
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
           resource.set_default_parameters(scope)
 
@@ -345,7 +347,8 @@ describe Puppet::Resource do
         end
 
         it "should use the default value if the data_binding terminus returns nil" do
-          Puppet::DataBinding.indirection.expects(:find).returns(nil)
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
 
           resource.set_default_parameters(scope)
 
@@ -353,7 +356,8 @@ describe Puppet::Resource do
         end
 
         it "should fail with error message about data binding on a hiera failure" do
-          Puppet::DataBinding.indirection.expects(:find).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
           expect {
             resource.set_default_parameters(scope)
           }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
@@ -428,11 +432,11 @@ describe Puppet::Resource do
     end
 
     it "should fail if invalid parameters are used" do
-      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error
+      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error(Puppet::Error, /no parameter named 'nosuchparam'/)
     end
 
     it "should fail if the resource type cannot be resolved" do
-      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error
+      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error(ArgumentError, /Invalid resource type/)
     end
   end
 
@@ -657,6 +661,20 @@ describe Puppet::Resource do
       )
     end
 
+    it "should escape internal single quotes in a title" do
+      singlequote_resource = Puppet::Resource.new("one::two", "/my/file'b'a'r",
+        :parameters => {
+          :ensure => 'present',
+        }
+      )
+      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+        one::two { '/my/file\\'b\\'a\\'r':
+          ensure => 'present',
+        }
+      HEREDOC
+
+    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$/, '')
         one::two { '/my/file':

data/spec/unit/settings/file_setting_spec.rb

@@ -295,4 +295,35 @@ describe Puppet::Settings::FileSetting do
       expect(filesetting.munge(':memory:')).to eq(':memory:')
     end
   end
+
+  context "when opening", :unless => Puppet.features.microsoft_windows? do
+    let(:path) do
+      tmpfile('file_setting_spec')
+    end
+
+    let(:setting) do
+      settings = mock("settings", :value => path)
+      FileSetting.new(:name => :mysetting, :desc => "creates a file", :settings => settings)
+    end
+
+    it "creates a file with mode 0640" do
+      setting.mode = '0640'
+
+      expect(File).to_not be_exist(path)
+      setting.open('w')
+
+      expect(File).to be_exist(path)
+      expect(Puppet::FileSystem.stat(path).mode & 0777).to eq(0640)
+    end
+
+    it "preserves the mode of an existing file" do
+      setting.mode = '0640'
+
+      Puppet::FileSystem.touch(path)
+      Puppet::FileSystem.chmod(0644, path)
+      setting.open('w')
+
+      expect(Puppet::FileSystem.stat(path).mode & 0777).to eq(0644)
+    end
+  end
 end