diff --git a/lib/puppet/parser/collector.rb b/lib/puppet/parser/collector.rb
index bb1cd3947..08fd3ff0e 100644
--- a/lib/puppet/parser/collector.rb
+++ b/lib/puppet/parser/collector.rb
@@ -1,218 +1,218 @@
 # An object that collects stored objects from the central cache and returns
 # them to the current host, yo.
 class Puppet::Parser::Collector
   attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
 
   # Call the collection method, mark all of the returned objects as
   # non-virtual, optionally applying parameter overrides. The collector can
   # also delete himself from the compiler if there is no more resources to
   # collect (valid only for resource fixed-set collector which get their
   # resources from +collect_resources+ and not from the catalog)
   def evaluate
     # Shortcut if we're not using storeconfigs and they're trying to collect
     # exported resources.
     if form == :exported and Puppet[:storeconfigs] != true
       Puppet.warning "Not collecting exported resources without storeconfigs"
       return false
     end
 
     if self.resources
       unless objects = collect_resources and ! objects.empty?
         return false
       end
     else
       method = "collect_#{@form.to_s}"
       objects = send(method).each do |obj|
         obj.virtual = false
       end
       return false if objects.empty?
     end
 
     # we have an override for the collected resources
     if @overrides and !objects.empty?
       # force the resource to be always child of any other resource
       overrides[:source].meta_def(:child_of?) do
         true
       end
 
       # tell the compiler we have some override for him unless we already
       # overrided those resources
       objects.each do |res|
         unless @collected.include?(res.ref)
           newres = Puppet::Parser::Resource.
             new(res.type, res.title,
                 :parameters => overrides[:parameters],
                 :file       => overrides[:file],
                 :line       => overrides[:line],
                 :source     => overrides[:source],
                 :scope      => overrides[:scope])
 
           scope.compiler.add_override(newres)
         end
       end
     end
 
     # filter out object that this collector has previously found.
     objects.reject! { |o| @collected.include?(o.ref) }
 
     return false if objects.empty?
 
     # keep an eye on the resources we have collected
     objects.inject(@collected) { |c,o| c[o.ref]=o; c }
 
     # return our newly collected resources
     objects
   end
 
   def initialize(scope, type, equery, vquery, form)
     @scope = scope
 
     # initialisation
     @collected = {}
 
     # Canonize the type
     @type = Puppet::Resource.new(type, "whatever").type
     @equery = equery
     @vquery = vquery
 
     raise(ArgumentError, "Invalid query form #{form}") unless [:exported, :virtual].include?(form)
     @form = form
   end
 
   # add a resource override to the soon to be exported/realized resources
   def add_override(hash)
     raise ArgumentError, "Exported resource try to override without parameters" unless hash[:parameters]
 
     # schedule an override for an upcoming collection
     @overrides = hash
   end
 
   private
 
   # Create our active record query.
   def build_active_record_query
     Puppet::Rails.init unless ActiveRecord::Base.connected?
 
     raise Puppet::DevError, "Cannot collect resources for a nil host" unless @scope.host
     host = Puppet::Rails::Host.find_by_name(@scope.host)
 
     search = "(exported=? AND restype=?)"
     values = [true, @type]
 
     search += " AND (#{@equery})" if @equery
 
     # note: we're not eagerly including any relations here because it can
     # creates so much objects we'll throw out later.  We used to eagerly
     # include param_names/values but the way the search filter is built ruined
     # those efforts and we were eagerly loading only the searched parameter
     # and not the other ones.
     query = {}
     case search
     when /puppet_tags/
       query = {:joins => {:resource_tags => :puppet_tag}}
     when /param_name/
       query = {:joins => {:param_values => :param_name}}
     end
 
     # We're going to collect objects from rails, but we don't want any
     # objects from this host.
     search = ("host_id != ? AND #{search}") and values.unshift(host.id) if host
 
     query[:conditions] = [search, *values]
 
     query
   end
 
   # Collect exported objects.
   def collect_exported
     # First get everything from the export table.  Just reuse our
     # collect_virtual method but tell it to use 'exported? for the test.
     resources = collect_virtual(true).reject { |r| ! r.virtual? }
 
     count = resources.length
 
     query = build_active_record_query
 
     # Now look them up in the rails db.  When we support attribute comparison
     # and such, we'll need to vary the conditions, but this works with no
     # attributes, anyway.
     time = Puppet::Util.thinmark do
       Puppet::Rails::Resource.find(:all, query).each do |obj|
         if resource = exported_resource(obj)
           count += 1
           resources << resource
         end
       end
     end
 
     scope.debug("Collected %s %s resource%s in %.2f seconds" % [count, @type, count == 1 ? "" : "s", time])
 
     resources
   end
 
   def collect_resources
     @resources = [@resources] unless @resources.is_a?(Array)
     method = "collect_#{form.to_s}_resources"
     send(method)
   end
 
   def collect_exported_resources
     raise Puppet::ParseError, "realize() is not yet implemented for exported resources"
   end
 
   # Collect resources directly; this is the result of using 'realize',
   # which specifies resources, rather than using a normal collection.
   def collect_virtual_resources
     return [] unless defined?(@resources) and ! @resources.empty?
     result = @resources.dup.collect do |ref|
       if res = @scope.findresource(ref.to_s)
         @resources.delete(ref)
         res
       end
     end.reject { |r| r.nil? }.each do |res|
       res.virtual = false
     end
 
     # If there are no more resources to find, delete this from the list
     # of collections.
     @scope.compiler.delete_collection(self) if @resources.empty?
 
     result
   end
 
   # Collect just virtual objects, from our local compiler.
   def collect_virtual(exported = false)
     scope.compiler.resources.find_all do |resource|
       resource.type == @type and (exported ? resource.exported? : true) and match?(resource)
     end
   end
 
   # Seek a specific exported resource.
   def exported_resource(obj)
     if existing = @scope.findresource(obj.restype, obj.title)
       # Next see if we've already collected this resource
-      return nil if existing.rails_id == obj.id
+      return nil if existing.collector_id == obj.id
 
       # This is the one we've already collected
       raise Puppet::ParseError, "Exported resource #{obj.ref} cannot override local resource"
     end
 
     resource = obj.to_resource(self.scope)
 
     resource.exported = false
 
     scope.compiler.add_resource(scope, resource)
 
     resource
   end
 
   # Does the resource match our tests?  We don't yet support tests,
   # so it's always true at the moment.
   def match?(resource)
     if self.vquery
       return self.vquery.call(resource)
     else
       return true
     end
   end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 3bb5f8601..4a1900315 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,343 +1,343 @@
 require 'puppet/resource'
 
 # The primary difference between this class and its
 # parent is that this class has rules on who can set
 # parameters
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/file_collection/lookup'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
   include Puppet::FileCollection::Lookup
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
-  attr_accessor :source, :scope, :rails_id
+  attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
 
   attr_reader :exported, :parameters
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
     @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
     @relationship_names.include?(name)
   end
 
   # Set up some boolean test methods
   def translated?; !!@translated; end
   def override?;   !!@override;   end
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
     param = symbolize(param)
     if param == :title
       return self.title
     end
     if @parameters.has_key?(param)
       @parameters[param].value
     else
       nil
     end
   end
 
   def []=(param, value)
     set_parameter(param, value)
   end
 
   def eachparam
     @parameters.each do |name, param|
       yield param
     end
   end
 
   def environment
     scope.environment
   end
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
     return unless self.type.to_s.downcase == "class"
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
       raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
     end
 
     self[:stage] ||= stage.title unless stage.title == :main
     catalog.add_edge(stage, self)
   end
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       evaluated_code = klass.evaluate_code(self)
       add_edge_to_stage
 
       return evaluated_code
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else
       self.fail "Cannot find definition #{type}"
     end
   end
 
   # Mark this resource as both exported and virtual,
   # or remove the exported mark.
   def exported=(value)
     if value
       @virtual = true
       @exported = value
     else
       @exported = value
     end
   end
 
   # Do any finishing work on this object, called before evaluation or
   # before storage/translation.
   def finish
     return if finished?
     @finished = true
     add_defaults
     add_metaparams
     add_scope_tags
     validate
   end
 
   # Has this resource already been finished?
   def finished?
     @finished
   end
 
   def initialize(*args)
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
     @source ||= scope.source
   end
 
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
       return resource_type.isomorphic?
     else
       return true
     end
   end
 
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
     end
   end
 
   # Unless we're running >= 0.25, we're in compat mode.
   def metaparam_compatibility_mode?
     ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
   end
 
   def name
     self[:name] || self.title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
   def path
     to_s
   end
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
     if ! value.nil?
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
     elsif ! param.is_a?(Puppet::Parser::Resource::Param)
       raise ArgumentError, "Must pass a parameter or all necessary values"
     end
 
     tag(*param.value) if param.name == :tag
 
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
       # Skip "undef" values.
       hash[param.name] = param.value if param.value != :undef
       hash
     end
   end
 
 
   # Create a Puppet::Resource instance from this parser resource.
   # We plan, at some point, on not needing to do this conversion, but
   # it's sufficient for now.
   def to_resource
     result = Puppet::Resource.new(type, title)
 
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
       elsif v.is_a?(Array)
         # flatten resource references arrays
         v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
         v = v.collect do |av|
           av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
           av
         end
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
 
     result
   end
 
   # Translate our object to a transportable object.
   def to_trans
     return nil if virtual?
 
     to_resource.to_trans
   end
 
   # Convert this resource to a RAL resource.  We hackishly go via the
   # transportable stuff.
   def to_ral
     to_resource.to_ral
   end
 
   private
 
   # Add default values from our definition.
   def add_defaults
     scope.lookupdefaults(self.type).each do |name, param|
       unless @parameters.include?(name)
         self.debug "Adding default for #{name}"
 
         @parameters[name] = param.dup
       end
     end
   end
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
     return unless val = scope.lookupvar(name.to_s) and val != :undefined
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
 
     # For relationship params, though, join the values (a la #446).
     @parameters[name].value = [@parameters[name].value, val].flatten
   end
 
   # Add any metaparams defined in our scope. This actually adds any metaparams
   # from any parent scope, and there's currently no way to turn that off.
   def add_metaparams
     compat_mode = metaparam_compatibility_mode?
 
     Puppet::Type.eachmetaparam do |name|
       next unless self.class.relationship_parameter?(name)
       add_backward_compatible_relationship_param(name) if compat_mode
     end
   end
 
   def add_scope_tags
     if scope_resource = scope.resource
       tag(*scope_resource.tags)
     end
   end
 
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source)
       puts caller if Puppet[:trace]
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
         fields = []
         fields << current.file if current.file
         fields << current.line.to_s if current.line
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
     # If we've gotten this far, we're allowed to override.
 
     # Merge with previous value, if the parameter was generated with the +>
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
     # implcitly shared when multiple resources are overrriden at once (see
     # ticket #3556).
     if param.add
       param = param.dup
       param.value = [current.value, param.value].flatten
     end
 
     set_parameter(param)
   end
 
   # Make sure the resource's parameters are all valid for the type.
   def validate
     @parameters.each do |name, param|
       validate_parameter(name)
     end
   rescue => detail
     fail Puppet::ParseError, detail.to_s
   end
 
   private
 
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice
       self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
 
       set_parameter(param)
     end
   end
 end
diff --git a/lib/puppet/rails/resource.rb b/lib/puppet/rails/resource.rb
index 582cdd41a..cded3f3c1 100644
--- a/lib/puppet/rails/resource.rb
+++ b/lib/puppet/rails/resource.rb
@@ -1,231 +1,231 @@
 require 'puppet'
 require 'puppet/rails/param_name'
 require 'puppet/rails/param_value'
 require 'puppet/rails/puppet_tag'
 require 'puppet/rails/benchmark'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Resource < ActiveRecord::Base
   include Puppet::Util::CollectionMerger
   include Puppet::Util::ReferenceSerializer
   include Puppet::Rails::Benchmark
 
   has_many :param_values, :dependent => :destroy, :class_name => "Puppet::Rails::ParamValue"
   has_many :param_names, :through => :param_values, :class_name => "Puppet::Rails::ParamName"
 
   has_many :resource_tags, :dependent => :destroy, :class_name => "Puppet::Rails::ResourceTag"
   has_many :puppet_tags, :through => :resource_tags, :class_name => "Puppet::Rails::PuppetTag"
 
   belongs_to :source_file
   belongs_to :host
 
   @tags = {}
   def self.tags
     @tags
   end
 
   # Determine the basic details on the resource.
   def self.rails_resource_initial_args(resource)
     result = [:type, :title, :line].inject({}) do |hash, param|
       # 'type' isn't a valid column name, so we have to use another name.
       to = (param == :type) ? :restype : param
       if value = resource.send(param)
         hash[to] = value
       end
       hash
     end
 
     # We always want a value here, regardless of what the resource has,
     # so we break it out separately.
     result[:exported] = resource.exported || false
 
     result
   end
 
   def add_resource_tag(tag)
     pt = Puppet::Rails::PuppetTag.accumulate_by_name(tag)
     resource_tags.build(:puppet_tag => pt)
   end
 
   def file
     (f = self.source_file) ? f.filename : nil
   end
 
   def file=(file)
     self.source_file = Puppet::Rails::SourceFile.find_or_create_by_filename(file)
   end
 
   def title
     unserialize_value(self[:title])
   end
 
   def params_list
     @params_list ||= []
   end
 
   def params_list=(params)
     @params_list = params
   end
 
   def add_param_to_list(param)
     params_list << param
   end
 
   def tags_list
     @tags_list ||= []
   end
 
   def tags_list=(tags)
     @tags_list = tags
   end
 
   def add_tag_to_list(tag)
     tags_list << tag
   end
 
   def [](param)
     super || parameter(param)
   end
 
   # Make sure this resource is equivalent to the provided Parser resource.
   def merge_parser_resource(resource)
     accumulate_benchmark("Individual resource merger", :attributes) { merge_attributes(resource) }
     accumulate_benchmark("Individual resource merger", :parameters) { merge_parameters(resource) }
     accumulate_benchmark("Individual resource merger", :tags) { merge_tags(resource) }
     save
   end
 
   def merge_attributes(resource)
     args = self.class.rails_resource_initial_args(resource)
     args.each do |param, value|
       self[param] = value unless resource[param] == value
     end
 
     # Handle file specially
     self.file = resource.file if (resource.file and  (!resource.file or self.file != resource.file))
   end
 
   def merge_parameters(resource)
     catalog_params = {}
     resource.each do |param, value|
       catalog_params[param.to_s] = value
     end
 
     db_params = {}
 
     deletions = []
     params_list.each do |value|
       # First remove any parameters our catalog resource doesn't have at all.
       deletions << value['id'] and next unless catalog_params.include?(value['name'])
 
       # Now store them for later testing.
       db_params[value['name']] ||= []
       db_params[value['name']] << value
     end
 
     # Now get rid of any parameters whose value list is different.
     # This might be extra work in cases where an array has added or lost
     # a single value, but in the most common case (a single value has changed)
     # this makes sense.
     db_params.each do |name, value_hashes|
       values = value_hashes.collect { |v| v['value'] }
 
       value_hashes.each { |v| deletions << v['id'] } unless value_compare(catalog_params[name], values)
     end
 
     # Perform our deletions.
     Puppet::Rails::ParamValue.delete(deletions) unless deletions.empty?
 
     # Lastly, add any new parameters.
     catalog_params.each do |name, value|
       next if db_params.include?(name) && ! db_params[name].find{ |val| deletions.include?( val["id"] ) }
       values = value.is_a?(Array) ? value : [value]
 
       values.each do |v|
         param_values.build(:value => serialize_value(v), :line => resource.line, :param_name => Puppet::Rails::ParamName.accumulate_by_name(name))
       end
     end
   end
 
   # Make sure the tag list is correct.
   def merge_tags(resource)
     in_db = []
     deletions = []
     resource_tags = resource.tags
     tags_list.each do |tag|
       deletions << tag['id'] and next unless resource_tags.include?(tag['name'])
       in_db << tag['name']
     end
     Puppet::Rails::ResourceTag.delete(deletions) unless deletions.empty?
 
     (resource_tags - in_db).each do |tag|
       add_resource_tag(tag)
     end
   end
 
   def value_compare(v,db_value)
     v = [v] unless v.is_a?(Array)
 
     v == db_value
   end
 
   def name
     ref
   end
 
   def parameter(param)
     if pn = param_names.find_by_name(param)
       return (pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn])) ? pv.value : nil
     end
   end
 
   def ref(dummy_argument=:work_arround_for_ruby_GC_bug)
     "#{self[:restype].split("::").collect { |s| s.capitalize }.join("::")}[#{self.title}]"
   end
 
   # Returns a hash of parameter names and values, no ActiveRecord instances.
   def to_hash
     Puppet::Rails::ParamValue.find_all_params_from_resource(self).inject({}) do |hash, value|
       hash[value['name']] ||= []
       hash[value['name']] << value.value
       hash
     end
   end
 
   # Convert our object to a resource.  Do not retain whether the object
   # is exported, though, since that would cause it to get stripped
   # from the configuration.
   def to_resource(scope)
     hash = self.attributes
     hash["type"] = hash["restype"]
     hash.delete("restype")
 
     # FIXME At some point, we're going to want to retain this information
     # for logging and auditing.
     hash.delete("host_id")
     hash.delete("updated_at")
     hash.delete("source_file_id")
     hash.delete("created_at")
     hash.delete("id")
     hash.each do |p, v|
       hash.delete(p) if v.nil?
     end
     hash[:scope] = scope
     hash[:source] = scope.source
     hash[:parameters] = []
     names = []
     self.param_names.each do |pname|
       # We can get the same name multiple times because of how the
       # db layout works.
       next if names.include?(pname.name)
       names << pname.name
       hash[:parameters] << pname.to_resourceparam(self, scope.source)
     end
     obj = Puppet::Parser::Resource.new(hash.delete("type"), hash.delete("title"), hash)
 
     # Store the ID, so we can check if we're re-collecting the same resource.
-    obj.rails_id = self.id
+    obj.collector_id = self.id
 
     obj
   end
 end
diff --git a/spec/unit/parser/collector_spec.rb b/spec/unit/parser/collector_spec.rb
index 01918d2a0..4ddafa160 100755
--- a/spec/unit/parser/collector_spec.rb
+++ b/spec/unit/parser/collector_spec.rb
@@ -1,555 +1,555 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/rails'
 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
 
   it "should accept an optional resource override" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     override = { :parameters => "whatever" }
     @collector.add_override(override)
     @collector.overrides.should equal(override)
   end
 
 end
 
 describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
   before do
     @scope = mock 'scope'
     @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 = 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
   end
 
   it "should return matched resources" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     @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 = stub_everything 'one'
     @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 = 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 and catalog 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 virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @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])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should mark all matched resources as non-virtual" do
     one = stub_everything '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_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @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_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything '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_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything '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 create a resource with overridden parameters" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).with { |type, title, h|
       h[:parameters] == 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(:parameters => 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(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == 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(:parameters => 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_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
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 end
 
 describe Puppet::Parser::Collector, "when collecting exported resources", :if => Puppet.features.rails? do
   before do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
     @resource_type = "Mytype"
     @equery = "test = true"
     @vquery = proc { |r| true }
 
     res = stub("resource 1")
     res.stubs(:type).returns @resource_type
     Puppet::Resource.stubs(:new).returns res
 
     Puppet.settings.stubs(:value).with(:storeconfigs).returns true
     Puppet.settings.stubs(:value).with(:environment).returns "production"
 
     @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, :ref => "one"
     two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "two"
 
     one.stubs(:exported=)
     one.stubs(:virtual=)
     two.stubs(:exported=)
     two.stubs(:virtual=)
 
     @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, :ref => "one"
 
     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, :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)
 
     @compiler.stubs(:add_resource)
 
     @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', :type => "Mytype"
     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(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == 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, :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)
 
     @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, :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)
 
     @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
+    inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :collector_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
+    inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :collector_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", :if => Puppet.features.rails? do
   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 }
 
     @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)
 
     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[1]
       options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should join with parameter names, parameter values when querying ActiveRecord" do
     @collector.equery = "param_names.name = title"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:param_values => :param_name}
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should join with tag tables when querying ActiveRecord with a tag exported query" do
     @collector.equery = "puppet_tags.name = test"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:resource_tags => :puppet_tag}
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should not join parameters when querying ActiveRecord with a tag exported query" do
     @collector.equery = "puppet_tags.name = test"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:param_values => :param_name}
     }.returns([@resource])
 
     @collector.evaluate.should be_false
   end
 
   it "should only search for exported resources with the matching type" do
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0].include?("(exported=? AND restype=?)") and options[:conditions][1] == true and options[:conditions][2] == "Mytype"
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should include the export query if one is provided" do
     @collector.equery = "test = true"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0].include?("test = true")
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 end