puppet 7.34.0-universal-darwin → 8.0.1-universal-darwin

data/spec/unit/functions/chop_spec.rb

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

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

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

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