puppet 0.24.6 → 0.24.7

data/spec/unit/transaction/event.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/event'
+
+describe Puppet::Transaction::Event do
+    Event = Puppet::Transaction::Event
+
+    it "should require a name and a source" do
+        lambda { Event.new }.should raise_error(ArgumentError)
+    end
+
+    it "should have a name getter" do
+        Event.new(:foo, "bar").name.should == :foo
+    end
+
+    it "should have a source accessor" do
+        Event.new(:foo, "bar").source.should == "bar"
+    end
+
+    it "should be able to produce a string containing the event name and the source" do
+        Event.new(:event, :source).to_s.should == "source -> event"
+    end
+end

data/spec/unit/transaction/report.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-12.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/report'
+
+describe Puppet::Transaction::Report, " when being indirect" do
+    it "should redirect :find to the indirection" do
+        @indirection = stub 'indirection', :name => :report
+        Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
+        @indirection.expects(:find)
+        Puppet::Transaction::Report.find(:report)
+    end
+
+    it "should redirect :save to the indirection" do
+        Facter.stubs(:value).returns("eh")
+        @indirection = stub 'indirection', :name => :report
+        Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
+        report = Puppet::Transaction::Report.new
+        @indirection.expects(:save)
+        report.save
+    end
+
+    it "should default to the 'processor' terminus" do
+        Puppet::Transaction::Report.indirection.terminus_class.should == :processor
+    end
+
+    it "should delegate its name attribute to its host method" do
+        report = Puppet::Transaction::Report.new
+        report.expects(:host).returns "me"
+        report.name.should == "me"
+    end
+
+    after do
+        Puppet::Indirector::Indirection.clear_cache
+    end
+end

data/spec/unit/type.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Puppet::Type do
+    describe "when retrieving current properties" do
+        # Use 'mount' as an example, because it doesn't override 'retrieve'
+        before do
+            @resource = Puppet::Type.type(:mount).create(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
+            @properties = {}
+        end
+
+        after { Puppet::Type.type(:mount).clear }
+
+        it "should return a hash containing values for all set properties" do
+            values = @resource.retrieve
+            [@resource.property(:fstype), @resource.property(:pass)].each { |property| values.should be_include(property) }
+        end
+
+        it "should not call retrieve on non-ensure properties if the resource is absent" do
+            @resource.property(:ensure).expects(:retrieve).returns :absent
+            @resource.property(:fstype).expects(:retrieve).never
+            @resource.retrieve[@resource.property(:fstype)]
+        end
+
+        it "should set all values to :absent if the resource is absent" do
+            @resource.property(:ensure).expects(:retrieve).returns :absent
+            @resource.retrieve[@resource.property(:fstype)].should == :absent
+        end
+
+        it "should include the result of retrieving each property's current value if the resource is present" do
+            @resource.property(:ensure).expects(:retrieve).returns :present
+            @resource.property(:fstype).expects(:retrieve).returns 15
+            @resource.retrieve[@resource.property(:fstype)].should == 15
+        end
+    end
+
+
+    describe "when in a catalog" do
+        before do
+            @catalog = Puppet::Node::Catalog.new
+            @container = Puppet::Type.type(:component).create(:name => "container")
+            @one = Puppet::Type.type(:file).create(:path => "/file/one")
+            @two = Puppet::Type.type(:file).create(:path => "/file/two")
+            @catalog.add_resource @container
+            @catalog.add_resource @one
+            @catalog.add_resource @two
+            @catalog.add_edge @container, @one
+            @catalog.add_edge @container, @two
+        end
+
+        it "should have no parent if there is no in edge" do
+            @container.parent.should be_nil
+        end
+
+        it "should set its parent to its in edge" do
+            @one.parent.ref.should == @container.ref
+        end
+
+        after do
+            @catalog.clear(true)
+        end
+    end
+end

data/spec/unit/type/augeas.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+augeas = Puppet::Type.type(:augeas)
+
+describe augeas do
+    describe "when augeas is present" do
+        confine "Augeas is unavailable" => Puppet.features.augeas?
+
+        it "should have a default provider inheriting from Puppet::Provider" do
+            augeas.defaultprovider.ancestors.should be_include(Puppet::Provider)
+        end
+        
+        it "should have a valid provider" do
+            augeas.create(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+        end        
+    end
+
+    describe "basic structure" do
+        it "should be able to create a instance" do
+            provider_class = Puppet::Type::Augeas.provider(Puppet::Type::Augeas.providers[0])
+            Puppet::Type::Augeas.expects(:defaultprovider).returns provider_class
+            augeas.create(:name => "bar").should_not be_nil
+        end
+
+        it "should have an parse_commands feature" do
+            augeas.provider_feature(:parse_commands).should_not be_nil
+        end
+        
+        it "should have an need_to_run? feature" do
+            augeas.provider_feature(:need_to_run?).should_not be_nil
+        end    
+        
+        it "should have an execute_changes feature" do
+            augeas.provider_feature(:execute_changes).should_not be_nil
+        end           
+
+        properties = [:returns]
+        params = [:name, :context, :onlyif, :changes, :root, :load_path, :type_check]
+
+        properties.each do |property|
+            it "should have a %s property" % property do
+                augeas.attrclass(property).ancestors.should be_include(Puppet::Property)
+            end
+
+            it "should have documentation for its %s property" % property do
+                augeas.attrclass(property).doc.should be_instance_of(String)
+            end
+        end        
+        
+        params.each do |param|
+            it "should have a %s parameter" % param do
+                augeas.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+            end
+
+            it "should have documentation for its %s parameter" % param do
+                augeas.attrclass(param).doc.should be_instance_of(String)
+            end
+        end                
+    end
+    
+    describe "default values" do
+        before do
+            provider_class = augeas.provider(augeas.providers[0])
+            augeas.expects(:defaultprovider).returns provider_class
+        end
+
+        it "should be blank for context" do
+            augeas.create(:name => :context)[:context].should == ""
+        end
+        
+        it "should be blank for onlyif" do
+            augeas.create(:name => :onlyif)[:onlyif].should == ""
+        end        
+        
+        it "should be blank for load_path" do
+            augeas.create(:name => :load_path)[:load_path].should == ""
+        end        
+        
+        it "should be / for root" do
+            augeas.create(:name => :root)[:root].should == "/"
+        end        
+        
+        it "should be false for type_check" do
+            augeas.create(:name => :type_check)[:type_check].should == :false
+        end                
+    end
+    
+    describe "provider interaction" do
+        it "should munge the changes" do
+            provider = stub("provider", :parse_commands => "Jar Jar Binks")
+            resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+            changes = augeas.attrclass(:changes).new(:resource => resource)
+            changes.value= "Testing 123"
+            changes.value.should == "Jar Jar Binks"
+        end
+        
+        it "should return 0 if it does not need to run" do
+            provider = stub("provider", :need_to_run? => false)
+            resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+            changes = augeas.attrclass(:returns).new(:resource => resource)
+            changes.retrieve.should == 0
+        end        
+        
+        it "should return :need_to_run if it needs to run" do
+            provider = stub("provider", :need_to_run? => true)
+            resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+            changes = augeas.attrclass(:returns).new(:resource => resource)
+            changes.retrieve.should == :need_to_run
+        end                
+    end
+end

data/spec/unit/type/computer.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+ 
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+computer = Puppet::Type.type(:computer)
+
+describe Puppet.type(:computer), " when checking computer objects" do
+    before do
+        provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
+        Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
+        @resource = Puppet::Type::Computer.create(
+                        :name => "puppetcomputertest",
+                        :en_address => "aa:bb:cc:dd:ee:ff",
+                        :ip_address => "1.2.3.4")
+        @properties = {}
+        @ensure = Puppet::Type::Computer.attrclass(:ensure).new(:resource => @resource)
+    end
+  
+    after do
+        computer.clear
+    end
+    
+    it "should be able to create a instance" do
+        provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
+        Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
+        computer.create(:name => "bar").should_not be_nil
+    end
+  
+    properties = [:en_address, :ip_address]
+    params = [:name]
+  
+    properties.each do |property|
+        it "should have a %s property" % property do
+            computer.attrclass(property).ancestors.should be_include(Puppet::Property)
+        end
+
+        it "should have documentation for its %s property" % property do
+            computer.attrclass(property).doc.should be_instance_of(String)
+        end
+        
+        it "should accept :absent as a value" do
+            prop = computer.attrclass(property).new(:resource => @resource)
+            prop.should = :absent
+            prop.should.must == :absent
+        end
+    end
+    
+    params.each do |param|
+        it "should have a %s parameter" % param do
+            computer.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+        end
+
+        it "should have documentation for its %s parameter" % param do
+            computer.attrclass(param).doc.should be_instance_of(String)
+        end
+    end
+    
+    describe "default values" do
+        before do
+            provider_class = computer.provider(computer.providers[0])
+            computer.expects(:defaultprovider).returns provider_class
+        end
+
+        it "should be nil for en_address" do
+            computer.create(:name => :en_address)[:en_address].should == nil
+        end
+        
+        it "should be nil for ip_address" do
+            computer.create(:name => :ip_address)[:ip_address].should == nil
+        end
+    end
+        
+    describe "when managing the ensure property" do    
+        it "should support a :present value" do
+            lambda { @ensure.should = :present }.should_not raise_error
+        end
+    
+        it "should support an :absent value" do
+            lambda { @ensure.should = :absent }.should_not raise_error
+        end
+    end
+end

data/spec/unit/type/exec.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module ExecModuleTesting
+    def create_resource(command, output, exitstatus)
+        @user_name = 'some_user_name'
+        @group_name = 'some_group_name'
+        Puppet.features.stubs(:root?).returns(true)
+        @execer = Puppet::Type.type(:exec).create(:name => command, :path => %w{/usr/bin /bin}, :user => @user_name, :group => @group_name)
+
+        status = stub "process"
+        status.stubs(:exitstatus).returns(exitstatus)
+
+        Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], @user_name, @group_name).returns([output, status])
+    end
+
+    def create_logging_resource(command, output, exitstatus, logoutput, loglevel)
+        create_resource(command, output, exitstatus)
+        @execer[:logoutput] = logoutput
+        @execer[:loglevel] = loglevel
+    end
+
+    def expect_output(output, loglevel)
+        output.split(/\n/).each do |line|
+            @execer.property(:returns).expects(loglevel).with(line)
+        end
+    end
+end
+
+describe Puppet::Type.type(:exec), " when execing" do
+    include ExecModuleTesting
+
+    it "should use the 'run_and_capture' method to exec" do
+        command = "true"
+        create_resource(command, "", 0)
+
+        @execer.refresh.should == :executed_command
+    end
+
+    it "should report a failure" do
+        command = "false"
+        create_resource(command, "", 1)
+
+        proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+    it "should log the output on success" do
+        #Puppet::Util::Log.newdestination :console
+        command = "false"
+        output = "output1\noutput2\n"
+        create_logging_resource(command, output, 0, true, :err)
+        expect_output(output, :err)
+        @execer.refresh
+    end
+
+    it "should log the output on failure" do
+        #Puppet::Util::Log.newdestination :console
+        command = "false"
+        output = "output1\noutput2\n"
+        create_logging_resource(command, output, 1, true, :err)
+        expect_output(output, :err)
+
+        proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+end
+
+
+describe Puppet::Type.type(:exec), " when logoutput=>on_failure is set," do
+    include ExecModuleTesting
+
+    it "should log the output on failure" do
+        #Puppet::Util::Log.newdestination :console
+        command = "false"
+        output = "output1\noutput2\n"
+        create_logging_resource(command, output, 1, :on_failure, :err)
+        expect_output(output, :err)
+
+        proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+    it "shouldn't log the output on success" do
+        #Puppet::Util::Log.newdestination :console
+        command = "true"
+        output = "output1\noutput2\n"
+        create_logging_resource(command, output, 0, :on_failure, :err)
+        @execer.property(:returns).expects(:err).never
+        @execer.refresh
+    end
+end

data/spec/unit/type/file.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:file) do
+    before do
+        @path = Tempfile.new("puppetspec")
+        @path.close!()
+        @path = @path.path
+        @file = Puppet::Type::File.create(:name => @path)
+    end
+
+    describe "when used with content and replace=>false" do
+        before do
+            @file[:content] = "foo"
+            @file[:replace] = false
+        end
+
+        it "should be insync if the file exists and the content is different" do
+            File.open(@path, "w") do |f| f.puts "bar" end
+            @file.property(:content).insync?("bar").should be_true
+        end
+
+        it "should be insync if the file exists and the content is right" do
+            File.open(@path, "w") do |f| f.puts "foo" end
+            @file.property(:content).insync?("foo").should be_true
+        end
+
+        it "should not be insync if the file does not exist" do
+            @file.property(:content).insync?(:nil).should be_false
+        end
+    end
+
+    describe "when specifying a source" do
+        before do
+            @file[:source] = "/bar"
+        end
+
+        it "should raise if source doesn't exist" do
+            @file.property(:source).expects(:found?).returns(false)
+            lambda { @file.retrieve }.should raise_error(Puppet::Error)
+        end
+
+        it "should have a checksum type of md5 and warn if retrieving with mtime" do
+            File.open(@path, "w") do |f| f.puts "foo" end
+            @file.property(:checksum).expects(:warning).with("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [:mtime, @path]) 
+            @file[:checksum] = :mtime
+            @file.property(:checksum).checktype.should == :md5
+            @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
+        end
+
+        it "should have a checksum type of md5 and warn if retrieving with md5lite" do
+            File.open(@path, "w") do |f| f.puts "foo" end
+            @file.property(:checksum).expects(:warning).with("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [:md5lite, @path]) 
+            @file[:checksum] = :md5lite
+            @file.property(:checksum).checktype.should == :md5
+            @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
+        end
+
+
+        it "should have a checksum type of md5 if getsum called with mtime" do
+            File.open(@path, "w") do |f| f.puts "foo" end
+            @file[:checksum] = :md5
+            @file.property(:checksum).checktype.should == :md5
+            @file.property(:checksum).getsum(:mtime).should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
+        end
+
+        it "should not warn if sumtype set to md5" do
+            File.open(@path, "w") do |f| f.puts "foo" end
+            @file.property(:checksum).expects(:warning).never
+            @file[:checksum] = :md5
+            @file.property(:checksum).checktype.should == :md5
+            @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
+        end
+
+    end
+
+    describe "when retrieving remote files" do
+        before do
+            @filesource = Puppet::Type::File::FileSource.new
+            @filesource.server = mock 'fileserver'
+
+            @file.stubs(:uri2obj).returns(@filesource)
+
+            @file[:source] = "puppet:///test"
+        end
+
+        it "should fail without writing if it cannot retrieve remote contents" do
+            # create the file, because we only get the problem when it starts
+            # out absent.
+            File.open(@file[:path], "w") { |f| f.puts "a" }
+            @file.expects(:write).never
+
+            @filesource.server.stubs(:describe).returns("493\tfile\t100\t0\t{md5}3f5fef3bddbc4398c46a7bd7ba7b3af7")
+            @filesource.server.stubs(:retrieve).raises(RuntimeError)
+            @file.property(:source).retrieve
+            lambda { @file.property(:source).sync }.should raise_error(Puppet::Error)
+        end
+
+        it "should fail if it cannot describe remote contents" do
+            @filesource.server.stubs(:describe).raises(Puppet::Network::XMLRPCClientError.new("Testing"))
+            lambda { @file.retrieve }.should raise_error(Puppet::Error)
+        end
+
+        it "should fail during eval_generate if no remote sources exist" do
+            file = Puppet::Type.type(:file).create :path => "/foobar", :source => "/this/file/does/not/exist", :recurse => true
+
+            lambda { file.eval_generate }.should raise_error(Puppet::Error)
+        end
+    end
+
+    describe "when managing links" do
+        require 'puppettest/support/assertions'
+        include PuppetTest
+        require 'tempfile'
+
+        before do
+            @basedir = tempfile
+            Dir.mkdir(@basedir)
+            @file = File.join(@basedir, "file")
+            @link = File.join(@basedir, "link")
+
+            File.open(@file, "w", 0644) { |f| f.puts "yayness"; f.flush }
+            File.symlink(@file, @link)
+
+            @resource = Puppet.type(:file).create(
+                :path => @link,
+                :mode => "755"
+            )
+            @catalog = Puppet::Node::Catalog.new
+            @catalog.add_resource @resource
+        end
+
+        after do
+            remove_tmp_files
+        end
+
+        it "should default to managing the link" do
+            @catalog.apply
+            # I convert them to strings so they display correctly if there's an error.
+            ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0644
+        end
+
+        it "should be able to follow links" do
+            @resource[:links] = :follow
+            @catalog.apply
+
+            ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0755
+        end
+    end
+
+    after do
+        Puppet::Type::File.clear
+    end
+end