puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/shared_behaviours/iterative_functions.rb

@@ -0,0 +1,69 @@
+
+shared_examples_for 'all iterative functions hash handling' do |func|
+  it 'passes a hash entry as an array of the key and value' do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      {a=>1}.#{func} |$v| { notify { "${v[0]} ${v[1]}": } }
+    MANIFEST
+
+    catalog.resource(:notify, "a 1").should_not be_nil
+  end
+end
+
+shared_examples_for 'all iterative functions argument checks' do |func|
+
+  it 'raises an error when used against an unsupported type' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        3.14.#{func} |$k, $v| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /must be something enumerable/)
+  end
+
+  it 'raises an error when called with any parameters besides a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}(1) |$v| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*arg count \{3\}/m)
+  end
+
+  it 'raises an error when called without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}()
+      MANIFEST
+    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*arg count \{1\}/m)
+  end
+
+  it 'raises an error when called with something that is not a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}(1)
+      MANIFEST
+    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*Callable.*actual(?!Callable\)).*/m)
+  end
+
+  it 'raises an error when called with a block with too many required parameters' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}() |$v1, $v2, $v3| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*Callable\[Any, Any, Any\]/m)
+  end
+
+  it 'raises an error when called with a block with too few parameters' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}() | | {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*Callable\[0, 0\]/m)
+  end
+
+  it 'does not raise an error when called with a block with too many but optional arguments' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].#{func}() |$v1, $v2, $v3=extra| {  }
+      MANIFEST
+    end.to_not raise_error
+  end
+end

data/spec/unit/application/apply_spec.rb

@@ -131,7 +131,9 @@ describe Puppet::Application::Apply do
 
       @apply.setup
 
-      expect(Puppet::Util::Profiler.current).to be_a(Puppet::Util::Profiler::WallClock)
+      expect(Puppet::Util::Profiler.current).to satisfy do |ps|
+        ps.any? {|p| p.is_a? Puppet::Util::Profiler::WallClock }
+      end
     end
 
     it "does not have a profiler if profiling is disabled" do
@@ -139,7 +141,7 @@ describe Puppet::Application::Apply do
 
       @apply.setup
 
-      expect(Puppet::Util::Profiler.current).to eq(Puppet::Util::Profiler::NONE)
+      expect(Puppet::Util::Profiler.current.length).to be 0
     end
 
     it "should set default_file_terminus to `file_server` to be local" do

data/spec/unit/application/doc_spec.rb

@@ -259,6 +259,7 @@ describe Puppet::Application::Doc do
 
       let(:envdir) { tmpdir('env') }
       let(:modules) { File.join(envdir, "modules") }
+      let(:modules2) { File.join(envdir, "modules2") }
       let(:manifests) { File.join(envdir, "manifests") }
 
       before :each do
@@ -277,8 +278,8 @@ describe Puppet::Application::Doc do
 
       around(:each) do |example|
         FileUtils.mkdir_p(modules)
-        @env = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [modules], "#{manifests}/site.pp")
-        Puppet.override(:environments => Puppet::Environments::Static.new(@env)) do
+        env = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [modules], "#{manifests}/site.pp")
+        Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
           example.run
         end
       end
@@ -287,39 +288,42 @@ describe Puppet::Application::Doc do
         @doc.options[:all] = true
         Puppet.settings.expects(:[]=).with(:document_all, true)
 
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode" do
         Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
         @doc.options[:charset] = 'utf-8'
         Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], "utf-8")
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
         @doc.options[:outputdir] = false
         Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
         @doc.manifest = true
         Puppet::Util::RDoc.expects(:manifestdoc)
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should get modulepath and manifestdir values from the environment" do
-        @env.expects(:modulepath).returns(['envmodules1','envmodules2'])
-        @env.expects(:manifest).returns('envmanifests/site.pp')
-
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', ['envmodules1','envmodules2','envmanifests'], nil)
-
-        expect { @doc.rdoc }.to exit_with 0
+        FileUtils.mkdir_p(modules)
+        FileUtils.mkdir_p(modules2)
+        env = Puppet::Node::Environment.create(Puppet[:environment].to_sym,
+          [modules, modules2],
+          "envmanifests/site.pp")
+        Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
+           Puppet::Util::RDoc.stubs(:rdoc).with('doc', [modules.to_s, modules2.to_s, env.manifest.to_s], nil)
+          expect { @doc.rdoc }.to exit_with(0)
+        end
       end
     end
 

data/spec/unit/application/master_spec.rb

@@ -114,38 +114,46 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       expect { @master.setup }.to raise_error(Puppet::Error, /Puppet master is not supported on Microsoft Windows/)
     end
 
-    it "should set log level to debug if --debug was passed" do
-      @master.options.stubs(:[]).with(:debug).returns(true)
-      @master.setup
-      Puppet::Log.level.should == :debug
-    end
-
-    it "should set log level to info if --verbose was passed" do
-      @master.options.stubs(:[]).with(:verbose).returns(true)
-      @master.setup
-      Puppet::Log.level.should == :info
-    end
-
-    it "should set console as the log destination if no --logdest and --daemonize" do
-      @master.stubs(:[]).with(:daemonize).returns(:false)
-
-      Puppet::Log.expects(:newdestination).with(:syslog)
-
-      @master.setup
-    end
+    describe "setting up logging" do
+      it "sets the log level" do
+        @master.expects(:set_log_level)
+        @master.setup
+      end
 
-    it "should set syslog as the log destination if no --logdest and not --daemonize" do
-      Puppet::Log.expects(:newdestination).with(:syslog)
+      describe "when the log destination is not explicitly configured" do
+        before do
+          @master.options.stubs(:[]).with(:setdest).returns false
+        end
 
-      @master.setup
-    end
+        it "logs to the console when --compile is given" do
+          @master.options.stubs(:[]).with(:node).returns "default"
+          Puppet::Util::Log.expects(:newdestination).with(:console)
+          @master.setup
+        end
 
-    it "should set syslog as the log destination if --rack" do
-      @master.options.stubs(:[]).with(:rack).returns(:true)
+        it "logs to the console when the master is not daemonized or run with rack" do
+          Puppet::Util::Log.expects(:newdestination).with(:console)
+          Puppet[:daemonize] = false
+          @master.options.stubs(:[]).with(:rack).returns(false)
+          @master.setup
+        end
 
-      Puppet::Log.expects(:newdestination).with(:syslog)
+        it "logs to syslog when the master is daemonized" do
+          Puppet::Util::Log.expects(:newdestination).with(:console).never
+          Puppet::Util::Log.expects(:newdestination).with(:syslog)
+          Puppet[:daemonize] = true
+          @master.options.stubs(:[]).with(:rack).returns(false)
+          @master.setup
+        end
 
-      @master.setup
+        it "logs to syslog when the master is run with rack" do
+          Puppet::Util::Log.expects(:newdestination).with(:console).never
+          Puppet::Util::Log.expects(:newdestination).with(:syslog)
+          Puppet[:daemonize] = false
+          @master.options.stubs(:[]).with(:rack).returns(true)
+          @master.setup
+        end
+      end
     end
 
     it "should print puppet config if asked to in Puppet config" do

data/spec/unit/application/resource_spec.rb

@@ -16,11 +16,6 @@ describe Puppet::Application::Resource do
       @resource_app.preinit
       @resource_app.extra_params.should == []
     end
-
-    it "should load Facter facts" do
-      Facter.expects(:loadfacts).once
-      @resource_app.preinit
-    end
   end
 
   describe "when handling options" do

data/spec/unit/configurer/downloader_factory_spec.rb

@@ -0,0 +1,96 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/configurer'
+
+describe Puppet::Configurer::DownloaderFactory do
+  let(:factory)     { Puppet::Configurer::DownloaderFactory.new }
+  let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
+
+  let(:plugin_downloader) do
+    factory.create_plugin_downloader(environment)
+  end
+
+  let(:facts_downloader) do
+    factory.create_plugin_facts_downloader(environment)
+  end
+
+  def ignores_source_permissions(downloader)
+    expect(downloader.file[:source_permissions]).to eq(:ignore)
+  end
+
+  def uses_source_permissions(downloader)
+    expect(downloader.file[:source_permissions]).to eq(:use)
+  end
+
+  context "when creating a plugin downloader for modules" do
+    it 'is named "plugin"' do
+      expect(plugin_downloader.name).to eq('plugin')
+    end
+
+    it 'downloads files into Puppet[:plugindest]' do
+      plugindest = File.expand_path("/tmp/pdest")
+      Puppet[:plugindest] = plugindest
+
+      expect(plugin_downloader.file[:path]).to eq(plugindest)
+    end
+
+    it 'downloads files from Puppet[:pluginsource]' do
+      Puppet[:pluginsource] = 'puppet:///myotherplugins'
+
+      expect(plugin_downloader.file[:source]).to eq([Puppet[:pluginsource]])
+    end
+
+    it 'ignores files from Puppet[:pluginsignore]' do
+      Puppet[:pluginsignore] = 'pignore'
+
+      expect(plugin_downloader.file[:ignore]).to eq(['pignore'])
+    end
+
+    it 'splits Puppet[:pluginsignore] on whitespace' do
+      Puppet[:pluginsignore] = ".svn CVS .git"
+
+      expect(plugin_downloader.file[:ignore]).to eq(%w[.svn CVS .git])
+    end
+
+    it "ignores source permissions" do
+      ignores_source_permissions(plugin_downloader)
+    end
+  end
+
+  context "when creating a plugin downloader for external facts" do
+    it 'is named "pluginfacts"' do
+      expect(facts_downloader.name).to eq('pluginfacts')
+    end
+
+    it 'downloads files into Puppet[:pluginfactdest]' do
+      plugindest = File.expand_path("/tmp/pdest")
+      Puppet[:pluginfactdest] = plugindest
+
+      expect(facts_downloader.file[:path]).to eq(plugindest)
+    end
+
+    it 'downloads files from Puppet[:pluginfactsource]' do
+      Puppet[:pluginfactsource] = 'puppet:///myotherfacts'
+
+      expect(facts_downloader.file[:source]).to eq([Puppet[:pluginfactsource]])
+    end
+
+    it 'ignores files from Puppet[:pluginsignore]' do
+      Puppet[:pluginsignore] = 'pignore'
+
+      expect(facts_downloader.file[:ignore]).to eq(['pignore'])
+    end
+
+    context "on POSIX", :if => Puppet.features.posix? do
+      it "uses source permissions" do
+        uses_source_permissions(facts_downloader)
+      end
+    end
+
+    context "on Windows", :if => Puppet.features.microsoft_windows? do
+      it "ignores source permissions during external fact pluginsync" do
+        ignores_source_permissions(facts_downloader)
+      end
+    end
+  end
+end

data/spec/unit/configurer/downloader_spec.rb

@@ -174,25 +174,6 @@ describe Puppet::Configurer::Downloader do
 
     it "should log that it is downloading" do
       Puppet.expects(:info)
-      Timeout.stubs(:timeout)
-
-      @dler.evaluate
-    end
-
-    it "should set a timeout for the download using the `configtimeout` setting" do
-      Puppet[:configtimeout] = 50
-      Timeout.expects(:timeout).with(50)
-
-      @dler.evaluate
-    end
-
-    it "should apply the catalog within the timeout block" do
-      catalog = mock 'catalog'
-      @dler.expects(:catalog).returns(catalog)
-
-      Timeout.expects(:timeout).yields
-
-      catalog.expects(:apply)
 
       @dler.evaluate
     end
@@ -204,8 +185,6 @@ describe Puppet::Configurer::Downloader do
       @dler.expects(:catalog).returns(catalog)
       catalog.expects(:apply).yields(trans)
 
-      Timeout.expects(:timeout).yields
-
       resource = mock 'resource'
       resource.expects(:[]).with(:path).returns "/changed/file"
 
@@ -221,8 +200,6 @@ describe Puppet::Configurer::Downloader do
       @dler.expects(:catalog).returns(catalog)
       catalog.expects(:apply).yields(trans)
 
-      Timeout.expects(:timeout).yields
-
       resource = mock 'resource'
       resource.expects(:[]).with(:path).returns "/changed/file"
 
@@ -235,7 +212,9 @@ describe Puppet::Configurer::Downloader do
 
     it "should catch and log exceptions" do
       Puppet.expects(:err)
-      Timeout.stubs(:timeout).raises(Puppet::Error, "testing")
+      # The downloader creates a new catalog for each apply, and really the only object
+      # that it is possible to stub for the purpose of generating a puppet error
+      Puppet::Resource::Catalog.any_instance.stubs(:apply).raises(Puppet::Error, "testing")
 
       lambda { @dler.evaluate }.should_not raise_error
     end

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -3,37 +3,37 @@ require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/plugin_handler'
 
-class PluginHandlerTester
-  include Puppet::Configurer::PluginHandler
-  attr_accessor :environment
-end
-
 describe Puppet::Configurer::PluginHandler do
-  before do
-    @pluginhandler = PluginHandlerTester.new
+  let(:factory)       { Puppet::Configurer::DownloaderFactory.new }
+  let(:pluginhandler) { Puppet::Configurer::PluginHandler.new(factory) }
+  let(:environment)   { Puppet::Node::Environment.create(:myenv, []) }
 
+  before :each do
     # PluginHandler#load_plugin has an extra-strong rescue clause
     # this mock is to make sure that we don't silently ignore errors
     Puppet.expects(:err).never
   end
 
-  it "should use an Agent Downloader, with the name, source, destination, ignore, and environment set correctly, to download plugins when downloading is enabled" do
-    environment = Puppet::Node::Environment.create(:myenv, [])
-    Puppet.features.stubs(:external_facts?).returns(:true)
-    plugindest = File.expand_path("/tmp/pdest")
-    Puppet[:pluginsource] = "psource"
-    Puppet[:plugindest] = plugindest
-    Puppet[:pluginsignore] = "pignore"
-    Puppet[:pluginfactsource] = "psource"
-    Puppet[:pluginfactdest] = plugindest
+  it "downloads plugins and facts" do
+    Puppet.features.stubs(:external_facts?).returns(true)
+
+    plugin_downloader = stub('plugin-downloader', :evaluate => [])
+    facts_downloader = stub('facts-downloader', :evaluate => [])
+
+    factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+    factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
+
+    pluginhandler.download_plugins(environment)
+  end
+
+  it "skips facts if not enabled" do
+    Puppet.features.stubs(:external_facts?).returns(false)
 
-    downloader = mock 'downloader'
-    Puppet::Configurer::Downloader.expects(:new).with("pluginfacts", plugindest, "psource", "pignore", environment, :use).returns downloader
-    Puppet::Configurer::Downloader.expects(:new).with("plugin", plugindest, "psource", "pignore", environment).returns downloader
+    plugin_downloader = stub('plugin-downloader', :evaluate => [])
 
-    downloader.stubs(:evaluate).returns([])
-    downloader.expects(:evaluate).twice
+    factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+    factory.expects(:create_plugin_facts_downloader).never
 
-    @pluginhandler.download_plugins(environment)
+    pluginhandler.download_plugins(environment)
   end
 end