puppet 0.23.2 → 0.24.0

data/test/puppet/conffiles.rb

@@ -1,9 +1,8 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
-require 'puppet/util/config'
 
 class TestConfFiles < Test::Unit::TestCase
     include PuppetTest
@@ -72,7 +71,7 @@ class TestConfFiles < Test::Unit::TestCase
         path = tempfile()
 
         sampledata { |data|
-            config = Puppet::Util::Config.new
+            config = Puppet::Util::Settings.new
             data.each { |section, hash|
                 hash.each { |param, value|
                     config.setdefaults(section, param => [value, value])
@@ -100,10 +99,9 @@ class TestConfFiles < Test::Unit::TestCase
     # that the default config is free of simple typos etc.
     def test_genconfig
         assert_nothing_raised {
-            Puppet::config::to_config
+            Puppet::settings::to_config
         }
     end
 
 end
 
-# $Id: conffiles.rb 2261 2007-03-07 22:20:51Z lutter $

data/test/puppet/defaults.rb

@@ -1,11 +1,10 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppettest'
 
-# $Id: defaults.rb 2178 2007-02-07 23:56:59Z luke $
 
 class TestPuppetDefaults < Test::Unit::TestCase
     include PuppetTest
@@ -38,32 +37,6 @@ class TestPuppetDefaults < Test::Unit::TestCase
         }
     end
 
-    if __FILE__ == $0
-        def disabled_testContained
-            confdir = Regexp.new(Puppet[:confdir])
-            vardir = Regexp.new(Puppet[:vardir])
-            [@@dirs,@@files].flatten.each { |param|
-                value = Puppet[param]
-
-                unless value =~ confdir or value =~ vardir
-                    assert_nothing_raised { raise "%s is in wrong dir: %s" %
-                        [param,value] }
-                end
-            }
-        end
-    end
-
-    def testArgumentTypes
-        assert_raise(ArgumentError) { Puppet[["string"]] }
-        assert_raise(ArgumentError) { Puppet[[:symbol]] }
-    end
-
-    def testFailOnBogusArgs
-        [0, "ashoweklj", ";"].each { |param|
-            assert_raise(ArgumentError, "No error on %s" % param) { Puppet[param] }
-        }
-    end
-
     # we don't want user defaults in /, or root defaults in ~
     def testDefaultsInCorrectRoots
         notval = nil

data/test/puppet/errortest.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppettest'
@@ -17,4 +17,3 @@ class TestError < Test::Unit::TestCase
     end
 end
 
-# $Id: errortest.rb 1793 2006-10-16 22:01:40Z luke $

data/test/puppet/tc_suidmanager.rb

@@ -1,21 +1,17 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppettest'
 require 'test/unit'
+require 'mocha'
 
 class TestSUIDManager < Test::Unit::TestCase
     include PuppetTest
 
     def setup
-        if Process.uid != 0
-            warn "Process tests must be run as root"
-            @run = false
-        else 
-            @run = true
-        end
+        @user = nonrootuser
         super
     end
 
@@ -24,6 +20,8 @@ class TestSUIDManager < Test::Unit::TestCase
         # SUIDManager for the UID/GID calls was causing problems due to the
         # modification of a closure. Should the bug rear itself again, this
         # test will fail.
+        Process.expects(:uid).times(2)
+
         assert_nothing_raised do
             Puppet::Util::SUIDManager.uid
             Puppet::Util::SUIDManager.uid
@@ -31,77 +29,93 @@ class TestSUIDManager < Test::Unit::TestCase
     end
 
     def test_id_set
-        if @run
-            user = nonrootuser
-            assert_nothing_raised do
-                Puppet::Util::SUIDManager.egid = user.gid
-                Puppet::Util::SUIDManager.euid = user.uid
-            end
-            
-            assert_equal(Puppet::Util::SUIDManager.euid, Process.euid)
-            assert_equal(Puppet::Util::SUIDManager.egid, Process.egid)
-
-            assert_nothing_raised do
-                Puppet::Util::SUIDManager.euid = 0
-                Puppet::Util::SUIDManager.egid = 0
-            end
+        Process.expects(:euid=).with(@user.uid)
+        Process.expects(:egid=).with(@user.gid)
+
+        assert_nothing_raised do
+            Puppet::Util::SUIDManager.egid = @user.gid
+            Puppet::Util::SUIDManager.euid = @user.uid
         end
     end
 
     def test_utiluid
-        user = nonrootuser.name
-        if @run
-            assert_not_equal(nil, Puppet::Util.uid(user))
-        end
+        assert_not_equal(nil, Puppet::Util.uid(@user.name))
     end
 
-    def test_asuser
-        if @run
-            user = nonrootuser
-            uid, gid = [nil, nil]
-
-            assert_nothing_raised do
-                Puppet::Util::SUIDManager.asuser(user.uid, user.gid) do 
-                    uid = Process.euid
-                    gid = Process.egid
-                end
-            end
-            assert_equal(user.uid, uid)
-            assert_equal(user.gid, gid)
-        end
+    def test_asuser_as_root
+        Process.stubs(:uid).returns(0)
+        expects_id_set_and_revert @user.uid, @user.gid
+        Puppet::Util::SUIDManager.asuser @user.uid, @user.gid do end
     end
 
-    def test_system
-        # NOTE: not sure what shells this will work on..
-        if @run 
-            user = nonrootuser
-            status = Puppet::Util::SUIDManager.system("exit $EUID", user.uid, user.gid)
-            assert_equal(user.uid, status.exitstatus, "EUID does not seem to be inherited.  This test consistently fails on RedHat-like machines.")
-        end
+    def test_asuser_as_nonroot
+        Process.stubs(:uid).returns(1)
+        expects_no_id_set
+        Puppet::Util::SUIDManager.asuser @user.uid, @user.gid do end
+    end
+
+
+    def test_system_as_root
+        Process.stubs(:uid).returns(0)
+        set_exit_status!
+        expects_id_set_and_revert @user.uid, @user.gid
+        Kernel.expects(:system).with('blah')
+        Puppet::Util::SUIDManager.system('blah', @user.uid, @user.gid)
+    end
+
+    def test_system_as_nonroot
+        Process.stubs(:uid).returns(1)
+        set_exit_status!
+        expects_no_id_set
+        Kernel.expects(:system).with('blah')
+        Puppet::Util::SUIDManager.system('blah', @user.uid, @user.gid)
     end
 
     def test_run_and_capture
         if (RUBY_VERSION <=> "1.8.4") < 0
             warn "Cannot run this test on ruby < 1.8.4"
         else
-            # NOTE: because of the way that run_and_capture currently 
-            # works, we cannot just blindly echo to stderr. This little
-            # hack gets around our problem, but the real problem is the
-            # way that run_and_capture works.
-            user = nil
-            uid = nil
-            if Puppet::Util::SUIDManager.uid == 0
-                userobj = nonrootuser()
-                user = userobj.name
-                uid = userobj.uid
-            else
-                uid = Process.uid
-            end
-            cmd = [%{/bin/echo $EUID}]
-            output = Puppet::Util::SUIDManager.run_and_capture(cmd, uid)[0].chomp
-            assert_equal(uid.to_s, output)
+            set_exit_status!
+
+            Puppet::Util.expects(:execute).with( 'yay',
+                                                 { :failonfail => false,
+                                                   :uid => @user.uid,
+                                                   :gid => @user.gid }
+                                               ).returns('output')
+
+
+            output = Puppet::Util::SUIDManager.run_and_capture 'yay', 
+                                                               @user.uid,
+                                                               @user.gid
+
+            assert_equal 'output', output.first
+            assert_kind_of Process::Status, output.last
         end
     end
+
+    private
+
+    def expects_id_set_and_revert(uid, gid)
+        Process.expects(:euid).returns(99997)
+        Process.expects(:egid).returns(99996)
+
+        Process.expects(:euid=).with(uid)
+        Process.expects(:egid=).with(gid)
+
+        Process.expects(:euid=).with(99997)
+        Process.expects(:egid=).with(99996)
+    end
+
+    def expects_no_id_set
+        Process.expects(:egid).never
+        Process.expects(:euid).never
+        Process.expects(:egid=).never
+        Process.expects(:euid=).never
+    end
+
+    def set_exit_status!
+      # We want to make sure $? is set, this is the only way I know how.
+      Kernel.system '' if $?.nil?
+    end
 end
 
-# $Id: tc_suidmanager.rb 2625 2007-06-19 01:51:48Z luke $

data/test/rails/ast.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/rails'
@@ -20,7 +20,8 @@ class TestRailsAST < PuppetTest::TestCase
     def test_exported_collexp
         railsinit
         Puppet[:storeconfigs] = true
-        @interp, @scope, @source = mkclassframing
+
+        @scope = mkscope
 
         # make a rails resource
         railsresource "file", "/tmp/testing", :owner => "root", :group => "bin",
@@ -61,7 +62,7 @@ class TestRailsAST < PuppetTest::TestCase
                 assert_equal(1, retval.length, "Did not find resource with '#{string}'")
                 res = retval.shift
 
-                assert_equal("file", res.restype)
+                assert_equal("File", res.restype)
                 assert_equal("/tmp/testing", res.title)
             else
                 assert_equal(0, retval.length, "found a resource with '#{string}'")
@@ -70,4 +71,3 @@ class TestRailsAST < PuppetTest::TestCase
     end
 end
 
-# $Id: ast.rb 2705 2007-07-18 17:32:46Z luke $

data/test/rails/configuration.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/puppettest'
+
+require 'puppettest'
+require 'puppet/parser/parser'
+require 'puppet/network/client'
+require 'puppet/rails'
+require 'puppettest/resourcetesting'
+require 'puppettest/parsertesting'
+require 'puppettest/servertest'
+require 'puppettest/railstesting'
+
+
+class ConfigurationRailsTests < PuppetTest::TestCase
+	include PuppetTest
+    include PuppetTest::ServerTest
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+    include PuppetTest::RailsTesting
+    AST = Puppet::Parser::AST
+    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
+        compile = mkcompile
+        parser = compile.parser
+
+        node = parser.newnode [compile.node.name], :code => AST::ASTArray.new(:children => [
+            resourcedef("file", "/tmp/yay", :group => "root"),
+            defaultobj("file", :owner => "root")
+        ])
+
+        # Now do the rails crap
+        Puppet[:storeconfigs] = true
+
+        Puppet::Rails::Host.expects(:store).with do |node, resources|
+            if res = resources.find { |r| r.type == "File" and r.title == "/tmp/yay" }
+                assert_equal("root", res["owner"], "Did not set default on resource")
+                true
+            else
+                raise "Resource was not passed to store()"
+            end
+        end
+        compile.compile
+    end
+
+    def test_hoststorage
+        assert_nothing_raised {
+            Puppet[:storeconfigs] = true
+        }
+
+        Puppet[:code] = "file { \"/etc\": owner => root }"
+
+        interp = Puppet::Parser::Interpreter.new
+
+        facts = {}
+        Facter.each { |fact, val| facts[fact] = val }
+        node = mknode(facts["hostname"])
+        node.parameters = facts
+
+        objects = nil
+        assert_nothing_raised {
+            objects = interp.compile(node)
+        }
+
+        obj = Puppet::Rails::Host.find_by_name(node.name)
+        assert(obj, "Could not find host object")
+    end
+end

data/test/rails/host.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppet/rails'
@@ -35,7 +35,7 @@ class TestRailsHost < PuppetTest::TestCase
     end
 
     def test_store
-        @interp, @scope, @source = mkclassframing
+        @scope = mkscope
         # First make some objects
         resources = []
         4.times { |i|
@@ -51,18 +51,14 @@ class TestRailsHost < PuppetTest::TestCase
         }
 
         # Now collect our facts
-        facts = {"hostname" => Facter.value(:hostname), "test1" => "funtest",
-            "ipaddress" => Facter.value(:ipaddress)}
+        facts = {"hostname" => "myhost", "test1" => "funtest", "ipaddress" => "192.168.0.1"}
 
         # Now try storing our crap
         host = nil
+        node = mknode(facts["hostname"])
+        node.parameters = facts
         assert_nothing_raised {
-            host = Puppet::Rails::Host.store(
-                :resources => resources,
-                :facts => facts,
-                :name => facts["hostname"],
-                :classes => ["one", "two::three", "four"]
-            )
+            host = Puppet::Rails::Host.store(node, resources)
         }
 
         assert(host, "Did not create host")
@@ -92,10 +88,10 @@ class TestRailsHost < PuppetTest::TestCase
             end
             assert(resource[:restype] != "", "Did not get a type from the resource")
             case resource["restype"]
-            when "file":
+            when "File":
                 assert_equal("user#{i}", resource.parameter("owner"),
                     "got no owner for %s" % resource.ref)
-            when "exec":
+            when "Exec":
                 assert_equal("user#{i}", resource.parameter("user"),
                     "got no user for %s" % resource.ref)
             else
@@ -110,7 +106,7 @@ class TestRailsHost < PuppetTest::TestCase
 
         # Change a few resources
         resources.find_all { |r| r.title =~ /file2/ }.each do |r|
-            r.set("loglevel", "notice", r.source)
+            r.send(:set_parameter, "loglevel", "notice")
         end
 
         # And add a new resource
@@ -123,16 +119,15 @@ class TestRailsHost < PuppetTest::TestCase
         facts["test3"] = "funtest"
         facts["test1"] = "changedfact"
         facts.delete("ipaddress")
-        host = nil
+        node = mknode(facts["hostname"])
+        node.parameters = facts
+        newhost = nil
         assert_nothing_raised {
-            host = Puppet::Rails::Host.store(
-                :resources => resources,
-                :facts => facts,
-                :name => facts["hostname"],
-                :classes => ["one", "two::three", "four"]
-            )
+            newhost = Puppet::Rails::Host.store(node, resources)
         }
 
+        assert_equal(host.id, newhost.id, "Created new host instance)")
+
         # Make sure it sets the last_compile time
         assert_nothing_raised do
             assert_instance_of(Time, host.last_compile, "did not set last_compile")
@@ -161,10 +156,9 @@ class TestRailsHost < PuppetTest::TestCase
         Puppet::Rails.init
         Puppet[:storeconfigs] = true
 
+        Puppet[:code] = " "
         # this is the default server setup
-        master = Puppet::Network::Handler.master.new(
-            :Code => "",
-            :UseNodes => true,
+        master = Puppet::Network::Handler.configuration.new(
             :Local => true
         )
 
@@ -172,7 +166,7 @@ class TestRailsHost < PuppetTest::TestCase
         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')
+            master.version("created",'192.168.0.1')
         end
         
         # Make sure it created the host
@@ -180,12 +174,10 @@ class TestRailsHost < PuppetTest::TestCase
         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')
+            master.version("test",'192.168.0.2')
         end
 
         # Recreate it, so we're not using the cached object.
@@ -194,9 +186,6 @@ class TestRailsHost < PuppetTest::TestCase
         # 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 2616 2007-06-18 21:03:18Z luke $