puppet 4.0.0 → 4.5.0

data/spec/integration/util/windows/user_spec.rb

@@ -67,7 +67,7 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
         yield
       }.to raise_error { |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
         # ERROR_LOGON_FAILURE 1326
         expect(error.code).to eq(1326)
       }

data/spec/integration/util_spec.rb

@@ -27,9 +27,10 @@ describe Puppet::Util do
       expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
       expect($CHILD_STATUS.exitstatus).to eq(43)
     end
+  end
 
-    it "replace_file should preserve original ACEs from existing replaced file on Windows",
-      :if => Puppet.features.microsoft_windows? do
+  describe "#replace_file on Windows", :if => Puppet.features.microsoft_windows? do
+    it "replace_file should preserve original ACEs from existing replaced file on Windows" do
 
       file = tmpfile("somefile")
       FileUtils.touch(file)
@@ -54,8 +55,7 @@ describe Puppet::Util do
       expect(replaced_sd.dacl).to eq(expected_sd.dacl)
     end
 
-    it "replace_file should use reasonable default ACEs on a new file on Windows",
-      :if => Puppet.features.microsoft_windows? do
+    it "replace_file should use reasonable default ACEs on a new file on Windows" do
 
       dir = tmpdir('DACL_playground')
       protected_sd = Puppet::Util::Windows::Security.get_security_descriptor(dir)
@@ -76,36 +76,58 @@ describe Puppet::Util do
 
       expect(new_sd.dacl).to eq(expected_sd.dacl)
     end
-  end
 
-  it "replace_file should work with filenames that include - and . (PUP-1389)", :if => Puppet.features.microsoft_windows? do
-    expected_content = 'some content'
-    dir = tmpdir('ReplaceFile_playground')
-    destination_file = File.join(dir, 'some-file.xml')
+    it "replace_file should work with filenames that include - and . (PUP-1389)" do
+      expected_content = 'some content'
+      dir = tmpdir('ReplaceFile_playground')
+      destination_file = File.join(dir, 'some-file.xml')
+
+      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+          temp_file.open
+          temp_file.write(expected_content)
+      end
 
-    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-        temp_file.open
-        temp_file.write(expected_content)
+      actual_content = File.read(destination_file)
+      expect(actual_content).to eq(expected_content)
     end
 
-    actual_content = File.read(destination_file)
-    expect(actual_content).to eq(expected_content)
+    it "replace_file should work with filenames that include special characters (PUP-1389)" do
+      expected_content = 'some content'
+      dir = tmpdir('ReplaceFile_playground')
+      # http://www.fileformat.info/info/unicode/char/00e8/index.htm
+      # dest_name = "somèfile.xml"
+      dest_name = "som\u00E8file.xml"
+      destination_file = File.join(dir, dest_name)
+
+      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+          temp_file.open
+          temp_file.write(expected_content)
+      end
+
+      actual_content = File.read(destination_file)
+      expect(actual_content).to eq(expected_content)
+    end
   end
 
-  it "replace_file should work with filenames that include special characters (PUP-1389)", :if => Puppet.features.microsoft_windows? do
-    expected_content = 'some content'
-    dir = tmpdir('ReplaceFile_playground')
-    # http://www.fileformat.info/info/unicode/char/00e8/index.htm
-    # dest_name = "somèfile.xml"
-    dest_name = "som\u00E8file.xml"
-    destination_file = File.join(dir, dest_name)
-
-    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-        temp_file.open
-        temp_file.write(expected_content)
+  describe "#which on Windows", :if => Puppet.features.microsoft_windows? do
+    let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+    let (:filename) { 'foo.exe' }
+    let (:filepath) { File.expand_path('C:\\' + rune_utf8 + '\\' + filename) }
+
+    before :each do
+      FileTest.stubs(:file?).returns false
+      FileTest.stubs(:file?).with(filepath).returns true
+
+      FileTest.stubs(:executable?).returns false
+      FileTest.stubs(:executable?).with(filepath).returns true
     end
 
-    actual_content = File.read(destination_file)
-    expect(actual_content).to eq(expected_content)
+    it "should be able to use UTF8 characters in the path" do
+      path = "C:\\" + rune_utf8 + "#{File::PATH_SEPARATOR}c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
+      Puppet::Util.withenv( { "PATH" => path } , :windows) do
+        expect(Puppet::Util.which(filename)).to eq(filepath)
+      end
+    end
   end
+
 end

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
@@ -12,10 +11,10 @@ RSpec::Matchers.define :include_in_order do |*expected|
   end
 
   def failure_message
-    "expected #{@actual.inspect} to include#{expected_to_sentence} in order"
+    "expected #{@actual.inspect} to include#{expected} in order"
   end
 
   def failure_message_when_negated
-    "expected #{@actual.inspect} not to include#{expected_to_sentence} in order"
+    "expected #{@actual.inspect} not to include#{expected} in order"
   end
 end

data/spec/lib/matchers/resource.rb

@@ -36,7 +36,7 @@ module Matchers; module Resource
       if resource = actual_catalog.resource(expected_resource)
         resource_match(expected_resource, resource)
       else
-        @mismatch = "expected #{@actual.to_dot} to include #{@expected[0]}"
+        @mismatch = "expected #{@actual.to_dot} to include #{expected_resource}"
         false
       end
     end
@@ -50,4 +50,25 @@ module Matchers; module Resource
       @mismatch
     end
   end
+
+
+  matcher :be_resource do |expected_resource|
+    def resource_match(expected_resource, actual_resource)
+      if actual_resource.ref == expected_resource
+        true
+      else
+        @mismatch = "expected #{expected_resource} but was #{actual_resource.ref}"
+        false
+      end
+    end
+
+    match do |actual_resource|
+      resource_match(expected_resource, actual_resource)
+    end
+
+    def failure_message
+      @mismatch
+    end
+  end
+
 end; end

data/spec/lib/puppet_spec/compiler.rb

@@ -1,14 +1,14 @@
 module PuppetSpec::Compiler
   module_function
 
-  def compile_to_catalog(string, node = Puppet::Node.new('foonode'))
+  def compile_to_catalog(string, node = Puppet::Node.new('test'))
     Puppet[:code] = string
     # see lib/puppet/indirector/catalog/compiler.rb#filter
     Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
   end
 
-  def compile_to_ral(manifest)
-    catalog = compile_to_catalog(manifest)
+  def compile_to_ral(manifest, node = Puppet::Node.new('test'))
+    catalog = compile_to_catalog(manifest, node)
     ral = catalog.to_ral
     ral.finalize
     ral
@@ -46,4 +46,28 @@ module PuppetSpec::Compiler
     relationships.traverse { |resource| order_seen << resource.ref }
     order_seen
   end
+
+  def collect_notices(code, node = Puppet::Node.new('foonode'))
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      yield(compiler)
+    end
+    logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+    logs
+  end
+
+  def eval_and_collect_notices(code, node = Puppet::Node.new('foonode'))
+    collect_notices(code, node) do |compiler|
+      if block_given?
+        compiler.compile do |catalog|
+          yield(compiler.topscope, catalog)
+          catalog
+        end
+      else
+        compiler.compile
+      end
+    end
+  end
 end

data/spec/lib/puppet_spec/files.rb

@@ -28,7 +28,7 @@ module PuppetSpec::Files
   def self.tmpfile(name, dir = nil)
     # Generate a temporary file, just for the name...
     source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
-    path = source.path
+    path = source.path.encode(Encoding::UTF_8)
     source.close!
 
     record_tmp(File.expand_path(path))
@@ -43,9 +43,23 @@ 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)
+    dir = Dir.mktmpdir(name).encode!(Encoding::UTF_8)
 
     record_tmp(dir)
 

data/spec/lib/puppet_spec/matchers.rb

@@ -58,10 +58,10 @@ end
 RSpec::Matchers.define :have_printed do |expected|
 
   case expected
-    when String, Regexp
-      expected = expected
-    else
-      expected = expected.to_s
+  when String, Regexp, Proc
+    expected = expected
+  else
+    expected = expected.to_s
   end
 
   chain :and_exit_with do |code|
@@ -79,6 +79,8 @@ RSpec::Matchers.define :have_printed do |expected|
         actual.include?(expected)
       when Regexp
         expected.match(actual)
+      when Proc
+        expected.call(actual)
       else
         raise ArgumentError, "No idea how to match a #{actual.class.name}"
     end

data/spec/lib/puppet_spec/pops.rb

@@ -13,4 +13,17 @@ module PuppetSpec::Pops
       "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain issue #{expected.issue_code}"
     end
   end
+
+  # Checks if an Acceptor has any issues
+  matcher :have_any_issues do
+    match do |actual|
+      !actual.diagnostics.empty?
+    end
+    failure_message do |actual|
+      'expected Acceptor[] to contain at least one issue'
+    end
+    failure_message_when_negated do |actual|
+      "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain any issues"
+    end
+  end
 end

data/spec/shared_behaviours/iterative_functions.rb

@@ -16,31 +16,31 @@ shared_examples_for 'all iterative functions argument checks' do |func|
       compile_to_catalog(<<-MANIFEST)
         3.14.#{func} |$k, $v| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /must be something enumerable/)
+    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
   end
 
   it 'raises an error when called with any parameters besides a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1) |$v| {  }
+        [1].#{func}(1,2) |$v,$y| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*arg count \{3\}/m)
+    end.to raise_error(Puppet::Error, /expects (?:between 1 and 2 arguments|1 argument), got 3/)
   end
 
   it 'raises an error when called without a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}()
+        [1].#{func}
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*arg count \{1\}/m)
+    end.to raise_error(Puppet::Error, /expects a block/)
   end
 
   it 'raises an error when called with something that is not a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1)
+        [1].#{func}(1,2)
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*Callable.*actual(?!Callable\)).*/m)
+    end.to raise_error(Puppet::Error, /expects (?:between 1 and 2 arguments|1 argument), got 3/)
   end
 
   it 'raises an error when called with a block with too many required parameters' do
@@ -48,7 +48,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
       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.to raise_error(Puppet::Error, /block expects(?: between 1 and)? 2 arguments, got 3/)
   end
 
   it 'raises an error when called with a block with too few parameters' do
@@ -56,7 +56,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
       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.to raise_error(Puppet::Error, /block expects(?: between 1 and)? 2 arguments, got none/)
   end
 
   it 'does not raise an error when called with a block with too many but optional arguments' do

data/spec/shared_contexts/types_setup.rb

@@ -0,0 +1,100 @@
+shared_context 'types_setup' do
+
+  # Do not include the special type Unit in this list
+  def all_types
+    [ Puppet::Pops::Types::PAnyType,
+      Puppet::Pops::Types::PUndefType,
+      Puppet::Pops::Types::PNotUndefType,
+      Puppet::Pops::Types::PDataType,
+      Puppet::Pops::Types::PScalarType,
+      Puppet::Pops::Types::PStringType,
+      Puppet::Pops::Types::PNumericType,
+      Puppet::Pops::Types::PIntegerType,
+      Puppet::Pops::Types::PFloatType,
+      Puppet::Pops::Types::PRegexpType,
+      Puppet::Pops::Types::PBooleanType,
+      Puppet::Pops::Types::PCollectionType,
+      Puppet::Pops::Types::PArrayType,
+      Puppet::Pops::Types::PHashType,
+      Puppet::Pops::Types::PIterableType,
+      Puppet::Pops::Types::PIteratorType,
+      Puppet::Pops::Types::PRuntimeType,
+      Puppet::Pops::Types::PHostClassType,
+      Puppet::Pops::Types::PResourceType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PEnumType,
+      Puppet::Pops::Types::PVariantType,
+      Puppet::Pops::Types::PStructType,
+      Puppet::Pops::Types::PTupleType,
+      Puppet::Pops::Types::PCallableType,
+      Puppet::Pops::Types::PType,
+      Puppet::Pops::Types::POptionalType,
+      Puppet::Pops::Types::PDefaultType,
+      Puppet::Pops::Types::PTypeReferenceType,
+      Puppet::Pops::Types::PTypeAliasType,
+      Puppet::Pops::Types::PSemVerType,
+      Puppet::Pops::Types::PSemVerRangeType,
+    ]
+  end
+
+  def scalar_types
+    # PVariantType is also scalar, if its types are all Scalar
+    [
+      Puppet::Pops::Types::PScalarType,
+      Puppet::Pops::Types::PStringType,
+      Puppet::Pops::Types::PNumericType,
+      Puppet::Pops::Types::PIntegerType,
+      Puppet::Pops::Types::PFloatType,
+      Puppet::Pops::Types::PRegexpType,
+      Puppet::Pops::Types::PBooleanType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PEnumType,
+      Puppet::Pops::Types::PSemVerType,
+      Puppet::Pops::Types::PSemVerRangeType,
+    ]
+  end
+
+  def numeric_types
+    # PVariantType is also numeric, if its types are all numeric
+    [
+      Puppet::Pops::Types::PNumericType,
+      Puppet::Pops::Types::PIntegerType,
+      Puppet::Pops::Types::PFloatType,
+    ]
+  end
+
+  def string_types
+    # PVariantType is also string type, if its types are all compatible
+    [
+      Puppet::Pops::Types::PStringType,
+      Puppet::Pops::Types::PPatternType,
+      Puppet::Pops::Types::PEnumType,
+    ]
+  end
+
+  def collection_types
+    # PVariantType is also string type, if its types are all compatible
+    [
+      Puppet::Pops::Types::PCollectionType,
+      Puppet::Pops::Types::PHashType,
+      Puppet::Pops::Types::PArrayType,
+      Puppet::Pops::Types::PStructType,
+      Puppet::Pops::Types::PTupleType,
+    ]
+  end
+
+  def data_compatible_types
+    result = scalar_types
+    result << Puppet::Pops::Types::PDataType
+    result << array_t(types::PDataType::DEFAULT)
+    result << types::TypeFactory.hash_of_data
+    result << Puppet::Pops::Types::PUndefType
+    result << not_undef_t(types::PDataType.new)
+    result << constrained_tuple_t(range_t(0, nil), types::PDataType::DEFAULT)
+    result
+  end
+
+  def type_from_class(c)
+    c.is_a?(Class) ? c::DEFAULT : c
+  end
+end

data/spec/spec_helper.rb

@@ -43,6 +43,13 @@ Pathname.glob("#{dir}/shared_behaviours/**/*.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)
+  vcr.hook_into :webmock
+  vcr.configure_rspec_metadata!
+end
+
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 

data/spec/unit/agent/locker_spec.rb

@@ -58,17 +58,17 @@ describe Puppet::Agent::Locker do
     expect(@locker.lock { :result }).to eq(:result)
   end
 
-  it "should return nil when the lock method does not receive the lock" do
+  it "should raise LockError when the lock method does not receive the lock" do
     @locker.send(:lockfile).expects(:lock).returns false
 
-    expect(@locker.lock {}).to be_nil
+    expect { @locker.lock {} }.to raise_error(Puppet::LockError)
   end
 
   it "should not yield when the lock method does not receive the lock" do
     @locker.send(:lockfile).expects(:lock).returns false
 
     yielded = false
-    @locker.lock { yielded = true }
+    expect { @locker.lock { yielded = true } }.to raise_error(Puppet::LockError)
     expect(yielded).to be_falsey
   end
 
@@ -76,7 +76,7 @@ describe Puppet::Agent::Locker do
     @locker.send(:lockfile).expects(:lock).returns false
     @locker.send(:lockfile).expects(:unlock).never
 
-    @locker.lock {}
+    expect { @locker.lock {} }.to raise_error(Puppet::LockError)
   end
 
   it "should unlock after yielding upon obtaining a lock" do

data/spec/unit/agent_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/agent'
+require 'puppet/configurer'
 
 class AgentTestClient
   def run
@@ -58,7 +59,6 @@ describe Puppet::Agent do
 
     client.expects(:run)
 
-    @agent.stubs(:running?).returns false
     @agent.stubs(:disabled?).returns false
     @agent.run
   end
@@ -75,7 +75,6 @@ describe Puppet::Agent do
   describe "when being run" do
     before do
       AgentTestClient.stubs(:lockfile_path).returns "/my/lock"
-      @agent.stubs(:running?).returns false
       @agent.stubs(:disabled?).returns false
     end
 
@@ -85,12 +84,6 @@ describe Puppet::Agent do
       @agent.run
     end
 
-    it "should do nothing if already running" do
-      @agent.expects(:running?).returns true
-      AgentTestClient.expects(:new).never
-      @agent.run
-    end
-
     it "should do nothing if disabled" do
       @agent.expects(:disabled?).returns(true)
       AgentTestClient.expects(:new).never
@@ -234,44 +227,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/agent_spec.rb

@@ -197,6 +197,11 @@ describe Puppet::Application::Agent do
       Puppet.stubs(:settraps)
     end
 
+    it "should not run with extra arguments" do
+      @puppetd.command_line.stubs(:args).returns(%w{disable})
+      expect{@puppetd.setup}.to raise_error ArgumentError, /does not take parameters/
+    end
+
     describe "with --test" do
       it "should call setup_test" do
         @puppetd.options[:test] = true
@@ -338,12 +343,22 @@ describe Puppet::Application::Agent do
 
     it "should not set catalog cache class if :catalog_cache_terminus is explicitly nil" do
       Puppet[:catalog_cache_terminus] = nil
+      Puppet::Resource::Catalog.indirection.unstub(:cache_class=)
       Puppet::Resource::Catalog.indirection.expects(:cache_class=).never
 
       @puppetd.initialize_app_defaults
       @puppetd.setup
     end
 
+    it "should set catalog cache class to nil during a noop run" do
+      Puppet[:catalog_cache_terminus] = "json"
+      Puppet[:noop] = true
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(nil)
+
+      @puppetd.initialize_app_defaults
+      @puppetd.setup
+    end
+
     it "should default facts_terminus setting to 'facter'" do
       @puppetd.initialize_app_defaults
       expect(Puppet[:facts_terminus]).to eq(:facter)