puppet 3.7.5-x86-mingw32 → 3.8.1-x86-mingw32

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

@@ -10,68 +10,79 @@ describe "base service provider" do
 
   let :type do Puppet::Type.type(:service) end
   let :provider do type.provider(:base) end
+  let(:executor) { Puppet::Util::Execution }
+  let(:start_command) { 'start' }
+  let(:status_command) { 'status' }
+  let(:stop_command) { 'stop' }
 
   subject { provider }
 
   context "basic operations" do
-    # Cross-platform file interactions.  Fun times.
-    Ruby = File.join(RbConfig::CONFIG["bindir"],
-                     RbConfig::CONFIG["RUBY_INSTALL_NAME"] +
-                     RbConfig::CONFIG["EXEEXT"])
-
-    Start  = [Ruby, '-rfileutils', '-e', 'FileUtils.touch(ARGV[0])']
-    Status = [Ruby, '-e' 'exit File.file?(ARGV[0])']
-    Stop   = [Ruby, '-e', 'File.exist?(ARGV[0]) and File.unlink(ARGV[0])']
-
-    let :flag do tmpfile('base-service-test') end
-
     subject do
-      type.new(:name  => "test", :provider => :base,
-               :start  => Start  + [flag],
-               :status => Status + [flag],
-               :stop   => Stop   + [flag]
+      type.new(
+         :name  => "test",
+         :provider => :base,
+         :start  => start_command,
+         :status => status_command,
+         :stop   => stop_command
       ).provider
     end
 
-    before :each do
-      Puppet::FileSystem.unlink(flag) if Puppet::FileSystem.exist?(flag)
+    def execute_command(command, options)
+      case command.shift
+      when start_command
+        expect(options[:failonfail]).to eq(true)
+        raise(Puppet::ExecutionFailure, 'failed to start') if @running
+        @running = true
+        return 'started'
+      when status_command
+        expect(options[:failonfail]).to eq(false)
+        $CHILD_STATUS.expects(:exitstatus).at_least(1).returns(@running ? 0 : 1)
+        return @running ? 'running' : 'not running'
+      when stop_command
+        expect(options[:failonfail]).to eq(true)
+        raise(Puppet::ExecutionFailure, 'failed to stop') unless @running
+        @running = false
+        return 'stopped'
+      else
+        raise "unexpected command execution: #{command}"
+      end
     end
 
-    it { should be }
+    before :each do
+      @running = false
+      executor.expects(:execute).at_least(1).with { |command, options| execute_command(command, options) }
+    end
 
     it "should invoke the start command if not running" do
-      File.should_not be_file(flag)
       subject.start
-      File.should be_file(flag)
     end
 
     it "should be stopped before being started" do
-      subject.status.should == :stopped
+      expect(subject.status).to eq(:stopped)
     end
 
     it "should be running after being started" do
       subject.start
-      subject.status.should == :running
+      expect(subject.status).to eq(:running)
     end
 
     it "should invoke the stop command when asked" do
       subject.start
-      subject.status.should == :running
+      expect(subject.status).to eq(:running)
       subject.stop
-      subject.status.should == :stopped
-      File.should_not be_file(flag)
+      expect(subject.status).to eq(:stopped)
     end
 
-    it "should start again even if already running" do
-      subject.start
-      subject.expects(:ucommand).with(:start)
+    it "should raise an error if started twice" do
       subject.start
+      expect {subject.start }.to raise_error(Puppet::Error, 'Could not start Service[test]: failed to start')
     end
 
-    it "should stop again even if already stopped" do
-      subject.stop
-      subject.expects(:ucommand).with(:stop)
+    it "should raise an error if stopped twice" do
+      subject.start
       subject.stop
+      expect {subject.stop }.to raise_error(Puppet::Error, 'Could not stop Service[test]: failed to stop')
     end
   end
 end

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

@@ -7,6 +7,7 @@ describe provider_class do
   before :each do
     @provider = provider_class.new
     @provider.stubs(:initscript)
+    Facter.stubs(:value).with(:osfamily).returns 'FreeBSD'
   end
 
   it "should correctly parse rcvar for FreeBSD < 7" do

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

@@ -9,6 +9,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     FileTest.stubs(:file?).with('/sbin/rc-update').returns true
     FileTest.stubs(:executable?).with('/sbin/rc-update').returns true
     Facter.stubs(:value).with(:operatingsystem).returns 'Gentoo'
+    Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
 
     # The initprovider (parent of the gentoo provider) does a stat call
     # before it even tries to execute an initscript. We use sshd in all the

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

@@ -208,5 +208,23 @@ describe Puppet::Type.type(:service).provider(:init) do
         provider.restart
       end
     end
+
+    describe "when starting a service on Solaris" do
+      it "should use ctrun" do
+        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        provider.expects(:execute).with('/usr/bin/ctrun -l none /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        provider.start
+      end
+    end
+
+    describe "when starting a service on RedHat" do
+      it "should not use ctrun" do
+        Facter.stubs(:value).with(:osfamily).returns 'RedHat'
+        provider.expects(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        provider.start
+      end
+    end
   end
 end

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

@@ -10,6 +10,7 @@ describe provider_class do
   before :each do
     Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
     Facter.stubs(:value).with(:operatingsystem).returns :openbsd
+    Facter.stubs(:value).with(:osfamily).returns 'OpenBSD'
   end
 
   let :rcscripts do

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

@@ -20,6 +20,7 @@ describe provider_class, :as_platform => :posix do
     FileTest.stubs(:file?).with('/sbin/service').returns true
     FileTest.stubs(:executable?).with('/sbin/service').returns true
     Facter.stubs(:value).with(:operatingsystem).returns('CentOS')
+    Facter.stubs(:value).with(:osfamily).returns 'RedHat'
   end
 
   osfamily = [ 'RedHat', 'Suse' ]

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

@@ -119,6 +119,19 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
+
+    it "should fail with an actionable message when trying to create an active directory user" do
+      resource[:name] = 'DOMAIN\testdomainuser'
+      Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
+      connection.expects(:Create)
+      connection.expects(:SetPassword)
+      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(
+        Puppet::Error,
+        /not able to create\/delete domain users/
+      )
+    end
   end
 
   it 'should be able to test whether a user exists' do
@@ -136,6 +149,14 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     provider.delete
   end
 
+  it 'should not run commit on a deleted user' do
+    connection.expects(:Delete).with('user', 'testuser')
+    connection.expects(:SetInfo).never
+
+    provider.delete
+    provider.flush
+  end
+
   it 'should delete the profile if managehome is set' do
     resource[:managehome] = true
 

data/spec/unit/provider/zpool/zpool_spec.rb

@@ -171,20 +171,57 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
   end
 
   context '#create' do
-    before do
-      resource[:disk] = "disk1"
+    context "when creating disks for a zpool" do
+      before do
+        resource[:disk] = "disk1"
+      end
+
+      it "should call create with the build_vdevs value" do
+        provider.expects(:zpool).with(:create, name, 'disk1')
+        provider.create
+      end
+
+      it "should call create with the 'spares' and 'log' values" do
+        resource[:spare] = ['value1']
+        resource[:log] = ['value2']
+        provider.expects(:zpool).with(:create, name, 'disk1', 'spare', 'value1', 'log', 'value2')
+        provider.create
+      end
     end
 
-    it "should call create with the build_vdevs value" do
-      provider.expects(:zpool).with(:create, name, 'disk1')
-      provider.create
+    context "when creating mirrors for a zpool" do
+      it "executes 'create' for a single group of mirrored devices" do
+        resource[:mirror] = ["disk1 disk2"]
+        provider.expects(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2')
+        provider.create
+      end
+
+      it "repeats the 'mirror' keyword between groups of mirrored devices" do
+        resource[:mirror] = ["disk1 disk2", "disk3 disk4"]
+        provider.expects(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2', 'mirror', 'disk3', 'disk4')
+        provider.create
+      end
     end
 
-    it "should call create with the 'spares' and 'log' values" do
-      resource[:spare] = ['value1']
-      resource[:log] = ['value2']
-      provider.expects(:zpool).with(:create, name, 'disk1', 'spare', 'value1', 'log', 'value2')
-      provider.create
+    describe "when creating raidz for a zpool" do
+      it "executes 'create' for a single raidz group" do
+        resource[:raidz] = ["disk1 disk2"]
+        provider.expects(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2')
+        provider.create
+      end
+
+      it "execute 'create' for a single raidz2 group" do
+        resource[:raidz] = ["disk1 disk2"]
+        resource[:raid_parity] = 'raidz2'
+        provider.expects(:zpool).with(:create, name, 'raidz2', 'disk1', 'disk2')
+        provider.create
+      end
+
+      it "repeats the 'raidz1' keyword between each group of raidz devices" do
+        resource[:raidz] = ["disk1 disk2", "disk3 disk4"]
+        provider.expects(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2', 'raidz1', 'disk3', 'disk4')
+        provider.create
+      end
     end
   end
 

data/spec/unit/util/log_spec.rb

@@ -93,7 +93,120 @@ describe Puppet::Util::Log do
 
       expect(logs.collect(&:message)).to include("Inner block", "Outer block")
     end
+
+    it 'includes backtrace for RuntimeError in log message when trace is enabled' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default, :trace => true)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to match('/log_spec.rb')
+      expect(log.backtrace).to be_nil
+    end
+
+    it 'excludes backtrace for RuntimeError in log message when trace is disabled' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise RuntimeError, 'Oops'
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match('/log_spec.rb')
+      expect(log.backtrace).to be_nil
+    end
+
+    it "backtrace is Array in 'backtrace' and excluded from 'message' when logging ParseErrorWithIssue with trace enabled" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e, :default, :trace => true)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match('/log_spec.rb')
+      expect(log.backtrace).to be_a(Array)
+    end
+
+    it "backtrace is excluded when logging ParseErrorWithIssue with trace disabled" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match('/log_spec.rb')
+      expect(log.backtrace).to be_nil
+    end
+
+    it 'includes position details for ParseError in log message' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseError.new('Oops', '/tmp/test.pp', 30, 15)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.message).to be(log.to_s)
+    end
+
+    it 'excludes position details for ParseErrorWithIssue from log message' do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        begin
+          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
+        rescue RuntimeError => e
+          Puppet.log_exception(e)
+        end
+      end
+      expect(logs.size).to eq(1)
+      log = logs[0]
+      expect(log.message).to_not match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.to_s).to match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.issue_code).to eq(:SYNTAX_ERROR)
+      expect(log.file).to eq('/tmp/test.pp')
+      expect(log.line).to eq(30)
+      expect(log.pos).to eq(15)
+    end
   end
+
   describe Puppet::Util::Log::DestConsole do
     before do
       @console = Puppet::Util::Log::DestConsole.new

data/spec/unit/util/windows/adsi_spec.rb

@@ -315,38 +315,118 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
         group.members.should =~ names
       end
 
-      it "should be able to add a list of users to a group" do
-        names = ['DOMAIN\user1', 'user2']
-        sids = [
-          stub(:account => 'user1', :domain => 'DOMAIN'),
-          stub(:account => 'user2', :domain => 'testcomputername'),
-          stub(:account => 'user3', :domain => 'DOMAIN2'),
-        ]
+      context "calling .set_members" do
+        it "should set the members of a group to only desired_members when inclusive" do
+          names = ['DOMAIN\user1', 'user2']
+          sids = [
+              stub(:account => 'user1', :domain => 'DOMAIN'),
+              stub(:account => 'user2', :domain => 'testcomputername'),
+              stub(:account => 'user3', :domain => 'DOMAIN2'),
+          ]
 
-        # use stubbed objectSid on member to return stubbed SID
-        Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
-        Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
+          # use stubbed objectSid on member to return stubbed SID
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
-        Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
-        Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
 
-        Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
-        Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
+          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
+          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
 
-        members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
-        adsi_group.expects(:Members).returns members
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
+          adsi_group.expects(:Members).returns members
 
-        adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
-        adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
+          adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
+          adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
 
-        group.set_members(['user2', 'DOMAIN2\user3'])
-      end
+          group.set_members(['user2', 'DOMAIN2\user3'])
+        end
 
-      it "should raise an error when a username does not resolve to a SID" do
-        expect {
-          adsi_group.expects(:Members).returns []
-          group.set_members(['foobar'])
-        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
+        it "should add the desired_members to an existing group when not inclusive" do
+          names = ['DOMAIN\user1', 'user2']
+          sids = [
+              stub(:account => 'user1', :domain => 'DOMAIN'),
+              stub(:account => 'user2', :domain => 'testcomputername'),
+              stub(:account => 'user3', :domain => 'DOMAIN2'),
+          ]
+
+          # use stubbed objectSid on member to return stubbed SID
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
+
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(sids[1])
+          Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
+
+          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
+
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
+          adsi_group.expects(:Members).returns members
+
+          adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user').never
+
+          adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
+
+          group.set_members(['user2', 'DOMAIN2\user3'],false)
+        end
+
+        it "should return immediately when desired_members is nil" do
+          adsi_group.expects(:Members).never
+
+          adsi_group.expects(:Remove).never
+          adsi_group.expects(:Add).never
+
+          group.set_members(nil)
+        end
+
+        it "should remove all members when desired_members is empty and inclusive" do
+          names = ['DOMAIN\user1', 'user2']
+          sids = [
+              stub(:account => 'user1', :domain => 'DOMAIN'),
+              stub(:account => 'user2', :domain => 'testcomputername')
+          ]
+
+          # use stubbed objectSid on member to return stubbed SID
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
+
+          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
+          Puppet::Util::Windows::ADSI.expects(:sid_uri).with(sids[1]).returns("WinNT://testcomputername/user2,user")
+
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
+          adsi_group.expects(:Members).returns members
+
+          adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
+          adsi_group.expects(:Remove).with('WinNT://testcomputername/user2,user')
+
+          group.set_members([])
+        end
+
+        it "should do nothing when desired_members is empty and not inclusive" do
+          names = ['DOMAIN\user1', 'user2']
+          sids = [
+              stub(:account => 'user1', :domain => 'DOMAIN'),
+              stub(:account => 'user2', :domain => 'testcomputername')
+          ]
+          # use stubbed objectSid on member to return stubbed SID
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+          Puppet::Util::Windows::SID.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
+
+          members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
+          adsi_group.expects(:Members).returns members
+
+          adsi_group.expects(:Remove).never
+          adsi_group.expects(:Add).never
+
+          group.set_members([],false)
+        end
+
+        it "should raise an error when a username does not resolve to a SID" do
+          expect {
+            adsi_group.expects(:Members).returns []
+            group.set_members(['foobar'])
+          }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
+        end
       end
 
       it "should generate the correct URI" do
@@ -426,7 +506,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should warn on 2003" do
-      connection.expects(:Delete).raises(RuntimeError,
+      connection.expects(:Delete).raises(WIN32OLERuntimeError,
  "Delete (WIN32OLERuntimeError)
     OLE error code:80041010 in SWbemServicesEx
       Invalid class