puppet 0.25.5 → 2.6.0

data/spec/unit/type/nagios.rb

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/external/nagios'
-
-describe "Nagios resource types" do
-    Nagios::Base.eachtype do |name, nagios_type|
-        puppet_type = Puppet::Type.type("nagios_" + name.to_s)
-
-        it "should have a valid type for #{name}" do
-            puppet_type.should_not be_nil
-        end
-
-        next unless puppet_type
-
-        describe puppet_type do
-            it "should be defined as a Puppet resource type" do
-                puppet_type.should_not be_nil
-            end
-
-            it "should have documentation" do
-                puppet_type.instance_variable_get("@doc").should_not == ""
-            end
-
-            it "should have %s as its namevar" % nagios_type.namevar do
-                puppet_type.namevar.should == nagios_type.namevar
-            end
-
-            it "should have documentation for its %s parameter" % nagios_type.namevar do
-                puppet_type.attrclass(nagios_type.namevar).instance_variable_get("@doc").should_not be_nil
-            end
-
-            it "should have an ensure property" do
-                puppet_type.should be_validproperty(:ensure)
-            end
-
-            it "should have a target property" do
-                puppet_type.should be_validproperty(:target)
-            end
-
-            it "should have documentation for its target property" do
-                puppet_type.attrclass(:target).instance_variable_get("@doc").should_not be_nil
-            end
-
-            nagios_type.parameters.reject { |param| param == nagios_type.namevar or param.to_s =~ /^[0-9]/ }.each do |param|
-                it "should have a %s property" % param do
-                    puppet_type.should be_validproperty(param)
-                end
-
-                it "should have documentation for its %s property" % param do
-                    puppet_type.attrclass(param).instance_variable_get("@doc").should_not be_nil
-                end
-            end
-
-            nagios_type.parameters.find_all { |param| param.to_s =~ /^[0-9]/ }.each do |param|
-                it "should have not have a %s property" % param do
-                    puppet_type.should_not be_validproperty(:param)
-                end
-            end
-        end
-    end
-end

data/spec/unit/type/noop_metaparam.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/type'
-
-describe Puppet::Type.type(:file).attrclass(:noop) do
-    before do
-        Puppet.settings.stubs(:use)
-        @file = Puppet::Type.newfile :path => "/what/ever"
-    end
-
-    it "should accept true as a value" do
-        lambda { @file[:noop] = true }.should_not raise_error
-    end
-
-    it "should accept false as a value" do
-        lambda { @file[:noop] = false }.should_not raise_error
-    end
-
-    describe "when set on a resource" do
-        it "should default to the :noop setting" do
-            Puppet.settings.expects(:value).with(:noop).returns "myval"
-            @file.noop.should == "myval"
-        end
-
-        it "should prefer true values from the attribute" do
-            @file[:noop] = true
-            @file.noop.should be_true
-        end
-
-        it "should prefer false values from the attribute" do
-            @file[:noop] = false
-            @file.noop.should be_false
-        end
-    end
-end

data/spec/unit/type/package.rb

@@ -1,236 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Puppet::Type.type(:package) do
-    it "should have an :installable feature that requires the :install method" do
-        Puppet::Type.type(:package).provider_feature(:installable).methods.should == [:install]
-    end
-
-    it "should have an :uninstallable feature that requires the :uninstall method" do
-        Puppet::Type.type(:package).provider_feature(:uninstallable).methods.should == [:uninstall]
-    end
-
-    it "should have an :upgradeable feature that requires :update and :latest methods" do
-        Puppet::Type.type(:package).provider_feature(:upgradeable).methods.should == [:update, :latest]
-    end
-
-    it "should have a :purgeable feature that requires the :purge latest method" do
-        Puppet::Type.type(:package).provider_feature(:purgeable).methods.should == [:purge]
-    end
-
-    it "should have a :versionable feature" do
-        Puppet::Type.type(:package).provider_feature(:versionable).should_not be_nil
-    end
-
-    it "should default to being installed" do
-        pkg = Puppet::Type.type(:package).new(:name => "yay")
-        pkg.should(:ensure).should == :present
-    end
-end
-
-describe Puppet::Type.type(:package), "when validating attributes" do
-    [:name, :source, :instance, :status, :adminfile, :responsefile, :configfiles, :category, :platform, :root, :vendor, :description, :allowcdrom].each do |param|
-        it "should have a #{param} parameter" do
-            Puppet::Type.type(:package).attrtype(param).should == :param
-        end
-    end
-
-    it "should have an ensure property" do
-        Puppet::Type.type(:package).attrtype(:ensure).should == :property
-    end
-end
-
-describe Puppet::Type.type(:package), "when validating attribute values" do
-    before do
-        @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil
-        Puppet::Type.type(:package).defaultprovider.expects(:new).returns(@provider)
-    end
-
-    it "should support :present as a value to :ensure" do
-        Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
-    end
-
-    it "should alias :installed to :present as a value to :ensure" do
-        pkg = Puppet::Type.type(:package).new(:name => "yay", :ensure => :installed)
-        pkg.should(:ensure).should == :present
-    end
-
-    it "should support :absent as a value to :ensure" do
-        Puppet::Type.type(:package).new(:name => "yay", :ensure => :absent)
-    end
-
-    it "should support :purged as a value to :ensure if the provider has the :purgeable feature" do
-        @provider.expects(:satisfies?).with(:purgeable).returns(true)
-        Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged)
-    end
-
-    it "should not support :purged as a value to :ensure if the provider does not have the :purgeable feature" do
-        @provider.expects(:satisfies?).with(:purgeable).returns(false)
-        proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged) }.should raise_error(Puppet::Error)
-    end
-
-    it "should support :latest as a value to :ensure if the provider has the :upgradeable feature" do
-        @provider.expects(:satisfies?).with(:upgradeable).returns(true)
-        Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest)
-    end
-
-    it "should not support :latest as a value to :ensure if the provider does not have the :upgradeable feature" do
-        @provider.expects(:satisfies?).with(:upgradeable).returns(false)
-        proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest) }.should raise_error(Puppet::Error)
-    end
-
-    it "should support version numbers as a value to :ensure if the provider has the :versionable feature" do
-        @provider.expects(:satisfies?).with(:versionable).returns(true)
-        Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0")
-    end
-
-    it "should not support version numbers as a value to :ensure if the provider does not have the :versionable feature" do
-        @provider.expects(:satisfies?).with(:versionable).returns(false)
-        proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
-    end
-
-    it "should accept any string as an argument to :source" do
-        proc { Puppet::Type.type(:package).new(:name => "yay", :source => "stuff") }.should_not raise_error(Puppet::Error)
-    end
-end
-
-module PackageEvaluationTesting
-    def setprops(properties)
-        @provider.stubs(:properties).returns(properties)
-    end
-end
-
-describe Puppet::Type.type(:package) do
-    before :each do
-        @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
-        Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
-        Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
-        @package = Puppet::Type.type(:package).new(:name => "yay")
-
-        @catalog = Puppet::Resource::Catalog.new
-        @catalog.add_resource(@package)
-    end
-
-    describe Puppet::Type.type(:package), "when it should be purged" do
-        include PackageEvaluationTesting
-
-        before { @package[:ensure] = :purged }
-
-        it "should do nothing if it is :purged" do
-            @provider.expects(:properties).returns(:ensure => :purged)
-            @catalog.apply
-        end
-
-        [:absent, :installed, :present, :latest].each do |state|
-            it "should purge if it is #{state.to_s}" do
-                @provider.stubs(:properties).returns(:ensure => state)
-                @provider.expects(:purge)
-                @catalog.apply
-            end
-        end
-    end
-
-    describe Puppet::Type.type(:package), "when it should be absent" do
-        include PackageEvaluationTesting
-
-        before { @package[:ensure] = :absent }
-
-        [:purged, :absent].each do |state|
-            it "should do nothing if it is #{state.to_s}" do
-                @provider.expects(:properties).returns(:ensure => state)
-                @catalog.apply
-            end
-        end
-
-        [:installed, :present, :latest].each do |state|
-            it "should uninstall if it is #{state.to_s}" do
-                @provider.stubs(:properties).returns(:ensure => state)
-                @provider.expects(:uninstall)
-                @catalog.apply
-            end
-        end
-    end
-
-    describe Puppet::Type.type(:package), "when it should be present" do
-        include PackageEvaluationTesting
-
-        before { @package[:ensure] = :present }
-
-        [:present, :latest, "1.0"].each do |state|
-            it "should do nothing if it is #{state.to_s}" do
-                @provider.expects(:properties).returns(:ensure => state)
-                @catalog.apply
-            end
-        end
-
-        [:purged, :absent].each do |state|
-            it "should install if it is #{state.to_s}" do
-                @provider.stubs(:properties).returns(:ensure => state)
-                @provider.expects(:install)
-                @catalog.apply
-            end
-        end
-    end
-
-    describe Puppet::Type.type(:package), "when it should be latest" do
-        include PackageEvaluationTesting
-
-        before { @package[:ensure] = :latest }
-
-        [:purged, :absent].each do |state|
-            it "should upgrade if it is #{state.to_s}" do
-                @provider.stubs(:properties).returns(:ensure => state)
-                @provider.expects(:update)
-                @catalog.apply
-            end
-        end
-
-        it "should upgrade if the current version is not equal to the latest version" do
-            @provider.stubs(:properties).returns(:ensure => "1.0")
-            @provider.stubs(:latest).returns("2.0")
-            @provider.expects(:update)
-            @catalog.apply
-        end
-
-        it "should do nothing if it is equal to the latest version" do
-            @provider.stubs(:properties).returns(:ensure => "1.0")
-            @provider.stubs(:latest).returns("1.0")
-            @provider.expects(:update).never
-            @catalog.apply
-        end
-
-        it "should do nothing if the provider returns :present as the latest version" do
-            @provider.stubs(:properties).returns(:ensure => :present)
-            @provider.stubs(:latest).returns("1.0")
-            @provider.expects(:update).never
-            @catalog.apply
-        end
-    end
-
-    describe Puppet::Type.type(:package), "when it should be a specific version" do
-        include PackageEvaluationTesting
-
-        before { @package[:ensure] = "1.0" }
-
-        [:purged, :absent].each do |state|
-            it "should install if it is #{state.to_s}" do
-                @provider.stubs(:properties).returns(:ensure => state)
-                @provider.expects(:install)
-                @catalog.apply
-            end
-        end
-
-        it "should do nothing if the current version is equal to the desired version" do
-            @provider.stubs(:properties).returns(:ensure => "1.0")
-            @provider.expects(:install).never
-            @catalog.apply
-        end
-
-        it "should install if the current version is not equal to the specified version" do
-            @provider.stubs(:properties).returns(:ensure => "2.0")
-            @provider.expects(:install)
-            @catalog.apply
-        end
-    end
-end

data/spec/unit/type/resources.rb

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-resources = Puppet::Type.type(:resources)
-
-# There are still plenty of tests to port over from test/.
-describe resources do
-    describe "when initializing" do
-        it "should fail if the specified resource type does not exist" do
-            Puppet::Type.stubs(:type).with { |x| x.to_s.downcase == "resources"}.returns resources
-            Puppet::Type.expects(:type).with("nosuchtype").returns nil
-            lambda { resources.new :name => "nosuchtype" }.should raise_error(Puppet::Error)
-        end
-
-        it "should not fail when the specified resource type exists" do
-            lambda { resources.new :name => "file" }.should_not raise_error
-        end
-
-        it "should set its :resource_type attribute" do
-            resources.new(:name => "file").resource_type.should == Puppet::Type.type(:file)
-        end
-    end
-
-    describe "#generate" do
-      before do
-          @host1 = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
-          @catalog = Puppet::Resource::Catalog.new
-          @context = Puppet::Transaction.new(@catalog)
-      end
-
-        describe "when dealing with non-purging resources" do
-            before do
-                @resources = Puppet::Type.type(:resources).new(:name => 'host')
-            end
-
-            it "should not generate any resource" do
-                @resources.generate.should be_empty
-            end
-        end
-
-        describe "when the catalog contains a purging resource" do
-            before do
-                @resources = Puppet::Type.type(:resources).new(:name => 'host', :purge => true)
-                @purgeable_resource = Puppet::Type.type(:host).new(:name => 'localhost', :ip => '127.0.0.1')
-                @catalog.add_resource @resources
-            end
-
-            it "should not generate a duplicate of that resource" do
-                Puppet::Type.type(:host).stubs(:instances).returns [@host1]
-                @catalog.add_resource @host1
-                @resources.generate.collect { |r| r.ref }.should_not include(@host1.ref)
-            end
-
-
-            describe "when generating a purgeable resource" do
-                it "should be included in the generated resources" do
-                    Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
-                    @resources.generate.collect { |r| r.ref }.should include(@purgeable_resource.ref)
-                end
-            end
-
-            describe "when the instance's do not have an ensure property" do
-                it "should not be included in the generated resources" do
-                    @no_ensure_resource = Puppet::Type.type(:exec).new(:name => '/usr/bin/env echo')
-                    Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]
-                    @resources.generate.collect { |r| r.ref }.should_not include(@no_ensure_resource.ref)
-                end
-            end
-
-            describe "when the instance's ensure property does not accept absent" do
-                it "should not be included in the generated resources" do
-                    @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
-                    Puppet::Type.type(:host).stubs(:instances).returns [@no_absent_resource]
-                    @resources.generate.collect { |r| r.ref }.should_not include(@no_absent_resource.ref)
-                end
-            end
-
-            describe "when checking the instance fails" do
-                it "should not be included in the generated resources" do
-                    @purgeable_resource = Puppet::Type.type(:host).new(:name => 'foobar')
-                    Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
-                    @resources.expects(:check).with(@purgeable_resource).returns(false)
-                    @resources.generate.collect { |r| r.ref }.should_not include(@purgeable_resource.ref)
-                end
-            end
-        end
-    end
-end

data/spec/unit/type/schedule.rb

@@ -1,333 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module ScheduleTesting
-
-    def format(time)
-        time.strftime("%H:%M:%S")
-    end
-
-    def diff(unit, incr, method, count)
-        diff = Time.now.to_i.send(method, incr * count)
-        Time.at(diff)
-    end
-
-    def month(method, count)
-        diff(:hour, 3600 * 24 * 30, method, count)
-    end
-
-    def week(method, count)
-        diff(:hour, 3600 * 24 * 7, method, count)
-    end
-
-    def day(method, count)
-        diff(:hour, 3600 * 24, method, count)
-    end
-
-    def hour(method, count)
-        diff(:hour, 3600, method, count)
-    end
-
-    def min(method, count)
-        diff(:min, 60, method, count)
-    end
-
-    def sec(method, count)
-        diff(:sec, 1, method, count)
-    end
-
-end
-
-describe Puppet::Type.type(:schedule) do
-    before :each do
-      Puppet.settings.stubs(:value).with(:ignoreschedules).returns(false)
-
-      @schedule = Puppet::Type.type(:schedule).new(:name => "testing")
-    end
-
-    describe Puppet::Type.type(:schedule) do
-        include ScheduleTesting
-
-        it "should default to :distance for period-matching" do
-            @schedule[:periodmatch].should == :distance
-        end
-
-        it "should default to a :repeat of 1" do
-            @schedule[:repeat].should == 1
-        end
-
-        it "should never match when the period is :never" do
-            @schedule[:period] = :never
-            @schedule.match?.should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when producing default schedules" do
-        include ScheduleTesting
-
-        %w{hourly daily weekly monthly never}.each do |period|
-            period = period.to_sym
-            it "should produce a #{period} schedule with the period set appropriately" do
-                schedules = Puppet::Type.type(:schedule).mkdefaultschedules
-                schedules.find { |s| s[:name] == period.to_s and s[:period] == period }.should be_instance_of(Puppet::Type.type(:schedule))
-            end
-        end
-
-        it "should produce a schedule named puppet with a period of hourly and a repeat of 2" do
-            schedules = Puppet::Type.type(:schedule).mkdefaultschedules
-            schedules.find { |s|
-                s[:name] == "puppet" and s[:period] == :hourly and s[:repeat] == 2
-            }.should be_instance_of(Puppet::Type.type(:schedule))
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching ranges" do
-        include ScheduleTesting
-
-        it "should match when the start time is before the current time and the end time is after the current time" do
-            @schedule[:range] = "%s - %s" % [format(Time.now - 10), format(Time.now + 10)]
-            @schedule.match?.should be_true
-        end
-
-        it "should not match when the start time is after the current time" do
-            @schedule[:range] = "%s - %s" % [format(Time.now + 5), format(Time.now + 10)]
-            @schedule.match?.should be_false
-        end
-
-        it "should not match when the end time is previous to the current time" do
-            @schedule[:range] = "%s - %s" % [format(Time.now - 10), format(Time.now - 5)]
-            @schedule.match?.should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching hourly by distance" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :hourly
-            @schedule[:periodmatch] = :distance
-        end
-
-        it "should match an hour ago" do
-            @schedule.match?(hour("-", 1)).should be_true
-        end
-
-        it "should not match now" do
-            @schedule.match?(Time.now).should be_false
-        end
-
-        it "should not match 59 minutes ago" do
-            @schedule.match?(min("-", 59)).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching daily by distance" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :daily
-            @schedule[:periodmatch] = :distance
-        end
-
-        it "should match when the previous time was one day ago" do
-            @schedule.match?(day("-", 1)).should be_true
-        end
-
-        it "should not match when the previous time is now" do
-            @schedule.match?(Time.now).should be_false
-        end
-
-        it "should not match when the previous time was 23 hours ago" do
-            @schedule.match?(hour("-", 23)).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching weekly by distance" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :weekly
-            @schedule[:periodmatch] = :distance
-        end
-
-        it "should match seven days ago" do
-            @schedule.match?(day("-", 7)).should be_true
-        end
-
-        it "should not match now" do
-            @schedule.match?(Time.now).should be_false
-        end
-
-        it "should not match six days ago" do
-            @schedule.match?(day("-", 6)).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching monthly by distance" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :monthly
-            @schedule[:periodmatch] = :distance
-        end
-
-        it "should match 32 days ago" do
-            @schedule.match?(day("-", 32)).should be_true
-        end
-
-        it "should not match now" do
-            @schedule.match?(Time.now).should be_false
-        end
-
-        it "should not match 27 days ago" do
-            @schedule.match?(day("-", 27)).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching hourly by number" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :hourly
-            @schedule[:periodmatch] = :number
-        end
-
-        it "should match if the times are one minute apart and the current minute is 0" do
-            current = Time.now
-
-            # Subtract an hour, reset the minute to zero, then add 59 minutes, so we're the previous hour plus 59 minutes.
-            previous = (current - 3600 - (current.min * 60) + (59 * 60))
-
-            # Now set the "current" time to the zero minute of the current hour.
-            now = (current - (current.min * 60))
-            Time.stubs(:now).returns(now)
-            @schedule.match?(previous).should be_true
-        end
-
-        it "should not match if the times are 58 minutes apart and the current minute is 59" do
-            current = Time.now
-
-            # reset the minute to zero
-            previous = current - (current.min * 60)
-
-            # Now set the "current" time to the 59th minute of the current hour.
-            now = (current - (current.min * 60) + (59 * 60))
-            Time.stubs(:now).returns(now)
-            @schedule.match?(previous).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching daily by number" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :daily
-            @schedule[:periodmatch] = :number
-        end
-
-        it "should match if the times are one minute apart and the current minute and hour are 0" do
-            zero = Time.now
-
-            # Reset the current time to X:00:00
-            current = zero - (zero.hour * 3600) - (zero.min * 60) - zero.sec
-
-            # Now set the previous time to one minute before that
-            previous = current - 60
-
-            Time.stubs(:now).returns(current)
-            @schedule.match?(previous).should be_true
-        end
-
-        it "should not match if the times are 23 hours and 58 minutes apart and the current hour is 23 and the current minute is 59" do
-            zero = Time.now
-
-            # Reset the previous time to 00:00:00
-            previous = zero - (zero.hour * 3600) - (zero.min * 60) - zero.sec
-
-            # Set the current time to 23:59
-            now = previous + (23 * 3600) + (59 * 60)
-
-            Time.stubs(:now).returns(now)
-            @schedule.match?(previous).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching weekly by number" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :weekly
-            @schedule[:periodmatch] = :number
-        end
-
-        it "should match if the previous time is prior to the most recent Sunday" do
-            now = Time.now
-
-            # Subtract the number days we've progressed into the week, plus one because we're zero-indexed.
-            previous = now - (3600 * 24 * (now.wday + 1))
-
-            @schedule.match?(previous).should be_true
-        end
-
-        it "should not match if the previous time is after the most recent Saturday" do
-            now = Time.now
-
-            # Subtract the number days we've progressed into the week
-            previous = now - (3600 * 24 * now.wday)
-
-            @schedule.match?(previous).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching monthly by number" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :monthly
-            @schedule[:periodmatch] = :number
-        end
-
-        it "should match when the previous time is prior to the first day of this month" do
-            now = Time.now
-
-            # Subtract the number days we've progressed into the month
-            previous = now - (3600 * 24 * now.day)
-
-            @schedule.match?(previous).should be_true
-        end
-
-        it "should not match when the previous time is after the last day of last month" do
-            now = Time.now
-
-            # Subtract the number days we've progressed into the month, minus one
-            previous = now - (3600 * 24 * (now.day - 1))
-
-            @schedule.match?(previous).should be_false
-        end
-    end
-
-    describe Puppet::Type.type(:schedule), "when matching with a repeat greater than one" do
-        include ScheduleTesting
-
-        before do
-            @schedule[:period] = :daily
-            @schedule[:repeat] = 2
-        end
-
-        it "should fail if the periodmatch is 'number'" do
-            @schedule[:periodmatch] = :number
-            proc { @schedule[:repeat] = 2 }.should raise_error(Puppet::Error)
-        end
-
-        it "should match if the previous run was further away than the distance divided by the repeat" do
-            previous = Time.now - (3600 * 13)
-            @schedule.match?(previous).should be_true
-        end
-
-        it "should not match if the previous run was closer than the distance divided by the repeat" do
-            previous = Time.now - (3600 * 11)
-            @schedule.match?(previous).should be_false
-        end
-    end
-end