puppet 0.24.6 → 0.24.7

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

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Node do
+    before :each do
+        @node = Puppet::Node.new "testnode"
+        @parser = Puppet::Parser::Parser.new :environment => "development"
+        @scope_resource = stub 'scope_resource', :builtin? => true
+        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
+
+        @scope = @compiler.topscope
+    end
+
+    describe Puppet::Parser::AST::Node, "when evaluating" do
+
+        before do
+            @top = @parser.newnode("top").shift
+            @middle = @parser.newnode("middle", :parent => "top").shift
+        end
+
+        it "should create a resource that references itself" do
+            @top.evaluate(@scope)
+
+            @compiler.catalog.resource(:node, "top").should be_an_instance_of(Puppet::Parser::Resource)
+        end
+
+        it "should evaluate the parent class if one exists" do
+            @middle.evaluate(@scope)
+
+            @compiler.catalog.resource(:node, "top").should be_an_instance_of(Puppet::Parser::Resource)
+        end
+
+        it "should fail to evaluate if a parent class is defined but cannot be found" do
+            othertop = @parser.newnode("something", :parent => "yay").shift
+            lambda { othertop.evaluate(@scope) }.should raise_error(Puppet::ParseError)
+        end
+
+        it "should not create a new resource if one already exists" do
+            @compiler.catalog.expects(:resource).with(:node, "top").returns("something")
+            @compiler.catalog.expects(:add_resource).never
+            @top.evaluate(@scope)
+        end
+
+        it "should not create a new parent resource if one already exists and it has a parent class" do
+            @top.evaluate(@scope)
+
+            top_resource = @compiler.catalog.resource(:node, "top")
+
+            @middle.evaluate(@scope)
+
+            @compiler.catalog.resource(:node, "top").should equal(top_resource)
+        end
+
+        # #795 - tag before evaluation.
+        it "should tag the catalog with the resource tags when it is evaluated" do
+            @middle.evaluate(@scope)
+
+            @compiler.catalog.should be_tagged("middle")
+        end
+
+        it "should tag the catalog with the parent class tags when it is evaluated" do
+            @middle.evaluate(@scope)
+
+            @compiler.catalog.should be_tagged("top")
+        end
+    end
+
+    describe Puppet::Parser::AST::Node, "when evaluating code" do
+
+        before do
+            @top_resource = stub "top_resource"
+            @top = @parser.newnode("top", :code => @top_resource).shift
+
+            @middle_resource = stub "middle_resource"
+            @middle = @parser.newnode("middle", :parent => "top", :code => @middle_resource).shift
+        end
+
+        it "should evaluate the code referred to by the class" do
+            @top_resource.expects(:safeevaluate)
+
+            resource = @top.evaluate(@scope)
+
+            @top.evaluate_code(resource)
+        end
+
+        it "should evaluate the parent class's code if it has a parent" do
+            @top_resource.expects(:safeevaluate)
+            @middle_resource.expects(:safeevaluate)
+
+            resource = @middle.evaluate(@scope)
+
+            @middle.evaluate_code(resource)
+        end
+
+        it "should not evaluate the parent class's code if the parent has already been evaluated" do
+            @top_resource.stubs(:safeevaluate)
+            resource = @top.evaluate(@scope)
+            @top.evaluate_code(resource)
+
+            @top_resource.expects(:safeevaluate).never
+            @middle_resource.stubs(:safeevaluate)
+            resource = @middle.evaluate(@scope)
+            @middle.evaluate_code(resource)
+        end
+
+        it "should use the parent class's scope as its parent scope" do
+            @top_resource.stubs(:safeevaluate)
+            @middle_resource.stubs(:safeevaluate)
+            resource = @middle.evaluate(@scope)
+            @middle.evaluate_code(resource)
+
+            @compiler.class_scope(@middle).parent.should equal(@compiler.class_scope(@top))
+        end
+
+        it "should add the parent class's namespace to its namespace search path" do
+            @top_resource.stubs(:safeevaluate)
+            @middle_resource.stubs(:safeevaluate)
+            resource = @middle.evaluate(@scope)
+            @middle.evaluate_code(resource)
+
+            @compiler.class_scope(@middle).namespaces.should be_include(@top.namespace)
+        end
+    end
+end

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Nop do
+
+    before do
+        @scope = mock 'scope'
+    end
+
+    it "should do nothing on evaluation" do
+        Puppet::Parser::AST.expects(:safeevaluate).never
+        Puppet::Parser::AST::Nop.new({}).evaluate(@scope)
+    end
+
+    it "should not return anything" do
+        Puppet::Parser::AST::Nop.new({}).evaluate(@scope).should be_nil
+    end
+
+end

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Not do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+        @true_ast = Puppet::Parser::AST::Boolean.new( :value => true)
+        @false_ast = Puppet::Parser::AST::Boolean.new( :value => false)
+    end
+
+    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
+
+    it "should return true for ! false" do
+        operator = Puppet::Parser::AST::Not.new :value => @false_ast
+        operator.evaluate(@scope).should == true
+    end
+
+    it "should return false for ! true" do
+        operator = Puppet::Parser::AST::Not.new :value => @true_ast
+        operator.evaluate(@scope).should == false
+    end
+
+end

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

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::ResourceOverride do
+
+    ast = Puppet::Parser::AST
+
+    before :each do
+        @compiler = stub 'compiler'
+        @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+        @params = ast::ASTArray.new({})
+        @compiler.stubs(:add_override)
+    end
+
+    it "should evaluate the overriden object" do
+        klass = stub 'klass', :title => "title", :type => "type"
+        object = mock 'object'
+        object.expects(:safeevaluate).with(@scope).returns(klass)
+        ast::ResourceOverride.new(:object => object, :params => @params ).evaluate(@scope)
+    end
+
+    it "should tell the compiler to override the resource with our own" do
+        @compiler.expects(:add_override)
+
+        klass = stub 'klass', :title => "title", :type => "one"
+        object = mock 'object', :safeevaluate => klass
+        ast::ResourceOverride.new(:object => object , :params => @params).evaluate(@scope)
+    end
+
+    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.should be_an_instance_of(Puppet::Parser::Resource)
+        override.title.should == "title"
+        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.should have(2).elements
+        override.each {|o| o.should be_an_instance_of(Puppet::Parser::Resource) }
+    end
+
+end

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

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::ResourceReference do
+
+    ast = Puppet::Parser::AST
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    def newref(title, type)
+        title = stub 'title', :safeevaluate => title
+        ref = Puppet::Parser::AST::ResourceReference.new(:type => type, :title => title)
+    end
+
+    it "should evaluate correctly reference to builtin types" do
+        newref("/tmp/yay", "File").evaluate(@scope).to_s.should == "File[/tmp/yay]"
+    end
+
+    %{ "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)
+        
+            newref("three", type).evaluate(@scope).to_ref.should == Puppet::Parser::Resource::Reference.new( :type => type, :title => "three" ).to_ref
+        end
+    end
+
+    it "should be able to call qualified_class" do
+        klass = stub 'klass', :title => "three", :classname => "one"
+        @scope.expects(:findclass).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)
+        
+        evaled = newref("one", "class").evaluate(@scope)
+        evaled.type.should == "Class"
+        evaled.title.should == "one"
+    end
+
+    it "should return an array of reference if given an array of titles" 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
+
+    it "should qualify class of all titles for Class resource references" do
+        titles = mock 'titles', :safeevaluate => ["title1","title2"]
+        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
+
+end

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

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::VarDef do
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    describe "when evaluating" 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,  
+                                                     :line => nil
+            vardef.evaluate(@scope)
+        end
+
+        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,  
+                                                     :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,  
+                                                     :line => nil, :append => true
+            vardef.evaluate(@scope)
+        end
+
+    end
+end

data/spec/unit/parser/collector.rb

@@ -0,0 +1,426 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parser/collector'
+
+describe Puppet::Parser::Collector, "when initializing" do
+    before do
+        @scope = mock 'scope'
+        @resource_type = 'resource_type'
+        @form = :exported
+        @vquery = mock 'vquery'
+        @equery = mock 'equery'
+
+        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, @form)
+    end
+
+    it "should require a scope" do
+        @collector.scope.should equal(@scope)
+    end
+
+    it "should require a resource type" do
+        @collector.type.should == 'Resource_type'
+    end
+
+    it "should only accept :virtual or :exported as the collector form" do
+        proc { @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @vquery, @equery, :other) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept an optional virtual query" do
+        @collector.vquery.should equal(@vquery)
+    end
+
+    it "should accept an optional exported query" do
+        @collector.equery.should equal(@equery)
+    end
+
+    it "should canonize the type name" do
+        @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
+        @collector.type.should == "Resource::Type"
+    end
+end
+
+describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
+    before do
+        @scope = mock 'scope'
+        @resource_type = mock 'resource_type'
+        @vquery = mock 'vquery'
+        @equery = mock 'equery'
+
+        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :virtual)
+    end
+
+    it "should not fail when it does not find any resources to collect" do
+        @collector.resources = ["File[virtual1]", "File[virtual2]"]
+        @scope.stubs(:findresource).returns(false)
+        proc { @collector.evaluate }.should_not raise_error
+    end
+
+    it "should mark matched resources as non-virtual" do
+        @collector.resources = ["File[virtual1]", "File[virtual2]"]
+        one = mock 'one'
+        one.expects(:virtual=).with(false)
+        @scope.stubs(:findresource).with("File[virtual1]").returns(one)
+        @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
+        @collector.evaluate
+    end
+
+    it "should return matched resources" do
+        @collector.resources = ["File[virtual1]", "File[virtual2]"]
+        one = mock 'one'
+        one.stubs(:virtual=)
+        @scope.stubs(:findresource).with("File[virtual1]").returns(one)
+        @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
+        @collector.evaluate.should == [one]
+    end
+
+    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=)
+        @compiler.expects(:delete_collection).with(@collector)
+        @scope.expects(:compiler).returns(@compiler)
+        @scope.stubs(:findresource).with("File[virtual1]").returns(one)
+        @collector.evaluate
+    end
+
+    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=)
+        @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
+    before do
+        @scope = mock 'scope'
+        @compiler = mock 'compile'
+        @scope.stubs(:compiler).returns(@compiler)
+        @resource_type = "Mytype"
+        @vquery = proc { |res| true }
+
+        @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
+
+        one.stubs(:virtual=)
+        two.stubs(:virtual=)
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector.evaluate.should == [one, two]
+    end
+
+    it "should mark all matched resources as non-virtual" do
+        one = stub 'one', :type => "Mytype", :virtual? => true
+
+        one.expects(:virtual=).with(false)
+
+        @compiler.expects(:resources).returns([one])
+
+        @collector.evaluate
+    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=)
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector.evaluate.should == [one, two]
+    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.expects(:virtual=).with(false)
+        two.expects(:virtual=).with(false)
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, nil, :virtual)
+
+        @collector.evaluate.should == [one, two]
+    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.expects(:virtual=).with(false)
+        two.expects(:virtual=).never
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @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
+
+        one.expects(:virtual=).never
+        two.expects(:virtual=).never
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector.evaluate.should be_false
+    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.expects(:virtual=).with(false)
+        two.expects(:virtual=).never
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector.evaluate.should == [one]
+    end
+end
+
+describe Puppet::Parser::Collector, "when collecting exported resources" do
+    confine Puppet.features.rails? => "Cannot test Rails integration without ActiveRecord"
+
+    before do
+        @scope = stub 'scope', :host => "myhost", :debug => nil
+        @compiler = mock 'compile'
+        @scope.stubs(:compiler).returns(@compiler)
+        @resource_type = "Mytype"
+        @equery = "test = true"
+        @vquery = proc { |r| true }
+
+        Puppet.settings.stubs(:value).with(:storeconfigs).returns true
+
+        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
+    end
+
+    # Stub most of our interface to Rails.
+    def stub_rails(everything = false)
+        ActiveRecord::Base.stubs(:connected?).returns(false)
+        Puppet::Rails.stubs(:init)
+        if everything
+            Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+            Puppet::Rails::Resource.stubs(:find).returns([])
+        end
+    end
+
+    it "should just return false if :storeconfigs is not enabled" do
+        Puppet.settings.expects(:value).with(:storeconfigs).returns false
+        @collector.evaluate.should be_false
+    end
+
+    it "should use initialize the Rails support if ActiveRecord is not connected" do
+        @compiler.stubs(:resources).returns([])
+        ActiveRecord::Base.expects(:connected?).returns(false)
+        Puppet::Rails.expects(:init)
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+        Puppet::Rails::Resource.stubs(:find).returns([])
+
+        @collector.evaluate
+    end
+
+    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.expects(:exported=).with(false)
+        one.expects(:virtual=).with(false)
+        two.expects(:exported=).with(false)
+        two.expects(:virtual=).with(false)
+
+        @compiler.expects(:resources).returns([one, two])
+
+        @collector.evaluate.should == [one, two]
+    end
+
+    it "should mark all returned resources as not virtual" do
+        stub_rails(true)
+
+        one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true
+
+        one.stubs(:exported=)
+        one.expects(:virtual=).with(false)
+
+        @compiler.expects(:resources).returns([one])
+
+        @collector.evaluate.should == [one]
+    end
+
+    it "should convert all found resources into parser resources" do
+        stub_rails()
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+
+        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true
+        Puppet::Rails::Resource.stubs(:find).returns([one])
+
+        resource = mock 'resource'
+        one.expects(:to_resource).with(@scope).returns(resource)
+        resource.stubs(:exported=)
+        resource.stubs(:virtual=)
+
+        @compiler.stubs(:resources).returns([])
+        @scope.stubs(:findresource).returns(nil)
+
+        @compiler.stubs(:add_resource)
+
+        @collector.evaluate.should == [resource]
+    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
+        Puppet::Rails::Resource.stubs(:find).returns([one])
+
+        resource = mock 'resource'
+        one.expects(:to_resource).with(@scope).returns(resource)
+        resource.stubs(:exported=)
+        resource.stubs(:virtual=)
+
+        @compiler.stubs(:resources).returns([])
+        @scope.stubs(:findresource).returns(nil)
+
+        @compiler.expects(:add_resource).with(@scope, resource)
+
+        @collector.evaluate.should == [resource]
+    end
+
+    # This way one host doesn't store another host's resources as exported.
+    it "should mark resources collected from the database as not exported" do
+        stub_rails()
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+
+        one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true
+        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=)
+
+        @compiler.stubs(:resources).returns([])
+        @scope.stubs(:findresource).returns(nil)
+
+        @compiler.stubs(:add_resource)
+
+        @collector.evaluate
+    end
+
+    it "should fail if an equivalent resource already exists in the compile" do
+        stub_rails()
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+
+        rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
+        inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 2
+
+        Puppet::Rails::Resource.stubs(:find).returns([rails])
+
+        resource = mock 'resource'
+
+        @compiler.stubs(:resources).returns([])
+        @scope.stubs(:findresource).returns(inmemory)
+
+        @compiler.stubs(:add_resource)
+
+        proc { @collector.evaluate }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should ignore exported resources that match already-collected resources" do
+        stub_rails()
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+
+        rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
+        inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 1
+
+        Puppet::Rails::Resource.stubs(:find).returns([rails])
+
+        resource = mock 'resource'
+
+        @compiler.stubs(:resources).returns([])
+        @scope.stubs(:findresource).returns(inmemory)
+
+        @compiler.stubs(:add_resource)
+
+        proc { @collector.evaluate }.should_not raise_error(Puppet::ParseError)
+    end
+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"
+
+    before do
+        @scope = stub 'scope', :host => "myhost", :debug => nil
+        @compiler = mock 'compile'
+        @scope.stubs(:compiler).returns(@compiler)
+        @resource_type = "Mytype"
+        @equery = nil
+        @vquery = proc { |r| true }
+
+        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
+        @compiler.stubs(:resources).returns([])
+
+        ActiveRecord::Base.stubs(:connected?).returns(false)
+
+        Puppet::Rails.stubs(:init)
+        Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+        Puppet::Rails::Resource.stubs(:find).returns([])
+
+        Puppet.settings.stubs(:value).with(:storeconfigs).returns true
+    end
+
+    it "should exclude all resources from the host if ActiveRecord contains information for this host" do
+        @host = mock 'host'
+        @host.stubs(:id).returns 5
+
+        Puppet::Rails::Host.expects(:find_by_name).with(@scope.host).returns(@host)
+
+        Puppet::Rails::Resource.stubs(:find).with { |*arguments|
+            options = arguments[3]
+            options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5 
+        }.returns([])
+
+        @collector.evaluate
+    end
+
+    it "should return parameter names and parameter values when querying ActiveRecord" do
+        Puppet::Rails::Resource.stubs(:find).with { |*arguments|
+            options = arguments[3]
+            options[:include] == {:param_values => :param_name}
+        }.returns([])
+
+        @collector.evaluate
+    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([])
+    end
+
+    it "should include the export query if one is provided" do
+        @collector = Puppet::Parser::Collector.new(@scope, @resource_type, "test = true", @vquery, :exported)
+        Puppet::Rails::Resource.stubs(:find).with { |*arguments|
+            options = arguments[3]
+            options[:conditions][0].include?("test = true")
+        }.returns([])
+    end
+end