puppet 4.3.1 → 4.3.2

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

@@ -32,9 +32,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
   describe "group type :members property helpers" do
 
-    let(:user1) { stub(:account => 'user1', :domain => '.', :to_s => 'user1sid') }
-    let(:user2) { stub(:account => 'user2', :domain => '.', :to_s => 'user2sid') }
-    let(:user3) { stub(:account => 'user3', :domain => '.', :to_s => 'user3sid') }
+    let(:user1) { stub(:account => 'user1', :domain => '.', :sid => 'user1sid') }
+    let(:user2) { stub(:account => 'user2', :domain => '.', :sid => 'user2sid') }
+    let(:user3) { stub(:account => 'user3', :domain => '.', :sid => 'user3sid') }
     let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
@@ -183,9 +183,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       provider.group.stubs(:members).returns ['user1', 'user2']
 
       member_sids = [
-        stub(:account => 'user1', :domain => 'testcomputername'),
-        stub(:account => 'user2', :domain => 'testcomputername'),
-        stub(:account => 'user3', :domain => 'testcomputername'),
+        stub(:account => 'user1', :domain => 'testcomputername', :sid => 1),
+        stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
+        stub(:account => 'user3', :domain => 'testcomputername', :sid => 3),
       ]
 
       provider.group.stubs(:member_sids).returns(member_sids[0..1])
@@ -241,8 +241,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   it "should be able to test whether a group exists" do
-    Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection')
+    Puppet::Util::Windows::SID.stubs(:name_to_sid_object).returns(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'Group')
     expect(provider).to be_exists
 
     Puppet::Util::Windows::ADSI.stubs(:connect).returns nil

data/spec/unit/provider/package/pip_spec.rb

@@ -12,7 +12,6 @@ describe provider_class do
     @client = stub_everything('client')
     @client.stubs(:call).with('package_releases', 'real_package').returns(["1.3", "1.2.5", "1.2.4"])
     @client.stubs(:call).with('package_releases', 'fake_package').returns([])
-    XMLRPC::Client.stubs(:new2).returns(@client)
   end
 
   describe "parse" do
@@ -118,23 +117,52 @@ describe provider_class do
   end
 
   describe "latest" do
+    context "connecting directly" do
 
-    it "should find a version number for real_package" do
-      @resource[:name] = "real_package"
-      expect(@provider.latest).not_to eq(nil)
-    end
+      before :each do
+        XMLRPC::Client.expects(:new2).with("http://pypi.python.org/pypi", nil).returns(@client)
+      end
 
-    it "should not find a version number for fake_package" do
-      @resource[:name] = "fake_package"
-      expect(@provider.latest).to eq(nil)
-    end
+      it "should find a version number for real_package" do
+        @resource[:name] = "real_package"
+        expect(@provider.latest).not_to eq(nil)
+      end
 
-    it "should handle a timeout gracefully" do
-      @resource[:name] = "fake_package"
-      @client.stubs(:call).raises(Timeout::Error)
-      expect { @provider.latest }.to raise_error(Puppet::Error)
+      it "should not find a version number for fake_package" do
+        @resource[:name] = "fake_package"
+        expect(@provider.latest).to eq(nil)
+      end
+
+      it "should handle a timeout gracefully" do
+        @resource[:name] = "fake_package"
+        @client.stubs(:call).raises(Timeout::Error)
+        expect { @provider.latest }.to raise_error(Puppet::Error)
+      end
     end
 
+    context "connecting via a proxy" do
+      before :each do
+        Puppet::Util::HttpProxy.expects(:http_proxy_host).returns 'some_host'
+        Puppet::Util::HttpProxy.expects(:http_proxy_port).returns 'some_port'
+        XMLRPC::Client.expects(:new2).with("http://pypi.python.org/pypi", "some_host:some_port").returns(@client)
+      end
+
+      it "should find a version number for real_package" do
+        @resource[:name] = "real_package"
+        expect(@provider.latest).not_to eq(nil)
+      end
+
+      it "should not find a version number for fake_package" do
+        @resource[:name] = "fake_package"
+        expect(@provider.latest).to eq(nil)
+      end
+
+      it "should handle a timeout gracefully" do
+        @resource[:name] = "fake_package"
+        @client.stubs(:call).raises(Timeout::Error)
+        expect { @provider.latest }.to raise_error(Puppet::Error)
+      end
+    end
   end
 
   describe "install" do

data/spec/unit/provider/package/rpm_spec.rb

@@ -12,7 +12,6 @@ describe provider_class do
     chkconfig 0 1.3.30.2 2.el5 x86_64
     myresource 0 1.2.3.4 5.el4 noarch
     mysummaryless 0 1.2.3.4 5.el4 noarch
-    tomcat 1 1.2.3.4 5.fc22 noarch
     RPM_OUTPUT
   end
 
@@ -117,18 +116,7 @@ describe provider_class do
           :ensure => "1.3.30.2-2.el5",
         }
       )
-      expect(installed_packages[3].properties).to eq(
-        {
-          :provider    => :rpm,
-          :name        => "myresource",
-          :epoch       => "0",
-          :version     => "1.2.3.4",
-          :release     => "5.el4",
-          :arch        => "noarch",
-          :ensure      => "1.2.3.4-5.el4",
-        }
-      )
-      expect(installed_packages[4].properties).to eq(
+      expect(installed_packages.last.properties).to eq(
         {
           :provider    => :rpm,
           :name        => "mysummaryless",
@@ -139,17 +127,6 @@ describe provider_class do
           :ensure      => "1.2.3.4-5.el4",
         }
       )
-      expect(installed_packages[5].properties).to eq(
-        {
-          :provider    => :rpm,
-          :name        => "tomcat",
-          :epoch       => "1",
-          :version     => "1.2.3.4",
-          :release     => "5.fc22",
-          :arch        => "noarch",
-          :ensure      => "1:1.2.3.4-5.fc22",
-        }
-      )
     end
   end
 
@@ -292,7 +269,7 @@ describe provider_class do
           line.gsub(field, delimiter),
           package_hash.merge(
             field.to_sym => delimiter,
-            :ensure => 'epoch:version-release'.gsub(field, delimiter)
+            :ensure => 'version-release'.gsub(field, delimiter)
           )
         )
       end

data/spec/unit/provider/package/yum_spec.rb

@@ -448,7 +448,7 @@ describe provider_class do
 
     it "returns an empty hash if 'yum check-update' returned an exit code that was not 0 or 100" do
       Puppet::Util::Execution.expects(:execute).returns(stub(:exitstatus => 1))
-      described_class.expects(:warn)
+      described_class.expects(:warning).with('Could not check for updates, \'/usr/bin/yum check-update\' exited with 1')
       expect(described_class.check_updates([], [], [])).to eq({})
     end
   end

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

@@ -27,6 +27,7 @@ describe provider_class do
 
     @provider.stubs(:command).with(:update_rc).returns "update_rc"
     @provider.stubs(:command).with(:invoke_rc).returns "invoke_rc"
+    @provider.stubs(:command).with(:service).returns "service"
 
     @provider.stubs(:update_rc)
     @provider.stubs(:invoke_rc)
@@ -142,30 +143,11 @@ describe provider_class do
   end
 
   describe "when checking service status" do
-    context "On systems which use the systemd-sysvinit compatibility layer" do
-      it "should call systemctl to determine running status in Debian" do
-        Facter.stubs(:value).with(:operatingsystem).returns('Debian')
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('8')
-        @resource.stubs(:[]).with(:hasstatus).returns(:true)
-        expect(@provider.statuscmd).to eq(["systemctl", "is-active", @resource[:name]])
-      end
-
-      it "should call systemctl to determine running status in Ubuntu" do
-        Facter.stubs(:value).with(:operatingsystem).returns('Ubuntu')
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('15.04')
-        @resource.stubs(:[]).with(:hasstatus).returns(:true)
-        expect(@provider.statuscmd).to eq(["systemctl", "is-active", @resource[:name]])
-      end
-    end
-
-    context "On systems which only use sysvinit" do
-      it "should use the service init script" do
-        Facter.stubs(:value).with(:operatingsystem).returns('Debian')
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('7')
-        @resource.stubs(:[]).with(:hasstatus).returns(:true)
-        @provider.stubs(:initscript).returns("/etc/init.d/script")
-        expect(@provider.statuscmd).to eq(["/etc/init.d/script", :status])
-      end
+    it "should use the service command" do
+      Facter.stubs(:value).with(:operatingsystem).returns('Debian')
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns('8')
+      @resource.stubs(:[]).with(:hasstatus).returns(:true)
+      expect(@provider.statuscmd).to eq(["service", @resource[:name], "status"])
     end
   end
 end

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

@@ -39,7 +39,7 @@ describe Puppet::Type.type(:service).provider(:init) do
     before :each do
       described_class.stubs(:defpath).returns('tmp')
 
-      @services = ['one', 'two', 'three', 'four']
+      @services = ['one', 'two', 'three', 'four', 'umountfs']
       Dir.stubs(:entries).with('tmp').returns @services
       FileTest.expects(:directory?).with('tmp').returns(true)
       FileTest.stubs(:executable?).returns(true)
@@ -59,6 +59,16 @@ describe Puppet::Type.type(:service).provider(:init) do
       expect(described_class.get_services(described_class.defpath, exclude).map(&:name)).to eq(@services - [exclude])
     end
 
+    it "should omit Yocto services on cisco-wrlinux" do
+      Facter.stubs(:value).with(:osfamily).returns 'cisco-wrlinux'
+      exclude = 'umountfs'
+      expect(described_class.get_services(described_class.defpath).map(&:name)).to eq(@services - [exclude])
+    end
+
+    it "should not omit Yocto services on non cisco-wrlinux platforms" do
+      expect(described_class.get_services(described_class.defpath).map(&:name)).to eq(@services)
+    end
+
     it "should use defpath" do
       expect(described_class.instances).to be_all { |provider| provider.get(:path) == described_class.defpath }
     end

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

@@ -254,6 +254,7 @@ 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'])
@@ -264,6 +265,8 @@ describe Puppet::Type.type(:service).provider(:launchd) do
       end
 
       it "[15929] should skip plists that plutil cannot read" do
+        Plist.expects(:parse_xml).with(busted_plist_path).raises(ArgumentError, 'boom')
+        Puppet.expects(:debug).with("Error reading #{busted_plist_path}: boom. Retrying with plutil.")
         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}; " +
@@ -271,6 +274,14 @@ describe Puppet::Type.type(:service).provider(:launchd) do
                                       "Details: boom")
         provider.read_plist(busted_plist_path)
       end
+
+      it "should read binary plists with plutil" do
+        Plist.expects(:parse_xml).with(binary_plist_path).raises(ArgumentError, 'boom')
+        Puppet.expects(:debug).with("Error reading #{binary_plist_path}: boom. Retrying with plutil.")
+        provider.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', binary_plist_path).returns('plist')
+        Plist.expects(:parse_xml).with('plist').returns('plist_map')
+        expect(provider.read_plist(binary_plist_path)).to eq('plist_map')
+      end
     end
     it "should return the cached value when available" do
       provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})

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,70 @@ 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
 
   [: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/user/windows_adsi_spec.rb

@@ -64,9 +64,9 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
   describe "#groups_insync?" do
 
-    let(:group1) { stub(:account => 'group1', :domain => '.', :to_s => 'group1sid') }
-    let(:group2) { stub(:account => 'group2', :domain => '.', :to_s => 'group2sid') }
-    let(:group3) { stub(:account => 'group3', :domain => '.', :to_s => 'group3sid') }
+    let(:group1) { stub(:account => 'group1', :domain => '.', :sid => 'group1sid') }
+    let(:group2) { stub(:account => 'group2', :domain => '.', :sid => 'group2sid') }
+    let(:group3) { stub(:account => 'group3', :domain => '.', :sid => 'group3sid') }
 
     before :each do
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group1').returns(group1)
@@ -244,8 +244,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   end
 
   it 'should be able to test whether a user exists' do
-    Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection')
+    Puppet::Util::Windows::SID.stubs(:name_to_sid_object).returns(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'User')
     expect(provider).to be_exists
 
     Puppet::Util::Windows::ADSI.stubs(:connect).returns nil