puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -1,276 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
-
-describe "egrammar parsing heredoc" do
-  include ParserRspecHelper
-
-  it "parses plain heredoc" do
-    expect(dump(parse("@(END)\nThis is\nheredoc text\nEND\n"))).to eq([
-      "(@()",
-      "  'This is\nheredoc text\n'",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses heredoc with margin" do
-    src = [
-    "@(END)",
-    "   This is",
-    "   heredoc text",
-    "   | END",
-    ""
-    ].join("\n")
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  'This is\nheredoc text\n'",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses heredoc with margin and right newline trim" do
-    src = [
-    "@(END)",
-    "   This is",
-    "   heredoc text",
-    "   |- END",
-    ""
-    ].join("\n")
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  'This is\nheredoc text'",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses syntax and escape specification" do
-    src = <<-CODE
-    @(END:syntax/t)
-    Tex\\tt\\n
-    |- END
-    CODE
-    expect(dump(parse(src))).to eq([
-      "(@(syntax)",
-      "  'Tex\tt\\n'",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses interpolated heredoc expression" do
-    src = <<-CODE
-    @("END")
-    Hello $name
-    |- END
-    CODE
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  (cat 'Hello ' (str $name))",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses interpolated heredoc expression containing escapes" do
-    src = <<-CODE
-    @("END")
-    Hello \\$name
-    |- END
-    CODE
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  (cat 'Hello \\' (str $name))",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses interpolated heredoc expression containing escapes when escaping other things than $" do
-    src = <<-CODE
-    @("END"/t)
-    Hello \\$name
-    |- END
-    CODE
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  (cat 'Hello \\' (str $name))",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses with escaped newlines without preceding whitespace" do
-    src = <<-CODE
-    @(END/L)
-    First Line\\
-     Second Line
-    |- END
-    CODE
-    parse(src)
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  'First Line Second Line'",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses with escaped newlines with proper margin" do
-    src = <<-CODE
-    @(END/L)
-     First Line\\
-      Second Line
-    |- END
-    CODE
-    parse(src)
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  ' First Line  Second Line'",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses interpolated heredoc expression with false start on $" do
-    src = <<-CODE
-    @("END")
-    Hello $name$%a
-    |- END
-    CODE
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  (cat 'Hello ' (str $name) '$%a')",
-      ")"
-    ].join("\n"))
-  end
-
-  it "parses interpolated [] expression by looking at the correct preceding char for space when there is no heredoc margin" do
-    # NOTE: Important not to use the left margin feature here
-    src = <<-CODE
-$xxxxxxx = @("END")
-${facts['os']['family']}
-XXXXXXX XXX
-END
-CODE
-    expect(dump(parse(src))).to eq([
-      "(= $xxxxxxx (@()",
-      "  (cat (str (slice (slice $facts 'os') 'family')) '",
-      "XXXXXXX XXX",
-      "')",
-      "))"].join("\n"))
-  end
-
-  it "parses interpolated [] expression by looking at the correct preceding char for space when there is a heredoc margin" do
-    # NOTE: Important not to use the left margin feature here - the problem in PUP 9303 is triggered by lines and text before
-    # an interpolation containing []. 
-    src = <<-CODE
-# comment
-# comment
-$xxxxxxx = @("END")
-    1
-    2
-    3
-    4
-    5
-    YYYYY${facts['fqdn']}
-    XXXXXXX XXX
-    | END
-CODE
-    expect(dump(parse(src))).to eq([
-      "(= $xxxxxxx (@()",
-      "  (cat '1", "2", "3", "4", "5",
-      "YYYYY' (str (slice $facts 'fqdn')) '",
-      "XXXXXXX XXX",
-      "')",
-      "))"].join("\n"))
-  end
-
-  it "correctly reports an error location in a nested heredoc with margin" do
-    # NOTE: Important not to use the left margin feature here - the problem in PUP 9303 is triggered by lines and text before
-    # an interpolation containing []. 
-    src = <<-CODE
-# comment
-# comment
-$xxxxxxx = @("END")
-  1
-  2
-  3
-  4
-  5
-  YYYYY${facts]}
-  XXXXXXX XXX
-  | END
-CODE
-    expect{parse(src)}.to raise_error(/Syntax error at '\]' \(line: 9, column: 15\)/)
-  end
-
-  it "correctly reports an error location in a heredoc with line endings escaped" do
-    # DO NOT CHANGE INDENTATION OF THIS HEREDOC
-    src = <<-CODE
-    # line one
-    # line two
-    @("END"/L)
-    First Line\\
-    Second Line ${facts]}
-    |- END
-    CODE
-    expect{parse(src)}.to raise_error(/Syntax error at '\]' \(line: 5, column: 24\)/)
-  end
-
-  it "correctly reports an error location in a heredoc with line endings escaped when there is text in the margin" do
-    # DO NOT CHANGE INDENTATION OR SPACING OF THIS HEREDOC
-    src = <<-CODE
-    # line one
-    # line two
-    @("END"/L)
-    First Line\\
-    Second Line
-  x Third Line ${facts]}
-    |- END
-    # line 8
-    # line 9
-    CODE
-    expect{parse(src)}.to raise_error(/Syntax error at '\]' \(line: 6, column: 23\)/)
-  end
-
-  it "correctly reports an error location in a heredoc with line endings escaped when there is text in the margin" do
-    # DO NOT CHANGE INDENTATION OR SPACING OF THIS HEREDOC
-    src = <<-CODE
-    @(END)
-AAA
- BBB
-  CCC
-   DDD
-    EEE
-     FFF
-    |- END
-    CODE
-    expect(dump(parse(src))).to eq([
-      "(@()",
-      "  'AAA", # no left space trimmed
-      " BBB",
-      "  CCC",
-      "   DDD",
-      "EEE", # left space trimmed
-      " FFF'", # indented one because it is one in from margin marker
-      ")"].join("\n"))
-  end
-
-  it 'parses multiple heredocs on the same line' do
-    src = <<-CODE
-    notice({ @(foo) => @(bar) })
-    hello
-    -foo
-    world
-    -bar
-    notice '!'
-    CODE
-    expect(dump(parse(src))).to eq([
-      '(block',
-      '  (invoke notice ({} ((@()',
-      '    \'    hello\'',
-      '  ) (@()',
-      '    \'    world\'',
-      '  ))))',
-      '  (invoke notice \'!\')',
-      ')'
-    ].join("\n"))
-  end
-
-end

data/spec/unit/pops/parser/parse_lambda_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require_relative 'parser_rspec_helper'
-
-describe 'egrammar parsing lambda definitions' do
-  include ParserRspecHelper
-
-  context 'without return type' do
-    it 'f() |$x| { 1 }' do
-      expect(dump(parse('f() |$x| { 1 }'))).to eq("(invoke f (lambda (parameters x) (block\n  1\n)))")
-    end
-  end
-
-  context 'with return type' do
-    it 'f() |$x| >> Integer { 1 }' do
-      expect(dump(parse('f() |$x| >> Integer { 1 }'))).to eq("(invoke f (lambda (parameters x) (return_type Integer) (block\n  1\n)))")
-    end
-  end
-end

data/spec/unit/pops/parser/parse_plan_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require_relative 'parser_rspec_helper'
-
-describe "egrammar parsing of 'plan'" do
-  include ParserRspecHelper
-
-  context 'with --tasks' do
-    before(:each) do
-      Puppet[:tasks] = true
-    end
-
-    it "an empty body" do
-      expect(dump(parse("plan foo { }"))).to eq("(plan foo ())")
-    end
-
-    it "a non empty body" do
-      prog = <<-EPROG
-  plan foo {
-    $a = 10
-    $b = 20
-  }
-  EPROG
-      expect(dump(parse(prog))).to eq( [
-  "(plan foo (block",
-  "  (= $a 10)",
-  "  (= $b 20)",
-  "))",
-  ].join("\n"))
-    end
-
-    it "accepts parameters" do
-      s = "plan foo($p1 = 'yo', $p2) { }"
-      expect(dump(parse(s))).to eq("(plan foo (parameters (= p1 'yo') p2) ())")
-    end
-  end
-
-  context 'with --no-tasks' do
-    before(:each) do
-      Puppet[:tasks] = false
-    end
-
-    it "the keyword 'plan' is a name" do
-      expect(dump(parse("$a = plan"))).to eq("(= $a plan)")
-    end
-  end
-end

data/spec/unit/pops/parser/parse_resource_spec.rb

@@ -1,328 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
-
-describe "egrammar parsing resource declarations" do
-  include ParserRspecHelper
-
-  context "When parsing regular resource" do
-    ["File", "file"].each do |word|
-      it "#{word} { 'title': }" do
-        expect(dump(parse("#{word} { 'title': }"))).to eq([
-          "(resource #{word}",
-          "  ('title'))"
-        ].join("\n"))
-      end
-
-      it "#{word} { 'title': path => '/somewhere', mode => '0777'}" do
-        expect(dump(parse("#{word} { 'title': path => '/somewhere', mode => '0777'}"))).to eq([
-          "(resource #{word}",
-          "  ('title'",
-          "    (path => '/somewhere')",
-          "    (mode => '0777')))"
-        ].join("\n"))
-      end
-
-      it "#{word} { 'title': path => '/somewhere', }" do
-        expect(dump(parse("#{word} { 'title': path => '/somewhere', }"))).to eq([
-          "(resource #{word}",
-          "  ('title'",
-          "    (path => '/somewhere')))"
-        ].join("\n"))
-      end
-
-      it "#{word} { 'title': , }" do
-        expect(dump(parse("#{word} { 'title': , }"))).to eq([
-          "(resource #{word}",
-          "  ('title'))"
-        ].join("\n"))
-      end
-
-      it "#{word} { 'title': ; }" do
-        expect(dump(parse("#{word} { 'title': ; }"))).to eq([
-          "(resource #{word}",
-          "  ('title'))"
-        ].join("\n"))
-      end
-
-      it "#{word} { 'title': ; 'other_title': }" do
-        expect(dump(parse("#{word} { 'title': ; 'other_title': }"))).to eq([
-          "(resource #{word}",
-          "  ('title')",
-          "  ('other_title'))"
-        ].join("\n"))
-      end
-
-      # PUP-2898, trailing ';'
-      it "#{word} { 'title': ; 'other_title': ; }" do
-        expect(dump(parse("#{word} { 'title': ; 'other_title': ; }"))).to eq([
-          "(resource #{word}",
-          "  ('title')",
-          "  ('other_title'))"
-        ].join("\n"))
-      end
-
-      it "#{word} { 'title1': path => 'x'; 'title2': path => 'y'}" do
-        expect(dump(parse("#{word} { 'title1': path => 'x'; 'title2': path => 'y'}"))).to eq([
-          "(resource #{word}",
-          "  ('title1'",
-          "    (path => 'x'))",
-          "  ('title2'",
-          "    (path => 'y')))",
-        ].join("\n"))
-      end
-
-      it "#{word} { title: * => {mode => '0777'} }" do
-        expect(dump(parse("#{word} { title: * => {mode => '0777'}}"))).to eq([
-          "(resource #{word}",
-          "  (title",
-          "    (* => ({} (mode '0777')))))"
-        ].join("\n"))
-      end
-    end
-  end
-
-  context "When parsing (type based) resource defaults" do
-    it "File {  }" do
-      expect(dump(parse("File { }"))).to eq("(resource-defaults File)")
-    end
-
-    it "File { mode => '0777' }" do
-      expect(dump(parse("File { mode => '0777'}"))).to eq([
-        "(resource-defaults File",
-        "  (mode => '0777'))"
-      ].join("\n"))
-    end
-
-    it "File { * => {mode => '0777'} } (even if validated to be illegal)" do
-      expect(dump(parse("File { * => {mode => '0777'}}"))).to eq([
-        "(resource-defaults File",
-        "  (* => ({} (mode '0777'))))"
-      ].join("\n"))
-    end
-  end
-
-  context "When parsing resource override" do
-    it "File['x'] {  }" do
-      expect(dump(parse("File['x'] { }"))).to eq("(override (slice File 'x'))")
-    end
-
-    it "File['x'] { x => 1 }" do
-      expect(dump(parse("File['x'] { x => 1}"))).to eq([
-        "(override (slice File 'x')",
-        "  (x => 1))"
-        ].join("\n"))
-    end
-
-
-    it "File['x', 'y'] { x => 1 }" do
-      expect(dump(parse("File['x', 'y'] { x => 1}"))).to eq([
-        "(override (slice File ('x' 'y'))",
-        "  (x => 1))"
-        ].join("\n"))
-    end
-
-    it "File['x'] { x => 1, y => 2 }" do
-      expect(dump(parse("File['x'] { x => 1, y=> 2}"))).to eq([
-        "(override (slice File 'x')",
-        "  (x => 1)",
-        "  (y => 2))"
-        ].join("\n"))
-    end
-
-    it "File['x'] { x +> 1 }" do
-      expect(dump(parse("File['x'] { x +> 1}"))).to eq([
-        "(override (slice File 'x')",
-        "  (x +> 1))"
-        ].join("\n"))
-    end
-
-    it "File['x'] { * => {mode => '0777'} } (even if validated to be illegal)" do
-      expect(dump(parse("File['x'] { * => {mode => '0777'}}"))).to eq([
-        "(override (slice File 'x')",
-        "  (* => ({} (mode '0777'))))"
-      ].join("\n"))
-    end
-  end
-
-  context "When parsing virtual and exported resources" do
-    it "parses exported @@file { 'title': }" do
-      expect(dump(parse("@@file { 'title': }"))).to eq("(exported-resource file\n  ('title'))")
-    end
-
-    it "parses virtual @file { 'title': }" do
-      expect(dump(parse("@file { 'title': }"))).to eq("(virtual-resource file\n  ('title'))")
-    end
-
-    it "nothing before the title colon is a syntax error" do
-      expect do
-        parse("@file {: mode => '0777' }")
-      end.to raise_error(/Syntax error/)
-    end
-
-    it "raises error for user error; not a resource" do
-      # The expression results in VIRTUAL, CALL FUNCTION('file', HASH) since the resource body has
-      # no title.
-      expect do
-        parse("@file { mode => '0777' }")
-      end.to raise_error(/Virtual \(@\) can only be applied to a Resource Expression/)
-    end
-
-    it "parses global defaults with @ (even if validated to be illegal)" do
-      expect(dump(parse("@File { mode => '0777' }"))).to eq([
-        "(virtual-resource-defaults File",
-        "  (mode => '0777'))"
-        ].join("\n"))
-    end
-
-    it "parses global defaults with @@ (even if validated to be illegal)" do
-      expect(dump(parse("@@File { mode => '0777' }"))).to eq([
-        "(exported-resource-defaults File",
-        "  (mode => '0777'))"
-        ].join("\n"))
-    end
-
-    it "parses override with @ (even if validated to be illegal)" do
-      expect(dump(parse("@File[foo] { mode => '0777' }"))).to eq([
-        "(virtual-override (slice File foo)",
-        "  (mode => '0777'))"
-        ].join("\n"))
-    end
-
-    it "parses override combined with @@ (even if validated to be illegal)" do
-      expect(dump(parse("@@File[foo] { mode => '0777' }"))).to eq([
-        "(exported-override (slice File foo)",
-        "  (mode => '0777'))"
-        ].join("\n"))
-    end
-  end
-
-  context "When parsing class resource" do
-    it "class { 'cname': }" do
-      expect(dump(parse("class { 'cname': }"))).to eq([
-        "(resource class",
-        "  ('cname'))"
-      ].join("\n"))
-    end
-
-    it "@class { 'cname': }" do
-      expect(dump(parse("@class { 'cname': }"))).to eq([
-        "(virtual-resource class",
-        "  ('cname'))"
-      ].join("\n"))
-    end
-
-    it "@@class { 'cname': }" do
-      expect(dump(parse("@@class { 'cname': }"))).to eq([
-        "(exported-resource class",
-        "  ('cname'))"
-      ].join("\n"))
-    end
-
-    it "class { 'cname': x => 1, y => 2}" do
-      expect(dump(parse("class { 'cname': x => 1, y => 2}"))).to eq([
-        "(resource class",
-        "  ('cname'",
-        "    (x => 1)",
-        "    (y => 2)))"
-      ].join("\n"))
-    end
-
-    it "class { 'cname1': x => 1; 'cname2': y => 2}" do
-      expect(dump(parse("class { 'cname1': x => 1; 'cname2': y => 2}"))).to eq([
-        "(resource class",
-        "  ('cname1'",
-        "    (x => 1))",
-        "  ('cname2'",
-        "    (y => 2)))",
-      ].join("\n"))
-    end
-  end
-
-  context "reported issues in 3.x" do
-    it "should not screw up on brackets in title of resource #19632" do
-      expect(dump(parse('notify { "thisisa[bug]": }'))).to eq([
-        "(resource notify",
-        "  ('thisisa[bug]'))",
-      ].join("\n"))
-    end
-  end
-
-  context "When parsing Relationships" do
-    it "File[a] -> File[b]" do
-      expect(dump(parse("File[a] -> File[b]"))).to eq("(-> (slice File a) (slice File b))")
-    end
-
-    it "File[a] <- File[b]" do
-      expect(dump(parse("File[a] <- File[b]"))).to eq("(<- (slice File a) (slice File b))")
-    end
-
-    it "File[a] ~> File[b]" do
-      expect(dump(parse("File[a] ~> File[b]"))).to eq("(~> (slice File a) (slice File b))")
-    end
-
-    it "File[a] <~ File[b]" do
-      expect(dump(parse("File[a] <~ File[b]"))).to eq("(<~ (slice File a) (slice File b))")
-    end
-
-    it "Should chain relationships" do
-      expect(dump(parse("a -> b -> c"))).to eq(
-      "(-> (-> a b) c)"
-      )
-    end
-
-    it "Should chain relationships" do
-      expect(dump(parse("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"))).to eq(
-      "(<~ (<- (~> (-> (slice File a) (slice File b)) (slice File c)) (slice File d)) (slice File e))"
-      )
-    end
-
-    it "should create relationships between collects" do
-      expect(dump(parse("File <| mode == 0644 |> -> File <| mode == 0755 |>"))).to eq(
-      "(-> (collect File\n  (<| |> (== mode 0644))) (collect File\n  (<| |> (== mode 0755))))"
-      )
-    end
-  end
-
-  context "When parsing collection" do
-    context "of virtual resources" do
-      it "File <| |>" do
-        expect(dump(parse("File <| |>"))).to eq("(collect File\n  (<| |>))")
-      end
-    end
-
-    context "of exported resources" do
-      it "File <<| |>>" do
-        expect(dump(parse("File <<| |>>"))).to eq("(collect File\n  (<<| |>>))")
-      end
-    end
-
-    context "queries are parsed with correct precedence" do
-      it "File <| tag == 'foo' |>" do
-        expect(dump(parse("File <| tag == 'foo' |>"))).to eq("(collect File\n  (<| |> (== tag 'foo')))")
-      end
-
-      it "File <| tag == 'foo' and mode != '0777' |>" do
-        expect(dump(parse("File <| tag == 'foo' and mode != '0777' |>"))).to eq("(collect File\n  (<| |> (&& (== tag 'foo') (!= mode '0777'))))")
-      end
-
-      it "File <| tag == 'foo' or mode != '0777' |>" do
-        expect(dump(parse("File <| tag == 'foo' or mode != '0777' |>"))).to eq("(collect File\n  (<| |> (|| (== tag 'foo') (!= mode '0777'))))")
-      end
-
-      it "File <| tag == 'foo' or tag == 'bar' and mode != '0777' |>" do
-        expect(dump(parse("File <| tag == 'foo' or tag == 'bar' and mode != '0777' |>"))).to eq(
-        "(collect File\n  (<| |> (|| (== tag 'foo') (&& (== tag 'bar') (!= mode '0777')))))"
-        )
-      end
-
-      it "File <| (tag == 'foo' or tag == 'bar') and mode != '0777' |>" do
-        expect(dump(parse("File <| (tag == 'foo' or tag == 'bar') and mode != '0777' |>"))).to eq(
-        "(collect File\n  (<| |> (&& (|| (== tag 'foo') (== tag 'bar')) (!= mode '0777'))))"
-        )
-      end
-    end
-  end
-end

data/spec/unit/pops/parser/parser_rspec_helper.rb

@@ -1,17 +0,0 @@
-require 'puppet/pops'
-
-require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
-
-module ParserRspecHelper
-  include FactoryRspecHelper
-
-  def parse(code)
-    parser = Puppet::Pops::Parser::Parser.new()
-    parser.parse_string(code)
-  end
-
-  def parse_epp(code)
-    parser = Puppet::Pops::Parser::EppParser.new()
-    parser.parse_string(code)
-  end
-end