puppet 0.16.0 → 0.18.4

data/test/language/rails.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/ruby
+
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/rails'
+require 'puppet/parser/interpreter'
+require 'puppet/parser/parser'
+require 'puppet/client'
+require 'test/unit'
+require 'puppettest'
+
+class TestRails < Test::Unit::TestCase
+	include ParserTesting
+
+    def test_includerails
+        assert_nothing_raised {
+            require 'puppet/rails'
+        }
+    end
+
+    # Don't do any tests w/out this class
+    if defined? ActiveRecord::Base
+    def test_hostcache
+        # First make some objects
+        bucket = mk_transtree do |object, depth, width|
+            # and mark some of them collectable
+            if width % 2 == 1
+                object.collectable = true
+            end
+        end
+
+        # Now collect our facts
+        facts = {}
+        Facter.each do |fact, value| facts[fact] = value end
+
+        assert_nothing_raised {
+            Puppet::Rails.init
+        }
+
+        # Now try storing our crap
+        host = nil
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.store(
+                :objects => bucket,
+                :facts => facts,
+                :host => facts["hostname"]
+            )
+        }
+
+        assert(host, "Did not create host")
+
+        host = nil
+        assert_nothing_raised {
+            host = Puppet::Rails::Host.find_by_name(facts["hostname"])
+        }
+        assert(host, "Could not find host object")
+
+        assert(host.rails_objects, "No objects on host")
+
+        assert_equal(facts["hostname"], host.facts["hostname"],
+            "Did not retrieve facts")
+
+        inline_test_objectcollection(host)
+    end
+
+    # This is called from another test, it just makes sense to split it out some
+    def inline_test_objectcollection(host)
+        # XXX For some reason, find_all doesn't work here at all.
+        collectable = []
+        host.rails_objects.each do |obj|
+            if obj.collectable?
+                collectable << obj
+            end
+        end
+
+        assert(collectable.length > 0, "Found no collectable objects")
+
+        collectable.each do |obj|
+            trans = nil
+            assert_nothing_raised {
+                trans = obj.to_trans
+            }
+            # Make sure that the objects do not retain their collectable
+            # nature.
+            assert(!trans.collectable, "Object from db was collectable")
+        end
+
+        # Now find all collectable objects directly through database APIs
+
+        list = Puppet::Rails::RailsObject.find_all_by_collectable(true)
+
+        assert_equal(collectable.length, list.length,
+            "Did not get the right number of objects")
+    end
+    else
+        $stderr.puts "Install Rails for Rails and Caching tests"
+    end
+end
+
+# $Id: rails.rb 1192 2006-05-14 02:42:21Z luke $

data/test/language/scope.rb

@@ -259,6 +259,16 @@ class TestScope < Test::Unit::TestCase
             val = scope.strinterp("string $test ${test} $test")
         }
         assert_equal("string value value value", val)
+
+        assert_nothing_raised {
+            val = scope.strinterp("string \\$test")
+        }
+        assert_equal("string $test", val)
+
+        assert_nothing_raised {
+            val = scope.strinterp("\\$test string")
+        }
+        assert_equal("$test string", val)
     end
 
     # Test some of the host manipulations
@@ -430,18 +440,17 @@ class TestScope < Test::Unit::TestCase
         scope = nil
         assert_nothing_raised("Could not evaluate") {
             scope = Puppet::Parser::Scope.new()
-            #scope.name =  "topscope"
-            #scope.type =  "topscope"
             objects = scope.evaluate(:ast => top)
         }
 
         assert_equal(1, objects.length, "Returned too many objects: %s" %
             objects.inspect)
+
         assert_equal(1, objects[0].length, "Returned too many objects: %s" %
             objects[0].inspect)
+
         assert_nothing_raised {
             file = objects[0][0]
-
             assert_equal("bin", file["owner"], "Value did not override correctly")
         }
     end
@@ -530,13 +539,9 @@ class TestScope < Test::Unit::TestCase
             :children => stats
         )
         scope = Puppet::Parser::Scope.new()
-        assert_nothing_raised {
-            scope.evaluate(:ast => top)
-        }
-
         trans = nil
         assert_nothing_raised {
-            trans = scope.to_trans
+            trans = scope.evaluate(:ast => top)
         }
 
         obj = trans.find do |obj| obj.is_a? Puppet::TransObject end
@@ -550,17 +555,306 @@ class TestScope < Test::Unit::TestCase
     def test_validclassnames
         scope = Puppet::Parser::Scope.new()
 
-        ["a-class", "a class", "Class", "a.class"].each do |bad|
+        ["a class", "Class", "a.class"].each do |bad|
             assert_raise(Puppet::ParseError, "Incorrectly allowed %s" % bad.inspect) do
                 scope.setclass(object_id, bad)
             end
         end
 
-        ["a_class", "class", "yayNess"].each do |good|
+        ["a-class", "a_class", "class", "yayNess"].each do |good|
             assert_nothing_raised("Incorrectly banned %s" % good.inspect) do
                 scope.setclass(object_id, good)
             end
         end
 
     end
+
+    def test_tagfunction
+        scope = Puppet::Parser::Scope.new()
+        
+        assert_nothing_raised {
+            scope.function_tag(["yayness", "booness"])
+        }
+
+        assert(scope.classlist.include?("yayness"), "tag 'yayness' did not get set")
+        assert(scope.classlist.include?("booness"), "tag 'booness' did not get set")
+
+        # Now verify that the 'tagged' function works correctly
+        assert(scope.function_tagged("yayness"),
+            "tagged function incorrectly returned false")
+        assert(scope.function_tagged("booness"),
+            "tagged function incorrectly returned false")
+
+        assert(! scope.function_tagged("funtest"),
+            "tagged function incorrectly returned true")
+    end
+
+    def test_includefunction
+        scope = Puppet::Parser::Scope.new()
+
+        one = tempfile()
+        two = tempfile()
+
+        children = []
+
+        children << classobj("one", :code => AST::ASTArray.new(
+            :children => [
+                fileobj(one, "owner" => "root")
+            ]
+        ))
+
+        children << classobj("two", :code => AST::ASTArray.new(
+            :children => [
+                fileobj(two, "owner" => "root")
+            ]
+        ))
+
+        children << Puppet::Parser::AST::Function.new(
+            :name => "include",
+            :ftype => :statement,
+            :arguments => AST::ASTArray.new(
+                :children => [nameobj("one"), nameobj("two")]
+            )
+        )
+
+        top = AST::ASTArray.new(:children => children)
+
+        #assert_nothing_raised {
+        #    scope.function_include(["one", "two"])
+        #}
+
+        assert_nothing_raised {
+            scope.evaluate(:ast => top)
+        }
+
+
+        assert(scope.classlist.include?("one"), "tag 'one' did not get set")
+        assert(scope.classlist.include?("two"), "tag 'two' did not get set")
+
+        # Now verify that the 'tagged' function works correctly
+        assert(scope.function_tagged("one"),
+            "tagged function incorrectly returned false")
+        assert(scope.function_tagged("two"),
+            "tagged function incorrectly returned false")
+    end
+
+    def test_definedfunction
+        scope = Puppet::Parser::Scope.new()
+
+        one = tempfile()
+        two = tempfile()
+
+        children = []
+
+        children << classobj("one", :code => AST::ASTArray.new(
+            :children => [
+                fileobj(one, "owner" => "root")
+            ]
+        ))
+
+        children << classobj("two", :code => AST::ASTArray.new(
+            :children => [
+                fileobj(two, "owner" => "root")
+            ]
+        ))
+
+        top = AST::ASTArray.new(:children => children)
+
+        top.evaluate(:scope => scope)
+
+        assert_nothing_raised {
+            %w{one two file user}.each do |type|
+                assert(scope.function_defined([type]),
+                    "Class #{type} was not considered defined")
+            end
+
+            assert(!scope.function_defined(["nopeness"]),
+                "Class 'nopeness' was incorrectly considered defined")
+        }
+
+
+    end
+
+    # Make sure components acquire defaults.
+    def test_defaultswithcomponents
+        children = []
+
+        # Create a component
+        filename = tempfile()
+        args = AST::ASTArray.new(
+            :file => tempfile(),
+            :line => rand(100),
+            :children => [nameobj("argument")]
+        )
+        children << compobj("comp", :args => args, :code => AST::ASTArray.new(
+            :children => [
+                fileobj(filename, "owner" => varref("argument") )
+            ]
+        ))
+
+        # Create a default
+        children << defaultobj("comp", "argument" => "yayness")
+
+        # lastly, create an object that calls our third component
+        children << objectdef("comp", "boo", {"argument" => "parentfoo"})
+
+        trans = assert_evaluate(children)
+
+        flat = trans.flatten
+
+        assert(!flat.empty?, "Got no objects back")
+
+        assert_equal("parentfoo", flat[0]["owner"], "default did not take")
+    end
+
+    if defined? ActiveRecord
+    # Verify that we recursively mark as collectable the results of collectable
+    # components.
+    def test_collectablecomponents
+        children = []
+
+        args = AST::ASTArray.new(
+            :file => tempfile(),
+            :line => rand(100),
+            :children => [nameobj("arg")]
+        )
+        # Create a top-level component
+        children << compobj("one", :args => args)
+
+        # And a component that calls it
+        children << compobj("two", :args => args, :code => AST::ASTArray.new(
+            :children => [
+                objectdef("one", "ptest", {"arg" => "parentfoo"})
+            ]
+        ))
+
+        # And then a third component that calls the second
+        children << compobj("three", :args => args, :code => AST::ASTArray.new(
+            :children => [
+                objectdef("two", "yay", {"arg" => "parentfoo"})
+            ]
+        ))
+
+        # lastly, create an object that calls our third component
+        obj = objectdef("three", "boo", {"arg" => "parentfoo"})
+
+        # And mark it as collectable
+        obj.collectable = true
+
+        children << obj
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        trans = nil
+        scope = nil
+        assert_nothing_raised {
+            scope = Puppet::Parser::Scope.new()
+            trans = scope.evaluate(:ast => top)
+        }
+
+        %w{file}.each do |type|
+            objects = scope.exported(type)
+
+            assert(!objects.empty?, "Did not get an exported %s" % type)
+        end
+    end
+
+    # Verify that we can both store and collect an object in the same
+    # run, whether it's in the same scope as a collection or a different
+    # scope.
+    def test_storeandcollect
+        Puppet[:storeconfigs] = true
+        Puppet::Rails.clear
+        Puppet::Rails.init
+        sleep 1
+        children = []
+        file = tempfile()
+        File.open(file, "w") { |f|
+            f.puts "
+class yay {
+    @host { myhost: ip => \"192.168.0.2\" }
+}
+include yay
+@host { puppet: ip => \"192.168.0.3\" }
+host <||>"
+        }
+
+        interp = nil
+        assert_nothing_raised {
+            interp = Puppet::Parser::Interpreter.new(
+                :Manifest => file,
+                :UseNodes => false,
+                :ForkSave => false
+            )
+        }
+
+        objects = nil
+        # We run it twice because we want to make sure there's no conflict
+        # if we pull it up from the database.
+        2.times { |i|
+            assert_nothing_raised {
+                objects = interp.run("localhost", {})
+            }
+
+            flat = objects.flatten
+
+            %w{puppet myhost}.each do |name|
+                assert(flat.find{|o| o.name == name }, "Did not find #{name}")
+            end
+        }
+    end
+
+    # Verify that we cannot override differently exported objects
+    def test_exportedoverrides
+        filename = tempfile()
+        children = []
+
+        obj = fileobj(filename, "owner" => "root")
+        obj.collectable = true
+        # create the parent class
+        children << classobj("parent", :code => AST::ASTArray.new(
+            :children => [
+                obj
+            ]
+        ))
+
+        # now create a child class with differ values
+        children << classobj("child", :parentclass => nameobj("parent"),
+            :code => AST::ASTArray.new(
+                :children => [
+                    fileobj(filename, "owner" => "bin")
+                ]
+        ))
+
+        # Now call the child class
+        assert_nothing_raised("Could not add AST nodes for calling") {
+            children << AST::ObjectDef.new(
+                :type => nameobj("child"),
+                :name => nameobj("yayness"),
+                :params => astarray()
+            )
+        }
+
+        top = nil
+        assert_nothing_raised("Could not create top object") {
+            top = AST::ASTArray.new(
+                :children => children
+            )
+        }
+
+        objects = nil
+        scope = nil
+        assert_raise(Puppet::ParseError, "Incorrectly allowed override") {
+            scope = Puppet::Parser::Scope.new()
+            objects = scope.evaluate(:ast => top)
+        }
+    end
+    else
+        $stderr.puts "No ActiveRecord -- skipping collection tests"
+    end
 end