puppet 0.18.4 → 0.22.4

data/test/lib/puppettest/fakes.rb

@@ -0,0 +1,194 @@
+require 'puppettest'
+
+module PuppetTest
+    # A baseclass for the faketypes.
+    class FakeModel
+        include Puppet::Util
+        class << self
+            attr_accessor :name, :realmodel
+            @name = :fakemodel
+        end
+
+        def self.namevar
+            @realmodel.namevar
+        end
+
+        def self.validproperties
+            Puppet::Type.type(@name).validproperties
+        end
+
+        def self.validproperty?(name)
+            Puppet::Type.type(@name).validproperty?(name)
+        end
+
+        def self.to_s
+            "Fake%s" % @name.to_s.capitalize
+        end
+
+        def [](param)
+            if @realmodel.attrtype(param) == :property
+                @is[param]
+            else
+                @params[param]
+            end
+        end
+
+        def []=(param, value)
+            param = symbolize(param)
+            unless @realmodel.validattr?(param)
+                raise Puppet::DevError, "Invalid attribute %s for %s" %
+                    [param, @realmodel.name]
+            end
+            if @realmodel.attrtype(param) == :property
+                @should[param] = value
+            else
+                @params[param] = value
+            end
+        end
+
+        def initialize(name)
+            @realmodel = Puppet::Type.type(self.class.name)
+            raise "Could not find type #{self.class.name}" unless @realmodel
+            @is = {}
+            @should = {}
+            @params = {}
+            self[@realmodel.namevar] = name
+        end
+
+        def inspect
+            "%s(%s)" % [self.class.to_s.sub(/.+::/, ''), super()]
+        end
+
+        def is(param)
+            @is[param]
+        end
+
+        def should(param)
+            @should[param]
+        end
+
+        def to_hash
+            hash = @params.dup
+            [@is, @should].each do |h|
+                h.each do |p, v|
+                    hash[p] = v
+                end
+            end
+            hash
+        end
+
+        def name
+            self[:name]
+        end
+    end
+
+    class FakeProvider
+        attr_accessor :model
+        class << self
+            attr_accessor :name, :model, :methods
+        end
+
+        # A very low number, so these never show up as defaults via the standard
+        # algorithms.
+        def self.defaultnum
+            -50
+        end
+
+        # Set up methods to fake things
+        def self.apimethods(*ary)
+            @model.validproperties.each do |property|
+                ary << property unless ary.include? property
+            end
+            attr_accessor(*ary)
+
+            @methods = ary
+        end
+
+        def self.default?
+            false
+        end
+
+        def self.initvars
+            @calls = Hash.new do |hash, key|
+                hash[key] = 0
+            end
+        end
+
+        def self.supports_parameter?(param)
+            true
+        end
+
+        def self.suitable?
+            true
+        end
+
+        def clear
+            @model = nil
+        end
+
+        def initialize(model)
+            @model = model
+        end
+    end
+
+    class FakeParsedProvider < FakeProvider
+        def hash
+            ret = {}
+            instance_variables.each do |v|
+                v = v.sub("@", '')
+                if val = self.send(v)
+                    ret[v.intern] = val
+                end
+            end
+
+            return ret
+        end 
+
+        def store(hash)
+            hash.each do |n, v|
+                method = n.to_s + "="
+                if respond_to? method
+                    send(method, v)
+                end
+            end
+        end
+    end
+
+    @@fakemodels = {}
+    @@fakeproviders = {}
+
+    def fakemodel(type, name, options = {})
+        type = type.intern if type.is_a? String
+        unless @@fakemodels.include? type
+            @@fakemodels[type] = Class.new(FakeModel)
+            @@fakemodels[type].name = type
+
+            model = Puppet::Type.type(type)
+            raise("Could not find type %s" % type) unless model
+            @@fakemodels[type].realmodel = model
+        end
+
+        obj = @@fakemodels[type].new(name)
+        options.each do |name, val|
+            obj[name] = val
+        end
+        obj
+    end
+
+    module_function :fakemodel
+
+    def fakeprovider(type, model)
+        type = type.intern if type.is_a? String
+        unless @@fakeproviders.include? type
+            @@fakeproviders[type] = Class.new(FakeModel) do
+                @name = type
+            end
+        end
+
+        @@fakeproviders[type].new(model)
+    end
+
+    module_function :fakeprovider
+end
+
+# $Id$

data/test/lib/puppettest/fileparsing.rb

@@ -0,0 +1,33 @@
+module PuppetTest::FileParsing
+    # Run an isomorphism test on our parsing process.
+    def fakedataparse(*files)
+        files.each do |file|
+            oldtarget = @provider.default_target
+            cleanup do
+                @provider.default_target = oldtarget
+            end
+            @provider.default_target = file
+
+            assert_nothing_raised("failed to fetch %s" % file) {
+                @provider.prefetch
+            }
+
+            text = nil
+            assert_nothing_raised("failed to generate %s" % file) do 
+                text = @provider.to_file(@provider.target_records(file))
+            end
+            text.gsub!(/^# HEADER.+\n/, '')
+
+            yield if block_given?
+
+            oldlines = File.readlines(file)
+            newlines = text.chomp.split "\n"
+            oldlines.zip(newlines).each do |old, new|
+                assert_equal(old.chomp.gsub(/\s+/, ''), new.gsub(/\s+/, ''),
+                    "Lines are not equal in %s" % file)
+            end
+        end
+    end
+end
+
+# $Id: fileparsing.rb 2296 2007-03-18 22:48:57Z luke $

data/test/lib/puppettest/filetesting.rb

@@ -0,0 +1,231 @@
+require 'puppettest'
+
+module PuppetTest::FileTesting
+    include PuppetTest
+    def cycle(comp)
+        trans = nil
+        assert_nothing_raised {
+            trans = comp.evaluate
+        }
+        assert_nothing_raised {
+            trans.evaluate
+        }
+    end
+
+    def randlist(list)
+        num = rand(4)
+        if num == 0
+            num = 1
+        end
+        set = []
+
+        ret = []
+        num.times { |index|
+            item = list[rand(list.length)]
+            if set.include?(item)
+                redo
+            end
+
+            ret.push item
+        }
+        return ret
+    end
+
+    def mkranddirsandfiles(dirs = nil,files = nil,depth = 3)
+        if depth < 0
+            return
+        end
+
+        unless dirs
+            dirs = %w{This Is A Set Of Directories}
+        end
+
+        unless files
+            files = %w{and this is a set of files}
+        end
+
+        tfiles = randlist(files)
+        tdirs = randlist(dirs)
+
+        tfiles.each { |file|
+            File.open(file, "w") { |of|
+                4.times {
+                    of.puts rand(100)
+                }
+            }
+        }
+
+        tdirs.each { |dir|
+            # it shouldn't already exist, but...
+            unless FileTest.exists?(dir)
+                Dir.mkdir(dir)
+                FileUtils.cd(dir) {
+                    mkranddirsandfiles(dirs,files,depth - 1)
+                }
+            end
+        }
+    end
+
+    def file_list(dir)
+        list = nil
+        FileUtils.cd(dir) {
+            list = %x{find . 2>/dev/null}.chomp.split(/\n/)
+        }
+        return list
+    end
+
+    def assert_trees_equal(fromdir,todir)
+        assert(FileTest.directory?(fromdir))
+        assert(FileTest.directory?(todir))
+
+        # verify the file list is the same
+        fromlist = nil
+        FileUtils.cd(fromdir) {
+            fromlist = %x{find . 2>/dev/null}.chomp.split(/\n/).reject { |file|
+            ! FileTest.readable?(file)
+        }.sort
+        }
+        tolist = file_list(todir).sort
+
+        fromlist.sort.zip(tolist.sort).each { |a,b|
+            assert_equal(a, b,
+        "Fromfile %s with length %s does not match tofile %s with length %s" %
+            [a, fromlist.length, b, tolist.length])
+        }
+        #assert_equal(fromlist,tolist)
+
+        # and then do some verification that the files are actually set up
+        # the same
+        checked = 0
+        fromlist.each_with_index { |file,i|
+            fromfile = File.join(fromdir,file)
+            tofile = File.join(todir,file)
+            fromstat = File.stat(fromfile)
+            tostat = File.stat(tofile)
+            [:ftype,:gid,:mode,:uid].each { |method|
+                assert_equal(
+                             fromstat.send(method),
+                             tostat.send(method)
+                            )
+
+                            next if fromstat.ftype == "directory"
+                            if checked < 10 and i % 3 == 0
+                                from = File.open(fromfile) { |f| f.read }
+                                to = File.open(tofile) { |f| f.read }
+
+                                assert_equal(from,to)
+                                checked += 1
+                            end
+            }
+        }
+    end
+
+    def random_files(dir)
+        checked = 0
+        list = file_list(dir)
+        list.reverse.each_with_index { |file,i|
+            path = File.join(dir,file)
+            stat = File.stat(dir)
+            if checked < 10 and (i % 3) == 2
+                unless yield path
+                    next
+                end
+                checked += 1
+            end
+        }
+    end
+
+    def delete_random_files(dir)
+        deleted = []
+        random_files(dir) { |file|
+            stat = File.stat(file)
+            begin
+                if stat.ftype == "directory"
+                    false
+                else
+                    deleted << file
+                    File.unlink(file)
+                    true
+                end
+            rescue => detail
+                # we probably won't be able to open our own secured files
+                puts detail
+                false
+            end
+        }
+
+        return deleted
+    end
+
+    def add_random_files(dir)
+        added = []
+        random_files(dir) { |file|
+            stat = File.stat(file)
+            begin
+                if stat.ftype == "directory"
+                    name = File.join(file,"file" + rand(100).to_s)
+                    File.open(name, "w") { |f|
+                        f.puts rand(10)
+                    }
+                    added << name
+                else
+                    false
+                end
+            rescue => detail
+                # we probably won't be able to open our own secured files
+                puts detail
+                false
+            end
+        }
+        return added
+    end
+
+    def modify_random_files(dir)
+        modded = []
+        random_files(dir) { |file|
+            stat = File.stat(file)
+            begin
+                if stat.ftype == "directory"
+                    false
+                else
+                    File.open(file, "w") { |f|
+                        f.puts rand(10)
+                    }
+                    modded << name
+                    true
+                end
+            rescue => detail
+                # we probably won't be able to open our own secured files
+                puts detail
+                false
+            end
+        }
+        return modded
+    end
+
+    def readonly_random_files(dir)
+        modded = []
+        random_files(dir) { |file|
+            stat = File.stat(file)
+            begin
+                if stat.ftype == "directory"
+                    File.new(file).chmod(0111)
+                else
+                    File.new(file).chmod(0000)
+                end
+                modded << file
+            rescue => detail
+                # we probably won't be able to open our own secured files
+                puts detail
+                false
+            end
+        }
+        return modded
+    end
+
+    def conffile
+        exampledir("root/etc/configfile")
+    end
+end
+
+# $Id: filetesting.rb 1632 2006-09-19 18:04:20Z luke $