diff --git a/spec/integration/parser/ruby_manifest_spec.rb b/spec/integration/parser/ruby_manifest_spec.rb
index af110d3b3..de6f4628c 100644
--- a/spec/integration/parser/ruby_manifest_spec.rb
+++ b/spec/integration/parser/ruby_manifest_spec.rb
@@ -1,128 +1,128 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'tempfile'
 require 'puppet_spec/files'
 
 describe "Pure ruby manifests" do
   include PuppetSpec::Files
 
   before do
     @node = Puppet::Node.new "testnode"
 
     @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
     @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
     @test_dir = tmpdir('ruby_manifest_test')
   end
 
   after do
     Puppet.settings.clear
   end
 
   def write_file(name, contents)
     path = File.join(@test_dir, name)
     File.open(path, "w") { |f| f.write(contents) }
     path
   end
 
   def compile(contents)
     Puppet[:code] = contents
     Dir.chdir(@test_dir) do
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
     end
   end
 
   it "should allow classes" do
     write_file('foo.rb', ["hostclass 'one' do notify('one_notify') end",
                           "hostclass 'two' do notify('two_notify') end"].join("\n"))
     catalog = compile("import 'foo'\ninclude one")
     catalog.resource("Notify[one_notify]").should_not be_nil
     catalog.resource("Notify[two_notify]").should be_nil
   end
 
   it "should allow defines" do
     write_file('foo.rb', 'define "bar", :arg do notify("bar_#{@name}_#{@arg}") end')
     catalog = compile("import 'foo'\nbar { instance: arg => 'xyz' }")
     catalog.resource("Notify[bar_instance_xyz]").should_not be_nil
     catalog.resource("Bar[instance]").should_not be_nil
   end
 
   it "should allow node declarations" do
     write_file('foo.rb', "node 'mynode' do notify('mynode') end")
     catalog = compile("import 'foo'")
     node_declaration = catalog.resource("Notify[mynode]")
     node_declaration.should_not be_nil
     node_declaration.title.should == 'mynode'
   end
 
   it "should allow access to the environment" do
     write_file('foo.rb', ["hostclass 'bar' do",
                           "  if environment.is_a? Puppet::Node::Environment",
                           "    notify('success')",
                           "  end",
                           "end"].join("\n"))
     compile("import 'foo'\ninclude bar").resource("Notify[success]").should_not be_nil
   end
 
   it "should allow creation of resources of built-in types" do
     write_file('foo.rb', "hostclass 'bar' do file 'test_file', :owner => 'root', :mode => '644' end")
     catalog = compile("import 'foo'\ninclude bar")
     file = catalog.resource("File[test_file]")
-    file.should be_a Puppet::Resource
+    file.should be_a(Puppet::Resource)
     file.type.should == 'File'
     file.title.should == 'test_file'
     file.exported.should_not be
     file.virtual.should_not be
     file[:owner].should == 'root'
     file[:mode].should == '644'
     file[:stage].should be_nil # TODO: is this correct behavior?
   end
 
   it "should allow calling user-defined functions" do
     write_file('foo.rb', "hostclass 'bar' do user_func 'name', :arg => 'xyz' end")
     catalog = compile(['define user_func($arg) { notify {"n_$arg": } }',
                        'import "foo"',
                        'include bar'].join("\n"))
     catalog.resource("Notify[n_xyz]").should_not be_nil
     catalog.resource("User_func[name]").should_not be_nil
   end
 
   it "should be properly cached for multiple compiles" do
     # Note: we can't test this by calling compile() twice, because
     # that sets Puppet[:code], which clears out all cached
     # environments.
     Puppet[:filetimeout] = 1000
     write_file('foo.rb', "hostclass 'bar' do notify('success') end")
     Puppet[:code] = "import 'foo'\ninclude bar"
 
     # Compile the catalog and check it
     catalog = Dir.chdir(@test_dir) do
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
     end
     catalog.resource("Notify[success]").should_not be_nil
 
     # Secretly change the file to make it invalid.  This change
     # shouldn't be noticed because the we've set a high
     # Puppet[:filetimeout].
     write_file('foo.rb', "raise 'should not be executed'")
 
     # Compile the catalog a second time and make sure it's still ok.
     catalog = Dir.chdir(@test_dir) do
       Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
     end
     catalog.resource("Notify[success]").should_not be_nil
   end
 
   it "should be properly reloaded when stale" do
     Puppet[:filetimeout] = -1 # force stale check to happen all the time
     write_file('foo.rb', "hostclass 'bar' do notify('version1') end")
     catalog = compile("import 'foo'\ninclude bar")
     catalog.resource("Notify[version1]").should_not be_nil
     sleep 1 # so that timestamp will change forcing file reload
     write_file('foo.rb', "hostclass 'bar' do notify('version2') end")
     catalog = compile("import 'foo'\ninclude bar")
     catalog.resource("Notify[version1]").should be_nil
     catalog.resource("Notify[version2]").should_not be_nil
   end
 end
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index 85098f490..877c47bcc 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -1,405 +1,405 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
 
 describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
     it "should declare handle_#{option} method" do
       @apply.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @apply.options.expects(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   it "should set the code to the provided code when :execute is used" do
     @apply.options.expects(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @apply.should_parse_config?.should be_true
   end
 
   describe "when applying options" do
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @apply.handle_logdest("console")
     end
 
     it "should put the logset options to true" do
       @apply.options.expects(:[]=).with(:logset,true)
 
       @apply.handle_logdest("console")
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:trap)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
 
       @apply.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set show_diff on --noop" do
       Puppet.stubs(:[]=)
       Puppet.stubs(:[]).with(:config)
       Puppet.stubs(:[]).with(:noop).returns(true)
 
       Puppet.expects(:[]=).with(:show_diff, true)
 
       @apply.setup
     end
 
     it "should set console as the log destination if logdest option wasn't provided" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @apply.setup
     end
 
     it "should set INT trap" do
       @apply.expects(:trap).with(:INT)
 
       @apply.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
 
       Puppet::Log.expects(:level=).with(:debug)
 
       @apply.setup
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
 
       Puppet::Log.expects(:level=).with(:info)
 
       @apply.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @apply.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @apply.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @apply.setup }.should raise_error(SystemExit)
     end
 
   end
 
   describe "when executing" do
 
     it "should dispatch to parseonly if parseonly is set" do
       @apply.stubs(:options).returns({})
       Puppet.stubs(:[]).with(:parseonly).returns(true)
 
       @apply.expects(:parseonly)
       @apply.run_command
     end
 
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
       @apply.expects(:apply)
       @apply.run_command
     end
 
     it "should dispatch to main if parseonly is not set" do
       @apply.stubs(:options).returns({})
       Puppet.stubs(:[]).with(:parseonly).returns(false)
 
       @apply.expects(:main)
       @apply.run_command
     end
 
     describe "the parseonly command" do
       before :each do
         Puppet.stubs(:[]).with(:environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @apply.stubs(:exit)
         @apply.options.stubs(:[]).with(:code).returns "some code"
         @collection = stub_everything
         Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
       end
 
       it "should use a Puppet Resource Type Collection to parse the file" do
         @collection.expects(:perform_initial_import)
         @apply.parseonly
       end
 
       it "should exit with exit code 0 if no error" do
         @apply.expects(:exit).with(0)
         @apply.parseonly
       end
 
       it "should exit with exit code 1 if error" do
         @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
     end
 
     describe "the main command" do
       before :each do
         Puppet.stubs(:[])
         Puppet.settings.stubs(:use)
         Puppet.stubs(:[]).with(:prerun_command).returns ""
         Puppet.stubs(:[]).with(:postrun_command).returns ""
         Puppet.stubs(:[]).with(:trace).returns(true)
 
         @apply.options.stubs(:[])
 
         @facts = stub_everything 'facts'
         Puppet::Node::Facts.stubs(:find).returns(@facts)
 
         @node = stub_everything 'node'
         Puppet::Node.stubs(:find).returns(@node)
 
         @catalog = stub_everything 'catalog'
         @catalog.stubs(:to_ral).returns(@catalog)
         Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
         @transaction = stub_everything 'transaction'
         @catalog.stubs(:apply).returns(@transaction)
 
         @apply.stubs(:exit)
       end
 
       it "should set the code to run from --code" do
         @apply.options.stubs(:[]).with(:code).returns("code to run")
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the code to run from STDIN if no arguments" do
         @apply.command_line.stubs(:args).returns([])
         STDIN.stubs(:read).returns("code to run")
 
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
         File.stubs(:exist?).with('site.pp').returns true
         @apply.command_line.stubs(:args).returns(['site.pp'])
 
         Puppet.expects(:[]=).with(:manifest,"site.pp")
 
         @apply.main
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         File.stubs(:exist?).with('noexist.pp').returns false
         @apply.command_line.stubs(:args).returns(['noexist.pp'])
         lambda { @apply.main }.should raise_error(RuntimeError, 'Could not find file noexist.pp')
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         File.stubs(:exist?).with('starwarsIV').returns true
         File.expects(:exist?).with('starwarsI').never
         @apply.command_line.stubs(:args).returns(['starwarsIV', 'starwarsI', 'starwarsII'])
 
         Puppet.expects(:[]=).with(:manifest,"starwarsIV")
         Puppet.expects(:warning).with('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
 
         @apply.main
       end
 
       it "should collect the node facts" do
         Puppet::Node::Facts.expects(:find).returns(@facts)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node::Facts.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should look for the node" do
         Puppet::Node.expects(:find).returns(@node)
 
         @apply.main
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should merge in our node the loaded facts" do
         @facts.stubs(:values).returns("values")
 
         @node.expects(:merge).with("values")
 
         @apply.main
       end
 
       it "should load custom classes if loadclasses" do
         @apply.options.stubs(:[]).with(:loadclasses).returns(true)
         Puppet.stubs(:[]).with(:classfile).returns("/etc/puppet/classes.txt")
         FileTest.stubs(:exists?).with("/etc/puppet/classes.txt").returns(true)
         FileTest.stubs(:readable?).with("/etc/puppet/classes.txt").returns(true)
         File.stubs(:read).with("/etc/puppet/classes.txt").returns("class")
 
         @node.expects(:classes=)
 
         @apply.main
       end
 
       it "should compile the catalog" do
         Puppet::Resource::Catalog.expects(:find).returns(@catalog)
 
         @apply.main
       end
 
       it "should transform the catalog to ral" do
 
         @catalog.expects(:to_ral).returns(@catalog)
 
         @apply.main
       end
 
       it "should finalize the catalog" do
         @catalog.expects(:finalize)
 
         @apply.main
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         configurer = stub 'configurer'
 
         Puppet::Configurer.expects(:new).returns configurer
         configurer.expects(:execute_prerun_command)
         configurer.expects(:execute_postrun_command)
 
         @apply.main
       end
 
       it "should apply the catalog" do
-        @catalog.expects(:apply).returns(stub_everything 'transaction')
+        @catalog.expects(:apply).returns(stub_everything('transaction'))
 
         @apply.main
       end
 
       describe "with detailed_exitcodes" do
         it "should exit with report's computed exit status" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(666)
 
           @apply.main
         end
 
         it "should always exit with 0 if option is disabled" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
 
         it "should always exit with 0 if --noop" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
 
           @apply.main
         end
       end
     end
 
     describe "the 'apply' command" do
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.expects(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
         $stdin.expects(:read).returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
         Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'something').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should fail helpfully if deserializing fails" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something syntacically invalid"
         lambda { @apply.apply }.should raise_error(Puppet::Error)
       end
 
       it "should convert plain data structures into a catalog if deserialization does not do so" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,"something").returns({:foo => "bar"})
         Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
         @apply.apply
       end
 
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = "/my/catalog.pson"
         File.stubs(:read).with("/my/catalog.pson").returns "something"
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns catalog
         catalog.expects(:to_ral).returns "mycatalog"
 
         configurer = stub 'configurer'
         Puppet::Configurer.expects(:new).returns configurer
         configurer.expects(:run).with(:catalog => "mycatalog")
 
         @apply.apply
       end
     end
   end
 end
diff --git a/spec/unit/parser/ast/leaf_spec.rb b/spec/unit/parser/ast/leaf_spec.rb
index 384ee08eb..a19c24115 100755
--- a/spec/unit/parser/ast/leaf_spec.rb
+++ b/spec/unit/parser/ast/leaf_spec.rb
@@ -1,408 +1,408 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Leaf do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value'
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
   it "should have a evaluate_match method" do
     Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
   end
 
   describe "when converting to string" do
     it "should transform its value to string" do
       value = stub 'value', :is_a? => true
       value.expects(:to_s)
       Puppet::Parser::AST::Leaf.new( :value => value ).to_s
     end
   end
 
   it "should have a match method" do
     @leaf.should respond_to(:match)
   end
 
   it "should delegate match to ==" do
     @value.expects(:==).with("value")
 
     @leaf.match("value")
   end
 end
 
 describe Puppet::Parser::AST::FlatString do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::FlatString.new( :value => value ).to_s.should == "\"ab\""
     end
   end
 end
 
 describe Puppet::Parser::AST::String do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::String.new( :value => value ).to_s.should == "\"ab\""
     end
     it "should return a dup of its value" do
       value = ""
-      Puppet::Parser::AST::String.new( :value => value ).evaluate(stub 'scope').should_not be_equal(value)
+      Puppet::Parser::AST::String.new( :value => value ).evaluate(stub('scope')).should_not be_equal(value)
     end
   end
 end
 
 describe Puppet::Parser::AST::Concat do
   describe "when evaluating" do
     before :each do
       @scope = stub_everything 'scope'
     end
     it "should interpolate variables and concatenate their values" do
       one = Puppet::Parser::AST::String.new(:value => "one")
       one.stubs(:evaluate).returns("one ")
       two = Puppet::Parser::AST::String.new(:value => "two")
       two.stubs(:evaluate).returns(" two ")
       three = Puppet::Parser::AST::String.new(:value => "three")
       three.stubs(:evaluate).returns(" three")
       var = Puppet::Parser::AST::Variable.new(:value => "myvar")
       var.stubs(:evaluate).returns("foo")
       array = Puppet::Parser::AST::Variable.new(:value => "array")
       array.stubs(:evaluate).returns(["bar","baz"])
       concat = Puppet::Parser::AST::Concat.new(:value => [one,var,two,array,three])
 
       concat.evaluate(@scope).should == 'one foo two barbaz three'
     end
 
     it "should transform undef variables to empty string" do
       var = Puppet::Parser::AST::Variable.new(:value => "myvar")
       var.stubs(:evaluate).returns(:undef)
       concat = Puppet::Parser::AST::Concat.new(:value => [var])
 
       concat.evaluate(@scope).should == ''
     end
   end
 end
 
 describe Puppet::Parser::AST::Undef do
   before :each do
     @scope = stub 'scope'
     @undef = Puppet::Parser::AST::Undef.new(:value => :undef)
   end
 
   it "should match undef with undef" do
     @undef.evaluate_match(:undef, @scope).should be_true
   end
 
   it "should not match undef with an empty string" do
     @undef.evaluate_match("", @scope).should be_false
   end
 end
 
 describe Puppet::Parser::AST::HashOrArrayAccess do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when evaluating" do
     it "should evaluate the variable part if necessary" do
       @scope.stubs(:lookupvar).with("a").returns(["b"])
 
       variable = stub 'variable', :evaluate => "a"
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => variable, :key => 0 )
 
       variable.expects(:safeevaluate).with(@scope).returns("a")
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should evaluate the access key part if necessary" do
       @scope.stubs(:lookupvar).with("a").returns(["b"])
 
       index = stub 'index', :evaluate => 0
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => index )
 
       index.expects(:safeevaluate).with(@scope).returns(0)
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should be able to return an array member" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an array member when index is a stringified number" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "1" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should raise an error when accessing an array with a key" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should be able to return an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an hash value with a numerical key" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
 
       access.evaluate(@scope).should == "45"
     end
 
     it "should raise an error if the variable lookup didn't return an hash or an array" do
       @scope.stubs(:lookupvar).with("a").returns("I'm a string")
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should raise an error if the variable wasn't in the scope" do
       @scope.stubs(:lookupvar).with("a").returns(nil)
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should return a correct string representation" do
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
       access.to_s.should == '$a[key2]'
     end
 
     it "should work with recursive hash access" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => { "subkey" => "b" }})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
 
       access2.evaluate(@scope).should == 'b'
     end
 
     it "should work with interleaved array and hash access" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => 1)
 
       access2.evaluate(@scope).should == 'b'
     end
   end
 
   describe "when assigning" do
     it "should add a new key and value" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", { 'a' => 'b' })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "b")
       access.assign(scope, "c" )
 
       scope.lookupvar("a").should be_include("b")
     end
 
     it "should raise an error when assigning an array element with a key" do
       @scope.stubs(:lookupvar).with("a").returns([])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
 
     it "should be able to return an array member when index is a stringified number" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", [])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "0" )
 
       access.assign(scope, "val2")
       scope.lookupvar("a").should == ["val2"]
     end
 
     it "should raise an error when trying to overwrite an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
   end
 end
 
 describe Puppet::Parser::AST::Regex do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when initializing" do
     it "should create a Regexp with its content when value is not a Regexp" do
       Regexp.expects(:new).with("/ab/")
 
       Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should not create a Regexp with its content when value is a Regexp" do
       value = Regexp.new("/ab/")
       Regexp.expects(:new).with("/ab/").never
 
       Puppet::Parser::AST::Regex.new :value => value
     end
   end
 
   describe "when evaluating" do
     it "should return self" do
       val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
       val.evaluate(@scope).should === val
     end
   end
 
   describe "when evaluate_match" do
     before :each do
       @value = stub 'regex'
       @value.stubs(:match).with("value").returns(true)
       Regexp.stubs(:new).returns(@value)
       @regex = Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should issue the regexp match" do
       @value.expects(:match).with("value")
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should not downcase the paramater value" do
       @value.expects(:match).with("VaLuE")
 
       @regex.evaluate_match("VaLuE", @scope)
     end
 
     it "should set ephemeral scope vars if there is a match" do
       @scope.expects(:ephemeral_from).with(true, nil, nil)
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should return the match to the caller" do
       @value.stubs(:match).with("value").returns(:match)
       @scope.stubs(:ephemeral_from)
 
       @regex.evaluate_match("value", @scope)
     end
   end
 
   it "should return the regex source with to_s" do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
     val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
     regex.expects(:source)
 
     val.to_s
   end
 
   it "should delegate match to the underlying regexp match method" do
     regex = Regexp.new("/ab/")
     val = Puppet::Parser::AST::Regex.new :value => regex
 
     regex.expects(:match).with("value")
 
     val.match("value")
   end
 end
 
 describe Puppet::Parser::AST::Variable do
   before :each do
     @scope = stub 'scope'
     @var = Puppet::Parser::AST::Variable.new(:value => "myvar")
   end
 
   it "should lookup the variable in scope" do
     @scope.expects(:lookupvar).with("myvar", false).returns(:myvalue)
     @var.safeevaluate(@scope).should == :myvalue
   end
 
   it "should return undef if the variable wasn't set" do
     @scope.expects(:lookupvar).with("myvar", false).returns(:undefined)
     @var.safeevaluate(@scope).should == :undef
   end
 
   describe "when converting to string" do
     it "should transform its value to a variable" do
       value = stub 'value', :is_a? => true, :to_s => "myvar"
       Puppet::Parser::AST::Variable.new( :value => value ).to_s.should == "\$myvar"
     end
   end
 end
 
 describe Puppet::Parser::AST::HostName do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value', :=~ => false
     @value.stubs(:to_s).returns(@value)
     @value.stubs(:downcase).returns(@value)
     @host = Puppet::Parser::AST::HostName.new( :value => @value)
   end
 
   it "should raise an error if hostname is not valid" do
     lambda { Puppet::Parser::AST::HostName.new( :value => "not an hostname!" ) }.should raise_error
   end
 
   it "should not raise an error if hostname is a regex" do
     lambda { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.should_not raise_error
   end
 
   it "should stringify the value" do
     value = stub 'value', :=~ => false
 
     value.expects(:to_s).returns("test")
 
     Puppet::Parser::AST::HostName.new(:value => value)
   end
 
   it "should downcase the value" do
     value = stub 'value', :=~ => false
     value.stubs(:to_s).returns("UPCASED")
     host = Puppet::Parser::AST::HostName.new(:value => value)
 
     host.value == "upcased"
   end
 
   it "should evaluate to its value" do
     @host.evaluate(@scope).should == @value
   end
 
   it "should delegate eql? to the underlying value if it is an HostName" do
     @value.expects(:eql?).with("value")
     @host.eql?("value")
   end
 
   it "should delegate eql? to the underlying value if it is not an HostName" do
     value = stub 'compared', :is_a? => true, :value => "value"
     @value.expects(:eql?).with("value")
     @host.eql?(value)
   end
 
   it "should delegate hash to the underlying value" do
     @value.expects(:hash)
     @host.hash
   end
 end
diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index e1f73e161..721c31a8d 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -1,172 +1,172 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Resource do
   ast = Puppet::Parser::AST
 
   describe "for builtin types" do
     before :each do
       @title = Puppet::Parser::AST::String.new(:value => "mytitle")
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
       @scope.stubs(:resource).returns(stub_everything)
       @resource = ast::Resource.new(:title => @title, :type => "file", :parameters => ast::ASTArray.new(:children => []) )
       @resource.stubs(:qualified_type).returns("Resource")
     end
 
     it "should evaluate all its parameters" do
       param = stub 'param'
       param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
       @resource.stubs(:parameters).returns [param]
 
       @resource.evaluate(@scope)
     end
 
     it "should evaluate its title" do
       @resource.evaluate(@scope)[0].title.should == "mytitle"
     end
 
     it "should flatten the titles array" do
       titles = []
       %w{one two}.each do |title|
         titles << Puppet::Parser::AST::String.new(:value => title)
       end
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
       @resource.title = array
       result = @resource.evaluate(@scope).collect { |r| r.title }
       result.should be_include("one")
       result.should be_include("two")
     end
 
     it "should create and return one resource objects per title" do
       titles = []
       %w{one two}.each do |title|
         titles << Puppet::Parser::AST::String.new(:value => title)
       end
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
       @resource.title = array
       result = @resource.evaluate(@scope).collect { |r| r.title }
       result.should be_include("one")
       result.should be_include("two")
     end
 
     it "should handover resources to the compiler" do
       titles = []
       %w{one two}.each do |title|
         titles << Puppet::Parser::AST::String.new(:value => title)
       end
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
       @resource.title = array
       result = @resource.evaluate(@scope)
 
       result.each do |res|
         @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
       end
     end
 
     it "should generate virtual resources if it is virtual" do
       @resource.virtual = true
 
       result = @resource.evaluate(@scope)
       result[0].should be_virtual
     end
 
     it "should generate virtual and exported resources if it is exported" do
       @resource.exported = true
 
       result = @resource.evaluate(@scope)
       result[0].should be_virtual
       result[0].should be_exported
     end
 
     # Related to #806, make sure resources always look up the full path to the resource.
     describe "when generating qualified resources" do
       before do
         @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
         @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
         @parser.newdefine "one"
         @parser.newdefine "one::two"
         @parser.newdefine "three"
         @twoscope = @scope.newscope(:namespace => "one")
         @twoscope.resource = @scope.resource
       end
 
       def resource(type, params = nil)
         params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
         Puppet::Parser::AST::Resource.new(:type => type, :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
       end
 
       it "should be able to generate resources with fully qualified type information" do
         resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
       end
 
       it "should be able to generate resources with unqualified type information" do
         resource("one").evaluate(@twoscope)[0].type.should == "One"
       end
 
       it "should correctly generate resources that can look up builtin types" do
         resource("file").evaluate(@twoscope)[0].type.should == "File"
       end
 
       it "should correctly generate resources that can look up defined classes by title" do
         @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
         @scope.compiler.stubs(:evaluate_classes)
         res = resource("class").evaluate(@twoscope)[0]
         res.type.should == "Class"
         res.title.should == "Myresource"
       end
 
       it "should evaluate parameterized classes when they are instantiated" do
         @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
         @scope.compiler.expects(:evaluate_classes).with(['myresource'],@twoscope,false)
         resource("class").evaluate(@twoscope)[0]
       end
 
       it "should fail for resource types that do not exist" do
         lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
       end
     end
   end
 
   describe "for class resources" do
     before do
       @title = Puppet::Parser::AST::String.new(:value => "classname")
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
       @scope.stubs(:resource).returns(stub_everything)
       @resource = ast::Resource.new(:title => @title, :type => "Class", :parameters => ast::ASTArray.new(:children => []) )
       @resource.stubs(:qualified_type).returns("Resource")
       @type = Puppet::Resource::Type.new(:hostclass, "classname")
       @compiler.known_resource_types.add(@type)
     end
 
     it "should instantiate the class" do
       @compiler.stubs(:evaluate_classes)
       result = @resource.evaluate(@scope)
       result.length.should == 1
       result.first.ref.should == "Class[Classname]"
-      @compiler.catalog.resource("Class[Classname]").should equal result.first
+      @compiler.catalog.resource("Class[Classname]").should equal(result.first)
     end
 
     it "should cause its parent to be evaluated" do
       parent_type = Puppet::Resource::Type.new(:hostclass, "parentname")
       @compiler.stubs(:evaluate_classes)
       @compiler.known_resource_types.add(parent_type)
       @type.parent = "parentname"
       result = @resource.evaluate(@scope)
       result.length.should == 1
       result.first.ref.should == "Class[Classname]"
-      @compiler.catalog.resource("Class[Classname]").should equal result.first
+      @compiler.catalog.resource("Class[Classname]").should equal(result.first)
       @compiler.catalog.resource("Class[Parentname]").should be_instance_of(Puppet::Parser::Resource)
     end
 
   end
 
 end
diff --git a/spec/unit/rails_spec.rb b/spec/unit/rails_spec.rb
index d30e52b8a..24248e622 100755
--- a/spec/unit/rails_spec.rb
+++ b/spec/unit/rails_spec.rb
@@ -1,324 +1,324 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/rails'
 
 describe Puppet::Rails, "when initializing any connection" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   before do
     Puppet.settings.stubs(:use)
     @logger = mock 'logger'
     @logger.stub_everything
     Logger.stubs(:new).returns(@logger)
 
     ActiveRecord::Base.stubs(:logger).returns(@logger)
     ActiveRecord::Base.stubs(:connected?).returns(false)
   end
 
   it "should use settings" do
     Puppet.settings.expects(:use).with(:main, :rails, :master)
 
     Puppet::Rails.connect
   end
 
   it "should set up a logger with the appropriate Rails log file" do
     logger = mock 'logger'
     Logger.expects(:new).with(Puppet[:railslog]).returns(logger)
     ActiveRecord::Base.expects(:logger=).with(logger)
 
     Puppet::Rails.connect
   end
 
   it "should set the log level to whatever the value is in the settings" do
     Puppet.settings.stubs(:use)
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("debug")
     Puppet.settings.stubs(:value).with(:railslog).returns("/my/file")
     logger = mock 'logger'
     Logger.stubs(:new).returns(logger)
     ActiveRecord::Base.stubs(:logger).returns(logger)
     logger.expects(:level=).with(Logger::DEBUG)
 
     ActiveRecord::Base.stubs(:allow_concurrency=)
     ActiveRecord::Base.stubs(:verify_active_connections!)
     ActiveRecord::Base.stubs(:establish_connection)
     Puppet::Rails.stubs(:database_arguments).returns({})
 
     Puppet::Rails.connect
   end
 
   describe "ActiveRecord Version" do
     it "should set ActiveRecord::Base.allow_concurrency if ActiveRecord is 2.1" do
       Puppet::Util.stubs(:activerecord_version).returns(2.1)
       ActiveRecord::Base.expects(:allow_concurrency=).with(true)
 
       Puppet::Rails.connect
     end
 
     it "should not set ActiveRecord::Base.allow_concurrency if ActiveRecord is >= 2.2" do
       Puppet::Util.stubs(:activerecord_version).returns(2.2)
       ActiveRecord::Base.expects(:allow_concurrency=).never
 
       Puppet::Rails.connect
     end
   end
 
   it "should call ActiveRecord::Base.verify_active_connections!" do
     ActiveRecord::Base.expects(:verify_active_connections!)
 
     Puppet::Rails.connect
   end
 
   it "should call ActiveRecord::Base.establish_connection with database_arguments" do
     Puppet::Rails.expects(:database_arguments).returns({})
     ActiveRecord::Base.expects(:establish_connection)
 
     Puppet::Rails.connect
   end
 end
 
 describe Puppet::Rails, "when initializing a sqlite3 connection" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   it "should provide the adapter, log_level, and database arguments" do
     Puppet.settings.expects(:value).with(:dbadapter).returns("sqlite3")
     Puppet.settings.expects(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.expects(:value).with(:dblocation).returns("testlocation")
 
     Puppet::Rails.database_arguments.should == {
       :adapter   => "sqlite3",
       :log_level => "testlevel",
       :database  => "testlocation"
     }
   end
 end
 
 describe Puppet::Rails, "when initializing a mysql connection" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   it "should provide the adapter, log_level, and host, port, username, password, database, and reconnect arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 45).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "mysql",
       :log_level => "testlevel",
       :host => "testserver",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :reconnect => true
     }
   end
 
   it "should provide the adapter, log_level, and host, port, username, password, database, socket, connections, and reconnect arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 12).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "mysql",
       :log_level => "testlevel",
       :host => "testserver",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
       :reconnect => true
     }
   end
 
   it "should provide the adapter, log_level, and host, port, username, password, database, socket, and connections arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 23).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "mysql",
       :log_level => "testlevel",
       :host => "testserver",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
       :reconnect => true
     }
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns(0)
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('')
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end
 
 describe Puppet::Rails, "when initializing a postgresql connection" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   it "should provide the adapter, log_level, and host, port, username, password, connections, and database arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("postgresql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 200).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "postgresql",
       :log_level => "testlevel",
       :host => "testserver",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :reconnect => true
     }
   end
 
   it "should provide the adapter, log_level, and host, port, username, password, database, connections, and socket arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("postgresql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 122).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "postgresql",
       :log_level => "testlevel",
       :host => "testserver",
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
       :reconnect => true
     }
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns(0)
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('')
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end
 
 describe Puppet::Rails, "when initializing an Oracle connection" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   it "should provide the adapter, log_level, and username, password, and database arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 123).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
       :log_level => "testlevel",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname"
     }
   end
 
   it "should provide the adapter, log_level, and host, username, password, database and socket arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 124).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
       :log_level => "testlevel",
       :username => "testuser",
       :password => "testpassword",
       :pool => pool_size,
       :database => "testname"
     }
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")
     Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
     Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
     Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns(0)
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
 
     Puppet.settings.stubs(:value).with(:dbconnections).returns('')
-    Puppet::Rails.database_arguments.should_not be_include :pool
+    Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end