puppet 4.1.0 → 4.10.0

data/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb

@@ -1573,6 +1573,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       end
 
       it 'should save the task' do
+        @mock_task.expects(:set_account_information).with(nil, nil)
         @mock_task.expects(:save)
 
         resource.provider.flush
@@ -1846,4 +1847,214 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       resource.provider.create
     end
   end
+
+  describe "Win32::TaskScheduler", :if => Puppet.features.microsoft_windows? do
+
+    let(:name) { SecureRandom.uuid }
+
+    describe 'sets appropriate generic trigger defaults' do
+      before(:each) do
+        @now = Time.now
+        Time.stubs(:now).returns(@now)
+      end
+
+      it 'for a ONCE schedule' do
+        task = Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a DAILY schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::DAILY,
+          'type' => { 'days_interval' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a WEEKLY schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::WEEKLY,
+          'type' => { 'weeks_interval' => 1, 'days_of_week' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a MONTHLYDATE schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::MONTHLYDATE,
+          'type' => { 'days' => 1, 'months' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+
+      it 'for a MONTHLYDOW schedule' do
+        trigger = {
+          'trigger_type' => Win32::TaskScheduler::MONTHLYDOW,
+          'type' => { 'weeks' => 1, 'days_of_week' => 1, 'months' => 1 }
+        }
+        task = Win32::TaskScheduler.new(name, trigger)
+
+        expect(task.trigger(0)['start_year']).to eq(@now.year)
+        expect(task.trigger(0)['start_month']).to eq(@now.month)
+        expect(task.trigger(0)['start_day']).to eq(@now.day)
+      end
+    end
+
+    describe 'enforces maximum lengths' do
+      let(:task) { Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE }) }
+
+      it 'on account user name' do
+        expect {
+          task.set_account_information('a' * (Win32::TaskScheduler::MAX_ACCOUNT_LENGTH + 1), 'pass')
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on application name' do
+        expect {
+          task.application_name = 'a' * (Win32::TaskScheduler::MAX_PATH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on parameters' do
+        expect {
+          task.parameters = 'a' * (Win32::TaskScheduler::MAX_PARAMETERS_LENGTH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on working directory' do
+        expect {
+          task.working_directory = 'a' * (Win32::TaskScheduler::MAX_PATH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on comment' do
+        expect {
+          task.comment = 'a' * (Win32::TaskScheduler::MAX_COMMENT_LENGTH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+
+      it 'on creator' do
+        expect {
+          task.creator = 'a' * (Win32::TaskScheduler::MAX_ACCOUNT_LENGTH + 1)
+        }.to raise_error(Puppet::Error)
+      end
+    end
+
+    def delete_task_with_retry(task, name, attempts = 3)
+      failed = false
+
+      attempts.times do
+        begin
+          task.delete(name) if Win32::TaskScheduler.new.exists?(name)
+        rescue Puppet::Util::Windows::Error
+          failed = true
+        end
+
+        if failed then sleep 1 else break end
+      end
+    end
+
+    describe '#exists?' do
+      it 'works with Unicode task names' do
+        task_name = name + "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+
+        begin
+          task = Win32::TaskScheduler.new(task_name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+          task.save()
+
+          expect(Puppet::FileSystem.exist?("C:\\Windows\\Tasks\\#{task_name}.job")).to be_truthy
+          expect(task.exists?(task_name)).to be_truthy
+        ensure
+          delete_task_with_retry(task, task_name)
+        end
+      end
+
+      it 'is case insensitive' do
+        task_name = name + 'abc' # name is a guid, but might not have alpha chars
+
+        begin
+          task = Win32::TaskScheduler.new(task_name.upcase, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+          task.save()
+
+          expect(task.exists?(task_name.downcase)).to be_truthy
+        ensure
+          delete_task_with_retry(task, task_name)
+        end
+      end
+    end
+
+    describe 'does not corrupt tasks' do
+      it 'when setting maximum length values for all settings' do
+        begin
+          task = Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+
+          application_name = 'a' * Win32::TaskScheduler::MAX_PATH
+          parameters = 'b' * Win32::TaskScheduler::MAX_PARAMETERS_LENGTH
+          working_directory = 'c' * Win32::TaskScheduler::MAX_PATH
+          comment = 'd' * Win32::TaskScheduler::MAX_COMMENT_LENGTH
+          creator = 'e' * Win32::TaskScheduler::MAX_ACCOUNT_LENGTH
+
+          task.application_name = application_name
+          task.parameters = parameters
+          task.working_directory = working_directory
+          task.comment = comment
+          task.creator = creator
+
+          # saving and reloading (activating) can induce COM load errors when
+          # file is corrupted, which can happen when the upper bounds of these lengths are set too high
+          task.save()
+          task.activate(name)
+
+          # furthermore, corrupted values may not necessarily be read back properly
+          # note that SYSTEM is always returned as an empty string in account_information
+          expect(task.account_information).to eq('')
+          expect(task.application_name).to eq(application_name)
+          expect(task.parameters).to eq(parameters)
+          expect(task.working_directory).to eq(working_directory)
+          expect(task.comment).to eq(comment)
+          expect(task.creator).to eq(creator)
+        ensure
+          delete_task_with_retry(task, name)
+        end
+      end
+
+      it 'by preventing a save() not preceded by a set_account_information()' do
+        begin
+          # creates a default new task with SYSTEM user
+          task = Win32::TaskScheduler.new(name, { 'trigger_type' => Win32::TaskScheduler::ONCE })
+          # save automatically resets the current task
+          task.save()
+
+          # re-activate named task, try to modify, and save
+          task.activate(name)
+          task.application_name = 'c:/windows/system32/notepad.exe'
+
+          expect { task.save() }.to raise_error(Puppet::Error, /Account information must be set on the current task to save it properly/)
+
+          # on a failed save, the current task is still active - add SYSTEM
+          task.set_account_information('', nil)
+          expect(task.save()).to be_instance_of(Win32::TaskScheduler::COM::Task)
+
+          # the most appropriate additional validation here would be to confirm settings with schtasks.exe
+          # but that test can live inside a system-level acceptance test
+        ensure
+          delete_task_with_retry(task, name)
+        end
+      end
+    end
+  end
 end

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

@@ -17,6 +17,12 @@ describe "base service provider" do
 
   subject { provider }
 
+  if Puppet.features.microsoft_windows?
+    # Get a pid for $CHILD_STATUS to latch on to
+    command = "cmd.exe /c \"exit 0\""
+    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  end
+
   context "basic operations" do
     subject do
       type.new(

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

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:bsd)
+
+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 :netbsd
+    Facter.stubs(:value).with(:osfamily).returns 'NetBSD'
+    described_class.stubs(:defpath).returns('/etc/rc.conf.d')
+    @provider = provider_class.new
+    @provider.stubs(:initscript)
+  end
+
+  describe "#instances" do
+    it "should have an instances method" do
+      expect(described_class).to respond_to :instances
+    end
+
+    it "should use defpath" do
+      expect(described_class.instances).to be_all { |provider| provider.get(:path) == described_class.defpath }
+    end
+  end
+
+  describe "#disable" do
+    it "should have a disable method" do
+      expect(@provider).to respond_to(:disable)
+    end
+
+    it "should remove a service file to disable" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      File.stubs(:delete).with('/etc/rc.conf.d/sshd')
+      provider.disable
+    end
+
+    it "should not remove a service file if it doesn't exist" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      File.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      provider.disable
+    end
+  end
+
+  describe "#enable" do
+    it "should have an enable method" do
+      expect(@provider).to respond_to(:enable)
+    end
+
+    it "should set the proper contents to enable" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      fh = stub 'fh'
+      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
+      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
+      provider.enable
+    end
+
+    it "should set the proper contents to enable when disabled" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
+      fh = stub 'fh'
+      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
+      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
+      provider.enable
+    end
+  end
+
+  describe "#enabled?" do
+    it "should have an enabled? method" do
+      expect(@provider).to respond_to(:enabled?)
+    end
+
+    it "should return false if the service file does not exist" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
+      expect(provider.enabled?).to eq(:false)
+    end
+
+    it "should return true if the service file exists" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"YES\"\n")
+      expect(provider.enabled?).to eq(:true)
+    end
+  end
+
+  describe "#startcmd" do
+    it "should have a startcmd method" do
+      expect(@provider).to respond_to(:startcmd)
+    end
+
+    it "should use the supplied start command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.start
+    end
+
+    it "should start the serviced directly otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.start
+    end
+  end
+
+  describe "#stopcmd" do
+    it "should have a stopcmd method" do
+      expect(@provider).to respond_to(:stopcmd)
+    end
+
+    it "should use the supplied stop command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.stop
+    end
+
+    it "should stop the serviced directly otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.stop
+    end
+  end
+end

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

@@ -9,6 +9,12 @@ provider_class = Puppet::Type.type(:service).provider(:debian)
 
 describe provider_class do
 
+  if Puppet.features.microsoft_windows?
+    # Get a pid for $CHILD_STATUS to latch on to
+    command = "cmd.exe /c \"exit 0\""
+    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  end
+
   before(:each) do
     # Create a mock resource
     @resource = stub 'resource'
@@ -27,19 +33,26 @@ 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)
   end
 
-  operatingsystem = [ 'Debian', 'CumulusLinux' ]
-  operatingsystem.each do |os|
-    it "should be the default provider on #{os}" do
-      Facter.expects(:value).with(:operatingsystem).returns(os)
+  ['1','2'].each do |version|
+    it "should be the default provider on CumulusLinux #{version}" do
+      Facter.expects(:value).with(:operatingsystem).at_least_once.returns('CumulusLinux')
+      Facter.expects(:value).with(:operatingsystemmajrelease).returns(version)
       expect(provider_class.default?).to be_truthy
     end
   end
 
+  it "should be the default provider on Debian" do
+    Facter.expects(:value).with(:operatingsystem).at_least_once.returns('Debian')
+    Facter.expects(:value).with(:operatingsystemmajrelease).returns('7')
+    expect(provider_class.default?).to be_truthy
+  end
+
   it "should have an enabled? method" do
     expect(@provider).to respond_to(:enabled?)
   end
@@ -81,6 +94,7 @@ describe provider_class do
   describe "when checking whether it is enabled" do
     it "should call Kernel.system() with the appropriate parameters" do
       @provider.expects(:system).with("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start").once
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       @provider.enabled?
     end
 
@@ -119,6 +133,14 @@ describe provider_class do
       it_should_behave_like "manually queries service status", 105
     end
 
+    context "when invoke-rc.d exits with 101 status" do
+      it_should_behave_like "manually queries service status", 101
+    end
+
+    context "when invoke-rc.d exits with 105 status" do
+      it_should_behave_like "manually queries service status", 105
+    end
+
     # pick a range of non-[104.106] numbers, strings and booleans to test with.
     [-100, -1, 0, 1, 100, "foo", "", :true, :false].each do |exitstatus|
       it "should return false when invoke-rc.d exits with #{exitstatus} status" do
@@ -129,4 +151,12 @@ describe provider_class do
     end
   end
 
+  describe "when checking service status" do
+    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/freebsd_spec.rb

@@ -44,6 +44,22 @@ OUTPUT
     expect(@provider.rcvar).to eq(['# ntpd', 'ntpd=YES'])
   end
 
+  it 'should parse service names with a description' do
+    @provider.stubs(:execute).returns <<OUTPUT
+# local_unbound : local caching forwarding resolver
+local_unbound_enable="YES"
+OUTPUT
+    expect(@provider.service_name).to eq('local_unbound')
+  end
+
+  it 'should parse service names without a description' do
+    @provider.stubs(:execute).returns <<OUTPUT
+# local_unbound
+local_unbound="YES"
+OUTPUT
+    expect(@provider.service_name).to eq('local_unbound')
+  end
+
   it "should find the right rcvar_value for FreeBSD < 7" do
     @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable=YES'])
 

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

@@ -4,6 +4,12 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:gentoo) do
 
+  if Puppet.features.microsoft_windows?
+    # Get a pid for $CHILD_STATUS to latch on to
+    command = "cmd.exe /c \"exit 0\""
+    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  end
+
   before :each do
     Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
     FileTest.stubs(:file?).with('/sbin/rc-update').returns true
@@ -159,6 +165,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status
       end
 

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

@@ -6,6 +6,13 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:init) do
+
+  if Puppet.features.microsoft_windows?
+    # Get a pid for $CHILD_STATUS to latch on to
+    command = "cmd.exe /c \"exit 0\""
+    Puppet::Util::Execution.execute(command, {:failonfail => false})
+  end
+
   before do
     Puppet::Type.type(:service).defaultprovider = described_class
   end
@@ -39,7 +46,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 +66,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
@@ -147,10 +164,14 @@ describe Puppet::Type.type(:service).provider(:init) do
         expect(provider).to respond_to(method)
       end
       describe "when running #{method}" do
+        before :each do
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
+        end
 
         it "should use any provided explicit command" do
           resource[method] = "/user/specified/command"
           provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+
           provider.send(method)
         end
 
@@ -158,6 +179,7 @@ describe Puppet::Type.type(:service).provider(:init) do
           resource[:hasrestart] = :true
           resource[:hasstatus] = :true
           provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
+
           provider.send(method)
         end
       end
@@ -170,6 +192,7 @@ describe Puppet::Type.type(:service).provider(:init) do
         end
         it "should execute the command" do
           provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           provider.status
         end
         it "should consider the process running if the command returns 0" do