Merge branch '0.24.x' Removed the 'after' blocks that call Type.clear,

since that method is deprecated.

Conflicts:

	CHANGELOG
	bin/puppetca
	lib/puppet/file_serving/fileset.rb
	lib/puppet/network/xmlrpc/client.rb
	lib/puppet/type/file/selcontext.rb
	spec/unit/file_serving/metadata.rb
	spec/unit/type/file.rb

2 files changed, 0 insertions, 241 deletions

diff --git a/test/util/log.rb b/test/util/log.rb
index 523652f37..8c7703cb9 100755
--- a/test/util/log.rb
+++ b/test/util/log.rb
@@ -114,44 +114,6 @@ class TestLog < Test::Unit::TestCase
         assert(FileTest.file?(file))
     end
 
-    def test_logtags
-        path = tempfile
-        File.open(path, "w") { |f| f.puts "yayness" }
-
-        file = Puppet.type(:file).create(
-            :path => path,
-            :check => [:owner, :group, :mode, :checksum],
-            :ensure => :file
-        )
-        file.tags = %w{this is a test}
-
-        property = file.property(:ensure)
-        assert(property, "Did not get property")
-        log = nil
-        assert_nothing_raised {
-            log = Puppet::Util::Log.new(
-                :level => :info,
-                :source => property,
-                :message => "A test message"
-            )
-        }
-
-        # Now yaml and de-yaml it, and test again
-        yamllog = YAML.load(YAML.dump(log))
-
-        {:log => log, :yaml => yamllog}.each do |type, msg|
-            assert(msg.tags, "Got no tags")
-
-            msg.tags.each do |tag|
-                assert(msg.tagged?(tag), "Was not tagged with %s" % tag)
-            end
-
-            assert_equal(msg.tags, property.tags, "Tags were not equal")
-            assert_equal(msg.source, property.path, "Source was not set correctly")
-        end
-
-    end
-
     # Verify that we can pass strings that match printf args
     def test_percentlogs
         Puppet::Util::Log.newdestination :syslog
@@ -182,27 +144,6 @@ class TestLog < Test::Unit::TestCase
         assert_instance_of(String, msg.source)
     end
 
-    # Verify that loglevel behaves as one expects
-    def test_loglevel
-        path = tempfile()
-        file = Puppet.type(:file).create(
-            :path => path,
-            :ensure => "file"
-        )
-
-        assert_nothing_raised {
-            assert_equal(:notice, file[:loglevel])
-        }
-
-        assert_nothing_raised {
-            file[:loglevel] = "warning"
-        }
-
-        assert_nothing_raised {
-            assert_equal(:warning, file[:loglevel])
-        }
-    end
-
     def test_destination_matching
         dest = nil
         assert_nothing_raised {
diff --git a/test/util/posixtest.rb b/test/util/posixtest.rb
deleted file mode 100755
index f64a95d18..000000000
--- a/test/util/posixtest.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2006-11-07.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppettest'
-require 'puppet/util/posix'
-
-class TestPosixUtil < Test::Unit::TestCase
-	include PuppetTest
-	include Puppet::Util::POSIX
-	
-	def mk_posix_resource(type, obj)
-	    field = idfield(type)
-        res = Puppet::Type.type(type).create(
-            :name => obj.name,
-            field => obj.send(field)
-        )
-        res.setdefaults
-        res
-    end
-	
-	def test_get_posix_field
-	    {:group => nonrootgroup, :passwd => nonrootuser}.each do |space, obj|
-            id = Puppet::Util.idfield(space)
-	        [obj.name, obj.send(id)].each do |test|
-        	    value = nil
-        	    assert_nothing_raised do
-        	        value = get_posix_field(space, :name, test)
-        	    end
-        	    assert_equal(obj.name, value, "did not get correct value from get_posix_field (known to be broken on some platforms)")
-    	    end
-	    end
-    end
-    
-    def test_search_posix_field
-        {:group => nonrootgroup, :passwd => nonrootuser}.each do |space, obj|
-              id = Puppet::Util.idfield(space)
-            [obj.name, obj.send(id)].each do |test|
-                value = nil
-                assert_nothing_raised do
-                    value = search_posix_field(space, :name, test)
-                end
-                assert_equal(obj.name, value, "did not get correct value from search_posix_field")
-            end
-        end
-      end
-    
-    def test_get_provider_value
-        user = nonrootuser
-        obj = mk_posix_resource(:user, user)
-        
-        assert_nothing_raised do
-            assert_equal(user.uid, get_provider_value(:user, :uid, user.uid))
-            assert_equal(user.name, get_provider_value(:user, :name, user.name))
-        end
-    end
-    
-    def test_gid_and_uid
-        {:user => nonrootuser, :group => nonrootgroup}.each do |type, obj|
-            method = idfield(type)
-            # First make sure we get it back with both name and id with no object
-            [obj.name, obj.send(method)].each do |value|
-                assert_equal(obj.send(method), send(method, value))
-            end
-            
-            # Now make a Puppet resource and make sure we get it from that.
-            resource = mk_posix_resource(type, obj)
-            
-            [obj.name, obj.send(method)].each do |value|
-                assert_equal(obj.send(method), send(method, value))
-            end
-        end
-    end
-    
-    def test_util_methods
-        assert(Puppet::Util.respond_to?(:uid), "util does not have methods")
-    end
-    
-    # First verify we can convert a known user
-    def test_gidbyname
-        %x{groups}.split(" ").each { |group|
-            gid = nil
-            assert_nothing_raised {
-                gid = Puppet::Util.gid(group)
-            }
-
-            assert(gid, "Could not retrieve gid for %s" % group)
-        }
-    end
-
-    # Then verify we can retrieve a known group by gid
-    def test_gidbyid
-        %x{groups}.split(" ").each { |group|
-            obj = Puppet.type(:group).create(
-                :name => group,
-                :check => [:gid]
-            )
-            obj.setdefaults
-            current = obj.retrieve
-            id = nil
-            current.find { |prop, value| id = value if prop.name == :gid }
-            gid = nil
-            assert_nothing_raised {
-                gid = Puppet::Util.gid(id)
-            }
-
-            assert(gid, "Could not retrieve gid for %s" % group)
-            assert_equal(id, gid, "Got mismatched ids")
-        }
-    end
-
-    # Finally, verify that we can find groups by id even if we don't
-    # know them
-    def test_gidbyunknownid
-        gid = nil
-        group = Puppet::Util::SUIDManager.gid
-        assert_nothing_raised {
-            gid = Puppet::Util.gid(group)
-        }
-
-        assert(gid, "Could not retrieve gid for %s" % group)
-        assert_equal(group, gid, "Got mismatched ids")
-    end
-
-    def user
-        require 'etc'
-        unless defined? @user
-            obj = Etc.getpwuid(Puppet::Util::SUIDManager.uid)
-            @user = obj.name
-        end
-        return @user
-    end
-
-    # And do it all over again for users
-    # First verify we can convert a known user
-    def test_uidbyname
-        user = user()
-        uid = nil
-        assert_nothing_raised {
-            uid = Puppet::Util.uid(user)
-        }
-
-        assert(uid, "Could not retrieve uid for %s" % user)
-        assert_equal(Puppet::Util::SUIDManager.uid, uid, "UIDs did not match")
-    end
-
-    # Then verify we can retrieve a known user by uid
-    def test_uidbyid
-        user = user()
-        obj = Puppet.type(:user).create(
-            :name => user,
-            :check => [:uid]
-        )
-        obj.setdefaults
-        obj.retrieve
-        id = obj.provider.uid
-        uid = nil
-        assert_nothing_raised {
-            uid = Puppet::Util.uid(id)
-        }
-
-        assert(uid, "Could not retrieve uid for %s" % user)
-        assert_equal(id, uid, "Got mismatched ids")
-    end
-
-    # Finally, verify that we can find users by id even if we don't
-    # know them
-    def test_uidbyunknownid
-        uid = nil
-        user = Puppet::Util::SUIDManager.uid
-        assert_nothing_raised {
-            uid = Puppet::Util.uid(user)
-        }
-
-        assert(uid, "Could not retrieve uid for %s" % user)
-        assert_equal(user, uid, "Got mismatched ids")
-    end
-end
-