puppet 0.23.1 → 0.23.2

data/lib/puppet/provider/user/directoryservice.rb

@@ -0,0 +1,116 @@
+#  Created by Jeff McCune on 2007-07-22
+#  Copyright (c) 2007. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation (version 2 of the License)
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston MA  02110-1301 USA
+
+require 'puppet/provider/nameservice/directoryservice'
+
+Puppet::Type.type(:user).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
+    desc "User management using DirectoryService on OS X."
+
+    commands :dscl => "/usr/bin/dscl"
+    confine :operatingsystem => :darwin
+    
+    # JJM: DirectoryService can manage passwords.
+    #      This needs to be a special option to dscl though (-passwd)
+    has_feature :manages_passwords
+    
+    # JJM: comment matches up with the /etc/passwd concept of an user
+    options :comment, :key => "realname"
+    options :password, :key => "passwd"
+    
+    autogen_defaults :home => "/var/empty", :shell => "/usr/bin/false"
+
+    verify :gid, "GID must be an integer" do |value|
+        value.is_a? Integer
+    end
+
+    verify :uid, "UID must be an integer" do |value|
+        value.is_a? Integer
+    end
+    
+    def autogen_comment
+        return @resource[:name].capitalize
+    end
+    
+    # The list of all groups the user is a member of.  Different
+    # user mgmt systems will need to override this method.
+    # JJM: FIXME: Override this method...
+    def groups
+        groups = []
+
+        # user = @resource[:name]
+        # # Retrieve them all from netinfo
+        # open("| #{command(:nireport)} / /groups name users") do |file|
+        #     file.each do |line|
+        #         name, members = line.split(/\s+/)
+        #         next unless members
+        #         next if members =~ /NoValue/
+        #         members = members.split(",")
+        # 
+        #         if members.include? user
+        #             groups << name
+        #         end
+        #     end
+        # end
+
+        groups.join(",")
+    end
+
+    # This is really lame.  We have to iterate over each
+    # of the groups and add us to them.
+    def groups=(groups)
+        # case groups
+        # when Fixnum:
+        #     groups = [groups.to_s]
+        # when String
+        #     groups = groups.split(/\s*,\s*/)
+        # else
+        #     raise Puppet::DevError, "got invalid groups value %s of type %s" % [groups.class, groups]
+        # end
+        # # Get just the groups we need to modify
+        # diff = groups - (@is || [])
+        # 
+        # data = {}
+        # open("| #{command(:nireport)} / /groups name users") do |file|
+        #     file.each do |line|
+        #         name, members = line.split(/\s+/)
+        # 
+        #         if members.nil? or members =~ /NoValue/
+        #             data[name] = []
+        #         else
+        #             # Add each diff group's current members
+        #             data[name] = members.split(/,/)
+        #         end
+        #     end
+        # end
+        # 
+        # user = @resource[:name]
+        # data.each do |name, members|
+        #     if members.include? user and groups.include? name
+        #         # I'm in the group and should be
+        #         next
+        #     elsif members.include? user
+        #         # I'm in the group and shouldn't be
+        #         setuserlist(name, members - [user])
+        #     elsif groups.include? name
+        #         # I'm not in the group and should be
+        #         setuserlist(name, members + [user])
+        #     else
+        #         # I'm not in the group and shouldn't be
+        #         next
+        #     end
+        # end
+    end
+    
+    
+end

data/lib/puppet/rails/host.rb

@@ -158,4 +158,4 @@ class Puppet::Rails::Host < ActiveRecord::Base
     end
 end
 
-# $Id: host.rb 2616 2007-06-18 21:03:18Z luke $
+# $Id: host.rb 2735 2007-08-03 19:31:15Z lutter $

data/lib/puppet/reference/configuration.rb

@@ -109,11 +109,14 @@ the executable in question with the `--genconfig` command.  The executable
 will print a template configuration to standard output, which can be
 redirected to a file like so::
 
-    $ puppetd --genconfig > /etc/puppet/puppetd.conf
+    $ puppetd --genconfig > /etc/puppet/puppet.conf
   
-Note that this invocation will \"clobber\" (throw away) the contents of any
-pre-existing `puppetd.conf` file, so make a backup of your present config
-if it contains valuable information.
+Note that this invocation will replace the contents of any pre-existing
+`puppet.conf` file, so make a backup of your present config if it contains
+valuable information.
+
+All parameters will be under a single section heading matching the name of
+the process used to generate the configuraiton ('puppetd', in this case).
   
 Like the `--genconfig` argument, the executables also accept a `--genmanifest`
 argument, which will generate a manifest that can be used to manage all of 

data/lib/puppet/type/interface.rb

@@ -0,0 +1,57 @@
+Puppet::Type.newtype(:interface) do
+	require 'erb'
+
+	@doc = "Create configuration for IP address aliases and loopback addresses."
+
+	newparam(:name, :namevar => true) do
+		desc "The ipaddress to add to alias or loopback/dummy interface"
+	end
+
+    ensurable
+
+	newparam(:interface) do
+		desc "The interface the IP should be added to"
+	end
+
+	newproperty(:interface_type) do
+		desc "The interface type, loopback (also dummy) or alias"
+
+        newvalue(:loopback)
+        newvalue(:alias)
+        newvalue(:normal)
+
+        # Make dummy and loopback equivalent
+        aliasvalue(:dummy, :loopback)
+
+        defaultto :normal
+	end
+
+	newparam(:interface_desc) do
+		desc "On Linux, the description / symbolic name you wish to refer to the 
+              interface by. When absent, Redhat Linux defaults to uses the namevar
+              which will be either the IP address, or hostname."
+	end
+
+	newproperty(:onboot) do
+		desc "Whether the interface should be configured to come up on boot"
+		newvalue(:true)
+		newvalue(:false)
+	end
+
+	newproperty(:ifnum) do
+		desc "If not automatically configuring the dummy interface or
+              and alias. This is use to force a given number to be used"
+	end
+
+	newproperty(:ifopts) do
+		desc "Interface options."
+	end
+
+    newparam(:target) do
+        desc "The path to the file this resource creates."
+
+        defaultto { @resource.provider.file_path }
+    end
+end
+
+# $Id: interface.rb 2747 2007-08-05 19:01:39Z luke $

data/lib/puppet/type/pfile/group.rb

@@ -36,7 +36,7 @@ module Puppet
 
         def should_to_s(newvalue = @should)
             if newvalue.is_a? Integer
-                id2name(newvalue) || newalue
+                id2name(newvalue) || newvalue
             else
                 return newvalue.to_s
             end
@@ -118,4 +118,4 @@ module Puppet
     end
 end
 
-# $Id: group.rb 2500 2007-05-09 22:05:32Z luke $
+# $Id: group.rb 2741 2007-08-03 23:14:32Z lutter $

data/lib/puppet/util/config.rb

@@ -541,8 +541,11 @@ Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
+        # Add a section heading that matches our name.
+        if @config.include?(:name)
+            str += "[%s]\n" % self[:name]
+        end
         eachsection do |section|
-            str += "[#{section}]\n"
             persection(section) do |obj|
                 str += obj.to_config + "\n"
             end
@@ -836,7 +839,11 @@ Generated on #{Time.now}.
                 Puppet.warning "Discarded unknown configuration parameter %s" % param
                 next
             end
-            self[param] = value
+            if @config[param].setbycli
+                Puppet.debug "Ignoring %s set by config file; overridden by cli" % param
+            else
+                self[param] = value
+            end
         end
 
         if meta = params[:_meta]
@@ -1106,4 +1113,4 @@ Generated on #{Time.now}.
     end
 end
 
-# $Id: config.rb 2464 2007-05-06 05:42:53Z luke $
+# $Id: config.rb 2743 2007-08-04 00:36:47Z luke $

data/lib/puppet/util/fileparsing.rb

@@ -320,7 +320,7 @@ module Puppet::Util::FileParsing
     # Convert our parsed record into a text record.
     def to_line(details)
         unless record = record_type(details[:record_type])
-            raise ArgumentError, "Invalid record type %s" % details[:record_type]
+            raise ArgumentError, "Invalid record type %s" % details[:record_type].inspect
         end
 
         if record.respond_to?(:pre_gen)
@@ -394,4 +394,4 @@ module Puppet::Util::FileParsing
     end
 end
 
-# $Id: fileparsing.rb 2697 2007-07-14 21:13:04Z luke $
+# $Id: fileparsing.rb 2750 2007-08-06 17:59:37Z luke $

data/test/language/ast/hostclass.rb

@@ -158,22 +158,6 @@ class TestASTHostClass < Test::Unit::TestCase
         assert(result, "could not find parent-defined definition from sub")
         assert(fun == result, "found incorrect parent-defined definition from sub")
     end
-
-    # Make sure the subscopes we generate get the right type and name
-    def test_subscope
-        interp = mkinterp
-
-        klass = interp.newclass("base")
-        scope = mkscope(:interp => interp)
-        scope.expects(:newscope).with(:name => "base", :type => "class", :namespace => "base").returns(mkscope(:interp => interp))
-        klass.subscope(scope)
-
-        # Now make sure it works for namespaces
-        klass = interp.newclass("sub::type")
-        scope = mkscope(:interp => interp)
-        scope.expects(:newscope).with(:name => "sub::type", :type => "class", :namespace => "sub::type").returns(mkscope(:interp => interp))
-        klass.subscope(scope)
-    end
 end
 
-# $Id: hostclass.rb 2715 2007-07-19 19:23:56Z luke $
+# $Id: hostclass.rb 2730 2007-07-31 02:34:07Z luke $

data/test/language/interpreter.rb

@@ -160,205 +160,6 @@ class TestInterpreter < PuppetTest::TestCase
         newdate = interp.parsedate
         assert(date != newdate, "Parsedate was not updated")
     end
-
-    # Make sure our node gets added to the node table.
-    def test_newnode
-        interp = mkinterp
-
-        # First just try calling it directly
-        assert_nothing_raised {
-            interp.newnode("mynode", :code => :yay)
-        }
-
-        assert_equal(:yay, interp.nodesearch_code("mynode").code)
-
-        # Now make sure that trying to redefine it throws an error.
-        assert_raise(Puppet::ParseError) {
-            interp.newnode("mynode", {})
-        }
-
-        # Now try one with no code
-        assert_nothing_raised {
-            interp.newnode("simplenode", :parent => :foo)
-        }
-
-        # Make sure trying to get the parentclass throws an error
-        assert_raise(Puppet::ParseError) do
-            interp.nodesearch_code("simplenode").parentobj
-        end
-
-        # Now define the parent node
-        interp.newnode(:foo)
-
-        # And make sure we get things back correctly
-        assert_equal("foo", interp.nodesearch_code("simplenode").parentobj.classname)
-        assert_nil(interp.nodesearch_code("simplenode").code)
-
-        # Now make sure that trying to redefine it throws an error.
-        assert_raise(Puppet::ParseError) {
-            interp.newnode("mynode", {})
-        }
-
-        # Test multiple names
-        names = ["one", "two", "three"]
-        assert_nothing_raised {
-            interp.newnode(names, {:code => :yay, :parent => :foo})
-        }
-
-        names.each do |name|
-            assert_equal(:yay, interp.nodesearch_code(name).code)
-            assert_equal("foo", interp.nodesearch_code(name).parentobj.name)
-            # Now make sure that trying to redefine it throws an error.
-            assert_raise(Puppet::ParseError) {
-                interp.newnode(name, {})
-            }
-        end
-    end
-
-    def test_fqfind
-        interp = mkinterp
-
-        table = {}
-        # Define a bunch of things.
-        %w{a c a::b a::b::c a::c a::b::c::d a::b::c::d::e::f c::d}.each do |string|
-            table[string] = string
-        end
-
-        check = proc do |namespace, hash|
-            hash.each do |thing, result|
-                assert_equal(result, interp.fqfind(namespace, thing, table),
-                            "Could not find %s in %s" % [thing, namespace])
-            end
-        end
-
-        # Now let's do some test lookups.
-
-        # First do something really simple
-        check.call "a", "b" => "a::b", "b::c" => "a::b::c", "d" => nil, "::c" => "c"
-
-        check.call "a::b", "c" => "a::b::c", "b" => "a::b", "a" => "a"
-
-        check.call "a::b::c::d::e", "c" => "a::b::c", "::c" => "c",
-            "c::d" => "a::b::c::d", "::c::d" => "c::d"
-
-        check.call "", "a" => "a", "a::c" => "a::c"
-    end
-
-    def test_newdefine
-        interp = mkinterp
-
-        assert_nothing_raised {
-            interp.newdefine("mydefine", :code => :yay,
-                :arguments => ["a", stringobj("b")])
-        }
-
-        mydefine = interp.finddefine("", "mydefine")
-        assert(mydefine, "Could not find definition")
-        assert_equal("mydefine", interp.finddefine("", "mydefine").classname)
-        assert_equal("", mydefine.namespace)
-        assert_equal("mydefine", mydefine.classname)
-
-        assert_raise(Puppet::ParseError) do
-            interp.newdefine("mydefine", :code => :yay,
-                :arguments => ["a", stringobj("b")])
-        end
-
-        # Now define the same thing in a different scope
-        assert_nothing_raised {
-            interp.newdefine("other::mydefine", :code => :other,
-                :arguments => ["a", stringobj("b")])
-        }
-        other = interp.finddefine("other", "mydefine")
-        assert(other, "Could not find definition")
-        assert(interp.finddefine("", "other::mydefine"),
-            "Could not find other::mydefine")
-        assert_equal(:other, other.code)
-        assert_equal("other", other.namespace)
-        assert_equal("other::mydefine", other.classname)
-    end
-
-    def test_newclass
-        interp = mkinterp
-
-        mkcode = proc do |ary|
-            classes = ary.collect do |string|
-                AST::FlatString.new(:value => string)
-            end
-            AST::ASTArray.new(:children => classes)
-        end
-        scope = Puppet::Parser::Scope.new(:interp => interp)
-
-        # First make sure that code is being appended
-        code = mkcode.call(%w{original code})
-
-        klass = nil
-        assert_nothing_raised {
-            klass = interp.newclass("myclass", :code => code)
-        }
-
-        assert(klass, "Did not return class")
-
-        assert(interp.findclass("", "myclass"), "Could not find definition")
-        assert_equal("myclass", interp.findclass("", "myclass").classname)
-        assert_equal(%w{original code},
-             interp.findclass("", "myclass").code.evaluate(:scope => scope))
-
-        # Now create the same class name in a different scope
-        assert_nothing_raised {
-            klass = interp.newclass("other::myclass",
-                            :code => mkcode.call(%w{something diff}))
-        }
-        assert(klass, "Did not return class")
-        other = interp.findclass("other", "myclass")
-        assert(other, "Could not find class")
-        assert(interp.findclass("", "other::myclass"), "Could not find class")
-        assert_equal("other::myclass", other.classname)
-        assert_equal("other::myclass", other.namespace)
-        assert_equal(%w{something diff},
-             interp.findclass("other", "myclass").code.evaluate(:scope => scope))
-
-        # Newclass behaves differently than the others -- it just appends
-        # the code to the existing class.
-        code = mkcode.call(%w{something new})
-        assert_nothing_raised do
-            klass = interp.newclass("myclass", :code => code)
-        end
-        assert(klass, "Did not return class when appending")
-        assert_equal(%w{original code something new},
-            interp.findclass("", "myclass").code.evaluate(:scope => scope))
-
-        # Make sure newclass deals correctly with nodes with no code
-        klass = interp.newclass("nocode")
-        assert(klass, "Did not return class")
-
-        assert_nothing_raised do
-            klass = interp.newclass("nocode", :code => mkcode.call(%w{yay test}))
-        end
-        assert(klass, "Did not return class with no code")
-        assert_equal(%w{yay test},
-            interp.findclass("", "nocode").code.evaluate(:scope => scope))
-
-        # Then try merging something into nothing
-        interp.newclass("nocode2", :code => mkcode.call(%w{foo test}))
-        assert(klass, "Did not return class with no code")
-
-        assert_nothing_raised do
-            klass = interp.newclass("nocode2")
-        end
-        assert(klass, "Did not return class with no code")
-        assert_equal(%w{foo test},
-            interp.findclass("", "nocode2").code.evaluate(:scope => scope))
-
-        # And lastly, nothing and nothing
-        klass = interp.newclass("nocode3")
-        assert(klass, "Did not return class with no code")
-
-        assert_nothing_raised do
-            klass = interp.newclass("nocode3")
-        end
-        assert(klass, "Did not return class with no code")
-        assert_nil(interp.findclass("", "nocode3").code)
-    end
     
     # Make sure class, node, and define methods are case-insensitive
     def test_structure_case_insensitivity
@@ -388,88 +189,6 @@ class TestInterpreter < PuppetTest::TestCase
         assert_equal(result, interp.nodesearch("yaYtEst.domAin.cOm"),
             "yaYtEst.domAin.cOm was not matched")
     end
-    
-    # Now make sure we get appropriate behaviour with parent class conflicts.
-    def test_newclass_parentage
-        interp = mkinterp
-        interp.newclass("base1")
-        interp.newclass("one::two::three")
-
-        # First create it with no parentclass.
-        assert_nothing_raised {
-            interp.newclass("sub")
-        }
-        assert(interp.findclass("", "sub"), "Could not find definition")
-        assert_nil(interp.findclass("", "sub").parentclass)
-
-        # Make sure we can't set the parent class to ourself.
-        assert_raise(Puppet::ParseError) {
-            interp.newclass("sub", :parent => "sub")
-        }
-
-        # Now create another one, with a parentclass.
-        assert_nothing_raised {
-            interp.newclass("sub", :parent => "base1")
-        }
-
-        # Make sure we get the right parent class, and make sure it's not an object.
-        assert_equal("base1",
-                    interp.findclass("", "sub").parentclass)
-        assert_equal(interp.findclass("", "base1"),
-                    interp.findclass("", "sub").parentobj)
-
-        # Now make sure we get a failure if we try to conflict.
-        assert_raise(Puppet::ParseError) {
-            interp.newclass("sub", :parent => "one::two::three")
-        }
-
-        # Make sure that failure didn't screw us up in any way.
-        assert_equal(interp.findclass("", "base1"),
-                    interp.findclass("", "sub").parentobj)
-        # But make sure we can create a class with a fq parent
-        assert_nothing_raised {
-            interp.newclass("another", :parent => "one::two::three")
-        }
-        assert_equal(interp.findclass("", "one::two::three"),
-                    interp.findclass("", "another").parentobj)
-
-    end
-
-    def test_namesplit
-        interp = mkinterp
-
-        assert_nothing_raised do
-            {"base::sub" => %w{base sub},
-                "main" => ["", "main"],
-                "one::two::three::four" => ["one::two::three", "four"],
-            }.each do |name, ary|
-                result = interp.namesplit(name)
-                assert_equal(ary, result, "%s split to %s" % [name, result])
-            end
-        end
-    end
-
-    # Make sure you can't have classes and defines with the same name in the
-    # same scope.
-    def test_classes_beat_defines
-        interp = mkinterp
-
-        assert_nothing_raised {
-            interp.newclass("yay::funtest")
-        }
-
-        assert_raise(Puppet::ParseError) do
-            interp.newdefine("yay::funtest")
-        end
-
-        assert_nothing_raised {
-            interp.newdefine("yay::yaytest")
-        }
-
-        assert_raise(Puppet::ParseError) do
-            interp.newclass("yay::yaytest")
-        end
-    end
 
     # Make sure our whole chain works.
     def test_evaluate
@@ -925,118 +644,29 @@ class TestInterpreter < PuppetTest::TestCase
         assert_equal({"base" => "true", "center" => "boo", "master" => "far"}, node.parameters, "node parameters were not set correctly with the top node")
     end
 
-    # Setup a module.
-    def mk_module(name, files = {})
-        mdir = File.join(@dir, name)
-        mandir = File.join(mdir, "manifests")
-        FileUtils.mkdir_p mandir
+    # Make sure that reparsing is atomic -- failures don't cause a broken state, and we aren't subject
+    # to race conditions if someone contacts us while we're reparsing.
+    def test_atomic_reparsing
+        Puppet[:filetimeout] = -10
+        file = tempfile
+        File.open(file, "w") { |f| f.puts %{file { '/tmp': ensure => directory }} }
+        interp = mkinterp :Manifest => file, :UseNodes => false
 
-        if defs = files[:define]
-            files.delete(:define)
+        assert_nothing_raised("Could not compile the first time") do
+            interp.run("yay", {})
         end
-        Dir.chdir(mandir) do
-            files.each do |file, classes|
-                File.open("%s.pp" % file, "w") do |f|
-                    classes.each { |klass|
-                        if defs
-                            f.puts "define %s {}" % klass
-                        else
-                            f.puts "class %s {}" % klass
-                        end
-                    }
-                end
-            end
-        end
-    end
-
-    # #596 - make sure classes and definitions load automatically if they're in modules, so we don't have to manually load each one.
-    def test_module_autoloading
-        @dir = tempfile
-        Puppet[:modulepath] = @dir
-
-        FileUtils.mkdir_p @dir
-
-        interp = mkinterp
-
-        # Make sure we fail like normal for actually missing classes
-        assert_nil(interp.findclass("", "nosuchclass"), "Did not return nil on missing classes")
-
-        # test the simple case -- the module class itself
-        name = "simple"
-        mk_module(name, :init => [name])
 
-        # Try to load the module automatically now
-        klass = interp.findclass("", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
-        assert_equal(name, klass.classname, "Incorrect class was returned")
+        oldparser = interp.send(:instance_variable_get, "@parser")
 
-        # Try loading the simple module when we're in something other than the base namespace.
-        interp = mkinterp
-        klass = interp.findclass("something::else", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
-        assert_equal(name, klass.classname, "Incorrect class was returned")
-
-        # Now try it with a definition as the base file
-        name = "simpdef"
-        mk_module(name, :define => true, :init => [name])
-
-        klass = interp.finddefine("", name)
-        assert_instance_of(AST::Component, klass, "Did not autoload class from module init file")
-        assert_equal(name, klass.classname, "Incorrect class was returned")
-
-        # Now try it with namespace classes where both classes are in the init file
-        interp = mkinterp
-        modname = "both"
-        name = "sub"
-        mk_module(modname, :init => %w{both both::sub})
-
-        # First try it with a namespace
-        klass = interp.findclass("both", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with a namespace")
-        assert_equal("both::sub", klass.classname, "Incorrect class was returned")
-
-        # Now try it using the fully qualified name
-        interp = mkinterp
-        klass = interp.findclass("", "both::sub")
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with no namespace")
-        assert_equal("both::sub", klass.classname, "Incorrect class was returned")
-
-
-        # Now try it with the class in a different file
-        interp = mkinterp
-        modname = "separate"
-        name = "sub"
-        mk_module(modname, :init => %w{separate}, :sub => %w{separate::sub})
-
-        # First try it with a namespace
-        klass = interp.findclass("separate", name)
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with a namespace")
-        assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
-
-        # Now try it using the fully qualified name
-        interp = mkinterp
-        klass = interp.findclass("", "separate::sub")
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with no namespace")
-        assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
-
-        # Now make sure we don't get a failure when there's no module file
-        interp = mkinterp
-        modname = "alone"
-        name = "sub"
-        mk_module(modname, :sub => %w{alone::sub})
-
-        # First try it with a namespace
-        assert_nothing_raised("Could not autoload file when module file is missing") do
-            klass = interp.findclass("alone", name)
+        # Now add a syntax failure
+        File.open(file, "w") { |f| f.puts %{file { /tmp: ensure => directory }} }
+        assert_nothing_raised("Could not compile the first time") do
+            interp.run("yay", {})
         end
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with a namespace")
-        assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
 
-        # Now try it using the fully qualified name
-        interp = mkinterp
-        klass = interp.findclass("", "alone::sub")
-        assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with no namespace")
-        assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
+        # And make sure the old parser is still there
+        newparser = interp.send(:instance_variable_get, "@parser")
+        assert_equal(oldparser.object_id, newparser.object_id, "Failed parser still replaced existing parser")
     end
 end
 
@@ -1171,4 +801,4 @@ class LdapReconnectTests < PuppetTest::TestCase
     end
 end
 
-# $Id: interpreter.rb 2686 2007-07-12 19:49:41Z luke $
+# $Id: interpreter.rb 2742 2007-08-03 23:49:53Z luke $