puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -21,27 +21,27 @@ describe provider_class do
 
   it "should have an install method" do
     @provider = provider_class.new
-    @provider.should respond_to(:install)
+    expect(@provider).to respond_to(:install)
   end
 
   it "should have an uninstall method" do
     @provider = provider_class.new
-    @provider.should respond_to(:uninstall)
+    expect(@provider).to respond_to(:uninstall)
   end
 
   it "should have an update method" do
     @provider = provider_class.new
-    @provider.should respond_to(:update)
+    expect(@provider).to respond_to(:update)
   end
 
   it "should have a latest method" do
     @provider = provider_class.new
-    @provider.should respond_to(:latest)
+    expect(@provider).to respond_to(:latest)
   end
 
   it "should have a install_options method" do
     @provider = provider_class.new
-    @provider.should respond_to(:install_options)
+    expect(@provider).to respond_to(:install_options)
   end
 
   describe "when installing with zypper version >= 1.0" do
@@ -80,7 +80,7 @@ describe provider_class do
       @resource.stubs(:should).with(:ensure).returns :latest
       @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "0.6.104"
-      @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
+      @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', 'mypackage')
       @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
@@ -101,7 +101,7 @@ describe provider_class do
       @resource.stubs(:should).with(:ensure).returns :latest
       @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "0.6.13"
-      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
+      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', '--name', 'mypackage')
       @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
@@ -120,28 +120,17 @@ describe provider_class do
 
       @resource.stubs(:[]).with(:name).returns "at"
       @provider.expects(:zypper).with("list-updates").returns fake_data
-      @provider.latest.should == "3.1.8-1069.18.2"
+      expect(@provider.latest).to eq("3.1.8-1069.18.2")
     end
   end
 
-  describe "should install a virtual package" do
-    it "when zypper version = 0.6.13" do
-      @resource.stubs(:should).with(:ensure).returns :installed
-      @resource.stubs(:allow_virtual?).returns true
-      @provider.stubs(:zypper_version).returns "0.6.13"
-      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
-      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
-      @provider.install
-    end
-
-    it "when zypper version >= 1.0.0" do
-      @resource.stubs(:should).with(:ensure).returns :installed
-      @resource.stubs(:allow_virtual?).returns true
-      @provider.stubs(:zypper_version).returns "1.2.8"
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
-      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
-      @provider.install
-    end
+  it "should install a virtual package" do
+    @resource.stubs(:should).with(:ensure).returns :installed
+    @resource.stubs(:allow_virtual?).returns true
+    @provider.stubs(:zypper_version).returns "0.6.13"
+    @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
+    @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
+    @provider.install
   end
 
   describe "when installing with zypper install options" do
@@ -152,8 +141,8 @@ describe provider_class do
       @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "1.2.8"
 
-      @provider.expects(:zypper).with('--quiet', '--no-gpg-check', :install,
-        '--auto-agree-with-licenses', '--no-confirm', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
+      @provider.expects(:zypper).with('--quiet', :install,
+        '--auto-agree-with-licenses', '--no-confirm', '--no-gpg-check', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
       @provider.expects(:query).returns "php5 0 5.4.10 4.5.6 x86_64"
       @provider.install
     end
@@ -165,7 +154,7 @@ describe provider_class do
       @resource.stubs(:allow_virtual?).returns false
 
       @provider.stubs(:zypper_version).returns '1.2.8'
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a=foo', '--b="quoted bar"', '--name', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', '--a=foo', '--b="quoted bar"', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
@@ -177,7 +166,7 @@ describe provider_class do
       @resource.stubs(:allow_virtual?).returns false
 
       @provider.stubs(:zypper_version).returns '1.2.8'
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a', '--b', '--c', '--name', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', '--a', '--b', '--c', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
@@ -189,7 +178,7 @@ describe provider_class do
       @resource.stubs(:allow_virtual?).returns false
 
       @provider.stubs(:zypper_version).returns '1.2.8'
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a --b --c', '--name', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', '--a --b --c', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end

data/spec/unit/provider/parsedfile_spec.rb

@@ -25,7 +25,7 @@ describe Puppet::Provider::ParsedFile do
 
   describe "when looking up records loaded from disk" do
     it "should return nil if no records have been loaded" do
-      provider.record?("foo").should be_nil
+      expect(provider.record?("foo")).to be_nil
     end
   end
 
@@ -44,7 +44,7 @@ describe Puppet::Provider::ParsedFile do
         provider.expects(:new).with(inst).returns(results[-1])
       end
 
-      provider.instances.should == results
+      expect(provider.instances).to eq(results)
     end
 
     it "should ignore target when retrieve fails" do
@@ -65,7 +65,7 @@ describe Puppet::Provider::ParsedFile do
       provider.expects(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).returns 'r3'
       provider.expects(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).returns 'r4'
 
-      provider.instances.should == %w{r1 r2 r3 r4}
+      expect(provider.instances).to eq(%w{r1 r2 r3 r4})
     end
 
     it "should skip specified records" do
@@ -90,12 +90,12 @@ describe Puppet::Provider::ParsedFile do
 
     it "returns a resource if the record name matches the resource name" do
       record = {:name => :one}
-      provider.resource_for_record(record, resources).should be first_resource
+      expect(provider.resource_for_record(record, resources)).to be first_resource
     end
 
     it "doesn't return a resource if the record name doesn't match any resource names" do
       record = {:name => :three}
-      provider.resource_for_record(record, resources).should be_nil
+      expect(provider.resource_for_record(record, resources)).to be_nil
     end
   end
 
@@ -198,8 +198,8 @@ describe "A very basic provider based on ParsedFile" do
   context "writing file contents back to disk" do
     it "should not change anything except from adding a header" do
       input_records = provider.parse(input_text)
-      provider.to_file(input_records).
-        should match provider.header + input_text
+      expect(provider.to_file(input_records)).
+        to match provider.header + input_text
     end
   end
 
@@ -212,7 +212,7 @@ describe "A very basic provider based on ParsedFile" do
     end
 
     it "should move the native header to the top" do
-      provider.to_file(input_records).should_not match /\A#{provider.header}/
+      expect(provider.to_file(input_records)).not_to match /\A#{provider.header}/
     end
 
     context "and dropping native headers found in input" do
@@ -221,7 +221,7 @@ describe "A very basic provider based on ParsedFile" do
       end
 
       it "should not include the native header in the output" do
-        provider.to_file(input_records).should_not match regex
+        expect(provider.to_file(input_records)).not_to match regex
       end
     end
   end

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

@@ -31,11 +31,11 @@ shared_examples_for "a trigger that handles start_date and start_time" do
     it 'should be able to be specified in ISO 8601 calendar date format' do
       trigger_hash['start_date'] = '2011-12-31'
 
-      date_component.should == {
+      expect(date_component).to eq({
         'start_year'  => 2011,
         'start_month' => 12,
         'start_day'   => 31
-      }
+      })
     end
 
     it 'should fail if before 1753-01-01' do
@@ -50,21 +50,21 @@ shared_examples_for "a trigger that handles start_date and start_time" do
     it 'should succeed if on 1753-01-01' do
       trigger_hash['start_date'] = '1753-01-01'
 
-      date_component.should == {
+      expect(date_component).to eq({
         'start_year'  => 1753,
         'start_month' => 1,
         'start_day'   => 1
-      }
+      })
     end
 
     it 'should succeed if after 1753-01-01' do
       trigger_hash['start_date'] = '1753-01-02'
 
-      date_component.should == {
+      expect(date_component).to eq({
         'start_year'  => 1753,
         'start_month' => 1,
         'start_day'   => 2
-      }
+      })
     end
   end
 
@@ -83,28 +83,28 @@ shared_examples_for "a trigger that handles start_date and start_time" do
     it 'should be able to be specified as a 24-hour "hh:mm"' do
       trigger_hash['start_time'] = '17:13'
 
-      time_component.should == {
+      expect(time_component).to eq({
         'start_hour'   => 17,
         'start_minute' => 13
-      }
+      })
     end
 
     it 'should be able to be specified as a 12-hour "hh:mm am"' do
       trigger_hash['start_time'] = '3:13 am'
 
-      time_component.should == {
+      expect(time_component).to eq({
         'start_hour'   => 3,
         'start_minute' => 13
-      }
+      })
     end
 
     it 'should be able to be specified as a 12-hour "hh:mm pm"' do
       trigger_hash['start_time'] = '3:13 pm'
 
-      time_component.should == {
+      expect(time_component).to eq({
         'start_hour'   => 15,
         'start_minute' => 13
-      }
+      })
     end
   end
 end
@@ -116,7 +116,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
   describe 'when retrieving' do
     before :each do
-      @mock_task = mock
+      @mock_task = stub
       @mock_task.responds_like(Win32::TaskScheduler.new)
       described_class.any_instance.stubs(:task).returns(@mock_task)
 
@@ -142,41 +142,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'type'         => { 'days_interval' => 2 },
           })
 
-          resource.provider.trigger.should == [{
-            '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,
+            'start_date' => '2011-9-12',
+            'start_time' => '13:20',
+            'schedule'   => 'daily',
+            'every'      => '2',
+            'enabled'    => true,
+            'index'      => 0,
           }])
         end
 
@@ -199,17 +171,15 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             }
           })
 
-          resource.provider.trigger.should == [{
-            '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,
-          }]
+          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,
+          }])
         end
 
         it 'should handle a single monthly date-based trigger' do
@@ -234,17 +204,15 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             }
           })
 
-          resource.provider.trigger.should == [{
-            '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,
-          }]
+          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,
+          }])
         end
 
         it 'should handle a single monthly day-of-week-based trigger' do
@@ -272,18 +240,16 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             }
           })
 
-          resource.provider.trigger.should == [{
+          expect(resource.provider.trigger).to eq([{
             'start_date'       => '2011-9-12',
             'start_time'       => '13:20',
             'schedule'         => 'monthly',
             '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,
-          }]
+          }])
         end
 
         it 'should handle a single one-time trigger' do
@@ -297,15 +263,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'flags'        => 0,
           })
 
-          resource.provider.trigger.should == [{
-            'start_date'       => '2011-9-12',
-            'start_time'       => '13:20',
-            'schedule'         => 'once',
-            'minutes_interval' => 0,
-            'minutes_duration' => 0,
-            'enabled'          => true,
-            'index'            => 0,
-          }]
+          expect(resource.provider.trigger).to eq([{
+            'start_date' => '2011-9-12',
+            'start_time' => '13:20',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 0,
+          }])
         end
       end
 
@@ -339,100 +303,27 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'flags'        => 0,
         })
 
-        resource.provider.trigger.should =~ [
-          {
-            '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' => '2011-10-13',
+            'start_time' => '14:21',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 0,
           },
           {
-            'start_date'       => '2012-11-14',
-            'start_time'       => '15:22',
-            'schedule'         => 'once',
-            'minutes_interval' => 30,
-            'minutes_duration' => 120,
-            'enabled'          => true,
-            'index'            => 1,
+            'start_date' => '2012-11-14',
+            'start_time' => '15:22',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 1,
           },
           {
-            'start_date'       => '2013-12-15',
-            'start_time'       => '16:23',
-            'schedule'         => 'once',
-            'minutes_interval' => 60,
-            'minutes_duration' => 240,
-            'enabled'          => true,
-            'index'            => 2,
+            'start_date' => '2013-12-15',
+            'start_time' => '16:23',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 2,
           }
         ])
       end
@@ -461,26 +352,22 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'flags'        => 0,
         })
 
-        resource.provider.trigger.should =~ [
+        expect(resource.provider.trigger).to match_array([
           {
-            'start_date'       => '2011-10-13',
-            'start_time'       => '14:21',
-            'schedule'         => 'once',
-            'minutes_interval' => 0,
-            'minutes_duration' => 0,
-            'enabled'          => true,
-            'index'            => 0,
+            'start_date' => '2011-10-13',
+            'start_time' => '14:21',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 0,
           },
           {
-            'start_date'       => '2013-12-15',
-            'start_time'       => '16:23',
-            'schedule'         => 'once',
-            'minutes_interval' => 0,
-            'minutes_duration' => 0,
-            'enabled'          => true,
-            'index'            => 2,
+            'start_date' => '2013-12-15',
+            'start_time' => '16:23',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 2,
           }
-        ]
+        ])
       end
 
       it 'should skip trigger types Puppet does not handle' do
@@ -507,64 +394,60 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'flags'        => 0,
         })
 
-        resource.provider.trigger.should =~ [
+        expect(resource.provider.trigger).to match_array([
           {
-            'start_date'       => '2011-10-13',
-            'start_time'       => '14:21',
-            'schedule'         => 'once',
-            'minutes_interval' => 0,
-            'minutes_duration' => 0,
-            'enabled'          => true,
-            'index'            => 0,
+            'start_date' => '2011-10-13',
+            'start_time' => '14:21',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 0,
           },
           {
-            'start_date'       => '2013-12-15',
-            'start_time'       => '16:23',
-            'schedule'         => 'once',
-            'minutes_interval' => 0,
-            'minutes_duration' => 0,
-            'enabled'          => true,
-            'index'            => 2,
+            'start_date' => '2013-12-15',
+            'start_time' => '16:23',
+            'schedule'   => 'once',
+            'enabled'    => true,
+            'index'      => 2,
           }
-        ]
+        ])
       end
     end
 
     it 'should get the working directory from the working_directory on the task' do
       @mock_task.expects(:working_directory).returns('C:\Windows\System32')
 
-      resource.provider.working_dir.should == 'C:\Windows\System32'
+      expect(resource.provider.working_dir).to eq('C:\Windows\System32')
     end
 
     it 'should get the command from the application_name on the task' do
       @mock_task.expects(:application_name).returns('C:\Windows\System32\notepad.exe')
 
-      resource.provider.command.should == 'C:\Windows\System32\notepad.exe'
+      expect(resource.provider.command).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should get the command arguments from the parameters on the task' do
       @mock_task.expects(:parameters).returns('these are my arguments')
 
-      resource.provider.arguments.should == 'these are my arguments'
+      expect(resource.provider.arguments).to eq('these are my arguments')
     end
 
     it 'should get the user from the account_information on the task' do
       @mock_task.expects(:account_information).returns('this is my user')
 
-      resource.provider.user.should == 'this is my user'
+      expect(resource.provider.user).to eq('this is my user')
     end
 
     describe 'whether the task is enabled' do
       it 'should report tasks with the disabled bit set as disabled' do
         @mock_task.stubs(:flags).returns(Win32::TaskScheduler::DISABLED)
 
-        resource.provider.enabled.should == :false
+        expect(resource.provider.enabled).to eq(:false)
       end
 
       it 'should report tasks without the disabled bit set as enabled' do
         @mock_task.stubs(:flags).returns(~Win32::TaskScheduler::DISABLED)
 
-        resource.provider.enabled.should == :true
+        expect(resource.provider.enabled).to eq(:true)
       end
 
       it 'should not consider triggers for determining if the task is enabled' do
@@ -580,14 +463,14 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'flags'        => Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED,
         })
 
-        resource.provider.enabled.should == :true
+        expect(resource.provider.enabled).to eq(:true)
       end
     end
   end
 
   describe '#exists?' do
     before :each do
-      @mock_task = mock
+      @mock_task = stub
       @mock_task.responds_like(Win32::TaskScheduler.new)
       described_class.any_instance.stubs(:task).returns(@mock_task)
 
@@ -598,14 +481,14 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     it "should delegate to Win32::TaskScheduler using the resource's name" do
       @mock_task.expects(:exists?).with('Test Task').returns(true)
 
-      resource.provider.exists?.should == true
+      expect(resource.provider.exists?).to eq(true)
     end
   end
 
   describe '#clear_task' do
     before :each do
-      @mock_task     = mock
-      @new_mock_task = mock
+      @mock_task     = stub
+      @new_mock_task = stub
       @mock_task.responds_like(Win32::TaskScheduler.new)
       @new_mock_task.responds_like(Win32::TaskScheduler.new)
       Win32::TaskScheduler.stubs(:new).returns(@mock_task, @new_mock_task)
@@ -615,12 +498,12 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     let(:resource) { Puppet::Type.type(:scheduled_task).new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
 
     it 'should clear the cached task object' do
-      resource.provider.task.should == @mock_task
-      resource.provider.task.should == @mock_task
+      expect(resource.provider.task).to eq(@mock_task)
+      expect(resource.provider.task).to eq(@mock_task)
 
       resource.provider.clear_task
 
-      resource.provider.task.should == @new_mock_task
+      expect(resource.provider.task).to eq(@new_mock_task)
     end
 
     it 'should clear the cached list of triggers for the task' do
@@ -646,29 +529,25 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       })
 
       mock_task_trigger = {
-        'start_date'       => '2011-10-13',
-        'start_time'       => '14:21',
-        'schedule'         => 'once',
-        'minutes_interval' => 0,
-        'minutes_duration' => 0,
-        'enabled'          => true,
-        'index'            => 0,
+        'start_date' => '2011-10-13',
+        'start_time' => '14:21',
+        'schedule'   => 'once',
+        'enabled'    => true,
+        'index'      => 0,
       }
 
-      resource.provider.trigger.should == [mock_task_trigger]
-      resource.provider.trigger.should == [mock_task_trigger]
+      expect(resource.provider.trigger).to eq([mock_task_trigger])
+      expect(resource.provider.trigger).to eq([mock_task_trigger])
 
       resource.provider.clear_task
 
-      resource.provider.trigger.should == [{
-        'start_date'       => '2012-11-14',
-        'start_time'       => '15:22',
-        'schedule'         => 'once',
-        'minutes_interval' => 0,
-        'minutes_duration' => 0,
-        'enabled'          => true,
-        'index'            => 0,
-      }]
+      expect(resource.provider.trigger).to eq([{
+        'start_date' => '2012-11-14',
+        'start_time' => '15:22',
+        'schedule'   => 'once',
+        'enabled'    => true,
+        'index'      => 0,
+      }])
     end
   end
 
@@ -692,27 +571,27 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     it 'should consider the user as in sync if the name matches' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('joe').twice.returns('SID A')
 
-      resource.should be_user_insync('joe', ['joe'])
+      expect(resource).to be_user_insync('joe', ['joe'])
     end
 
     it 'should consider the user as in sync if the current user is fully qualified' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('joe').returns('SID A')
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('MACHINE\joe').returns('SID A')
 
-      resource.should be_user_insync('MACHINE\joe', ['joe'])
+      expect(resource).to be_user_insync('MACHINE\joe', ['joe'])
     end
 
     it 'should consider a current user of the empty string to be the same as the system user' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('system').twice.returns('SYSTEM SID')
 
-      resource.should be_user_insync('', ['system'])
+      expect(resource).to be_user_insync('', ['system'])
     end
 
     it 'should consider different users as being different' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('joe').returns('SID A')
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('bob').returns('SID B')
 
-      resource.should_not be_user_insync('joe', ['bob'])
+      expect(resource).not_to be_user_insync('joe', ['bob'])
     end
   end
 
@@ -726,7 +605,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       ]
       desired = {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'}
 
-      resource.should_not be_trigger_insync(current, desired)
+      expect(resource).not_to be_trigger_insync(current, desired)
     end
 
     it 'should not consider any extra desired triggers as in sync' do
@@ -736,7 +615,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         {'start_date' => '2012-10-13', 'start_time' => '16:16', 'schedule' => 'once'}
       ]
 
-      resource.should_not be_trigger_insync(current, desired)
+      expect(resource).not_to be_trigger_insync(current, desired)
     end
 
     it 'should consider triggers to be in sync if the sets of current and desired triggers are equal' do
@@ -749,7 +628,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         {'start_date' => '2012-10-13', 'start_time' => '16:16', 'schedule' => 'once'}
       ]
 
-      resource.should be_trigger_insync(current, desired)
+      expect(resource).to be_trigger_insync(current, desired)
     end
   end
 
@@ -784,14 +663,14 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       current = {'schedule' => 'once', 'enabled' => false}
       desired = {'schedule' => 'once'}
 
-      provider.should_not be_triggers_same(current, desired)
+      expect(provider).not_to be_triggers_same(current, desired)
     end
 
     it 'should not consider triggers with different schedules to be the same' do
       current = {'schedule' => 'once'}
       desired = {'schedule' => 'weekly'}
 
-      provider.should_not be_triggers_same(current, desired)
+      expect(provider).not_to be_triggers_same(current, desired)
     end
 
     describe 'start_date' do
@@ -799,7 +678,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_time' => '15:30', 'every' => 3}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
     end
 
@@ -808,48 +687,48 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2012-09-12', 'start_time' => '15:30', 'every' => 3}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:31', 'every' => 3}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-9-12',  'start_time' => '15:30', 'every' => 3}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '5:30',  'every' => 3}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '05:30', 'every' => 3}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'every' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 1}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30', 'every' => 1}
 
-        provider.should be_triggers_same(trigger, trigger)
+        expect(provider).to be_triggers_same(trigger, trigger)
       end
     end
 
@@ -858,34 +737,34 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
         desired = {'schedule' => 'daily', 'start_date' => '2012-09-12', 'start_time' => '15:30'}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:31'}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-9-12',  'start_time' => '15:30'}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '1:30'}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30'}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30'}
 
-        provider.should be_triggers_same(trigger, trigger)
+        expect(provider).to be_triggers_same(trigger, trigger)
       end
     end
 
@@ -894,55 +773,55 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [3], 'on' => [1,'last']}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'on' => [1, 'last']}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-10-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '22:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-9-12',  'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '5:30',  'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '05:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'months' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1],    'on' => [1, 3, 5, 7]}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'on' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 5, 7]}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
-        provider.should be_triggers_same(trigger, trigger)
+        expect(provider).to be_triggers_same(trigger, trigger)
       end
     end
 
@@ -964,7 +843,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
@@ -985,7 +864,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
@@ -1006,7 +885,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'months' as different triggers" do
@@ -1027,7 +906,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'which_occurrence' as different triggers" do
@@ -1048,7 +927,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'day_of_week' as different triggers" do
@@ -1069,7 +948,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['fri']
         }
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
@@ -1082,7 +961,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
-        provider.should be_triggers_same(trigger, trigger)
+        expect(provider).to be_triggers_same(trigger, trigger)
       end
     end
 
@@ -1091,68 +970,68 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-10-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '22:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-9-12',  'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '1:30',  'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
-        provider.should be_triggers_same(current, desired)
+        expect(provider).to be_triggers_same(current, desired)
       end
 
       it "should consider different 'every' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 1, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it "should consider different 'day_of_week' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['fri']}
 
-        provider.should_not be_triggers_same(current, desired)
+        expect(provider).not_to be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
-        provider.should be_triggers_same(trigger, trigger)
+        expect(provider).to be_triggers_same(trigger, trigger)
       end
     end
   end
 
   describe '#normalized_date' do
     it 'should format the date without leading zeros' do
-      described_class.normalized_date('2011-01-01').should == '2011-1-1'
+      expect(described_class.normalized_date('2011-01-01')).to eq('2011-1-1')
     end
   end
 
   describe '#normalized_time' do
     it 'should format the time as {24h}:{minutes}' do
-      described_class.normalized_time('8:37 PM').should == '20:37'
+      expect(described_class.normalized_time('8:37 PM')).to eq('20:37')
     end
   end
 
@@ -1166,138 +1045,17 @@ 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'
       end
 
       it 'should set the trigger_type to Win32::TaskScheduler::ONCE' do
-        trigger['trigger_type'].should == Win32::TaskScheduler::ONCE
+        expect(trigger['trigger_type']).to eq(Win32::TaskScheduler::ONCE)
       end
 
       it 'should not set a type' do
-        trigger.should_not be_has_key('type')
+        expect(trigger).not_to be_has_key('type')
       end
 
       it "should require 'start_date'" do
@@ -1329,22 +1087,22 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       end
 
       it "should default 'every' to 1" do
-        trigger['type']['days_interval'].should == 1
+        expect(trigger['type']['days_interval']).to eq(1)
       end
 
       it "should use the specified value for 'every'" do
         @puppet_trigger['every'] = 5
 
-        trigger['type']['days_interval'].should == 5
+        expect(trigger['type']['days_interval']).to eq(5)
       end
 
       it "should default 'start_date' to 'today'" do
         @puppet_trigger.delete('start_date')
         today = Time.now
 
-        trigger['start_year'].should == today.year
-        trigger['start_month'].should == today.month
-        trigger['start_day'].should == today.day
+        expect(trigger['start_year']).to eq(today.year)
+        expect(trigger['start_month']).to eq(today.month)
+        expect(trigger['start_day']).to eq(today.day)
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
@@ -1358,40 +1116,40 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       end
 
       it "should default 'every' to 1" do
-        trigger['type']['weeks_interval'].should == 1
+        expect(trigger['type']['weeks_interval']).to eq(1)
       end
 
       it "should use the specified value for 'every'" do
         @puppet_trigger['every'] = 4
 
-        trigger['type']['weeks_interval'].should == 4
+        expect(trigger['type']['weeks_interval']).to eq(4)
       end
 
       it "should default 'day_of_week' to be every day of the week" do
-        trigger['type']['days_of_week'].should == Win32::TaskScheduler::MONDAY    |
+        expect(trigger['type']['days_of_week']).to eq(Win32::TaskScheduler::MONDAY    |
                                                   Win32::TaskScheduler::TUESDAY   |
                                                   Win32::TaskScheduler::WEDNESDAY |
                                                   Win32::TaskScheduler::THURSDAY  |
                                                   Win32::TaskScheduler::FRIDAY    |
                                                   Win32::TaskScheduler::SATURDAY  |
-                                                  Win32::TaskScheduler::SUNDAY
+                                                  Win32::TaskScheduler::SUNDAY)
       end
 
       it "should use the specified value for 'day_of_week'" do
         @puppet_trigger['day_of_week'] = ['mon', 'wed', 'fri']
 
-        trigger['type']['days_of_week'].should == Win32::TaskScheduler::MONDAY    |
+        expect(trigger['type']['days_of_week']).to eq(Win32::TaskScheduler::MONDAY    |
                                                   Win32::TaskScheduler::WEDNESDAY |
-                                                  Win32::TaskScheduler::FRIDAY
+                                                  Win32::TaskScheduler::FRIDAY)
       end
 
       it "should default 'start_date' to 'today'" do
         @puppet_trigger.delete('start_date')
         today = Time.now
 
-        trigger['start_year'].should == today.year
-        trigger['start_month'].should == today.month
-        trigger['start_day'].should == today.day
+        expect(trigger['start_year']).to eq(today.year)
+        expect(trigger['start_month']).to eq(today.month)
+        expect(trigger['start_day']).to eq(today.day)
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
@@ -1401,7 +1159,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
     shared_examples_for 'a monthly schedule' do
       it "should default 'months' to be every month" do
-        trigger['type']['months'].should == Win32::TaskScheduler::JANUARY   |
+        expect(trigger['type']['months']).to eq(Win32::TaskScheduler::JANUARY   |
                                             Win32::TaskScheduler::FEBRUARY  |
                                             Win32::TaskScheduler::MARCH     |
                                             Win32::TaskScheduler::APRIL     |
@@ -1412,14 +1170,14 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
                                             Win32::TaskScheduler::SEPTEMBER |
                                             Win32::TaskScheduler::OCTOBER   |
                                             Win32::TaskScheduler::NOVEMBER  |
-                                            Win32::TaskScheduler::DECEMBER
+                                            Win32::TaskScheduler::DECEMBER)
       end
 
       it "should use the specified value for 'months'" do
         @puppet_trigger['months'] = [2, 8]
 
-        trigger['type']['months'].should == Win32::TaskScheduler::FEBRUARY  |
-                                            Win32::TaskScheduler::AUGUST
+        expect(trigger['type']['months']).to eq(Win32::TaskScheduler::FEBRUARY  |
+                                            Win32::TaskScheduler::AUGUST)
       end
     end
 
@@ -1462,9 +1220,9 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         @puppet_trigger.delete('start_date')
         today = Time.now
 
-        trigger['start_year'].should == today.year
-        trigger['start_month'].should == today.month
-        trigger['start_day'].should == today.day
+        expect(trigger['start_year']).to eq(today.year)
+        expect(trigger['start_month']).to eq(today.month)
+        expect(trigger['start_day']).to eq(today.day)
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
@@ -1512,9 +1270,9 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         @puppet_trigger.delete('start_date')
         today = Time.now
 
-        trigger['start_year'].should == today.year
-        trigger['start_month'].should == today.month
-        trigger['start_day'].should == today.day
+        expect(trigger['start_year']).to eq(today.year)
+        expect(trigger['start_month']).to eq(today.month)
+        expect(trigger['start_day']).to eq(today.day)
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
@@ -1532,7 +1290,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         {'schedule' => 'weekly', 'start_date' => '2011-09-13', 'start_time' => '13:50', 'day_of_week' => 'mon'}
       ]
 
-      provider.validate_trigger(triggers_to_validate).should == true
+      expect(provider.validate_trigger(triggers_to_validate)).to eq(true)
     end
 
     it 'should use the exception from translate_hash_to_trigger when it fails' do
@@ -1558,7 +1316,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     end
 
     before :each do
-      @mock_task = mock
+      @mock_task = stub
       @mock_task.responds_like(Win32::TaskScheduler.new)
       @mock_task.stubs(:exists?).returns(true)
       @mock_task.stubs(:activate)
@@ -1625,7 +1383,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
     end
 
     before :each do
-        @mock_task = mock
+        @mock_task = stub
         @mock_task.responds_like(Win32::TaskScheduler.new)
         @mock_task.stubs(:exists?).returns(true)
         @mock_task.stubs(:activate)
@@ -1682,7 +1440,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       end
 
       before :each do
-        @mock_task = mock
+        @mock_task = stub
         @mock_task.responds_like(Win32::TaskScheduler.new)
         @mock_task.stubs(:exists?).returns(true)
         @mock_task.stubs(:activate)
@@ -1736,7 +1494,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
     describe '#user=', :if => Puppet.features.microsoft_windows? do
       before :each do
-        @mock_task = mock
+        @mock_task = stub
         @mock_task.responds_like(Win32::TaskScheduler.new)
         @mock_task.stubs(:exists?).returns(true)
         @mock_task.stubs(:activate)
@@ -1792,7 +1550,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       @arguments   = '/a /list /of /arguments'
       @working_dir = 'C:\Windows\Some\Directory'
 
-      @mock_task = mock
+      @mock_task = stub
       @mock_task.responds_like(Win32::TaskScheduler.new)
       @mock_task.stubs(:exists?).returns(true)
       @mock_task.stubs(:activate)