puppet 3.3.2 → 3.4.0.rc1

data/lib/puppet/util/windows/security_descriptor.rb

@@ -0,0 +1,62 @@
+# Windows Security Descriptor
+#
+# Represents a security descriptor that can be applied to any Windows securable
+# object, e.g. file, registry key, service, etc. It consists of an owner, group,
+# flags, DACL, and SACL. The SACL is not currently supported, though it has the
+# same layout as a DACL.
+#
+# @see http://msdn.microsoft.com/en-us/library/windows/desktop/aa379563(v=vs.85).aspx
+# @api private
+class Puppet::Util::Windows::SecurityDescriptor
+  require 'puppet/util/windows/security'
+  include Puppet::Util::Windows::SID
+
+  attr_reader :owner, :group, :dacl
+  attr_accessor :protect
+
+  # Construct a security descriptor
+  #
+  # @param owner [String] The SID of the owner, e.g. 'S-1-5-18'
+  # @param group [String] The SID of the group
+  # @param dacl [AccessControlList] The ACL specifying the rights granted to
+  # each user for accessing the object that the security descriptor refers to.
+  # @param protect [Boolean] If true, then inheritable access control
+  # entries will be blocked, and not applied to the object.
+  def initialize(owner, group, dacl, protect = false)
+    @owner = owner
+    @group = group
+    @dacl = dacl
+    @protect = protect
+  end
+
+  # Set the owner. Non-inherited access control entries assigned to the
+  # current owner will be assigned to the new owner.
+  #
+  # @param new_owner [String] The SID of the new owner, e.g. 'S-1-5-18'
+  def owner=(new_owner)
+    if @owner != new_owner
+      @dacl.reassign!(@owner, new_owner)
+      @owner = new_owner
+    end
+  end
+
+  # Set the group. Non-inherited access control entries assigned to the
+  # current group will be assigned to the new group.
+  #
+  # @param new_group [String] The SID of the new group, e.g. 'S-1-0-0'
+  def group=(new_group)
+    if @group != new_group
+      @dacl.reassign!(@group, new_group)
+      @group = new_group
+    end
+  end
+
+  def inspect
+    str = sid_to_name(owner)
+    str << "\n"
+    str << sid_to_name(group)
+    str << "\n"
+    str << @dacl.inspect
+    str
+  end
+end

data/lib/puppet/util/windows/sid.rb

@@ -20,17 +20,39 @@ module Puppet::Util::Windows
     # 'BUILTIN\Administrators', or 'S-1-5-32-544', and will return the
     # SID. Returns nil if the account doesn't exist.
     def name_to_sid(name)
+      sid = name_to_sid_object(name)
+
+      sid ? sid.to_s : nil
+    end
+
+    # Convert an account name, e.g. 'Administrators' into a SID object,
+    # e.g. 'S-1-5-32-544'. The name can be specified as 'Administrators',
+    # 'BUILTIN\Administrators', or 'S-1-5-32-544', and will return the
+    # SID object. Returns nil if the account doesn't exist.
+    def name_to_sid_object(name)
       # Apparently, we accept a symbol..
-      name = name.to_s if name
+      name = name.to_s.strip if name
 
-      # if it's in SID string form, return it, otherwise, lookup sid
-      is_sid = Win32::Security::SID.string_to_sid(name) rescue nil
+      # if it's in SID string form, convert to user
+      parsed_sid = Win32::Security::SID.string_to_sid(name) rescue nil
 
-      is_sid ? name : Win32::Security::SID.new(name).to_s
+      parsed_sid ? Win32::Security::SID.new(parsed_sid) : Win32::Security::SID.new(name)
     rescue
       nil
     end
 
+    # Converts an octet string array of bytes to a SID object,
+    # e.g. [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0] is the representation for
+    # S-1-5-18, the local 'SYSTEM' account.
+    # Raises an Error for nil or non-array input.
+    def octet_string_to_sid_object(bytes)
+      if !bytes || !bytes.respond_to?('pack') || bytes.empty?
+        raise Puppet::Util::Windows::Error.new("Octet string must be an array of bytes")
+      end
+
+      Win32::Security::SID.new(bytes.pack('C*'))
+    end
+
     # Convert a SID string, e.g. "S-1-5-32-544" to a name,
     # e.g. 'BUILTIN\Administrators'. Returns nil if an account
     # for that SID does not exist.

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.3.2'
+  PUPPETVERSION = '3.4.0-rc1'
 
   ##
   # version is a public API method intended to always provide a fast and
@@ -81,7 +81,7 @@ module Puppet
   # @return [String] for example: "1.6.14-6-gea42046" or nil if the VERSION
   #   file does not exist.
   def self.read_version_file(path)
-    if File.exists?(path)
+    if File.exist?(path)
       File.read(path).chomp
     end
   end

data/spec/fixtures/releases/jamtur01-apache/lib/puppet/provider/a2mod/debian.rb

@@ -16,6 +16,6 @@ Puppet::Type.type(:a2mod).provide(:debian) do
 
     def exists?
         mod= "/etc/apache2/mods-enabled/" + resource[:name] + ".load"
-        File.exists?(mod)
+        Puppet::FileSystem::File.exist?(mod)
     end
 end

data/spec/fixtures/unit/indirector/data_binding/hiera/invalid.yaml

@@ -0,0 +1 @@
+{ invalid:

data/spec/fixtures/unit/module/trailing-comma.json

@@ -0,0 +1,24 @@
+{
+    "name": "puppetlabs/ruby",
+    "version": "0.0.2",
+    "summary": "Manage Ruby",
+    "source": "git@github.com/puppetlabs/puppetlabs-ruby.git",
+    "project_page": "http://github.com/puppetlabs/puppetlabs-ruby",
+    "author": "Puppet Labs",
+    "license": "Apache-2.0",
+    "operatingsystem_support": [
+        "RedHat",
+        "OpenSUSE",
+        "SLES",
+        "SLED",
+        "Debian",
+        "Ubuntu"
+    ],
+    "puppet_version": [
+        2.7,
+        3.0,
+        3.1,
+        3.2,
+        3.3,
+    ],
+}

data/spec/fixtures/unit/util/monkey_patches/x509.pem

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFmTCCA4GgAwIBAgIQea0WoUqgpa1Mc1j0BxMuZTANBgkqhkiG9w0BAQUFADBf
+MRMwEQYKCZImiZPyLGQBGRYDY29tMRkwFwYKCZImiZPyLGQBGRYJbWljcm9zb2Z0
+MS0wKwYDVQQDEyRNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkw
+HhcNMDEwNTA5MjMxOTIyWhcNMjEwNTA5MjMyODEzWjBfMRMwEQYKCZImiZPyLGQB
+GRYDY29tMRkwFwYKCZImiZPyLGQBGRYJbWljcm9zb2Z0MS0wKwYDVQQDEyRNaWNy
+b3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQDzXfqAZ9Rap6kMLJAg0DUIPHWEzbcHiZyJ2t7Ow2D6
+kWhanpRxKRh2fMLgyCV2lA5Y+gQ0Nubfr/eAuulYCyuT5Z0F43cikfc0ZDwikR1e
+4QmQvBT+/HVYGeF5tweSo66IWQjYnwfKA1j8aCltMtfSqMtL/OELSDJP5uu4rU/k
+XG8TlJnbldV126gat5SRtHdb9UgMj2p5fRRwBH1tr5D12nDYR7e/my9s5wW34RFg
+rHmRFHzF1qbk4X7Vw37lktI8ALU2gt554W3ztW74nzPJy1J9c5g224uha6KVl5uj
+3sJNJv8GlmclBsjnrOTuEjOVMZnINQhONMp5U9W1vmMyWUA2wKVOBE0921sHM+RY
+v+8/U2TYQlk1V/0PRXwkBE2e1jh0EZcikM5oRHSSb9VLb7CG48c2QqDQ/MHAWvmj
+YbkwR3GWChawkcBCle8Qfyhq4yofseTNAz93cQTHIPxJDx1FiKTXy36IrY4t7EXb
+xFEEySr87IaemhGXW97OU4jm4rf9rJXCKEDb7wSQ34EzOdmyRaUjhwalVYkxuwYt
+YA5BGH0fLrWXyxHrFdUkpZTvFRSJ/Utz+jJb/NEzAPlZYnAHMuouq0Ate8rdIWcb
+MJmPFqojqEHRsG4RmzbE3kB0nOFYZcFgHnpbOMiPuwQmfNQWQOW2a2yqhv0Av87B
+NQIDAQABo1EwTzALBgNVHQ8EBAMCAcYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQUDqyCYEBWJ5flJRP8KuEKU5VZ5KQwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZI
+hvcNAQEFBQADggIBAMURTQM6YN1dUhF3j7K7NsiyBb+0t6jYIJ1cEwO2HCL6BhM1
+tshj1JpHbyZX0lXxBLEmX9apUGigvNK4bszD6azfGc14rFl0rGY0NsQbPmw4TDMO
+MBINoyb+UVMA/69aToQNDx/kbQUuToVLjWwzb1TSZKu/UK99ejmgN+1jAw/8EwbO
+FjbUVDuVG1FiOuVNF9QFOZKaJ6hbqr3su77jIIlgcWxWs6UT0G0OI36VA+1oPfLY
+Y7hrTbboMLXhypRL96KqXZkwsj2nwlFsKCABJCcrSwC3nRFrcL6yEIK8DJto0I07
+JIeqmShynTNfWZC99d6TnjpiWjQ54ohVHbkGsMGJay3XacMZEjaE0Mmg2v8vaXiy
+5Xra69cMwPe9Yxe4ORM4ojZbe/KFVmodZGLBOOKqv1FmopT1EpxmIhBr8rcwki3y
+KfA9OxRDaKLxnCk3y844ICVtfGfzfiQSJAMIgUfspZ6X9RjXz7vV73aW7/3O21ad
+laBC+ZdY4dcxItNfWeY+biIA6kOEtiXb2fMIVmjAZGsdfOy2k6JiV24u2OdYj8Qx
+SSbd3ik1h/UwcXBbFDxpvYkSfesuo/7Yf56CWlIKK8FDK9kwiJ/IEPuJjeahhXUz
+fmye23MTZGJppS99ypZtn/gETTCSPW4hFCHJPeDD/YprnUr90aGdmUN3P7Da
+-----END CERTIFICATE-----

data/spec/integration/application/apply_spec.rb

@@ -26,7 +26,7 @@ describe "apply" do
 
       puppet.apply
 
-      File.should be_exist(file_to_create)
+      Puppet::FileSystem::File.exist?(file_to_create).should be_true
       File.read(file_to_create).should == "my stuff"
     end
   end

data/spec/integration/application/doc_spec.rb

@@ -40,7 +40,7 @@ describe Puppet::Application::Doc do
 
       expect { puppet.run_command }.to exit_with 0
 
-      File.should be_exist('doc')
+      Puppet::FileSystem::File.exist?('doc').should be_true
     ensure
       Dir.chdir(old_dir)
     end

data/spec/integration/configurer_spec.rb

@@ -9,7 +9,9 @@ describe Puppet::Configurer do
   describe "when downloading plugins" do
     it "should use the :pluginsignore setting, split on whitespace, for ignoring remote files" do
       resource = Puppet::Type.type(:notify).new :name => "yay"
-      Puppet::Type.type(:file).expects(:new).with { |args| args[:ignore] == Puppet[:pluginsignore].split(/\s+/) }.returns resource
+      Puppet::Type.type(:file).expects(:new).at_most(2).with do |args|
+        args[:ignore] == Puppet[:pluginsignore].split(/\s+/)
+      end.returns resource
 
       configurer = Puppet::Configurer.new
       configurer.stubs(:download_plugins?).returns true
@@ -59,7 +61,7 @@ describe Puppet::Configurer do
 
       file_mode = Puppet.features.microsoft_windows? ? '100644' : '100666'
 
-      File.stat(Puppet[:lastrunfile]).mode.to_s(8).should == file_mode
+      Puppet::FileSystem::File.new(Puppet[:lastrunfile]).stat.mode.to_s(8).should == file_mode
 
       summary = nil
       File.open(Puppet[:lastrunfile], "r") do |fd|

data/spec/integration/data_binding.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+
+describe "Data binding" do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+
+  let(:dir) { tmpdir("puppetdir") }
+
+  before do
+    Puppet[:data_binding_terminus] = "hiera"
+    Puppet[:modulepath] = dir
+  end
+
+  it "looks up data from hiera" do
+    configure_hiera_for({
+      "testing::binding::value" => "the value",
+      "testing::binding::calling_class" => "%{calling_class}",
+      "testing::binding::calling_module" => "%{calling_module}"
+    })
+
+    create_manifest_in_module("testing", "binding.pp",
+                              <<-MANIFEST)
+    class testing::binding($value,
+                           $calling_class,
+                           $calling_module) {}
+    MANIFEST
+
+    catalog = compile_to_catalog("include testing::binding")
+    resource = catalog.resource('Class[testing::binding]')
+
+    expect(resource[:value]).to eq("the value")
+    expect(resource[:calling_class]).to eq("testing::binding")
+    expect(resource[:calling_module]).to eq("testing")
+  end
+
+  it "works with the puppet backend configured, although it can't use it for lookup" do
+    configure_hiera_for_puppet
+    create_manifest_in_module("testing", "binding.pp",
+                              <<-MANIFEST)
+    # lookup via the puppet backend to ensure it works
+    class testing::binding($value = hiera('variable')) {}
+    MANIFEST
+
+    create_manifest_in_module("testing", "data.pp",
+                              <<-MANIFEST)
+    class testing::data {
+      $variable = "the value"
+    }
+    MANIFEST
+
+    catalog = compile_to_catalog("include testing::binding")
+    resource = catalog.resource('Class[testing::binding]')
+
+    expect(resource[:value]).to eq("the value")
+  end
+
+  def configure_hiera_for(data)
+    hiera_config_file = tmpfile("hiera.yaml")
+
+    File.open(hiera_config_file, 'w') do |f|
+      f.write("---
+        :yaml:
+          :datadir: #{dir}
+        :hierarchy: ['global']
+        :logger: 'noop'
+        :backends: ['yaml']
+      ")
+    end
+
+    File.open(File.join(dir, 'global.yaml'), 'w') do |f|
+      f.write(YAML.dump(data))
+    end
+
+    Puppet[:hiera_config] = hiera_config_file
+  end
+
+  def configure_hiera_for_puppet
+    hiera_config_file = tmpfile("hiera.yaml")
+
+    File.open(hiera_config_file, 'w') do |f|
+      f.write("---
+        :logger: 'noop'
+        :backends: ['puppet']
+      ")
+    end
+
+    Puppet[:hiera_config] = hiera_config_file
+  end
+
+  def create_manifest_in_module(module_name, name, manifest)
+    module_dir = File.join(dir, module_name, 'manifests')
+    FileUtils.mkdir_p(module_dir)
+
+    File.open(File.join(module_dir, name), 'w') do |f|
+      f.write(manifest)
+    end
+  end
+end

data/spec/integration/indirector/catalog/compiler_spec.rb

@@ -32,33 +32,36 @@ describe Puppet::Resource::Catalog::Compiler do
   end
 
   it "should filter out virtual resources when finding a catalog" do
-    @one.virtual = true
-    request = stub 'request', :name => "mynode"
+    Puppet[:node_terminus] = :memory
+    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
     Puppet::Resource::Catalog.indirection.terminus.stubs(:extract_facts_from_request)
-    Puppet::Resource::Catalog.indirection.terminus.stubs(:node_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:compile).returns(@catalog)
 
-    Puppet::Resource::Catalog.indirection.find(request).resource_refs.should == [ @two.ref ]
+    @one.virtual = true
+
+    Puppet::Resource::Catalog.indirection.find("mynode").resource_refs.should == [ @two.ref ]
   end
 
   it "should not filter out exported resources when finding a catalog" do
-    @one.exported = true
-    request = stub 'request', :name => "mynode"
+    Puppet[:node_terminus] = :memory
+    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
     Puppet::Resource::Catalog.indirection.terminus.stubs(:extract_facts_from_request)
-    Puppet::Resource::Catalog.indirection.terminus.stubs(:node_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:compile).returns(@catalog)
 
-    Puppet::Resource::Catalog.indirection.find(request).resource_refs.sort.should == [ @one.ref, @two.ref ]
+    @one.exported = true
+
+    Puppet::Resource::Catalog.indirection.find("mynode").resource_refs.sort.should == [ @one.ref, @two.ref ]
   end
 
   it "should filter out virtual exported resources when finding a catalog" do
-    @one.exported = true
-    @one.virtual = true
-    request = stub 'request', :name => "mynode"
+    Puppet[:node_terminus] = :memory
+    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
     Puppet::Resource::Catalog.indirection.terminus.stubs(:extract_facts_from_request)
-    Puppet::Resource::Catalog.indirection.terminus.stubs(:node_from_request)
     Puppet::Resource::Catalog.indirection.terminus.stubs(:compile).returns(@catalog)
 
-    Puppet::Resource::Catalog.indirection.find(request).resource_refs.should == [ @two.ref ]
+    @one.exported = true
+    @one.virtual = true
+
+    Puppet::Resource::Catalog.indirection.find("mynode").resource_refs.should == [ @two.ref ]
   end
 end

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Indirector::DirectFileServer, " when interacting with the files
 
   it "should return an instance of the model" do
     pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-      FileTest.expects(:exists?).with(@filepath).returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with(@filepath).returns(true)
 
       @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}", nil)).should be_instance_of(Puppet::FileServing::Content)
     end
@@ -23,11 +23,9 @@ describe Puppet::Indirector::DirectFileServer, " when interacting with the files
 
   it "should return an instance capable of returning its content" do
     pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-      FileTest.expects(:exists?).with(@filepath).returns(true)
-      File.stubs(:lstat).with(@filepath).returns(stub("stat", :ftype => "file"))
-      IO.expects(:binread).with(@filepath).returns("my content")
+      filename = file_containing("testfile", "my content")
 
-      instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}", nil))
+      instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{filename}", nil))
 
       instance.content.should == "my content"
     end

data/spec/integration/indirector/file_content/file_server_spec.rb

@@ -59,8 +59,8 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
   end
 
   it "should find file content in files when node name expansions are used" do
-    FileTest.stubs(:exists?).returns true
-    FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).returns true
+    Puppet::FileSystem::File.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = tmpfile("file_server_testing")
 

data/spec/integration/node/facts_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Node::Facts do
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
 
       terminus.expects(:path).with("me").returns "/my/yaml/file"
-      FileTest.expects(:exist?).with("/my/yaml/file").returns false
+      Puppet::FileSystem::File.expects(:exist?).with("/my/yaml/file").returns false
 
       Puppet::Node::Facts.indirection.find("me").should be_nil
     end

data/spec/integration/node_spec.rb

@@ -21,7 +21,7 @@ describe Puppet::Node do
 
       terminus.expects(:path).with(@name).returns "/my/yaml/file"
 
-      FileTest.expects(:exist?).with("/my/yaml/file").returns false
+      Puppet::FileSystem::File.expects(:exist?).with("/my/yaml/file").returns false
       Puppet::Node.indirection.find(@name).should be_nil
     end
 

data/spec/integration/parser/compiler_spec.rb

@@ -1,8 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/parser/parser_factory'
+require 'puppet_spec/compiler'
 
 describe "Puppet::Parser::Compiler" do
+  include PuppetSpec::Compiler
+
   before :each do
     @node = Puppet::Node.new "testnode"
 
@@ -310,6 +313,93 @@ describe "Puppet::Parser::Compiler" do
         expected_subscriptions << ['b', 'c'] << ['e', 'd']
       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
   end
 
   describe 'using classic parser' do