puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

data/spec/spec_helper.rb

@@ -43,6 +43,10 @@ Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
   require behaviour.relative_path_from(Pathname.new(dir))
 end
 
+Pathname.glob("#{dir}/shared_examples/**/*.rb") do |behaviour|
+  require behaviour.relative_path_from(Pathname.new(dir))
+end
+
 require 'vcr'
 VCR.configure do |vcr|
   vcr.cassette_library_dir = File.expand_path('vcr/cassettes', PuppetSpec::FIXTURE_DIR)
@@ -68,8 +72,8 @@ RSpec.configure do |config|
 
   config.mock_with :mocha
 
-  tmpdir = Dir.mktmpdir("rspecrun")
-  oldtmpdir = Dir.tmpdir()
+  tmpdir = Puppet::FileSystem.expand_path(Dir.mktmpdir("rspecrun"))
+  oldtmpdir = Puppet::FileSystem.expand_path(Dir.tmpdir())
   ENV['TMPDIR'] = tmpdir
 
   if Puppet::Util::Platform.windows?
@@ -148,6 +152,8 @@ RSpec.configure do |config|
     Puppet[:rundir] = "$vardir/run"
     Puppet[:hiera_config] = File.join(base, 'hiera')
 
+    FileUtils.mkdir_p Puppet[:statedir]
+
     Puppet::Test::TestHelper.before_each_test()
   end
 

data/spec/unit/application/cert_spec.rb

@@ -52,6 +52,26 @@ describe Puppet::Application::Cert => true do
     expect(@cert_app.signed).to be_truthy
   end
 
+  it "should set human to true for --human-readable" do
+    @cert_app.handle_human_readable(0)
+    expect(@cert_app.options[:format]).to be :human
+  end
+
+  it "should set machine to true for --machine-readable" do
+    @cert_app.handle_machine_readable(0)
+    expect(@cert_app.options[:format]).to be :machine
+  end
+
+  it "should set interactive to true for --interactive" do
+    @cert_app.handle_interactive(0)
+    expect(@cert_app.options[:interactive]).to be_truthy
+  end
+
+  it "should set yes to true for --assume-yes" do
+    @cert_app.handle_assume_yes(0)
+    expect(@cert_app.options[:yes]).to be_truthy
+  end
+
   Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS.reject { |m| m == :destroy }.each do |method|
     it "should set cert_mode to #{method} with option --#{method}" do
       @cert_app.send("handle_#{method}".to_sym, nil)

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -39,30 +39,4 @@ describe Puppet::Configurer::PluginHandler do
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
     end
   end
-
-  context "when external facts are not supported" do
-    before :each do
-      Puppet.features.stubs(:external_facts?).returns(false)
-    end
-
-    it "downloads plugins only" do
-      plugin_downloader = stub('plugin-downloader', :evaluate => [])
-
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-      factory.expects(:create_plugin_facts_downloader).never
-
-      pluginhandler.download_plugins(environment)
-    end
-
-    it "returns downloaded plugin filenames only" do
-      Puppet.features.stubs(:external_facts?).returns(false)
-
-      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
-      facts_downloader = stub('facts-downloader')
-
-      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-
-      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a])
-    end
-  end
 end

data/spec/unit/configurer_spec.rb

@@ -920,4 +920,50 @@ describe Puppet::Configurer do
       expect(described_class).not_to be_should_pluginsync
     end
   end
+
+  describe "when attempting failover" do
+    it "should not failover if server_list is not set" do
+      Puppet.settings[:server_list] = []
+      @agent.expects(:find_functional_server).never
+      @agent.run
+    end
+
+    it "should not failover during an apply run" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      @agent.expects(:find_functional_server).never
+      catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      @agent.run :catalog => catalog
+    end
+
+    it "should select a server when provided" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
+      Puppet::Network::HTTP::Pool.expects(:new).returns(pool)
+      Puppet.expects(:override).with({:http_pool => pool}).yields
+      Puppet.expects(:override).with({:server => "myserver", :serverport => '123'}).twice.yields
+      Puppet::Node.indirection.expects(:find).returns(nil)
+      @agent.expects(:run_internal).returns(nil)
+      @agent.run
+    end
+
+    it "should fallback to an empty server when failover fails" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
+      Puppet::Network::HTTP::Pool.expects(:new).returns(pool)
+      Puppet.expects(:override).with({:http_pool => pool}).yields
+      Puppet.expects(:override).with({:server => "myserver", :serverport => '123'}).yields
+      Puppet.expects(:override).with({:server => nil, :serverport => nil}).yields
+      error = Net::HTTPError.new(400, 'dummy server communication error')
+      Puppet::Node.indirection.expects(:find).raises(error)
+      @agent.expects(:run_internal).returns(nil)
+      @agent.run
+    end
+
+    it "should not make multiple node requets when the server is found" do
+      Puppet.settings[:server_list] = ["myserver:123"]
+      Puppet::Node.indirection.expects(:find).returns("mynode").once
+      @agent.expects(:prepare_and_retrieve_catalog).returns(nil)
+      @agent.run
+    end
+  end
 end

data/spec/unit/defaults_spec.rb

@@ -104,4 +104,18 @@ describe "Defaults" do
       expect(Puppet.settings[:supported_checksum_types]).to eq(['sha256', 'md5lite', 'mtime'])
     end
   end
+  
+  describe 'server vs server_list' do
+    it 'should warn when both settings are set in code' do
+      Puppet.expects(:deprecation_warning).with('Attempted to set both server and server_list. Server setting will not be used.', :SERVER_DUPLICATION)
+      Puppet.settings[:server] = 'test_server'
+      Puppet.settings[:server_list] = ['one', 'two']
+    end
+
+    it 'should warn when both settings are set by command line' do
+      Puppet.expects(:deprecation_warning).with('Attempted to set both server and server_list. Server setting will not be used.', :SERVER_DUPLICATION)
+      Puppet.settings.handlearg("--server_list", "one,two")
+      Puppet.settings.handlearg("--server", "test_server")
+    end
+  end
 end

data/spec/unit/face/generate_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/face'
+
+describe Puppet::Face[:generate, :current] do
+  include PuppetSpec::Files
+
+  let(:genface) { Puppet::Face[:generate, :current] }
+
+  # * Format is 'pcore' by default
+  # * Format is accepted as 'pcore'
+  # * Any format expect 'pcore' is an error
+  # * Produces output to '<envroot>/.resource_types'
+  # * Produces all types found on the module path (that are not in puppet core)
+  # * Output files match input
+  # * Removes files for which there is no input
+  # * Updates a pcore file if it is out of date
+  # * The --force flag overwrite the output even if it is up to date
+  # * Environment is set with --environment (setting) (not tested explicitly)
+  # Writes output for:
+  #   - isomorphic
+  #   - parameters
+  #   - properties
+  #   - title patterns
+  #   - type information is written when the type is X, Y, or Z
+  #
+  # Additional features
+  #   - blacklist? whitelist? types to exclude/include
+  #   - generate one resource type (somewhere on modulepath)
+  #   - output to directory of choice
+  #   - clean, clean the output directory (similar to force)
+  #
+
+  [:types].each do |action|
+    it { is_expected.to be_action(action) }
+    it { is_expected.to respond_to(action) }
+  end
+
+  context "when used from an interactive terminal" do
+    before :each do
+      from_an_interactive_terminal
+    end
+
+    context "in an environment with two modules containing resource types" do
+      let(:dir) do
+        dir_containing('environments', { 'testing_generate' => {
+          'environment.conf' => "modulepath = modules",
+          'manifests' => { 'site.pp' => "" },
+          'modules' => {
+            'm1' => {
+              'lib' => { 'puppet' => { 'type' => {
+                'test1.rb' => <<-EOF
+                module Puppet
+                Type.newtype(:test1) do
+                  @doc = "Docs for resource"
+                  newproperty(:message) do
+                    desc "Docs for 'message' property"
+                  end
+                  newparam(:name) do
+                    desc "Docs for 'name' parameter"
+                    isnamevar
+                  end
+                end; end
+                EOF
+               } }
+            },
+          },
+          'm2' => { 
+            'lib' => { 'puppet' => { 'type' => {
+              'test2.rb' => <<-EOF
+              module Puppet
+              Type.newtype(:test2) do
+                @doc = "Docs for resource"
+                newproperty(:message) do
+                  desc "Docs for 'message' property"
+                end
+                newparam(:name) do
+                  desc "Docs for 'name' parameter"
+                  isnamevar
+                end
+              end;end
+              EOF
+             } } },
+          }
+        }}})
+      end
+
+      let(:modulepath) do
+        File.join(dir, 'testing_generate', 'modules')
+      end
+
+      let(:m1) do
+        File.join(modulepath, 'm1')
+      end
+
+      let(:m2) do
+        File.join(modulepath, 'm2')
+      end
+
+      let(:outputdir) do
+        File.join(dir, 'testing_generate', '.resource_types')
+      end
+
+      around(:each) do |example|
+        Puppet.settings.initialize_global_settings
+        Puppet[:manifest] = ''
+        loader = Puppet::Environments::Directories.new(dir, [])
+        Puppet.override(:environments => loader) do
+          Puppet.override(:current_environment => loader.get('testing_generate')) do
+            example.run
+          end
+        end
+      end
+
+      it 'error if format is given as something other than pcore' do
+        expect {
+          genface.types(:format => 'json')
+        }.to raise_exception(ArgumentError, /'json' is not a supported format for type generation/)
+      end
+
+      it 'accepts --format pcore as a format' do
+        expect {
+          genface.types(:format => 'pcore')
+        }.not_to raise_error
+      end
+
+      it 'sets pcore as the default format' do
+        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
+        genface.types()
+      end
+
+      it 'finds all files to generate types for' do
+        # using expects and returning what the side effect should have been
+        # (There is no way to call the original when mocking expected parameters).
+        input1 = Puppet::Generate::Type::Input.new(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore)
+        input2 = Puppet::Generate::Type::Input.new(m1, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore)
+        Puppet::Generate::Type::Input.expects(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).returns(input1)
+        Puppet::Generate::Type::Input.expects(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).returns(input2)
+        genface.types
+      end
+
+      it 'creates output directory <env>/.resource_types/ if it does not exist' do
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(false)
+        genface.types
+        expect(Puppet::FileSystem.dir_exist?(outputdir)).to be(true)
+      end
+
+      it 'creates output with matching names for each input' do
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(false)
+        genface.types
+        children = Puppet::FileSystem.children(outputdir).map {|p| Puppet::FileSystem.basename_string(p) }
+        expect(children.sort).to eql(['test1.pp', 'test2.pp'])
+      end
+
+      it 'tolerates that <env>/.resource_types/ directory exists' do
+        Puppet::FileSystem.mkpath(outputdir)
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(true)
+        genface.types
+        expect(Puppet::FileSystem.dir_exist?(outputdir)).to be(true)
+      end
+
+      it 'errors if <env>/.resource_types exists and is not a directory' do
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(false) # assert it is not already there
+        Puppet::FileSystem.touch(outputdir)
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(true)
+        expect(Puppet::FileSystem.directory?(outputdir)).to be(false)
+        expect {
+          genface.types
+        }.to raise_error(ArgumentError, /The output directory '#{outputdir}' exists and is not a directory/)
+      end
+
+      it 'does not overwrite if files exists and are up to date' do
+        # create them (first run)
+        genface.types
+        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        # generate again
+        genface.types
+        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        expect(stats_before <=> stats_after).to be(0)
+      end
+
+      it 'overwrites if files exists that are not up to date while keeping up to date files' do
+        # create them (first run)
+        genface.types
+        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        # fake change in input test1 - sorry about the sleep (which there was a better way to change the modtime
+        sleep(1)
+        Puppet::FileSystem.touch(File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'))
+        # generate again
+        genface.types
+        # assert that test1 was overwritten (later) but not test2 (same time)
+        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        expect(stats_before[1] <=> stats_after[1]).to be(0)
+        expect(stats_before[0] <=> stats_after[0]).to be(-1)
+      end
+
+      it 'overwrites all files when called with --force' do
+        # create them (first run)
+        genface.types
+        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        # generate again
+        sleep(1) # sorry, if there is no delay the stats will be the same
+        genface.types(:force => true)
+        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        expect(stats_before <=> stats_after).to be(-1)
+      end
+
+      it 'removes previously generated files from output when there is no input for it' do
+        # create them (first run)
+        genface.types
+        stat_before = Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))
+        # remove input
+        Puppet::FileSystem.unlink(File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'))
+        # generate again
+        genface.types
+        # assert that test1 was deleted but not test2 (same time)
+        expect(Puppet::FileSystem.exist?(File.join(outputdir, 'test1.pp'))).to be(false)
+        stats_after = Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))
+        expect(stat_before <=> stats_after).to be(0)
+      end
+
+    end
+  end
+
+  def from_an_interactive_terminal
+    STDIN.stubs(:tty?).returns(true)
+  end
+
+end

data/spec/unit/face/help_spec.rb

@@ -48,6 +48,24 @@ describe Puppet::Face[:help, '0.0.1'] do
       to eq(subject.help(:huzzah, :version => :current))
   end
 
+  it "raises an ArgumentError if the face raises a StandardError" do
+    face = Puppet::Face[:module, :current]
+    face.stubs(:short_description).raises(StandardError, "whoops")
+
+    expect {
+      subject.help(:module)
+    }.to raise_error(ArgumentError, /Detail: "whoops"/)
+  end
+
+  it "raises an ArgumentError if the face raises a LoadError" do
+    face = Puppet::Face[:module, :current]
+    face.stubs(:short_description).raises(LoadError, "cannot load such file -- yard")
+
+    expect {
+      subject.help(:module)
+    }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
+  end
+
   context "when listing subcommands" do
     subject { Puppet::Face[:help, :current].help }
 
@@ -84,6 +102,18 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
     end
 
+    it "returns an 'unavailable' summary if the 'agent' application fails to generate help" do
+      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(ArgumentError, "whoops")
+
+      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
+    end
+
+    it "returns an 'unavailable' summary if the legacy application raises a LoadError" do
+      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+
+      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
+    end
+
     context "face summaries" do
       it "can generate face summaries" do
         faces = Puppet::Face.faces
@@ -92,6 +122,13 @@ describe Puppet::Face[:help, '0.0.1'] do
           expect(Puppet::Face[name, :current]).to have_a_summary
         end
       end
+
+      it "returns an 'unavailable' summary if the face application raises a LoadError" do
+        face = Puppet::Face[:module, :current]
+        face.stubs(:summary).raises(LoadError, "cannot load such file -- yard")
+
+        expect(Puppet::Face[:help, :current].help).to match(/module\s+! Subcommand unavailable due to error\. Check error logs\./)
+      end
     end
 
     it "lists all legacy applications" do
@@ -141,5 +178,21 @@ describe Puppet::Face[:help, '0.0.1'] do
       expect { subject.help(appname, :whatever) }.
         to raise_error ArgumentError, /Legacy subcommands don't take actions/
     end
+
+    it "raises an ArgumentError if a legacy application raises a StandardError" do
+      Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, "whoops")
+
+      expect {
+        subject.help(appname)
+      }.to raise_error ArgumentError, /Detail: "whoops"/
+    end
+
+    it "raises an ArgumentError if a legacy application raises a LoadError" do
+      Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+
+      expect {
+        subject.help(appname)
+      }.to raise_error ArgumentError, /Detail: "cannot load such file -- yard"/
+    end
   end
 end