puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/puppet_spec.rb

@@ -1,22 +1,34 @@
-#!/usr/bin/env rspec"
-
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet'
 require 'puppet_spec/files'
-require 'semver'
 
 describe Puppet do
   include PuppetSpec::Files
 
-  context "#version" do
-    it "should be valid semver" do
-      SemVer.should be_valid Puppet.version
-    end
-  end
-
   Puppet::Util::Log.eachlevel do |level|
     it "should have a method for sending '#{level}' logs" do
       Puppet.should respond_to(level)
     end
   end
+
+  it "should be able to change the path" do
+    newpath = ENV["PATH"] + File::PATH_SEPARATOR + "/something/else"
+    Puppet[:path] = newpath
+    ENV["PATH"].should == newpath
+  end
+
+  it "should change $LOAD_PATH when :libdir changes" do
+    one = tmpdir('load-path-one')
+    two = tmpdir('load-path-two')
+    one.should_not == two
+
+    Puppet[:libdir] = one
+    $LOAD_PATH.should include one
+    $LOAD_PATH.should_not include two
+
+    Puppet[:libdir] = two
+    $LOAD_PATH.should_not include one
+    $LOAD_PATH.should include two
+  end
 end

data/spec/unit/rails/host_spec.rb

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

data/spec/unit/rails/param_value_spec.rb

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

data/spec/unit/rails/resource_spec.rb

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

data/spec/unit/rails_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/rails'
 
@@ -29,8 +29,8 @@ describe Puppet::Rails, "when initializing any connection", :if => Puppet.featur
 
   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")
+    Puppet[:rails_loglevel] = "debug"
+    Puppet[:railslog] = "/my/file"
     logger = mock 'logger'
     Logger.stubs(:new).returns(logger)
     ActiveRecord::Base.stubs(:logger).returns(logger)
@@ -76,14 +76,14 @@ end
 
 describe Puppet::Rails, "when initializing a sqlite3 connection", :if => Puppet.features.rails? do
   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[:dbadapter] = "sqlite3"
+    Puppet[:rails_loglevel] = "testlevel"
+    Puppet[:dblocation] = File.expand_path("testlocation")
 
     Puppet::Rails.database_arguments.should == {
       :adapter   => "sqlite3",
       :log_level => "testlevel",
-      :database  => "testlocation"
+      :database  => File.expand_path("testlocation")
     }
   end
 end
@@ -91,15 +91,15 @@ end
 ['mysql','mysql2','postgresql'].each do |dbadapter|
   describe Puppet::Rails, "when initializing a #{dbadapter} connection", :if => Puppet.features.rails? do
     it "should provide the adapter, log_level, and host, port, username, password, database, and reconnect arguments" do
-      Puppet.settings.stubs(:value).with(:dbadapter).returns(dbadapter)
-      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[:dbadapter] = dbadapter
+      Puppet[:rails_loglevel] = "testlevel"
+      Puppet[:dbserver] = "testserver"
+      Puppet[:dbport] = ""
+      Puppet[:dbuser] = "testuser"
+      Puppet[:dbpassword] = "testpassword"
+      Puppet[:dbconnections] = (pool_size = 45).to_s
+      Puppet[:dbname] = "testname"
+      Puppet[:dbsocket] = ""
 
       Puppet::Rails.database_arguments.should == {
         :adapter => dbadapter,
@@ -114,15 +114,15 @@ end
     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(dbadapter)
-      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[:dbadapter] = dbadapter
+      Puppet[:rails_loglevel] = "testlevel"
+      Puppet[:dbserver] = "testserver"
+      Puppet[:dbport] = "9999"
+      Puppet[:dbuser] = "testuser"
+      Puppet[:dbpassword] = "testpassword"
+      Puppet[:dbconnections] = (pool_size = 12).to_s
+      Puppet[:dbname] = "testname"
+      Puppet[:dbsocket] = "testsocket"
 
       Puppet::Rails.database_arguments.should == {
         :adapter => dbadapter,
@@ -139,15 +139,15 @@ end
     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(dbadapter)
-      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[:dbadapter] = dbadapter
+      Puppet[:rails_loglevel] = "testlevel"
+      Puppet[:dbserver] = "testserver"
+      Puppet[:dbport] = "9999"
+      Puppet[:dbuser] = "testuser"
+      Puppet[:dbpassword] = "testpassword"
+      Puppet[:dbconnections] = (pool_size = 23).to_s
+      Puppet[:dbname] = "testname"
+      Puppet[:dbsocket] = "testsocket"
 
       Puppet::Rails.database_arguments.should == {
         :adapter => dbadapter,
@@ -164,22 +164,22 @@ end
     end
 
     it "should not provide the pool if dbconnections is 0, '0', or ''" do
-      Puppet.settings.stubs(:value).with(:dbadapter).returns(dbadapter)
-      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[:dbadapter] = dbadapter
+      Puppet[:rails_loglevel] = "testlevel"
+      Puppet[:dbserver] = "testserver"
+      Puppet[:dbport] = "9999"
+      Puppet[:dbuser] = "testuser"
+      Puppet[:dbpassword] = "testpassword"
+      Puppet[:dbname] = "testname"
+      Puppet[:dbsocket] = "testsocket"
+
+      Puppet[:dbconnections] = 0
       Puppet::Rails.database_arguments.should_not be_include(:pool)
 
-      Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
+      Puppet[:dbconnections] = '0'
       Puppet::Rails.database_arguments.should_not be_include(:pool)
 
-      Puppet.settings.stubs(:value).with(:dbconnections).returns('')
+      Puppet[:dbconnections] = ''
       Puppet::Rails.database_arguments.should_not be_include(:pool)
     end
   end
@@ -187,12 +187,12 @@ end
 
 describe Puppet::Rails, "when initializing an Oracle connection", :if => Puppet.features.rails? do
   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[:dbadapter] = "oracle_enhanced"
+    Puppet[:rails_loglevel] = "testlevel"
+    Puppet[:dbuser] = "testuser"
+    Puppet[:dbpassword] = "testpassword"
+    Puppet[:dbconnections] = (pool_size = 123).to_s
+    Puppet[:dbname] = "testname"
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
@@ -205,12 +205,12 @@ describe Puppet::Rails, "when initializing an Oracle connection", :if => Puppet.
   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[:dbadapter] = "oracle_enhanced"
+    Puppet[:rails_loglevel] = "testlevel"
+    Puppet[:dbuser] = "testuser"
+    Puppet[:dbpassword] = "testpassword"
+    Puppet[:dbconnections] = (pool_size = 124).to_s
+    Puppet[:dbname] = "testname"
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
@@ -223,22 +223,22 @@ describe Puppet::Rails, "when initializing an Oracle connection", :if => Puppet.
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
-    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[:dbadapter] = "oracle_enhanced"
+    Puppet[:rails_loglevel] = "testlevel"
+    Puppet[:dbserver] = "testserver"
+    Puppet[:dbport] = "9999"
+    Puppet[:dbuser] = "testuser"
+    Puppet[:dbpassword] = "testpassword"
+    Puppet[:dbname] = "testname"
+    Puppet[:dbsocket] = "testsocket"
+
+    Puppet[:dbconnections] = 0
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
-    Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
+    Puppet[:dbconnections] = '0'
     Puppet::Rails.database_arguments.should_not be_include(:pool)
 
-    Puppet.settings.stubs(:value).with(:dbconnections).returns('')
+    Puppet[:dbconnections] = ''
     Puppet::Rails.database_arguments.should_not be_include(:pool)
   end
 end

data/spec/unit/relationship_spec.rb

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

data/spec/unit/reports/http_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/reports'
 
@@ -7,39 +7,72 @@ processor = Puppet::Reports.report(:http)
 describe processor do
   subject { Puppet::Transaction::Report.new("apply").extend(processor) }
 
-  it "should use the reporturl setting's host and port" do
-    uri = URI.parse(Puppet[:reporturl])
-    Net::HTTP.expects(:new).with(uri.host, uri.port).returns(stub_everything('http'))
-    subject.process
+  describe "when setting up the connection" do
+    let(:http) { stub_everything "http" }
+    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+
+    before :each do
+      http.expects(:post).returns(httpok)
+    end
+
+    it "should use the reporturl setting's host, port and ssl option" do
+      uri = URI.parse(Puppet[:reporturl])
+      ssl = (uri.scheme == 'https')
+      Net::HTTP.expects(:new).with(
+        uri.host, uri.port, optionally(anything, anything)
+      ).returns http
+      http.expects(:use_ssl=).with(ssl)
+      subject.process
+    end
+
+    it "uses ssl if reporturl has the https protocol" do
+      Puppet[:reporturl] = "https://myhost.mydomain:1234/report/upload"
+      uri = URI.parse(Puppet[:reporturl])
+      Net::HTTP.expects(:new).with(
+        uri.host, uri.port, optionally(anything, anything)
+      ).returns http
+      http.expects(:use_ssl=).with(true)
+      subject.process
+    end
+
+    it "does not use ssl if reporturl has plain http protocol" do
+      Puppet[:reporturl] = "http://myhost.mydomain:1234/report/upload"
+      uri = URI.parse(Puppet[:reporturl])
+      Net::HTTP.expects(:new).with(
+        uri.host, uri.port, optionally(anything, anything)
+      ).returns http
+      http.expects(:use_ssl=).with(false)
+      subject.process
+    end
   end
 
   describe "when making a request" do
-    let(:http) { mock "http" }
+    let(:http) { stub_everything "http" }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
-      Net::HTTP.any_instance.expects(:start).yields(http)
+      Net::HTTP.expects(:new).returns(http)
     end
 
     it "should use the path specified by the 'reporturl' setting" do
-      http.expects(:request).with {|req|
-        req.path.should == URI.parse(Puppet[:reporturl]).path
+      http.expects(:post).with {|path, data, headers|
+        path.should == URI.parse(Puppet[:reporturl]).path
       }.returns(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      http.expects(:request).with {|req|
-        req.body.should == subject.to_yaml
+      http.expects(:post).with {|path, data, headers|
+        data.should == subject.to_yaml
       }.returns(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      http.expects(:request).with {|req|
-        req.content_type.should == "application/x-yaml"
+      http.expects(:post).with {|path, data, headers|
+        headers["Content-Type"].should == "application/x-yaml"
       }.returns(httpok)
 
       subject.process
@@ -49,7 +82,7 @@ describe processor do
       if code.to_i >= 200 and code.to_i < 300
         it "should succeed on http code #{code}" do
           response = klass.new('1.1', code, '')
-          http.expects(:request).returns(response)
+          http.expects(:post).returns(response)
 
           Puppet.expects(:err).never
           subject.process
@@ -59,7 +92,7 @@ describe processor do
       if code.to_i >= 300
         it "should log error on http code #{code}" do
           response = klass.new('1.1', code, '')
-          http.expects(:request).returns(response)
+          http.expects(:post).returns(response)
 
           Puppet.expects(:err)
           subject.process

data/spec/unit/reports/rrdgraph_spec.rb

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

data/spec/unit/reports/store_spec.rb

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

data/spec/unit/reports/tagmail_spec.rb

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

data/spec/unit/reports_spec.rb

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

data/spec/unit/resource/catalog_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog, "when compiling" do
@@ -60,10 +60,10 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     @catalog.add_class "foo", "bar"
 
-    Puppet.settings.expects(:value).with(:classfile).returns "/class/file"
+    Puppet[:classfile] = File.expand_path("/class/file")
 
     fh = mock 'filehandle'
-    File.expects(:open).with("/class/file", "w").yields fh
+    File.expects(:open).with(Puppet[:classfile], "w").yields fh
 
     fh.expects(:puts).with "foo\nbar"
 
@@ -123,165 +123,6 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
   end
 
-  describe "when extracting transobjects" do
-
-    def mkscope
-      @node = Puppet::Node.new("mynode")
-      @compiler = Puppet::Parser::Compiler.new(@node)
-
-      # XXX This is ridiculous.
-      @compiler.send(:evaluate_main)
-      @scope = @compiler.topscope
-    end
-
-    def mkresource(type, name)
-      Puppet::Parser::Resource.new(type, name, :source => @source, :scope => @scope)
-    end
-
-    it "should fail if no 'main' stage can be found" do
-      lambda { Puppet::Resource::Catalog.new("mynode").extract }.should raise_error(Puppet::DevError)
-    end
-
-    it "should warn if any non-main stages are present" do
-      config = Puppet::Resource::Catalog.new("mynode")
-
-      @scope = mkscope
-      @source = mock 'source'
-
-      main = mkresource("stage", "main")
-      config.add_resource(main)
-
-      other = mkresource("stage", "other")
-      config.add_resource(other)
-
-      Puppet.expects(:warning)
-
-      config.extract
-    end
-
-    it "should always create a TransBucket for the 'main' stage" do
-      config = Puppet::Resource::Catalog.new("mynode")
-
-      @scope = mkscope
-      @source = mock 'source'
-
-      main = mkresource("stage", "main")
-      config.add_resource(main)
-
-      result = config.extract
-      result.type.should == "Stage"
-      result.name.should == "main"
-    end
-
-    # Now try it with a more complicated graph -- a three tier graph, each tier
-    it "should transform arbitrarily deep graphs into isomorphic trees" do
-      config = Puppet::Resource::Catalog.new("mynode")
-
-      @scope = mkscope
-      @scope.stubs(:tags).returns([])
-      @source = mock 'source'
-
-      # Create our scopes.
-      top = mkresource "stage", "main"
-
-      config.add_resource top
-      topbucket = []
-      topbucket.expects(:classes=).with([])
-      top.expects(:to_trans).returns(topbucket)
-      topres = mkresource "file", "/top"
-      topres.expects(:to_trans).returns(:topres)
-      config.add_edge top, topres
-
-      middle = mkresource "class", "middle"
-      middle.expects(:to_trans).returns([])
-      config.add_edge top, middle
-      midres = mkresource "file", "/mid"
-      midres.expects(:to_trans).returns(:midres)
-      config.add_edge middle, midres
-
-      bottom = mkresource "class", "bottom"
-      bottom.expects(:to_trans).returns([])
-      config.add_edge middle, bottom
-      botres = mkresource "file", "/bot"
-      botres.expects(:to_trans).returns(:botres)
-      config.add_edge bottom, botres
-
-      toparray = config.extract
-
-      # This is annoying; it should look like:
-      #   [[[:botres], :midres], :topres]
-      # but we can't guarantee sort order.
-      toparray.include?(:topres).should be_true
-
-      midarray = toparray.find { |t| t.is_a?(Array) }
-      midarray.include?(:midres).should be_true
-      botarray = midarray.find { |t| t.is_a?(Array) }
-      botarray.include?(:botres).should be_true
-    end
-  end
-
-  describe " when converting to a Puppet::Resource catalog" do
-    before do
-      @original = Puppet::Resource::Catalog.new("mynode")
-      @original.tag(*%w{one two three})
-      @original.add_class *%w{four five six}
-
-      @top            = Puppet::TransObject.new 'top', "class"
-      @topobject      = Puppet::TransObject.new '/topobject', "file"
-      @middle         = Puppet::TransObject.new 'middle', "class"
-      @middleobject   = Puppet::TransObject.new '/middleobject', "file"
-      @bottom         = Puppet::TransObject.new 'bottom', "class"
-      @bottomobject   = Puppet::TransObject.new '/bottomobject', "file"
-
-      @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject]
-
-      @original.add_resource(*@resources)
-
-      @original.add_edge(@top, @topobject)
-      @original.add_edge(@top, @middle)
-      @original.add_edge(@middle, @middleobject)
-      @original.add_edge(@middle, @bottom)
-      @original.add_edge(@bottom, @bottomobject)
-
-      @catalog = @original.to_resource
-    end
-
-    it "should copy over the version" do
-      @original.version = "foo"
-      @original.to_resource.version.should == "foo"
-    end
-
-    it "should convert parser resources to plain resources" do
-      resource = Puppet::Parser::Resource.new(:file, "foo", :scope => stub("scope", :environment => nil, :namespaces => nil), :source => stub("source"))
-      catalog = Puppet::Resource::Catalog.new("whev")
-      catalog.add_resource(resource)
-      new = catalog.to_resource
-      new.resource(:file, "foo").class.should == Puppet::Resource
-    end
-
-    it "should add all resources as Puppet::Resource instances" do
-      @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Resource) }
-    end
-
-    it "should copy the tag list to the new catalog" do
-      @catalog.tags.sort.should == @original.tags.sort
-    end
-
-    it "should copy the class list to the new catalog" do
-      @catalog.classes.should == @original.classes
-    end
-
-    it "should duplicate the original edges" do
-      @original.edges.each do |edge|
-        @catalog.edge?(@catalog.resource(edge.source.ref), @catalog.resource(edge.target.ref)).should be_true
-      end
-    end
-
-    it "should set itself as the catalog for each converted resource" do
-      @catalog.vertices.each { |v| v.catalog.object_id.should equal(@catalog.object_id) }
-    end
-  end
-
   describe "when converting to a RAL catalog" do
     before do
       @original = Puppet::Resource::Catalog.new("mynode")
@@ -337,7 +178,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     # This tests #931.
     it "should not lose track of resources whose names vary" do
-      changer = Puppet::TransObject.new 'changer', 'test'
+      changer = Puppet::Resource.new :file, @basepath+'/test/', :parameters => {:ensure => :directory}
 
       config = Puppet::Resource::Catalog.new('test')
       config.add_resource(changer)
@@ -345,16 +186,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
       config.add_edge(@top, changer)
 
-      resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
-
-      #changer is going to get duplicated as part of a fix for aliases 1094
-      changer.expects(:dup).returns(changer)
-      changer.expects(:to_ral).returns(resource)
-
-      newconfig = nil
-
-      proc { @catalog = config.to_ral }.should_not raise_error
-      @catalog.resource("Test[changer2]").should equal(resource)
+      catalog = config.to_ral
+      catalog.resource("File[#{@basepath}/test/]").must equal(catalog.resource("File[#{@basepath}/test]"))
     end
 
     after do
@@ -372,12 +205,12 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @r1 = stub_everything 'r1', :ref => "File[/a]"
       @r1.stubs(:respond_to?).with(:ref).returns(true)
       @r1.stubs(:dup).returns(@r1)
-      @r1.stubs(:is_a?).returns(Puppet::Resource).returns(true)
+      @r1.stubs(:is_a?).with(Puppet::Resource).returns(true)
 
       @r2 = stub_everything 'r2', :ref => "File[/b]"
       @r2.stubs(:respond_to?).with(:ref).returns(true)
       @r2.stubs(:dup).returns(@r2)
-      @r2.stubs(:is_a?).returns(Puppet::Resource).returns(true)
+      @r2.stubs(:is_a?).with(Puppet::Resource).returns(true)
 
       @resources = [@r1,@r2]