puppet 4.1.0-x64-mingw32 → 4.2.0-x64-mingw32

data/spec/lib/matchers/include_in_order.rb

@@ -1,5 +1,4 @@
 RSpec::Matchers.define :include_in_order do |*expected|
-  include RSpec::Matchers::Pretty
 
   match do |actual|
     elements = expected.dup

data/spec/lib/puppet_spec/files.rb

@@ -43,6 +43,20 @@ module PuppetSpec::Files
     file
   end
 
+  def script_containing(name, contents) PuppetSpec::Files.script_containing(name, contents) end
+  def self.script_containing(name, contents)
+    file = tmpfile(name)
+    if Puppet.features.microsoft_windows?
+      file += '.bat'
+      text = contents[:windows]
+    else
+      text = contents[:posix]
+    end
+    File.open(file, 'wb') { |f| f.write(text) }
+    Puppet::FileSystem.chmod(0755, file)
+    file
+  end
+
   def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
   def self.tmpdir(name)
     dir = Dir.mktmpdir(name)

data/spec/unit/agent_spec.rb

@@ -234,44 +234,6 @@ describe Puppet::Agent do
     end
   end
 
-  describe "when splaying" do
-    before do
-      Puppet[:splay] = true
-      Puppet[:splaylimit] = "10"
-    end
-
-    it "should do nothing if splay is disabled" do
-      Puppet[:splay] = false
-      @agent.expects(:sleep).never
-      @agent.splay
-    end
-
-    it "should do nothing if it has already splayed" do
-      @agent.expects(:splayed?).returns true
-      @agent.expects(:sleep).never
-      @agent.splay
-    end
-
-    it "should log that it is splaying" do
-      @agent.stubs :sleep
-      Puppet.expects :info
-      @agent.splay
-    end
-
-    it "should sleep for a random portion of the splaylimit plus 1" do
-      Puppet[:splaylimit] = "50"
-      @agent.expects(:rand).with(51).returns 10
-      @agent.expects(:sleep).with(10)
-      @agent.splay
-    end
-
-    it "should mark that it has splayed" do
-      @agent.stubs(:sleep)
-      @agent.splay
-      expect(@agent).to be_splayed
-    end
-  end
-
   describe "when checking execution state" do
     describe 'with regular run status' do
       before :each do

data/spec/unit/application/apply_spec.rb

@@ -120,6 +120,13 @@ describe Puppet::Application::Apply do
       expect { @apply.setup }.to exit_with 1
     end
 
+    it "should use :main, :puppetd, and :ssl" do
+      Puppet.settings.unstub(:use)
+      Puppet.settings.expects(:use).with(:main, :agent, :ssl)
+
+      @apply.setup
+    end
+
     it "should tell the report handler to cache locally as yaml" do
       Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
 
@@ -243,6 +250,12 @@ describe Puppet::Application::Apply do
         expect(msg.level).to eq(:warning)
       end
 
+      it "should splay" do
+        @apply.expects(:splay)
+
+        expect { @apply.main }.to exit_with 0
+      end
+
       it "should raise an error if we can't find the node" do
         Puppet::Node.indirection.expects(:find).returns(nil)
 

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -14,26 +14,55 @@ describe Puppet::Configurer::PluginHandler do
     Puppet.expects(:err).never
   end
 
-  it "downloads plugins and facts" do
-    Puppet.features.stubs(:external_facts?).returns(true)
+  context "when external facts are supported" do
+    before :each do
+      Puppet.features.stubs(:external_facts?).returns(true)
+    end
 
-    plugin_downloader = stub('plugin-downloader', :evaluate => [])
-    facts_downloader = stub('facts-downloader', :evaluate => [])
+    it "downloads plugins and facts" do
+      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)
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
 
-    pluginhandler.download_plugins(environment)
+      pluginhandler.download_plugins(environment)
+    end
+
+    it "returns downloaded plugin and fact filenames" do
+      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
+      facts_downloader = stub('facts-downloader', :evaluate => %w[/b])
+
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
+      factory.expects(:create_plugin_facts_downloader).returns(facts_downloader)
+
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+    end
   end
 
-  it "skips facts if not enabled" do
-    Puppet.features.stubs(:external_facts?).returns(false)
+  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 => [])
+      plugin_downloader = stub('plugin-downloader', :evaluate => %w[/a])
+      facts_downloader = stub('facts-downloader')
 
-    factory.expects(:create_plugin_downloader).returns(plugin_downloader)
-    factory.expects(:create_plugin_facts_downloader).never
+      factory.expects(:create_plugin_downloader).returns(plugin_downloader)
 
-    pluginhandler.download_plugins(environment)
+      expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a])
+    end
   end
 end

data/spec/unit/configurer_spec.rb

@@ -531,6 +531,11 @@ describe Puppet::Configurer do
       Puppet::Node.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => anything)).twice
       @agent.run
     end
+
+    it "sends the configured environment in the request" do
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => Puppet[:environment])).twice
+      @agent.run
+    end
   end
 
   describe "when retrieving a catalog" do

data/spec/unit/face/plugin_spec.rb

@@ -2,9 +2,38 @@
 require 'spec_helper'
 require 'puppet/face'
 
-describe Puppet::Face[:plugin, '0.0.1'] do
-  [:download].each do |action|
-    it { is_expected.to be_action action }
-    it { is_expected.to respond_to action }
+describe Puppet::Face[:plugin, :current] do
+
+  let(:pluginface) { described_class }
+  let(:action) { pluginface.get_action(:download) }
+
+  def render(result)
+    action.when_rendering(:console).call(result)
+  end
+
+  context "download" do
+    before :each do
+      Puppet.features.stubs(:external_facts?).returns(true)
+    end
+
+    it "downloads plugins and external facts" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+
+      pluginface.download
+    end
+
+    it "renders 'No plugins downloaded' if nothing was downloaded" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.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])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+    end
   end
 end

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

@@ -33,16 +33,6 @@ describe Puppet::FileServing::Configuration::Parser do
       expect { @parser.parse }.not_to raise_error
     end
 
-    it "should create a new mount for each section in the configuration" do
-      mount1 = mock 'one', :validate => true
-      mount2 = mock 'two', :validate => true
-      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
-      Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
-      write_config_file "[one]\n[two]\n"
-      @parser.parse
-    end
-
-    # This test is almost the exact same as the previous one.
     it "should return a hash of the created mounts" do
       mount1 = mock 'one', :validate => true
       mount2 = mock 'two', :validate => true
@@ -108,29 +98,34 @@ describe Puppet::FileServing::Configuration::Parser do
       @parser.parse
     end
 
-    it "should tell the mount to allow any allow values from the section" do
-      write_config_file "[one]\nallow something\n"
+    [:allow,:deny].each { |acl_type|
+      it "should support inline comments in #{acl_type}" do
+        write_config_file "[one]\n#{acl_type} something \# will it work?\n"
 
       @mount.expects(:info)
-      @mount.expects(:allow).with("something")
+      @mount.expects(acl_type).with("something")
       @parser.parse
-    end
-
-    it "should support inline comments" do
-      write_config_file "[one]\nallow something \# will it work?\n"
-
-      @mount.expects(:info)
-      @mount.expects(:allow).with("something")
-      @parser.parse
-    end
-
-    it "should tell the mount to deny any deny values from the section" do
-      write_config_file "[one]\ndeny something\n"
-
-      @mount.expects(:info)
-      @mount.expects(:deny).with("something")
-      @parser.parse
-    end
+      end
+
+      it "should tell the mount to #{acl_type} from ACLs with varying spacing around commas" do
+        write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
+
+        @mount.expects(:info).times(5)
+        @mount.expects(acl_type).times(5).with(any_of('someone','sometwo','somethree','somefour','somefive'))
+        @parser.parse
+      end
+
+      # each ip, with glob in the various octet positions
+      ['100','4','42','*'].permutation.map {|permutes| permutes.join('.') }.each { |ip_pattern|
+        it "should tell the mount to #{acl_type} from ACLs with glob at #{ip_pattern}" do
+          write_config_file "[one]\n#{acl_type} #{ip_pattern}\n"
+
+          @mount.expects(:info)
+          @mount.expects(acl_type).with(ip_pattern)
+          @parser.parse
+        end
+      }
+    }
 
     it "should return comprehensible error message, if failed on invalid attribute" do
       write_config_file "[one]\ndo something\n"

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -200,6 +200,22 @@ describe Puppet::Resource::Catalog::Compiler do
 
       compiler.find(request)
     end
+
+    it "should pass the configured_environment to the node indirection" do
+      environment = 'foo'
+      node = Puppet::Node.new("thing")
+      compiler = Puppet::Resource::Catalog::Compiler.new
+      compiler.stubs(:compile)
+      request = Puppet::Indirector::Request.new(:catalog, :find, "thing",
+                                                nil, :configured_environment => environment)
+
+      Puppet::Node.indirection.expects(:find).with(
+        "thing",
+        has_entries(:configured_environment => environment)
+      ).returns(node)
+
+      compiler.find(request)
+    end
   end
 
   describe "after finding nodes" do

data/spec/unit/indirector/facts/facter_spec.rb

@@ -43,10 +43,11 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
-    it 'should add the puppetversion fact' do
+    it 'should add the puppetversion and agent_specified_environment facts' do
       reset = sequence 'reset'
       Facter.expects(:reset).in_sequence(reset)
       Facter.expects(:add).with(:puppetversion)
+      Facter.expects(:add).with(:agent_specified_environment)
       @facter.find(@request)
     end
 

data/spec/unit/module_spec.rb

@@ -132,23 +132,6 @@ describe Puppet::Module do
       mod.description = "GPL2"
       expect(mod.description).to eq("GPL2")
     end
-
-    it "should support specifying a compatible puppet version" do
-      mod.puppetversion = "0.25"
-      expect(mod.puppetversion).to eq("0.25")
-    end
-  end
-
-  it "should validate that the puppet version is compatible" do
-    mod.puppetversion = "0.25"
-    Puppet.expects(:version).returns "0.25"
-    mod.validate_puppet_version
-  end
-
-  it "should fail if the specified puppet version is not compatible" do
-    mod.puppetversion = "0.25"
-    Puppet.stubs(:version).returns "0.24"
-    expect { mod.validate_puppet_version }.to raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when finding unmet dependencies" do
@@ -670,7 +653,6 @@ describe Puppet::Module do
         :author        => "luke",
         :version       => "1.0",
         :source        => "http://foo/",
-        :puppetversion => "0.25",
         :dependencies  => []
       }
       @module = a_module_with_metadata(@data)
@@ -692,11 +674,6 @@ describe Puppet::Module do
         )
       end
     end
-
-    it "should set puppetversion if present in the metadata file" do
-      @module.load_metadata
-      expect(@module.puppetversion).to eq(@data[:puppetversion])
-    end
   end
 
   it "should be able to tell if there are local changes" do

data/spec/unit/network/http/factory_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
+require 'puppet/util/http_proxy'
 
 describe Puppet::Network::HTTP::Factory do
   before :each do
@@ -41,13 +42,25 @@ describe Puppet::Network::HTTP::Factory do
 
     it "should not set a proxy if the value is 'none'" do
       Puppet[:http_proxy_host] = 'none'
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
     end
 
+    it 'should not set a proxy if a no_proxy env var matches the destination' do
+      Puppet[:http_proxy_host] = proxy_host
+      Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
+      conn = create_connection(site)
+
+      expect(conn.proxy_address).to be_nil
+      expect(conn.proxy_port).to be_nil
+    end
+
     it 'sets proxy_address' do
       Puppet[:http_proxy_host] = proxy_host
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_address).to eq(proxy_host)
@@ -56,6 +69,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'sets proxy address and port' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_port).to eq(proxy_port)

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -4,9 +4,13 @@ require 'puppet_spec/scope'
 
 describe "the fqdn_rand function" do
   include PuppetSpec::Scope
-  
+
+  it "returns an integer" do
+    expect(fqdn_rand(3)).to be_an(Integer)
+  end
+
   it "provides a random number strictly less than the given max" do
-    expect(fqdn_rand(3)).to satisfy {|n| n.to_i < 3 }
+    expect(fqdn_rand(3)).to satisfy {|n| n < 3 }
   end
 
   it "provides the same 'random' value on subsequent calls for the same host" do

data/spec/unit/parser/functions/generate_spec.rb

@@ -92,18 +92,9 @@ describe "the generate function" do
   end
 
   let :command do
-    cmd = tmpfile('function_generate')
-
-    if Puppet.features.microsoft_windows?
-      cmd += '.bat'
-      text = '@echo off' + "\n" + 'echo a-%1 b-%2'
-    else
-      text = '#!/bin/sh' + "\n" + 'echo a-$1 b-$2'
-    end
-
-    File.open(cmd, 'w') {|fh| fh.puts text }
-    File.chmod 0700, cmd
-    cmd
+    script_containing('function_generate',
+      :windows => '@echo off' + "\n" + 'echo a-%1 b-%2',
+      :posix   => '#!/bin/sh' + "\n" + 'echo a-$1 b-$2')
   end
 
   after :each do