puppet 8.4.0-x86-mingw32 → 8.5.0-x86-mingw32

data/spec/unit/functions/chop_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the chop function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'removes last character in a string' do
-    expect(compile_to_catalog("notify { String('abc'.chop == 'ab'): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns empty string for an empty string' do
-    expect(compile_to_catalog("notify { String(''.chop == ''): }")).to have_resource('Notify[true]')
-  end
-
-  it 'removes both CR LF if both are the last characters in a string' do
-    expect(compile_to_catalog("notify { String(\"abc\r\n\".chop == 'abc'): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns the value if Numeric' do
-    expect(compile_to_catalog("notify { String(42.chop == 42): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns chopped version of each entry in an array' do
-    expect(compile_to_catalog("notify { String(['aa', 'ba', 'ca'].chop == ['a', 'b', 'c']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns chopped version of each entry in an Iterator' do
-    expect(compile_to_catalog("notify { String(['aa', 'bb', 'cc'].reverse_each.chop == ['c', 'b', 'a']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'errors when given a a nested Array' do
-    expect { compile_to_catalog("['a', 'b', ['c']].chop")}.to raise_error(/'chop' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
-  end
-
-end

data/spec/unit/functions/compare_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the compare function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  {
-    [0, 1]     => -1,
-    [1, 0]     => 1,
-    [1, 1]     => 0,
-    [0.0, 1.0] => -1,
-    [1.0, 0.0] => 1,
-    [1.0, 1.0] => 0,
-    [0.0, 1]   => -1,
-    [1.0, 0]   => 1,
-    [1.0, 1]   => 0,
-    [0, 1.0]   => -1,
-    [1, 0.0]   => 1,
-    [1, 1.0]   => 0,
-  }.each_pair do |values, expected|
-    it "compares numeric/numeric such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
-      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  {
-    ['"a"', '"b"'] => -1,
-    ['"b"', '"a"'] => 1,
-    ['"b"', '"b"'] => 0,
-    ['"A"', '"b"'] => -1,
-    ['"B"', '"a"'] => 1,
-    ['"B"', '"b"'] => 0,
-  }.each_pair do |values, expected|
-    it "compares String values by default such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
-      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-
-    it "compares String values with third true arg such that compare(#{values[0]}, #{values[1]}, true) returns #{expected}" do
-      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}, true) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  {
-    ['"a"', '"b"'] => -1,
-    ['"b"', '"a"'] => 1,
-    ['"b"', '"b"'] => 0,
-    ['"A"', '"b"'] => -1,
-    ['"B"', '"a"'] => -1,
-    ['"B"', '"b"'] => -1,
-  }.each_pair do |values, expected|
-    it "compares String values with third arg false such that compare(#{values[0]}, #{values[1]}, false) returns #{expected}" do
-      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}, false) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  {
-    ["Semver('1.0.0')", "Semver('2.0.0')"] => -1,
-    ["Semver('2.0.0')", "Semver('1.0.0')"] => 1,
-    ["Semver('2.0.0')", "Semver('2.0.0')"] => 0,
-  }.each_pair do |values, expected|
-    it "compares Semver values such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
-      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  {
-    ["Timespan(1)", "Timespan(2)"] => -1,
-    ["Timespan(2)", "Timespan(1)"] => 1,
-    ["Timespan(1)", "Timespan(1)"] => 0,
-    ["Timespan(1)", 2] => -1,
-    ["Timespan(2)", 1] => 1,
-    ["Timespan(1)", 1] => 0,
-    [1, "Timespan(2)"] => -1,
-    [2, "Timespan(1)"] => 1,
-    [1, "Timespan(1)"] => 0,
-
-    ["Timestamp(1)", "Timestamp(2)"] => -1,
-    ["Timestamp(2)", "Timestamp(1)"] => 1,
-    ["Timestamp(1)", "Timestamp(1)"] => 0,
-    ["Timestamp(1)", 2] => -1,
-    ["Timestamp(2)", 1] => 1,
-    ["Timestamp(1)", 1] => 0,
-    [1, "Timestamp(2)"] => -1,
-    [2, "Timestamp(1)"] => 1,
-    [1, "Timestamp(1)"] => 0,
-
-  }.each_pair do |values, expected|
-    it "compares time values such that compare(#{values[0]}, #{values[1]}) returns #{expected}" do
-      expect(compile_to_catalog("notify { String( compare(#{values[0]},#{values[1]}) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  context "errors when" do
-    [ [true, false],
-      ['/x/', '/x/'],
-      ['undef', 'undef'],
-      ['undef', 1],
-      [1, 'undef'],
-      [[1], [1]],
-      [{'a' => 1}, {'b' => 1}],
-    ].each do |a, b|
-      it "given values of non comparable types #{a.class}, #{b.class}" do
-        expect { compile_to_catalog("compare(#{a},#{b})")}.to raise_error(/Non comparable type/)
-      end
-    end
-
-    [
-      [10, '"hello"'],
-      ['"hello"', 10],
-      [10.0, '"hello"'],
-      ['"hello"', 10.0],
-      ['Timespan(1)', '"hello"'],
-      ['Timestamp(1)', '"hello"'],
-      ['Timespan(1)', 'Semver("1.2.3")'],
-      ['Timestamp(1)', 'Semver("1.2.3")'],
-    ].each do |a, b|
-      it "given values of comparable, but incompatible types #{a.class}, #{b.class}" do
-        expect { compile_to_catalog("compare(#{a},#{b})")}.to raise_error(/Can only compare values of the same type/)
-      end
-    end
-
-      [
-        [10, 10],
-        [10.0, 10],
-        ['Timespan(1)', 'Timespan(1)'],
-        ['Timestamp(1)', 'Timestamp(1)'],
-        ['Semver("1.2.3")', 'Semver("1.2.3")'],
-      ].each do |a, b|
-        it "given ignore case true when values are comparable, but not both being strings" do
-          expect { compile_to_catalog("compare(#{a},#{b}, true)")}.to raise_error(/can only be used when comparing strings/)
-        end
-        it "given ignore case false when values are comparable, but not both being strings" do
-          expect { compile_to_catalog("compare(#{a},#{b}, false)")}.to raise_error(/can only be used when comparing strings/)
-        end
-      end
-
-      it "given more than three arguments" do
-          expect { compile_to_catalog("compare('a','b', false, false)")}.to raise_error(/Accepts at most 3 arguments, got 4/)
-      end
-  end
-
-  # Error if not the same except Timestamp and Timespan that accepts Numeric on either side
-  # Error for non supported - Boolean, Regexp, etc
-end

data/spec/unit/functions/contain_spec.rb

@@ -1,297 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'puppet/parser/functions'
-require 'matchers/containment_matchers'
-require 'matchers/resource'
-require 'matchers/include_in_order'
-require 'unit/functions/shared'
-
-describe 'The "contain" function' do
-  include PuppetSpec::Compiler
-  include ContainmentMatchers
-  include Matchers::Resource
-
-  before(:each) do
-    compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-    @scope = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it "includes the class" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class contained {
-        notify { "contained": }
-      }
-
-      class container {
-        contain contained
-      }
-
-      include container
-    MANIFEST
-
-    expect(catalog.classes).to include("contained")
-  end
-
-  it "includes the class when using a fully qualified anchored name" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class contained {
-        notify { "contained": }
-      }
-
-      class container {
-        contain ::contained
-      }
-
-      include container
-    MANIFEST
-
-    expect(catalog.classes).to include("contained")
-  end
-
-  it "ensures that the edge is with the correct class" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class outer {
-        class named { }
-        contain outer::named
-      }
-
-      class named { }
-
-      include named
-      include outer
-    MANIFEST
-
-    expect(catalog).to have_resource("Class[Named]")
-    expect(catalog).to have_resource("Class[Outer]")
-    expect(catalog).to have_resource("Class[Outer::Named]")
-    expect(catalog).to contain_class("outer::named").in("outer")
-  end
-
-  it "makes the class contained in the current class" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class contained {
-        notify { "contained": }
-      }
-
-      class container {
-        contain contained
-      }
-
-      include container
-    MANIFEST
-
-    expect(catalog).to contain_class("contained").in("container")
-  end
-
-  it "can contain multiple classes" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class a {
-        notify { "a": }
-      }
-
-      class b {
-        notify { "b": }
-      }
-
-      class container {
-        contain a, b
-      }
-
-      include container
-    MANIFEST
-
-    expect(catalog).to contain_class("a").in("container")
-    expect(catalog).to contain_class("b").in("container")
-  end
-
-  context "when containing a class in multiple classes" do
-    it "creates a catalog with all containment edges" do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        class contained {
-          notify { "contained": }
-        }
-
-        class container {
-          contain contained
-        }
-
-        class another {
-          contain contained
-        }
-
-        include container
-        include another
-      MANIFEST
-
-      expect(catalog).to contain_class("contained").in("container")
-      expect(catalog).to contain_class("contained").in("another")
-    end
-
-    it "and there are no dependencies applies successfully" do
-      manifest = <<-MANIFEST
-        class contained {
-          notify { "contained": }
-        }
-
-        class container {
-          contain contained
-        }
-
-        class another {
-          contain contained
-        }
-
-        include container
-        include another
-      MANIFEST
-
-      expect { apply_compiled_manifest(manifest) }.not_to raise_error
-    end
-
-    it "and there are explicit dependencies on the containing class causes a dependency cycle" do
-      manifest = <<-MANIFEST
-        class contained {
-          notify { "contained": }
-        }
-
-        class container {
-          contain contained
-        }
-
-        class another {
-          contain contained
-        }
-
-        include container
-        include another
-
-        Class["container"] -> Class["another"]
-      MANIFEST
-
-      expect { apply_compiled_manifest(manifest) }.to raise_error(
-        Puppet::Error,
-        /One or more resource dependency cycles detected in graph/
-      )
-    end
-  end
-
-  it "does not create duplicate edges" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class contained {
-        notify { "contained": }
-      }
-
-      class container {
-        contain contained
-        contain contained
-      }
-
-      include container
-    MANIFEST
-
-    contained = catalog.resource("Class", "contained")
-    container = catalog.resource("Class", "container")
-
-    expect(catalog.edges_between(container, contained).count).to eq 1
-  end
-
-  context "when a containing class has a dependency order" do
-    it "the contained class is applied in that order" do
-      catalog = compile_to_relationship_graph(<<-MANIFEST)
-        class contained {
-          notify { "contained": }
-        }
-
-        class container {
-          contain contained
-        }
-
-        class first {
-          notify { "first": }
-        }
-
-        class last {
-          notify { "last": }
-        }
-
-        include container, first, last
-
-        Class["first"] -> Class["container"] -> Class["last"]
-      MANIFEST
-
-      expect(order_resources_traversed_in(catalog)).to include_in_order(
-        "Notify[first]", "Notify[contained]", "Notify[last]"
-      )
-    end
-  end
-
-  it 'produces an array with a single class references given a single argument' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class a {
-        notify { "a": }
-      }
-
-      class container {
-        $x = contain(a)
-        Array[Type[Class], 1, 1].assert_type($x)
-        notify { 'feedback': message => "$x" }
-      }
-
-      include container
-    MANIFEST
-
-    feedback = catalog.resource("Notify", "feedback")
-    expect(feedback[:message]).to eql("[Class[a]]")
-  end
-
-  it 'produces an array with class references given multiple arguments' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class a {
-        notify { "a": }
-      }
-
-      class b {
-        notify { "b": }
-      }
-
-      class container {
-        $x = contain(a, b)
-        Array[Type[Class], 2, 2].assert_type($x)
-        notify { 'feedback': message => "$x" }
-      }
-
-      include container
-    MANIFEST
-
-    feedback = catalog.resource("Notify", "feedback")
-    expect(feedback[:message]).to eql("[Class[a], Class[b]]")
-  end
-
-  it 'allows the result to be used in a relationship operation' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class a {
-        notify { "a": }
-      }
-
-      class b {
-        notify { "b": }
-      }
-
-      notify { 'c': }
-
-      class container {
-        contain(a, b) -> Notify[c]
-      }
-
-      include container
-    MANIFEST
-
-    # Assert relationships are formed
-    expect(catalog.resource("Class", "a")[:before][0]).to eql('Notify[c]')
-    expect(catalog.resource("Class", "b")[:before][0]).to eql('Notify[c]')
-  end
-
-  it_should_behave_like 'all functions transforming relative to absolute names', :contain
-  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :contain
-  it_should_behave_like 'an inclusion function, when --tasks is on,', :contain
-end

data/spec/unit/functions/convert_to_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the convert_to function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'converts and returns the converted when no lambda is given' do
-    expect(compile_to_catalog('notify{ "testing-${[a,1].convert_to(Hash) =~ Hash}": }')).to have_resource('Notify[testing-true]')
-  end
-
-  it 'converts given value to instance of type and calls a lambda with converted value' do
-    expect(compile_to_catalog('"1".convert_to(Integer) |$x| { notify { "testing-${x.type(generalized)}": } }')).to have_resource('Notify[testing-Integer]')
-  end
-
-  it 'returns the lambda return when lambda is given' do
-    expect(compile_to_catalog('notify{ "testing-${[a,1].convert_to(Hash) |$x| { yay }}": }')).to have_resource('Notify[testing-yay]')
-  end
-
-  it 'passes on additional arguments to the new function' do
-    expect(compile_to_catalog('"111".convert_to(Integer, 2) |$x| { notify { "testing-${x}": } }')).to have_resource('Notify[testing-7]')
-  end
-end