puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/integration/parser/parameter_defaults_spec.rb

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

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