puppet 0.23.2 → 0.24.0

data/test/other/relationship.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2006-11-24.
-#  Copyright (c) 2006. All rights reserved.
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppet/relationship'
-
-class TestRelationship < Test::Unit::TestCase
-    include PuppetTest
-    
-    def test_initialize
-        rel = Puppet::Relationship
-        
-        [["source", "target", "label"],
-         ["source", "target", {:event => :nothing}]
-        ].each do |ary|
-            # Make sure the label is required
-            assert_raise(Puppet::DevError) do
-                rel.new(*ary)
-            end
-        end
-    end
-    
-    def test_attributes
-        rel = Puppet::Relationship
-        
-        i = nil
-        assert_nothing_raised do
-            i = rel.new "source", "target", :event => :yay, :callback => :boo
-        end
-        
-        assert_equal(:yay, i.event, "event was not retrieved")
-        assert_equal(:boo, i.callback, "callback was not retrieved")
-        
-        # Now try it with nil values
-        assert_nothing_raised("failed to create with no event or callback") {
-            i = rel.new "source", "target"
-        }
-        
-        assert_nil(i.event, "event was not nil")
-        assert_nil(i.callback, "callback was not nil")
-    end
-
-    def test_match
-        edge = Puppet::Relationship.new(:a, :b)
-
-        assert(! edge.match?(:NONE), "nil event matched :NONE")
-        assert(! edge.match?(:ALL_EVENT), "nil event matched :ALL_EVENTS")
-        assert(! edge.match?(:random), "nil event matched random")
-
-        # Now set the edge to none
-        edge.label = {:event => :NONE}
-        assert(! edge.match?(:NONE), ":NONE event matched :NONE")
-        assert(! edge.match?(:ALL_EVENT), ":NONE event matched :ALL_EVENTS")
-        assert(! edge.match?(:random), ":NONE event matched random")
-
-        # Now set it to :ALL
-        edge.label = {:event => :ALL_EVENTS}
-        assert(! edge.match?(:NONE), ":ALL_EVENTS event matched :NONE")
-        assert(edge.match?(:ALL_EVENTS), ":ALL_EVENTS did not match :ALL_EVENTS")
-        assert(edge.match?(:random), ":ALL_EVENTS did not match random")
-
-        # And finally, :random
-        edge.label = {:event => :random}
-        assert(! edge.match?(:NONE), ":random event matched :NONE")
-        assert(! edge.match?(:ALL_EVENTS), ":random matched :ALL_EVENTS")
-        assert(edge.match?(:random), ":random did not match random")
-    end
-end
-
-# $Id: relationship.rb 1983 2006-12-29 04:15:36Z luke $

data/test/puppet/modules.rb

@@ -1,59 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-
-class TestModules < Test::Unit::TestCase
-	include PuppetTest
-
-    def setup
-        super
-        @varmods = File::join(Puppet[:vardir], "modules")
-        FileUtils::mkdir_p(@varmods)
-    end
-
-    def test_modulepath
-        Puppet[:modulepath] = "$vardir/modules:/no/such/path/anywhere:.::"
-        assert_equal([ @varmods ], Puppet::Module.modulepath)
-    end
-
-    def test_find
-        assert_nil(Puppet::Module::find("/tmp"))
-
-        file = "testmod/something"
-        assert_nil(Puppet::Module::find(file))
-
-        path = File::join(@varmods, "testmod")
-        FileUtils::mkdir_p(path)
-
-        mod = Puppet::Module::find("testmod")
-        assert_not_nil(mod)
-        assert_equal("testmod", mod.name)
-        assert_equal(path, mod.path)
-
-        mod = Puppet::Module::find(file)
-        assert_not_nil(mod)
-        assert_equal("testmod", mod.name)
-        assert_equal(path, mod.path)
-    end
-
-    def test_find_template
-        templ = "testmod/templ.erb"
-        assert_equal(File::join(Puppet[:templatedir], templ),
-                     Puppet::Module::find_template(templ))
-
-        templ_path = File::join(@varmods, "testmod",
-                                Puppet::Module::TEMPLATES, "templ.erb")
-        FileUtils::mkdir_p(File::dirname(templ_path))
-        File::open(templ_path, "w") { |f| f.puts "Howdy" }
-
-        assert_equal(templ_path, Puppet::Module::find_template(templ))
-
-        mod = Puppet::Module::find(templ)
-        assert_not_nil(mod)
-        assert_equal(templ_path, mod.template(templ))
-    end
-end
-
-# $Id: modules.rb 2655 2007-07-06 22:22:10Z luke $

data/test/rails/collection.rb

@@ -1,247 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppet'
-require 'puppet/rails'
-require 'puppettest'
-require 'puppettest/railstesting'
-require 'puppettest/resourcetesting'
-
-
-# A separate class for testing rails integration
-class TestRailsCollection < PuppetTest::TestCase
-    confine "Missing rails support" => Puppet.features.rails?
-	include PuppetTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    include PuppetTest::RailsTesting
-    Parser = Puppet::Parser
-    AST = Parser::AST
-
-    def setup
-        super
-        Puppet[:trace] = false
-        @interp, @scope, @source = mkclassframing
-    end
-
-    def test_collect_exported
-        railsinit
-
-        # Set a hostname
-        @scope.host = Facter.value(:hostname)
-
-        # make an exported resource
-        exported = mkresource(:type => "file", :title => "/tmp/exported",
-            :exported => true, :params => {:owner => "root"})
-        @scope.setresource exported
-
-        assert(exported.exported?, "Object was not marked exported")
-        assert(exported.virtual?, "Object was not marked virtual")
-
-        # And a non-exported
-        real = mkresource(:type => "file", :title => "/tmp/real",
-            :params => {:owner => "root"})
-        @scope.setresource real
-
-        # Now make a collector
-        coll = nil
-        assert_nothing_raised do
-            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
-        end
-
-        # Set it in our scope
-        @scope.newcollection(coll)
-
-        # Make sure it's in the collections
-        assert_equal([coll], @scope.collections)
-
-        # And try to collect the virtual resources.
-        ret = nil
-        assert_nothing_raised do
-            ret = coll.collect_exported
-        end
-
-        assert_equal([exported], ret)
-
-        # Now make sure evaluate does the right thing.
-        assert_nothing_raised do
-            ret = coll.evaluate
-        end
-
-        # Make sure that the collection does not find the resource on the
-        # next run.
-        ret = nil
-        assert_nothing_raised do
-            ret = coll.collect_exported
-        end
-
-        assert(ret.empty?, "Exported resource was collected on the second run")
-
-
-        # And make sure our exported object is no longer exported
-        assert(! exported.virtual?, "Virtual object did not get realized")
-
-        # But it should still be marked exported.
-        assert(exported.exported?, "Resource got un-exported")
-
-        # Now make a new collector of a different type and make sure it
-        # finds nothing.
-        assert_nothing_raised do
-            coll = Puppet::Parser::Collector.new(@scope, "exec", nil, nil, :exported)
-        end
-
-        # Remark this as virtual
-        exported.virtual = true
-
-        assert_nothing_raised do
-            ret = coll.evaluate
-        end
-
-        assert(! ret, "got resources back")
-
-        # Now create a whole new scope and make sure we can actually retrieve
-        # the resource from the database, not just from the scope.
-        # First create a host object and store our resource in it.
-
-        # Now collect our facts
-        facts = {}
-        Facter.each do |fact, value| facts[fact] = value end 
-
-        # Now try storing our crap
-        # Remark this as exported
-        exported.exported = true
-        host = Puppet::Rails::Host.store(
-            :resources => [exported],
-            :facts => facts,
-            :name => facts["hostname"]
-        )
-        assert(host, "did not get rails host")
-        host.save
-
-        # And make sure it's in there
-        newres = host.resources.find_by_restype_and_title_and_exported("file", "/tmp/exported", true)
-        assert(newres, "Did not find resource in db")
-        interp, scope, source = mkclassframing
-        scope.host = "two"
-
-        # Now make a collector
-        coll = nil
-        assert_nothing_raised do
-            coll = Puppet::Parser::Collector.new(scope, "file", nil, nil, :exported)
-        end
-
-        # Set it in our scope
-        scope.newcollection(coll)
-
-        # Make sure it's in the collections
-        assert_equal([coll], scope.collections)
-
-        # And try to collect the virtual resources.
-        ret = nil
-        assert_nothing_raised do
-            ret = coll.collect_exported
-        end
-
-        assert_equal(["/tmp/exported"], ret.collect { |f| f.title })
-
-        # Make sure we can evaluate the same collection multiple times and
-        # that later collections do nothing
-        assert_nothing_raised("Collection found same resource twice") do
-            ret = coll.evaluate
-        end
-    end
-
-    def test_collection_conflicts
-        railsinit
-
-        # First make a railshost we can conflict with
-        host = Puppet::Rails::Host.new(:name => "myhost")
-
-        host.resources.build(:title => "/tmp/conflicttest", :restype => "file",
-            :exported => true)
-
-        host.save
-
-        # Now make a normal resource
-        normal = mkresource(:type => "file", :title => "/tmp/conflicttest",
-            :params => {:owner => "root"})
-        @scope.setresource normal
-        @scope.host = "otherhost"
-
-        # Now make a collector
-        coll = nil
-        assert_nothing_raised do
-            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
-        end
-
-        # And try to collect the virtual resources.
-        assert_raise(Puppet::ParseError) do
-            ret = coll.collect_exported
-        end
-    end
-
-    # Make sure we do not collect resources from the host we're on
-    def test_no_resources_from_me
-        railsinit
-
-        # Make our configuration
-        host = Puppet::Rails::Host.new(:name => "myhost")
-
-        host.resources.build(:title => "/tmp/hosttest", :restype => "file",
-            :exported => true)
-
-        host.save
-
-        @scope.host = "myhost"
-
-        # Now make a collector
-        coll = nil
-        assert_nothing_raised do
-            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
-        end
-
-        # And make sure we get nada back
-        ret = nil
-        assert_nothing_raised do
-            ret = coll.collect_exported
-        end
-
-        assert(ret.empty?, "Found exports from our own host")
-    end
-
-    # #731 -- we're collecting all resources, not just exported resources.
-    def test_only_collecting_exported_resources
-        railsinit
-
-        # Make our configuration
-        host = Puppet::Rails::Host.new(:name => "myhost")
-
-        host.resources.build(:title => "/tmp/exporttest1", :restype => "file",
-            :exported => true)
-        host.resources.build(:title => "/tmp/exporttest2", :restype => "file",
-            :exported => false)
-
-        host.save
-
-        @scope.host = "otherhost"
-
-        # Now make a collector
-        coll = nil
-        assert_nothing_raised do
-            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
-        end
-
-        # And make sure we get nada back
-        ret = nil
-        assert_nothing_raised do
-            ret = coll.collect_exported
-        end
-
-        names = ret.collect { |res| res.title }
-
-        assert_equal(%w{/tmp/exporttest1}, names, "Collected incorrect resource list")
-    end
-end
-
-# $Id: collection.rb 2746 2007-08-05 17:57:31Z luke $

data/test/rails/interpreter.rb

@@ -1,91 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppet/parser/interpreter'
-require 'puppet/parser/parser'
-require 'puppet/network/client'
-require 'puppet/rails'
-require 'puppettest/resourcetesting'
-require 'puppettest/parsertesting'
-require 'puppettest/servertest'
-require 'puppettest/railstesting'
-
-
-class InterpreterRailsTests < PuppetTest::TestCase
-	include PuppetTest
-    include PuppetTest::ServerTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    include PuppetTest::RailsTesting
-    AST = Puppet::Parser::AST
-    NodeDef = Puppet::Parser::Interpreter::NodeDef
-    confine "No rails support" => Puppet.features.rails?
-
-    # We need to make sure finished objects are stored in the db.
-    def test_finish_before_store
-        railsinit
-        interp = mkinterp
-
-        node = interp.newnode ["myhost"], :code => AST::ASTArray.new(:children => [
-            resourcedef("file", "/tmp/yay", :group => "root"),
-            defaultobj("file", :owner => "root")
-        ])
-
-        interp.newclass "myclass", :code => AST::ASTArray.new(:children => [
-        ])
-
-        interp.newclass "sub", :parent => "myclass",
-            :code => AST::ASTArray.new(:children => [
-                resourceoverride("file", "/tmp/yay", :owner => "root")
-            ]
-        )
-
-        # Now do the rails crap
-        Puppet[:storeconfigs] = true
-
-        interp.evaluate("myhost", {})
-
-        # And then retrieve the object from rails
-        #res = Puppet::Rails::Resource.find_by_restype_and_title("file", "/tmp/yay", :include => {:param_values => :param_names})
-        res = Puppet::Rails::Resource.find_by_restype_and_title("file", "/tmp/yay")
-
-        assert(res, "Did not get resource from rails")
-
-        params = res.parameters
-
-        assert_equal(["root"], params["owner"], "Did not get correct value for owner param")
-    end
-
-    def test_hoststorage
-        assert_nothing_raised {
-            Puppet[:storeconfigs] = true
-        }
-
-        file = tempfile()
-        File.open(file, "w") { |f|
-            f.puts "file { \"/etc\": owner => root }"
-        }
-
-        interp = nil
-        assert_nothing_raised {
-            interp = Puppet::Parser::Interpreter.new(
-                :Manifest => file,
-                :UseNodes => false,
-                :ForkSave => false
-            )
-        }
-
-        facts = {}
-        Facter.each { |fact, val| facts[fact] = val }
-
-        objects = nil
-        assert_nothing_raised {
-            objects = interp.run(facts["hostname"], facts)
-        }
-
-        obj = Puppet::Rails::Host.find_by_name(facts["hostname"])
-        assert(obj, "Could not find host object")
-    end
-end