puppet 4.0.0-x64-mingw32 → 4.1.0-x64-mingw32

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

@@ -10,39 +10,52 @@ 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 { is_expected.to 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
-      expect(File).not_to be_file(flag)
       subject.start
-      expect(File).to be_file(flag)
     end
 
     it "should be stopped before being started" do
@@ -59,19 +72,17 @@ describe "base service provider" do
       expect(subject.status).to eq(:running)
       subject.stop
       expect(subject.status).to eq(:stopped)
-      expect(File).not_to be_file(flag)
     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/debian_spec.rb

@@ -32,6 +32,14 @@ describe provider_class do
     @provider.stubs(:invoke_rc)
   end
 
+  operatingsystem = [ 'Debian', 'CumulusLinux' ]
+  operatingsystem.each do |os|
+    it "should be the default provider on #{os}" do
+      Facter.expects(:value).with(:operatingsystem).returns(os)
+      expect(provider_class.default?).to be_truthy
+    end
+  end
+
   it "should have an enabled? method" do
     expect(@provider).to respond_to(:enabled?)
   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

@@ -213,5 +213,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, :unless => Puppet.features.microsoft_windows? 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'
     FileTest.stubs(:file?).with('/usr/sbin/rcctl').returns true
     FileTest.stubs(:executable?).with('/usr/sbin/rcctl').returns true
   end

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

@@ -20,6 +20,7 @@ describe provider_class, :if => Puppet.features.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

@@ -35,16 +35,18 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   end
 
   describe "when managing groups" do
-    it 'should return the list of groups as a comma-separated list' do
-      provider.user.stubs(:groups).returns ['group1', 'group2', 'group3']
+    it 'should return the list of groups as an array of strings' do
+      provider.user.stubs(:groups).returns nil
+      groups = {'group1' => nil, 'group2' => nil, 'group3' => nil}
+      Puppet::Util::Windows::ADSI::Group.expects(:name_sid_hash).returns(groups)
 
-      expect(provider.groups).to eq('group1,group2,group3')
+      expect(provider.groups).to eq(groups.keys)
     end
 
-    it "should return absent if there are no groups" do
+    it "should return an empty array if there are no groups" do
       provider.user.stubs(:groups).returns []
 
-      expect(provider.groups).to eq('')
+      expect(provider.groups).to eq([])
     end
 
     it 'should be able to add a user to a set of groups' do
@@ -60,6 +62,112 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     end
   end
 
+  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') }
+
+    before :each do
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group1').returns(group1)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group2').returns(group2)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group3').returns(group3)
+    end
+
+    it "should return true for same lists of members" do
+      expect(provider.groups_insync?(['group1', 'group2'], ['group1', 'group2'])).to be_truthy
+    end
+
+    it "should return true for same lists of unordered members" do
+      expect(provider.groups_insync?(['group1', 'group2'], ['group2', 'group1'])).to be_truthy
+    end
+
+    it "should return true for same lists of members irrespective of duplicates" do
+      expect(provider.groups_insync?(['group1', 'group2', 'group2'], ['group2', 'group1', 'group1'])).to be_truthy
+    end
+
+    it "should return true when current group(s) and should group(s) are empty lists" do
+      expect(provider.groups_insync?([], [])).to be_truthy
+    end
+
+    it "should return true when current groups is empty and should groups is nil" do
+      expect(provider.groups_insync?([], nil)).to be_truthy
+    end
+
+    context "when membership => inclusive" do
+      before :each do
+        resource[:membership] = :inclusive
+      end
+
+      it "should return false when current contains different groups than should" do
+        expect(provider.groups_insync?(['group1'], ['group2'])).to be_falsey
+      end
+
+      it "should return false when current is nil" do
+        expect(provider.groups_insync?(nil, ['group2'])).to be_falsey
+      end
+
+      it "should return false when should is nil" do
+        expect(provider.groups_insync?(['group1'], nil)).to be_falsey
+      end
+
+      it "should return false when current contains members and should is empty" do
+        expect(provider.groups_insync?(['group1'], [])).to be_falsey
+      end
+
+      it "should return false when current is empty and should contains members" do
+        expect(provider.groups_insync?([], ['group2'])).to be_falsey
+      end
+
+      it "should return false when should groups(s) are not the only items in the current" do
+        expect(provider.groups_insync?(['group1', 'group2'], ['group1'])).to be_falsey
+      end
+
+      it "should return false when current group(s) is not empty and should is an empty list" do
+        expect(provider.groups_insync?(['group1','group2'], [])).to be_falsey
+      end
+    end
+
+    context "when membership => minimum" do
+      before :each do
+        # this is also the default
+        resource[:membership] = :minimum
+      end
+
+      it "should return false when current contains different groups than should" do
+        expect(provider.groups_insync?(['group1'], ['group2'])).to be_falsey
+      end
+
+      it "should return false when current is nil" do
+        expect(provider.groups_insync?(nil, ['group2'])).to be_falsey
+      end
+
+      it "should return true when should is nil" do
+        expect(provider.groups_insync?(['group1'], nil)).to be_truthy
+      end
+
+      it "should return true when current contains members and should is empty" do
+        expect(provider.groups_insync?(['group1'], [])).to be_truthy
+      end
+
+      it "should return false when current is empty and should contains members" do
+        expect(provider.groups_insync?([], ['group2'])).to be_falsey
+      end
+
+      it "should return true when current group(s) contains at least the should list" do
+        expect(provider.groups_insync?(['group1','group2'], ['group1'])).to be_truthy
+      end
+
+      it "should return true when current group(s) is not empty and should is an empty list" do
+        expect(provider.groups_insync?(['group1','group2'], [])).to be_truthy
+      end
+
+      it "should return true when current group(s) contains at least the should list, even unordered" do
+        expect(provider.groups_insync?(['group3','group1','group2'], ['group2','group1'])).to be_truthy
+      end
+    end
+  end
+
   describe "when creating a user" do
     it "should create the user on the system and set its other properties" do
       resource[:groups]     = ['group1', 'group2']
@@ -119,6 +227,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 +257,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/settings_spec.rb

@@ -118,6 +118,17 @@ describe Puppet::Settings do
 
       expect(@settings.preferred_run_mode).to eq(:master)
     end
+
+    it "creates ancestor directories for all required app settings" do
+      # initialize_app_defaults is called in spec_helper, before we even
+      # get here, but call it here to make it explicit what we're trying
+      # to do.
+      @settings.initialize_app_defaults(default_values)
+
+      Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
+        expect(File).to exist(File.dirname(Puppet[key]))
+      end
+    end
   end
 
   describe "#call_hooks_deferred_to_application_initialization" do

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