diff --git a/spec/unit/parser/ast/asthash_spec.rb b/spec/unit/parser/ast/asthash_spec.rb
index d7fbbfae9..ab1281f91 100755
--- a/spec/unit/parser/ast/asthash_spec.rb
+++ b/spec/unit/parser/ast/asthash_spec.rb
@@ -1,97 +1,96 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::AST::ASTHash do
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should have a merge functionality" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => {})
     hash.should respond_to(:merge)
   end
 
   it "should be able to merge 2 AST hashes" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b" })
 
     hash.merge(Puppet::Parser::AST::ASTHash.new(:value => {"c" => "d"}))
 
     hash.value.should == { "a" => "b", "c" => "d" }
   end
 
   it "should be able to merge with a ruby Hash" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b" })
 
     hash.merge({"c" => "d"})
 
     hash.value.should == { "a" => "b", "c" => "d" }
   end
 
   it "should evaluate each hash value" do
     key1 = stub "key1"
     value1 = stub "value1"
     key2 = stub "key2"
     value2 = stub "value2"
 
     value1.expects(:safeevaluate).with(@scope).returns("b")
     value2.expects(:safeevaluate).with(@scope).returns("d")
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     operator.evaluate(@scope)
   end
 
   it "should evaluate the hash keys if they are AST instances" do
     key1 = stub "key1"
     value1 = stub "value1", :safeevaluate => "one"
     key2 = stub "key2"
     value2 = stub "value2", :safeevaluate => "two"
 
     key1.expects(:safeevaluate).with(@scope).returns("1")
     key2.expects(:safeevaluate).with(@scope).returns("2")
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     hash = operator.evaluate(@scope)
     hash["1"].should == "one"
     hash["2"].should == "two"
   end
 
   it "should evaluate the hash keys if they are not AST instances" do
     key1 = "1"
     value1 = stub "value1", :safeevaluate => "one"
     key2 = "2"
     value2 = stub "value2", :safeevaluate => "two"
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     hash = operator.evaluate(@scope)
     hash["1"].should == "one"
     hash["2"].should == "two"
   end
 
   it "should return an evaluated hash" do
     key1 = stub "key1"
     value1 = stub "value1", :safeevaluate => "b"
     key2 = stub "key2"
     value2 = stub "value2", :safeevaluate => "d"
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     operator.evaluate(@scope).should == { key1 => "b", key2 => "d" }
   end
 
   describe "when being initialized without arguments" do
     it "should evaluate to an empty hash" do
       hash = Puppet::Parser::AST::ASTHash.new({})
       hash.evaluate(@scope).should == {}
     end
 
     it "should support merging" do
       hash = Puppet::Parser::AST::ASTHash.new({})
       hash.merge({"a" => "b"}).should == {"a" => "b"}
     end
   end
 
   it "should return a valid string with to_s" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b", "c" => "d" })
-
-    hash.to_s.should == '{a => b, c => d}'
+    ["{a => b, c => d}", "{c => d, a => b}"].should be_include hash.to_s
   end
 end
diff --git a/spec/unit/property/keyvalue_spec.rb b/spec/unit/property/keyvalue_spec.rb
index 821c61799..2bead50e3 100755
--- a/spec/unit/property/keyvalue_spec.rb
+++ b/spec/unit/property/keyvalue_spec.rb
@@ -1,167 +1,170 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/property/keyvalue'
 
 klass = Puppet::Property::KeyValue
 
 describe klass do
 
   it "should be a subclass of Property" do
     klass.superclass.must == Puppet::Property
   end
 
   describe "as an instance" do
     before do
       # Wow that's a messy interface to the resource.
       klass.initvars
       @resource = stub 'resource', :[]= => nil, :property => nil
       @property = klass.new(:resource => @resource)
     end
 
     it "should have a , as default delimiter" do
       @property.delimiter.should == ";"
     end
 
     it "should have a = as default separator" do
       @property.separator.should == "="
     end
 
     it "should have a :membership as default membership" do
       @property.membership.should == :key_value_membership
     end
 
     it "should return the same value passed into should_to_s" do
       @property.should_to_s({:foo => "baz", :bar => "boo"}) == "foo=baz;bar=boo"
     end
 
-    it "should return the passed in array values joined with the delimiter from is_to_s" do
-      @property.is_to_s({"foo" => "baz" , "bar" => "boo"}).should == "foo=baz;bar=boo"
+    it "should return the passed in hash values joined with the delimiter from is_to_s" do
+      s = @property.is_to_s({"foo" => "baz" , "bar" => "boo"})
+
+      # We can't predict the order the hash is processed in...
+      ["foo=baz;bar=boo", "bar=boo;foo=baz"].should be_include s
     end
 
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
         @property.expects(:membership).returns(:key_value_membership)
         @resource.expects(:[]).with(:key_value_membership)
         @property.inclusive?
       end
 
       it "should return true when @resource[membership] == inclusive" do
         @property.stubs(:membership).returns(:key_value_membership)
         @resource.stubs(:[]).with(:key_value_membership).returns(:inclusive)
         @property.inclusive?.must == true
       end
 
       it "should return false when @resource[membership] != inclusive" do
         @property.stubs(:membership).returns(:key_value_membership)
         @resource.stubs(:[]).with(:key_value_membership).returns(:minimum)
         @property.inclusive?.must == false
       end
     end
 
     describe "when calling process_current_hash" do
       it "should return {} if hash is :absent" do
         @property.process_current_hash(:absent).must == {}
       end
 
       it "should set every key to nil if inclusive?" do
         @property.stubs(:inclusive?).returns(true)
         @property.process_current_hash({:foo => "bar", :do => "re"}).must == { :foo => nil, :do => nil }
       end
 
       it "should return the hash if !inclusive?" do
         @property.stubs(:inclusive?).returns(false)
         @property.process_current_hash({:foo => "bar", :do => "re"}).must == {:foo => "bar", :do => "re"}
       end
     end
 
     describe "when calling should" do
       it "should return nil if @should is nil" do
         @property.should.must == nil
       end
 
       it "should call process_current_hash" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.stubs(:retrieve).returns({:do => "re", :mi => "fa" })
         @property.expects(:process_current_hash).returns({})
         @property.should
       end
 
       it "should return the hashed values of @should and the nilled values of retrieve if inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:retrieve).returns({:do => "re", :mi => "fa" })
         @property.expects(:inclusive?).returns(true)
         @property.should.must == { :foo => "baz", :bar => "boo", :do => nil, :mi => nil }
       end
 
       it "should return the hashed @should + the unique values of retrieve if !inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:retrieve).returns({:foo => "diff", :do => "re", :mi => "fa"})
         @property.expects(:inclusive?).returns(false)
         @property.should.must == { :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" }
       end
     end
 
     describe "when calling retrieve" do
       before do
         @provider = mock("provider")
         @property.stubs(:provider).returns(@provider)
       end
 
       it "should send 'name' to the provider" do
         @provider.expects(:send).with(:keys)
         @property.expects(:name).returns(:keys)
         @property.retrieve
       end
 
       it "should return a hash with the provider returned info" do
         @provider.stubs(:send).with(:keys).returns({"do" => "re", "mi" => "fa" })
         @property.stubs(:name).returns(:keys)
         @property.retrieve == {"do" => "re", "mi" => "fa" }
       end
 
       it "should return :absent when the provider returns :absent" do
         @provider.stubs(:send).with(:keys).returns(:absent)
         @property.stubs(:name).returns(:keys)
         @property.retrieve == :absent
       end
     end
 
     describe "when calling hashify" do
       it "should return the array hashified" do
         @property.hashify(["foo=baz", "bar=boo"]).must == { :foo => "baz", :bar => "boo" }
       end
     end
 
     describe "when calling safe_insync?" do
       before do
         @provider = mock("provider")
         @property.stubs(:provider).returns(@provider)
         @property.stubs(:name).returns(:prop_name)
       end
 
       it "should return true unless @should is defined and not nil" do
         @property.safe_insync?("foo") == true
       end
 
       it "should return true if the passed in values is nil" do
         @property.should = "foo"
         @property.safe_insync?(nil) == true
       end
 
       it "should return true if hashified should value == (retrieved) value passed in" do
         @provider.stubs(:prop_name).returns({ :foo => "baz", :bar => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:inclusive?).returns(true)
         @property.safe_insync?({ :foo => "baz", :bar => "boo" }).must == true
       end
 
       it "should return false if prepared value != should value" do
         @provider.stubs(:prop_name).returns({ "foo" => "bee", "bar" => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:inclusive?).returns(true)
         @property.safe_insync?({ "foo" => "bee", "bar" => "boo" }).must == false
       end
     end
   end
 end