puppet 5.3.3 → 5.3.4

data/spec/unit/environments_spec.rb

@@ -209,6 +209,20 @@ static_catalogs=false
       end
 
       it "logs a warning, but processes the main settings if there are any extraneous settings" do
+        content << "dog=arf\n"
+        content << "cat=mew\n"
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script'))
+        end
+
+        expect(@logs.map(&:to_s).join).to match(/Invalid.*at.*\/env1.*unknown setting.*dog, cat/)
+      end
+
+      it "logs a warning, but processes the main settings if there are any ignored sections" do
         content << "dog=arf\n"
         content << "cat=mew\n"
         content << "[ignored]\n"
@@ -221,6 +235,7 @@ static_catalogs=false
             with_config_version(File.expand_path('/some/script'))
         end
 
+        expect(@logs.map(&:to_s).join).to match(/Invalid.*at.*\/env1.*The following sections are being ignored: 'ignored'/)
         expect(@logs.map(&:to_s).join).to match(/Invalid.*at.*\/env1.*unknown setting.*dog, cat/)
       end
 

data/spec/unit/face/config_spec.rb

@@ -18,8 +18,8 @@ describe Puppet::Face[:config, '0.0.1'] do
     Puppet[:syslogfacility] = "file"
 
     expect { subject.print("trace", "syslogfacility") }.to have_printed(<<-OUTPUT)
-trace = true
 syslogfacility = file
+trace = true
     OUTPUT
   end
 
@@ -108,11 +108,11 @@ syslogfacility = file
       ) do
         args = "environmentpath","manifest","modulepath","environment","basemodulepath"
         expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+basemodulepath = #{File.expand_path("/some/base")}
+environment = production
 environmentpath = #{File.expand_path("/dev/null/environments")}
 manifest = #{File.expand_path("/dev/null/environments/production/manifests")}
 modulepath = #{File.expand_path("/dev/null/environments/production/modules")}#{File::PATH_SEPARATOR}#{File.expand_path("/some/base")}
-environment = production
-basemodulepath = #{File.expand_path("/some/base")}
         OUTPUT
       end
     end
@@ -129,17 +129,16 @@ basemodulepath = #{File.expand_path("/some/base")}
       ) do
         args = "environmentpath","manifest","modulepath","environment","basemodulepath"
         expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+basemodulepath = #{File.expand_path("/some/base")}
+environment = production
 environmentpath = #{File.expand_path("/dev/null/environments")}
 manifest = #{File.expand_path("/dev/null/environments/production/manifests")}
 modulepath = #{File.expand_path("/custom/modules")}#{File::PATH_SEPARATOR}#{File.expand_path("/some/base")}
-environment = production
-basemodulepath = #{File.expand_path("/some/base")}
         OUTPUT
       end
     end
 
     it "prints the default configured env settings for an env that does not exist" do
-      pending "This case no longer exists because Application will through an error before we even get here because of the non-existent environment"
       Puppet[:environment] = 'doesnotexist'
 
       FS.overlay(
@@ -149,11 +148,11 @@ basemodulepath = #{File.expand_path("/some/base")}
       ) do
         args = "environmentpath","manifest","modulepath","environment","basemodulepath"
         expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+basemodulepath = #{File.expand_path("/some/base")}
+environment = doesnotexist
 environmentpath = #{File.expand_path("/dev/null/environments")}
-manifest = no_manifest
+manifest = 
 modulepath = 
-environment = doesnotexist
-basemodulepath = #{File.expand_path("/some/base")}
         OUTPUT
       end
     end

data/spec/unit/face/epp_face_spec.rb

@@ -147,7 +147,7 @@ describe Puppet::Face[:epp, :current] do
       dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
       template = File.join(dir, template_name)
       expect(eppface.dump(template, :validate => true)).to eq("")
-      expect(@logs.join).to match(/This Literal Integer has no effect.*\/template1.epp:1:4/)
+      expect(@logs.join).to match(/This Literal Integer has no effect.*\(file: .*\/template1\.epp, line: 1, column: 4\)/)
     end
 
     it "validated content by default" do
@@ -155,7 +155,7 @@ describe Puppet::Face[:epp, :current] do
       dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
       template = File.join(dir, template_name)
       expect(eppface.dump(template)).to eq("")
-      expect(@logs.join).to match(/This Literal Integer has no effect.*\/template1.epp:1:4/)
+      expect(@logs.join).to match(/This Literal Integer has no effect.*\(file: .*\/template1\.epp, line: 1, column: 4\)/)
     end
 
     it "informs the user of files that don't exist" do

data/spec/unit/face/plugin_spec.rb

@@ -12,21 +12,67 @@ describe Puppet::Face[:plugin, :current] do
   end
 
   context "download" do
-    it "downloads plugins and external facts" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+    before :each do
+      #Server_agent version needs to be at 5.3.4 in order to mount locales
+      Puppet.push_context({:server_agent_version => "5.3.4"})
+    end
+
+    it "downloads plugins, external facts, and locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       pluginface.download
     end
 
     it "renders 'No plugins downloaded' if nothing was downloaded" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
 
       result = pluginface.download
       expect(render(result)).to eq('No plugins downloaded.')
     end
 
     it "renders comma separate list of downloaded file names" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns(%w[/a]).then.returns(%w[/b])
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
+    end
+  end
+
+  context "download when server_agent_version is 5.3.3" do
+    before :each do
+      #Server_agent version needs to be at 5.3.4 in order to mount locales
+      Puppet.push_context({:server_agent_version => "5.3.3"})
+    end
+
+    it "downloads plugins, and external facts, but not locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
+
+      pluginface.download
+    end
+
+    it "renders comma separate list of downloaded file names that does not include locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+    end
+  end
+
+  context "download when server_agent_version is blank" do
+    before :each do
+      #Server_agent version needs to be at 5.3.4 in order to mount locales
+      #A blank version will default to 0.0
+      Puppet.push_context({:server_agent_version => ""})
+    end
+
+    it "downloads plugins, and external facts, but not locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns([])
+
+      pluginface.download
+    end
+
+    it "renders comma separate list of downloaded file names that does not include locales" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
 
       result = pluginface.download
       expect(render(result)).to eq('Downloaded these plugins: /a, /b')

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -78,7 +78,7 @@ describe Puppet::FileServing::Configuration::Parser do
     it "should return comprehensible error message, if invalid line detected" do
       write_config_file "[one]\n\n\x01path /etc/puppetlabs/puppet/files\n\x01allow *\n"
 
-      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid line.*in.*, line 3/)
+      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid entry at \(file: .*, line: 3\): .*/)
     end
   end
 
@@ -130,7 +130,7 @@ describe Puppet::FileServing::Configuration::Parser do
     it "should return comprehensible error message, if failed on invalid attribute" do
       write_config_file "[one]\ndo something\n"
 
-      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid argument 'do' in .*, line 2/)
+      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid argument 'do' at \(file: .*, line: 2\)/)
     end
   end
 

data/spec/unit/file_serving/mount/locales_spec.rb

@@ -0,0 +1,73 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/file_serving/mount/locales'
+
+describe Puppet::FileServing::Mount::Locales do
+  before do
+    @mount = Puppet::FileServing::Mount::Locales.new("locales")
+
+    @environment = stub 'environment', :module => nil
+    @options = { :recurse => true }
+    @request = stub 'request', :environment => @environment, :options => @options
+  end
+
+  describe  "when finding files" do
+    it "should use the provided environment to find the modules" do
+      @environment.expects(:modules).returns []
+
+      @mount.find("foo", @request)
+    end
+
+    it "should return nil if no module can be found with a matching locale" do
+      mod = mock 'module'
+      mod.stubs(:locale).with("foo/bar").returns nil
+
+      @environment.stubs(:modules).returns [mod]
+      expect(@mount.find("foo/bar", @request)).to be_nil
+    end
+
+    it "should return the file path from the module" do
+      mod = mock 'module'
+      mod.stubs(:locale).with("foo/bar").returns "eh"
+
+      @environment.stubs(:modules).returns [mod]
+      expect(@mount.find("foo/bar", @request)).to eq("eh")
+    end
+  end
+
+  describe "when searching for files" do
+    it "should use the node's environment to find the modules" do
+      @environment.expects(:modules).at_least_once.returns []
+      @environment.stubs(:modulepath).returns ["/tmp/modules"]
+
+      @mount.search("foo", @request)
+    end
+
+    it "should return modulepath if no modules can be found that have locales" do
+      mod = mock 'module'
+      mod.stubs(:locales?).returns false
+
+      @environment.stubs(:modules).returns []
+      @environment.stubs(:modulepath).returns ["/"]
+      @options.expects(:[]=).with(:recurse, false)
+      expect(@mount.search("foo/bar", @request)).to eq(["/"])
+    end
+
+    it "should return nil if no modules can be found that have locales and modulepath is invalid" do
+      mod = mock 'module'
+      mod.stubs(:locales?).returns false
+
+      @environment.stubs(:modules).returns []
+      @environment.stubs(:modulepath).returns []
+      expect(@mount.search("foo/bar", @request)).to be_nil
+    end
+
+    it "should return the locale paths for each module that has locales" do
+      one = stub 'module', :locales? => true, :locale_directory => "/one"
+      two = stub 'module', :locales? => true, :locale_directory => "/two"
+
+      @environment.stubs(:modules).returns [one, two]
+      expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
+    end
+  end
+end

data/spec/unit/functions/break_spec.rb

@@ -8,7 +8,7 @@ describe 'the break function' do
   include Matchers::Resource
 
   context  do
-    it 'breaks iteration as if at end of input in a map' do
+    it 'breaks iteration as if at end of input in a map for an array' 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 }
@@ -44,24 +44,81 @@ describe 'the break function' do
         CODE
     end
 
-  end
+    it 'breaks iteration as if at end of input in a map for a hash' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
+          function please_break() {
+            {'a' => 1, 'b' => 2, 'c' => 3}.map |$x, $y| { if $y == 3 { break() } $y }
+          }
+          notify { String(please_break()): }
+        CODE
+    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 'breaks iteration as if at end of input in a reduce for an array' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[6]')
+          function please_break() {
+            [1,2,3,4].reduce |$memo, $x| { if $x == 4 { break() } $memo + $x }
+          }
+          notify { String(please_break()): }
+        CODE
+    end
+
+    it 'breaks iteration as if at end of input in a reduce for a hash' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource("Notify[['abc', 6]]")
+          function please_break() {
+            {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}.reduce |$memo, $x| {
+              if $x[1] == 4 { break() }
+              $string = "${memo[0]}${x[0]}"
+              $number = $memo[1] + $x[1]
+              [$string, $number]
+            }
+          }
+          notify { String(please_break()): }
+        CODE
+    end
+
+    it 'breaks iteration as if at end of input in an each for an array' do
+      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
+          function please_break() {
+            [1,2,3].each |$x| { if $x == 3 { break() } notify { "$x": } }
+          }
+          please_break()
+        CODE
+    end
+
+    it 'breaks iteration as if at end of input in an each for a hash' do
+      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
+          function please_break() {
+            {'a' => 1, 'b' => 2, 'c' => 3}.each |$x, $y| { if $y == 3 { break() } notify { "$y": } }
+          }
+          please_break()
+        CODE
+    end
+
+    it 'breaks iteration as if at end of input in a reverse_each' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[2]')
+          function please_break() {
+            [1,2,3].reverse_each |$x| { if $x == 1 { break() } notify { "$x": } }
+          }
+          please_break()
+        CODE
+    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 \(file: unknown, line: 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
@@ -77,41 +134,42 @@ describe 'the break function' do
           }
             does_break { 'no_you_cannot': }
         CODE
-      end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+      end.to raise_error(/break\(\) from context where this is illegal \(file: unknown, line: 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 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 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 \(file: unknown, line: 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.*/)
+    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 \(file: unknown, line: 3\) on node.*/)
+    end
   end
 end