puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/man/man8/puppet-queue.8

@@ -1,55 +0,0 @@
-.\" generated with Ronn/v0.7.3
-.\" http://github.com/rtomayko/ronn/tree/0.7.3
-.
-.TH "PUPPET\-QUEUE" "8" "January 2013" "Puppet Labs, LLC" "Puppet manual"
-.
-.SH "NAME"
-\fBpuppet\-queue\fR \- Queuing daemon for asynchronous storeconfigs
-.
-.SH "SYNOPSIS"
-Retrieves serialized storeconfigs records from a queue and processes them in order\.
-.
-.SH "USAGE"
-puppet queue [\-d|\-\-debug] [\-v|\-\-verbose]
-.
-.SH "DESCRIPTION"
-This application runs as a daemon and processes storeconfigs data, retrieving the data from a stomp server message queue and writing it to a database\.
-.
-.P
-For more information, including instructions for properly setting up your puppet master and message queue, see the documentation on setting up asynchronous storeconfigs at: http://projects\.puppetlabs\.com/projects/1/wiki/Using_Stored_Configuration
-.
-.SH "OPTIONS"
-Note that any configuration parameter that\'s valid in the configuration file is also a valid long argument\. For example, \'server\' is a valid configuration parameter, so you can specify \'\-\-server \fIservername\fR\' as an argument\.
-.
-.P
-See the configuration file documentation at http://docs\.puppetlabs\.com/references/stable/configuration\.html for the full list of acceptable parameters\. A commented list of all configuration options can also be generated by running puppet queue with \'\-\-genconfig\'\.
-.
-.TP
-\-\-debug
-Enable full debugging\.
-.
-.TP
-\-\-help
-Print this help message
-.
-.TP
-\-\-verbose
-Turn on verbose reporting\.
-.
-.TP
-\-\-version
-Print the puppet version number and exit\.
-.
-.SH "EXAMPLE"
-.
-.nf
-
-$ puppet queue
-.
-.fi
-.
-.SH "AUTHOR"
-Luke Kanies
-.
-.SH "COPYRIGHT"
-Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2\.0 License

data/man/man8/puppet-secret_agent.8

@@ -1,70 +0,0 @@
-.\" generated with Ronn/v0.7.3
-.\" http://github.com/rtomayko/ronn/tree/0.7.3
-.
-.TH "PUPPET\-SECRET_AGENT" "8" "January 2013" "Puppet Labs, LLC" "Puppet manual"
-.
-.SH "NAME"
-\fBpuppet\-secret_agent\fR \- Mimics puppet agent\.
-.
-.SH "SYNOPSIS"
-puppet secret_agent \fIaction\fR
-.
-.SH "DESCRIPTION"
-This subcommand currently functions as a proof of concept, demonstrating how the Faces API exposes Puppet\'s internal systems to application logic; compare the actual code for puppet agent\. It will eventually replace puppet agent entirely, and can provide a template for users who wish to implement agent\-like functionality with non\-standard application logic\.
-.
-.SH "OPTIONS"
-Note that any configuration parameter that\'s valid in the configuration file is also a valid long argument, although it may or may not be relevant to the present action\. For example, \fBserver\fR and \fBrun_mode\fR are valid configuration parameters, so you can specify \fB\-\-server <servername>\fR, or \fB\-\-run_mode <runmode>\fR as an argument\.
-.
-.P
-See the configuration file documentation at \fIhttp://docs\.puppetlabs\.com/references/stable/configuration\.html\fR for the full list of acceptable parameters\. A commented list of all configuration options can also be generated by running puppet with \fB\-\-genconfig\fR\.
-.
-.TP
-\-\-render\-as FORMAT
-The format in which to render output\. The most common formats are \fBjson\fR, \fBs\fR (string), \fByaml\fR, and \fBconsole\fR, but other options such as \fBdot\fR are sometimes available\.
-.
-.TP
-\-\-verbose
-Whether to log verbosely\.
-.
-.TP
-\-\-debug
-Whether to log debug information\.
-.
-.SH "ACTIONS"
-.
-.TP
-\fBsynchronize\fR \- Run secret_agent once\.
-\fBSYNOPSIS\fR
-.
-.IP
-puppet secret_agent
-.
-.IP
-\fBDESCRIPTION\fR
-.
-.IP
-Mimics a single run of puppet agent\. This action does not currently daemonize, but can download plugins, submit facts, retrieve and apply a catalog, and submit a report to the puppet master\.
-.
-.IP
-\fBRETURNS\fR
-.
-.IP
-Verbose logging from the completed run\. When used from the Ruby API: returns a Puppet::Transaction::Report object\.
-.
-.IP
-\fBNOTES\fR
-.
-.IP
-This action requires that the puppet master\'s \fBauth\.conf\fR file allow save access to the \fBfacts\fR REST terminus\. Puppet agent does not use this facility, and it is turned off by default\. See \fIhttp://docs\.puppetlabs\.com/guides/rest_auth_conf\.html\fR for more details\.
-.
-.SH "EXAMPLES"
-\fBsynchronize\fR
-.
-.P
-Trigger a Puppet run with the configured puppet master:
-.
-.P
-$ puppet secret_agent
-.
-.SH "COPYRIGHT AND LICENSE"
-Copyright 2011 by Puppet Labs Apache 2 license; see COPYING

data/spec/fixtures/unit/provider/package/pkg/publisher

@@ -1,2 +0,0 @@
-SUNWdummy (solaris)                            8.8-0.111       installed  -----
-service/network/dummy (solaris)                 0.5.11-0.151.0.1 installed  -----

data/spec/fixtures/unit/provider/package/pkg/simple

@@ -1,2 +0,0 @@
-SUNWdummy                                     2.5.5-0.111     installed  -----
-dummy2                                      9.3.6.1-0.111   installed  -----

data/spec/fixtures/yaml/report0.25.x.yaml

@@ -1,64 +0,0 @@
---- !ruby/object:Puppet::Transaction::Report
-  host: mattmac.local
-  logs: 
-    - !ruby/object:Puppet::Util::Log
-      level: !ruby/sym info
-      message: Applying configuration version '1285283846'
-      source: Puppet
-      tags: 
-        - info
-      time: 2010-09-23 16:17:26.977750 -07:00
-  metrics: 
-    time: !ruby/object:Puppet::Util::Metric
-      label: Time
-      name: time
-      values: 
-        - - !ruby/sym config_retrieval
-          - Config retrieval
-          - 0.955046892166138
-        - - !ruby/sym schedule
-          - Schedule
-          - 0.00123691558837891
-        - - !ruby/sym total
-          - Total
-          - 0.956486701965332
-        - - !ruby/sym filebucket
-          - Filebucket
-          - 0.00020289421081543
-    resources: !ruby/object:Puppet::Util::Metric
-      label: Resources
-      name: resources
-      values: 
-        - - !ruby/sym skipped
-          - Skipped
-          - 0
-        - - !ruby/sym scheduled
-          - Scheduled
-          - 7
-        - - !ruby/sym applied
-          - Applied
-          - 0
-        - - !ruby/sym restarted
-          - Restarted
-          - 0
-        - - !ruby/sym total
-          - Total
-          - 10
-        - - !ruby/sym failed_restarts
-          - Failed restarts
-          - 0
-        - - !ruby/sym out_of_sync
-          - Out of sync
-          - 0
-        - - !ruby/sym failed
-          - Failed
-          - 0
-    changes: !ruby/object:Puppet::Util::Metric
-      label: Changes
-      name: changes
-      values: 
-        - - !ruby/sym total
-          - Total
-          - 0
-  records: {}
-  time: 2010-09-23 16:17:26.987789 -07:00

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

@@ -1,55 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/resource/catalog'
-
-describe "Puppet::Resource::Catalog::Queue" do
-  before do
-    Puppet::Resource::Catalog.indirection.terminus(:queue)
-    @catalog = Puppet::Resource::Catalog.new("foo", Puppet::Node::Environment::NONE)
-
-    @one = Puppet::Resource.new(:file, "/one")
-    @two = Puppet::Resource.new(:file, "/two")
-    @catalog.add_resource(@one, @two)
-
-    @catalog.add_edge(@one, @two)
-
-    Puppet[:trace] = true
-  end
-
-  it "should render catalogs to pson and publish them via the queue client when catalogs are saved" do
-    terminus = Puppet::Resource::Catalog.indirection.terminus(:queue)
-
-    client = mock 'client'
-    terminus.stubs(:client).returns client
-
-    client.expects(:publish_message).with(:catalog, @catalog.to_pson)
-
-    request = Puppet::Indirector::Request.new(:catalog, :save, "foo", @catalog)
-
-    terminus.save(request)
-  end
-
-  it "should intern catalog messages when they are passed via a subscription" do
-    client = mock 'client'
-    Puppet::Resource::Catalog::Queue.stubs(:client).returns client
-
-    pson = @catalog.to_pson
-
-    client.expects(:subscribe).with(:catalog).yields(pson)
-
-    Puppet.expects(:err).never
-
-    result = []
-    Puppet::Resource::Catalog::Queue.subscribe do |catalog|
-      result << catalog
-    end
-
-    catalog = result.shift
-    catalog.should be_instance_of(Puppet::Resource::Catalog)
-
-    catalog.resource(:file, "/one").should be_instance_of(Puppet::Resource)
-    catalog.resource(:file, "/two").should be_instance_of(Puppet::Resource)
-    catalog.should be_edge(catalog.resource(:file, "/one"), catalog.resource(:file, "/two"))
-  end
-end

data/spec/integration/module_tool/tar/mini_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'puppet/module_tool'
-require 'puppet_spec/files'
-
-describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? && Puppet.features.zlib?) do
-  let(:minitar)    { described_class.new }
-
-  describe "Extracts tars with long and short pathnames" do
-    let (:sourcetar) { File.expand_path('../../../../fixtures/module.tar.gz', __FILE__) }
-
-    let (:longfilepath)  { "puppetlabs-dsc-1.0.0/lib/puppet_x/dsc_resources/xWebAdministration/DSCResources/MSFT_xWebAppPoolDefaults/MSFT_xWebAppPoolDefaults.schema.mof" }
-    let (:shortfilepath) { "puppetlabs-dsc-1.0.0/README.md" }
-
-    it "unpacks a tar with a short path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{shortfilepath}"))
-    end
-
-    it "unpacks a tar with a long path length" do
-      extractdir = PuppetSpec::Files.tmpdir('minitar')
-
-      minitar.unpack(sourcetar,extractdir,'module')
-      expect(File).to exist(File.expand_path("#{extractdir}/#{longfilepath}"))
-    end
-  end
-end

data/spec/integration/parser/dynamic_scoping_spec.rb

@@ -1,131 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/parser/parser_factory'
-require 'puppet_spec/compiler'
-require 'puppet_spec/pops'
-require 'puppet_spec/scope'
-require 'matchers/resource'
-require 'rgen/metamodel_builder'
-
-# These tests are in a separate file since othr compiler related tests have
-# been dramatically changed between 3.x and 4.x and it is a pain to merge
-# them.
-#
-describe "Puppet::Parser::Compiler when dealing with relative naming" do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  describe "the compiler when using 4.x parser and evaluator" do
-    # this before-clause should be removed when merging to 4.x
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-
-    it "should use absolute references even if references are not anchored" do
-      node = Puppet::Node.new("testnodex")
-      catalog = compile_to_catalog(<<-PP, node)
-      class foo::thing {
-        notify {"from foo::thing":}
-      }
-
-      class thing {
-        notify {"from ::thing":}
-      }
-
-      class foo {
-      #  include thing
-        class {'thing':}
-      }
-
-      include foo
-      PP
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource("Notify[from ::thing]")
-    end
-
-    it "should use absolute references when references are absolute" do
-      node = Puppet::Node.new("testnodex")
-      catalog = compile_to_catalog(<<-PP, node)
-      class foo::thing {
-        notify {"from foo::thing":}
-      }
-
-      class thing {
-        notify {"from ::thing":}
-      }
-
-      class foo {
-      #  include thing
-        class {'::thing':}
-      }
-
-      include foo
-      PP
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource("Notify[from ::thing]")
-    end
-  end
-
-  # This entire describe should be removed when merged to 4.x
-  #
-  describe "the compiler when using 3.x parser and evaluator" do
-    # this before-clause should be removed when merging to 4.x
-    before :each do
-      Puppet[:parser] = 'current'
-    end
-
-    it "should use relative references when they are not anchored" do
-      node = Puppet::Node.new("testnodex")
-      catalog = compile_to_catalog(<<-PP, node)
-            class foo::thing {
-              notify {"from foo::thing":}
-            }
-
-            class thing {
-              notify {"from ::thing":}
-            }
-
-            class foo {
-            #  include thing
-              class {'thing':}
-            }
-
-            include foo
-      PP
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource("Notify[from foo::thing]")
-    end
-
-    it "should use absolute references when references are absolute" do
-      node = Puppet::Node.new("testnodex")
-      catalog = compile_to_catalog(<<-PP, node)
-      class foo::thing {
-        notify {"from foo::thing":}
-      }
-
-      class thing {
-        notify {"from ::thing":}
-      }
-
-      class foo {
-      #  include thing
-        class {'::thing':}
-      }
-
-      include foo
-      PP
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource("Notify[from ::thing]")
-    end
-
-  end # End 3.x only case
-
-end

data/spec/integration/parser/future_compiler_spec.rb

@@ -1,822 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/parser/parser_factory'
-require 'puppet_spec/compiler'
-require 'puppet_spec/pops'
-require 'puppet_spec/scope'
-require 'matchers/resource'
-require 'rgen/metamodel_builder'
-
-# Test compilation using the future evaluator
-describe "Puppet::Parser::Compiler" do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
-  describe "the compiler when using future parser and evaluator" 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'
-
-        compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("testnode"))
-        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
-      node = Puppet::Node.new("testnodex")
-      node.classes = ['foo', 'bar']
-      catalog = compile_to_catalog(<<-PP, node)
-        class foo
-        {
-          notify { foo_notify: }
-          include bar
-        }
-        class bar
-        {
-          notify { bar_notify: }
-        }
-      PP
-
-      catalog = Puppet::Parser::Compiler.compile(node)
-
-      expect(catalog).to have_resource("Notify[foo_notify]")
-      expect(catalog).to have_resource("Notify[bar_notify]")
-    end
-
-    it 'applies defaults for defines with qualified names (PUP-2302)' do
-      catalog = compile_to_catalog(<<-CODE)
-        define my::thing($msg = 'foo') { notify {'check_me': message => $msg } }
-        My::Thing { msg => 'evoe' }
-        my::thing { 'name': }
-      CODE
-
-      expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "evoe")
-    end
-
-    it 'Applies defaults from dynamic scopes (3x and future with reverted PUP-867)' do
-      catalog = compile_to_catalog(<<-CODE)
-      class a {
-        Notify { message => "defaulted" }
-        include b
-        notify { bye: }
-      }
-      class b { notify { hi: } }
-
-      include a
-      CODE
-      expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "defaulted")
-      expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
-    end
-
-    it 'gets default from inherited class (PUP-867)' do
-      catalog = compile_to_catalog(<<-CODE)
-      class a {
-        Notify { message => "defaulted" }
-        include c
-        notify { bye: }
-      }
-      class b { Notify { message => "inherited" } }
-      class c inherits b { notify { hi: } }
-
-      include a
-      CODE
-
-      expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "inherited")
-      expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
-    end
-
-    it 'looks up default parameter values from inherited class (PUP-2532)' do
-      catalog = compile_to_catalog(<<-CODE)
-      class a {
-        Notify { message => "defaulted" }
-        include c
-        notify { bye: }
-      }
-      class b { Notify { message => "inherited" } }
-      class c inherits b { notify { hi: } }
-
-      include a
-      notify {hi_test: message => Notify[hi][message] }
-      notify {bye_test: message => Notify[bye][message] }
-      CODE
-
-      expect(catalog).to have_resource("Notify[hi_test]").with_parameter(:message, "inherited")
-      expect(catalog).to have_resource("Notify[bye_test]").with_parameter(:message, "defaulted")
-    end
-
-    it 'does not allow override of class parameters using a resource override expression' do
-      expect do
-        compile_to_catalog(<<-CODE)
-          Class[a] { x => 2}
-        CODE
-      end.to raise_error(/Resource Override can only.*got: Class\[a\].*/)
-    end
-
-    describe "when resolving class references" do
-      it "should not favor local scope (with class included in topscope)" do
-        catalog = compile_to_catalog(<<-PP)
-          class experiment {
-            class baz {
-            }
-            notify {"x" : require => Class[Baz] }
-            notify {"y" : require => Class[Experiment::Baz] }
-          }
-          class baz {
-          }
-          include baz
-          include experiment
-          include experiment::baz
-        PP
-
-        expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
-        expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
-      end
-
-      it "should not favor local scope, (with class not included in topscope)" do
-        catalog = compile_to_catalog(<<-PP)
-          class experiment {
-            class baz {
-            }
-            notify {"x" : require => Class[Baz] }
-            notify {"y" : require => Class[Experiment::Baz] }
-          }
-          class baz {
-          }
-          include experiment
-          include experiment::baz
-        PP
-
-        expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
-        expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[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
-            catalog = compile_to_catalog(<<-MANIFEST)
-              class { 'foo::test': }
-              class foo::test {
-              	#{include}
-              }
-              class bar::baz {
-              	notify { 'good!': }
-              }
-              class foo::bar::baz {
-              	notify { 'bad!': }
-              }
-            MANIFEST
-
-            expect(catalog).to have_resource("Class[Bar::Baz]")
-            expect(catalog).to have_resource("Notify[good!]")
-            expect(catalog).to_not have_resource("Class[Foo::Bar::Baz]")
-            expect(catalog).to_not have_resource("Notify[bad!]")
-          end
-        end
-      end
-    end
-
-    it 'should recompute the version after input files are re-parsed' do
-      Puppet[:code] = 'class foo { }'
-      first_time = Time.at(1)
-      second_time = Time.at(200)
-      Time.stubs(:now).returns(first_time)
-      node = Puppet::Node.new('mynode')
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
-      Time.stubs(:now).returns(second_time)
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
-      Puppet[:code] = nil
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)
-    end
-
-    ['define', 'class', 'node'].each do |thing|
-      it "'#{thing}' is not allowed inside evaluated conditional constructs" do
-        expect do
-          compile_to_catalog(<<-PP)
-            if true {
-              #{thing} foo {
-              }
-              notify { decoy: }
-            }
-          PP
-        end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
-      end
-
-      it "'#{thing}' is not allowed inside un-evaluated conditional constructs" do
-        expect do
-          compile_to_catalog(<<-PP)
-            if false {
-              #{thing} foo {
-              }
-              notify { decoy: }
-            }
-          PP
-        end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
-      end
-    end
-
-    describe "relationships can be formed" do
-      def extract_name(ref)
-        ref.sub(/File\[(\w+)\]/, '\1')
-      end
-
-      def assert_creates_relationships(relationship_code, expectations)
-        base_manifest = <<-MANIFEST
-          file { [a,b,c]:
-            mode => '0644',
-          }
-          file { [d,e]:
-            mode => '0755',
-          }
-        MANIFEST
-        catalog = compile_to_catalog(base_manifest + relationship_code)
-
-        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 =~ (expectations[:relationships] || [])
-        actual_subscriptions.should =~ (expectations[:subscriptions] || [])
-      end
-
-      it "of regular type" do
-        assert_creates_relationships("File[a] -> File[b]",
-                                     :relationships => [['a','b']])
-      end
-
-      it "of subscription type" do
-        assert_creates_relationships("File[a] ~> File[b]",
-                                     :subscriptions => [['a', 'b']])
-      end
-
-      it "between multiple resources expressed as resource with multiple titles" do
-        assert_creates_relationships("File[a,b] -> File[c,d]",
-                                     :relationships => [['a', 'c'],
-                                                        ['b', 'c'],
-                                                        ['a', 'd'],
-                                                        ['b', 'd']])
-      end
-
-      it "between collection expressions" do
-        assert_creates_relationships("File <| mode == '0644' |> -> File <| mode == '0755' |>",
-                                     :relationships => [['a', 'd'],
-                                                        ['b', 'd'],
-                                                        ['c', 'd'],
-                                                        ['a', 'e'],
-                                                        ['b', 'e'],
-                                                        ['c', 'e']])
-      end
-
-      it "between resources expressed as Strings" do
-        assert_creates_relationships("'File[a]' -> 'File[b]'",
-                                     :relationships => [['a', 'b']])
-      end
-
-      it "between resources expressed as variables" do
-        assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
-          $var = File[a]
-          $var -> File[b]
-        MANIFEST
-
-      end
-
-      it "between resources expressed as case statements" do
-        assert_creates_relationships(<<-MANIFEST, :relationships => [['s1', 't2']])
-          $var = 10
-          case $var {
-            10: {
-              file { s1: }
-            }
-            12: {
-              file { s2: }
-            }
-          }
-          ->
-          case $var + 2 {
-            10: {
-              file { t1: }
-            }
-            12: {
-              file { t2: }
-            }
-          }
-        MANIFEST
-      end
-
-      it "using deep access in array" do
-        assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
-          $var = [ [ [ File[a], File[b] ] ] ]
-          $var[0][0][0] -> $var[0][0][1]
-        MANIFEST
-
-      end
-
-      it "using deep access in hash" do
-        assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
-          $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
-          $var[foo][bar][source] -> $var[foo][bar][target]
-        MANIFEST
-
-      end
-
-      it "using resource declarations" do
-        assert_creates_relationships("file { l: } -> file { r: }", :relationships => [['l', 'r']])
-      end
-
-      it "between entries in a chain of relationships" do
-        assert_creates_relationships("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]",
-                                     :relationships => [['a', 'b'], ['d', 'c']],
-                                     :subscriptions => [['b', 'c'], ['e', 'd']])
-      end
-    end
-
-    context "when dealing with variable references" do
-      it 'an initial underscore in a variable name is ok' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          class a { $_a = 10}
-          include a
-          notify { 'test': message => $a::_a }
-        MANIFEST
-
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 10)
-      end
-
-      it 'an initial underscore in not ok if elsewhere than last segment' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            class a { $_a = 10}
-            include a
-            notify { 'test': message => $_a::_a }
-          MANIFEST
-        end.to raise_error(/Illegal variable name/)
-      end
-
-      it 'a missing variable as default value becomes undef' do
-        # strict variables not on
-        catalog = compile_to_catalog(<<-MANIFEST)
-        class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
-          include a
-        MANIFEST
-
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "yes true")
-      end
-    end
-
-    context 'when working with the trusted data hash' do
-      context 'and have opted in to hashed_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
-
-          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "value")
-        end
-
-        it 'should not allow assignment to $trusted' do
-          node = Puppet::Node.new("testing")
-          node.trusted_data = { "data" => "value" }
-
-          expect do
-            compile_to_catalog(<<-MANIFEST, node)
-              $trusted = 'changed'
-              notify { 'test': message => $trusted == 'changed' }
-            MANIFEST
-          end.to raise_error(Puppet::Error, /Attempt to assign to a reserved variable name: 'trusted'/)
-        end
-      end
-
-      context 'and have not opted in to hashed_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
-
-          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-        end
-
-        it 'should allow assignment to $trusted' do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            $trusted = 'changed'
-            notify { 'test': message => $trusted == 'changed' }
-          MANIFEST
-
-          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
-        end
-      end
-    end
-
-    context 'when using typed parameters in definition' do
-      it 'accepts type compliant arguments' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define foo(String $x) { }
-          foo { 'test': x =>'say friend' }
-        MANIFEST
-        expect(catalog).to have_resource("Foo[test]").with_parameter(:x, 'say friend')
-      end
-
-      it 'accepts undef as the default for an Optional argument' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define foo(Optional[String] $x = undef) {
-            notify { "expected": message => $x == undef }
-          }
-          foo { 'test': }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
-      end
-
-      it 'accepts anything when parameters are untyped' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-          define foo($a, $b, $c) { }
-          foo { 'test': a => String, b=>10, c=>undef }
-        MANIFEST
-        end.to_not raise_error()
-      end
-
-      it 'denies non type compliant arguments' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            define foo(Integer $x) { }
-            foo { 'test': x =>'say friend' }
-          MANIFEST
-        end.to raise_error(/type Integer, got String/)
-      end
-
-      it 'denies undef for a non-optional type' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            define foo(Integer $x) { }
-            foo { 'test': x => undef }
-          MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
-      end
-
-      it 'denies non type compliant default argument' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            define foo(Integer $x = 'pow') { }
-            foo { 'test':  }
-          MANIFEST
-        end.to raise_error(/type Integer, got String/)
-      end
-
-      it 'denies undef as the default for a non-optional type' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            define foo(Integer $x = undef) { }
-            foo { 'test':  }
-          MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
-      end
-
-      it 'accepts a Resource as a Type' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define foo(Type[Bar] $x) {
-            notify { 'test': message => $x[text] }
-          }
-          define bar($text) { }
-          bar { 'joke': text => 'knock knock' }
-          foo { 'test': x => Bar[joke] }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
-      end
-
-      it 'uses infer_set when reporting type mismatch' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            define foo(Struct[{b => Integer, d=>String}] $a) { }
-            foo{ bar: a => {b => 5, c => 'stuff'}}
-          MANIFEST
-        end.to raise_error(/got Struct\[\{'b'=>Integer, 'c'=>String\}\]/)
-      end
-    end
-
-    context 'when using typed parameters in class' do
-      it 'accepts type compliant arguments' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          class foo(String $x) { }
-          class { 'foo': x =>'say friend' }
-        MANIFEST
-        expect(catalog).to have_resource("Class[Foo]").with_parameter(:x, 'say friend')
-      end
-
-      it 'accepts undef as the default for an Optional argument' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          class foo(Optional[String] $x = undef) {
-            notify { "expected": message => $x == undef }
-          }
-          class { 'foo': }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
-      end
-
-      it 'accepts anything when parameters are untyped' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            class foo($a, $b, $c) { }
-            class { 'foo': a => String, b=>10, c=>undef }
-          MANIFEST
-        end.to_not raise_error()
-      end
-
-      it 'denies non type compliant arguments' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            class foo(Integer $x) { }
-            class { 'foo': x =>'say friend' }
-          MANIFEST
-        end.to raise_error(/type Integer, got String/)
-      end
-
-      it 'denies undef for a non-optional type' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            class foo(Integer $x) { }
-            class { 'foo': x => undef }
-          MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
-      end
-
-      it 'denies non type compliant default argument' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            class foo(Integer $x = 'pow') { }
-            class { 'foo':  }
-          MANIFEST
-        end.to raise_error(/type Integer, got String/)
-      end
-
-      it 'denies undef as the default for a non-optional type' do
-        expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
-            class foo(Integer $x = undef) { }
-            class { 'foo':  }
-          MANIFEST
-        end.to raise_error(/type Integer, got Undef/)
-      end
-
-      it 'accepts a Resource as a Type' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          class foo(Type[Bar] $x) {
-            notify { 'test': message => $x[text] }
-          }
-          define bar($text) { }
-          bar { 'joke': text => 'knock knock' }
-          class { 'foo': x => Bar[joke] }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
-      end
-    end
-
-    context 'when using typed parameters in lambdas' do
-      it 'accepts type compliant arguments' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with('value') |String $x| { notify { "$x": } }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[value]")
-      end
-
-      it 'handles an array as a single argument' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with(['value', 'second']) |$x| { notify { "${x[0]} ${x[1]}": } }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[value second]")
-      end
-
-      # Conditinoally left out for Ruby 1.8.x since the Proc created for the expected number of arguments will accept
-      # a call with fewer arguments and then pass all arguments to the closure. The closure then receives an argument
-      # array of correct size with nil values instead of an array with too few arguments
-      unless RUBY_VERSION[0,3] == '1.8'
-        it 'denies when missing required arguments' do
-          expect do
-            compile_to_catalog(<<-MANIFEST)
-              with(1) |$x, $y| { }
-            MANIFEST
-          end.to raise_error(/Parameter \$y is required but no value was given/m)
-        end
-      end
-
-      it 'accepts anything when parameters are untyped' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          ['value', 1, true, undef].each |$x| { notify { "value: $x": } }
-        MANIFEST
-
-        expect(catalog).to have_resource("Notify[value: value]")
-        expect(catalog).to have_resource("Notify[value: 1]")
-        expect(catalog).to have_resource("Notify[value: true]")
-        expect(catalog).to have_resource("Notify[value: ]")
-      end
-
-      it 'accepts type-compliant, slurped arguments' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with(1, 2) |Integer *$x| { notify { "${$x[0] + $x[1]}": } }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[3]")
-      end
-
-      it 'denies non-type-compliant arguments' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with(1) |String $x| { }
-          MANIFEST
-        end.to raise_error(/expected.*String.*actual.*Integer/m)
-      end
-
-      it 'denies non-type-compliant, slurped arguments' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with(1, "hello") |Integer *$x| { }
-          MANIFEST
-        end.to raise_error(/called with mis-matched arguments.*expected.*Integer.*actual.*Integer, String/m)
-      end
-
-      it 'denies non-type-compliant default argument' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with(1) |$x, String $defaulted = 1| { notify { "${$x + $defaulted}": }}
-          MANIFEST
-        end.to raise_error(/expected.*Any.*String.*actual.*Integer.*Integer/m)
-      end
-
-      it 'raises an error when a default argument value is an incorrect type and there are no arguments passed' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with() |String $defaulted = 1| {}
-          MANIFEST
-        end.to raise_error(/expected.*String.*actual.*Integer/m)
-      end
-
-      it 'raises an error when the default argument for a slurped parameter is an incorrect type' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with() |String *$defaulted = 1| {}
-          MANIFEST
-        end.to raise_error(/expected.*String.*actual.*Integer/m)
-      end
-
-      it 'allows using an array as the default slurped value' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with() |String *$defaulted = [hi]| { notify { $defaulted[0]: } }
-        MANIFEST
-
-        expect(catalog).to have_resource('Notify[hi]')
-      end
-
-      it 'allows using a value of the type as the default slurped value' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with() |String *$defaulted = hi| { notify { $defaulted[0]: } }
-        MANIFEST
-
-        expect(catalog).to have_resource('Notify[hi]')
-      end
-
-      it 'allows specifying the type of a slurped parameter as an array' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with() |Array[String] *$defaulted = hi| { notify { $defaulted[0]: } }
-        MANIFEST
-
-        expect(catalog).to have_resource('Notify[hi]')
-      end
-
-      it 'raises an error when the number of default values does not match the parameter\'s size specification' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with() |Array[String, 2] *$defaulted = hi| { }
-          MANIFEST
-        end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
-      end
-
-      it 'raises an error when the number of passed values does not match the parameter\'s size specification' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with(hi) |Array[String, 2] *$passed| { }
-          MANIFEST
-        end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
-      end
-
-      it 'matches when the number of arguments passed for a slurp parameter match the size specification' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with(hi, bye) |Array[String, 2] *$passed| {
-            $passed.each |$n| { notify { $n: } }
-          }
-        MANIFEST
-
-        expect(catalog).to have_resource('Notify[hi]')
-        expect(catalog).to have_resource('Notify[bye]')
-      end
-
-      it 'raises an error when the number of allowed slurp parameters exceeds the size constraint' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with(hi, bye) |Array[String, 1, 1] *$passed| { }
-          MANIFEST
-        end.to raise_error(/expected.*arg count \{1\}.*actual.*arg count \{2\}/m)
-      end
-
-      it 'allows passing slurped arrays by specifying an array of arrays' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with([hi], [bye]) |Array[Array[String, 1, 1]] *$passed| {
-            notify { $passed[0][0]: }
-            notify { $passed[1][0]: }
-          }
-        MANIFEST
-
-        expect(catalog).to have_resource('Notify[hi]')
-        expect(catalog).to have_resource('Notify[bye]')
-      end
-
-      it 'raises an error when a required argument follows an optional one' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with() |$y = first, $x, Array[String, 1] *$passed = bye| {}
-          MANIFEST
-        end.to raise_error(/Parameter \$x is required/)
-      end
-
-      it 'raises an error when the minimum size of a slurped argument makes it required and it follows an optional argument' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with() |$x = first, Array[String, 1] *$passed| {}
-          MANIFEST
-        end.to raise_error(/Parameter \$passed is required/)
-      end
-
-      it 'allows slurped arguments with a minimum size of 0 after an optional argument' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          with() |$x = first, Array[String, 0] *$passed| {
-            notify { $x: }
-          }
-        MANIFEST
-
-        expect(catalog).to have_resource('Notify[first]')
-      end
-
-      it 'accepts a Resource as a Type' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define bar($text) { }
-          bar { 'joke': text => 'knock knock' }
-
-          with(Bar[joke]) |Type[Bar] $joke| { notify { "${joke[text]}": } }
-        MANIFEST
-        expect(catalog).to have_resource("Notify[knock knock]")
-      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).to have_resource("Notify[nbr1]").with_parameter(:message, 'overridden')
-      expect(catalog).to have_resource("Notify[nbr2]").with_parameter(:message, 'overridden')
-    end
-  end
-
-end