puppet 0.24.9 → 0.25.0

data/spec/unit/parser/ast/not.rb

@@ -12,7 +12,7 @@ describe Puppet::Parser::AST::Not do
     it "should evaluate its child expression" do
         val = stub "val"
         val.expects(:safeevaluate).with(@scope)
-        
+
         operator = Puppet::Parser::AST::Not.new :value => val
         operator.evaluate(@scope)
     end

data/spec/unit/parser/ast/resource_override.rb

@@ -31,19 +31,19 @@ describe Puppet::Parser::AST::ResourceOverride do
     it "should return the overriden resource directly when called with one item" do
         klass = stub 'klass', :title => "title", :type => "one"
         object = mock 'object', :safeevaluate => klass
-        override = ast::ResourceOverride.new(:object => object , :params => @params).evaluate(@scope)        
+        override = ast::ResourceOverride.new(:object => object , :params => @params).evaluate(@scope)
         override.should be_an_instance_of(Puppet::Parser::Resource)
         override.title.should == "title"
-        override.type.should == "One" 
+        override.type.should == "One"
     end
 
     it "should return an array of overriden resources when called with an array of titles" do
         klass1 = stub 'klass1', :title => "title1", :type => "one"
         klass2 = stub 'klass2', :title => "title2", :type => "one"
-        
+
         object = mock 'object', :safeevaluate => [klass1,klass2]
-        
-        override = ast::ResourceOverride.new(:object => object , :params => @params).evaluate(@scope)        
+
+        override = ast::ResourceOverride.new(:object => object , :params => @params).evaluate(@scope)
         override.should have(2).elements
         override.each {|o| o.should be_an_instance_of(Puppet::Parser::Resource) }
     end

data/spec/unit/parser/ast/resource_reference.rb

@@ -22,7 +22,7 @@ describe Puppet::Parser::AST::ResourceReference do
     %{ "one::two" "one-two"}.each do |type|
         it "should evaluate correctly reference to define" do
             klass = stub 'klass', :title => "three", :classname => type
-            @scope.stubs(:finddefine).returns(klass)
+            @scope.stubs(:find_definition).returns(klass)
         
             newref("three", type).evaluate(@scope).to_ref.should == Puppet::Parser::Resource::Reference.new( :type => type, :title => "three" ).to_ref
         end
@@ -30,13 +30,13 @@ describe Puppet::Parser::AST::ResourceReference do
 
     it "should be able to call qualified_class" do
         klass = stub 'klass', :title => "three", :classname => "one"
-        @scope.expects(:findclass).with("one").returns(klass)
+        @scope.expects(:find_hostclass).with("one").returns(klass)
         newref("three","class").qualified_class(@scope,"one").should == "one" 
     end
 
     it "should be able to find qualified classes when evaluating" do
         klass = stub 'klass', :title => "one", :classname => "one"
-        @scope.stubs(:findclass).returns(klass)
+        @scope.stubs(:find_hostclass).returns(klass)
         
         evaled = newref("one", "class").evaluate(@scope)
         evaled.type.should == "Class"
@@ -47,7 +47,7 @@ describe Puppet::Parser::AST::ResourceReference do
         titles = mock 'titles', :safeevaluate => ["title1","title2"]
         ref = ast::ResourceReference.new( :title => titles, :type => "Resource" )
         ref.stubs(:qualified_type).with(@scope).returns("Resource")
-        
+
         ref.evaluate(@scope).should have(2).elements
     end
 
@@ -56,8 +56,14 @@ describe Puppet::Parser::AST::ResourceReference do
         ref = ast::ResourceReference.new( :title => titles, :type => "Class" )
         ref.expects(:qualified_class).with(@scope,"title1").returns("class")
         ref.expects(:qualified_class).with(@scope,"title2").returns("class")
-        
+
         ref.evaluate(@scope)
     end
 
+    it "should return a correct representation when converting to string" do
+        type = stub 'type', :is_a? => true, :to_s => "file"
+        title = stub 'title', :is_a? => true, :to_s => "[/tmp/a, /tmp/b]"
+
+        ast::ResourceReference.new( :type => type, :title => title ).to_s.should == "File[/tmp/a, /tmp/b]"
+    end
 end

data/spec/unit/parser/ast/selector.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Selector do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    describe "when evaluating" do
+
+        before :each do
+            @param = stub 'param'
+            @param.stubs(:safeevaluate).with(@scope).returns("value")
+
+            @value1 = stub 'value1'
+            @param1 = stub_everything 'param1'
+            @param1.stubs(:safeevaluate).with(@scope).returns(@param1)
+            @param1.stubs(:respond_to?).with(:downcase).returns(false)
+            @value1.stubs(:param).returns(@param1)
+            @value1.stubs(:value).returns(@value1)
+
+            @value2 = stub 'value2'
+            @param2 = stub_everything 'param2'
+            @param2.stubs(:safeevaluate).with(@scope).returns(@param2)
+            @param2.stubs(:respond_to?).with(:downcase).returns(false)
+            @value2.stubs(:param).returns(@param2)
+            @value2.stubs(:value).returns(@value2)
+
+            @values = stub 'values', :instance_of? => true
+            @values.stubs(:each).multiple_yields(@value1, @value2)
+
+            @selector = Puppet::Parser::AST::Selector.new :param => @param, :values => @values
+            @selector.stubs(:fail)
+        end
+
+        it "should evaluate param" do
+            @param.expects(:safeevaluate).with(@scope)
+
+            @selector.evaluate(@scope)
+        end
+
+        it "should downcase the evaluated param value if allowed" do
+            Puppet.stubs(:[]).with(:casesensitive).returns(false)
+            value = stub 'param'
+            @param.stubs(:safeevaluate).with(@scope).returns(value)
+
+            value.expects(:downcase)
+
+            @selector.evaluate(@scope)
+        end
+
+        it "should scan each option" do
+            @values.expects(:each).multiple_yields(@value1, @value2)
+
+            @selector.evaluate(@scope)
+        end
+
+        describe "when scanning values" do
+            it "should evaluate first matching option" do
+                @param2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
+                @value2.expects(:safeevaluate).with(@scope)
+
+                @selector.evaluate(@scope)
+            end
+
+            it "should return the first matching evaluated option" do
+                @param2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
+                @value2.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @selector.evaluate(@scope).should == :result
+            end
+
+            it "should evaluate the default option if none matched" do
+                @param1.stubs(:is_a?).with(Puppet::Parser::AST::Default).returns(true)
+                @value1.expects(:safeevaluate).with(@scope).returns(@param1)
+
+                @selector.evaluate(@scope)
+            end
+
+            it "should return the default evaluated option if none matched" do
+                result = stub 'result'
+                @param1.stubs(:is_a?).with(Puppet::Parser::AST::Default).returns(true)
+                @value1.stubs(:safeevaluate).returns(result)
+
+                @selector.evaluate(@scope).should == result
+            end
+
+            it "should return nil if nothing matched" do
+                @selector.evaluate(@scope).should be_nil
+            end
+
+            it "should delegate matching to evaluate_match" do
+                @param1.expects(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }
+
+                @selector.evaluate(@scope)
+            end
+
+            it "should transmit the sensitive parameter to evaluate_match" do
+                Puppet.stubs(:[]).with(:casesensitive).returns(:sensitive)
+                @param1.expects(:evaluate_match).with { |*arg| arg[2][:sensitive] == :sensitive }
+
+                @selector.evaluate(@scope)
+            end
+
+            it "should transmit the AST file and line to evaluate_match" do
+                @selector.file = :file
+                @selector.line = :line
+                @param1.expects(:evaluate_match).with { |*arg| arg[2][:file] == :file and arg[2][:line] == :line }
+
+                @selector.evaluate(@scope)
+            end
+
+
+            it "should evaluate the matching param" do
+                @param1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+
+                @value1.expects(:safeevaluate).with(@scope)
+
+                @selector.evaluate(@scope)
+            end
+
+            it "should return this evaluated option if it matches" do
+                @param1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+                @value1.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @selector.evaluate(@scope).should == :result
+            end
+
+            it "should unset scope ephemeral variables after option evaluation" do
+                @param1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+                @value1.stubs(:safeevaluate).with(@scope).returns(:result)
+
+                @scope.expects(:unset_ephemeral_var)
+
+                @selector.evaluate(@scope)
+            end
+
+            it "should not leak ephemeral variables even if evaluation fails" do
+                @param1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
+                @value1.stubs(:safeevaluate).with(@scope).raises
+
+                @scope.expects(:unset_ephemeral_var)
+
+                lambda { @selector.evaluate(@scope) }.should raise_error
+            end
+
+            it "should fail if there is no default" do
+                @selector.expects(:fail)
+
+                @selector.evaluate(@scope)
+            end
+        end
+
+    end
+end

data/spec/unit/parser/ast/vardef.rb

@@ -12,11 +12,11 @@ describe Puppet::Parser::AST::VarDef do
         it "should evaluate arguments" do
             name = mock 'name'
             value = mock 'value'
-            
+
             name.expects(:safeevaluate).with(@scope)
             value.expects(:safeevaluate).with(@scope)
 
-            vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,  
+            vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
                                                      :line => nil
             vardef.evaluate(@scope)
         end
@@ -24,21 +24,21 @@ describe Puppet::Parser::AST::VarDef do
         it "should be in append=false mode if called without append" do
             name = stub 'name', :safeevaluate => "var"
             value = stub 'value', :safeevaluate => "1"
-            
-            @scope.expects(:setvar).with { |name,value,file,line,append| append == nil }
-            
-            vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,  
+
+            @scope.expects(:setvar).with { |name,value,options| options[:append] == nil }
+
+            vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
                                                      :line => nil
             vardef.evaluate(@scope)
         end
-        
+
         it "should call scope in append mode if append is true" do
             name = stub 'name', :safeevaluate => "var"
             value = stub 'value', :safeevaluate => "1"
-            
-            @scope.expects(:setvar).with { |name,value,file,line,append| append == true }
-            
-            vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,  
+
+            @scope.expects(:setvar).with { |name,value,options| options[:append] == true }
+
+            vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
                                                      :line => nil, :append => true
             vardef.evaluate(@scope)
         end

data/spec/unit/parser/collector.rb

@@ -39,6 +39,14 @@ describe Puppet::Parser::Collector, "when initializing" do
         @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
         @collector.type.should == "Resource::Type"
     end
+
+    it "should accept an optional resource override" do
+        @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
+        override = { :params => "whatever" }
+        @collector.add_override(override)
+        @collector.overrides.should equal(override)
+    end
+
 end
 
 describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
@@ -59,8 +67,9 @@ describe Puppet::Parser::Collector, "when collecting specific virtual resources"
 
     it "should mark matched resources as non-virtual" do
         @collector.resources = ["File[virtual1]", "File[virtual2]"]
-        one = mock 'one'
+        one = stub_everything 'one'
         one.expects(:virtual=).with(false)
+
         @scope.stubs(:findresource).with("File[virtual1]").returns(one)
         @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
         @collector.evaluate
@@ -68,8 +77,7 @@ describe Puppet::Parser::Collector, "when collecting specific virtual resources"
 
     it "should return matched resources" do
         @collector.resources = ["File[virtual1]", "File[virtual2]"]
-        one = mock 'one'
-        one.stubs(:virtual=)
+        one = stub_everything 'one'
         @scope.stubs(:findresource).with("File[virtual1]").returns(one)
         @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
         @collector.evaluate.should == [one]
@@ -77,8 +85,7 @@ describe Puppet::Parser::Collector, "when collecting specific virtual resources"
 
     it "should delete itself from the compile's collection list if it has found all of its resources" do
         @collector.resources = ["File[virtual1]"]
-        one = mock 'one'
-        one.stubs(:virtual=)
+        one = stub_everything 'one'
         @compiler.expects(:delete_collection).with(@collector)
         @scope.expects(:compiler).returns(@compiler)
         @scope.stubs(:findresource).with("File[virtual1]").returns(one)
@@ -87,15 +94,14 @@ describe Puppet::Parser::Collector, "when collecting specific virtual resources"
 
     it "should not delete itself from the compile's collection list if it has unfound resources" do
         @collector.resources = ["File[virtual1]"]
-        one = mock 'one'
-        one.stubs(:virtual=)
+        one = stub_everything 'one'
         @compiler.expects(:delete_collection).never
         @scope.stubs(:findresource).with("File[virtual1]").returns(nil)
         @collector.evaluate
     end
 end
 
-describe Puppet::Parser::Collector, "when collecting virtual resources" do
+describe Puppet::Parser::Collector, "when collecting virtual and catalog resources" do
     before do
         @scope = mock 'scope'
         @compiler = mock 'compile'
@@ -106,12 +112,18 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
         @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, @vquery, :virtual)
     end
 
-    it "should find all resources matching the vquery" do
-        one = stub 'one', :type => "Mytype", :virtual? => true
-        two = stub 'two', :type => "Mytype", :virtual? => true
+    it "should find all virtual resources matching the vquery" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true
+        two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
-        one.stubs(:virtual=)
-        two.stubs(:virtual=)
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector.evaluate.should == [one, two]
+    end
+
+    it "should find all non-virtual resources matching the vquery" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => false
+        two = stub_everything 'two', :type => "Mytype", :virtual? => false
 
         @compiler.expects(:resources).returns([one, two])
 
@@ -119,7 +131,7 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
     end
 
     it "should mark all matched resources as non-virtual" do
-        one = stub 'one', :type => "Mytype", :virtual? => true
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true
 
         one.expects(:virtual=).with(false)
 
@@ -129,11 +141,8 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
     end
 
     it "should return matched resources" do
-        one = stub 'one', :type => "Mytype", :virtual? => true
-        two = stub 'two', :type => "Mytype", :virtual? => true
-
-        one.stubs(:virtual=)
-        two.stubs(:virtual=)
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true
+        two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
         @compiler.expects(:resources).returns([one, two])
 
@@ -141,8 +150,8 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
     end
 
     it "should return all resources of the correct type if there is no virtual query" do
-        one = stub 'one', :type => "Mytype", :virtual? => true
-        two = stub 'two', :type => "Mytype", :virtual? => true
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true
+        two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
         one.expects(:virtual=).with(false)
         two.expects(:virtual=).with(false)
@@ -155,8 +164,8 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
     end
 
     it "should not return or mark resources of a different type" do
-        one = stub 'one', :type => "Mytype", :virtual? => true
-        two = stub 'two', :type => :other, :virtual? => true
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true
+        two = stub_everything 'two', :type => :other, :virtual? => true
 
         one.expects(:virtual=).with(false)
         two.expects(:virtual=).never
@@ -166,23 +175,84 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
         @collector.evaluate.should == [one]
     end
 
-    it "should not return or mark non-virtual resources" do
-        one = stub 'one', :type => "Mytype", :virtual? => false
-        two = stub 'two', :type => :other, :virtual? => false
+    it "should create a resource with overriden parameters" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
+        param = stub 'param'
+        @compiler.stubs(:add_override)
 
-        one.expects(:virtual=).never
-        two.expects(:virtual=).never
+        @compiler.expects(:resources).returns([one])
 
-        @compiler.expects(:resources).returns([one, two])
+        @collector.add_override(:params => param )
+        Puppet::Parser::Resource.expects(:new).with { |h|
+            h[:params] == param
+        }
+
+        @collector.evaluate
+    end
+
+    it "should define a new allow all child_of? on overriden resource" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
+        param = stub 'param'
+        source = stub 'source'
+        @compiler.stubs(:add_override)
+
+        @compiler.expects(:resources).returns([one])
+
+        @collector.add_override(:params => param, :source => source )
+        Puppet::Parser::Resource.stubs(:new)
+
+        source.expects(:meta_def).with { |name,block| name == :child_of? }
+
+        @collector.evaluate
+    end
+
+
+    it "should not override already overriden resources for this same collection in a previous run" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
+        param = stub 'param'
+        @compiler.stubs(:add_override)
+
+        @compiler.expects(:resources).at_least(2).returns([one])
+
+        @collector.add_override(:params => param )
+        Puppet::Parser::Resource.expects(:new).once.with { |h|
+            h[:params] == param
+        }
+
+        @collector.evaluate
+
+        @collector.evaluate
+    end
+
+    it "should not return resources that were collected in a previous run of this collector" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
+        @compiler.stubs(:resources).returns([one])
+
+        @collector.evaluate
 
         @collector.evaluate.should be_false
     end
 
+
+    it "should tell the compiler about the overriden resources" do
+        one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
+        param = stub 'param'
+
+        one.expects(:virtual=).with(false)
+        @compiler.expects(:resources).returns([one])
+        @collector.add_override(:params => param )
+        Puppet::Parser::Resource.stubs(:new).returns("whatever")
+
+        @compiler.expects(:add_override).with("whatever")
+
+        @collector.evaluate
+    end
+
     it "should not return or mark non-matching resources" do
         @collector.vquery = proc { |res| res.name == :one }
 
-        one = stub 'one', :name => :one, :type => "Mytype", :virtual? => true
-        two = stub 'two', :name => :two, :type => "Mytype", :virtual? => true
+        one = stub_everything 'one', :name => :one, :type => "Mytype", :virtual? => true
+        two = stub_everything 'two', :name => :two, :type => "Mytype", :virtual? => true
 
         one.expects(:virtual=).with(false)
         two.expects(:virtual=).never
@@ -194,7 +264,7 @@ describe Puppet::Parser::Collector, "when collecting virtual resources" do
 end
 
 describe Puppet::Parser::Collector, "when collecting exported resources" do
-    confine Puppet.features.rails? => "Cannot test Rails integration without ActiveRecord"
+    confine "Cannot test Rails integration without ActiveRecord" => Puppet.features.rails?
 
     before do
         @scope = stub 'scope', :host => "myhost", :debug => nil
@@ -237,8 +307,8 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
     it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
         stub_rails(true)
 
-        one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true
-        two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true
+        one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
+        two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "two"
 
         one.stubs(:exported=)
         one.stubs(:virtual=)
@@ -253,7 +323,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
     it "should mark all returned resources as not virtual" do
         stub_rails(true)
 
-        one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true
+        one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
 
         one.stubs(:exported=)
         one.expects(:virtual=).with(false)
@@ -267,13 +337,14 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
         stub_rails()
         Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
-        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true
+        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
         Puppet::Rails::Resource.stubs(:find).returns([one])
 
         resource = mock 'resource'
         one.expects(:to_resource).with(@scope).returns(resource)
         resource.stubs(:exported=)
         resource.stubs(:virtual=)
+        resource.stubs(:ref)
 
         @compiler.stubs(:resources).returns([])
         @scope.stubs(:findresource).returns(nil)
@@ -283,17 +354,47 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
         @collector.evaluate.should == [resource]
     end
 
+    it "should override all exported collected resources if collector has an override" do
+        stub_rails()
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+
+        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
+        Puppet::Rails::Resource.stubs(:find).returns([one])
+
+        resource = mock 'resource'
+        one.expects(:to_resource).with(@scope).returns(resource)
+        resource.stubs(:exported=)
+        resource.stubs(:virtual=)
+        resource.stubs(:ref)
+        resource.stubs(:title)
+
+        @compiler.stubs(:resources).returns([])
+        @scope.stubs(:findresource).returns(nil)
+
+        param = stub 'param'
+        @compiler.stubs(:add_override)
+        @compiler.stubs(:add_resource)
+
+        @collector.add_override(:params => param )
+        Puppet::Parser::Resource.expects(:new).once.with { |h|
+            h[:params] == param
+        }
+
+        @collector.evaluate
+    end
+
     it "should store converted resources in the compile's resource list" do
         stub_rails()
         Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
-        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true
+        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
         Puppet::Rails::Resource.stubs(:find).returns([one])
 
         resource = mock 'resource'
         one.expects(:to_resource).with(@scope).returns(resource)
         resource.stubs(:exported=)
         resource.stubs(:virtual=)
+        resource.stubs(:ref)
 
         @compiler.stubs(:resources).returns([])
         @scope.stubs(:findresource).returns(nil)
@@ -308,13 +409,14 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
         stub_rails()
         Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
-        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true
+        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
         Puppet::Rails::Resource.stubs(:find).returns([one])
 
         resource = mock 'resource'
         one.expects(:to_resource).with(@scope).returns(resource)
         resource.expects(:exported=).with(false)
         resource.stubs(:virtual=)
+        resource.stubs(:ref)
 
         @compiler.stubs(:resources).returns([])
         @scope.stubs(:findresource).returns(nil)
@@ -364,7 +466,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
 end
 
 describe Puppet::Parser::Collector, "when building its ActiveRecord query for collecting exported resources" do
-    confine Puppet.features.rails? => "Cannot test Rails integration without ActiveRecord"
+    confine "Cannot test Rails integration without ActiveRecord" => Puppet.features.rails?
 
     before do
         @scope = stub 'scope', :host => "myhost", :debug => nil
@@ -374,7 +476,10 @@ describe Puppet::Parser::Collector, "when building its ActiveRecord query for co
         @equery = nil
         @vquery = proc { |r| true }
 
+        @resource = stub_everything 'collected'
+
         @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
+        @collector.stubs(:exported_resource).with(@resource).returns(@resource)
         @compiler.stubs(:resources).returns([])
 
         ActiveRecord::Base.stubs(:connected?).returns(false)
@@ -394,33 +499,47 @@ describe Puppet::Parser::Collector, "when building its ActiveRecord query for co
 
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
             options = arguments[3]
-            options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5 
-        }.returns([])
+            options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5
+        }.returns([@resource])
 
-        @collector.evaluate
+        @collector.evaluate.should == [@resource]
     end
 
-    it "should return parameter names and parameter values when querying ActiveRecord" do
+    it "should return parameter names, parameter values when querying ActiveRecord" do
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
             options = arguments[3]
             options[:include] == {:param_values => :param_name}
-        }.returns([])
+        }.returns([@resource])
 
-        @collector.evaluate
+        @collector.evaluate.should == [@resource]
+    end
+
+    it "should return tags when querying ActiveRecord with a tag exported query" do
+        @collector.equery = "puppet_tags.name = test"
+        Puppet::Rails::Resource.stubs(:find).with { |*arguments|
+            options = arguments[3]
+            options[:include] == {:param_values => :param_name, :puppet_tags => :resource_tags}
+        }.returns([@resource])
+
+        @collector.evaluate.should == [@resource]
     end
 
     it "should only search for exported resources with the matching type" do
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
             options = arguments[3]
             options[:conditions][0].include?("(exported=? AND restype=?)") and options[:conditions][1] == true and options[:conditions][2] == "Mytype"
-        }.returns([])
+        }.returns([@resource])
+
+        @collector.evaluate.should == [@resource]
     end
 
     it "should include the export query if one is provided" do
-        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, "test = true", @vquery, :exported)
+        @collector.equery = "test = true"
         Puppet::Rails::Resource.stubs(:find).with { |*arguments|
             options = arguments[3]
             options[:conditions][0].include?("test = true")
-        }.returns([])
+        }.returns([@resource])
+
+        @collector.evaluate.should == [@resource]
     end
 end