puppet 4.0.0 → 4.9.1

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

@@ -143,12 +143,40 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           })
 
           expect(resource.provider.trigger).to eq([{
-            'start_date' => '2011-9-12',
-            'start_time' => '13:20',
-            'schedule'   => 'daily',
-            'every'      => '2',
-            'enabled'    => true,
-            'index'      => 0,
+            'start_date'       => '2011-9-12',
+            'start_time'       => '13:20',
+            'schedule'         => 'daily',
+            'every'            => '2',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
+          }])
+        end
+
+        it 'should handle a single daily with repeat trigger' do
+          @mock_task.expects(:trigger).with(0).returns({
+            'trigger_type'     => Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY,
+            'start_year'       => 2011,
+            'start_month'      => 9,
+            'start_day'        => 12,
+            'start_hour'       => 13,
+            'start_minute'     => 20,
+            'minutes_interval' => 60,
+            'minutes_duration' => 180,
+            'flags'            => 0,
+            'type'             => { 'days_interval' => 2 },
+          })
+
+          expect(resource.provider.trigger).to eq([{
+            'start_date'       => '2011-9-12',
+            'start_time'       => '13:20',
+            'schedule'         => 'daily',
+            'every'            => '2',
+            'minutes_interval' => 60,
+            'minutes_duration' => 180,
+            'enabled'          => true,
+            'index'            => 0,
           }])
         end
 
@@ -172,13 +200,15 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           })
 
           expect(resource.provider.trigger).to eq([{
-            'start_date'  => '2011-9-12',
-            'start_time'  => '13:20',
-            'schedule'    => 'weekly',
-            'every'       => '2',
-            'day_of_week' => ['sun', 'mon', 'wed', 'fri'],
-            'enabled'     => true,
-            'index'       => 0,
+            'start_date'       => '2011-9-12',
+            'start_time'       => '13:20',
+            'schedule'         => 'weekly',
+            'every'            => '2',
+            'day_of_week'      => ['sun', 'mon', 'wed', 'fri'],
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
           }])
         end
 
@@ -205,13 +235,15 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           })
 
           expect(resource.provider.trigger).to eq([{
-            'start_date' => '2011-9-12',
-            'start_time' => '13:20',
-            'schedule'   => 'monthly',
-            'months'     => [1, 2, 8, 9, 12],
-            'on'         => [1, 3, 5, 15, 'last'],
-            'enabled'    => true,
-            'index'      => 0,
+            'start_date'       => '2011-9-12',
+            'start_time'       => '13:20',
+            'schedule'         => 'monthly',
+            'months'           => [1, 2, 8, 9, 12],
+            'on'               => [1, 3, 5, 15, 'last'],
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
           }])
         end
 
@@ -247,6 +279,8 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'months'           => [1, 2, 8, 9, 12],
             'which_occurrence' => 'first',
             'day_of_week'      => ['sun', 'mon', 'wed', 'fri'],
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
             'enabled'          => true,
             'index'            => 0,
           }])
@@ -264,11 +298,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           })
 
           expect(resource.provider.trigger).to eq([{
-            'start_date' => '2011-9-12',
-            'start_time' => '13:20',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 0,
+            'start_date'       => '2011-9-12',
+            'start_time'       => '13:20',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
           }])
         end
       end
@@ -305,25 +341,98 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
         expect(resource.provider.trigger).to match_array([
           {
-            'start_date' => '2011-10-13',
-            'start_time' => '14:21',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 0,
+            'start_date'       => '2011-10-13',
+            'start_time'       => '14:21',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
+          },
+          {
+            'start_date'       => '2012-11-14',
+            'start_time'       => '15:22',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 1,
+          },
+          {
+            'start_date'       => '2013-12-15',
+            'start_time'       => '16:23',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 2,
+          }
+        ])
+      end
+
+      it 'should handle multiple triggers with repeat triggers' do
+        @mock_task.expects(:trigger_count).returns(3)
+        @mock_task.expects(:trigger).with(0).returns({
+          'trigger_type'     => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
+          'start_year'       => 2011,
+          'start_month'      => 10,
+          'start_day'        => 13,
+          'start_hour'       => 14,
+          'start_minute'     => 21,
+          'minutes_interval' => 15,
+          'minutes_duration' => 60,
+          'flags'            => 0,
+        })
+        @mock_task.expects(:trigger).with(1).returns({
+          'trigger_type'     => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
+          'start_year'       => 2012,
+          'start_month'      => 11,
+          'start_day'        => 14,
+          'start_hour'       => 15,
+          'start_minute'     => 22,
+          'minutes_interval' => 30,
+          'minutes_duration' => 120,
+          'flags'            => 0,
+        })
+        @mock_task.expects(:trigger).with(2).returns({
+          'trigger_type'     => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
+          'start_year'       => 2013,
+          'start_month'      => 12,
+          'start_day'        => 15,
+          'start_hour'       => 16,
+          'start_minute'     => 23,
+          'minutes_interval' => 60,
+          'minutes_duration' => 240,
+          'flags'            => 0,
+        })
+
+        expect(resource.provider.trigger).to match_array([
+          {
+            'start_date'       => '2011-10-13',
+            'start_time'       => '14:21',
+            'schedule'         => 'once',
+            'minutes_interval' => 15,
+            'minutes_duration' => 60,
+            'enabled'          => true,
+            'index'            => 0,
           },
           {
-            'start_date' => '2012-11-14',
-            'start_time' => '15:22',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 1,
+            'start_date'       => '2012-11-14',
+            'start_time'       => '15:22',
+            'schedule'         => 'once',
+            'minutes_interval' => 30,
+            'minutes_duration' => 120,
+            'enabled'          => true,
+            'index'            => 1,
           },
           {
-            'start_date' => '2013-12-15',
-            'start_time' => '16:23',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 2,
+            'start_date'       => '2013-12-15',
+            'start_time'       => '16:23',
+            'schedule'         => 'once',
+            'minutes_interval' => 60,
+            'minutes_duration' => 240,
+            'enabled'          => true,
+            'index'            => 2,
           }
         ])
       end
@@ -354,18 +463,22 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
         expect(resource.provider.trigger).to match_array([
           {
-            'start_date' => '2011-10-13',
-            'start_time' => '14:21',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 0,
+            'start_date'       => '2011-10-13',
+            'start_time'       => '14:21',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
           },
           {
-            'start_date' => '2013-12-15',
-            'start_time' => '16:23',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 2,
+            'start_date'       => '2013-12-15',
+            'start_time'       => '16:23',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 2,
           }
         ])
       end
@@ -396,18 +509,22 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
         expect(resource.provider.trigger).to match_array([
           {
-            'start_date' => '2011-10-13',
-            'start_time' => '14:21',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 0,
+            'start_date'       => '2011-10-13',
+            'start_time'       => '14:21',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 0,
           },
           {
-            'start_date' => '2013-12-15',
-            'start_time' => '16:23',
-            'schedule'   => 'once',
-            'enabled'    => true,
-            'index'      => 2,
+            'start_date'       => '2013-12-15',
+            'start_time'       => '16:23',
+            'schedule'         => 'once',
+            'minutes_interval' => 0,
+            'minutes_duration' => 0,
+            'enabled'          => true,
+            'index'            => 2,
           }
         ])
       end
@@ -529,11 +646,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       })
 
       mock_task_trigger = {
-        'start_date' => '2011-10-13',
-        'start_time' => '14:21',
-        'schedule'   => 'once',
-        'enabled'    => true,
-        'index'      => 0,
+        'start_date'       => '2011-10-13',
+        'start_time'       => '14:21',
+        'schedule'         => 'once',
+        'minutes_interval' => 0,
+        'minutes_duration' => 0,
+        'enabled'          => true,
+        'index'            => 0,
       }
 
       expect(resource.provider.trigger).to eq([mock_task_trigger])
@@ -542,11 +661,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       resource.provider.clear_task
 
       expect(resource.provider.trigger).to eq([{
-        'start_date' => '2012-11-14',
-        'start_time' => '15:22',
-        'schedule'   => 'once',
-        'enabled'    => true,
-        'index'      => 0,
+        'start_date'       => '2012-11-14',
+        'start_time'       => '15:22',
+        'schedule'         => 'once',
+        'minutes_interval' => 0,
+        'minutes_duration' => 0,
+        'enabled'          => true,
+        'index'            => 0,
       }])
     end
   end
@@ -1045,6 +1166,127 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     let(:provider) { described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
     let(:trigger)  { provider.translate_hash_to_trigger(@puppet_trigger) }
 
+    context "working with repeat every x triggers" do
+      before :each do
+        @puppet_trigger['schedule'] = 'once'
+      end
+
+      it 'should succeed if minutes_interval is equal to 0' do
+        @puppet_trigger['minutes_interval'] = '0'
+
+        expect(trigger['minutes_interval']).to eq(0)
+      end
+
+      it 'should default minutes_duration to a full day when minutes_interval is greater than 0 without setting minutes_duration' do
+        @puppet_trigger['minutes_interval'] = '1'
+
+        expect(trigger['minutes_duration']).to eq(1440)
+      end
+
+      it 'should succeed if minutes_interval is greater than 0 and minutes_duration is also set' do
+        @puppet_trigger['minutes_interval'] = '1'
+        @puppet_trigger['minutes_duration'] = '2'
+
+        expect(trigger['minutes_interval']).to eq(1)
+      end
+
+      it 'should fail if minutes_interval is less than 0' do
+        @puppet_trigger['minutes_interval'] = '-1'
+
+        expect { trigger }.to raise_error(
+          Puppet::Error,
+          'minutes_interval must be an integer greater or equal to 0'
+        )
+      end
+
+      it 'should fail if minutes_interval is not an integer' do
+        @puppet_trigger['minutes_interval'] = 'abc'
+        expect { trigger }.to raise_error(ArgumentError)
+      end
+
+      it 'should succeed if minutes_duration is equal to 0' do
+        @puppet_trigger['minutes_duration'] = '0'
+        expect(trigger['minutes_duration']).to eq(0)
+      end
+
+      it 'should succeed if minutes_duration is greater than 0' do
+        @puppet_trigger['minutes_duration'] = '1'
+        expect(trigger['minutes_duration']).to eq(1)
+      end
+
+      it 'should fail if minutes_duration is less than 0' do
+        @puppet_trigger['minutes_duration'] = '-1'
+
+        expect { trigger }.to raise_error(
+          Puppet::Error,
+          'minutes_duration must be an integer greater than minutes_interval and equal to or greater than 0'
+        )
+      end
+
+      it 'should fail if minutes_duration is not an integer' do
+        @puppet_trigger['minutes_duration'] = 'abc'
+        expect { trigger }.to raise_error(ArgumentError)
+      end
+
+      it 'should succeed if minutes_duration is equal to a full day' do
+        @puppet_trigger['minutes_duration'] = '1440'
+        expect(trigger['minutes_duration']).to eq(1440)
+      end
+
+      it 'should succeed if minutes_duration is equal to three days' do
+        @puppet_trigger['minutes_duration'] = '4320'
+        expect(trigger['minutes_duration']).to eq(4320)
+      end
+
+      it 'should succeed if minutes_duration is greater than minutes_duration' do
+        @puppet_trigger['minutes_interval'] = '10'
+        @puppet_trigger['minutes_duration'] = '11'
+
+        expect(trigger['minutes_interval']).to eq(10)
+        expect(trigger['minutes_duration']).to eq(11)
+      end
+
+      it 'should fail if minutes_duration is equal to minutes_interval' do
+        # On Windows 2003, the duration must be greater than the interval
+        # on other platforms the values can be equal.
+        @puppet_trigger['minutes_interval'] = '10'
+        @puppet_trigger['minutes_duration'] = '10'
+
+        expect { trigger }.to raise_error(
+          Puppet::Error,
+          'minutes_duration must be an integer greater than minutes_interval and equal to or greater than 0'
+        )
+      end
+
+      it 'should succeed if minutes_duration and minutes_interval are both set to 0' do
+        @puppet_trigger['minutes_interval'] = '0'
+        @puppet_trigger['minutes_duration'] = '0'
+
+        expect(trigger['minutes_interval']).to eq(0)
+        expect(trigger['minutes_duration']).to eq(0)
+      end
+
+      it 'should fail if minutes_duration is less than minutes_interval' do
+        @puppet_trigger['minutes_interval'] = '10'
+        @puppet_trigger['minutes_duration'] = '9'
+
+        expect { trigger }.to raise_error(
+          Puppet::Error,
+          'minutes_duration must be an integer greater than minutes_interval and equal to or greater than 0'
+        )
+      end
+
+      it 'should fail if minutes_duration is less than minutes_interval and set to 0' do
+        @puppet_trigger['minutes_interval'] = '10'
+        @puppet_trigger['minutes_duration'] = '0'
+
+        expect { trigger }.to raise_error(
+          Puppet::Error,
+          'minutes_interval cannot be set without minutes_duration also being set to a number greater than 0'
+        )
+      end
+    end
+
     describe 'when given a one-time trigger' do
       before :each do
         @puppet_trigger['schedule'] = 'once'
@@ -1331,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
@@ -1604,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