puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/provider/service/openbsd_spec.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+#
+# Unit testing for the OpenBSD service provider
+
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:openbsd)
+
+describe provider_class do
+  before :each do
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    Facter.stubs(:value).with(:operatingsystem).returns :openbsd
+  end
+
+  let :rcscripts do
+    [
+     'apmd',
+     'aucat',
+     'cron',
+     'puppetd'
+   ]
+  end
+
+  describe "#instances" do
+    it "should have an instances method" do
+      described_class.should respond_to :instances
+    end
+
+    it "should list all available services" do
+      FileTest.expects(:directory?).with('/etc/rc.d').returns true
+      Dir.expects(:entries).with('/etc/rc.d').returns rcscripts
+
+      rcscripts.each do |script|
+        FileTest.expects(:executable?).with("/etc/rc.d/#{script}").returns true
+      end
+
+      described_class.instances.map(&:name).should == [
+        'apmd',
+        'aucat',
+        'cron',
+        'puppetd'
+      ]
+    end
+  end
+
+  describe "#start" do
+    it "should use the supplied start command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.start
+    end
+
+    it "should start the service otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.start
+    end
+  end
+
+  describe "#stop" do
+    it "should use the supplied stop command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.stop
+    end
+
+    it "should stop the service otherwise" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.stop
+    end
+  end
+
+  describe "#status" do
+    it "should use the status command from the resource" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+      provider.status
+    end
+
+      it "should return :stopped when status command returns with a non-zero exitcode" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
+        provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 3
+        provider.status.should == :stopped
+      end
+
+      it "should return :running when status command returns with a zero exitcode" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
+        provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.status.should == :running
+      end
+  end
+
+  describe "#restart" do
+    it "should use the supplied restart command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.restart
+    end
+
+    it "should restart the service with rc-service restart if hasrestart is true" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.restart
+    end
+
+    it "should restart the service with rc-service stop/start if hasrestart is false" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => true).never
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
+      provider.restart
+    end
+  end
+end

data/spec/unit/provider/service/openwrt_spec.rb

@@ -33,7 +33,7 @@ describe Puppet::Type.type(:service).provider(:openwrt), :as_platform => :posix
     # All OpenWrt tests operate on the init script directly. It must exist.
     File.stubs(:directory?).with('/etc/init.d').returns true
 
-    File.stubs(:exist?).with('/etc/init.d/myservice').returns true
+    Puppet::FileSystem::File.stubs(:exist?).with('/etc/init.d/myservice').returns true
     FileTest.stubs(:file?).with('/etc/init.d/myservice').returns true
     FileTest.stubs(:executable?).with('/etc/init.d/myservice').returns true
   end

data/spec/unit/provider/service/runit_spec.rb

@@ -96,18 +96,25 @@ describe provider_class do
   end
 
   describe "when enabling" do
-    it "should create a symlink between daemon dir and service dir" do
-      FileTest.stubs(:symlink?).returns(false)
-      File.expects(:symlink).with(File.join(@daemondir,"myservice"), File.join(@servicedir,"myservice")).returns(0)
+    it "should create a symlink between daemon dir and service dir", :if => Puppet.features.manages_symlinks? do
+      daemon_path = File.join(@daemondir,"myservice")
+      mock_daemon = mock(daemon_path)
+      Puppet::FileSystem::File.expects(:new).with(daemon_path).returns(mock_daemon)
+      service_path = File.join(@servicedir,"myservice")
+      mock_service = mock(service_path, :symlink? => false)
+      Puppet::FileSystem::File.expects(:new).with(service_path).returns(mock_service)
+      mock_daemon.expects(:symlink).with(File.join(@servicedir,"myservice")).returns(0)
       @provider.enable
     end
   end
 
   describe "when disabling" do
     it "should remove the '/etc/service/myservice' symlink" do
+      path = File.join(@servicedir,"myservice")
+      mocked_file = mock(path, :symlink? => true)
       FileTest.stubs(:directory?).returns(false)
-      FileTest.stubs(:symlink?).returns(true)
-      File.expects(:unlink).with(File.join(@servicedir,"myservice")).returns(0)
+      Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
+      Puppet::FileSystem::File.expects(:unlink).with(path).returns(0)
       @provider.disable
     end
   end

data/spec/unit/provider/service/upstart_spec.rb

@@ -51,8 +51,8 @@ describe Puppet::Type.type(:service).provider(:upstart) do
   describe "#search" do
     it "searches through paths to find a matching conf file" do
       File.stubs(:directory?).returns(true)
-      File.stubs(:exists?).returns(false)
-      File.expects(:exists?).with("/etc/init/foo-bar.conf").returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.expects(:exist?).with("/etc/init/foo-bar.conf").returns(true)
       resource = Puppet::Type.type(:service).new(:name => "foo-bar", :provider => :upstart)
       provider = provider_class.new(resource)
 
@@ -61,8 +61,8 @@ describe Puppet::Type.type(:service).provider(:upstart) do
 
     it "searches for just the name of a compound named service" do
       File.stubs(:directory?).returns(true)
-      File.stubs(:exists?).returns(false)
-      File.expects(:exists?).with("/etc/init/network-interface.conf").returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.expects(:exist?).with("/etc/init/network-interface.conf").returns(true)
       resource = Puppet::Type.type(:service).new(:name => "network-interface INTERFACE=lo", :provider => :upstart)
       provider = provider_class.new(resource)
 

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -162,7 +162,7 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should create the directory" do
-        File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
+        Puppet::FileSystem::File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
         Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
         @provider.flush
       end
@@ -199,19 +199,19 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should create the directory if it doesn't exist" do
-        File.stubs(:exist?).with(@dir).returns false
+        Puppet::FileSystem::File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).with(@dir,0700)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
-        File.stubs(:exist?).with(@dir).returns false
+        Puppet::FileSystem::File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         @provider.flush
       end
 
       it "should absolutely not chown the directory to the user if it creates it" do
-        File.stubs(:exist?).with(@dir).returns false
+        Puppet::FileSystem::File.stubs(:exist?).with(@dir).returns false
         Dir.stubs(:mkdir).with(@dir,0700)
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).never
@@ -219,7 +219,7 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
       end
 
       it "should not create or chown the directory if it already exist" do
-        File.stubs(:exist?).with(@dir).returns false
+        Puppet::FileSystem::File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         File.expects(:chown).never
         @provider.flush

data/spec/unit/provider/user/directoryservice_spec.rb

@@ -704,7 +704,7 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     let(:stub_password_file) { stub('connection') }
 
     it 'should return a sha1 hash read from disk' do
-      File.expects(:exists?).with(password_hash_file).returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with(password_hash_file).returns(true)
       File.expects(:file?).with(password_hash_file).returns(true)
       File.expects(:readable?).with(password_hash_file).returns(true)
       File.expects(:new).with(password_hash_file).returns(stub_password_file)
@@ -714,18 +714,18 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     end
 
     it 'should return nil if the password_hash_file does not exist' do
-      File.expects(:exists?).with(password_hash_file).returns(false)
+      Puppet::FileSystem::File.expects(:exist?).with(password_hash_file).returns(false)
       provider.class.get_sha1('user_guid').should == nil
     end
 
     it 'should return nil if the password_hash_file is not a file' do
-      File.expects(:exists?).with(password_hash_file).returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with(password_hash_file).returns(true)
       File.expects(:file?).with(password_hash_file).returns(false)
       provider.class.get_sha1('user_guid').should == nil
     end
 
     it 'should raise an error if the password_hash_file is not readable' do
-      File.expects(:exists?).with(password_hash_file).returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with(password_hash_file).returns(true)
       File.expects(:file?).with(password_hash_file).returns(true)
       File.expects(:readable?).with(password_hash_file).returns(false)
       expect { provider.class.get_sha1('user_guid').should == nil }.to raise_error Puppet::Error, /Could not read password hash file at #{password_hash_file}/

data/spec/unit/provider/zone/solaris_spec.rb

@@ -138,7 +138,7 @@ net:
     it "should not require path if sysidcfg is specified" do
       resource[:path] = '/mypath'
       resource[:sysidcfg] = 'dummy'
-      File.stubs(:exists?).with('/mypath/root/etc/sysidcfg').returns true
+      Puppet::FileSystem::File.stubs(:exist?).with('/mypath/root/etc/sysidcfg').returns true
       File.stubs(:directory?).with('/mypath/root/etc').returns true
       provider.expects(:zoneadm).with(:boot)
       provider.start

data/spec/unit/provider_spec.rb

@@ -349,10 +349,10 @@ describe Puppet::Provider do
       command = Puppet::Util.which('sh') || Puppet::Util.which('cmd.exe')
       parent.commands :sh => command
 
-      FileTest.should be_exists parent.command(:sh)
+      Puppet::FileSystem::File.exist?(parent.command(:sh)).should be_true
       parent.command(:sh).should =~ /#{Regexp.escape(command)}$/
 
-      FileTest.should be_exists child.command(:sh)
+      Puppet::FileSystem::File.exist?(child.command(:sh)).should be_true
       child.command(:sh).should =~ /#{Regexp.escape(command)}$/
     end
 

data/spec/unit/reports/http_spec.rb

@@ -15,65 +15,50 @@ describe processor 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 "configures the connection for ssl when using https" do
+      Puppet[:reporturl] = 'https://testing:8080/the/path'
 
-    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)
+      Puppet::Network::HttpPool.expects(:http_instance).with(
+        'testing', 8080, true
       ).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)
+    it "does not configure the connectino for ssl when using http" do
+      Puppet[:reporturl] = "http://testing:8080/the/path"
+
+      Puppet::Network::HttpPool.expects(:http_instance).with(
+        'testing', 8080, false
       ).returns http
-      http.expects(:use_ssl=).with(false)
+
       subject.process
     end
   end
 
   describe "when making a request" do
-    let(:http) { stub_everything "http" }
+    let(:connection) { stub_everything "connection" }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
-      Net::HTTP.expects(:new).returns(http)
+      Puppet::Network::HttpPool.expects(:http_instance).returns(connection)
     end
 
     it "should use the path specified by the 'reporturl' setting" do
-      http.expects(:post).with {|path, data, headers|
-        path.should == URI.parse(Puppet[:reporturl]).path
-      }.returns(httpok)
+      report_path = URI.parse(Puppet[:reporturl]).path
+      connection.expects(:post).with(report_path, anything, anything).returns(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      http.expects(:post).with {|path, data, headers|
-        data.should == subject.to_yaml
-      }.returns(httpok)
+      connection.expects(:post).with(anything, subject.to_yaml, anything).returns(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      http.expects(:post).with {|path, data, headers|
-        headers["Content-Type"].should == "application/x-yaml"
-      }.returns(httpok)
+      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml")).returns(httpok)
 
       subject.process
     end
@@ -82,7 +67,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(:post).returns(response)
+          connection.expects(:post).returns(response)
 
           Puppet.expects(:err).never
           subject.process
@@ -92,7 +77,7 @@ describe processor do
       if code.to_i >= 300 && ![301, 302, 307].include?(code.to_i)
         it "should log error on http code #{code}" do
           response = klass.new('1.1', code, '')
-          http.expects(:post).returns(response)
+          connection.expects(:post).returns(response)
 
           Puppet.expects(:err)
           subject.process

data/spec/unit/reports/store_spec.rb

@@ -47,7 +47,7 @@ describe processor do
 
     it "rejects invalid hostnames" do
       @report.host = ".."
-      FileTest.expects(:exists?).never
+      Puppet::FileSystem::File.expects(:exist?).never
       Tempfile.expects(:new).never
       expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
@@ -55,7 +55,7 @@ describe processor do
 
   describe "::destroy" do
     it "rejects invalid hostnames" do
-      File.expects(:unlink).never
+      Puppet::FileSystem::File.expects(:unlink).never
       expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end

data/spec/unit/resource/catalog_spec.rb

@@ -1,5 +1,18 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/compiler'
+
+# the json-schema gem doesn't support windows
+if not Puppet.features.microsoft_windows?
+  CATALOG_SCHEMA = JSON.parse(File.read(File.join(File.dirname(__FILE__), '../../../api/schemas/catalog.json')))
+
+  describe "catalog schema" do
+    it "should validate against the json meta-schema" do
+      JSON::Validator.validate!(JSON_META_SCHEMA, CATALOG_SCHEMA)
+    end
+  end
+
+end
 
 describe Puppet::Resource::Catalog, "when compiling" do
   include PuppetSpec::Files
@@ -86,26 +99,28 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one")
-      config.tags.should == %w{one}
+      config.should be_tagged("one")
     end
 
     it "should accept multiple tags at once" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one", "two")
-      config.tags.should == %w{one two}
+      config.should be_tagged("one")
+      config.should be_tagged("two")
     end
 
     it "should convert all tags to strings" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one", :two)
-      config.tags.should == %w{one two}
+      config.should be_tagged("one")
+      config.should be_tagged("two")
     end
 
     it "should tag with both the qualified name and the split name" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.tag("one::two")
-      config.tags.include?("one").should be_true
-      config.tags.include?("one::two").should be_true
+      config.should be_tagged("one")
+      config.should be_tagged("one::two")
     end
 
     it "should accept classes" do
@@ -119,7 +134,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should tag itself with passed class names" do
       config = Puppet::Resource::Catalog.new("mynode")
       config.add_class("one")
-      config.tags.should == %w{one}
+      config.should be_tagged("one")
     end
   end
 
@@ -204,12 +219,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(:copy_as_resource).returns(@r1)
       @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(:copy_as_resource).returns(@r2)
       @r2.stubs(:is_a?).with(Puppet::Resource).returns(true)
 
       @resources = [@r1,@r2]
@@ -720,6 +735,60 @@ describe Puppet::Resource::Catalog, "when compiling" do
   end
 end
 
+describe Puppet::Resource::Catalog, "when converting a resource catalog to pson" do
+  include PuppetSpec::Compiler
+
+  def validate_json_for_catalog(catalog)
+    JSON::Validator.validate!(CATALOG_SCHEMA, catalog.to_pson)
+  end
+
+  it "should validate an empty catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    empty_catalog = compile_to_catalog("")
+    validate_json_for_catalog(empty_catalog)
+  end
+
+  it "should validate a noop catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    noop_catalog = compile_to_catalog("create_resources('file', {})")
+    validate_json_for_catalog(noop_catalog)
+  end
+
+  it "should validate a single resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
+    validate_json_for_catalog(catalog)
+  end
+
+  it "should validate a virtual resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
+    validate_json_for_catalog(catalog)
+  end
+
+  it "should validate a single exported resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
+    validate_json_for_catalog(catalog)
+  end
+
+  it "should validate a two resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
+    validate_json_for_catalog(catalog)
+  end
+
+  it "should validate a two parameter class catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class multi_param_class ($one, $two) {
+        notify {'foo':
+          message => "One is $one, two is $two",
+        }
+      }
+
+      class {'multi_param_class':
+        one => 'hello',
+        two => 'world',
+      }
+    MANIFEST
+    validate_json_for_catalog(catalog)
+  end
+end
+
 describe Puppet::Resource::Catalog, "when converting to pson" do
   before do
     @catalog = Puppet::Resource::Catalog.new("myhost")
@@ -742,11 +811,11 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
     PSON.parse @catalog.to_pson
   end
 
-  [:name, :version, :tags, :classes].each do |param|
+  [:name, :version, :classes].each do |param|
     it "should set its #{param} to the #{param} of the resource" do
       @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
 
-      pson_output_should { |hash| hash['data'][param.to_s] == @catalog.send(param) }
+      pson_output_should { |hash| hash['data'][param.to_s].should == @catalog.send(param) }
       PSON.parse @catalog.to_pson
     end
   end
@@ -815,7 +884,8 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
   it "should set any provided tags on the catalog" do
     @data['tags'] = %w{one two}
     PSON.parse @pson.to_pson
-    @catalog.tags.should == @data['tags']
+    @catalog.should be_tagged("one")
+    @catalog.should be_tagged("two")
   end
 
   it "should set any provided classes on the catalog" do