9 files changed, 565 insertions, 47 deletions

diff --git a/spec/unit/parser/ast/astarray.rb b/spec/unit/parser/ast/astarray.rb
new file mode 100755
index 000000000..f1c28ce47
--- /dev/null
+++ b/spec/unit/parser/ast/astarray.rb
@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::ASTArray do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should have a [] accessor" do
+        array = Puppet::Parser::AST::ASTArray.new :children => []
+        array.should respond_to(:[])
+    end
+    
+    it "should evaluate all its children" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2", :is_a? => true
+
+        item1.expects(:safeevaluate).with(@scope).returns(123)
+        item2.expects(:safeevaluate).with(@scope).returns(246)
+        
+        operator = Puppet::Parser::AST::ASTArray.new :children => [item1,item2]
+        operator.evaluate(@scope)
+    end
+
+    it "should evaluate childrens of type ASTArray" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2"
+        item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
+        item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
+        item2.stubs(:each).yields(item1)
+        
+        item1.expects(:safeevaluate).with(@scope).returns(123)
+        
+        operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
+        operator.evaluate(@scope).should == [123]
+    end
+
+    it "should flatten children coming from children ASTArray" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2"
+        item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
+        item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
+        item2.stubs(:each).yields([item1])
+        
+        item1.expects(:safeevaluate).with(@scope).returns(123)
+        
+        operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
+        operator.evaluate(@scope).should == [123]
+    end
+
+    it "should flatten the results of children evaluation" do
+        item1 = stub "item1", :is_a? => true
+        item2 = stub "item2"
+        item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
+        item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
+        item2.stubs(:each).yields([item1])
+        
+        item1.expects(:safeevaluate).with(@scope).returns([123])
+        
+        operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
+        operator.evaluate(@scope).should == [123]
+    end
+    
+    
+end
diff --git a/spec/unit/parser/ast/hostclass.rb b/spec/unit/parser/ast/hostclass.rb
index 0abc174d9..10aa62176 100755
--- a/spec/unit/parser/ast/hostclass.rb
+++ b/spec/unit/parser/ast/hostclass.rb
@@ -123,6 +123,19 @@ describe Puppet::Parser::AST::HostClass do
             @compiler.class_scope(@middle).parent.should equal(@compiler.class_scope(@top))
         end
 
+        it "should add the class's name and title to its own scope" do
+            @top_resource.stubs(:safeevaluate)
+            @middle_resource.stubs(:safeevaluate)
+            resource = @middle.evaluate(@scope)
+            scope = stub_everything 'scope', :compiler => @compiler
+            @middle.stubs(:subscope).returns(scope)
+
+            scope.expects(:setvar).with("title","top::middle")
+            scope.expects(:setvar).with("name","top::middle")
+
+            @middle.evaluate_code(resource)
+        end
+
         it "should add the parent class's namespace to its namespace search path" do
             @top_resource.stubs(:safeevaluate)
             @middle_resource.stubs(:safeevaluate)
diff --git a/spec/unit/parser/lexer.rb b/spec/unit/parser/lexer.rb
index 3b0df96a9..d62d99258 100755
--- a/spec/unit/parser/lexer.rb
+++ b/spec/unit/parser/lexer.rb
@@ -201,7 +201,7 @@ describe Puppet::Parser::Lexer::TOKENS do
     end
 
     # These tokens' strings don't matter, just that the tokens exist.
-    [:DQTEXT, :SQTEXT, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
+    [:DQTEXT, :SQTEXT, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
         it "should have a token named #{name.to_s}" do
             Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
         end
@@ -287,6 +287,34 @@ describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do
     end
 end
 
+describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do
+    before do
+        @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT]
+        @lexer = stub 'lexer', :line => 0
+    end
+
+    it "should match against lines enclosed with '/*' and '*/'" do
+        @token.regex.should =~ "/* this is a comment */"
+    end
+
+    it "should match multiple lines enclosed with '/*' and '*/'" do
+        @token.regex.should =~ """/*
+                                   this is a comment
+                                   */"""
+    end
+
+    it "should increase the lexer current line number by the amount of lines spanned by the comment" do
+        @lexer.expects(:line=).with(2)
+        @token.convert(@lexer, "1\n2\n3")
+    end
+
+    it "should not greedily match comments" do
+        match = @token.regex.match("/* first */ word /* second */")
+        match[1].should == " first "
+    end
+
+end
+
 describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
     before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] }
 
diff --git a/spec/unit/parser/parser.rb b/spec/unit/parser/parser.rb
index 07aad588d..077f93d98 100755
--- a/spec/unit/parser/parser.rb
+++ b/spec/unit/parser/parser.rb
@@ -171,6 +171,34 @@ describe Puppet::Parser do
         it "should not raise errors with a trailing comma" do
             lambda { @parser.parse("$a = [1,2,]") }.should_not raise_error
         end
+    end
+            
+    describe Puppet::Parser, "when instantiating class of same name" do
+
+        before :each do
+            @one = stub 'one', :is_a? => true
+            @one.stubs(:is_a?).with(AST::ASTArray).returns(false)
+            @one.stubs(:is_a?).with(AST).returns(true)
+
+            @two = stub 'two'
+            @two.stubs(:is_a?).with(AST::ASTArray).returns(false)
+            @two.stubs(:is_a?).with(AST).returns(true)
+        end
+
+        it "should return the first class" do
+
+            klass1 = @parser.newclass("one", { :code => @one })
+
+            @parser.newclass("one", { :code => @two }).should == klass1
+        end
+
+        it "should concatenate code" do
+            klass1 = @parser.newclass("one", { :code => @one })
+
+            @parser.newclass("one", { :code => @two })
+
+            klass1.code.children.should == [@one,@two]
+        end
 
     end
 
diff --git a/spec/unit/provider/augeas/augeas.rb b/spec/unit/provider/augeas/augeas.rb
new file mode 100644
index 000000000..1bbf18f83
--- /dev/null
+++ b/spec/unit/provider/augeas/augeas.rb
@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:augeas).provider(:augeas)
+
+describe provider_class do
+    describe "command parsing" do
+        it "should break apart a single line into three tokens" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set /Jar/Jar Binks")
+            tokens.size.should == 1
+            tokens[0].size.should == 3      
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"            
+        end
+        
+        it "should break apart a multiple line into six tokens" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set /Jar/Jar Binks\nrm anakin skywalker")
+            tokens.size.should == 2
+            tokens[0].size.should == 3      
+            tokens[1].size.should == 3            
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"            
+            tokens[1][0].should == "rm"
+            tokens[1][1].should == "anakin"
+            tokens[1][2].should == "skywalker"                
+        end        
+        
+        it "should handle arrays" do
+            provider = provider_class.new()
+            commands = ["set /Jar/Jar Binks", "rm anakin skywalker"]
+            tokens = provider.parse_commands(commands)
+            tokens.size.should == 2
+            tokens[0].size.should == 3      
+            tokens[1].size.should == 3            
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks"            
+            tokens[1][0].should == "rm"
+            tokens[1][1].should == "anakin"
+            tokens[1][2].should == "skywalker"                
+        end                
+        
+        it "should concat the last values" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set /Jar/Jar Binks is my copilot")
+            tokens.size.should == 1
+            tokens[0].size.should == 3      
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "/Jar/Jar"
+            tokens[0][2].should == "Binks is my copilot"            
+        end
+    end
+    
+    describe "get filters" do
+        before do
+            augeas_stub = stub("augeas", :get => "value")
+            @provider = provider_class.new()        
+            @provider.stubs(:open_augeas).returns(augeas_stub)        
+        end
+        
+        it "should return false for a = nonmatch" do
+            command = ["get", "fake value", "==", "value"]
+            @provider.process_get(command).should == true
+        end
+        
+        it "should return true for a != match" do
+            command = ["get", "fake value", "!=", "value"]
+            @provider.process_get(command).should == false
+        end        
+        
+        it "should return true for a =~ match" do
+            command = ["get", "fake value", "=~", "val*"]
+            @provider.process_get(command).should == true
+        end           
+        
+        it "should return false for a == nonmatch" do
+            command = ["get", "fake value", "=~", "num*"]
+            @provider.process_get(command).should == false
+        end 
+    end
+    
+    describe "match filters" do
+        before do
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            @provider = provider_class.new()        
+            @provider.stubs(:open_augeas).returns(augeas_stub)        
+        end
+        
+        it "should return true for size match" do
+            command = ["match", "fake value", "size", "==", "3"]
+            @provider.process_match(command).should == true
+        end
+        
+        it "should return false for a size non match" do
+            command = ["match", "fake value", "size", "<", "3"]
+            @provider.process_match(command).should == false
+        end    
+        
+        it "should return true for includes match" do
+            command = ["get", "fake value", "include", "values"]
+            @provider.process_match(command).should == true
+        end           
+        
+        it "should return false for includes non match" do
+            command = ["get", "fake value", "include", "JarJar"]
+            @provider.process_match(command).should == false
+        end           
+        
+        it "should return true for an array match" do
+            command = ["get", "fake value", "==", "['set', 'of', 'values']"]
+            @provider.process_match(command).should == true
+        end  
+        
+        it "should return false for an array non match" do
+            command = ["get", "fake value", "==", "['this', 'should', 'not', 'match']"]
+            @provider.process_match(command).should == false
+        end                 
+    end    
+    
+    describe "need_to_run" do
+        it "should handle no filters" do
+            resource = stub("resource", :[] => "")
+            provider = provider_class.new(resource)
+            provider.need_to_run?.should == true        
+        end
+        
+        it "should return true when a get filter matches" do
+            resource = stub("resource", :[] => "get path == value")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :get => "value")
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == true       
+        end       
+        
+        it "should return false when a get filter does not match" do
+            resource = stub("resource", :[] => "get path == another value")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :get => "value")
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == false       
+        end            
+        
+        it "should return true when a match filter matches" do
+            resource = stub("resource", :[] => "match path size == 3")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == true       
+        end       
+        
+        it "should return false when a match filter does not match" do
+            resource = stub("resource", :[] => "match path size == 2")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            provider.stubs(:open_augeas).returns(augeas_stub)              
+            provider.need_to_run?.should == false       
+        end       
+    end
+    
+    describe "augeas integration" do
+        
+        before do
+            @resource = stub("resource")
+            @provider = provider_class.new(@resource)
+            @augeas = stub("augeas")
+            @provider.stubs(:open_augeas).returns(@augeas)
+        end
+    
+        it "should handle set commands" do
+            command = [["set", "/Jar/Jar", "Binks"]]
+            context = "/some/path"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:set).with("/some/path/Jar/Jar", "Binks")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end
+        
+        it "should handle rm commands" do
+            command = [["rm", "/Jar/Jar"]]
+            context = ""
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:rm).with("/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end        
+        
+        it "should handle remove commands" do
+            command = [["remove", "Jar/Jar"]]
+            context = ""
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:rm).with("/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end              
+        
+        it "should handle clear commands" do
+            command = [["clear", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:clear).with("/foo/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end        
+        
+        it "should handle insert commands" do
+            command = [["insert", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end     
+        
+        it "should handle ins commands" do
+            command = [["ins", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end      
+        
+        it "should handle multiple commands" do
+            command = [["ins", "/Jar/Jar"], ["clear", "/Jar/Jar"]]
+            context = "/foo"
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:clear).with("/foo/Jar/Jar")            
+            @augeas.expects(:save).returns(true)
+            @provider.execute_changes.should == :executed
+        end    
+    end
+end
diff --git a/spec/unit/type/augeas.rb b/spec/unit/type/augeas.rb
new file mode 100644
index 000000000..bda98b697
--- /dev/null
+++ b/spec/unit/type/augeas.rb
@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+augeas = Puppet::Type.type(:augeas)
+
+describe augeas do
+
+	describe "basic structure" do
+		it "should have a default provider inheriting from Puppet::Provider" do
+			augeas.defaultprovider.ancestors.should be_include(Puppet::Provider)
+		end
+		
+		it "should have a valid provider" do
+			augeas.create(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+		end		
+
+		it "should be able to create a instance" do
+			augeas.create(:name => "bar").should_not be_nil
+		end
+
+		it "should have an parse_commands feature" do
+			augeas.provider_feature(:parse_commands).should_not be_nil
+		end
+		
+		it "should have an need_to_run? feature" do
+			augeas.provider_feature(:need_to_run?).should_not be_nil
+		end    
+		
+		it "should have an execute_changes feature" do
+			augeas.provider_feature(:execute_changes).should_not be_nil
+		end   		
+
+		properties = [:returns]
+		params = [:name, :context, :onlyif, :changes, :root, :load_path, :type_check]
+
+		properties.each do |property|
+			it "should have a %s property" % property do
+				augeas.attrclass(property).ancestors.should be_include(Puppet::Property)
+			end
+
+			it "should have documentation for its %s property" % property do
+				augeas.attrclass(property).doc.should be_instance_of(String)
+			end
+		end		
+		
+		params.each do |param|
+			it "should have a %s parameter" % param do
+				augeas.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+			end
+
+			it "should have documentation for its %s parameter" % param do
+				augeas.attrclass(param).doc.should be_instance_of(String)
+			end
+		end				
+	end
+	
+	describe "default values" do
+		it "should be blank for context" do
+			augeas.create(:name => :context)[:context].should == ""
+		end
+		
+		it "should be blank for onlyif" do
+			augeas.create(:name => :onlyif)[:onlyif].should == ""
+		end		
+		
+		it "should be blank for load_path" do
+			augeas.create(:name => :load_path)[:load_path].should == ""
+		end		
+		
+		it "should be / for root" do
+			augeas.create(:name => :root)[:root].should == "/"
+		end		
+		
+		it "should be false for type_check" do
+			augeas.create(:name => :type_check)[:type_check].should == :false
+		end				
+	end
+	
+	describe "provider interaction" do
+		it "should munge the changes" do
+			provider = stub("provider", :parse_commands => "Jar Jar Binks")
+			resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+			changes = augeas.attrclass(:changes).new(:resource => resource)
+			changes.value= "Testing 123"
+			changes.value.should == "Jar Jar Binks"
+		end
+		
+		it "should return 0 if it does not need to run" do
+			provider = stub("provider", :need_to_run? => false)
+			resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+			changes = augeas.attrclass(:returns).new(:resource => resource)
+			changes.retrieve.should == 0
+		end		
+		
+		it "should return :need_to_run if it needs to run" do
+			provider = stub("provider", :need_to_run? => true)
+			resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+			changes = augeas.attrclass(:returns).new(:resource => resource)
+			changes.retrieve.should == :need_to_run
+		end				
+	end
+end
diff --git a/spec/unit/type/mount.rb b/spec/unit/type/mount.rb
index 9d09225cc..7ddb7ea26 100755
--- a/spec/unit/type/mount.rb
+++ b/spec/unit/type/mount.rb
@@ -180,3 +180,32 @@ describe Puppet::Type.type(:mount)::Ensure do
         end
     end
 end
+
+describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
+    before do
+        @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
+        Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
+        @mount = Puppet::Type.type(:mount).create(:name => "yay", :ensure => :mounted)
+
+        {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
+            :ensure => :mounted}.each do
+            |param, value|
+            @mount.provider.stubs(param).returns value
+            @mount[param] = value
+        end
+
+        @mount.provider.stubs(:mounted?).returns true
+
+        @catalog = Puppet::Node::Catalog.new
+        @catalog.add_resource @mount
+    end
+
+    it "should use the provider to change the dump value" do
+        @mount.provider.expects(:dump).returns 0
+        @mount.provider.expects(:dump=).with(1)
+
+        @mount[:dump] = 1
+
+        @catalog.apply
+    end
+end
diff --git a/spec/unit/type/tidy.rb b/spec/unit/type/tidy.rb
new file mode 100755
index 000000000..89f178389
--- /dev/null
+++ b/spec/unit/type/tidy.rb
@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+tidy = Puppet::Type.type(:tidy)
+
+describe tidy do
+    [:ensure, :age, :size].each do |property|
+        it "should have a %s property" % property do
+            tidy.attrclass(property).ancestors.should be_include(Puppet::Property)
+        end
+
+        it "should have documentation for its %s property" % property do
+            tidy.attrclass(property).doc.should be_instance_of(String)
+        end
+    end
+
+    [:path, :matches, :type, :recurse, :rmdirs].each do |param|
+        it "should have a %s parameter" % param do
+            tidy.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+        end
+
+        it "should have documentation for its %s param" % param do
+            tidy.attrclass(param).doc.should be_instance_of(String)
+        end
+    end
+
+    describe "when validating parameter values" do
+        describe "for 'recurse'" do
+            before do
+                @tidy = tidy.create :path => "/tmp", :age => "100d"
+            end
+
+            it "should allow 'true'" do
+                lambda { @tidy[:recurse] = true }.should_not raise_error
+            end
+
+            it "should allow 'false'" do
+                lambda { @tidy[:recurse] = false }.should_not raise_error
+            end
+
+            it "should allow integers" do
+                lambda { @tidy[:recurse] = 10 }.should_not raise_error
+            end
+
+            it "should allow string representations of integers" do
+                lambda { @tidy[:recurse] = "10" }.should_not raise_error
+            end
+
+            it "should allow 'inf'" do
+                lambda { @tidy[:recurse] = "inf" }.should_not raise_error
+            end
+
+            it "should not allow arbitrary values" do
+                lambda { @tidy[:recurse] = "whatever" }.should raise_error
+            end
+        end
+    end
+end
diff --git a/spec/unit/util/log.rb b/spec/unit/util/log.rb
index aa00602a9..c42b25c74 100755
--- a/spec/unit/util/log.rb
+++ b/spec/unit/util/log.rb
@@ -103,51 +103,5 @@ describe Puppet::Util::Log do
             report.should be_include(log.source)
             report.should be_include(log.time.to_s)
         end
-
-        it "should have a method for indicating whether it was created by a resource" do
-            Puppet::Util::Log.new(:level => "notice", :message => :foo).should respond_to(:objectsource?)
-        end
-
-        describe "when setting a source" do
-            it "should mark itself as from a Puppet resource if its source is a Puppet resource" do
-                file = Puppet::Type.type(:file).create :path => "/testing/object/source/in/logs"
-                Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => file).should be_objectsource
-            end
-
-            it "should use the resource's path when its source is a resource" do
-                # Use a different path, so we don't use 'clear', which is deprecated in master
-                file = Puppet::Type.type(:file).create :path => "/testing/object/source/in/logs/with/path"
-                file.expects(:path).returns "mypath"
-                Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => file).source.should == "mypath"
-            end
-
-            it "should mark itself as from a Puppet resource if its source is a Puppet parameter" do
-                file = Puppet::Type.type(:file).create :path => "/testing/object/source/in/logs/with/parameters", :mode => "500"
-                mode = file.property(:mode)
-                Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => mode).should be_objectsource
-            end
-
-            it "should use the resource's path when its source is a Puppet parameter" do
-                # Use a different path, so we don't use 'clear', which is deprecated in master
-                file = Puppet::Type.type(:file).create :path => "/testing/object/source/in/logs/with/path/in/parameters", :mode => "500"
-                mode = file.property(:mode)
-                mode.expects(:path).returns "mypath"
-                Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => mode).source.should == "mypath"
-            end
-
-            it "should acquire its source's tags if its source has any" do
-                file = Puppet::Type.type(:file).create :path => "/testing/object/source/in/logs/with/tags"
-                file.tag("foo")
-                file.tag("bar")
-                log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => file)
-
-                log.should be_tagged("foo")
-                log.should be_tagged("bar")
-            end
-
-            it "should not set objectsource if the source is not a Parameter or Resource" do
-                Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => "mysource").should_not be_objectsource
-            end
-        end
     end
 end