puppet 0.22.4 → 0.23.0

data/test/rails/host.rb

@@ -12,7 +12,8 @@ require 'puppettest/parsertesting'
 require 'puppettest/resourcetesting'
 require 'puppettest/railstesting'
 
-class TestRailsHost < Test::Unit::TestCase
+class TestRailsHost < PuppetTest::TestCase
+    confine "Missing ActiveRecord" => Puppet.features.rails?
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
     include PuppetTest::RailsTesting
@@ -33,8 +34,6 @@ class TestRailsHost < Test::Unit::TestCase
         }
     end
 
-    # Don't do any tests w/out this class
-    if Puppet.features.rails?
     def test_store
         @interp, @scope, @source = mkclassframing
         # First make some objects
@@ -77,7 +76,7 @@ class TestRailsHost < Test::Unit::TestCase
         assert(host.resources, "No objects on host")
 
         facts.each do |fact, value|
-            assert_equal(value, host.fact(fact), "fact %s is wrong" % fact)
+            assert_equal(value, host.fact(fact)[0].value, "fact %s is wrong" % fact)
         end
         assert_equal(facts["ipaddress"], host.ip, "IP did not get set")
 
@@ -122,7 +121,8 @@ class TestRailsHost < Test::Unit::TestCase
         # And change some facts
         facts["test2"] = "yaytest"
         facts["test3"] = "funtest"
-        facts.delete("test1")
+        facts["test1"] = "changedfact"
+        facts.delete("ipaddress")
         host = nil
         assert_nothing_raised {
             host = Puppet::Rails::Host.store(
@@ -138,9 +138,9 @@ class TestRailsHost < Test::Unit::TestCase
             assert_instance_of(Time, host.last_compile, "did not set last_compile")
         end
 
-        assert_nil(host.fact('test1'), "removed fact was not deleted")
+        assert_equal(0, host.fact('ipaddress').size, "removed fact was not deleted")
         facts.each do |fact, value|
-            assert_equal(value, host.fact(fact), "fact %s is wrong" % fact)
+            assert_equal(value, host.fact(fact)[0].value, "fact %s is wrong" % fact)
         end
 
         # And check the changes we made.
@@ -151,27 +151,52 @@ class TestRailsHost < Test::Unit::TestCase
         assert(res, "New resource was not added")
         assert_equal("user_added", res.parameter("owner"), "user info was not stored")
 
-        # This actually works in real life, but I can't get it to work in testing.
-        # I expect it's a caching problem.
-        count = 0
-        host.resources.find(:all).find_all { |r| r.title =~ /file2/ }.each do |r|
-            r.save
-            puts "%s => %s" % [r.ref, r.parameters.inspect]
+        host.resources.find(:all, :conditions => [ "title like ?", "%file2%"]).each do |r|
             assert_equal("notice", r.parameter("loglevel"),
                 "loglevel was not added")
-            case r.restype
-            when "file":
-                assert_equal("fake", r.parameter("owner"), "owner was not modified")
-            when "exec":
-                assert_equal("fake", r.parameter("user"), "user was not modified")
-            else
-                raise "invalid resource type %s" % r.restype
-            end
         end
     end
-    else
-        $stderr.puts "Install Rails for Rails and Caching tests"
+
+    def test_freshness_connect_update
+        Puppet::Rails.init
+        Puppet[:storeconfigs] = true
+
+        # this is the default server setup
+        master = Puppet::Network::Handler.master.new(
+            :Code => "",
+            :UseNodes => true,
+            :Local => true
+        )
+
+        # Create a host
+        Puppet::Rails::Host.new(:name => "test", :ip => "192.168.0.3").save
+
+        assert_nothing_raised("Failed to update last_connect for unknown host") do
+            master.freshness("created",'192.168.0.1')
+        end
+        
+        # Make sure it created the host
+        created = Puppet::Rails::Host.find_by_name("created")
+        assert(created, "Freshness did not create host")
+        assert(created.last_freshcheck,
+            "Did not set last_freshcheck on created host")
+        assert_equal("192.168.0.1", created.ip,
+            "Did not set IP address on created host")
+
+        # Now check on the existing host
+        assert_nothing_raised("Failed to update last_connect for unknown host") do
+            master.freshness("test",'192.168.0.2')
+        end
+
+        # Recreate it, so we're not using the cached object.
+        host = Puppet::Rails::Host.find_by_name("test")
+        
+        # Make sure it created the host
+        assert(host.last_freshcheck,
+            "Did not set last_freshcheck on existing host")
+        assert_equal("192.168.0.3", host.ip,
+            "Overrode IP on found host")
     end
 end
 
-# $Id: host.rb 2296 2007-03-18 22:48:57Z luke $
+# $Id: host.rb 2616 2007-06-18 21:03:18Z luke $

data/test/rails/interpreter.rb

@@ -0,0 +1,91 @@
+#!/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

data/test/rails/railsparameter.rb

@@ -12,6 +12,10 @@ if defined? ActiveRecord::Base
 class TestRailsParameter < Test::Unit::TestCase
     include PuppetTest::RailsTesting
     
+    def params
+        {"myname" => "myval", "multiple" => %w{one two three}}
+    end
+
     # Create a resource param from a rails parameter
     def test_to_resourceparam
         railsinit
@@ -19,34 +23,41 @@ class TestRailsParameter < Test::Unit::TestCase
         # Now create a source
         interp = mkinterp
         source = interp.newclass "myclass"
+
+        host = Puppet::Rails::Host.new(:name => "myhost")
         
-        #FIXME Need to re-add file/line support
+        resource = host.resources.create(
+            :title => "/tmp/to_resource", 
+            :restype => "file",
+            :exported => true)
 
         # Use array and non-array values, to make sure we get things back in
         # the same form.
-        {"myname" => "myval", "multiple" => %w{one two three}}.each do |name, value|
-            param = Puppet::Rails::ParamName.new(:name => name)
+        params.each do |name, value|
+            param = Puppet::Rails::ParamName.find_or_create_by_name(name)
             if value.is_a? Array
                 values = value
             else
                 values = [value]
             end
             valueobjects = values.collect do |v|
-                obj = Puppet::Rails::ParamValue.new(:value => v)
-                assert_nothing_raised do
-                    param.param_values << obj
-                end
+                resource.param_values.create(:value => v,
+                                             :param_name => param)
             end
 
             assert(param, "Did not create rails parameter")
 
             # The id doesn't get assigned until we save
-            param.save
+        end
+
+        resource.save
 
-            # And try to convert our parameter
+        # And try to convert our parameter
+        params.each do |name, value|
+            param = Puppet::Rails::ParamName.find_by_name(name)
             pp = nil
             assert_nothing_raised do
-                pp = param.to_resourceparam(source)
+                pp = param.to_resourceparam(resource, source)
             end
 
             assert_instance_of(Puppet::Parser::Resource::Param, pp)
@@ -59,4 +70,4 @@ else
     $stderr.puts "Install Rails for Rails and Caching tests"
 end
 
-# $Id: railsparameter.rb 2206 2007-02-17 01:52:59Z shadoi $
+# $Id: railsparameter.rb 2565 2007-06-12 00:31:16Z ballman $

data/test/rails/railsresource.rb

@@ -36,9 +36,9 @@ class TestRailsResource < Test::Unit::TestCase
 
         # Now add some params
         params.each do |param, value|
-            pn = resource.param_names.find_or_create_by_name(param)
-            pv = pn.param_values.find_or_create_by_value(value)
-            resource.param_names << pn
+            pn = Puppet::Rails::ParamName.find_or_create_by_name(param)
+            pv = resource.param_values.create(:value => value,
+                                              :param_name => pn)
         end
 
         host.save
@@ -58,7 +58,7 @@ class TestRailsResource < Test::Unit::TestCase
         interp, scope, source = mkclassframing
 
         # Find the new resource and include all it's parameters.
-        resource = Puppet::Rails::Resource.find_by_id(resource.id, :include => [ :param_names, :param_values ])
+        resource = Puppet::Rails::Resource.find_by_id(resource.id)
 
         # Now, try to convert our resource to a real resource
         res = nil
@@ -74,10 +74,12 @@ class TestRailsResource < Test::Unit::TestCase
 
     def test_parameters
         resource = mktest_resource
-
         setparams = nil
         assert_nothing_raised do
-            setparams = resource.parameters
+            setparams = resource.parameters.inject({}) { |h, a|
+                h[a[0]] = a[1][0]
+                h
+            }
         end
         assert_equal(params, setparams,
             "Did not get the right answer from #parameters")
@@ -96,5 +98,136 @@ else
     $stderr.puts "Install Rails for Rails and Caching tests"
 end
 
-# $Id: railsresource.rb 2206 2007-02-17 01:52:59Z shadoi $
+# A separate class for testing rails integration
+class TestExportedResources < PuppetTest::TestCase
+	include PuppetTest
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+    include PuppetTest::RailsTesting
+    Parser = Puppet::Parser
+    AST = Parser::AST
+    Reference = Puppet::Parser::Resource::Reference
+
+    def setup
+        super
+        Puppet[:trace] = false
+        @interp, @scope, @source = mkclassframing
+    end
+
+    confine "Missing rails support" => Puppet.features.rails?
+
+    # Compare a parser resource to a rails resource.
+    def compare_resources(host, res, updating, options = {})
+        newobj = nil
+
+        # If the resource is in the db, then use modify_rails, else use to_rails
+        if newobj = Puppet::Rails::Resource.find_by_restype_and_title(res.type, res.title)
+            assert_nothing_raised("Call to modify_rails failed") do
+                res.modify_rails(newobj)
+            end
+        else
+            assert_nothing_raised("Call to to_rails failed") do
+                newobj = res.to_rails(host)
+            end
+        end
+
+        assert_instance_of(Puppet::Rails::Resource, newobj)
+        newobj.save
+
+        if updating
+            tail = "on update"
+        else
+            tail = ""
+        end
+
+        # Make sure we find our object and only our object
+        count = 0
+        obj = nil
+        Puppet::Rails::Resource.find(:all).each do |obj|
+            assert_equal(newobj.id, obj.id, "A new resource was created instead of modifying an existing resource")
+            count += 1
+            [:title, :restype, :line, :exported].each do |param|
+                if param == :restype
+                    method = :type
+                else
+                    method = param
+                end
+                assert_equal(res.send(method), obj[param], 
+                    "attribute %s was not set correctly in rails %s" % [param, tail])
+            end
+        end
+        assert_equal(1, count, "Got too many resources %s" % tail)
+        # Now make sure we can find it again
+        assert_nothing_raised do
+            obj = Puppet::Rails::Resource.find_by_restype_and_title(
+                res.type, res.title, :include => :param_names
+            )
+        end
+        assert_instance_of(Puppet::Rails::Resource, obj)
+
+        # Make sure we get the parameters back
+        params = options[:params] || [obj.param_names.collect { |p| p.name },
+            res.to_hash.keys].flatten.collect { |n| n.to_s }.uniq
+
+        params.each do |name|
+            param = obj.param_names.find_by_name(name)
+            if res[name]
+                assert(param, "resource did not keep %s %s" % [name, tail])
+            else
+                assert(! param, "resource did not delete %s %s" % [name, tail])
+            end
+            if param
+                values = param.param_values.collect { |pv| pv.value }
+                should = res[param.name]
+                should = [should] unless should.is_a?(Array)
+                assert_equal(should, values,
+                    "%s was different %s" % [param.name, tail])
+            end
+        end
+    end
+
+    def test_to_rails
+        railsteardown
+        railsinit
+        ref1 = Reference.new :type => "exec", :title => "one"
+        ref2 = Reference.new :type => "exec", :title => "two"
+        res = mkresource :type => "file", :title => "/tmp/testing",
+            :source => @source, :scope => @scope,
+            :params => {:owner => "root", :source => ["/tmp/A", "/tmp/B"],
+                :mode => "755", :require => [ref1, ref2]}
+
+        res.line = 50
+
+        # We also need a Rails Host to store under
+        host = Puppet::Rails::Host.new(:name => Facter.hostname)
+
+        compare_resources(host, res, false, :params => %w{owner source mode})
+
+        # Now make sure our parameters did not change
+        assert_instance_of(Array, res[:require], "Parameter array changed")
+        res[:require].each do |ref|
+            assert_instance_of(Reference, ref, "Resource reference changed")
+        end
+
+        # Now make some changes to our resource.  We're removing the mode,
+        # changing the source, and adding 'check'.
+        res = mkresource :type => "file", :title => "/tmp/testing",
+            :source => @source, :scope => @scope,
+            :params => {:owner => "bin", :source => ["/tmp/A", "/tmp/C"],
+            :check => "checksum",  :require => [ref1, ref2]}
+
+        res.line = 75
+        res.exported = true
+
+        compare_resources(host, res, true, :params => %w{owner source mode check})
+
+        # Again make sure our parameters did not change
+        assert_instance_of(Array, res[:require], "Parameter array changed")
+        res[:require].each do |ref|
+            assert_instance_of(Reference, ref, "Resource reference changed")
+        end
+    end
+end
+
+# $Id: railsresource.rb 2597 2007-06-17 21:41:50Z luke $