puppet 0.24.6 → 0.24.7

data/spec/unit/type/resources.rb

@@ -0,0 +1,27 @@
+#!/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
+        before do
+            resources.clear
+        end
+
+        it "should fail if the specified resource type does not exist" do
+            Puppet::Type.expects(:type).with("nosuchtype").returns nil
+            lambda { resources.create :name => "nosuchtype" }.should raise_error(Puppet::Error)
+        end
+
+        it "should not fail when the specified resource type exists" do
+            lambda { resources.create :name => "file" }.should_not raise_error
+        end
+
+        it "should set its :resource_type attribute" do
+            resources.create(:name => "file").resource_type.should == Puppet::Type.type(:file)
+        end
+    end
+end

data/spec/unit/type/schedule.rb

@@ -0,0 +1,339 @@
+#!/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).create(:name => "testing")
+    end
+
+    after :each do
+        Puppet::Type.type(:schedule).clear
+    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

data/spec/unit/type/selboolean.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+describe Puppet::Type.type(:selboolean), "when validating attributes" do
+    [:name, :persistent].each do |param|
+        it "should have a #{param} parameter" do
+            Puppet::Type.type(:selboolean).attrtype(param).should == :param
+        end
+    end
+
+    it "should have a value property" do
+        Puppet::Type.type(:selboolean).attrtype(:value).should == :property
+    end
+end
+
+describe Puppet::Type.type(:selboolean), "when validating values" do
+    before do
+        @class = Puppet::Type.type(:selboolean)
+
+        @provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
+        @class.stubs(:defaultprovider).returns(@provider_class)
+        @class.stubs(:provider).returns(@provider_class)
+
+        @provider = stub 'provider', :class => @provider_class, :clear => nil
+        @provider_class.stubs(:new).returns(@provider)
+    end
+
+    it "should support :on as a value to :value" do
+        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :on)
+    end
+
+    it "should support :off as a value to :value" do
+        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :off)
+    end
+
+    it "should support :true as a value to :persistent" do
+        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :on, :persistent => :true)
+    end
+
+    it "should support :false as a value to :persistent" do
+        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :on, :persistent => :false)
+    end
+
+    after { Puppet::Type.type(:selboolean).clear }
+end
+

data/spec/unit/type/selmodule.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+describe Puppet::Type.type(:selmodule), "when validating attributes" do
+    [:name, :selmoduledir, :selmodulepath].each do |param|
+        it "should have a #{param} parameter" do
+            Puppet::Type.type(:selmodule).attrtype(param).should == :param
+        end
+    end
+
+    [:ensure, :syncversion].each do |param|
+        it "should have a #{param} property" do
+            Puppet::Type.type(:selmodule).attrtype(param).should == :property
+        end
+    end
+end
+

data/spec/unit/type/service.rb

@@ -0,0 +1,254 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:service) do
+    it "should have an :enableable feature that requires the :enable, :disable, and :enabled? methods" do
+        Puppet::Type.type(:service).provider_feature(:enableable).methods.should == [:disable, :enable, :enabled?]
+    end
+
+    it "should have a :refreshable feature that requires the :restart method" do
+        Puppet::Type.type(:service).provider_feature(:refreshable).methods.should == [:restart]
+    end
+end
+
+describe Puppet::Type.type(:service), "when validating attributes" do
+    [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control].each do |param|
+        it "should have a #{param} parameter" do
+            Puppet::Type.type(:service).attrtype(param).should == :param
+        end
+    end
+
+    [:ensure, :enable].each do |param|
+        it "should have an #{param} property" do
+            Puppet::Type.type(:service).attrtype(param).should == :property
+        end
+    end
+end
+
+describe Puppet::Type.type(:service), "when validating attribute values" do
+    before do
+        @provider = stub 'provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false
+        Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(@provider)
+    end
+
+    it "should support :running as a value to :ensure" do
+        Puppet::Type.type(:service).create(:name => "yay", :ensure => :running)
+    end
+
+    it "should support :stopped as a value to :ensure" do
+        Puppet::Type.type(:service).create(:name => "yay", :ensure => :stopped)
+    end
+
+    it "should alias the value :true to :running in :ensure" do
+        svc = Puppet::Type.type(:service).create(:name => "yay", :ensure => true)
+        svc.should(:ensure).should == :running
+    end
+
+    it "should alias the value :false to :stopped in :ensure" do
+        svc = Puppet::Type.type(:service).create(:name => "yay", :ensure => false)
+        svc.should(:ensure).should == :stopped
+    end
+
+    it "should support :true as a value to :enable" do
+        Puppet::Type.type(:service).create(:name => "yay", :enable => :true)
+    end
+
+    it "should support :false as a value to :enable" do
+        Puppet::Type.type(:service).create(:name => "yay", :enable => :false)
+    end
+
+    it "should support :true as a value to :hasstatus" do
+        Puppet::Type.type(:service).create(:name => "yay", :hasstatus => :true)
+    end
+
+    it "should support :false as a value to :hasstatus" do
+        Puppet::Type.type(:service).create(:name => "yay", :hasstatus => :false)
+    end
+
+    it "should support :true as a value to :hasrestart" do
+        Puppet::Type.type(:service).create(:name => "yay", :hasrestart => :true)
+    end
+
+    it "should support :false as a value to :hasrestart" do
+        Puppet::Type.type(:service).create(:name => "yay", :hasrestart => :false)
+    end
+
+    it "should allow setting the :enable parameter if the provider has the :enableable feature" do
+        Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
+        Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(true)
+        svc = Puppet::Type.type(:service).create(:name => "yay", :enable => true)
+        svc.should(:enable).should == :true
+    end
+
+    it "should not allow setting the :enable parameter if the provider is missing the :enableable feature" do
+        Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
+        Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(false)
+        svc = Puppet::Type.type(:service).create(:name => "yay", :enable => true)
+        svc.should(:enable).should be_nil
+    end
+
+    it "should discard paths that do not exist" do
+        FileTest.stubs(:exist?).returns(false)
+        FileTest.stubs(:directory?).returns(false)
+        svc = Puppet::Type.type(:service).create(:name => "yay", :path => "/one/two")
+        svc[:path].should be_empty
+    end
+
+    it "should discard paths that are not directories" do
+        FileTest.stubs(:exist?).returns(true)
+        FileTest.stubs(:directory?).returns(false)
+        svc = Puppet::Type.type(:service).create(:name => "yay", :path => "/one/two")
+        svc[:path].should be_empty
+    end
+
+    it "should split paths on ':'" do
+        FileTest.stubs(:exist?).returns(true)
+        FileTest.stubs(:directory?).returns(true)
+        svc = Puppet::Type.type(:service).create(:name => "yay", :path => "/one/two:/three/four")
+        svc[:path].should == %w{/one/two /three/four}
+    end
+
+    it "should accept arrays of paths joined by ':'" do
+        FileTest.stubs(:exist?).returns(true)
+        FileTest.stubs(:directory?).returns(true)
+        svc = Puppet::Type.type(:service).create(:name => "yay", :path => ["/one:/two", "/three:/four"])
+        svc[:path].should == %w{/one /two /three /four}
+    end
+
+    after { Puppet::Type.type(:service).clear }
+end
+
+describe Puppet::Type.type(:service), "when setting default attribute values" do
+    it "should default to the provider's default path if one is available" do
+        FileTest.stubs(:directory?).returns(true)
+        FileTest.stubs(:exist?).returns(true)
+
+        Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
+        Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
+        svc = Puppet::Type.type(:service).create(:name => "other")
+        svc[:path].should == ["testing"]
+    end
+
+    it "should default 'pattern' to the binary if one is provided" do
+        svc = Puppet::Type.type(:service).create(:name => "other", :binary => "/some/binary")
+        svc[:pattern].should == "/some/binary"
+    end
+
+    it "should default 'pattern' to the name if no pattern is provided" do
+        svc = Puppet::Type.type(:service).create(:name => "other")
+        svc[:pattern].should == "other"
+    end
+
+    it "should default 'control' to the upcased service name with periods replaced by underscores if the provider supports the 'controllable' feature" do
+        provider = stub 'provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil
+        Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(provider)
+        svc = Puppet::Type.type(:service).create(:name => "nfs.client")
+        svc[:control].should == "NFS_CLIENT_START"
+    end
+
+    after { Puppet::Type.type(:service).clear }
+end
+
+describe Puppet::Type.type(:service), "when retrieving the host's current state" do
+    before do
+        @service = Puppet::Type.type(:service).create(:name => "yay")
+    end
+
+    it "should use the provider's status to determine whether the service is running" do
+        @service.provider.expects(:status).returns(:yepper)
+        @service[:ensure] = :running
+        @service.property(:ensure).retrieve.should == :yepper
+    end
+
+    it "should ask the provider whether it is enabled" do
+        @service.provider.class.stubs(:supports_parameter?).returns(true)
+        @service.provider.expects(:enabled?).returns(:yepper)
+        @service[:enable] = true
+        @service.property(:enable).retrieve.should == :yepper
+    end
+
+    after { Puppet::Type.type(:service).clear }
+end
+
+describe Puppet::Type.type(:service), "when changing the host" do
+    before do
+        @service = Puppet::Type.type(:service).create(:name => "yay")
+    end
+
+    it "should start the service if it is supposed to be running" do
+        @service[:ensure] = :running
+        @service.provider.expects(:start)
+        @service.property(:ensure).sync
+    end
+
+    it "should stop the service if it is supposed to be stopped" do
+        @service[:ensure] = :stopped
+        @service.provider.expects(:stop)
+        @service.property(:ensure).sync
+    end
+
+    it "should enable the service if it is supposed to be enabled" do
+        @service.provider.class.stubs(:supports_parameter?).returns(true)
+        @service[:enable] = true
+        @service.provider.expects(:enable)
+        @service.property(:enable).sync
+    end
+
+    it "should disable the service if it is supposed to be disabled" do
+        @service.provider.class.stubs(:supports_parameter?).returns(true)
+        @service[:enable] = false
+        @service.provider.expects(:disable)
+        @service.property(:enable).sync
+    end
+
+    it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
+        @service.provider.class.stubs(:supports_parameter?).returns(true)
+        @service[:enable] = false
+        @service[:ensure] = :stopped
+
+        @service.property(:enable).expects(:retrieve).returns("whatever")
+        @service.property(:enable).expects(:insync?).returns(false)
+        @service.property(:enable).expects(:sync)
+
+        @service.provider.stubs(:stop)
+
+        @service.property(:ensure).sync
+    end
+
+    after { Puppet::Type.type(:service).clear }
+end
+
+describe Puppet::Type.type(:service), "when refreshing the service" do
+    before do
+        @service = Puppet::Type.type(:service).create(:name => "yay")
+    end
+
+    it "should restart the service if it is running" do
+        @service[:ensure] = :running
+        @service.provider.expects(:status).returns(:running)
+        @service.provider.expects(:restart)
+        @service.refresh
+    end
+
+    it "should restart the service if it is running, even if it is supposed to stopped" do
+        @service[:ensure] = :stopped
+        @service.provider.expects(:status).returns(:running)
+        @service.provider.expects(:restart)
+        @service.refresh
+    end
+
+    it "should not restart the service if it is not running" do
+        @service[:ensure] = :running
+        @service.provider.expects(:status).returns(:stopped)
+        @service.refresh
+    end
+
+    it "should add :ensure as a property if it is not being managed" do
+        @service.provider.expects(:status).returns(:running)
+        @service.provider.expects(:restart)
+        @service.refresh
+    end
+
+    after { Puppet::Type.type(:service).clear }
+end