puppet 3.7.5 → 3.8.1

data/spec/unit/pops/validation_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'Puppet::Pops::Validation::Diagnostic' do
+
+  # Mocks a SourcePosAdapter as it is used in these use cases
+  # of a Diagnostic
+  #
+  class MockSourcePos
+    attr_reader :offset
+    def initialize(offset)
+      @offset = offset
+    end
+  end
+
+  it "computes equal hash value ignoring arguments" do
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos = MockSourcePos.new(10)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos, {:foo => 10})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos.clone, {:bar => 20})
+    expect(d1.hash).to eql(d2.hash)
+  end
+
+  it "computes non equal hash value for different severities" do
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos = MockSourcePos.new(10)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos, {})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:error, issue, "foo", source_pos.clone, {})
+    expect(d1.hash).to_not eql(d2.hash)
+  end
+
+  it "computes non equal hash value for different offsets" do
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos1 = MockSourcePos.new(10)
+    source_pos2 = MockSourcePos.new(11)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos1, {})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos2, {})
+    expect(d1.hash).to_not eql(d2.hash)
+  end
+
+  it "can be used in a set" do
+    the_set = Set.new()
+    issue = Puppet::Pops::Issues::DIV_BY_ZERO
+    source_pos = MockSourcePos.new(10)
+    d1 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos, {})
+    d2 = Puppet::Pops::Validation::Diagnostic.new(:warning, issue, "foo", source_pos.clone, {})
+    d3 = Puppet::Pops::Validation::Diagnostic.new(:error, issue, "foo", source_pos.clone, {})
+    expect(the_set.add?(d1)).to_not be_nil
+    expect(the_set.add?(d2)).to be_nil
+    expect(the_set.add?(d3)).to_not be_nil
+  end
+
+end
+
+describe "Puppet::Pops::Validation::SeverityProducer" do
+  it 'sets default severity given in initializer' do
+    producer = Puppet::Pops::Validation::SeverityProducer.new(:warning)
+    expect(producer.severity(Puppet::Pops::Issues::DIV_BY_ZERO)).to be(:warning)
+  end
+
+  it 'sets default severity to :error if not given' do
+    producer = Puppet::Pops::Validation::SeverityProducer.new()
+    expect(producer.severity(Puppet::Pops::Issues::DIV_BY_ZERO)).to be(:error)
+  end
+
+end

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

@@ -34,33 +34,77 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
     let(:user1) { stub(:account => 'user1', :domain => '.', :to_s => 'user1sid') }
     let(:user2) { stub(:account => 'user2', :domain => '.', :to_s => 'user2sid') }
+    let(:user3) { stub(:account => 'user3', :domain => '.', :to_s => 'user3sid') }
 
     before :each do
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user1').returns(user1)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user2').returns(user2)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user3').returns(user3)
     end
 
     describe "#members_insync?" do
       it "should return false when current is nil" do
         provider.members_insync?(nil, ['user2']).should be_false
       end
+
       it "should return false when should is nil" do
         provider.members_insync?(['user1'], nil).should be_false
       end
+
       it "should return false for differing lists of members" do
         provider.members_insync?(['user1'], ['user2']).should be_false
         provider.members_insync?(['user1'], []).should be_false
         provider.members_insync?([], ['user2']).should be_false
       end
+
       it "should return true for same lists of members" do
         provider.members_insync?(['user1', 'user2'], ['user1', 'user2']).should be_true
       end
+
       it "should return true for same lists of unordered members" do
         provider.members_insync?(['user1', 'user2'], ['user2', 'user1']).should be_true
       end
+
       it "should return true for same lists of members irrespective of duplicates" do
         provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1']).should be_true
       end
+
+      it "should return true when current user(s) and should user(s) are empty lists" do
+        provider.members_insync?([], []).should be_true
+      end
+
+      context "when auth_membership => true" do
+        before :each do
+          # this is also the default
+          resource[:auth_membership] = true
+        end
+
+        it "should return false when should user(s) are not the only items in the current" do
+          provider.members_insync?(['user1', 'user2'], ['user1']).should be_false
+        end
+
+        it "should return false when current user(s) is not empty and should is an empty list" do
+          provider.members_insync?(['user1','user2'], []).should be_false
+        end
+      end
+
+      context "when auth_membership => false" do
+        before :each do
+          resource[:auth_membership] = false
+        end
+
+        it "should return true when current user(s) contains at least the should list" do
+          provider.members_insync?(['user1','user2'], ['user1']).should be_true
+        end
+
+        it "should return true when current user(s) is not empty and should is an empty list" do
+          provider.members_insync?(['user1','user2'], []).should be_true
+        end
+
+        it "should return true when current user(s) contains at least the should list, even unordered" do
+          provider.members_insync?(['user3','user1','user2'], ['user2','user1']).should be_true
+        end
+      end
     end
 
     describe "#members_to_s" do
@@ -119,7 +163,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       create = sequence('create')
       group.expects(:commit).in_sequence(create)
-      group.expects(:set_members).with(['user1', 'user2']).in_sequence(create)
+      group.expects(:set_members).with(['user1', 'user2'], true).in_sequence(create)
 
       provider.create
     end
@@ -130,6 +174,18 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         /Cannot create group if user 'testers' exists./ )
     end
 
+    it "should fail with an actionable message when trying to create an active directory group" do
+      resource[:name] = 'DOMAIN\testdomaingroup'
+      Puppet::Util::Windows::ADSI::User.expects(:exists?).with(resource[:name]).returns(false)
+      connection.expects(:Create)
+      connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
+
+      expect{ provider.create }.to raise_error(
+                                       Puppet::Error,
+                                       /not able to create\/delete domain groups/
+                                   )
+    end
+
     it 'should commit a newly created group' do
       provider.group.expects( :commit )
 
@@ -152,6 +208,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     provider.delete
   end
 
+  it 'should not run commit on a deleted group' do
+    connection.expects(:Delete).with('group', 'testers')
+    connection.expects(:SetInfo).never
+
+    provider.delete
+    provider.flush
+  end
+
   it "should report the group's SID as gid" do
     Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns('S-1-5-32-547')
     provider.gid.should == 'S-1-5-32-547'

data/spec/unit/provider/mount/parsed_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
 describe Puppet::Type.type(:mount).provider(:parsed), :unless => Puppet.features.microsoft_windows? do
+  before :each do
+    Facter.clear
+  end
 
   let :vfstab_sample do
     "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
@@ -18,6 +21,11 @@ describe Puppet::Type.type(:mount).provider(:parsed), :unless => Puppet.features
     described_class.default_target.should == '/etc/vfstab'
   end
 
+  it "should default to /etc/vfstab on Solaris" do
+    pending "This test only works on AIX" unless Facter.value(:osfamily) == 'AIX'
+    described_class.default_target.should == '/etc/filesystems'
+  end
+
   it "should default to /etc/fstab on anything else" do
     pending "This test does not work on Solaris" if Facter.value(:osfamily) == 'Solaris'
     described_class.default_target.should == '/etc/fstab'
@@ -160,10 +168,14 @@ FSTAB
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = described_class.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
-      mounts[1].should == { :name => '/tmp', :mounted => :yes }
-      mounts[2].should == { :name => '/home', :mounted => :yes }
-      mounts[3].should == { :name => '/usr', :mounted => :yes }
-      mounts[4].should == { :name => '/usr/code', :mounted => :yes }
+      mounts[1].should == { :name => '/usr', :mounted => :yes }
+      mounts[2].should == { :name => '/var', :mounted => :yes }
+      mounts[3].should == { :name => '/tmp', :mounted => :yes }
+      mounts[4].should == { :name => '/home', :mounted => :yes }
+      mounts[5].should == { :name => '/admin', :mounted => :yes }
+      mounts[6].should == { :name => '/proc', :mounted => :yes }
+      mounts[7].should == { :name => '/opt', :mounted => :yes }
+      mounts[8].should == { :name => '/srv/aix', :mounted => :yes }
     end
 
     it "should raise an error if a line is not understandable" do
@@ -173,7 +185,21 @@ FSTAB
 
   end
 
-  it "should support AIX's paragraph based /etc/filesystems"
+  it "should support AIX's paragraph based /etc/filesystems" do
+    pending "This test only works on AIX" unless Facter.value(:osfamily) == 'AIX'
+    Facter.stubs(:value).with(:osfamily).returns 'AIX'
+    described_class.stubs(:default_target).returns my_fixture('aix.filesystems')
+    described_class.stubs(:mountcmd).returns File.read(my_fixture('aix.mount'))
+    instances = described_class.instances
+    instances[0].name.should == "/"
+    instances[0].device.should == "/dev/hd4"
+    instances[0].fstype.should == "jfs2"
+    instances[0].options.should == "check=false,free=true,log=NULL,mount=automatic,quota=no,type=bootfs,vol=root"
+    instances[11].name.should == "/srv/aix"
+    instances[11].device.should == "mynode"
+    instances[11].fstype.should == "nfs"
+    instances[11].options.should == "vers=2,account=false,log=NULL,mount=true"
+  end
 
   my_fixtures('*.fstab').each do |fstab|
     platform = File.basename(fstab, '.fstab')

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

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:package).provider(:pip)
-osfamilies = { 'RedHat' => 'pip-python', 'Not RedHat' => 'pip' }
+osfamilies = { ['RedHat', '6'] => 'pip-python', ['RedHat', '7'] => 'pip', ['Not RedHat', nil] => 'pip' }
 
 describe provider_class do
 
@@ -32,11 +32,18 @@ describe provider_class do
   end
 
   describe "cmd" do
-    it "should return pip-python on RedHat systems" do
+    it "should return pip-python on RedHat < 7 systems" do
       Facter.stubs(:value).with(:osfamily).returns("RedHat")
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("6")
       provider_class.cmd.should == 'pip-python'
     end
 
+    it "should return pip on RedHat >= 7 systems" do
+      Facter.stubs(:value).with(:osfamily).returns("RedHat")
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
+      provider_class.cmd.should == 'pip'
+    end
+
     it "should return pip by default" do
       Facter.stubs(:value).with(:osfamily).returns("Not RedHat")
       provider_class.cmd.should == 'pip'
@@ -48,7 +55,8 @@ describe provider_class do
 
     osfamilies.each do |osfamily, pip_cmd|
       it "should return an array on #{osfamily} when #{pip_cmd} is present" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily)
+        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
         provider_class.expects(:which).with(pip_cmd).returns("/fake/bin/pip")
         p = stub("process")
         p.expects(:collect).yields("real_package==1.2.5")
@@ -57,7 +65,8 @@ describe provider_class do
       end
 
       it "should return an empty array on #{osfamily} when #{pip_cmd} is missing" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily)
+        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
         provider_class.expects(:which).with(pip_cmd).returns nil
         provider_class.instances.should == []
       end
@@ -219,21 +228,24 @@ describe provider_class do
 
     osfamilies.each do |osfamily, pip_cmd|
       it "should retry on #{osfamily} if #{pip_cmd} has not yet been found" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily)
+        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
         @provider.expects(:pip).twice.with('freeze').raises(NoMethodError).then.returns(nil)
         @provider.expects(:which).with(pip_cmd).returns("/fake/bin/pip")
         @provider.method(:lazy_pip).call "freeze"
       end
 
       it "should fail on #{osfamily} if #{pip_cmd} is missing" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily)
+        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
         @provider.expects(:pip).with('freeze').raises(NoMethodError)
         @provider.expects(:which).with(pip_cmd).returns(nil)
         expect { @provider.method(:lazy_pip).call("freeze") }.to raise_error(NoMethodError)
       end
 
       it "should output a useful error message on #{osfamily} if #{pip_cmd} is missing" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily)
+        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
         @provider.expects(:pip).with('freeze').raises(NoMethodError)
         @provider.expects(:which).with(pip_cmd).returns(nil)
         expect { @provider.method(:lazy_pip).call("freeze") }.

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

@@ -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', '--name', 'mypackage')
+      @provider.expects(:zypper).with('--terse', :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
@@ -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', '--name', 'mypackage')
+      @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
@@ -124,13 +124,24 @@ describe provider_class do
     end
   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
+  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
   end
 
   describe "when installing with zypper install options" do
@@ -141,8 +152,8 @@ 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', '--no-gpg-check', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
+      @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(:query).returns "php5 0 5.4.10 4.5.6 x86_64"
       @provider.install
     end
@@ -154,7 +165,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', '--name', '--a=foo', '--b="quoted bar"', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a=foo', '--b="quoted bar"', '--name', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
@@ -166,7 +177,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', '--name', '--a', '--b', '--c', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a', '--b', '--c', '--name', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
@@ -178,7 +189,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', '--name', '--a --b --c', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a --b --c', '--name', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end

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

@@ -143,15 +143,43 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
           })
 
           resource.provider.trigger.should == [{
-            '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
+
         it 'should handle a single weekly trigger' do
           scheduled_days_of_week = Win32::TaskScheduler::MONDAY |
                                    Win32::TaskScheduler::WEDNESDAY |
@@ -172,13 +200,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',
-            'on'         => ['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
           })
 
           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'],
-            '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
           })
 
           resource.provider.trigger.should == [{
-            '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,29 +341,102 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
         resource.provider.trigger.should =~ [
           {
-            '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',
-            'enabled'    => true,
-            'index'      => 1,
+            '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',
-            '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
 
+      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',
+            'minutes_interval' => 30,
+            'minutes_duration' => 120,
+            '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,
+          }
+        ])
+      end
+
       it 'should skip triggers Win32::TaskScheduler cannot handle' do
         @mock_task.expects(:trigger_count).returns(3)
         @mock_task.expects(:trigger).with(0).returns({
@@ -354,18 +463,22 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
 
         resource.provider.trigger.should =~ [
           {
-            '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
 
         resource.provider.trigger.should =~ [
           {
-            '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,
       }
 
       resource.provider.trigger.should == [mock_task_trigger]
@@ -542,11 +661,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       resource.provider.clear_task
 
       resource.provider.trigger.should == [{
-        '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'