puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/spec/integration/parser/undef_param_spec.rb

@@ -84,4 +84,12 @@ describe "Parameter passing" do
     MANIFEST
     end
   end
+
+  it "uses a given undef and do not require a default expression" do
+    expect_the_message_to_be(true) do <<-MANIFEST
+        define a(Optional[Integer] $x) { notify { 'something': message => $x == undef}}
+        a {'a': x => undef }
+    MANIFEST
+    end
+  end
 end

data/spec/integration/provider/yumrepo_spec.rb

@@ -87,7 +87,7 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile), '(integration)',
     properties = {"bandwidth"      => "42M",
                   "baseurl"        => "http://er0ck",
                   "cost"           => "42",
-                  "enabled"        => "YeS",
+                  "enabled"        => "Yes",
                   "exclude"        => "er0ckSet2.0",
                   "failovermethod" => "roundrobin",
                   "include"        => "https://er0ck",

data/spec/integration/test/test_helper_spec.rb

@@ -0,0 +1,28 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe "Windows UTF8 environment variables", :if => Puppet.features.microsoft_windows? do
+  # The Puppet::Util::Windows::Process class is used to manipulate environment variables as it is known to handle UTF8 characters. Where as the implementation of ENV in ruby does not.
+  # before and end all are used to inject environment variables before the test helper 'before_each_test' function is called
+  # Do not use before and after hooks in these tests as it may have unintended consequences
+
+  before(:all) {
+    @varname = 'test-helper-foo'
+    @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"
+
+    Puppet::Util::Windows::Process.set_environment_variable(@varname, @rune_utf8)
+  }
+
+  it "#after_each_test should preserve UTF8 environment variables" do
+    envhash = Puppet::Util::Windows::Process.get_environment_strings
+    expect(envhash[@varname]).to eq(@rune_utf8)
+    # Change the value in the test to force test_helper to restore the environment
+    ENV[@varname] = 'bad foo'
+
+    # Prematurely trigger the after_each_test method
+    Puppet::Test::TestHelper.after_each_test
+
+    envhash = Puppet::Util::Windows::Process.get_environment_strings
+    expect(envhash[@varname]).to eq(@rune_utf8)
+  end
+end

data/spec/integration/transaction/report_spec.rb

@@ -21,4 +21,20 @@ describe Puppet::Transaction::Report do
       Puppet::Transaction::Report.indirection.save(report)
     end
   end
+
+  describe "when dumping to YAML" do
+    it "should not contain TagSet objects" do
+      resource = Puppet::Resource.new(:notify, "Hello")
+      ral_resource = resource.to_ral
+      status = Puppet::Resource::Status.new(ral_resource)
+
+      log = Puppet::Util::Log.new(:level => :info, :message => "foo")
+
+      report = Puppet::Transaction::Report.new("apply")
+      report.add_resource_status(status)
+      report << log
+
+      expect(YAML.dump(report)).to_not match('Puppet::Util::TagSet')
+    end
+  end
 end

data/spec/integration/transaction_spec.rb

@@ -319,6 +319,17 @@ describe Puppet::Transaction do
       expect(Puppet::FileSystem.exist?(fname)).to be_falsey
     end
 
+    it "does not trigger skip-tagged resources" do
+      catalog = mk_catalog
+
+      Puppet[:skip_tags] = "skipme"
+      exec.tag("skipme")
+
+      catalog.add_resource(file, exec)
+      catalog.apply
+      expect(Puppet::FileSystem.exist?(fname)).to be_falsey
+    end
+
     it "does not trigger resources with failed dependencies" do
       catalog = mk_catalog
       file[:path] = make_absolute("/foo/bar/baz")

data/spec/integration/type/file_spec.rb

@@ -1226,6 +1226,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
           :backup => false
         }
       end
+
       describe "on POSIX systems", :if => Puppet.features.posix? do
         it "should apply the source metadata values" do
           @options[:source_permissions] = :use
@@ -1260,6 +1261,102 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
     end
 
     let(:source) { tmpfile_with_contents("source_default_values", "yay") }
+
+    describe "from http" do
+      let(:http_source) { "http://my-server/file" }
+      let(:httppath) { "#{path}http" }
+
+      context "using mtime", :vcr => true do
+        let(:resource) do
+          described_class.new(
+            :path   => httppath,
+            :ensure => :file,
+            :source => http_source,
+            :backup => false,
+            :checksum => :mtime
+          )
+        end
+
+        it "should fetch if not on the local disk" do
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+        end
+
+        # The fixture has neither last-modified nor content-checksum headers.
+        # Such upstream ressources are treated as "really fresh" and get
+        # downloaded during every run.
+        it "should fetch if no header specified" do
+          File.open(httppath, "wb") { |f| f.puts "Content originally on disk\n" }
+          # make sure the mtime is not "right now", lest we get a race
+          FileUtils.touch httppath, :mtime => Time.parse("Sun, 22 Mar 2015 22:57:43 GMT")
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+        end
+
+        it "should fetch if mtime is older on disk" do
+          File.open(httppath, "wb") { |f| f.puts "Content originally on disk\n" }
+          # fixture has Last-Modified: Sun, 22 Mar 2015 22:25:34 GMT
+          FileUtils.touch httppath, :mtime => Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+        end
+
+        it "should not update if mtime is newer on disk" do
+          File.open(httppath, "wb") { |f| f.puts "Content via HTTP\n" }
+          mtime = File.stat(httppath).mtime
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+          expect(File.stat(httppath).mtime).to eq mtime
+        end
+      end
+
+      context "using md5", :vcr => true do
+        let(:resource) do
+          described_class.new(
+            :path   => httppath,
+            :ensure => :file,
+            :source => http_source,
+            :backup => false,
+          )
+        end
+
+        it "should fetch if not on the local disk" do
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+        end
+
+        it "should update if content differs on disk" do
+          File.open(httppath, "wb") { |f| f.puts "Content originally on disk\n" }
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+        end
+
+        it "should not update if content on disk is up-to-date" do
+          File.open(httppath, "wb") { |f| f.puts "Content via HTTP\n" }
+          disk_mtime = Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
+          FileUtils.touch httppath, :mtime => disk_mtime
+          catalog.add_resource resource
+          catalog.apply
+          expect(Puppet::FileSystem.exist?(httppath)).to be_truthy
+          expect(File.read(httppath)).to eq "Content via HTTP\n"
+          expect(File.stat(httppath).mtime).to eq disk_mtime
+        end
+
+      end
+    end
+
     describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
       def expects_sid_granted_full_access_explicitly(path, sid)
         inherited_ace = Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE
@@ -1297,11 +1394,11 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         before do
           @sids = {
             :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
-            :system => Win32::Security::SID::LocalSystem,
+            :system => Puppet::Util::Windows::SID::LocalSystem,
             :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
-            :users => Win32::Security::SID::BuiltinUsers,
-            :power_users => Win32::Security::SID::PowerUsers,
-            :none => Win32::Security::SID::Nobody
+            :users => Puppet::Util::Windows::SID::BuiltinUsers,
+            :power_users => Puppet::Util::Windows::SID::PowerUsers,
+            :none => Puppet::Util::Windows::SID::Nobody
           }
         end
 
@@ -1690,4 +1787,97 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       end
     end
   end
+
+  [:md5, :sha256, :md5lite, :sha256lite].each do |checksum|
+    describe "setting checksum_value explicitly with checksum #{checksum}" do
+      let(:path) { tmpfile('target') }
+      let(:contents) { 'yay' }
+
+      before :each do
+        @options = {
+          :path           => path,
+          :ensure         => :file,
+          :checksum       => checksum,
+          :checksum_value => Puppet::Util::Checksums.send(checksum, contents)
+        }
+      end
+
+      def verify_file(transaction)
+        status = transaction.report.resource_statuses["File[#{path}]"]
+        expect(status).not_to be_failed
+        expect(Puppet::FileSystem).to be_file(path)
+        expect(File.read(path)).to eq(contents)
+        status
+      end
+
+      [:source, :content].each do |prop|
+        context "from #{prop}" do
+          let(:source) { tmpfile_with_contents("source_default_values", contents) }
+
+          before :each do
+            @options[prop] = {:source => source, :content => contents}[prop]
+          end
+
+          it "should create a new file" do
+            catalog.add_resource described_class.new(@options)
+            status = verify_file catalog.apply
+            expect(status).to be_changed
+          end
+
+          it "should overwrite an existing file" do
+            File.open(path, "w") { |f| f.write('bar') }
+            catalog.add_resource described_class.new(@options)
+            status = verify_file catalog.apply
+            expect(status).to be_changed
+          end
+
+          it "should not overwrite the same file" do
+            File.open(path, "w") { |f| f.write(contents) }
+            catalog.add_resource described_class.new(@options)
+            status = verify_file catalog.apply
+            expect(status).to_not be_changed
+          end
+
+          it "should not create a file when ensuring absent" do
+            @options[:ensure] = :absent
+            catalog.add_resource described_class.new(@options)
+            catalog.apply
+            expect(Puppet::FileSystem).to_not be_file(path)
+          end
+        end
+      end
+    end
+  end
+
+  describe "setting checksum_value explicitly with checksum mtime" do
+    let(:path) { tmpfile('target_dir') }
+    let(:time) { Time.now }
+
+    before :each do
+      @options = {
+        :path           => path,
+        :ensure         => :directory,
+        :checksum       => :mtime,
+        :checksum_value => time
+      }
+    end
+
+    it "should create a new directory" do
+      catalog.add_resource described_class.new(@options)
+      status = catalog.apply.report.resource_statuses["File[#{path}]"]
+      expect(status).not_to be_failed
+      expect(status).to be_changed
+      expect(Puppet::FileSystem).to be_directory(path)
+    end
+
+    it "should not update mtime on an old directory" do
+      disk_mtime = Time.parse("Sun, 22 Mar 2015 22:22:34 GMT")
+      FileUtils.mkdir_p path
+      FileUtils.touch path, :mtime => disk_mtime
+      status = catalog.apply.report.resource_statuses["File[#{path}]"]
+      expect(status).to be_nil
+      expect(Puppet::FileSystem).to be_directory(path)
+      expect(File.stat(path).mtime).to eq(disk_mtime)
+    end
+  end
 end

data/spec/integration/type/package_spec.rb

@@ -28,7 +28,11 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
         :yum
       end
     when 'Fedora'
-      :yum
+      if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemmajrelease), '22') >= 0
+        :dnf
+      else
+        :yum
+      end
     when 'FreeBSD'
       :ports
     when 'OpenBSD'

data/spec/integration/type/tidy_spec.rb

@@ -1,16 +1,32 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+require 'puppet_spec/compiler'
 require 'puppet_spec/files'
 require 'puppet/file_bucket/dipper'
 
 describe Puppet::Type.type(:tidy) do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
+  it "should be able to recursively remove directories" do
+    dir = tmpfile("tidy_testing")
+    FileUtils.mkdir_p(File.join(dir, "foo", "bar"))
+
+    apply_compiled_manifest(<<-MANIFEST)
+      tidy { '#{dir}':
+        recurse => true,
+        rmdirs  => true,
+      }
+    MANIFEST
+
+    expect(Puppet::FileSystem.directory?(dir)).to be_falsey
+  end
+
   # Testing #355.
   it "should be able to remove dead links", :if => Puppet.features.manages_symlinks? do
     dir = tmpfile("tidy_link_testing")
@@ -19,15 +35,11 @@ describe Puppet::Type.type(:tidy) do
     Dir.mkdir(dir)
     Puppet::FileSystem.symlink(target, link)
 
-    tidy = Puppet::Type.type(:tidy).new :path => dir, :recurse => true
-
-    catalog = Puppet::Resource::Catalog.new
-    catalog.add_resource(tidy)
-    # avoid crude failures because of nil resources that result
-    # from implicit containment and lacking containers
-    catalog.stubs(:container_of).returns tidy
-
-    catalog.apply
+    apply_compiled_manifest(<<-MANIFEST)
+      tidy { '#{dir}':
+        recurse => true,
+      }
+    MANIFEST
 
     expect(Puppet::FileSystem.symlink?(link)).to be_falsey
   end

data/spec/integration/util/execution_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Puppet::Util::Execution do
+  include PuppetSpec::Files
+
   describe "#execpipe" do
     it "should set LANG to C avoid localized output", :if => !Puppet.features.microsoft_windows? do
       out = ""
@@ -14,4 +16,24 @@ describe Puppet::Util::Execution do
       expect(out).to eq("C")
     end
   end
+
+  describe "#execute (Windows)", :if => Puppet.features.microsoft_windows? do
+    let(:utf8text) do
+      # Japanese Lorem Ipsum snippet
+      "utf8testfile" + [227, 131, 171, 227, 131, 147, 227, 131, 179, 227, 131, 132, 227,
+                        130, 162, 227, 130, 166, 227, 130, 167, 227, 131, 150, 227, 130,
+                        162, 227, 129, 181, 227, 129, 185, 227, 129, 139, 227, 130, 137,
+                        227, 129, 154, 227, 130, 187, 227, 130, 183, 227, 131, 147, 227,
+                        131, 170, 227, 131, 134].pack('c*').force_encoding(Encoding::UTF_8)
+    end
+    let(:temputf8filename) do
+      script_containing(utf8text, :windows => "@ECHO OFF\nECHO #{utf8text}\nEXIT 100")
+    end
+
+    it "should execute with non-english characters in command line" do
+      result = Puppet::Util::Execution.execute("cmd /c \"#{temputf8filename}\"", :failonfail => false)
+      expect(temputf8filename.encoding.name).to eq('UTF-8')
+      expect(result.exitstatus).to eq(100)
+    end
+  end
 end

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

@@ -15,7 +15,15 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
       expect(principal.sid).to eq('S-1-5-18')
       expect(principal.domain).to eq('NT AUTHORITY')
       expect(principal.domain_account).to eq('NT AUTHORITY\\SYSTEM')
-      expect(principal.account_type).to eq(:SidTypeWellKnownGroup)
+
+      # Windows API LookupAccountSid behaves differently if current user is SYSTEM
+      if Puppet::Util::Windows::ADSI::User.current_user_name != 'SYSTEM'
+        account_type = :SidTypeWellKnownGroup
+      else
+        account_type = :SidTypeUser
+      end
+
+      expect(principal.account_type).to eq(account_type)
     end
 
     it "should create an instance from a well-known account prefixed with NT AUTHORITY" do
@@ -25,7 +33,15 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
       expect(principal.sid).to eq('S-1-5-18')
       expect(principal.domain).to eq('NT AUTHORITY')
       expect(principal.domain_account).to eq('NT AUTHORITY\\SYSTEM')
-      expect(principal.account_type).to eq(:SidTypeWellKnownGroup)
+
+      # Windows API LookupAccountSid behaves differently if current user is SYSTEM
+      if Puppet::Util::Windows::ADSI::User.current_user_name != 'SYSTEM'
+        account_type = :SidTypeWellKnownGroup
+      else
+        account_type = :SidTypeUser
+      end
+
+      expect(principal.account_type).to eq(account_type)
     end
 
     it "should create an instance from a local account prefixed with hostname" do
@@ -65,6 +81,25 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
         principal.lookup_account_name('ConanTheBarbarian')
       }.to raise_error(Puppet::Util::Windows::Error, /Failed to call LookupAccountNameW/)
     end
+
+    it "should return a BUILTIN domain principal for empty account names" do
+      principal = Puppet::Util::Windows::SID::Principal.lookup_account_name('')
+      expect(principal.account_type).to eq(:SidTypeDomain)
+      expect(principal.sid).to eq('S-1-5-32')
+      expect(principal.account).to eq('BUILTIN')
+      expect(principal.domain).to eq('BUILTIN')
+      expect(principal.domain_account).to eq('BUILTIN')
+    end
+
+    it "should return a BUILTIN domain principal for BUILTIN account names" do
+      principal = Puppet::Util::Windows::SID::Principal.lookup_account_name('BUILTIN')
+      expect(principal.account_type).to eq(:SidTypeDomain)
+      expect(principal.sid).to eq('S-1-5-32')
+      expect(principal.account).to eq('BUILTIN')
+      expect(principal.domain).to eq('BUILTIN')
+      expect(principal.domain_account).to eq('BUILTIN')
+    end
+
   end
 
   describe ".lookup_account_sid" do
@@ -77,7 +112,6 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
       expect(principal.domain_account).to eq('NT AUTHORITY\\SYSTEM')
 
       # Windows API LookupAccountSid behaves differently if current user is SYSTEM
-      # even though LookupAccountName does not demonstrate same behavior
       if Puppet::Util::Windows::ADSI::User.current_user_name != 'SYSTEM'
         account_type = :SidTypeWellKnownGroup
       else
@@ -97,10 +131,34 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
       expect(principal.account_type).to eq(:SidTypeAlias)
     end
 
-    it "should raise an error when trying to lookup completely invalid SID bytes" do
+    it "should raise an error when trying to lookup nil" do
+      principal = Puppet::Util::Windows::SID::Principal
+      expect {
+        principal.lookup_account_sid(nil)
+      }.to raise_error(Puppet::Util::Windows::Error, /must not be nil/)
+    end
+
+    it "should raise an error when trying to lookup non-byte array" do
+      principal = Puppet::Util::Windows::SID::Principal
+      expect {
+        principal.lookup_account_sid('ConanTheBarbarian')
+      }.to raise_error(Puppet::Util::Windows::Error, /array/)
+    end
+
+    it "should raise an error when trying to lookup an empty array" do
       principal = Puppet::Util::Windows::SID::Principal
       expect {
         principal.lookup_account_sid([])
+      }.to raise_error(Puppet::Util::Windows::Error, /at least 1 byte long/)
+    end
+
+    # https://technet.microsoft.com/en-us/library/cc962011.aspx
+    # "... The structure used in all SIDs created by Windows NT and Windows 2000 is revision level 1. ..."
+    # Therefore a value of zero for the revision, is not a valid SID
+    it "should raise an error when trying to lookup completely invalid SID bytes" do
+      principal = Puppet::Util::Windows::SID::Principal
+      expect {
+        principal.lookup_account_sid([0])
       }.to raise_error(Puppet::Util::Windows::Error, /Failed to call LookupAccountSidW:  The parameter is incorrect/)
     end
 
@@ -111,5 +169,33 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet.features.microsoft
         principal.lookup_account_sid([1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0])
       }.to raise_error(Puppet::Util::Windows::Error, /Failed to call LookupAccountSidW:  No mapping between account names and security IDs was done/)
     end
+
+    it "should return a domain principal for BUILTIN SID S-1-5-32" do
+      principal = Puppet::Util::Windows::SID::Principal.lookup_account_sid([1, 1, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0])
+      expect(principal.account_type).to eq(:SidTypeDomain)
+      expect(principal.sid).to eq('S-1-5-32')
+      expect(principal.account).to eq('BUILTIN')
+      expect(principal.domain).to eq('BUILTIN')
+      expect(principal.domain_account).to eq('BUILTIN')
+    end
+  end
+
+  describe "it should create matching Principal objects" do
+    let(:builtin_sid) { [1, 1, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0] }
+    let(:sid_principal) { Puppet::Util::Windows::SID::Principal.lookup_account_sid(builtin_sid) }
+
+    ['.', 'builtin', ''].each do |name|
+      it "when comparing the one looked up via SID S-1-5-32 to one looked up via non-canonical name #{name} for the BUILTIN domain" do
+        name_principal = Puppet::Util::Windows::SID::Principal.lookup_account_name(name)
+
+        # compares canonical sid
+        expect(sid_principal).to eq(name_principal)
+
+        # compare all properties that have public accessors
+        sid_principal.public_methods(false).reject { |m| m == :== }.each do |method|
+          expect(sid_principal.send(method)).to eq(name_principal.send(method))
+        end
+      end
+    end
   end
 end