diff --git a/lib/puppet/util/tagging.rb b/lib/puppet/util/tagging.rb
index 0da22f5e5..0eb0096fe 100644
--- a/lib/puppet/util/tagging.rb
+++ b/lib/puppet/util/tagging.rb
@@ -1,57 +1,57 @@
 require 'puppet/util/tag_set'
 
 module Puppet::Util::Tagging
   ValidTagRegex = /^\w[-\w:.]*$/
 
-  # Add a tag to the current tag set. 
+  # Add a tag to the current tag set.
   # When a tag set is used for a scope, these tags will be added to all of
   # the objects contained in this scope when the objects are finished.
   #
   def tag(*ary)
     @tags ||= new_tags
 
     ary.flatten.each do |tag|
       name = tag.to_s.downcase
       if name =~ ValidTagRegex
         @tags << name
         name.split("::").each do |section|
           fail(Puppet::ParseError, "Invalid tag ''") if section.empty?
           @tags << section
         end
       else
         fail(Puppet::ParseError, "Invalid tag '#{name}'")
       end
     end
   end
 
   # Is the receiver tagged with the given tags?
   def tagged?(*tags)
     not ( self.tags & tags.flatten.collect { |t| t.to_s } ).empty?
   end
 
   # Return a copy of the tag list, so someone can't ask for our tags
   # and then modify them.
   def tags
     @tags ||= new_tags
     @tags.dup
   end
 
   def tags=(tags)
     @tags = new_tags
 
     return if tags.nil? or tags == ""
 
     tags = tags.strip.split(/\s*,\s*/) if tags.is_a?(String)
     tags.each {|t| tag(t) }
   end
 
   private
 
   def valid_tag?(tag)
     tag.is_a?(String) and tag =~ ValidTagRegex
   end
 
   def new_tags
     Puppet::Util::TagSet.new
   end
 end
diff --git a/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index c68ed7cbd..6ce0b7d67 100755
--- a/spec/integration/parser/compiler_spec.rb
+++ b/spec/integration/parser/compiler_spec.rb
@@ -1,541 +1,541 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
 describe "Puppet::Parser::Compiler" do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :each do
     @node = Puppet::Node.new "testnode"
 
     @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
     @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
   end
 
   after do
     Puppet.settings.clear
   end
 
   # shared because tests are invoked both for classic and future parser
   #
   shared_examples_for "the compiler" do
     it "should be able to determine the configuration version from a local version control repository" do
       pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
         # This should always work, because we should always be
         # in the puppet repo when we run this.
         version = %x{git rev-parse HEAD}.chomp
 
         Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
         @parser = Puppet::Parser::ParserFactory.parser "development"
         @compiler = Puppet::Parser::Compiler.new(@node)
 
         @compiler.catalog.version.should == version
       end
     end
 
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       Puppet[:code] = <<-PP
         class foo
         {
           notify { foo_notify: }
           include bar
         }
         class bar
         {
           notify { bar_notify: }
         }
       PP
 
       @node.stubs(:classes).returns(['foo', 'bar'])
 
       catalog = Puppet::Parser::Compiler.compile(@node)
 
       catalog.resource("Notify[foo_notify]").should_not be_nil
       catalog.resource("Notify[bar_notify]").should_not be_nil
     end
 
     describe "when resolving class references" do
       it "should favor local scope, even if there's an included class in topscope" do
         Puppet[:code] = <<-PP
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
           }
           class baz {
           }
           include baz
           include experiment
           include experiment::baz
         PP
 
         catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
         notify_resource = catalog.resource( "Notify[x]" )
 
         notify_resource[:require].title.should == "Experiment::Baz"
       end
 
       it "should favor local scope, even if there's an unincluded class in topscope" do
         Puppet[:code] = <<-PP
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
           }
           class baz {
           }
           include experiment
           include experiment::baz
         PP
 
         catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
         notify_resource = catalog.resource( "Notify[x]" )
 
         notify_resource[:require].title.should == "Experiment::Baz"
       end
     end
     describe "(ticket #13349) when explicitly specifying top scope" do
       ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
         describe "with #{include}" do
           it "should find the top level class" do
             Puppet[:code] = <<-MANIFEST
               class { 'foo::test': }
               class foo::test {
               	#{include}
               }
               class bar::baz {
               	notify { 'good!': }
               }
               class foo::bar::baz {
               	notify { 'bad!': }
               }
             MANIFEST
 
             catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
             catalog.resource("Class[Bar::Baz]").should_not be_nil
             catalog.resource("Notify[good!]").should_not be_nil
             catalog.resource("Class[Foo::Bar::Baz]").should be_nil
             catalog.resource("Notify[bad!]").should be_nil
           end
         end
       end
     end
 
     it "should recompute the version after input files are re-parsed" do
       Puppet[:code] = 'class foo { }'
       Time.stubs(:now).returns(1)
       node = Puppet::Node.new('mynode')
       Puppet::Parser::Compiler.compile(node).version.should == 1
       Time.stubs(:now).returns(2)
       Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
       Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
       Puppet::Parser::Compiler.compile(node).version.should == 2
     end
 
     ['class', 'define', 'node'].each do |thing|
       it "should not allow '#{thing}' inside evaluated conditional constructs" do
         Puppet[:code] = <<-PP
           if true {
             #{thing} foo {
             }
             notify { decoy: }
           }
         PP
 
         begin
           Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
           raise "compilation should have raised Puppet::Error"
         rescue Puppet::Error => e
           e.message.should =~ /at line 2/
         end
       end
     end
 
     it "should not allow classes inside unevaluated conditional constructs" do
       Puppet[:code] = <<-PP
         if false {
           class foo {
           }
         }
       PP
 
       lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
     end
 
     describe "when defining relationships" do
       def extract_name(ref)
         ref.sub(/File\[(\w+)\]/, '\1')
       end
 
       let(:node) { Puppet::Node.new('mynode') }
       let(:code) do
         <<-MANIFEST
           file { [a,b,c]:
             mode => 0644,
           }
           file { [d,e]:
             mode => 0755,
           }
         MANIFEST
       end
       let(:expected_relationships) { [] }
       let(:expected_subscriptions) { [] }
 
       before :each do
         Puppet[:code] = code
       end
 
       after :each do
         catalog = Puppet::Parser::Compiler.compile(node)
 
         resources = catalog.resources.select { |res| res.type == 'File' }
 
         actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
           resources.map do |res|
             dependents = Array(res[relation])
             dependents.map { |ref| [res.title, extract_name(ref)] }
           end.inject(&:concat)
         end
 
         actual_relationships.should =~ expected_relationships
         actual_subscriptions.should =~ expected_subscriptions
       end
 
       it "should create a relationship" do
         code << "File[a] -> File[b]"
 
         expected_relationships << ['a','b']
       end
 
       it "should create a subscription" do
         code << "File[a] ~> File[b]"
 
         expected_subscriptions << ['a', 'b']
       end
 
       it "should create relationships using title arrays" do
         code << "File[a,b] -> File[c,d]"
 
         expected_relationships.concat [
           ['a', 'c'],
           ['b', 'c'],
           ['a', 'd'],
           ['b', 'd'],
         ]
       end
 
       it "should create relationships using collection expressions" do
         code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
 
         expected_relationships.concat [
           ['a', 'd'],
           ['b', 'd'],
           ['c', 'd'],
           ['a', 'e'],
           ['b', 'e'],
           ['c', 'e'],
         ]
       end
 
       it "should create relationships using resource names" do
         code << "'File[a]' -> 'File[b]'"
 
         expected_relationships << ['a', 'b']
       end
 
       it "should create relationships using variables" do
         code << <<-MANIFEST
           $var = File[a]
           $var -> File[b]
         MANIFEST
 
         expected_relationships << ['a', 'b']
       end
 
       it "should create relationships using case statements" do
         code << <<-MANIFEST
           $var = 10
           case $var {
             10: {
               file { s1: }
             }
             12: {
               file { s2: }
             }
           }
           ->
           case $var + 2 {
             10: {
               file { t1: }
             }
             12: {
               file { t2: }
             }
           }
         MANIFEST
 
         expected_relationships << ['s1', 't2']
       end
 
       it "should create relationships using array members" do
         code << <<-MANIFEST
           $var = [ [ [ File[a], File[b] ] ] ]
           $var[0][0][0] -> $var[0][0][1]
         MANIFEST
 
         expected_relationships << ['a', 'b']
       end
 
       it "should create relationships using hash members" do
         code << <<-MANIFEST
           $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
           $var[foo][bar][source] -> $var[foo][bar][target]
         MANIFEST
 
         expected_relationships << ['a', 'b']
       end
 
       it "should create relationships using resource declarations" do
         code << "file { l: } -> file { r: }"
 
         expected_relationships << ['l', 'r']
       end
 
       it "should chain relationships" do
         code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
 
         expected_relationships << ['a', 'b'] << ['d', 'c']
         expected_subscriptions << ['b', 'c'] << ['e', 'd']
       end
     end
 
     context 'when working with immutable node data' do
       context 'and have opted in to immutable_node_data' do
         before :each do
           Puppet[:immutable_node_data] = true
         end
 
         def node_with_facts(facts)
           Puppet[:facts_terminus] = :memory
           Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new("testing", facts))
           node = Puppet::Node.new("testing")
           node.fact_merge
           node
         end
 
         matcher :fail_compile_with do |node, message_regex|
           match do |manifest|
             @error = nil
             begin
               compile_to_catalog(manifest, node)
               false
             rescue Puppet::Error => e
               @error = e
               message_regex.match(e.message)
             end
           end
 
           failure_message_for_should do
             if @error
               "failed with #{@error}\n#{@error.backtrace}"
             else
               "did not fail"
             end
           end
         end
 
         it 'should make $facts available' do
           node = node_with_facts('the_facts' => 'straight')
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
            notify { 'test': message => $facts[the_facts] }
           MANIFEST
 
           catalog.resource("Notify[test]")[:message].should == "straight"
         end
 
         it 'should make $facts reserved' do
           node = node_with_facts('the_facts' => 'straight')
 
           expect('$facts = {}').to fail_compile_with(node, /assign to a reserved variable name: 'facts'/)
           expect('class a { $facts = {} } include a').to fail_compile_with(node, /assign to a reserved variable name: 'facts'/)
         end
 
         it 'should make $facts immutable' do
           node = node_with_facts('string' => 'value', 'array' => ['string'], 'hash' => { 'a' => 'string' }, 'number' => 1, 'boolean' => true)
 
           expect('$i=inline_template("<% @facts[%q{new}] = 2 %>")').to fail_compile_with(node, /frozen Hash/i)
           expect('$i=inline_template("<% @facts[%q{string}].chop! %>")').to fail_compile_with(node, /frozen String/i)
 
           expect('$i=inline_template("<% @facts[%q{array}][0].chop! %>")').to fail_compile_with(node, /frozen String/i)
           expect('$i=inline_template("<% @facts[%q{array}][1] = 2 %>")').to fail_compile_with(node, /frozen Array/i)
 
           expect('$i=inline_template("<% @facts[%q{hash}][%q{a}].chop! %>")').to fail_compile_with(node, /frozen String/i)
           expect('$i=inline_template("<% @facts[%q{hash}][%q{b}] = 2 %>")').to fail_compile_with(node, /frozen Hash/i)
         end
 
         it 'should make $facts available even if there are no facts' do
           Puppet[:facts_terminus] = :memory
           node = Puppet::Node.new("testing2")
           node.fact_merge
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => $facts }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, {})
         end
       end
 
       context 'and have not opted in to immutable_node_data' do
         before :each do
           Puppet[:immutable_node_data] = false
         end
 
         it 'should not make $facts available' do
          Puppet[:facts_terminus] = :memory
          facts = Puppet::Node::Facts.new("testing", 'the_facts' => 'straight')
          Puppet::Node::Facts.indirection.save(facts)
          node = Puppet::Node.new("testing")
          node.fact_merge
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => "An $facts space" }
           MANIFEST
 
           catalog.resource("Notify[test]")[:message].should == "An  space"
         end
       end
     end
 
     context 'when working with the trusted data hash' do
       context 'and have opted in to trusted_node_data' do
         before :each do
           Puppet[:trusted_node_data] = true
         end
 
         it 'should make $trusted available' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => $trusted[data] }
           MANIFEST
 
           catalog.resource("Notify[test]")[:message].should == "value"
         end
 
         it 'should not allow assignment to $trusted' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           expect do
             catalog = compile_to_catalog(<<-MANIFEST, node)
               $trusted = 'changed'
               notify { 'test': message => $trusted == 'changed' }
             MANIFEST
             catalog.resource("Notify[test]")[:message].should == true
           end.to raise_error(Puppet::Error, /Attempt to assign to a reserved variable name: 'trusted'/)
         end
 
         it 'should not allow addition to $trusted hash' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           expect do
             catalog = compile_to_catalog(<<-MANIFEST, node)
               $trusted['extra'] = 'added'
               notify { 'test': message => $trusted['extra'] == 'added' }
             MANIFEST
             catalog.resource("Notify[test]")[:message].should == true
             # different errors depending on regular or future parser
           end.to raise_error(Puppet::Error, /(can't modify frozen [hH]ash)|(Illegal attempt to assign)/)
         end
 
         it 'should not allow addition to $trusted hash via Ruby inline template' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           expect do
             catalog = compile_to_catalog(<<-MANIFEST, node)
             $dummy = inline_template("<% @trusted['extra'] = 'added' %> lol")
               notify { 'test': message => $trusted['extra'] == 'added' }
             MANIFEST
             catalog.resource("Notify[test]")[:message].should == true
           end.to raise_error(Puppet::Error, /can't modify frozen [hH]ash/)
         end
       end
 
       context 'and have not opted in to trusted_node_data' do
         before :each do
           Puppet[:trusted_node_data] = false
         end
 
         it 'should not make $trusted available' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => $trusted == undef }
           MANIFEST
 
           catalog.resource("Notify[test]")[:message].should == true
         end
 
         it 'should allow assignment to $trusted' do
           node = Puppet::Node.new("testing")
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             $trusted = 'changed'
             notify { 'test': message => $trusted == 'changed' }
           MANIFEST
 
           catalog.resource("Notify[test]")[:message].should == true
         end
       end
     end
 
     context 'when evaluating collection' do
       it 'matches on container inherited tags' do
         Puppet[:code] = <<-MANIFEST
         class xport_test {
           tag 'foo_bar'
           @notify { 'nbr1':
             message => 'explicitly tagged',
             tag => 'foo_bar'
           }
 
           @notify { 'nbr2':
             message => 'implicitly tagged'
           }
 
           Notify <| tag == 'foo_bar' |> {
             message => 'overridden'
           }
         }
         include xport_test
         MANIFEST
 
         catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
-        expect(catalog.resource("Notify[nbr1]")['message']).to eql('overridden')
-        expect(catalog.resource("Notify[nbr2]")['message']).to eql('overridden')
+        expect(catalog).to have_resource("Notify[nbr1]").with_parameter(:message, 'overridden')
+        expect(catalog).to have_resource("Notify[nbr2]").with_parameter(:message, 'overridden')
       end
     end
   end
 
   describe 'using classic parser' do
     before :each do
       Puppet[:parser] = 'current'
     end
     it_behaves_like 'the compiler' do
     end
   end
 end