puppet 0.18.4 → 0.22.4

data/test/{types → ral/types}/yumrepo.rb

@@ -1,18 +1,12 @@
-# Test the yumrepo type
+#!/usr/bin/env ruby
 
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
-require 'puppet'
-require 'test/unit'
 require 'fileutils'
 
 class TestYumRepo < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
 
     def setup
         super
@@ -32,14 +26,15 @@ class TestYumRepo < Test::Unit::TestCase
         devel.retrieve
         assert_equal("development", devel[:name])
         assert_equal('Fedora Core $releasever - Development Tree', 
-                     devel.state(:descr).is)
+                     devel.property(:descr).is)
         assert_equal('New description', 
-                     devel.state(:descr).should)
+                     devel.property(:descr).should)
         assert_apply(devel)
         inifile = Puppet.type(:yumrepo).read()
         assert_equal('New description', inifile['development']['name'])
         assert_equal('Fedora Core $releasever - $basearch - Base',
                      inifile['base']['name'])
+        assert_equal("foo\n  bar\n  baz", inifile['base']['exclude'])
         assert_equal(['base', 'development', 'main'],
                      all_sections(inifile))
     end
@@ -55,6 +50,7 @@ class TestYumRepo < Test::Unit::TestCase
             :gpgkey => "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora"
         }
         repo = make_repo("base", values)
+
         assert_apply(repo)
         inifile = Puppet.type(:yumrepo).read()
         sections = all_sections(inifile)

data/test/{types → ral/types}/zone.rb

@@ -1,19 +1,12 @@
-# Test host job creation, modification, and destruction
+#!/usr/bin/env ruby
 
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
-require 'puppet'
 require 'puppet/type/zone'
-require 'test/unit'
-require 'facter'
 
 class TestZone < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
 
     def test_nothing
     end
@@ -82,11 +75,11 @@ class TestZone < Test::Unit::TestCase
     def test_valueslice
         zone = mkzone("slicetest")
 
-        state = zone.state(:ensure)
+        property = zone.property(:ensure)
 
         slice = nil
         assert_nothing_raised {
-            slice = state.class.valueslice(:absent, :installed).collect do |o|
+            slice = property.class.valueslice(:absent, :installed).collect do |o|
                 o[:name]
             end
         }
@@ -95,7 +88,7 @@ class TestZone < Test::Unit::TestCase
         assert_equal([:configured, :installed], slice)
 
         assert_nothing_raised {
-            slice = state.class.valueslice(:running, :installed).collect do |o|
+            slice = property.class.valueslice(:running, :installed).collect do |o|
                 o[:name]
             end
         }
@@ -109,23 +102,23 @@ class TestZone < Test::Unit::TestCase
     def test_zoneensure
         zone = mkzone("ensurezone")
 
-        state = zone.state(:ensure)
+        property = zone.property(:ensure)
 
-        assert(state, "Did not get ensure state")
+        assert(property, "Did not get ensure property")
 
         assert_nothing_raised {
             zone.retrieve
         }
 
-        assert(! state.insync?, "State is somehow in sync")
+        assert(! property.insync?, "Property is somehow in sync")
 
-        assert(state.up?, "State incorrectly thinks it is not moving up")
+        assert(property.up?, "Property incorrectly thinks it is not moving up")
 
         zone.is = [:ensure, :configured]
         zone[:ensure] = :installed
-        assert(state.up?, "State incorrectly thinks it is not moving up")
+        assert(property.up?, "Property incorrectly thinks it is not moving up")
         zone[:ensure] = :absent
-        assert(! state.up?, "State incorrectly thinks it is moving up")
+        assert(! property.up?, "Property incorrectly thinks it is moving up")
     end
 
     # Make sure all mentioned methods actually exist.
@@ -133,9 +126,9 @@ class TestZone < Test::Unit::TestCase
         methods = []
         zone = mkzone("methodtest")
 
-        state = zone.state(:ensure)
+        property = zone.property(:ensure)
         assert_nothing_raised {
-            state.class.valueslice(:absent, :running).each do |st|
+            property.class.valueslice(:absent, :running).each do |st|
                 [:up, :down].each do |m|
                     if st[m]
                         methods << st[m]
@@ -145,33 +138,36 @@ class TestZone < Test::Unit::TestCase
         }
 
         methods.each do |m|
-            assert(Puppet::Type.type(:zone).method_defined?(m),
-                "Zones do not define method %s" % m)
+            Puppet::Type.type(:zone).suitableprovider.each do |prov|
+                assert(prov.method_defined?(m),
+                    "Zone provider %s does not define method %s" %
+                    [prov.name, m])
+            end
         end
 
     end
 
-    # Make sure our state generates the correct text.
-    def test_inherit_state
+    # Make sure our property generates the correct text.
+    def test_inherit_property
         zone = mkzone("configtesting")
         zone[:ensure] = :configured
 
         assert_nothing_raised {
             zone[:inherit] = "/usr"
         }
-        state = zone.state(:inherit)
-        assert(zone, "Did not get 'inherit' state")
+        property = zone.property(:inherit)
+        assert(zone, "Did not get 'inherit' property")
 
-        assert_equal("add inherit-pkg-dir\nset dir=/usr\nend", state.configtext,
+        assert_equal("add inherit-pkg-dir\nset dir=/usr\nend", property.configtext,
             "Got incorrect config text")
 
-        state.is = "/usr"
+        property.is = "/usr"
 
-        assert_equal("", state.configtext,
+        assert_equal("", property.configtext,
             "Got incorrect config text")
 
         # Now we want multiple directories
-        state.should = %w{/usr /sbin /lib}
+        property.should = %w{/usr /sbin /lib}
 
         # The statements are sorted
         text = "add inherit-pkg-dir
@@ -181,19 +177,19 @@ add inherit-pkg-dir
 set dir=/sbin
 end"
 
-        assert_equal(text, state.configtext,
+        assert_equal(text, property.configtext,
             "Got incorrect config text")
 
-        state.is = %w{/usr /sbin /lib}
-        state.should = %w{/usr /sbin}
+        property.is = %w{/usr /sbin /lib}
+        property.should = %w{/usr /sbin}
 
         text = "remove inherit-pkg-dir dir=/lib"
 
-        assert_equal(text, state.configtext,
+        assert_equal(text, property.configtext,
             "Got incorrect config text")
     end
 
-    if Process.uid == 0
+    if Puppet::Util::SUIDManager.uid == 0
     # Make sure our ensure process actually works.
     def test_ensure_sync
         zone = mkzone("ensuretesting")
@@ -248,11 +244,15 @@ end
 
         #@@zones << "configtesting"
 
+        hash = nil
         assert_nothing_raised {
-            zone.send(:getconfig)
+            hash = zone.provider.send(:getconfig)
         }
 
-        # Now, make sure everything is right.
+        # Now set the configuration
+        assert_nothing_raised { zone.send(:config2status, hash) }
+
+        # And make sure it gets set correctly.
         assert_equal(%w{/sbin /usr /opt/csw /lib /platform}.sort,
             zone.is(:inherit).sort, "Inherited dirs did not get collected correctly."
         )
@@ -332,7 +332,7 @@ end
             "ip was not removed")
     end
 
-    # Test creating and removing a zone, but only up to the configured state,
+    # Test creating and removing a zone, but only up to the configured property,
     # so it's faster.
     def test_smallcreate
         zone = mkzone("smallcreate")
@@ -382,20 +382,20 @@ end
             [:stop, :installed],
             [:uninstall, :configured],
             [:unconfigure, :absent]
-        ].each do |method, state|
+        ].each do |method, property|
             Puppet.info "Testing %s" % method
             assert_nothing_raised {
                 zone.retrieve
             }
             assert_nothing_raised {
-                zone.send(method)
+                zone.provider.send(method)
             }
             assert_nothing_raised {
                 zone.retrieve
             }
-            assert_equal(state, zone.is(:ensure),
-                "Method %s did not correctly set state %s" %
-                    [method, state])
+            assert_equal(property, zone.is(:ensure),
+                "Method %s did not correctly set property %s" %
+                    [method, property])
         end
     end
 
@@ -434,4 +434,4 @@ end
     end
 end
 
-# $Id: zone.rb 1329 2006-06-28 18:51:11Z luke $
+# $Id: zone.rb 2178 2007-02-07 23:56:59Z luke $

data/test/tagging/tagging.rb

@@ -1,21 +1,22 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
-require 'test/unit'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
 
 class TestTagging < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
 
     # Make sure the scopes are getting the right tags
     def test_scopetags
         scope = nil
         assert_nothing_raised {
-            scope = Puppet::Parser::Scope.new()
+            scope = mkscope
             scope.name = "yayness"
             scope.type = "solaris"
         }
@@ -29,7 +30,7 @@ class TestTagging < Test::Unit::TestCase
     def test_deepscopetags
         scope = nil
         assert_nothing_raised {
-            scope = Puppet::Parser::Scope.new()
+            scope = mkscope
             scope.name = "yayness"
             scope.type = "solaris"
             scope = scope.newscope
@@ -47,31 +48,21 @@ class TestTagging < Test::Unit::TestCase
     def test_objecttags
         scope = nil
         assert_nothing_raised {
-            scope = Puppet::Parser::Scope.new()
+            scope = mkscope
             scope.name = "yayness"
             scope.type = "solaris"
         }
 
-        assert_nothing_raised {
-            scope.setobject(
-                :type => "file",
-                :name => "/etc/passwd",
-                :arguments => {"owner" => "root"},
-                :file => "/yay",
-                :line => 1
-            )
-        }
+        resource = mkresource :type => "file", :title => "/tmp/testing",
+            :params => {:owner => "root"}, :file => "/yay", :line => 1,
+            :scope => scope
 
-        objects = nil
         assert_nothing_raised {
-            objects = scope.to_trans
+            scope.setresource(resource)
         }
 
-        # There's only one object, so shift it out
-        object = objects.shift
-
         assert_nothing_raised {
-            assert_equal(%w{solaris}, object.tags,
+            assert_equal(%w{solaris file}, resource.tags,
                 "Incorrect tags")
         }
     end
@@ -176,4 +167,4 @@ class TestTagging < Test::Unit::TestCase
     end
 end
 
-# $Id: tagging.rb 1099 2006-04-11 15:30:19Z luke $
+# $Id: tagging.rb 1793 2006-10-16 22:01:40Z luke $

data/test/util/autoload.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/util/autoload'
+require 'puppettest'
+
+class TestAutoload < Test::Unit::TestCase
+	include PuppetTest
+    @things = []
+    def self.newthing(name)
+        @things << name
+    end
+
+    def self.thing?(name)
+        @things.include? name
+    end
+
+    def self.clear
+        @things.clear
+    end
+
+    def mkfile(name, path)
+        # Now create a file to load
+        File.open(path, "w") do |f|
+            f.puts %{
+TestAutoload.newthing(:#{name.to_s})
+            }
+        end
+    end
+
+    def teardown
+        super
+        self.class.clear
+    end
+
+    def test_load
+        dir = tempfile()
+        $: << dir
+        cleanup do
+            $:.delete(dir)
+        end
+
+        Dir.mkdir(dir)
+
+        rbdir = File.join(dir, "yayness")
+
+        Dir.mkdir(rbdir)
+
+        # An object for specifying autoload
+        klass = self.class
+
+        loader = nil
+        assert_nothing_raised {
+            loader = Puppet::Util::Autoload.new(klass, :yayness)
+        }
+
+        assert_equal(loader.object_id, Puppet::Util::Autoload[klass].object_id,
+                    "Did not retrieve loader object by class")
+
+        # Make sure we don't fail on missing files
+        assert_nothing_raised {
+            assert_equal(false, loader.load(:mything),
+                        "got incorrect return on failed load")
+        }
+
+        # Now create a couple of files for testing
+        path = File.join(rbdir, "mything.rb")
+        mkfile(:mything, path)
+        opath = File.join(rbdir, "othing.rb")
+        mkfile(:othing, opath)
+
+        # Now try to actually load it.
+        assert_nothing_raised {
+            assert_equal(true, loader.load(:mything),
+                        "got incorrect return on failed load")
+        }
+
+        assert(loader.loaded?(:mything), "Not considered loaded")
+
+        assert(klass.thing?(:mything),
+                "Did not get loaded thing")
+
+        # Now clear everything, and test loadall
+        assert_nothing_raised {
+            loader.clear
+        }
+
+        self.class.clear
+
+        assert_nothing_raised {
+            loader.loadall
+        }
+
+        [:mything, :othing].each do |thing|
+            assert(loader.loaded?(thing), "#{thing.to_s} not considered loaded")
+
+            assert(klass.thing?(thing),
+                    "Did not get loaded #{thing.to_s}")
+        end
+    end
+
+    # Make sure that autoload dynamically modifies $: with the libdir as
+    # appropriate.
+    def test_autoload_uses_libdir
+        dir = Puppet[:libdir]
+        unless FileTest.directory?(dir)
+            Dir.mkdir(dir)
+        end
+
+        loader = File.join(dir, "test")
+        Dir.mkdir(loader)
+        name = "funtest"
+        file = File.join(loader, "funtest.rb")
+        File.open(file, "w") do |f|
+            f.puts "$loaded = true"
+        end
+
+        auto = Puppet::Util::Autoload.new(self, "test")
+
+        # Now make sure autoloading modifies $: as necessary
+        assert(! $:.include?(dir), "search path already includes libdir")
+
+        assert_nothing_raised do
+            assert(auto.load("funtest"), "did not successfully load funtest")
+        end
+        assert($:.include?(dir), "libdir did not get added to search path")
+    end
+end