puppet 7.31.0-universal-darwin → 8.0.1-universal-darwin

data/spec/integration/parser/parameter_defaults_spec.rb

@@ -0,0 +1,358 @@
+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')) }
+
+    let (:topscope) { compiler.topscope }
+
+    def collect_notices(code)
+      logs = []
+      Puppet[:code] = code
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          compiler.compile do |catalog|
+            yield
+            catalog
+          end
+      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, [], /expects a value for parameter \$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/pcore_resource_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/compiler'
+
+require 'puppet/face'
+
+describe 'when pcore described resources types are in use' do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+
+  let(:genface) { Puppet::Face[:generate, :current] }
+
+  context "in an environment with two modules" do
+    let(:dir) do
+      dir_containing('environments', { 'production' => {
+        'environment.conf' => "modulepath = modules",
+        'manifests' => { 'site.pp' => "" },
+        'modules' => {
+          'm1' => {
+            'lib' => { 'puppet' => { 'type' => {
+              'test1.rb' => <<-EOF
+              module Puppet
+              Type.newtype(:test1) do
+                @doc = "Docs for resource"
+                newproperty(:message) do
+                  desc "Docs for 'message' property"
+                end
+                newparam(:name) do
+                  desc "Docs for 'name' parameter"
+                  isnamevar
+                end
+                newparam(:whatever) do
+                  desc "Docs for 'whatever' parameter"
+                end
+              end; end
+              EOF
+             } }
+          },
+        },
+        'm2' => {
+          'lib' => { 'puppet' => { 'type' => {
+            'test2.rb' => <<-EOF,
+            module Puppet
+            Type.newtype(:test2) do
+              @doc = "Docs for resource"
+              @isomorphic = false
+              newproperty(:message) do
+                desc "Docs for 'message' property"
+              end
+              newparam(:name) do
+                desc "Docs for 'name' parameter"
+                isnamevar
+              end
+              newparam(:color) do
+                desc "Docs for 'color' parameter"
+                newvalues(:red, :green, :blue, /#[0-9A-Z]{6}/)
+              end
+            end;end
+            EOF
+            'test3.rb' => <<-RUBY,
+              Puppet::Type.newtype(:test3) do
+                newproperty(:message)
+                newparam(:a) { isnamevar }
+                newparam(:b) { isnamevar }
+                newparam(:c) { isnamevar }
+                def self.title_patterns
+                  [ [ /^((.+)\\/(.*))$/,  [[:a], [:b], [:c]]] ]
+                end
+              end
+            RUBY
+           } } },
+        }
+      }}})
+    end
+
+    let(:modulepath) do
+      File.join(dir, 'production', 'modules')
+    end
+
+    let(:m1) do
+      File.join(modulepath, 'm1')
+    end
+
+    let(:m2) do
+      File.join(modulepath, 'm2')
+    end
+
+    let(:outputdir) do
+      File.join(dir, 'production', '.resource_types')
+    end
+
+    around(:each) do |example|
+      Puppet.settings.initialize_global_settings
+      Puppet[:manifest] = ''
+      loader = Puppet::Environments::Directories.new(dir, [])
+      Puppet.override(:environments => loader) do
+        Puppet.override(:current_environment => loader.get('production')) do
+          example.run
+        end
+      end
+    end
+
+    it 'can use generated types to compile a catalog' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'a works'
+        }
+        # Several instances of the type can be created - implicit test
+        test1 { 'another a':
+          message => 'another a works'
+        }
+        test2 { 'b':
+          message => 'b works'
+        }
+        test3 { 'x/y':
+          message => 'x/y works'
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a")['message']).to eq('a works')
+      expect(catalog.resource(:test2, "b")['message']).to eq('b works')
+      expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
+    end
+
+    it 'considers Pcore types to be builtin ' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'a works'
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a").kind).to eq('compilable_type')
+    end
+
+    it 'considers Pcore types to be builtin ' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'a works'
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a").kind).to eq('compilable_type')
+    end
+
+    it 'the validity of attribute names are checked' do
+      genface.types
+      expect do
+        compile_to_catalog(<<-MANIFEST)
+          test1 { 'a':
+            mezzage => 'a works'
+          }
+        MANIFEST
+      end.to raise_error(/no parameter named 'mezzage'/)
+    end
+
+    it 'meta-parameters such as noop can be used' do
+      genface.types
+      catalog = compile_to_catalog(<<-MANIFEST)
+        test1 { 'a':
+          message => 'noop works',
+          noop => true
+        }
+      MANIFEST
+      expect(catalog.resource(:test1, "a")['noop']).to eq(true)
+    end
+
+    it 'a generated type describes if it is isomorphic' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.isomorphic?).to be(true)
+        t2 = find_resource_type(compiler.topscope, 'test2')
+        expect(t2.isomorphic?).to be(false)
+      end
+    end
+
+    it 'a generated type returns parameters defined in pcore' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.parameters.size).to be(2)
+        expect(t1.parameters[0].name).to eql('name')
+        expect(t1.parameters[1].name).to eql('whatever')
+      end
+    end
+
+    it 'a generated type picks up and returns if a parameter is a namevar' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.parameters[0].name_var).to be(true)
+        expect(t1.parameters[1].name_var).to be(false)
+      end
+    end
+
+    it 'a generated type returns properties defined in pcore' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.properties.size).to be(1)
+        expect(t1.properties[0].name).to eql('message')
+      end
+    end
+
+    it 'a generated type returns [[/(.*)/m, <first attr>]] as default title_pattern when there is a namevar but no pattern specified' do
+      generate_and_in_a_compilers_context do |compiler|
+        t1 = find_resource_type(compiler.topscope, 'test1')
+        expect(t1.title_patterns.size).to be(1)
+        expect(t1.title_patterns[0][0]).to eql(/(?m-ix:(.*))/)
+      end
+    end
+
+    it "the compiler asserts the type of parameters" do
+      pending "assertion of parameter types not yet implemented"
+      genface.types
+      expect {
+      compile_to_catalog(<<-MANIFEST)
+        test2 { 'b':
+          color => 'white is not a color'
+        }
+      MANIFEST
+      }.to raise_error(/an error indicating that color cannot have that value/) # ERROR TBD.
+    end
+  end
+
+  def find_resource_type(scope, name)
+    Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, name)
+  end
+
+  def generate_and_in_a_compilers_context(&block)
+    genface.types
+    # Since an instance of a compiler is needed and it starts an initial import that evaluates
+    # code, and that code will be loaded from manifests with a glob (go figure)
+    # the only way to stop that is to set 'code' to something as that overrides "importing" files.
+    Puppet[:code] = "undef"
+    node = Puppet::Node.new('test')
+    # All loading must be done in a context configured as the compiler does it.
+    # (Therefore: use the context a compiler creates as this test logic must otherwise
+    #  know how to do this).
+    #
+    compiler = Puppet::Parser::Compiler.new(node)
+    Puppet::override(compiler.context_overrides) do
+      block.call(compiler)
+    end
+  end
+
+end