puppet 0.18.4 → 0.22.4

data/test/lib/puppettest/reporttesting.rb

@@ -0,0 +1,19 @@
+module PuppetTest::Reporttesting
+    def fakereport
+        # Create a bunch of log messages in an array.
+        report = Puppet::Transaction::Report.new
+
+        3.times { |i|
+            # We have to use warning so that the logs always happen
+            log = Puppet.warning("Report test message %s" % i)
+            log.tags = %w{a list of tags}
+            log.tags << "tag%s" % i
+
+            report.newlog(log)
+        }
+
+        return report
+    end
+end
+
+# $Id: reporttesting.rb 1797 2006-10-17 15:12:48Z luke $

data/test/lib/puppettest/resourcetesting.rb

@@ -0,0 +1,73 @@
+module PuppetTest::ResourceTesting
+    Parser = Puppet::Parser
+    AST = Puppet::Parser::AST
+    def mkclassframing(interp = nil)
+        interp ||= mkinterp
+
+        interp.newdefine("resource", :arguments => [%w{one}, %w{two value}, %w{three}])
+        interp.newclass("")
+        source = interp.newclass("base")
+        interp.newclass("sub1", :parent => "base")
+        interp.newclass("sub2", :parent => "base")
+        interp.newclass("other")
+
+        scope = Parser::Scope.new(:interp => interp)
+        scope.source = source
+
+        return interp, scope, source
+    end
+
+    def mkevaltest(interp = nil)
+        interp ||= mkinterp
+        @interp.newdefine("evaltest",
+            :arguments => [%w{one}, ["two", stringobj("755")]],
+            :code => resourcedef("file", "/tmp",
+                "owner" => varref("one"), "mode" => varref("two"))
+        )
+    end
+
+    def mkresource(args = {})
+
+        if args[:scope] and ! args[:source]
+            args[:source] = args[:scope].source
+        end
+
+        unless args[:scope]
+            unless defined? @scope
+                raise "Must set @scope to mkresource"
+            end
+        end
+
+        {:type => "resource", :title => "testing",
+            :source => @source, :scope => @scope}.each do |param, value|
+                args[param] ||= value
+        end
+
+        unless args[:source].is_a?(Puppet::Parser::AST::HostClass)
+            args[:source] = args[:scope].findclass(args[:source])
+        end
+
+        params = args[:params] || {:one => "yay", :three => "rah"}
+        if args[:params] == :none
+            args.delete(:params)
+        else
+            args[:params] = paramify args[:source], params
+        end
+
+        Parser::Resource.new(args)
+    end
+
+    def param(name, value, source)
+        Parser::Resource::Param.new(:name => name, :value => value, :source => source)
+    end
+
+    def paramify(source, hash)
+        hash.collect do |name, value|
+            Parser::Resource::Param.new(
+                :name => name, :value => value, :source => source
+            )
+        end
+    end
+end
+
+# $Id: resourcetesting.rb 1739 2006-10-06 03:13:15Z luke $

data/test/lib/puppettest/servertest.rb

@@ -0,0 +1,72 @@
+require 'puppettest'
+require 'puppet/network/server/webrick'
+
+module PuppetTest::ServerTest
+    include PuppetTest
+    def setup
+        super
+
+        if defined? @@port
+            @@port += 1
+        else
+            @@port = 20000
+        end
+    end
+
+    # create a simple manifest that just creates a file
+    def mktestmanifest
+        file = File.join(Puppet[:confdir], "%ssite.pp" % (self.class.to_s + "test"))
+        #@createdfile = File.join(tmpdir(), self.class.to_s + "manifesttesting" +
+        #    "_" + @method_name)
+        @createdfile = tempfile()
+
+        File.open(file, "w") { |f|
+            f.puts "file { \"%s\": ensure => file, mode => 755 }\n" % @createdfile
+        }
+
+        @@tmpfiles << @createdfile
+        @@tmpfiles << file
+
+        return file
+    end
+
+    # create a server, forked into the background
+    def mkserver(handlers = nil)
+        Puppet[:name] = "puppetmasterd"
+        # our default handlers
+        unless handlers
+            handlers = {
+                :CA => {}, # so that certs autogenerate
+                :Master => {
+                    :Manifest => mktestmanifest(),
+                    :UseNodes => false
+                },
+            }
+        end
+
+        # then create the actual server
+        server = nil
+        assert_nothing_raised {
+            server = Puppet::Network::Server::WEBrick.new(
+                :Port => @@port,
+                :Handlers => handlers
+            )
+        }
+
+        # fork it
+        spid = fork {
+            trap(:INT) { server.shutdown }
+            server.start
+        }
+
+        # and store its pid for killing
+        @@tmppids << spid
+
+        # give the server a chance to do its thing
+        sleep 1 
+        return spid
+    end
+
+end
+
+# $Id$

data/test/lib/puppettest/support.rb

@@ -0,0 +1,8 @@
+require 'puppettest'
+
+module PuppetTest::Support
+end
+
+require 'puppettest/support/assertions'
+require 'puppettest/support/helpers'
+require 'puppettest/support/utils'

data/test/lib/puppettest/support/assertions.rb

@@ -0,0 +1,101 @@
+require 'puppettest'
+require 'fileutils'
+
+module PuppetTest
+    def assert_logged(level, regex, msg = nil)
+        # Skip verifying logs that we're not supposed to send.
+        return unless Puppet::Util::Log.sendlevel?(level)
+        r = @logs.detect { |l| l.level == level and l.message =~ regex }
+        @logs.clear
+        assert(r, msg)
+    end
+
+    def assert_uid_gid(uid, gid, filename)
+        flunk "Must be uid 0 to run these tests" unless Process.uid == 0
+
+        fork do 
+            Puppet::Util::SUIDManager.gid = gid
+            Puppet::Util::SUIDManager.uid = uid
+            # FIXME: use the tempfile method from puppettest.rb
+            system("mkfifo "+filename)
+            f = File.open(filename, "w")
+            f << "#{Puppet::Util::SUIDManager.uid}\n#{Puppet::Util::SUIDManager.gid}\n"
+            yield if block_given?
+        end
+
+        # avoid a race.
+        true while !File.exists? filename
+
+        f = File.open(filename, "r")
+
+        a = f.readlines 
+        assert_equal(uid, a[0].chomp.to_i, "UID was incorrect")
+        assert_equal(gid, a[1].chomp.to_i, "GID was incorrect")
+        FileUtils.rm(filename)
+    end
+
+    def assert_rollback_events(events, trans, msg = nil)
+        run_events(:rollback, events, trans, msg)
+    end
+
+    def assert_events(events, *items)
+        trans = nil
+        comp = nil
+        msg = nil
+
+        unless events.is_a? Array
+            raise Puppet::DevError, "Incorrect call of assert_events"
+        end
+        if items[-1].is_a? String
+            msg = items.pop
+        end
+
+        remove_comp = false
+        # They either passed a comp or a list of items.
+        if items[0].is_a? Puppet.type(:component)
+            comp = items.shift
+        else
+            comp = newcomp(items[0].title, *items)
+            remove_comp = true
+        end
+        msg ||= comp.title
+        assert_nothing_raised("Component %s failed" % [msg]) {
+            trans = comp.evaluate
+        }
+
+        run_events(:evaluate, trans, events, msg)
+
+        if remove_comp
+            Puppet.type(:component).delete(comp)
+        end
+
+        return trans
+    end
+
+    # A simpler method that just applies what we have.
+    def assert_apply(*objects)
+        if objects[0].is_a?(Puppet.type(:component))
+            comp = objects.shift
+            unless objects.empty?
+                objects.each { |o| comp.push o }
+            end
+        else
+            comp = newcomp(*objects)
+        end
+        trans = nil
+
+        assert_nothing_raised("Failed to create transaction") {
+            trans = comp.evaluate
+        }
+
+        events = nil
+        assert_nothing_raised("Failed to evaluate transaction") {
+            events = trans.evaluate.collect { |e| e.event }
+        }
+        trans.cleanup
+        Puppet.type(:component).delete(comp)
+        events
+    end
+end
+
+# $Id$

data/test/lib/puppettest/support/helpers.rb

@@ -0,0 +1,23 @@
+require 'puppettest'
+
+module PuppetTest
+    # NOTE: currently both of these will produce bogus results on Darwin due to the wonderful
+    # UID of nobody.
+    def nonrootuser
+        Etc.passwd { |user|
+            if user.uid != Puppet::Util::SUIDManager.uid and user.uid > 0 and user.uid < 255
+                return user
+            end
+        }
+    end
+
+    def nonrootgroup
+        Etc.group { |group|
+            if group.gid != Puppet::Util::SUIDManager.gid and group.gid > 0 and group.gid < 255
+                return group
+            end
+        }
+    end
+end
+
+# $Id$

data/test/lib/puppettest/support/resources.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-11-29.
+#  Copyright (c) 2006. All rights reserved.
+
+module PuppetTest::Support::Resources
+    def treefile(name)
+        Puppet::Type.type(:file).create :path => "/tmp/#{name}", :mode => 0755
+    end
+    
+    def treecomp(name)
+        Puppet::Type::Component.create :name => name, :type => "yay"
+    end
+    
+    def treenode(name, *children)
+        comp = treecomp name
+        children.each do |c| 
+            if c.is_a?(String)
+                comp.push treefile(c)
+            else
+                comp.push c
+            end
+        end
+        return comp
+    end
+    
+    def mktree
+        one = treenode("one", "a", "b")
+        two = treenode("two", "c", "d")
+        middle = treenode("middle", "e", "f", two)
+        top = treenode("top", "g", "h", middle, one)
+        
+        return one, two, middle, top
+    end
+end
+
+# $Id: resources.rb 1896 2006-12-01 04:11:11Z luke $

data/test/lib/puppettest/support/utils.rb

@@ -0,0 +1,160 @@
+require 'puppettest'
+
+module PuppetTest
+    def gcdebug(type)
+        Puppet.warning "%s: %s" % [type, ObjectSpace.each_object(type) { |o| }]
+    end
+
+    #
+    # TODO: I think this method needs to be renamed to something a little more
+    # explanatory.
+    #
+
+    def newobj(type, name, hash)
+        transport = Puppet::TransObject.new(name, "file")
+        transport[:path] = path
+        transport[:ensure] = "file"
+        assert_nothing_raised {
+            file = transport.to_type
+        }
+    end
+
+    # stop any services that might be hanging around
+    def stopservices
+        if stype = Puppet::Type.type(:service)
+            stype.each { |service|
+                service[:ensure] = :stopped
+                service.evaluate
+            }
+        end
+    end
+
+    # TODO: rewrite this to use the 'etc' module.
+
+    def setme
+        # retrieve the user name
+        id = %x{id}.chomp
+        if id =~ /uid=\d+\(([^\)]+)\)/
+            @me = $1
+        else
+            puts id
+        end
+        unless defined? @me
+            raise "Could not retrieve user name; 'id' did not work"
+        end
+    end
+
+    def run_events(type, trans, events, msg)
+        case type
+        when :evaluate, :rollback: # things are hunky-dory
+        else
+            raise Puppet::DevError, "Incorrect run_events type"
+        end
+
+        method = type
+
+        newevents = nil
+        assert_nothing_raised("Transaction %s %s failed" % [type, msg]) {
+            newevents = trans.send(method).reject { |e| e.nil? }.collect { |e|
+                e.event
+            }
+        }
+
+        assert_equal(events, newevents, "Incorrect %s %s events" % [type, msg])
+
+        return trans
+    end
+
+    # If there are any fake data files, retrieve them
+    def fakedata(dir)
+        ary = [basedir, "test"]
+        ary += dir.split("/")
+        dir = File.join(ary)
+
+        unless FileTest.exists?(dir)
+            raise Puppet::DevError, "No fakedata dir %s" % dir
+        end
+        files = Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f|
+            File.join(dir, f)
+        }
+
+        return files
+    end
+
+    def fakefile(name)
+        ary = [basedir, "test"]
+        ary += name.split("/")
+        file = File.join(ary)
+        unless FileTest.exists?(file)
+            raise Puppet::DevError, "No fakedata file %s" % file
+        end
+        return file
+    end
+
+    # wrap how to retrieve the masked mode
+    def filemode(file)
+        File.stat(file).mode & 007777
+    end
+
+    def memory
+        Puppet::Util.memory
+    end
+
+    # a list of files that we can parse for testing
+    def textfiles
+        textdir = datadir "snippets"
+        Dir.entries(textdir).reject { |f|
+            f =~ /^\./ or f =~ /fail/
+        }.each { |f|
+            yield File.join(textdir, f)
+        }
+    end
+
+    def failers
+        textdir = datadir "failers"
+        # only parse this one file now
+        files = Dir.entries(textdir).reject { |file|
+            file =~ %r{\.swp}
+        }.reject { |file|
+            file =~ %r{\.disabled}
+        }.collect { |file|
+            File.join(textdir,file)
+        }.find_all { |file|
+            FileTest.file?(file)
+        }.sort.each { |file|
+            Puppet.debug "Processing %s" % file
+            yield file
+        }
+    end
+
+    def newcomp(*ary)
+        name = nil
+        if ary[0].is_a?(String)
+            name = ary.shift
+        else
+            name = ary[0].title
+        end
+
+        comp = Puppet.type(:component).create(:name => name)
+        ary.each { |item|
+            comp.push item
+        }
+
+        return comp
+    end
+    
+    def setme
+        # retrieve the user name
+        id = %x{id}.chomp 
+        if id =~ /uid=\d+\(([^\)]+)\)/
+            @me = $1
+        else
+            puts id
+        end 
+        unless defined? @me
+            raise "Could not retrieve user name; 'id' did not work"
+        end
+    end
+end
+
+# $Id$