puppet 4.0.0 → 4.5.0

data/spec/integration/parser/dynamic_scoping_spec.rb

@@ -0,0 +1,67 @@
+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
+    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
+end

data/spec/integration/parser/parameter_defaults_spec.rb

@@ -0,0 +1,354 @@
+require 'spec_helper'
+require 'puppet_spec/language'
+
+['Function', 'EPP'].each do |call_type|
+  describe "#{call_type} parameter default expressions" do
+    let! (:func_bodies) {
+      [
+        '{}',
+        '{ notice("\$a == ${a}") }',
+        '{ notice("\$a == ${a}") notice("\$b == ${b}") }',
+        '{ notice("\$a == ${a}") notice("\$b == ${b}")  notice("\$c == ${c}") }'
+      ]
+    }
+
+    let! (:epp_bodies) {
+      [
+        '',
+        '<% notice("\$a == ${a}") %>',
+        '<% notice("\$a == ${a}") notice("\$b == ${b}") %>',
+        '<% notice("\$a == ${a}") notice("\$b == ${b}")  notice("\$c == ${c}") %>'
+      ]
+    }
+    let! (:param_names) {  ('a'..'c').to_a }
+
+    let (:call_type) { call_type }
+
+    let (:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('specification')) }
+
+    def collect_notices(code)
+      logs = []
+      Puppet[:code] = code
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        compiler.compile
+        yield
+      end
+      logs.select { |log| log.level == :notice }.map { |log| log.message }
+    end
+
+    # @param arg_list [String] comma separated parameter declarations. Not enclosed in parenthesis
+    # @param body [String,Integer] verbatim body or index of an entry in func_bodies
+    # @param call_params [Array[#to_s]] array of call parameters
+    # @return [Array] array of notice output entries
+    #
+    def eval_collect_notices(arg_list, body, call_params)
+      call = call_params.is_a?(String) ? call_params : "example(#{call_params.map {|p| p.nil? ? 'undef' : (p.is_a?(String) ? "'#{p}'" : p )}.join(',')})"
+      body = func_bodies[body] if body.is_a?(Integer)
+      evaluator = Puppet::Pops::Parser::EvaluatingParser.new()
+      collect_notices("function example(#{arg_list}) #{body}") do
+        evaluator.evaluate_string(compiler.topscope, call)
+      end
+    end
+
+    # @param arg_list [String] comma separated parameter declarations. Not enclosed in parenthesis
+    # @param body [String,Integer] verbatim body or index of an entry in bodies
+    # @param call_params [Array] array of call parameters
+    # @param code [String] code to evaluate
+    # @return [Array] array of notice output entries
+    #
+    def epp_eval_collect_notices(arg_list, body, call_params, code, inline_epp)
+      body = body.is_a?(Integer) ? epp_bodies[body] : body.strip
+      source = "<%| #{arg_list} |%>#{body}"
+      named_params = call_params.reduce({}) {|h, v| h[param_names[h.size]] = v; h }
+      collect_notices(code) do
+        if inline_epp
+          Puppet::Pops::Evaluator::EppEvaluator.inline_epp(compiler.topscope, source, named_params)
+        else
+          file = Tempfile.new(['epp-script', '.epp'])
+          begin
+            file.write(source)
+            file.close
+            Puppet::Pops::Evaluator::EppEvaluator.epp(compiler.topscope, file.path, 'test', named_params)
+          ensure
+            file.unlink
+          end
+        end
+      end
+    end
+
+
+    # evaluates a function or EPP call, collects notice output in a log and compares log to expected result
+    #
+    # @param decl [Array[]] two element array with argument list declaration and body. Body can a verbatim string
+    #   or an integer index of an entry in bodies
+    # @param call_params [Array[#to_s]] array of call parameters
+    # @param code [String] code to evaluate. Only applicable when call_type == 'EPP'
+    # @param inline_epp [Boolean] true for inline_epp, false for file based epp, Only applicable when call_type == 'EPP'
+    # @return [Array] array of notice output entries
+    #
+    def expect_log(decl, call_params, result, code = 'undef', inline_epp = true)
+      if call_type == 'Function'
+        expect(eval_collect_notices(decl[0], decl[1], call_params)).to include(*result)
+      else
+        expect(epp_eval_collect_notices(decl[0], decl[1], call_params, code, inline_epp)).to include(*result)
+      end
+    end
+
+    # evaluates a function or EPP call and expects a failure
+    #
+    # @param decl [Array[]] two element array with argument list declaration and body. Body can a verbatim string
+    #   or an integer index of an entry in bodies
+    # @param call_params [Array[#to_s]] array of call parameters
+    # @param text [String,Regexp] expected error message
+    def expect_fail(decl, call, text, inline_epp = true)
+      if call_type == 'Function'
+        expect{eval_collect_notices(decl[0], decl[1], call) }.to raise_error(StandardError, text)
+      else
+        expect{epp_eval_collect_notices(decl[0], decl[1], call, 'undef', inline_epp) }.to raise_error(StandardError, text)
+      end
+    end
+
+    context 'that references a parameter to the left that has no default' do
+      let!(:params) { [ <<-SOURCE, 2 ]
+      $a,
+      $b = $a
+      SOURCE
+      }
+
+      it 'fails when no value is provided for required first parameter', :if => call_type == 'Function' do
+        expect_fail(params, [], /expects between 1 and 2 arguments, got none/)
+      end
+
+      it 'fails when no value is provided for required first parameter', :if => call_type == 'EPP' do
+        expect_fail(params, [], /default expression for \$b tries to illegally access not yet evaluated \$a/)
+      end
+
+      it "will use the referenced parameter's given value" do
+        expect_log(params, [2], ['$a == 2', '$b == 2'])
+      end
+
+      it 'will not be evaluated when a value is given' do
+        expect_log(params, [2, 5], ['$a == 2', '$b == 5'])
+      end
+    end
+
+    context 'that references a parameter to the left that has a default' do
+      let!(:params) { [ <<-SOURCE, 2 ]
+      $a = 10,
+      $b = $a
+      SOURCE
+      }
+
+      it "will use the referenced parameter's default value when no value is given for the referenced parameter" do
+        expect_log(params, [], ['$a == 10', '$b == 10'])
+      end
+
+      it "will use the referenced parameter's given value" do
+        expect_log(params, [2], ['$a == 2', '$b == 2'])
+      end
+
+      it 'will not be evaluated when a value is given' do
+        expect_log(params, [2, 5], ['$a == 2', '$b == 5'])
+      end
+    end
+
+    context 'that references a variable to the right' do
+      let!(:params) { [ <<-SOURCE, 3 ]
+      $a = 10,
+      $b = $c,
+      $c = 20
+      SOURCE
+      }
+
+      it 'fails when the reference is evaluated' do
+        expect_fail(params, [1], /default expression for \$b tries to illegally access not yet evaluated \$c/)
+      end
+
+      it 'does not fail when a value is given for the culprit parameter' do
+        expect_log(params, [1,2], ['$a == 1', '$b == 2', '$c == 20'])
+      end
+
+      it 'does not fail when all values are given' do
+        expect_log(params, [1,2,3], ['$a == 1', '$b == 2', '$c == 3'])
+      end
+    end
+
+    context 'with regular expressions' do
+      it "evaluates unset match scope parameter's to undef" do
+        expect_log([<<-SOURCE, 2], [], ['$a == ', '$b == '])
+        $a = $0,
+        $b = $1
+        SOURCE
+      end
+
+      it 'does not leak match variables from one expression to the next' do
+        expect_log([<<-SOURCE, 2], [], ['$a == [true, h, ello]', '$b == '])
+        $a = ['hello' =~ /(h)(.*)/, $1, $2],
+        $b = $1
+        SOURCE
+      end
+
+      it 'can evaluate expressions in separate match scopes' do
+        expect_log([<<-SOURCE, 3], [], ['$a == [true, h, ell, o]', '$b == [true, h, i, ]', '$c == '])
+        $a = ['hello' =~ /(h)(.*)(o)/, $1, $2, $3],
+        $b = ['hi' =~ /(h)(.*)/, $1, $2, $3],
+        $c = $1
+        SOURCE
+      end
+
+      it 'can have nested match expressions' do
+        expect_log([<<-SOURCE, 2], [], ['$a == [true, h, oo, h, i]', '$b == '] )
+        $a = ['hi' =~ /(h)(.*)/, $1, if'foo' =~ /f(oo)/ { $1 }, $1, $2],
+        $b = $0
+        SOURCE
+      end
+
+      it 'can not see match scope from calling scope', :if => call_type == 'Function' do
+        expect_log([<<-SOURCE, <<-BODY], <<-CALL, ['$a == '])
+        $a = $0
+        SOURCE
+        {
+          notice("\\$a == ${a}")
+        }
+        function caller() {
+          example()
+        }
+        BODY
+        $tmp = 'foo' =~ /(f)(o)(o)/
+        caller()
+        CALL
+      end
+
+      context 'matches in calling scope', :if => call_type == 'EPP' do
+        it 'are available when using inlined epp' do
+          # Note that CODE is evaluated before the EPP is evaluated
+          #
+          expect_log([<<-SOURCE, <<-BODY], [], ['$ax == true', '$bx == foo'], <<-CODE, true)
+          $a = $tmp,
+          $b = $0
+          SOURCE
+          <% called_from_template($a, $b) %>
+          BODY
+          function called_from_template($ax, $bx) {
+            notice("\\$ax == $ax")
+            notice("\\$bx == $bx")
+          }
+          $tmp = 'foo' =~ /(f)(o)(o)/
+          CODE
+        end
+
+        it 'are not available when using epp file' do
+          # Note that CODE is evaluated before the EPP is evaluated
+          #
+          expect_log([<<-SOURCE, <<-BODY], [], ['$ax == true', '$bx == '], <<-CODE, false)
+          $a = $tmp,
+          $b = $0
+            SOURCE
+          <% called_from_template($a, $b) %>
+            BODY
+          function called_from_template($ax, $bx) {
+            notice("\\$ax == $ax")
+            notice("\\$bx == $bx")
+          }
+          $tmp = 'foo' =~ /(f)(o)(o)/
+          CODE
+        end
+      end
+
+
+      it 'will allow nested lambdas to access enclosing match scope' do
+        expect_log([<<-SOURCE, 1], [], ['$a == [1-ello, 2-ello, 3-ello]'])
+        $a = case "hello" {
+          /(h)(.*)/ : {
+            [1,2,3].map |$x| { "$x-$2" }
+          }
+        }
+        SOURCE
+      end
+
+      it "will not make match scope available to #{call_type} body" do
+        expect_log([<<-SOURCE, call_type == 'Function' ? <<-BODY : <<-EPP_BODY], [], ['Yes'])
+        $a = "hello" =~ /.*/
+        SOURCE
+        {
+          notice("Y${0}es")
+        }
+        BODY
+        <%
+          notice("Y${0}es")
+        %>
+        EPP_BODY
+      end
+
+      it 'can access earlier match results when produced using the match function' do
+        expect_log([<<-SOURCE, 3], [], ['$a == [hello, h, ello]', '$b == hello', '$c == h'])
+        $a = 'hello'.match(/(h)(.*)/),
+        $b = $a[0],
+        $c = $a[1]
+        SOURCE
+      end
+    end
+
+
+    context 'will not permit assignments' do
+      it 'at top level' do
+        expect_fail([<<-SOURCE, 0], [], /Syntax error at '='/)
+        $a = $x = $0
+        SOURCE
+      end
+
+      it 'in arrays' do
+        expect_fail([<<-SOURCE, 0], [], /Assignment not allowed here/)
+        $a = [$x = 3]
+        SOURCE
+      end
+
+      it 'of variable with the same name as a subsequently declared parameter' do
+        expect_fail([<<-SOURCE, 0], [], /Assignment not allowed here/)
+        $a = ($b = 3),
+        $b = 5
+        SOURCE
+      end
+
+      it 'of variable with the same name as a previously declared parameter' do
+        expect_fail([<<-SOURCE, 0], [], /Assignment not allowed here/)
+        $a = 10,
+        $b = ($a = 10)
+        SOURCE
+      end
+    end
+
+    it 'will permit assignments in nested scope' do
+      expect_log([<<-SOURCE, 3], [], ['$a == [1, 2, 3]', '$b == 0', '$c == [6, 12, 18]'])
+      $a = [1,2,3],
+      $b = 0,
+      $c = $a.map |$x| { $b = $x; $b * $a.reduce |$x, $y| {$x + $y} }
+      SOURCE
+    end
+
+    it 'will not permit duplicate parameter names' do
+      expect_fail([<<-SOURCE, 0], [], /The parameter 'a' is declared more than once/ )
+      $a = 2,
+      $a = 5
+      SOURCE
+    end
+
+    it 'will permit undef for optional parameters' do
+      expect_log([<<-SOURCE, 1], [nil], ['$a == '])
+      Optional[Integer] $a
+      SOURCE
+    end
+
+    it 'undef will override parameter default', :if => call_type == 'Function' do
+      expect_log([<<-SOURCE, 1], [nil], ['$a == '])
+      Optional[Integer] $a = 4
+      SOURCE
+    end
+
+    it 'undef will not override parameter default', :unless => call_type == 'Function' do
+      expect_log([<<-SOURCE, 1], [nil], ['$a == 4'])
+      Optional[Integer] $a = 4
+      SOURCE
+    end
+  end
+end

data/spec/integration/parser/resource_expressions_spec.rb

@@ -114,7 +114,7 @@ describe "Puppet resource expressions" do
 
     fails( "define a::b { notify { testing: } } 'a::b' { title: }" => /Illegal Resource Type expression.*got String/)
 
-    fails( "Does::Not::Exist { title: }" => /Invalid resource type does::not::exist/)
+    fails( "Does::Not::Exist { title: }" => /Resource type not found: Does::Not::Exist/)
   end
 
   context "local defaults" do
@@ -164,15 +164,18 @@ describe "Puppet resource expressions" do
              path => '/somewhere',
              * => $y }"  => "File[$t][mode] == '0666' and File[$t][owner] == 'the_x' and File[$t][path] == '/somewhere'")
 
-    fails("notify { title: unknown => value }" => /Invalid parameter: 'unknown'/)
+    produces("notify{title:}; Notify[title] { * => { message => set}}" => "Notify[title][message] == 'set'")
+    produces("Notify { * => { message => set}}; notify{title:}"      => "Notify[title][message] == 'set'")
+
+    fails("notify { title: unknown => value }" => /no parameter named 'unknown'/)
 
     # this really needs to be a better error message.
-    fails("notify { title: * => { hash => value }, message => oops }" => /Invalid parameter: 'hash'/)
+    fails("notify { title: * => { hash => value }, message => oops }" => /no parameter named 'hash'/)
 
     # should this be a better error message?
-    fails("notify { title: message => oops, * => { hash => value } }" => /Invalid parameter: 'hash'/)
+    fails("notify { title: message => oops, * => { hash => value } }" => /no parameter named 'hash'/)
 
-    fails("notify { title: * => { unknown => value } }" => /Invalid parameter: 'unknown'/)
+    fails("notify { title: * => { unknown => value } }" => /no parameter named 'unknown'/)
     fails("
          $x = { mode => '0666' }
          $y = { owner => the_y }

data/spec/integration/parser/scope_spec.rb

@@ -34,10 +34,31 @@ describe "Two step scoping for variables" do
         MANIFEST
       end.to raise_error(/The operator '-=' is no longer supported/)
     end
-  end
 
-  it "when using a template ignores the dynamic value of the var when using the @varname syntax" do
-    expect_the_message_to_be('node_msg') do <<-MANIFEST
+    it "issues error about built-in variable when reassigning to name" do
+        enc_node = Puppet::Node.new("the_node", { :parameters => {  } })
+
+        expect {
+          compile_to_catalog("$name = 'never in a 0xF4240 years'", enc_node)
+        }.to raise_error(
+          Puppet::Error,
+          /Cannot reassign built in \(or already assigned\) variable '\$name' at line 1(\:7)? on node the_node/
+        )
+    end
+
+    it "issues error about built-in variable when reassigning to title" do
+        enc_node = Puppet::Node.new("the_node", { :parameters => {  } })
+
+        expect {
+          compile_to_catalog("$title = 'never in a 0xF4240 years'", enc_node)
+        }.to raise_error(
+          Puppet::Error,
+          /Cannot reassign built in \(or already assigned\) variable '\$title' at line 1(\:8)? on node the_node/
+        )
+    end
+
+    it "when using a template ignores the dynamic value of the var when using the @varname syntax" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
           node default {
             $var = "node_msg"
             include foo
@@ -90,7 +111,26 @@ describe "Two step scoping for variables" do
           class bar inherits bar_bamama {
             notify { 'something': message => inline_template("<%= @var %>"), }
           }
-      MANIFEST
+        MANIFEST
+      end
+    end
+
+    describe 'handles 3.x/4.x functions' do
+      it 'can call a 3.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("fqdn_rand", [30]).to_i <= 30 ? "yes" : "no" %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
+
+      it 'it can call a 4.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("with", ["yes"]) { |x| x } %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
     end
   end
 
@@ -589,12 +629,11 @@ describe "Two step scoping for variables" do
 
     it "does not allow the enc to specify an existing top scope var" do
       enc_node = Puppet::Node.new("the_node", { :parameters => { "var" => 'from_enc' } })
-
       expect {
         compile_to_catalog("$var = 'top scope'", enc_node)
       }.to raise_error(
-      Puppet::Error,
-      /Cannot reassign variable var at line 1(\:6)? on node the_node/
+        Puppet::Error,
+        /Cannot reassign variable '\$var' at line 1(\:6)? on node the_node/
       )
     end
 

data/spec/integration/parser/undef_param_spec.rb

@@ -78,10 +78,18 @@ describe "Parameter passing" do
   end
 
   it "errors when no parameter is provided and there is no default" do
-    expect_puppet_error(/^Must pass x to A\[a\].*/) do <<-MANIFEST
+    expect_puppet_error(/A\[a\]: expects a value for parameter 'x'/) do <<-MANIFEST
         define a($x) { notify { 'something': message => $x }}
         a {'a': }
     MANIFEST
     end
   end
+
+  it "uses a given undef and do not require a default expression" do
+    expect_the_message_to_be(true) do <<-MANIFEST
+        define a(Optional[Integer] $x) { notify { 'something': message => $x == undef}}
+        a {'a': x => undef }
+    MANIFEST
+    end
+  end
 end

data/spec/integration/provider/mount_spec.rb

@@ -22,9 +22,9 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
     Facter.stubs(:value).with(:hostname).returns('some_host')
     Facter.stubs(:value).with(:domain).returns('some_domain')
-    Facter.stubs(:value).with(:kernel).returns('Darwin')
-    Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
-    Facter.stubs(:value).with(:osfamily).returns('Darwin')
+    Facter.stubs(:value).with(:kernel).returns('Linux')
+    Facter.stubs(:value).with(:operatingsystem).returns('RedHat')
+    Facter.stubs(:value).with(:osfamily).returns('RedHat')
     Puppet::Util::ExecutionStub.set do |command, options|
       case command[0]
       when %r{/s?bin/mount}
@@ -35,24 +35,7 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
             ''
           end
         else
-          expect(command.length).to eq(4)
-          expect(command[1]).to eq('-o')
-
-          # update is a special option, used on bsd's
-          # strip it out and track as a local bool here
-          update = false
-          tmp_options = command[2].split(",")
-
-          if tmp_options.include?("update")
-            update = true
-            tmp_options.delete("update")
-          end
-          @current_options = tmp_options.join(",")
-
-          if !update
-            expect(@mounted).to eq(false) # verify that we don't try to call "mount" redundantly
-          end
-          expect(command[3]).to eq('/Volumes/foo_disk')
+          expect(command.last).to eq('/Volumes/foo_disk')
           @current_device = check_fstab(true)
           @mounted = true
           ''
@@ -123,27 +106,31 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
             end
             expected_fstab_data = (ensure_setting != :absent)
             describe "When setting ensure => #{ensure_setting}" do
-              ["local", "journaled"].each do |options_setting|
-                describe "When setting options => #{options_setting}" do
+              ["local", "journaled", "", nil].each do |options_setting|
+                describe "When setting options => '#{options_setting}'" do
                   it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
                     if family == "Solaris"
                       skip("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb")
                     else
-                      @desired_options = options_setting
-                      run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
-                      expect(@mounted).to eq(expected_final_state)
-                      if expected_fstab_data
-                        expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
+                      if options_setting && options_setting.empty?
+                        expect { run_in_catalog(:ensure=>ensure_setting, :options => options_setting) }.to raise_error Puppet::ResourceError
                       else
-                        expect(check_fstab(expected_fstab_data)).to eq(nil)
-                      end
-                      if @mounted
-                        if ![:defined, :present].include?(ensure_setting)
-                          expect(@current_options).to eq(@desired_options)
-                        elsif initial_fstab_entry
-                          expect(@current_options).to eq(@desired_options)
+                        if options_setting
+                          @desired_options = options_setting
+                          run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
+                        else
+                          if initial_fstab_entry
+                            @desired_options = @current_options
+                          else
+                            @desired_options = 'defaults'
+                          end
+                          run_in_catalog(:ensure=>ensure_setting)
+                        end
+                        expect(@mounted).to eq(expected_final_state)
+                        if expected_fstab_data
+                          expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
                         else
-                          expect(@current_options).to eq('local') #Workaround for #6645
+                          expect(check_fstab(expected_fstab_data)).to eq(nil)
                         end
                       end
                     end

data/spec/integration/provider/yumrepo_spec.rb

@@ -87,7 +87,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
     properties = {"bandwidth"      => "42M",
                   "baseurl"        => "http://er0ck",
                   "cost"           => "42",
-                  "enabled"        => "YeS",
+                  "enabled"        => "Yes",
                   "exclude"        => "er0ckSet2.0",
                   "failovermethod" => "roundrobin",
                   "include"        => "https://er0ck",

data/spec/integration/resource/catalog_spec.rb

@@ -35,7 +35,7 @@ describe Puppet::Resource::Catalog do
       node.stub_everything
 
       Puppet::Node.indirection.expects(:find).returns(node)
-      compiler.expects(:compile).with(node).returns nil
+      compiler.expects(:compile).with(node, anything).returns nil
 
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end