puppet 4.7.1-x64-mingw32 → 4.8.0-x64-mingw32

data/spec/unit/capability_spec.rb

@@ -391,4 +391,26 @@ test { one: hostname => "ahost", export => Cap[two] }
       end
     end
   end
+
+  context 'and aliased resources' do
+    let(:drive) { Puppet.features.microsoft_windows? ? 'C:' : '' }
+    let(:code) { <<-PUPPET }
+      $dir='#{drive}/tmp/test'
+      $same_dir='#{drive}/tmp/test/'
+
+      file {$dir:
+        ensure => directory
+      }
+
+      if !defined(File["${same_dir}"]) {
+        file { $same_dir:
+          ensure => directory
+        }
+      }
+    PUPPET
+
+    it 'fails if a resource is defined and then redefined using name that results in the same alias' do
+      expect { compile_to_ral(code) }.to raise_error(/resource \["File", "#{drive}\/tmp\/test"\] already declared/)
+    end
+  end
 end

data/spec/unit/configurer_spec.rb

@@ -424,6 +424,14 @@ describe Puppet::Configurer do
     end
   end
 
+  describe "when initialized with a transaction_uuid" do
+    it "stores it" do
+      SecureRandom.expects(:uuid).never
+      configurer = Puppet::Configurer.new(Puppet::Configurer::DownloaderFactory.new, 'foo')
+      expect(configurer.instance_variable_get(:@transaction_uuid) == 'foo')
+    end
+  end
+
   describe "when sending a report" do
     include PuppetSpec::Files
 

data/spec/unit/face/epp_face_spec.rb

@@ -102,9 +102,6 @@ describe Puppet::Face[:epp, :current] do
     end
   end
 
-  context "render" do
-
-  end
 
   context "dump" do
     it "prints the AST of a template given with the -e option" do
@@ -232,6 +229,28 @@ describe Puppet::Face[:epp, :current] do
         ).to eq("goodbye mr Y")
     end
 
+    it "sets $facts" do
+      expect(eppface.render({ :e => 'facts is hash: <%= $facts =~ Hash %>' })).to eql("facts is hash: true")
+    end
+
+    it "sets $trusted" do
+      expect(eppface.render({ :e => 'trusted is hash: <%= $trusted =~ Hash %>' })).to eql("trusted is hash: true")
+    end
+
+    it "facts can be added to" do
+      expect(eppface.render({
+        :facts => {'the_crux' => 'biscuit'},
+        :e     => '<%= $facts[the_crux] %>', 
+      })).to eql("biscuit")
+    end
+
+    it "facts can be overridden" do
+      expect(eppface.render({
+        :facts => {'operatingsystem' => 'Merwin'},
+        :e     => '<%= $facts[operatingsystem] %>', 
+      })).to eql("Merwin")
+    end
+
     context "in an environment with templates" do
       let(:dir) do
         dir_containing('environments', { 'production' => { 'modules' => {

data/spec/unit/functions/assert_type_spec.rb

@@ -22,7 +22,7 @@ describe 'the assert_type function' do
   it 'asserts non compliant type by raising an error' do
     expect do
       func.call({}, type(Integer), 'hello world')
-    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /expected an Integer value, got String/)
+    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /expects an Integer value, got String/)
   end
 
   it 'checks that first argument is a type' do
@@ -84,7 +84,7 @@ describe 'the assert_type function' do
       assert_type(UnprivilegedPort, 345)
       notice('ok')
     CODE
-    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expected an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[345, 345\]/)
+    expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error, /expects an UnprivilegedPort = Integer\[1024, 65537\] value, got Integer\[345, 345\]/)
   end
 
   it 'will use infer_set to report detailed information about complex mismatches' do
@@ -92,6 +92,6 @@ describe 'the assert_type function' do
       assert_type(Struct[{a=>Integer,b=>Boolean}], {a=>hej,x=>s})
     CODE
     expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
-      /entry 'a' expected an Integer value, got String.*expected a value for key 'b'.*unrecognized key 'x'/m)
+      /entry 'a' expects an Integer value, got String.*expects a value for key 'b'.*unrecognized key 'x'/m)
   end
 end

data/spec/unit/functions/binary_file_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the binary_file function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  def with_file_content(content)
+    path = tmpfile('find-file-function')
+    file = File.new(path, 'wb')
+    file.sync = true
+    file.print content
+    yield path
+  end
+
+  it 'reads an existing absolute file' do
+    with_file_content('one') do |one|
+      # Note that Binary to String produced Base64 encoded version of 'one' which is 'b23l'
+      expect(compile_to_catalog("notify { String(binary_file('#{one}')):}")).to have_resource("Notify[b25l]")
+    end
+  end
+
+  it 'errors on non existing files' do
+    expect do
+      with_file_content('one') do |one|
+        compile_to_catalog("notify { binary_file('#{one}/nope'):}")
+      end
+    end.to raise_error(/The given file '.*' does not exist/)
+  end
+
+  it 'reads an existing file in a module' do
+    with_file_content('binary_data') do |name|
+      mod = mock 'module'
+      mod.stubs(:file).with('myfile').returns(name)
+      Puppet[:code] = "notify { String(binary_file('mymod/myfile')):}"
+      node = Puppet::Node.new('localhost')
+      compiler = Puppet::Parser::Compiler.new(node)
+      compiler.environment.stubs(:module).with('mymod').returns(mod)
+      # Note that the Binary to string produces Base64 encoded version of 'binary_data' which is 'YmluYXJ5X2RhdGE='
+      expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[YmluYXJ5X2RhdGE=]")
+    end
+  end
+end

data/spec/unit/functions/break_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the break function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context  do
+    it 'breaks iteration as if at end of input' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
+          function please_break() {
+            [1,2,3].map |$x| { if $x == 3 { break() } $x }
+          }
+          notify { String(please_break()): }
+        CODE
+    end
+  end
+
+  it 'does not provide early exit from a class' do
+    # A break would semantically mean that the class should not be included - as if the
+    # iteration over class names should stop. That is too magic and should
+    # be done differently by the user.
+    #
+    expect do
+      compile_to_catalog(<<-CODE)
+        class does_break {
+          notice 'a'
+          if 1 == 1 { break() } # avoid making next line statically unreachable
+          notice 'b'
+        }
+        include(does_break)
+      CODE
+    end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
+
+    it 'does not provide early exit from a define' do
+      # A break would semantically mean that the resource should not be created - as if the
+      # iteration over resource titles should stop. That is too magic and should
+      # be done differently by the user.
+      #
+      expect do
+        compile_to_catalog(<<-CODE)
+          define does_break {
+            notice 'a'
+            if 1 == 1 { break() } # avoid making next line statically unreachable
+            notice 'b'
+          }
+            does_break { 'no_you_cannot': }
+        CODE
+      end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+    end
+
+  it 'can be called when nested in a function to make that function behave as a break' do
+    # This allows functions like break_when(...) to be implemented by calling break() conditionally
+    #
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['[100]'])
+      function nested_break($x) {
+        if $x == 2 { break() } else { $x * 100 }
+      }
+      function example() {
+        [1,2,3].map |$x| { nested_break($x)  }
+      }
+      notice example()
+      CODE
+  end
+
+  it 'can not be called nested from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        $result = with(1) |$x| { with($x) |$x| {break() }}
+        notice $result
+      CODE
+    end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
+
+  it 'can not be called from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        break()
+      CODE
+    end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
+end

data/spec/unit/{parser/functions → functions}/contain_spec.rb

@@ -5,7 +5,7 @@ require 'puppet/parser/functions'
 require 'matchers/containment_matchers'
 require 'matchers/resource'
 require 'matchers/include_in_order'
-require 'unit/parser/functions/shared'
+require 'unit/functions/shared'
 
 
 describe 'The "contain" function' do
@@ -227,7 +227,72 @@ describe 'The "contain" function' do
     end
   end
 
-  it_should_behave_like 'all functions transforming relative to absolute names', :function_contain
-  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :contain
+  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
 end

data/spec/unit/functions/find_file_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the find_file function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  def with_file_content(content)
+    path = tmpfile('find-file-function')
+    file = File.new(path, 'wb')
+    file.sync = true
+    file.print content
+    yield path
+  end
+
+  it 'finds an existing absolute file when given arguments individually' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_file('#{one}', '#{two}'):}")).to have_resource("Notify[#{one}]")
+      end
+    end
+  end
+
+  it 'skips non existing files' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_file('#{one}/nope', '#{two}'):}")).to have_resource("Notify[#{two}]")
+      end
+    end
+  end
+
+  it 'accepts arguments given as an array' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_file(['#{one}', '#{two}']):}")).to have_resource("Notify[#{one}]")
+      end
+    end
+  end
+
+  it 'finds an existing file in a module' do
+    with_file_content('file content') do |name|
+      mod = mock 'module'
+      mod.stubs(:file).with('myfile').returns(name)
+      Puppet[:code] = "notify { find_file('mymod/myfile'):}"
+      node = Puppet::Node.new('localhost')
+      compiler = Puppet::Parser::Compiler.new(node)
+      compiler.environment.stubs(:module).with('mymod').returns(mod)
+
+      expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[#{name}]")
+    end
+  end
+
+  it 'returns undef when none of the paths were found' do
+    mod = mock 'module'
+    mod.stubs(:file).with('myfile').returns(nil)
+    Puppet[:code] = "notify { String(type(find_file('mymod/myfile', 'nomod/nofile'))):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    # For a module that does not have the file
+    compiler.environment.stubs(:module).with('mymod').returns(mod)
+    # For a module that does not exist
+    compiler.environment.stubs(:module).with('nomod').returns(nil)
+
+    expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[Undef]")
+  end
+end

data/spec/unit/functions/include_spec.rb

@@ -0,0 +1,175 @@
+#! /usr/bin/env ruby
+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 "include" 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 a class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+
+      include included
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+  end
+
+  it "includes a class when using a fully qualified anchored name" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+
+      include ::included
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+  end
+
+  it "includes multiple classes" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+      class included_too {
+        notify { "included_too": }
+      }
+
+      include included, included_too
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+    expect(catalog.classes).to include("included_too")
+  end
+
+  it "includes multiple classes given as an array" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+      class included_too {
+        notify { "included_too": }
+      }
+
+      include [included, included_too]
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+    expect(catalog.classes).to include("included_too")
+  end
+
+  it "flattens nested arrays" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class included {
+        notify { "included": }
+      }
+      class included_too {
+        notify { "included_too": }
+      }
+
+      include [[[included], [[[included_too]]]]]
+    MANIFEST
+
+    expect(catalog.classes).to include("included")
+    expect(catalog.classes).to include("included_too")
+  end
+
+  it "raises an error if class does not exist" do
+    expect {
+      catalog = compile_to_catalog(<<-MANIFEST)
+        include the_god_in_your_religion
+      MANIFEST
+    }.to raise_error(Puppet::Error)
+  end
+
+  it "does not contained the included class in the current class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class not_contained {
+        notify { "not_contained": }
+      }
+
+      class container {
+        include not_contained
+      }
+
+      include container
+    MANIFEST
+
+    expect(catalog).to_not contain_class("not_contained").in("container")
+  end
+
+
+  it 'produces an array with a single class references given a single argument' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class a {
+        notify { "a": }
+      }
+
+      $x = include(a)
+      Array[Type[Class], 1, 1].assert_type($x)
+      notify { 'feedback': message => "$x" }
+    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": }
+      }
+
+      $x = include(a, b)
+      Array[Type[Class], 2, 2].assert_type($x)
+      notify { 'feedback': message => "$x" }
+    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': }
+
+      include(a, b) -> Notify[c]
+    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', :include
+  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
+
+end