puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/resource/status_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/resource/status'
@@ -142,7 +142,7 @@ describe Puppet::Resource::Status do
     end
   end
 
-  describe "When converting to YAML", :'fails_on_ruby_1.9.2' => true do
+  describe "When converting to YAML" do
     it "should include only documented attributes" do
       @status.file = "/foo.rb"
       @status.line = 27

data/spec/unit/resource/type_collection_helper_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/resource/type_collection_helper'

data/spec/unit/resource/type_collection_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
@@ -55,14 +55,6 @@ describe Puppet::Resource::TypeCollection do
     @code.node("foo").should equal(node)
   end
 
-  it "should fail if a duplicate node is added" do
-    @code.add(Puppet::Resource::Type.new(:node, "foo"))
-
-    expect do
-      @code.add(Puppet::Resource::Type.new(:node, "foo"))
-    end.to raise_error(Puppet::ParseError, /cannot redefine/)
-  end
-
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
@@ -70,16 +62,6 @@ describe Puppet::Resource::TypeCollection do
     @code.hostclass("foo").should equal(klass)
   end
 
-  it "merge together hostclasses of the same name" do
-    klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
-    klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
-
-    @code.add(klass1)
-    @code.add(klass2)
-
-    @code.hostclass("foo").doc.should == "firstsecond"
-  end
-
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
@@ -87,12 +69,13 @@ describe Puppet::Resource::TypeCollection do
     @code.definition("foo").should equal(define)
   end
 
-  it "should fail if a duplicate definition is added" do
-    @code.add(Puppet::Resource::Type.new(:definition, "foo"))
-
-    expect do
-      @code.add(Puppet::Resource::Type.new(:definition, "foo"))
-    end.to raise_error(Puppet::ParseError, /cannot be redefined/)
+  it "should merge new classes with existing classes of the same name" do
+    loader = Puppet::Resource::TypeCollection.new("env")
+    first = Puppet::Resource::Type.new(:hostclass, "foo")
+    second = Puppet::Resource::Type.new(:hostclass, "foo")
+    loader.add first
+    first.expects(:merge).with(second)
+    loader.add(second)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
@@ -174,7 +157,7 @@ describe Puppet::Resource::TypeCollection do
       end
 
       it "should return nil if the name isn't found" do
-        @code.stubs(:try_load_fqname).returns(nil)
+        @code.loader.stubs(:try_load_fqname).returns(nil)
         @code.find_hostclass("Ns", "Klass").should be_nil
       end
 
@@ -183,31 +166,70 @@ describe Puppet::Resource::TypeCollection do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
         @code.find_hostclass("foo", "bar").should == :foobar
       end
+
+      it "should not try to autoload names that we couldn't autoload in a previous step" do
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass").returns(nil)
+        @code.find_hostclass("Ns", "Klass").should be_nil
+
+        @code.find_hostclass("Ns", "Klass").should be_nil
+      end
     end
   end
 
   %w{hostclass node definition}.each do |data|
-    describe "behavior of add for #{data}" do
+    before do
+      @instance = Puppet::Resource::Type.new(data, "foo")
+    end
 
-      it "should return the added #{data}" do
-        loader = Puppet::Resource::TypeCollection.new("env")
-        instance = Puppet::Resource::Type.new(data, "foo")
+    it "should have a method for adding a #{data}" do
+      Puppet::Resource::TypeCollection.new("env").should respond_to("add_#{data}")
+    end
 
-        loader.add(instance).should equal(instance)
-      end
+    it "should use the name of the instance to add it" do
+      loader = Puppet::Resource::TypeCollection.new("env")
+      loader.send("add_#{data}", @instance)
+      loader.send(data, @instance.name).should equal(@instance)
+    end
 
-      it "should retrieve #{data} insensitive to case" do
+    unless data == "hostclass"
+      it "should fail to add a #{data} when one already exists" do
         loader = Puppet::Resource::TypeCollection.new("env")
-        instance = Puppet::Resource::Type.new(data, "Bar")
+        loader.add @instance
+        lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
+      end
+    end
 
-        loader.add instance
+    it "should return the added #{data}" do
+      loader = Puppet::Resource::TypeCollection.new("env")
 
-        loader.send(data, "bAr").should equal(instance)
-      end
+      loader.add(@instance).should equal(@instance)
+    end
 
-      it "should return nil when asked for a #{data} that has not been added" do
-        Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
-      end
+    it "should be able to retrieve #{data} by name" do
+      loader = Puppet::Resource::TypeCollection.new("env")
+      instance = Puppet::Resource::Type.new(data, "bar")
+      loader.add instance
+      loader.send(data, "bar").should equal(instance)
+    end
+
+    it "should retrieve #{data} insensitive to case" do
+      loader = Puppet::Resource::TypeCollection.new("env")
+      instance = Puppet::Resource::Type.new(data, "Bar")
+      loader.add instance
+      loader.send(data, "bAr").should equal(instance)
+    end
+
+    it "should return nil when asked for a #{data} that has not been added" do
+      Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
+    end
+
+    it "should be able to retrieve all #{data}s" do
+      plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
+      loader = Puppet::Resource::TypeCollection.new("env")
+      instance = Puppet::Resource::Type.new(data, "foo")
+      loader.add instance
+      loader.send(plurals[data]).should == { "foo" => instance }
     end
   end
 
@@ -295,9 +317,12 @@ describe Puppet::Resource::TypeCollection do
       it "should only look in the topclass, if the name is qualified" do
         @loader.find_hostclass("foo", "::bar").name.should == 'bar'
       end
-
+      
+      it "should only look in the topclass, if we assume the name is fully qualified" do
+        @loader.find_hostclass("foo", "bar", :assume_fqname => true).name.should == 'bar'
+      end
     end
-
+    
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new("env")
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
@@ -316,7 +341,7 @@ describe Puppet::Resource::TypeCollection do
 
   it "should use the 'find_or_load' method to find hostclasses" do
     loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find_or_load).with("foo", "bar", :hostclass)
+    loader.expects(:find_or_load).with("foo", "bar", :hostclass, {})
     loader.find_hostclass("foo", "bar")
   end
 
@@ -421,15 +446,17 @@ describe Puppet::Resource::TypeCollection do
     it "should use the output of the environment's config_version setting if one is provided" do
       @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
 
-      Puppet::Util.expects(:execute).with(["/my/foo"]).returns "output\n"
+      Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
       @code.version.should == "output"
     end
 
     it "should raise a puppet parser error if executing config_version fails" do
       @code.environment.stubs(:[]).with(:config_version).returns("test")
-      Puppet::Util.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
+      Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
       lambda { @code.version }.should raise_error(Puppet::ParseError)
     end
+
   end
+
 end

data/spec/unit/resource/type_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/resource/type'
@@ -238,9 +238,10 @@ describe Puppet::Resource::Type do
 
   describe "when setting its parameters in the scope" do
     before do
-      @scope = Puppet::Parser::Scope.new(:compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("foo")), :source => stub("source"))
+      @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo")), :source => stub("source"))
       @resource = Puppet::Parser::Resource.new(:foo, "bar", :scope => @scope)
-      @type = Puppet::Resource::Type.new(:hostclass, "foo")
+      @type = Puppet::Resource::Type.new(:definition, "foo")
+      @resource.environment.known_resource_types.add @type
     end
 
     ['module_name', 'name', 'title'].each do |variable|
@@ -249,20 +250,20 @@ describe Puppet::Resource::Type do
         var = Puppet::Parser::AST::Variable.new({'value' => variable})
         @type.set_arguments :foo => var
         @type.set_resource_parameters(@resource, @scope)
-        @scope.lookupvar('foo').should == 'bar'
+        @scope['foo'].should == 'bar'
       end
     end
 
     # this test is to clarify a crazy edge case
     # if you specify these special names as params, the resource
     # will override the special variables
-    it "resource should override defaults" do
+    it "should allow the resource to override defaults" do
       @type.set_arguments :name => nil
       @resource[:name] = 'foobar'
       var = Puppet::Parser::AST::Variable.new({'value' => 'name'})
       @type.set_arguments :foo => var
       @type.set_resource_parameters(@resource, @scope)
-      @scope.lookupvar('foo').should == 'foobar'
+      @scope['foo'].should == 'foobar'
     end
 
     it "should set each of the resource's parameters as variables in the scope" do
@@ -272,8 +273,8 @@ describe Puppet::Resource::Type do
 
       @type.set_resource_parameters(@resource, @scope)
 
-      @scope.lookupvar("foo").should == "bar"
-      @scope.lookupvar("boo").should == "baz"
+      @scope['foo'].should == "bar"
+      @scope['boo'].should == "baz"
     end
 
     it "should set the variables as strings" do
@@ -282,7 +283,7 @@ describe Puppet::Resource::Type do
 
       @type.set_resource_parameters(@resource, @scope)
 
-      @scope.lookupvar("foo").should == "bar"
+      @scope['foo'].should == "bar"
     end
 
     it "should fail if any of the resource's parameters are not valid attributes" do
@@ -293,13 +294,13 @@ describe Puppet::Resource::Type do
     end
 
     it "should evaluate and set its default values as variables for parameters not provided by the resource" do
-      @type.set_arguments :foo => stub("value", :safeevaluate => "something")
+      @type.set_arguments :foo => Puppet::Parser::AST::String.new(:value => "something")
       @type.set_resource_parameters(@resource, @scope)
-      @scope.lookupvar("foo").should == "something"
+      @scope['foo'].should == "something"
     end
 
     it "should set all default values as parameters in the resource" do
-      @type.set_arguments :foo => stub("value", :safeevaluate => "something")
+      @type.set_arguments :foo => Puppet::Parser::AST::String.new(:value => "something")
 
       @type.set_resource_parameters(@resource, @scope)
 
@@ -308,7 +309,6 @@ describe Puppet::Resource::Type do
 
     it "should fail if the resource does not provide a value for a required argument" do
       @type.set_arguments :foo => nil
-      @resource.expects(:to_hash).returns({})
 
       lambda { @type.set_resource_parameters(@resource, @scope) }.should raise_error(Puppet::ParseError)
     end
@@ -316,13 +316,13 @@ describe Puppet::Resource::Type do
     it "should set the resource's title as a variable if not otherwise provided" do
       @type.set_resource_parameters(@resource, @scope)
 
-      @scope.lookupvar("title").should == "bar"
+      @scope['title'].should == "bar"
     end
 
     it "should set the resource's name as a variable if not otherwise provided" do
       @type.set_resource_parameters(@resource, @scope)
 
-      @scope.lookupvar("name").should == "bar"
+      @scope['name'].should == "bar"
     end
 
     it "should set its module name in the scope if available" do
@@ -330,7 +330,7 @@ describe Puppet::Resource::Type do
 
       @type.set_resource_parameters(@resource, @scope)
 
-      @scope.lookupvar("module_name").should == "mymod"
+      @scope["module_name"].should == "mymod"
     end
 
     it "should set its caller module name in the scope if available" do
@@ -338,21 +338,20 @@ describe Puppet::Resource::Type do
 
       @type.set_resource_parameters(@resource, @scope)
 
-      @scope.lookupvar("caller_module_name").should == "mycaller"
+      @scope["caller_module_name"].should == "mycaller"
     end
   end
 
   describe "when describing and managing parent classes" do
     before do
-      @code = Puppet::Resource::TypeCollection.new("env")
+      @krt = Puppet::Node::Environment.new.known_resource_types
       @parent = Puppet::Resource::Type.new(:hostclass, "bar")
-      @code.add @parent
+      @krt.add @parent
 
       @child = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
-      @code.add @child
+      @krt.add @child
 
-      @env   = stub "environment", :known_resource_types => @code
-      @scope = stub "scope", :environment => @env, :namespaces => [""]
+      @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo")))
     end
 
     it "should be able to define a parent" do
@@ -365,16 +364,16 @@ describe Puppet::Resource::Type do
 
     it "should be able to find parent nodes" do
       parent = Puppet::Resource::Type.new(:node, "bar")
-      @code.add parent
+      @krt.add parent
       child = Puppet::Resource::Type.new(:node, "foo", :parent => "bar")
-      @code.add child
+      @krt.add child
 
       child.parent_type(@scope).should equal(parent)
     end
 
     it "should cache a reference to the parent type" do
-      @code.stubs(:hostclass).with("foo::bar").returns nil
-      @code.expects(:hostclass).with("bar").once.returns @parent
+      @krt.stubs(:hostclass).with("foo::bar").returns nil
+      @krt.expects(:hostclass).with("bar").once.returns @parent
       @child.parent_type(@scope)
       @child.parent_type
     end
@@ -386,7 +385,7 @@ describe Puppet::Resource::Type do
 
     it "should be considered the child of a parent's parent" do
       @grandchild = Puppet::Resource::Type.new(:hostclass, "baz", :parent => "foo")
-      @code.add @grandchild
+      @krt.add @grandchild
 
       @child.parent_type(@scope)
       @grandchild.parent_type(@scope)
@@ -396,7 +395,7 @@ describe Puppet::Resource::Type do
 
     it "should correctly state when it is not another type's child" do
       @notchild = Puppet::Resource::Type.new(:hostclass, "baz")
-      @code.add @notchild
+      @krt.add @notchild
 
       @notchild.should_not be_child_of(@parent)
     end
@@ -405,15 +404,14 @@ describe Puppet::Resource::Type do
   describe "when evaluating its code" do
     before do
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-      @scope = Puppet::Parser::Scope.new :compiler => @compiler
-      @resource = Puppet::Parser::Resource.new(:foo, "yay", :scope => @scope)
+      @scope = Puppet::Parser::Scope.new @compiler
+      @resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope)
 
       # This is so the internal resource lookup works, yo.
       @compiler.catalog.add_resource @resource
 
-      @known_resource_types = stub 'known_resource_types'
-      @resource.stubs(:known_resource_types).returns @known_resource_types
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
+      @resource.environment.known_resource_types.add @type
     end
 
     it "should add hostclass names to the classes list" do
@@ -571,7 +569,7 @@ describe Puppet::Resource::Type do
     before do
       @node = Puppet::Node.new("foo", :environment => 'env')
       @compiler = Puppet::Parser::Compiler.new(@node)
-      @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+      @scope = Puppet::Parser::Scope.new(@compiler)
 
       @top = Puppet::Resource::Type.new :hostclass, "top"
       @middle = Puppet::Resource::Type.new :hostclass, "middle", :parent => "top"

data/spec/unit/resource_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/resource'
 
@@ -109,10 +109,6 @@ describe Puppet::Resource do
       to raise_error ArgumentError, /Puppet::Resource.new does not take a hash/
   end
 
-  it "should be able to produce a backward-compatible reference array" do
-    Puppet::Resource.new("foobar", "/f").to_trans_ref.should == %w{Foobar /f}
-  end
-
   it "should be taggable" do
     Puppet::Resource.ancestors.should be_include(Puppet::Util::Tagging)
   end
@@ -270,6 +266,132 @@ describe Puppet::Resource do
     Puppet::Resource.new("file", "/foo").should_not == Puppet::Resource.new("file", "/f")
   end
 
+  describe "when setting default parameters" do
+    before do
+      @scope = mock "Scope"
+      @scope.stubs(:source).returns(nil)
+    end
+
+    it "should fail when asked to set default values and it is not a parser resource" do
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "default")})
+      )
+      resource = Puppet::Resource.new("default_param", "name")
+      lambda { resource.set_default_parameters(@scope) }.should raise_error(Puppet::DevError)
+    end
+
+    it "should evaluate and set any default values when no value is provided" do
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "a_default_value")})
+      )
+      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))))
+      resource.set_default_parameters(@scope)
+      resource["a"].should == "a_default_value"
+    end
+
+    it "should skip attributes with no default value" do
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "a_default_value")})
+      )
+      resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))))
+      lambda { resource.set_default_parameters(@scope) }.should_not raise_error
+    end
+
+    it "should return the list of default parameters set" do
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "a_default_value")})
+      )
+      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))))
+      resource.set_default_parameters(@scope).should == [:a]
+    end
+
+    describe "when the resource type is :hostclass" do
+      let(:environmnet_name) { "testing env" }
+      let(:fact_values) { { :a => 1 } }
+      let(:port) { Puppet::Parser::AST::String.new(:value => '80') }
+      let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
+
+      before do
+        environment = Puppet::Node::Environment.new(environmnet_name)
+        environment.known_resource_types.add(apache)
+
+        @scope.stubs(:host).returns('host')
+        @scope.stubs(:environment).returns(Puppet::Node::Environment.new(environmnet_name))
+        @scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
+      end
+
+      context "when no value is provided" do
+        let(:resource) do
+          Puppet::Parser::Resource.new("class", "apache", :scope => @scope)
+        end
+
+        it "should query the data_binding terminus using a namespaced key" do
+          Puppet::DataBinding.indirection.expects(:find).with(
+            'apache::port', :host => 'host', :environment => environmnet_name, :facts => fact_values)
+          resource.set_default_parameters(@scope)
+        end
+
+        it "should use the value from the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).returns('443')
+          resource.set_default_parameters(@scope).should == [:port]
+          resource[:port].should == '443'
+        end
+
+        it "should use the default value if the data_binding terminus returns nil" do
+          Puppet::DataBinding.indirection.expects(:find).returns(nil)
+          resource.set_default_parameters(@scope).should == [:port]
+          resource[:port].should == '80'
+        end
+      end
+
+      context "when a value is provided" do
+        let(:port_parameter) do
+          Puppet::Parser::Resource::Param.new(
+            { :name => 'port', :value => '8080' }
+          )
+        end
+
+        let(:resource) do
+          Puppet::Parser::Resource.new("class", "apache", :scope => @scope,
+            :parameters => [port_parameter])
+        end
+
+        it "should not query the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).never
+          resource.set_default_parameters(@scope)
+        end
+
+        it "should use the value provided" do
+          Puppet::DataBinding.indirection.expects(:find).never
+          resource.set_default_parameters(@scope).should == []
+          resource[:port].should == '8080'
+        end
+      end
+    end
+  end
+
+  describe "when validating all required parameters are present" do
+    it "should be able to validate that all required parameters are present" do
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new(:definition, "required_param", :arguments => {"a" => nil})
+      )
+      lambda { Puppet::Resource.new("required_param", "name").validate_complete }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should not fail when all required parameters are present" do
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new(:definition, "no_required_param")
+      )
+      resource = Puppet::Resource.new("no_required_param", "name")
+      resource["a"] = "meh"
+      lambda { resource.validate_complete }.should_not raise_error
+    end
+
+    it "should not validate against builtin types" do
+      lambda { Puppet::Resource.new("file", "/bar").validate_complete }.should_not raise_error
+    end
+  end
+
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
@@ -444,11 +566,41 @@ describe Puppet::Resource do
       @resource["two"] = "other"
     end
 
+    it "should be able to be dumped to yaml" do
+      expect { YAML.dump(@resource) }.to_not raise_error
+    end
+
     it "should produce an equivalent yaml object" do
-      text = @resource.render('yaml')
+      text = YAML.dump(@resource)
 
-      newresource = Puppet::Resource.convert_from('yaml', text)
-      newresource.should equal_attributes_of @resource
+      newresource = YAML.load(text)
+      newresource.title.should == @resource.title
+      newresource.type.should == @resource.type
+      %w{one two}.each do |param|
+        newresource[param].should == @resource[param]
+      end
+    end
+  end
+
+  describe "when loading 0.25.x storedconfigs YAML" do
+    before :each do
+      @old_storedconfig_yaml = %q{--- !ruby/object:Puppet::Resource::Reference
+builtin_type:
+title: /tmp/bar
+type: File
+}
+    end
+
+    it "should deserialize a Puppet::Resource::Reference without exceptions" do
+      expect { YAML.load(@old_storedconfig_yaml) }.to_not raise_error
+    end
+
+    it "should deserialize as a Puppet::Resource::Reference as a Puppet::Resource" do
+      YAML.load(@old_storedconfig_yaml).class.should == Puppet::Resource
+    end
+
+    it "should to_hash properly" do
+      YAML.load(@old_storedconfig_yaml).to_hash.should == { :path => "/tmp/bar" }
     end
   end
 
@@ -480,7 +632,7 @@ describe Puppet::Resource do
       )
     end
 
-    it "should align, sort and add trailing commas to attributes with ensure first", :'fails_on_ruby_1.9.2' => true do
+    it "should align, sort and add trailing commas to attributes with ensure first" do
       @resource.to_manifest.should == <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
         one::two { '/my/file':
           ensure => 'present',
@@ -491,93 +643,6 @@ describe Puppet::Resource do
     end
   end
 
-  describe "when converting to a TransObject" do
-    describe "and the resource is not an instance of a builtin type" do
-      before do
-        @resource = Puppet::Resource.new("resource-spec-foo", "bar")
-      end
-
-      it "should return a simple TransBucket if it is not an instance of a builtin type" do
-        bucket = @resource.to_trans
-        bucket.should be_instance_of(Puppet::TransBucket)
-        bucket.type.should == @resource.type
-        bucket.name.should == @resource.title
-      end
-
-      it "should return a simple TransBucket if it is a stage" do
-        @resource = Puppet::Resource.new("stage", "bar")
-        bucket = @resource.to_trans
-        bucket.should be_instance_of(Puppet::TransBucket)
-        bucket.type.should == @resource.type
-        bucket.name.should == @resource.title
-      end
-
-      it "should copy over the resource's file" do
-        @resource.file = "/foo/bar"
-        @resource.to_trans.file.should == "/foo/bar"
-      end
-
-      it "should copy over the resource's line" do
-        @resource.line = 50
-        @resource.to_trans.line.should == 50
-      end
-    end
-
-    describe "and the resource is an instance of a builtin type" do
-      before do
-        @resource = Puppet::Resource.new("file", "bar")
-      end
-
-      it "should return a TransObject if it is an instance of a builtin resource type" do
-        trans = @resource.to_trans
-        trans.should be_instance_of(Puppet::TransObject)
-        trans.type.should == "file"
-        trans.name.should == @resource.title
-      end
-
-      it "should copy over the resource's file" do
-        @resource.file = "/foo/bar"
-        @resource.to_trans.file.should == "/foo/bar"
-      end
-
-      it "should copy over the resource's line" do
-        @resource.line = 50
-        @resource.to_trans.line.should == 50
-      end
-
-      # Only TransObjects support tags, annoyingly
-      it "should copy over the resource's tags" do
-        @resource.tag "foo"
-        @resource.to_trans.tags.should == @resource.tags
-      end
-
-      it "should copy the resource's parameters into the transobject and convert the parameter name to a string" do
-        @resource[:foo] = "bar"
-        @resource.to_trans["foo"].should == "bar"
-      end
-
-      it "should be able to copy arrays of values" do
-        @resource[:foo] = %w{yay fee}
-        @resource.to_trans["foo"].should == %w{yay fee}
-      end
-
-      it "should reduce single-value arrays to just a value" do
-        @resource[:foo] = %w{yay}
-        @resource.to_trans["foo"].should == "yay"
-      end
-
-      it "should convert resource references into the backward-compatible form" do
-        @resource[:foo] = Puppet::Resource.new(:file, "/f")
-        @resource.to_trans["foo"].should == %w{File /f}
-      end
-
-      it "should convert resource references into the backward-compatible form even when within arrays" do
-        @resource[:foo] = ["a", Puppet::Resource.new(:file, "/f")]
-        @resource.to_trans["foo"].should == ["a", %w{File /f}]
-      end
-    end
-  end
-
   describe "when converting to pson", :if => Puppet.features.pson? do
     def pson_output_should
       @resource.class.expects(:pson_create).with { |hash| yield hash }
@@ -623,13 +688,13 @@ describe Puppet::Resource do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported?.should be_true
+      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_true
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported?.should be_false
+      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_false
     end
 
     it "should set all of its parameters as the 'parameters' entry" do