puppet 4.3.0 → 4.4.0

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

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:launchd) do
+  let (:plistlib) { Puppet::Util::Plist }
   let (:joblabel) { "com.foo.food" }
   let (:provider) { subject.class }
   let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
@@ -43,21 +44,21 @@ describe Puppet::Type.type(:service).provider(:launchd) do
       it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
         provider.expects(:get_os_version).returns(kernel).at_least_once
         subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
         FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
         expect(subject.enabled?).to eq(:true)
       end
       it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
         provider.expects(:get_os_version).returns(kernel).at_least_once
         subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
         FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
         expect(subject.enabled?).to eq(:false)
       end
       it "should return true if the job plist and the global overrides have no disabled keys" do
         provider.expects(:get_os_version).returns(kernel).at_least_once
         subject.expects(:plist_from_label).returns([joblabel, {}])
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
         FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
         expect(subject.enabled?).to eq(:true)
       end
@@ -68,21 +69,21 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
       provider.expects(:get_os_version).returns(14).at_least_once
       subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => false})
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({joblabel => false})
       FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       expect(subject.enabled?).to eq(:true)
     end
     it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
       provider.expects(:get_os_version).returns(14).at_least_once
       subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => true})
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({joblabel => true})
       FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       expect(subject.enabled?).to eq(:false)
     end
     it "should return true if the job plist and the global overrides have no disabled keys" do
       provider.expects(:get_os_version).returns(14).at_least_once
       subject.expects(:plist_from_label).returns([joblabel, {}])
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
       FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       expect(subject.enabled?).to eq(:true)
     end
@@ -203,8 +204,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
       it "should write to the global launchd overrides file once" do
         resource[:enable] = true
         provider.expects(:get_os_version).returns(kernel).at_least_once
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
-        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:write_plist_file).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
         subject.enable
       end
     end
@@ -213,8 +214,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
       it "should write to the global launchd overrides file once" do
         resource[:enable] = false
         provider.expects(:get_os_version).returns(kernel).at_least_once
-        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
-        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:write_plist_file).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
         subject.disable
       end
     end
@@ -224,8 +225,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
       provider.expects(:get_os_version).returns(14).at_least_once
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
-      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], false), launchd_overrides_10_).once
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:write_plist_file).with(has_entry(resource[:name], false), launchd_overrides_10_).once
       subject.enable
     end
   end
@@ -234,8 +235,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
       provider.expects(:get_os_version).returns(14).at_least_once
-      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
-      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], true), launchd_overrides_10_).once
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:write_plist_file).with(has_entry(resource[:name], true), launchd_overrides_10_).once
       subject.disable
     end
   end
@@ -254,23 +255,15 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         }
       end
       let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
+      let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
       it "[17624] should warn that the plist in question is being skipped" do
         provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
         provider.expects(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').returns([busted_plist_path])
-        provider.expects(:read_plist).with(busted_plist_path).returns(plist_without_label)
+        plistlib.expects(:read_plist_file).with(busted_plist_path).returns(plist_without_label)
         Puppet.expects(:warning).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
-
-      it "[15929] should skip plists that plutil cannot read" do
-        provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout',
-          busted_plist_path).raises(Puppet::ExecutionFailure, 'boom')
-        Puppet.expects(:warning).with("Cannot read file #{busted_plist_path}; " +
-                                      "Puppet is skipping it. \n" +
-                                      "Details: boom")
-        provider.read_plist(busted_plist_path)
-      end
     end
     it "should return the cached value when available" do
       provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
@@ -284,7 +277,7 @@ describe Puppet::Type.type(:service).provider(:launchd) do
         provider.instance_variable_set(:@label_to_path_map, nil)
         provider.expects(:launchd_paths).returns([launchd_dir])
         provider.expects(:return_globbed_list_of_file_paths).with(launchd_dir).returns([plist])
-        provider.expects(:read_plist).with(plist).returns({'Label'=>'foo.bar.service'})
+        plistlib.expects(:read_plist_file).with(plist).returns({'Label'=>'foo.bar.service'})
       end
       it "should read the plists and return their contents" do
         expect(provider.make_label_to_path_map).to eq({label=>plist})

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

@@ -19,14 +19,14 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   osfamily.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
       Facter.stubs(:value).with(:osfamily).returns(osfamily)
-      expect(described_class.default?).to be_truthy
+      expect(described_class).to be_default
     end
   end
 
   it "should be the default provider on rhel7" do
     Facter.stubs(:value).with(:osfamily).returns(:redhat)
     Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
-    expect(described_class.default?).to be_truthy
+    expect(described_class).to be_default
   end
 
   [ 4, 5, 6 ].each do |ver|
@@ -38,7 +38,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
       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
+      expect(described_class).not_to be_default
     end
   end
 
@@ -47,64 +47,77 @@ describe Puppet::Type.type(:service).provider(:systemd) do
       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
+      expect(described_class).to be_default
     end
   end
 
   it "should be the default provider on sles12" do
     Facter.stubs(:value).with(:osfamily).returns(:suse)
     Facter.stubs(:value).with(:operatingsystemmajrelease).returns("12")
-    expect(described_class.default?).to be_truthy
+    expect(described_class).to be_default
   end
 
   it "should be the default provider on opensuse13" do
     Facter.stubs(:value).with(:osfamily).returns(:suse)
     Facter.stubs(:value).with(:operatingsystemmajrelease).returns("13")
-    expect(described_class.default?).to be_truthy
+    expect(described_class).to be_default
   end
 
   # 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
+    expect(described_class).to be_default
   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
+    expect(described_class).to be_default
   end
 
   it "should not be the default provider on debian7" do
     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
+    expect(described_class).not_to be_default
   end
 
   it "should be the default provider on debian8" do
     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
+    expect(described_class).to be_default
   end
 
   it "should not be the default provider on ubuntu14.04" do
     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
+    expect(described_class).not_to be_default
   end
 
   it "should be the default provider on ubuntu15.04" do
     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
+    expect(described_class).to be_default
   end
 
+  it "should be the default provider on ubuntu15.10" do
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("15.10")
+    expect(described_class).to be_default
+  end
+
+  it "should be the default provider on ubuntu16.04" do
+    Facter.stubs(:value).with(:osfamily).returns(:debian)
+    Facter.stubs(:value).with(:operatingsystem).returns(:ubuntu)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("16.04")
+    expect(described_class).to be_default
+  end
 
   [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
     it "should have a #{method} method" do

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

@@ -158,6 +158,63 @@ describe Puppet::Type.type(:service).provider(:upstart) do
       end
     end
 
+    describe "when a special status command is specifed" do
+      it "should use the provided status command" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        Process::Status.any_instance.stubs(:exitstatus).returns(0)
+        provider.status
+      end
+
+      it "should return :stopped when the provided status command return non-zero" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 1
+        expect(provider.status).to eq(:stopped)
+      end
+
+      it "should return :running when the provided status command return zero" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :provider => :upstart, :status => '/bin/foo')
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        expect(provider.status).to eq(:running)
+      end
+    end
+
+    describe "when :hasstatus is set to false" do
+      it "should return :stopped if the pid can not be found" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns nil
+        expect(provider.status).to eq(:stopped)
+      end
+
+      it "should return :running if the pid can be found" do
+        resource = Puppet::Type.type(:service).new(:name => 'foo', :hasstatus => false, :provider => :upstart)
+        provider = provider_class.new(resource)
+        provider.stubs(:is_upstart?).returns(true)
+
+        provider.expects(:status_exec).with(['foo']).never
+        provider.expects(:getpid).returns 2706
+        expect(provider.status).to eq(:running)
+      end
+    end
+
     it "should properly handle services with 'start' in their name" do
       resource = Puppet::Type.type(:service).new(:name => "foostartbar", :provider => :upstart)
       provider = provider_class.new(resource)

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

@@ -41,30 +41,31 @@ describe "sshkey parsed provider" do
   end
 
   context "with the sample file" do
-    let :fixture do my_fixture('sample') end
-    before :each do subject.stubs(:default_target).returns(fixture) end
+    ['sample', 'sample_with_blank_lines'].each do |sample_file|
+      let :fixture do my_fixture(sample_file) end
+      before :each do subject.stubs(:default_target).returns(fixture) end
 
-    it "should parse to records on prefetch" do
-      expect(subject.target_records(fixture)).to be_empty
-      subject.prefetch
+      it "should parse to records on prefetch" do
+        expect(subject.target_records(fixture)).to be_empty
+        subject.prefetch
 
-      records = subject.target_records(fixture)
-      expect(records).to be_an Array
-      expect(records).to be_all {|x| expect(x).to be_an Hash }
-    end
-
-    it "should reconstitute the file from records" do
-      subject.prefetch
-      records = subject.target_records(fixture)
+        records = subject.target_records(fixture)
+        expect(records).to be_an Array
+        expect(records).to be_all {|x| expect(x).to be_an Hash }
+      end
 
-      text = subject.to_file(records).gsub(/^# HEADER.+\n/, '')
+      it "should reconstitute the file from records" do
+        subject.prefetch
+        records = subject.target_records(fixture)
+        text = subject.to_file(records).gsub(/^# HEADER.+\n/, '')
 
-      oldlines = File.readlines(fixture).map(&:chomp)
-      newlines = text.chomp.split("\n")
-      expect(oldlines.length).to eq(newlines.length)
+        oldlines = File.readlines(fixture).map(&:chomp)
+        newlines = text.chomp.split("\n")
+        expect(oldlines.length).to eq(newlines.length)
 
-      oldlines.zip(newlines).each do |old, new|
-        expect(old.gsub(/\s+/, '')).to eq(new.gsub(/\s+/, ''))
+        oldlines.zip(newlines).each do |old, new|
+          expect(old.gsub(/\s+/, '')).to eq(new.gsub(/\s+/, ''))
+        end
       end
     end
   end