diff --git a/spec/unit/parser/ast/function_spec.rb b/spec/unit/parser/ast/function_spec.rb
index d683b122b..95dc1150c 100755
--- a/spec/unit/parser/ast/function_spec.rb
+++ b/spec/unit/parser/ast/function_spec.rb
@@ -1,92 +1,92 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::AST::Function do
   before :each do
     @scope = mock 'scope'
   end
 
   describe "when initializing" do
     it "should not fail if the function doesn't exist" do
       Puppet::Parser::Functions.stubs(:function).returns(false)
 
       lambda{ Puppet::Parser::AST::Function.new :name => "dontexist" }.should_not raise_error(Puppet::ParseError)
 
     end
   end
 
   it "should return its representation with to_s" do
     args = stub 'args', :is_a? => true, :to_s => "[a, b]"
 
     Puppet::Parser::AST::Function.new(:name => "func", :arguments => args).to_s.should == "func(a, b)"
   end
 
   describe "when evaluating" do
 
     it "should fail if the function doesn't exist" do
       Puppet::Parser::Functions.stubs(:function).returns(false)
       func = Puppet::Parser::AST::Function.new :name => "dontexist"
 
       lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should fail if the function is a statement used as rvalue" do
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       Puppet::Parser::Functions.stubs(:rvalue?).with("exist").returns(false)
 
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :rvalue
 
       lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError, "Function 'exist' does not return a value")
     end
 
     it "should fail if the function is an rvalue used as statement" do
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       Puppet::Parser::Functions.stubs(:rvalue?).with("exist").returns(true)
 
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement
 
       lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError,"Function 'exist' must be the value of a statement")
     end
 
     it "should evaluate its arguments", :'fails_on_ruby_1.9.2' => true do
       argument = stub 'arg'
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
       @scope.stubs(:function_exist)
 
-      argument.expects(:safeevaluate).with(@scope).returns("argument")
+      argument.expects(:safeevaluate).with(@scope).returns(["argument"])
 
       func.evaluate(@scope)
     end
 
     it "should call the underlying ruby function" do
       argument = stub 'arg', :safeevaluate => ["nothing"]
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
 
       @scope.expects(:function_exist).with(["nothing"])
 
       func.evaluate(@scope)
     end
 
     it "should convert :undef to '' in arguments" do
       argument = stub 'arg', :safeevaluate => ["foo", :undef, "bar"]
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
 
       @scope.expects(:function_exist).with(["foo", "", "bar"])
 
       func.evaluate(@scope)
     end
 
     it "should return the ruby function return for rvalue functions" do
       argument = stub 'arg', :safeevaluate => ["nothing"]
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
       @scope.stubs(:function_exist).with(["nothing"]).returns("returning")
 
       func.evaluate(@scope).should == "returning"
     end
 
   end
 end
diff --git a/spec/unit/parser/functions/inline_template_spec.rb b/spec/unit/parser/functions/inline_template_spec.rb
index 47dcae15e..6357e2fea 100755
--- a/spec/unit/parser/functions/inline_template_spec.rb
+++ b/spec/unit/parser/functions/inline_template_spec.rb
@@ -1,61 +1,61 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "the inline_template function", :'fails_on_ruby_1.9.2' => true do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("inline_template").should == "function_inline_template"
   end
 
   it "should create a TemplateWrapper when called" do
     tw = stub_everything 'template_wrapper'
 
     Puppet::Parser::TemplateWrapper.expects(:new).returns(tw)
 
-    @scope.function_inline_template("test")
+    @scope.function_inline_template(["test"])
   end
 
   it "should pass the template string to TemplateWrapper.result" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
 
     tw.expects(:result).with("test")
 
-    @scope.function_inline_template("test")
+    @scope.function_inline_template(["test"])
   end
 
   it "should return what TemplateWrapper.result returns" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
 
     tw.expects(:result).returns("template contents evaluated")
 
-    @scope.function_inline_template("test").should == "template contents evaluated"
+    @scope.function_inline_template(["test"]).should == "template contents evaluated"
   end
 
   it "should concatenate template wrapper outputs for multiple templates" do
     tw1 = stub_everything "template_wrapper1"
     tw2 = stub_everything "template_wrapper2"
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
     tw1.stubs(:result).returns("result1")
     tw2.stubs(:result).returns("result2")
 
     @scope.function_inline_template(["1","2"]).should == "result1result2"
   end
 
   it "should raise an error if the template raises an error" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
     tw.stubs(:result).raises
 
-    lambda { @scope.function_inline_template("1") }.should raise_error(Puppet::ParseError)
+    lambda { @scope.function_inline_template(["1"]) }.should raise_error(Puppet::ParseError)
   end
 
 end
diff --git a/spec/unit/parser/functions/template_spec.rb b/spec/unit/parser/functions/template_spec.rb
index 6bce69534..07d42dac6 100755
--- a/spec/unit/parser/functions/template_spec.rb
+++ b/spec/unit/parser/functions/template_spec.rb
@@ -1,64 +1,62 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe "the template function", :'fails_on_ruby_1.9.2' => true do
+describe "the template function" do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let :scope do Puppet::Parser::Scope.new end
 
   it "should exist" do
     Puppet::Parser::Functions.function("template").should == "function_template"
   end
 
   it "should create a TemplateWrapper when called" do
     tw = stub_everything 'template_wrapper'
 
     Puppet::Parser::TemplateWrapper.expects(:new).returns(tw)
 
-    @scope.function_template("test")
+    scope.function_template(["test"])
   end
 
   it "should give the template filename to the TemplateWrapper" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
 
     tw.expects(:file=).with("test")
 
-    @scope.function_template("test")
+    scope.function_template(["test"])
   end
 
   it "should return what TemplateWrapper.result returns" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
     tw.stubs(:file=).with("test")
 
     tw.expects(:result).returns("template contents evaluated")
 
-    @scope.function_template("test").should == "template contents evaluated"
+    scope.function_template(["test"]).should == "template contents evaluated"
   end
 
   it "should concatenate template wrapper outputs for multiple templates" do
     tw1 = stub_everything "template_wrapper1"
     tw2 = stub_everything "template_wrapper2"
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
     tw1.stubs(:file=).with("1")
     tw2.stubs(:file=).with("2")
     tw1.stubs(:result).returns("result1")
     tw2.stubs(:result).returns("result2")
 
-    @scope.function_template(["1","2"]).should == "result1result2"
+    scope.function_template(["1","2"]).should == "result1result2"
   end
 
   it "should raise an error if the template raises an error" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
     tw.stubs(:result).raises
 
-    lambda { @scope.function_template("1") }.should raise_error(Puppet::ParseError)
+    expect { scope.function_template(["1"]) }.should raise_error(Puppet::ParseError)
   end
 
 end
diff --git a/spec/unit/provider/user/user_role_add_spec.rb b/spec/unit/provider/user/user_role_add_spec.rb
index d6235cb4b..3d96f34bd 100755
--- a/spec/unit/provider/user/user_role_add_spec.rb
+++ b/spec/unit/provider/user/user_role_add_spec.rb
@@ -1,303 +1,306 @@
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'tempfile'
 
 provider_class = Puppet::Type.type(:user).provider(:user_role_add)
 
 describe provider_class, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before do
     @resource = stub("resource", :name => "myuser", :managehome? => nil)
+
     @resource.stubs(:should).returns "fakeval"
+    @resource.stubs(:should).with(:keys).returns Hash.new
     @resource.stubs(:[]).returns "fakeval"
+
     @resource.stubs(:allowdupe?).returns false
     @provider = provider_class.new(@resource)
   end
 
   describe "when calling command" do
     before do
       klass = stub("provider")
       klass.stubs(:command).with(:foo).returns("userfoo")
       klass.stubs(:command).with(:role_foo).returns("rolefoo")
       @provider.stubs(:class).returns(klass)
     end
 
     it "should use the command if not a role and ensure!=role" do
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:exists?).returns(false)
       @resource.stubs(:[]).with(:ensure).returns(:present)
       @provider.command(:foo).should == "userfoo"
     end
 
     it "should use the role command when a role" do
       @provider.stubs(:is_role?).returns(true)
       @provider.command(:foo).should == "rolefoo"
     end
 
     it "should use the role command when !exists and ensure=role" do
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:exists?).returns(false)
       @resource.stubs(:[]).with(:ensure).returns(:role)
       @provider.command(:foo).should == "rolefoo"
     end
   end
 
   describe "when calling transition", :'fails_on_ruby_1.9.2' => true do
     it "should return the type set to whatever is passed in" do
       @provider.expects(:command).with(:modify).returns("foomod")
       @provider.transition("bar").include?("type=bar")
     end
   end
 
   describe "when calling create" do
     before do
       @provider.stubs(:password=)
     end
 
     it "should use the add command when the user is not a role" do
       @provider.stubs(:is_role?).returns(false)
       @provider.expects(:addcmd).returns("useradd")
       @provider.expects(:run).at_least_once
       @provider.create
     end
 
     it "should use transition(normal) when the user is a role" do
       @provider.stubs(:is_role?).returns(true)
       @provider.expects(:transition).with("normal")
       @provider.expects(:run)
       @provider.create
     end
 
     it "should set password age rules" do
       @resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :user_role_add
       @provider = provider_class.new(@resource)
       @provider.stubs(:user_attributes)
       @provider.stubs(:execute)
       @provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, "myuser"] }
       @provider.create
     end
   end
 
   describe "when calling destroy" do
     it "should use the delete command if the user exists and is not a role" do
       @provider.stubs(:exists?).returns(true)
       @provider.stubs(:is_role?).returns(false)
       @provider.expects(:deletecmd)
       @provider.expects(:run)
       @provider.destroy
     end
 
     it "should use the delete command if the user is a role" do
       @provider.stubs(:exists?).returns(true)
       @provider.stubs(:is_role?).returns(true)
       @provider.expects(:deletecmd)
       @provider.expects(:run)
       @provider.destroy
     end
   end
 
   describe "when calling create_role" do
     it "should use the transition(role) if the user exists" do
       @provider.stubs(:exists?).returns(true)
       @provider.stubs(:is_role?).returns(false)
       @provider.expects(:transition).with("role")
       @provider.expects(:run)
       @provider.create_role
     end
 
     it "should use the add command when role doesn't exists" do
       @provider.stubs(:exists?).returns(false)
       @provider.expects(:addcmd)
       @provider.expects(:run)
       @provider.create_role
     end
   end
 
   describe "when allow duplicate is enabled" do
     before do
       @resource.expects(:allowdupe?).returns true
       @resource.stubs(:system?)
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:execute)
       @provider.expects(:execute).with { |args| args.include?("-o") }
     end
 
     it "should add -o when the user is being created", :'fails_on_ruby_1.9.2' => true do
       @provider.stubs(:password=)
       @provider.create
     end
 
     it "should add -o when the uid is being modified" do
       @provider.uid = 150
     end
   end
 
   [:roles, :auths, :profiles].each do |val|
     describe "when getting #{val}" do
       it "should get the user_attributes" do
         @provider.expects(:user_attributes)
         @provider.send(val)
       end
 
       it "should get the #{val} attribute" do
         attributes = mock("attributes")
         attributes.expects(:[]).with(val)
         @provider.stubs(:user_attributes).returns(attributes)
         @provider.send(val)
       end
     end
   end
 
   describe "when getting the keys" do
     it "should get the user_attributes" do
       @provider.expects(:user_attributes)
       @provider.keys
     end
 
     it "should call removed_managed_attributes" do
       @provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
       @provider.expects(:remove_managed_attributes)
       @provider.keys
     end
 
     it "should removed managed attribute (type, auths, roles, etc)" do
       @provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
       @provider.keys.should == { :foo => "something" }
     end
   end
 
   describe "when adding properties" do
     it "should call build_keys_cmd" do
       @resource.stubs(:should).returns ""
       @resource.expects(:should).with(:keys).returns({ :foo => "bar" })
       @provider.expects(:build_keys_cmd).returns([])
       @provider.add_properties
     end
 
     it "should add the elements of the keys hash to an array" do
       @resource.stubs(:should).returns ""
       @resource.expects(:should).with(:keys).returns({ :foo => "bar"})
       @provider.add_properties.must == ["-K", "foo=bar"]
     end
   end
 
   describe "when calling build_keys_cmd" do
     it "should build cmd array with keypairs seperated by -K ending with user" do
       @provider.build_keys_cmd({"foo" => "bar", "baz" => "boo"}).should.eql? ["-K", "foo=bar", "-K", "baz=boo"]
     end
   end
 
   describe "when setting the keys" do
     before do
       @provider.stubs(:is_role?).returns(false)
     end
 
     it "should run a command" do
       @provider.expects(:run)
       @provider.keys=({})
     end
 
     it "should build the command" do
       @resource.stubs(:[]).with(:name).returns("someuser")
       @provider.stubs(:command).returns("usermod")
       @provider.expects(:build_keys_cmd).returns(["-K", "foo=bar"])
       @provider.expects(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
       @provider.keys=({})
     end
   end
 
   describe "when getting the hashed password" do
     before do
       @array = mock "array"
     end
 
     it "should readlines of /etc/shadow" do
       File.expects(:readlines).with("/etc/shadow").returns([])
       @provider.password
     end
 
     it "should reject anything that doesn't start with alpha numerics" do
       @array.expects(:reject).returns([])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
       @provider.password
     end
 
     it "should collect splitting on ':'" do
       @array.stubs(:reject).returns(@array)
       @array.expects(:collect).returns([])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
       @provider.password
     end
 
     it "should find the matching user" do
       @resource.stubs(:[]).with(:name).returns("username")
       @array.stubs(:reject).returns(@array)
       @array.stubs(:collect).returns([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
       @provider.password.must == "hashedpassword"
     end
 
     it "should get the right password" do
       @resource.stubs(:[]).with(:name).returns("username")
       File.stubs(:readlines).with("/etc/shadow").returns(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
       @provider.password.must == "hashedpassword"
     end
   end
 
   describe "when setting the password" do
     let(:path) { tmpfile('etc-shadow') }
 
     before :each do
       @provider.stubs(:target_file_path).returns(path)
     end
 
     def write_fixture(content)
       File.open(path, 'w') { |f| f.print(content) }
     end
 
     it "should update the target user" do
       write_fixture <<FIXTURE
 fakeval:seriously:15315:0:99999:7:::
 FIXTURE
       @provider.password = "totally"
       File.read(path).should =~ /^fakeval:totally:/
     end
 
     it "should only update the target user" do
       write_fixture <<FIXTURE
 before:seriously:15315:0:99999:7:::
 fakeval:seriously:15315:0:99999:7:::
 fakevalish:seriously:15315:0:99999:7:::
 after:seriously:15315:0:99999:7:::
 FIXTURE
       @provider.password = "totally"
       File.read(path).should == <<EOT
 before:seriously:15315:0:99999:7:::
 fakeval:totally:15315:0:99999:7:::
 fakevalish:seriously:15315:0:99999:7:::
 after:seriously:15315:0:99999:7:::
 EOT
     end
 
     # This preserves the current semantics, but is it right? --daniel 2012-02-05
     it "should do nothing if the target user is missing" do
       fixture = <<FIXTURE
 before:seriously:15315:0:99999:7:::
 fakevalish:seriously:15315:0:99999:7:::
 after:seriously:15315:0:99999:7:::
 FIXTURE
 
       write_fixture fixture
       @provider.password = "totally"
       File.read(path).should == fixture
     end
   end
 
   describe "#shadow_entry" do
     it "should return the line for the right user" do
       File.stubs(:readlines).returns(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
       @provider.shadow_entry.should == ["fakeval", "*", "20", "10", "30", "7", "2"]
     end
   end
 end
diff --git a/spec/unit/provider/zpool/solaris_spec.rb b/spec/unit/provider/zpool/solaris_spec.rb
index 39ee9c9ba..ae8ce5f98 100755
--- a/spec/unit/provider/zpool/solaris_spec.rb
+++ b/spec/unit/provider/zpool/solaris_spec.rb
@@ -1,208 +1,208 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:zpool).provider(:solaris)
 
 describe provider_class do
   before do
     @resource = stub("resource", :name => "mypool")
-    @resource.stubs(:[]).returns "shouldvalue"
+    @resource.stubs(:[]).returns ["shouldvalue"]
     @provider = provider_class.new(@resource)
   end
 
   describe "when getting the instance" do
     it "should call process_zpool_data with the result of get_pool_data only once" do
       @provider.stubs(:get_pool_data).returns(["foo", "disk"])
       @provider.expects(:process_zpool_data).with(["foo", "disk"]).returns("stuff").once
       @provider.current_pool
       @provider.current_pool
     end
   end
 
   describe "when calling flush" do
     it "should need to reload the pool" do
       @provider.stubs(:get_pool_data)
       @provider.expects(:process_zpool_data).returns("stuff").times(2)
       @provider.current_pool
       @provider.flush
       @provider.current_pool
     end
   end
 
   describe "when procesing zpool data" do
     before do
       @zpool_data = ["foo", "disk"]
     end
 
     describe "when there is no data" do
       it "should return a hash with ensure=>:absent" do
         @provider.process_zpool_data([])[:ensure].should == :absent
       end
     end
 
     describe "when there is a spare" do
       it "should add the spare disk to the hash" do
         @zpool_data += ["spares", "spare_disk"]
         @provider.process_zpool_data(@zpool_data)[:spare].should == ["spare_disk"]
       end
     end
 
     describe "when there are two spares" do
       it "should add the spare disk to the hash as a single string" do
         @zpool_data += ["spares", "spare_disk", "spare_disk2"]
         @provider.process_zpool_data(@zpool_data)[:spare].should == ["spare_disk spare_disk2"]
       end
     end
 
     describe "when there is a log" do
       it "should add the log disk to the hash" do
         @zpool_data += ["logs", "log_disk"]
         @provider.process_zpool_data(@zpool_data)[:log].should == ["log_disk"]
       end
     end
 
     describe "when there are two logs" do
       it "should add the log disks to the hash as a single string" do
         @zpool_data += ["spares", "spare_disk", "spare_disk2"]
         @provider.process_zpool_data(@zpool_data)[:spare].should == ["spare_disk spare_disk2"]
       end
     end
 
     describe "when the vdev is a single mirror" do
       it "should call create_multi_array with mirror" do
         @zpool_data = ["mirrorpool", "mirror", "disk1", "disk2"]
         @provider.process_zpool_data(@zpool_data)[:mirror].should == ["disk1 disk2"]
       end
     end
 
     describe "when the vdev is a single mirror on solaris 10u9 or later" do
       it "should call create_multi_array with mirror" do
         @zpool_data = ["mirrorpool", "mirror-0", "disk1", "disk2"]
         @provider.process_zpool_data(@zpool_data)[:mirror].should == ["disk1 disk2"]
       end
     end
 
     describe "when the vdev is a double mirror" do
       it "should call create_multi_array with mirror" do
         @zpool_data = ["mirrorpool", "mirror", "disk1", "disk2", "mirror", "disk3", "disk4"]
         @provider.process_zpool_data(@zpool_data)[:mirror].should == ["disk1 disk2", "disk3 disk4"]
       end
     end
 
     describe "when the vdev is a double mirror on solaris 10u9 or later" do
       it "should call create_multi_array with mirror" do
         @zpool_data = ["mirrorpool", "mirror-0", "disk1", "disk2", "mirror-1", "disk3", "disk4"]
         @provider.process_zpool_data(@zpool_data)[:mirror].should == ["disk1 disk2", "disk3 disk4"]
       end
     end
 
     describe "when the vdev is a raidz1" do
       it "should call create_multi_array with raidz1" do
         @zpool_data = ["mirrorpool", "raidz1", "disk1", "disk2"]
         @provider.process_zpool_data(@zpool_data)[:raidz].should == ["disk1 disk2"]
       end
     end
 
     describe "when the vdev is a raidz1 on solaris 10u9 or later" do
       it "should call create_multi_array with raidz1" do
         @zpool_data = ["mirrorpool", "raidz1-0", "disk1", "disk2"]
         @provider.process_zpool_data(@zpool_data)[:raidz].should == ["disk1 disk2"]
       end
     end
 
     describe "when the vdev is a raidz2" do
       it "should call create_multi_array with raidz2 and set the raid_parity" do
         @zpool_data = ["mirrorpool", "raidz2", "disk1", "disk2"]
         pool = @provider.process_zpool_data(@zpool_data)
         pool[:raidz].should == ["disk1 disk2"]
         pool[:raid_parity].should == "raidz2"
       end
     end
 
     describe "when the vdev is a raidz2 on solaris 10u9 or later" do
       it "should call create_multi_array with raidz2 and set the raid_parity" do
         @zpool_data = ["mirrorpool", "raidz2-0", "disk1", "disk2"]
         pool = @provider.process_zpool_data(@zpool_data)
         pool[:raidz].should == ["disk1 disk2"]
         pool[:raid_parity].should == "raidz2"
       end
     end
   end
 
   describe "when calling the getters and setters" do
     [:disk, :mirror, :raidz, :log, :spare].each do |field|
       describe "when calling #{field}" do
         it "should get the #{field} value from the current_pool hash" do
           pool_hash = mock "pool hash"
           pool_hash.expects(:[]).with(field)
           @provider.stubs(:current_pool).returns(pool_hash)
           @provider.send(field)
         end
       end
 
       describe "when setting the #{field}" do
         it "should warn the #{field} values were not in sync" do
           Puppet.expects(:warning).with("NO CHANGES BEING MADE: zpool #{field} does not match, should be 'shouldvalue' currently is 'currentvalue'")
           @provider.stubs(:current_pool).returns(Hash.new("currentvalue"))
           @provider.send((field.to_s + "=").intern, "shouldvalue")
         end
       end
     end
   end
 
   describe "when calling create", :'fails_on_ruby_1.9.2' => true do
     before do
       @resource.stubs(:[]).with(:pool).returns("mypool")
       @provider.stubs(:zpool)
     end
 
 
     it "should call build_vdevs" do
       @provider.expects(:build_vdevs).returns([])
       @provider.create
     end
 
     it "should call build_named with 'spares' and 'log" do
       @provider.expects(:build_named).with("spare").returns([])
       @provider.expects(:build_named).with("log").returns([])
       @provider.create
     end
 
     it "should call zpool with arguments from build_vdevs and build_named" do
       @provider.expects(:zpool).with(:create, 'mypool', 'shouldvalue', 'spare', 'shouldvalue', 'log', 'shouldvalue')
       @provider.create
     end
   end
 
   describe "when calling delete" do
     it "should call zpool with destroy and the pool name" do
       @resource.stubs(:[]).with(:pool).returns("poolname")
       @provider.expects(:zpool).with(:destroy, "poolname")
       @provider.delete
     end
   end
 
   describe "when calling exists?" do
     before do
       @current_pool = Hash.new(:absent)
       @provider.stubs(:get_pool_data).returns([])
       @provider.stubs(:process_zpool_data).returns(@current_pool)
     end
 
     it "should get the current pool" do
       @provider.expects(:process_zpool_data).returns(@current_pool)
       @provider.exists?
     end
 
     it "should return false if the current_pool is absent" do
       #the before sets it up
       @provider.exists?.should == false
     end
 
     it "should return true if the current_pool has values" do
       @current_pool[:pool] = "mypool"
       @provider.exists?.should == true
     end
   end
 
 end
diff --git a/spec/unit/util/autoload_spec.rb b/spec/unit/util/autoload_spec.rb
index 587d54796..98b137995 100755
--- a/spec/unit/util/autoload_spec.rb
+++ b/spec/unit/util/autoload_spec.rb
@@ -1,222 +1,222 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/autoload'
 
 describe Puppet::Util::Autoload do
   before do
     @autoload = Puppet::Util::Autoload.new("foo", "tmp")
 
     @autoload.stubs(:eachdir).yields "/my/dir"
     @loaded = {}
     @autoload.class.stubs(:loaded).returns(@loaded)
   end
 
   describe "when building the search path" do
     before :each do
       ## modulepath/libdir can't be used until after app settings are initialized, so we need to simulate that:
       Puppet.settings.expects(:app_defaults_initialized?).returns(true).at_least_once
 
       @dira = File.expand_path('/a')
       @dirb = File.expand_path('/b')
       @dirc = File.expand_path('/c')
     end
 
     it "should collect all of the plugins and lib directories that exist in the current environment's module path" do
       Puppet.settings.expects(:value).with(:environment).returns "foo"
       Puppet.settings.expects(:value).with(:modulepath, :foo).returns "#{@dira}#{File::PATH_SEPARATOR}#{@dirb}#{File::PATH_SEPARATOR}#{@dirc}"
       Dir.expects(:entries).with(@dira).returns %w{one two}
       Dir.expects(:entries).with(@dirb).returns %w{one two}
 
       FileTest.stubs(:directory?).returns false
       FileTest.expects(:directory?).with(@dira).returns true
       FileTest.expects(:directory?).with(@dirb).returns true
       ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@dirb}/two/lib"].each do |d|
         FileTest.expects(:directory?).with(d).returns true
       end
 
       @autoload.class.module_directories.should == ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@dirb}/two/lib"]
     end
 
     it "should not look for lib directories in directories starting with '.'" do
       Puppet.settings.expects(:value).with(:environment).returns "foo"
       Puppet.settings.expects(:value).with(:modulepath, :foo).returns @dira
       Dir.expects(:entries).with(@dira).returns %w{. ..}
 
       FileTest.expects(:directory?).with(@dira).returns true
       FileTest.expects(:directory?).with("#{@dira}/./lib").never
       FileTest.expects(:directory?).with("#{@dira}/./plugins").never
       FileTest.expects(:directory?).with("#{@dira}/../lib").never
       FileTest.expects(:directory?).with("#{@dira}/../plugins").never
 
       @autoload.class.module_directories
     end
 
     it "should include the module directories, the Puppet libdir, and all of the Ruby load directories" do
       Puppet[:libdir] = %w{/libdir1 /lib/dir/two /third/lib/dir}.join(File::PATH_SEPARATOR)
       @autoload.class.expects(:module_directories).returns %w{/one /two}
       @autoload.class.search_directories.should == %w{/one /two} + Puppet[:libdir].split(File::PATH_SEPARATOR) + $LOAD_PATH
     end
   end
 
   describe "when loading a file" do
     before do
       @autoload.class.stubs(:search_directories).returns %w{/a}
       FileTest.stubs(:directory?).returns true
       @time_a = Time.utc(2010, 'jan', 1, 6, 30)
       File.stubs(:mtime).returns @time_a
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die with Puppet::Error if a #{error.to_s} exception is thrown" do
         File.stubs(:exist?).returns true
 
         Kernel.expects(:load).raises error
 
         lambda { @autoload.load("foo") }.should raise_error(Puppet::Error)
       end
     end
 
     it "should not raise an error if the file is missing" do
       @autoload.load("foo").should == false
     end
 
     it "should register loaded files with the autoloader" do
       File.stubs(:exist?).returns true
       Kernel.stubs(:load)
       @autoload.load("myfile")
 
       @autoload.class.loaded?("tmp/myfile.rb").should be
 
       $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
 
     it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
       File.stubs(:exist?).returns true
       Kernel.stubs(:load)
 
       @autoload.load("myfile")
 
       $LOADED_FEATURES.should be_include("tmp/myfile.rb")
 
       $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
 
     it "should load the first file in the searchpath" do
       @autoload.stubs(:search_directories).returns %w{/a /b}
       FileTest.stubs(:directory?).returns true
       File.stubs(:exist?).returns true
       Kernel.expects(:load).with("/a/tmp/myfile.rb", optionally(anything))
 
       @autoload.load("myfile")
 
       $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
 
     it "should treat equivalent paths to a loaded file as loaded" do
       File.stubs(:exist?).returns true
       Kernel.stubs(:load)
       @autoload.load("myfile")
 
       @autoload.class.loaded?("tmp/myfile").should be
       @autoload.class.loaded?("tmp/./myfile.rb").should be
       @autoload.class.loaded?("./tmp/myfile.rb").should be
       @autoload.class.loaded?("tmp/../tmp/myfile.rb").should be
 
       $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
   end
 
   describe "when loading all files" do
     before do
       @autoload.class.stubs(:search_directories).returns %w{/a}
       FileTest.stubs(:directory?).returns true
-      Dir.stubs(:glob).returns "/a/foo/file.rb"
+      Dir.stubs(:glob).returns ["/a/foo/file.rb"]
       File.stubs(:exist?).returns true
       @time_a = Time.utc(2010, 'jan', 1, 6, 30)
       File.stubs(:mtime).returns @time_a
 
       @autoload.class.stubs(:loaded?).returns(false)
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die an if a #{error.to_s} exception is thrown", :'fails_on_ruby_1.9.2' => true do
         Kernel.expects(:load).raises error
 
         lambda { @autoload.loadall }.should raise_error(Puppet::Error)
       end
     end
 
     it "should require the full path to the file", :'fails_on_ruby_1.9.2' => true do
       Kernel.expects(:load).with("/a/foo/file.rb", optionally(anything))
 
       @autoload.loadall
     end
   end
 
   describe "when reloading files" do
     before :each do
       @file_a = "/a/file.rb"
       @file_b = "/b/file.rb"
       @first_time = Time.utc(2010, 'jan', 1, 6, 30)
       @second_time = @first_time + 60
     end
 
     after :each do
       $LOADED_FEATURES.delete("a/file.rb")
       $LOADED_FEATURES.delete("b/file.rb")
     end
 
     describe "in one directory" do
       before :each do
         @autoload.class.stubs(:search_directories).returns %w{/a}
         File.expects(:mtime).with(@file_a).returns(@first_time)
         @autoload.class.mark_loaded("file", @file_a)
       end
 
       it "should reload if mtime changes" do
         File.stubs(:mtime).with(@file_a).returns(@first_time + 60)
         File.stubs(:exist?).with(@file_a).returns true
         Kernel.expects(:load).with(@file_a, optionally(anything))
         @autoload.class.reload_changed
       end
 
       it "should do nothing if the file is deleted" do
         File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
         File.stubs(:exist?).with(@file_a).returns false
         Kernel.expects(:load).never
         @autoload.class.reload_changed
       end
     end
 
     describe "in two directories" do
       before :each do
         @autoload.class.stubs(:search_directories).returns %w{/a /b}
       end
 
       it "should load b/file when a/file is deleted" do
         File.expects(:mtime).with(@file_a).returns(@first_time)
         @autoload.class.mark_loaded("file", @file_a)
         File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
         File.stubs(:exist?).with(@file_a).returns false
         File.stubs(:exist?).with(@file_b).returns true
         File.stubs(:mtime).with(@file_b).returns @first_time
         Kernel.expects(:load).with(@file_b, optionally(anything))
         @autoload.class.reload_changed
         @autoload.class.send(:loaded)["file"].should == [@file_b, @first_time]
       end
 
       it "should load a/file when b/file is loaded and a/file is created" do
         File.stubs(:mtime).with(@file_b).returns @first_time
         File.stubs(:exist?).with(@file_b).returns true
         @autoload.class.mark_loaded("file", @file_b)
 
         File.stubs(:mtime).with(@file_a).returns @first_time
         File.stubs(:exist?).with(@file_a).returns true
         Kernel.expects(:load).with(@file_a, optionally(anything))
         @autoload.class.reload_changed
         @autoload.class.send(:loaded)["file"].should == [@file_a, @first_time]
       end
     end
   end
 end