diff --git a/spec/unit/rails/host_spec.rb b/spec/unit/rails/host_spec.rb
index 98541c0a8..f82dfda05 100755
--- a/spec/unit/rails/host_spec.rb
+++ b/spec/unit/rails/host_spec.rb
@@ -1,168 +1,162 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/node/environment'
 
-describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
-  def column(name, type)
-    ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
-  end
-
+describe "Puppet::Rails::Host", :if => can_use_scratch_database? do
   before do
     require 'puppet/rails/host'
-
-    # Stub this so we don't need access to the DB.
-    Puppet::Rails::Host.stubs(:columns).returns([column("name", "string"), column("environment", "string"), column("ip", "string")])
+    setup_scratch_database
 
     @node = Puppet::Node.new("foo")
     @node.environment = "production"
     @node.ipaddress = "127.0.0.1"
 
     @host = stub 'host', :environment= => nil, :ip= => nil
   end
 
   describe "when converting a Puppet::Node instance into a Rails instance" do
     it "should modify any existing instance in the database" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should create a new instance in the database if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
       Puppet::Rails::Host.expects(:new).with(:name => "foo").returns @host
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should copy the environment from the Puppet instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @node.environment = "production"
       @host.expects(:environment=).with {|x| x.name.to_s == 'production' }
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should stringify the environment" do
       host = Puppet::Rails::Host.new
       host.environment = Puppet::Node::Environment.new("production")
       host.environment.class.should == String
     end
 
     it "should copy the ipaddress from the Puppet instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @node.ipaddress = "192.168.0.1"
       @host.expects(:ip=).with "192.168.0.1"
 
       Puppet::Rails::Host.from_puppet(@node)
     end
 
     it "should not save the Rails instance" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @host.expects(:save).never
 
       Puppet::Rails::Host.from_puppet(@node)
     end
   end
 
   describe "when converting a Puppet::Rails::Host instance into a Puppet::Node instance" do
     before do
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @node = Puppet::Node.new("foo")
       Puppet::Node.stubs(:new).with("foo").returns @node
     end
 
     it "should create a new instance with the correct name" do
       Puppet::Node.expects(:new).with("foo").returns @node
 
       @host.to_puppet
     end
 
     it "should copy the environment from the Rails instance" do
       @host.environment = "prod"
       @node.expects(:environment=).with "prod"
       @host.to_puppet
     end
 
     it "should copy the ipaddress from the Rails instance" do
       @host.ip = "192.168.0.1"
       @node.expects(:ipaddress=).with "192.168.0.1"
       @host.to_puppet
     end
   end
 
   describe "when merging catalog resources and database resources" do
     before :each do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
+      Puppet[:thin_storeconfigs] = false
       @resource1 = stub_everything 'res1'
       @resource2 = stub_everything 'res2'
       @resources = [ @resource1, @resource2 ]
 
       @dbresource1 = stub_everything 'dbres1'
       @dbresource2 = stub_everything 'dbres2'
       @dbresources = { 1 => @dbresource1, 2 => @dbresource2 }
 
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @host.stubs(:find_resources).returns(@dbresources)
       @host.stubs(:find_resources_parameters_tags)
       @host.stubs(:compare_to_catalog)
       @host.stubs(:id).returns(1)
     end
 
     it "should find all database resources" do
       @host.expects(:find_resources)
 
       @host.merge_resources(@resources)
     end
 
     it "should find all paramaters and tags for those database resources" do
       @host.expects(:find_resources_parameters_tags).with(@dbresources)
 
       @host.merge_resources(@resources)
     end
 
     it "should compare all database resources to catalog" do
       @host.expects(:compare_to_catalog).with(@dbresources, @resources)
 
       @host.merge_resources(@resources)
     end
 
     it "should compare only exported resources in thin_storeconfigs mode" do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
+      Puppet[:thin_storeconfigs] = true
       @resource1.stubs(:exported?).returns(true)
 
       @host.expects(:compare_to_catalog).with(@dbresources, [ @resource1 ])
 
       @host.merge_resources(@resources)
     end
   end
 
   describe "when searching the database for host resources" do
     before :each do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
+      Puppet[:thin_storeconfigs] = false
       @resource1 = stub_everything 'res1', :id => 1
       @resource2 = stub_everything 'res2', :id => 2
       @resources = [ @resource1, @resource2 ]
 
       @dbresources = stub 'resources'
       @dbresources.stubs(:find).returns(@resources)
 
       @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
       @host.stubs(:resources).returns(@dbresources)
     end
 
     it "should return a hash keyed by id of all resources" do
       @host.find_resources.should == { 1 => @resource1, 2 => @resource2 }
     end
 
     it "should return a hash keyed by id of only exported resources in thin_storeconfigs mode" do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
+      Puppet[:thin_storeconfigs] = true
       @dbresources.expects(:find).with { |*h| h[1][:conditions] == { :exported => true } }.returns([])
 
       @host.find_resources
     end
   end
 end
diff --git a/spec/unit/rails/param_value_spec.rb b/spec/unit/rails/param_value_spec.rb
index 7f0086252..e7f4328b1 100755
--- a/spec/unit/rails/param_value_spec.rb
+++ b/spec/unit/rails/param_value_spec.rb
@@ -1,47 +1,42 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/rails'
 
-describe "Puppet::Rails::ParamValue", :if => Puppet.features.rails? do
-  def column(name, type)
-    ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
-  end
-
+describe "Puppet::Rails::ParamValue", :if => can_use_scratch_database? do
   before do
     require 'puppet/rails/param_value'
-
-    name = stub 'param_name', :name => "foo"
+    setup_scratch_database
 
     # Stub this so we don't need access to the DB.
-    Puppet::Rails::ParamValue.stubs(:columns).returns([column("value", "string")])
+    name = stub 'param_name', :name => "foo"
     Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(name)
   end
 
   describe "when creating initial parameter values" do
     it "should return an array of hashes" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, %w{a b})[0].should be_instance_of(Hash)
     end
 
     it "should return hashes for each value with the parameter name set as the ParamName instance" do
       name = stub 'param_name', :name => "foo"
       Puppet::Rails::ParamName.expects(:find_or_create_by_name).returns(name)
 
       result = Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0]
       result[:value].should == "a"
       result[:param_name].should == name
     end
 
     it "should return an array of hashes even when only one parameter is provided" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0].should be_instance_of(Hash)
     end
 
     it "should convert all arguments into strings" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, 50)[0][:value].should == "50"
     end
 
     it "should not convert Resource References into strings" do
       ref = Puppet::Resource.new(:file, "/file")
       Puppet::Rails::ParamValue.from_parser_param(:myparam, ref)[0][:value].should == ref
     end
   end
 end
diff --git a/spec/unit/rails/resource_spec.rb b/spec/unit/rails/resource_spec.rb
index 22e5267f4..4202df4e2 100755
--- a/spec/unit/rails/resource_spec.rb
+++ b/spec/unit/rails/resource_spec.rb
@@ -1,121 +1,115 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/rails'
 
-describe "Puppet::Rails::Resource", :if => Puppet.features.rails? do
-  def column(name, type)
-    ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
-  end
-
+describe "Puppet::Rails::Resource", :if => can_use_scratch_database? do
   before do
     require 'puppet/rails/resource'
-
-    # Stub this so we don't need access to the DB.
-    Puppet::Rails::Resource.stubs(:columns).returns([column("title", "string"), column("restype", "string"), column("exported", "boolean")])
+    setup_scratch_database
   end
 
   describe "when creating initial resource arguments" do
     it "should set the restype to the resource's type" do
       Puppet::Rails::Resource.rails_resource_initial_args(Puppet::Resource.new(:file, "/file"))[:restype].should == "File"
     end
 
     it "should set the title to the resource's title" do
       Puppet::Rails::Resource.rails_resource_initial_args(Puppet::Resource.new(:file, "/file"))[:title].should == "/file"
     end
 
     it "should set the line to the resource's line if one is available" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.line = 50
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:line].should == 50
     end
 
     it "should set 'exported' to true of the resource is exported" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = true
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_true
     end
 
     it "should set 'exported' to false of the resource is not exported" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = false
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_false
 
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = nil
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_false
     end
   end
 
   describe "when merging in a parser resource" do
     before do
       @parser = mock 'parser resource'
 
       @resource = Puppet::Rails::Resource.new
       [:merge_attributes, :merge_parameters, :merge_tags, :save].each { |m| @resource.stubs(m) }
     end
 
     it "should merge the attributes" do
       @resource.expects(:merge_attributes).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should merge the parameters" do
       @resource.expects(:merge_parameters).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should merge the tags" do
       @resource.expects(:merge_tags).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should save itself" do
       @resource.expects(:save)
 
       @resource.merge_parser_resource(@parser)
     end
   end
 
   describe "merge_parameters" do
     it "should replace values that have changed" do
       @resource = Puppet::Rails::Resource.new
       @resource.params_list = [{"name" => "replace", "value" => 1, "id" => 100 }]
 
       Puppet::Rails::ParamValue.expects(:delete).with([100])
       param_values = stub "param_values"
       param_values.expects(:build).with({:value=>nil, :param_name=>nil, :line=>{"replace"=>2}})
       @resource.stubs(:param_values).returns(param_values)
 
       Puppet::Rails::ParamName.stubs(:accumulate_by_name)
 
       merge_resource = stub "merge_resource"
       merge_resource.expects(:line).returns({ "replace" => 2 })
       merge_resource.stubs(:each).yields([["replace", 2]])
 
       @resource.merge_parameters(merge_resource)
     end
   end
 
   describe "#to_resource" do
     it "should instantiate a Puppet::Parser::Resource" do
       scope = stub "scope", :source => nil, :environment => nil, :namespaces => nil
 
       @resource = Puppet::Rails::Resource.new
       @resource.stubs(:attributes).returns({
         "restype" => 'notify',
         "title"   => 'hello'
       })
       @resource.stubs(:param_names).returns([])
 
       @resource.to_resource(scope).should be_a(Puppet::Parser::Resource)
 
     end
   end
 end