diff --git a/spec/lib/puppet_spec/database.rb b/spec/lib/puppet_spec/database.rb
new file mode 100644
index 000000000..2f7c209cd
--- /dev/null
+++ b/spec/lib/puppet_spec/database.rb
@@ -0,0 +1,30 @@
+# This just makes some nice things available at global scope, and for setup of
+# tests to use a real fake database, rather than a fake stubs-that-don't-work
+# version of the same.  Fun times.
+def sqlite?
+  if $sqlite.nil?
+    begin
+      require 'sqlite3'
+      $sqlite = true
+    rescue LoadError
+      $sqlite = false
+    end
+  end
+  $sqlite
+end
+
+def can_use_scratch_database?
+  sqlite? and Puppet.features.rails?
+end
+
+
+# This is expected to be called in your `before :each` block, and will get you
+# ready to roll with a serious database and all.  Cleanup is handled
+# automatically for you.  Nothing to do there.
+def setup_scratch_database
+  dir = PuppetSpec::Files.tmpdir('puppet-sqlite')
+  Puppet[:dbadapter]    = 'sqlite3'
+  Puppet[:dblocation]   = (dir + 'storeconfigs.sqlite').to_s
+  Puppet[:railslog]     = '/dev/null'
+  Puppet::Rails.init
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index d5beddb98..d00590a6e 100755
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,121 +1,122 @@
 dir = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift File.join(dir, 'lib')
 
 # Don't want puppet getting the command line arguments for rake or autotest
 ARGV.clear
 
 require 'puppet'
 require 'mocha'
 gem 'rspec', '>=2.0.0'
 require 'rspec/expectations'
 
 # So everyone else doesn't have to include this base constant.
 module PuppetSpec
   FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
 end
 
 require 'pathname'
 require 'tmpdir'
 
 require 'puppet_spec/verbose'
 require 'puppet_spec/files'
 require 'puppet_spec/fixtures'
 require 'puppet_spec/matchers'
+require 'puppet_spec/database'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/publicize_methods'
 
 Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
   require behaviour.relative_path_from(Pathname.new(dir))
 end
 
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
   config.mock_with :mocha
 
   config.before :each do
     # Disabling garbage collection inside each test, and only running it at
     # the end of each block, gives us an ~ 15 percent speedup, and more on
     # some platforms *cough* windows *cough* that are a little slower.
     GC.disable
 
     # We need to preserve the current state of all our indirection cache and
     # terminus classes.  This is pretty important, because changes to these
     # are global and lead to order dependencies in our testing.
     #
     # We go direct to the implementation because there is no safe, sane public
     # API to manage restoration of these to their default values.  This
     # should, once the value is proved, be moved to a standard API on the
     # indirector.
     #
     # To make things worse, a number of the tests stub parts of the
     # indirector.  These stubs have very specific expectations that what
     # little of the public API we could use is, well, likely to explode
     # randomly in some tests.  So, direct access.  --daniel 2011-08-30
     $saved_indirection_state = {}
     indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
     indirections.each do |indirector|
       $saved_indirection_state[indirector.name] = {
         :@terminus_class => indirector.instance_variable_get(:@terminus_class),
         :@cache_class    => indirector.instance_variable_get(:@cache_class)
       }
     end
 
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
 
     # REVISIT: I think this conceals other bad tests, but I don't have time to
     # fully diagnose those right now.  When you read this, please come tell me
     # I suck for letting this float. --daniel 2011-04-21
     Signal.stubs(:trap)
 
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
     Puppet[:confdir] = "/dev/null"
     Puppet[:vardir] = "/dev/null"
 
     # Avoid opening ports to the outside world
     Puppet.settings[:bindaddress] = "127.0.0.1"
 
     @logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
 
     @log_level = Puppet::Util::Log.level
   end
 
   config.after :each do
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
     Puppet::Util::ExecutionStub.reset
 
     PuppetSpec::Files.cleanup
 
     @logs.clear
     Puppet::Util::Log.close_all
     Puppet::Util::Log.level = @log_level
 
     # Restore the indirector configuration.  See before hook.
     indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
     indirections.each do |indirector|
       $saved_indirection_state.fetch(indirector.name, {}).each do |variable, value|
         indirector.instance_variable_set(variable, value)
       end
     end
     $saved_indirection_state = nil
 
     # Some tests can cause us to connect, in which case the lingering
     # connection is a resource that can cause unexpected failure in later
     # tests, as well as sharing state accidentally.
     # We're testing if ActiveRecord::Base is defined because some test cases
     # may stub Puppet.features.rails? which is how we should normally
     # introspect for this functionality.
     ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
 
     # This will perform a GC between tests, but only if actually required.  We
     # experimented with forcing a GC run, and that was less efficient than
     # just letting it run all the time.
     GC.enable
   end
 end
diff --git a/spec/unit/indirector/catalog/active_record_spec.rb b/spec/unit/indirector/catalog/active_record_spec.rb
index d434f694c..242f30da8 100755
--- a/spec/unit/indirector/catalog/active_record_spec.rb
+++ b/spec/unit/indirector/catalog/active_record_spec.rb
@@ -1,146 +1,138 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-begin
-  require 'sqlite3'
-rescue LoadError
-  # this code deliberately left blank.
-end
 
-describe "Puppet::Resource::Catalog::ActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   require 'puppet/rails'
 
   before :each do
     require 'puppet/indirector/catalog/active_record'
-    Puppet[:dbadapter]  = 'sqlite3'
-    Puppet[:dblocation] = tmpdir('puppet-catalog-activerecord') + '/test.sqlite'
-    Puppet[:railslog]   = "/dev/null"
-    Puppet::Rails.init
+    setup_scratch_database
   end
 
   let :terminus do
     Puppet::Resource::Catalog::ActiveRecord.new
   end
 
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
 
   it "should use Puppet::Rails::Host as its ActiveRecord model" do
     Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
   end
 
   describe "when finding an instance" do
     let :request do
       stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
     end
 
     # This hack is here because we don't want to look in the db unless we actually want
     # to look in the db, but our indirection architecture in 0.24.x isn't flexible
     # enough to tune that via configuration.
     it "should return nil unless ':cache_integration_hack' is set to true" do
       request.options[:cache_integration_hack] = false
       Puppet::Rails::Host.expects(:find_by_name).never
       terminus.find(request).should be_nil
     end
 
     it "should use the Hosts ActiveRecord class to find the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
       terminus.find(request)
     end
 
     it "should return nil if no host instance can be found" do
       Puppet::Rails::Host.expects(:find_by_name).returns nil
 
       terminus.find(request).should be_nil
     end
 
     it "should return a catalog with the same name as the host if the host can be found" do
       host = stub 'host', :name => "foo", :resources => []
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       result = terminus.find(request)
       result.should be_instance_of(Puppet::Resource::Catalog)
       result.name.should == "foo"
     end
 
     it "should set each of the host's resources as a transportable resource within the catalog" do
       host = stub 'host', :name => "foo"
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       res1 = mock 'res1', :to_transportable => "trans_res1"
       res2 = mock 'res2', :to_transportable => "trans_res2"
 
       host.expects(:resources).returns [res1, res2]
 
       catalog = stub 'catalog'
       Puppet::Resource::Catalog.expects(:new).returns catalog
 
       catalog.expects(:add_resource).with "trans_res1"
       catalog.expects(:add_resource).with "trans_res2"
 
       terminus.find(request)
     end
   end
 
   describe "when saving an instance" do
     let :catalog do Puppet::Resource::Catalog.new("foo") end
     let :request do Puppet::Indirector::Request.new(:active_record, :save, catalog) end
     let :node do Puppet::Node.new("foo", :environment => "environment") end
 
     before :each do
       Puppet::Node.indirection.stubs(:find).with("foo").returns(node)
     end
 
     it "should find the Rails host with the same name" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo")
       terminus.save(request)
     end
 
     it "should create a new Rails host if none can be found" do
       Puppet::Rails::Host.find_by_name('foo').should be_nil
       terminus.save(request)
       Puppet::Rails::Host.find_by_name('foo').should be_valid
     end
 
     it "should set the catalog vertices as resources on the Rails host instance" do
       # We need to stub this so we get the same object, not just the same
       # content, otherwise the expect can't fire. :(
       host = Puppet::Rails::Host.create!(:name => "foo")
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
       catalog.expects(:vertices).returns("foo")
       host.expects(:merge_resources).with("foo")
 
       terminus.save(request)
     end
 
     it "should set host ip if we could find a matching node" do
       node.merge("ipaddress" => "192.168.0.1")
       terminus.save(request)
       Puppet::Rails::Host.find_by_name("foo").ip.should == '192.168.0.1'
     end
 
     it "should set host environment if we could find a matching node" do
       terminus.save(request)
       Puppet::Rails::Host.find_by_name("foo").environment.should == "environment"
     end
 
     it "should set the last compile time on the host" do
       now = Time.now
       Time.stubs(:now).returns now
 
       terminus.save(request)
       Puppet::Rails::Host.find_by_name("foo").last_compile.should == now
     end
 
     it "should save the Rails host instance" do
       host = Puppet::Rails::Host.create!(:name => "foo")
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
       host.expects(:save)
 
       terminus.save(request)
     end
   end
 end
diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
index b14262b5b..a79f53744 100755
--- a/spec/unit/indirector/facts/inventory_active_record_spec.rb
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -1,179 +1,166 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-require 'tempfile'
 require 'puppet/rails'
 
-describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+describe "Puppet::Node::Facts::InventoryActiveRecord", :if => can_use_scratch_database? do
+  include PuppetSpec::Files
+
   let(:terminus) { Puppet::Node::Facts::InventoryActiveRecord.new }
 
   before :all do
     require 'puppet/indirector/facts/inventory_active_record'
-    @dbfile = Tempfile.new("testdb")
-    @dbfile.close
   end
 
-  after :all do
+  after :each do
     Puppet::Node::Facts.indirection.reset_terminus_class
-    @dbfile.unlink
   end
 
   before :each do
     Puppet::Node.indirection.reset_terminus_class
     Puppet::Node.indirection.cache_class = nil
 
     Puppet::Node::Facts.indirection.terminus_class = :inventory_active_record
-    Puppet[:dbadapter]  = 'sqlite3'
-    Puppet[:dblocation] = @dbfile.path
-    Puppet[:railslog] = "/dev/null"
-    Puppet::Rails.init
-  end
-
-  after :each do
-    Puppet::Rails.teardown
+    setup_scratch_database
   end
 
   describe "#save" do
     let(:node) {
       Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
     }
 
     let(:facts) {
       Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
     }
 
     it "should retry on ActiveRecord error" do
       Puppet::Rails::InventoryNode.expects(:create).twice.raises(ActiveRecord::StatementInvalid).returns node
 
       Puppet::Node::Facts.indirection.save(facts)
     end
 
     it "should use an existing node if possible" do
       node.save
       Puppet::Node::Facts.indirection.save(facts)
 
       Puppet::Rails::InventoryNode.count.should == 1
       Puppet::Rails::InventoryNode.first.should == node
     end
 
     it "should create a new node if one can't be found" do
       # This test isn't valid if there are nodes to begin with
       Puppet::Rails::InventoryNode.count.should == 0
 
       Puppet::Node::Facts.indirection.save(facts)
 
       Puppet::Rails::InventoryNode.count.should == 1
       Puppet::Rails::InventoryNode.first.name.should == "foo"
     end
 
     it "should save the facts" do
       Puppet::Node::Facts.indirection.save(facts)
 
       Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]
     end
 
     it "should remove the previous facts for an existing node" do
       facts = Puppet::Node::Facts.new("foo", "uptime_days" => "30", "kernel" => "Darwin")
       Puppet::Node::Facts.indirection.save(facts)
       bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "35", "kernel" => "Linux")
       foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "is_virtual" => "false")
       Puppet::Node::Facts.indirection.save(bar_facts)
       Puppet::Node::Facts.indirection.save(foo_facts)
 
       Puppet::Node::Facts.indirection.find("bar").should == bar_facts
       Puppet::Node::Facts.indirection.find("foo").should == foo_facts
       Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should_not include(["uptime_days", "30"], ["kernel", "Darwin"])
     end
   end
 
   describe "#find" do
     before do
       @foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
       @bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "30", "kernel" => "Linux")
       Puppet::Node::Facts.indirection.save(@foo_facts)
       Puppet::Node::Facts.indirection.save(@bar_facts)
     end
 
     it "should identify facts by node name" do
       Puppet::Node::Facts.indirection.find("foo").should == @foo_facts
     end
 
     it "should return nil if no node instance can be found" do
       Puppet::Node::Facts.indirection.find("non-existent node").should == nil
     end
   end
 
   describe "#search" do
     def search_request(conditions)
       Puppet::Indirector::Request.new(:facts, :search, nil, conditions)
     end
 
     before :each do
       @now = Time.now
       @foo = Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "uptime_days" => "30")
       @bar = Puppet::Node::Facts.new("bar", "fact1" => "value1", "uptime_days" => "60")
       @baz = Puppet::Node::Facts.new("baz", "fact1" => "value2", "fact2" => "value1", "uptime_days" => "90")
       @bat = Puppet::Node::Facts.new("bat")
       @foo.timestamp = @now - 3600*1
       @bar.timestamp = @now - 3600*3
       @baz.timestamp = @now - 3600*5
       @bat.timestamp = @now - 3600*7
       [@foo, @bar, @baz, @bat].each {|facts| Puppet::Node::Facts.indirection.save(facts)}
     end
 
     it "should return node names that match 'equal' constraints" do
       request = search_request('facts.fact1.eq' => 'value1',
                                'facts.fact2.eq' => 'value2')
       terminus.search(request).should == ["foo"]
     end
 
     it "should return node names that match 'not equal' constraints" do
       request = search_request('facts.fact1.ne' => 'value2')
       terminus.search(request).should == ["bar","foo"]
     end
 
     it "should return node names that match strict inequality constraints" do
       request = search_request('facts.uptime_days.gt' => '20',
                                'facts.uptime_days.lt' => '70')
       terminus.search(request).should == ["bar","foo"]
     end
 
     it "should return node names that match non-strict inequality constraints" do
       request = search_request('facts.uptime_days.ge' => '30',
                                'facts.uptime_days.le' => '60')
       terminus.search(request).should == ["bar","foo"]
     end
 
     it "should return node names whose facts are within a given timeframe" do
       request = search_request('meta.timestamp.ge' => @now - 3600*5,
                                'meta.timestamp.le' => @now - 3600*1)
       terminus.search(request).should == ["bar","baz","foo"]
     end
 
     it "should return node names whose facts are from a specific time" do
       request = search_request('meta.timestamp.eq' => @now - 3600*3)
       terminus.search(request).should == ["bar"]
     end
 
     it "should return node names whose facts are not from a specific time" do
       request = search_request('meta.timestamp.ne' => @now - 3600*1)
       terminus.search(request).should == ["bar","bat","baz"]
     end
 
     it "should perform strict searches on nodes by timestamp" do
       request = search_request('meta.timestamp.gt' => @now - 3600*5,
                                'meta.timestamp.lt' => @now - 3600*1)
       terminus.search(request).should == ["bar"]
     end
 
     it "should search nodes based on both facts and timestamp values" do
       request = search_request('facts.uptime_days.gt' => '45',
                                'meta.timestamp.lt'    => @now - 3600*4)
       terminus.search(request).should == ["baz"]
     end
   end
 end
 
diff --git a/spec/unit/indirector/resource/active_record_spec.rb b/spec/unit/indirector/resource/active_record_spec.rb
index 4c009767d..e9ccea30f 100755
--- a/spec/unit/indirector/resource/active_record_spec.rb
+++ b/spec/unit/indirector/resource/active_record_spec.rb
@@ -1,187 +1,178 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-
 require 'puppet/rails'
 require 'puppet/node/facts'
 
-describe "Puppet::Resource::ActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+describe "Puppet::Resource::ActiveRecord", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   before :each do
-    dir = Pathname(tmpdir('puppet-var'))
-    Puppet[:vardir]       = dir.to_s
-    Puppet[:dbadapter]    = 'sqlite3'
-    Puppet[:dblocation]   = (dir + 'storeconfigs.sqlite').to_s
+    setup_scratch_database
     Puppet[:storeconfigs] = true
   end
 
   subject {
     require 'puppet/indirector/resource/active_record'
     Puppet::Resource.indirection.terminus(:active_record)
   }
 
   it "should automatically initialize Rails" do
     # Other tests in the suite may have established the connection, which will
     # linger; the assertion is just to enforce our assumption about the call,
     # not because I *really* want to test ActiveRecord works.  Better to have
     # an early failure than wonder why the test overall doesn't DTRT.
     ActiveRecord::Base.remove_connection
     ActiveRecord::Base.should_not be_connected
     subject.should be
     ActiveRecord::Base.should be_connected
   end
 
   describe "#search" do
     before :each do Puppet::Rails.init end
 
     def search(type, host = 'default.local', filter = nil)
       args = { :host => host, :filter => filter }
       subject.search(Puppet::Resource.indirection.request(:search, type, args))
     end
 
     it "should return an empty array if no resources match" do
       search("Exec").should == []
     end
 
     # Assert that this is a case-insensitive rule, too.
     %w{and or AND OR And Or anD oR}.each do |op|
       it "should fail if asked to search with #{op.inspect}" do
         filter = [%w{tag == foo}, op, %w{title == bar}]
         expect { search("Notify", 'localhost', filter) }.
           to raise_error Puppet::Error, /not supported/
       end
     end
 
     context "with a matching resource" do
       before :each do
         host = Puppet::Rails::Host.create!(:name => 'one.local')
         Puppet::Rails::Resource.
           create!(:host     => host,
                   :restype  => 'Exec', :title => 'whammo',
                   :exported => true)
 
       end
 
       it "should return something responding to `to_resource` if a resource matches" do
         found = search("Exec")
         found.length.should == 1
         found.map do |item|
           item.should respond_to :to_resource
           item.restype.should == "Exec"
         end
       end
 
       it "should not filter resources that have been found before" do
         search("Exec").should == search("Exec")
       end
     end
   end
 
   describe "#build_active_record_query" do
     before :each do
       Puppet::Rails.init
     end
 
     let :type do 'Notify' end
 
     def query(type, host, filter = nil)
       subject.send :build_active_record_query, type, host, filter
     end
 
     it "should exclude all database resources from the host" do
       host = Puppet::Rails::Host.create! :name => 'one.local'
       got = query(type, host.name)
       got.keys.should =~ [:conditions]
       got[:conditions][0] =~ /\(host_id != \?\)/
       got[:conditions].last.should == host.id
     end
 
     it "should join appropriately when filtering on parameters" do
       filter = %w{propname == propval}
       got = query(type, 'whatever', filter)
       got.keys.should =~ [:conditions, :joins]
       got[:joins].should == { :param_values => :param_name }
       got[:conditions][0].should =~ /param_names\.name = \?/
       got[:conditions][0].should =~ /param_values\.value = \?/
       got[:conditions].should be_include filter.first
       got[:conditions].should be_include filter.last
     end
 
     it "should join appropriately when filtering on tags" do
       filter = %w{tag == test}
       got = query(type, 'whatever', filter)
       got.keys.should =~ [:conditions, :joins]
       got[:joins].should == {:resource_tags => :puppet_tag}
       got[:conditions].first.should =~ /puppet_tags/
       got[:conditions].should_not be_include filter.first
       got[:conditions].should be_include filter.last
     end
 
     it "should only search for exported resources with the matching type" do
       got = query(type, 'whatever')
       got.keys.should =~ [:conditions]
       got[:conditions][0].should be_include "(exported=? AND restype=?)"
       got[:conditions][1].should == true
       got[:conditions][2].should == type.to_s.capitalize
     end
 
     it "should capitalize the type, since PGSQL is case sensitive" do
       got = query(type, 'whatever')
       got[:conditions][2].should == 'Notify'
     end
   end
 
   describe "#filter_to_active_record" do
     def filter_to_active_record(input)
       subject.send :filter_to_active_record, input
     end
 
     [nil, '', 'whatever', 12].each do |input|
       it "should fail if filter is not an array (with #{input.inspect})" do
         expect { filter_to_active_record(input) }.
           to raise_error ArgumentError, /must be arrays/
       end
     end
 
     # Not exhaustive, just indicative.
     ['=', '<>', '=~', '+', '-', '!'].each do |input|
       it "should fail with unexpected comparison operators (with #{input.inspect})" do
         expect { filter_to_active_record(["one", input, "two"]) }.
           to raise_error ArgumentError, /unknown operator/
       end
     end
 
     {
       ["title", "==", "whatever"] => ["title = ?", ["whatever"]],
       ["title", "!=", "whatever"] => ["title != ?", ["whatever"]],
 
       # Technically, these are not supported by Puppet yet, but as we pay
       # approximately zero cost other than a few minutes writing the tests,
       # and it would be *harder* to fail on them, nested queries.
       [["title", "==", "foo"], "or", ["title", "==", "bar"]] =>
         ["(title = ?) OR (title = ?)", ["foo", "bar"]],
 
       [["title", "==", "foo"], "or", ["tag", "==", "bar"]] =>
         ["(title = ?) OR (puppet_tags.name = ?)", ["foo", "bar"]],
 
       [["title", "==", "foo"], "or", ["param", "==", "bar"]] =>
         ["(title = ?) OR (param_names.name = ? AND param_values.value = ?)",
          ["foo", "param", "bar"]],
 
       [[["title","==","foo"],"or",["tag", "==", "bar"]],"and",["param","!=","baz"]] =>
       ["((title = ?) OR (puppet_tags.name = ?)) AND "+
        "(param_names.name = ? AND param_values.value != ?)",
        ["foo", "bar", "param", "baz"]]
 
     }.each do |input, expect|
       it "should map #{input.inspect} to #{expect.inspect}" do
         filter_to_active_record(input).should == expect
       end
     end
   end
 end
diff --git a/spec/unit/parser/collector_spec.rb b/spec/unit/parser/collector_spec.rb
index 79a6a17b9..251fec78a 100755
--- a/spec/unit/parser/collector_spec.rb
+++ b/spec/unit/parser/collector_spec.rb
@@ -1,447 +1,437 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-
 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? and defined? SQLite3) do
+describe Puppet::Parser::Collector, "when collecting exported resources", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   before do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
     @resource_type = "notify"
     @equery = ["title", "!=", ""]
     @vquery = proc { |r| true }
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type,
                                                @equery, @vquery, :exported)
   end
 
   it "should just return false if :storeconfigs is not enabled" do
     Puppet[:storeconfigs] = false
     @collector.evaluate.should be_false
   end
 
   context "with storeconfigs enabled" do
     before :each do
-      dir = Pathname(tmpdir('puppet-var'))
-      Puppet[:vardir]       = dir.to_s
-      Puppet[:dbadapter]    = 'sqlite3'
-      Puppet[:dblocation]   = (dir + 'storeconfigs.sqlite').to_s
+      setup_scratch_database
       Puppet[:storeconfigs] = true
       Puppet[:environment]  = "production"
       Puppet[:storeconfigs_backend] = "active_record"
-      Puppet::Rails.init
     end
 
     it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
       one = Puppet::Parser::Resource.new('notify', 'one',
                                          :virtual  => true,
                                          :exported => true,
                                          :scope    => @scope)
       two = Puppet::Parser::Resource.new('notify', 'two',
                                          :virtual  => true,
                                          :exported => true,
                                          :scope    => @scope)
 
       @compiler.resources << one
       @compiler.resources << two
 
       @collector.evaluate.should == [one, two]
       one.should_not be_virtual
       two.should_not be_virtual
 
       # REVISIT: Apparently we never actually marked local resources as
       # non-exported.  So, this is what the previous test asserted, and checking
       # what it claims to do causes test failures. --daniel 2011-08-23
     end
 
     it "should mark all returned resources as not virtual" do
       one = Puppet::Parser::Resource.new('notify', 'one',
                                          :virtual  => true,
                                          :exported => true,
                                          :scope    => @scope)
 
       @compiler.resources << one
 
       @collector.evaluate.should == [one]
       one.should_not be_virtual
     end
 
     it "should convert all found resources into parser resources if necessary" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       result = @collector.evaluate
       result.length.should == 1
       result.first.should be_an_instance_of Puppet::Parser::Resource
       result.first.type.should == 'Notify'
       result.first.title.should == 'whammo'
     end
 
     it "should leave parser resources alone" do
       resource = Puppet::Parser::Resource.new(:file, "/tmp/foo", :scope => @scope)
       resource2 = Puppet::Parser::Resource.new(:file, "/tmp/bar", :scope => @scope)
       resource.expects(:to_resource).never
       resource2.expects(:to_resource).never
 
       resources = [resource, resource2]
 
       Puppet::Resource.indirection.stubs(:search).returns resources
 
       @collector.evaluate.should == resources
     end
 
     it "should override all exported collected resources if collector has an override" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       param = Puppet::Parser::Resource::Param.
         new(:name => 'message', :value => 'howdy')
       @collector.add_override(:parameters => [param], :scope => @scope)
 
       got = @collector.evaluate
       got.first[:message].should == param.value
     end
 
     it "should store converted resources in the compile's resource list" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       @compiler.expects(:add_resource).with do |scope, resource|
         scope.should be_an_instance_of Puppet::Parser::Scope
         resource.type.should  == 'Notify'
         resource.title.should == 'whammo'
         true
       end
 
       @collector.evaluate
     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
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       got = @collector.evaluate
       got.length.should == 1
       got.first.type.should == "Notify"
       got.first.title.should == "whammo"
       got.first.should_not be_exported
     end
 
     it "should fail if an equivalent resource already exists in the compile" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       local = Puppet::Parser::Resource.new('notify', 'whammo', :scope => @scope)
       @compiler.add_resource(@scope, local)
 
       expect { @collector.evaluate }.
         to raise_error Puppet::ParseError, /exists with the type and title/
     end
 
     it "should ignore exported resources that match already-collected resources" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       # One that we already collected...
       db = Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
       # ...and one we didn't.
       Puppet::Rails::Resource.
         create!(:host     => host,
                 :restype  => 'Notify', :title => 'boingy-boingy',
                 :exported => true)
 
       local = Puppet::Parser::Resource.new('notify', 'whammo',
                                            :scope        => @scope,
                                            :collector_id => db.id)
       @compiler.add_resource(@scope, local)
 
       got = nil
       expect { got = @collector.evaluate }.not_to raise_error(Puppet::ParseError)
       got.length.should == 1
       got.first.type.should == "Notify"
       got.first.title.should == "boingy-boingy"
     end
   end
 end