puppet 4.1.0 → 4.10.0

data/spec/integration/transaction_spec.rb

@@ -266,6 +266,80 @@ describe Puppet::Transaction do
     expect(Puppet::FileSystem.exist?(newfile)).to be_truthy
   end
 
+  # Ensure when resources have been generated with eval_generate that event
+  # propagation still works when filtering with tags
+  context "when filtering with tags" do
+    context "when resources are dependent on dynamically generated resources" do
+      it "should trigger (only) appropriately tagged dependent resources" do
+        source = dir_containing('sourcedir', {'foo' => 'bar'})
+        target = tmpdir('targetdir')
+        file1 = tmpfile("file1")
+        file2 = tmpfile("file2")
+
+        file = Puppet::Type.type(:file).new(
+          :path    => target,
+          :source  => source,
+          :ensure  => :present,
+          :recurse => true,
+          :tag     => "foo_tag",
+        )
+
+        exec1 = Puppet::Type.type(:exec).new(
+          :path        => ENV["PATH"],
+          :command     => touch(file1),
+          :refreshonly => true,
+          :subscribe   => file,
+          :tag         => "foo_tag",
+        )
+
+        exec2 = Puppet::Type.type(:exec).new(
+          :path        => ENV["PATH"],
+          :command     => touch(file2),
+          :refreshonly => true,
+          :subscribe   => file,
+        )
+
+        Puppet[:tags] = "foo_tag"
+        catalog = mk_catalog(file, exec1, exec2)
+        catalog.apply
+        expect(Puppet::FileSystem.exist?(file1)).to be_truthy
+        expect(Puppet::FileSystem.exist?(file2)).to be_falsey
+      end
+
+      it "should trigger implicitly tagged dependent resources, ie via type name" do
+        file1 = tmpfile("file1")
+        file2 = tmpfile("file2")
+
+        exec1 = Puppet::Type.type(:exec).new(
+          :name        => "exec1",
+          :path        => ENV["PATH"],
+          :command     => touch(file1),
+        )
+
+        exec1.stubs(:eval_generate).returns(
+          [ (Puppet::Type.type(:notify).new :name => "eval1_notify")]
+        )
+
+        exec2 = Puppet::Type.type(:exec).new(
+          :name        => "exec2",
+          :path        => ENV["PATH"],
+          :command     => touch(file2),
+          :refreshonly => true,
+          :subscribe   => exec1,
+        )
+        exec2.stubs(:eval_generate).returns(
+          [ (Puppet::Type.type(:notify).new :name => "eval2_notify")]
+        )
+
+        Puppet[:tags] = "exec"
+        catalog = mk_catalog(exec1, exec2)
+        catalog.apply
+        expect(Puppet::FileSystem.exist?(file1)).to be_truthy
+        expect(Puppet::FileSystem.exist?(file2)).to be_truthy
+      end
+    end
+  end
+
   describe "skipping resources" do
     let(:fname) { tmpfile("exec") }
 
@@ -319,6 +393,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")
@@ -352,10 +437,49 @@ describe Puppet::Transaction do
     )
 
     catalog = mk_catalog(exec, file1, file2)
-    catalog.apply
+    transaction = catalog.apply
 
     expect(Puppet::FileSystem.exist?(file1[:path])).to be_falsey
     expect(Puppet::FileSystem.exist?(file2[:path])).to be_falsey
+
+    expect(transaction.resource_status(file1).skipped).to be_truthy
+    expect(transaction.resource_status(file2).skipped).to be_truthy
+
+    expect(transaction.resource_status(file1).failed_dependencies).to eq([exec])
+    expect(transaction.resource_status(file2).failed_dependencies).to eq([exec])
+  end
+
+  it "on failure, skips dynamically-generated dependents" do
+    exec = Puppet::Type.type(:exec).new(
+      :command => "#{File.expand_path('/bin/mkdir')} /this/path/cannot/possibly/exist",
+      :title => "mkdir"
+    )
+
+    tmp = tmpfile("dir1")
+    FileUtils.mkdir_p(tmp)
+    FileUtils.mkdir_p(File.join(tmp, "foo"))
+
+    purge_dir = Puppet::Type.type(:file).new(
+      :title => "dir1",
+      :path => tmp,
+      :require => exec,
+      :ensure => :directory,
+      :recurse => true,
+      :purge => true
+    )
+
+    catalog = mk_catalog(exec, purge_dir)
+    txn = catalog.apply
+
+    expect(txn.resource_status(purge_dir).skipped).to be_truthy
+
+    children = catalog.relationship_graph.direct_dependents_of(purge_dir)
+
+    children.each do |child|
+      expect(txn.resource_status(child).skipped).to be_truthy
+    end
+
+    expect(Puppet::FileSystem.exist?(File.join(tmp, "foo"))).to be_truthy
   end
 
   it "should not trigger subscribing resources on failure" do

data/spec/integration/type/file_spec.rb

@@ -716,6 +716,42 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       end
     end
 
+    it "should not recursively manage files set to be ignored" do
+      srcdir = tmpfile("ignore_vs_recurse_1")
+      dstdir = tmpfile("ignore_vs_recurse_2")
+
+      FileUtils.mkdir_p(srcdir)
+      FileUtils.mkdir_p(dstdir)
+
+      srcfile = File.join(srcdir, "file.src")
+      cpyfile = File.join(dstdir, "file.src")
+      ignfile = File.join(srcdir, "file.ign")
+
+      File.open(srcfile, "w") { |f| f.puts "don't ignore me" }
+      File.open(ignfile, "w") { |f| f.puts "you better ignore me" }
+
+
+      catalog.add_resource described_class.new(
+                             :name => srcdir,
+                             :ensure => 'directory',
+                             :mode => '0755',)
+
+      catalog.add_resource described_class.new(
+                             :name => dstdir,
+                             :ensure => 'directory',
+                             :mode => "755",
+                             :source => srcdir,
+                             :recurse => true,
+                             :ignore => '*.ign',)
+
+      catalog.apply
+      expect(Puppet::FileSystem.exist?(srcdir)).to be_truthy
+      expect(Puppet::FileSystem.exist?(dstdir)).to be_truthy
+      expect(File.read(srcfile).strip).to eq("don't ignore me")
+      expect(File.read(cpyfile).strip).to eq("don't ignore me")
+      expect(Puppet::FileSystem.exist?("#{dstdir}/file.ign")).to be_falsey
+    end
+
     it "should not recursively manage files managed by a more specific explicit file" do
       dir = tmpfile("recursion_vs_explicit_1")
 
@@ -1190,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
@@ -1224,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
@@ -1260,12 +1393,11 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       describe "when processing SYSTEM ACEs" 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,
-            :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
+            :current_user => Puppet::Util::Windows::ADSI::User.current_user_sid.sid,
+            :system => Puppet::Util::Windows::SID::LocalSystem,
+            :users => Puppet::Util::Windows::SID::BuiltinUsers,
+            :power_users => Puppet::Util::Windows::SID::PowerUsers,
+            :none => Puppet::Util::Windows::SID::Nobody
           }
         end
 
@@ -1282,8 +1414,8 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
           describe "when permissions are not insync?" do
             before :each do
-              @file[:owner] = 'None'
-              @file[:group] = 'None'
+              @file[:owner] = @sids[:none]
+              @file[:group] = @sids[:none]
             end
 
             it "preserves the inherited SYSTEM ACE for an existing file" do
@@ -1370,8 +1502,8 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
           describe "when permissions are not insync?" do
             before :each do
-              @directory[:owner] = 'None'
-              @directory[:group] = 'None'
+              @directory[:owner] = @sids[:none]
+              @directory[:group] = @sids[:none]
             end
 
             it "preserves the inherited SYSTEM ACEs for an existing directory" do
@@ -1593,7 +1725,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         catalog.apply
         expect(Puppet::FileSystem).to be_directory(copy)
       end
-    
+
       it "should copy the link itself if :links => manage" do
         catalog.add_resource described_class.new(
           :name => target,
@@ -1613,7 +1745,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
         expect(Dir.entries(link)).to eq(Dir.entries(copy))
       end
     end
-  
+
     context "and the recurse attribute is true" do
       it "should recursively copy the directory if :links => follow" do
         catalog.add_resource described_class.new(
@@ -1654,4 +1786,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'
@@ -54,6 +58,7 @@ end
 
 describe Puppet::Type.type(:package), "when packages with the same name are sourced" do
   before :each do
+    Process.stubs(:euid).returns 0
     @provider = stub(
       'provider',
       :class           => Puppet::Type.type(:package).defaultprovider,
@@ -125,3 +130,69 @@ describe Puppet::Type.type(:package), "when packages with the same name are sour
   end
 end
 
+describe Puppet::Type.type(:package), 'logging package state transitions' do
+
+  let(:catalog) { Puppet::Resource::Catalog.new }
+  let(:provider) { stub('provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :validate_source => nil) }
+
+  before :each do
+    Process.stubs(:euid).returns 0
+    provider.stubs(:satisfies?).with([:purgeable]).returns(true)
+    provider.class.stubs(:instances).returns([])
+    provider.stubs(:install).returns nil
+    provider.stubs(:uninstall).returns nil
+    provider.stubs(:purge).returns nil
+    Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(provider)
+  end
+
+  after :each do
+    Puppet::Type.type(:package).defaultprovider = nil
+  end
+
+  # Map of old state -> {new state -> change}
+  states = {
+    # 'installed' transitions to 'removed' or 'purged'
+    :installed => {
+      :installed => nil,
+      :absent    => 'removed',
+      :purged    => 'purged'
+    },
+    # 'absent' transitions to 'created' or 'purged'
+    :absent => {
+      :installed => 'created',
+      :absent    => nil,
+      :purged    => 'purged'
+    },
+    # 'purged' transitions to 'created'
+    :purged => {
+      :installed => 'created',
+      :absent    => nil,
+      :purged    => nil
+    }
+  }
+
+  states.each do |old, new_states|
+    describe "#{old} package" do
+
+      before :each do
+        provider.stubs(:properties).returns(:ensure => old)
+      end
+
+      new_states.each do |new, status|
+        it "ensure => #{new} should log #{status ? status : 'nothing'}" do
+          catalog.add_resource(described_class.new(:name => 'yay', :ensure => new))
+          catalog.apply
+
+          logs = catalog.apply.report.logs
+          if status
+            expect(logs.first.source).to eq("/Package[yay]/ensure")
+            expect(logs.first.message).to eq(status)
+          else
+            expect(logs.first).to be_nil
+          end
+        end
+      end
+    end
+  end
+end
+

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/type/user_spec.rb

@@ -8,9 +8,16 @@ describe Puppet::Type.type(:user), '(integration)', :unless => Puppet.features.m
   include PuppetSpec::Compiler
 
   context "when set to purge ssh keys from a file" do
+    # different UTF-8 widths
+    # 1-byte A
+    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+    # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+    let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ𠜎
+
     let(:tempfile) do
       file_containing('user_spec', <<-EOF)
-        # comment
+        # comment #{mixed_utf8}
         ssh-rsa KEY-DATA key-name
         ssh-rsa KEY-DATA key name
         EOF
@@ -22,12 +29,12 @@ describe Puppet::Type.type(:user), '(integration)', :unless => Puppet.features.m
 
     it "should purge authorized ssh keys" do
       apply_compiled_manifest(manifest)
-      expect(File.read(tempfile)).not_to match(/key-name/)
+      expect(File.read(tempfile, :encoding => Encoding::UTF_8)).not_to match(/key-name/)
     end
 
     it "should purge keys with spaces in the comment string" do
       apply_compiled_manifest(manifest)
-      expect(File.read(tempfile)).not_to match(/key name/)
+      expect(File.read(tempfile, :encoding => Encoding::UTF_8)).not_to match(/key name/)
     end
 
     context "with other prefetching resources evaluated first" do
@@ -35,14 +42,14 @@ describe Puppet::Type.type(:user), '(integration)', :unless => Puppet.features.m
 
       it "should purge authorized ssh keys" do
         apply_compiled_manifest(manifest)
-        expect(File.read(tempfile)).not_to match(/key-name/)
+        expect(File.read(tempfile, :encoding => Encoding::UTF_8)).not_to match(/key-name/)
       end
     end
 
     context "with multiple unnamed keys" do
       let(:tempfile) do
         file_containing('user_spec', <<-EOF)
-          # comment
+          # comment #{mixed_utf8}
           ssh-rsa KEY-DATA1
           ssh-rsa KEY-DATA2
           EOF
@@ -50,7 +57,7 @@ describe Puppet::Type.type(:user), '(integration)', :unless => Puppet.features.m
 
       it "should purge authorized ssh keys" do
         apply_compiled_manifest(manifest)
-        expect(File.read(tempfile)).not_to match(/KEY-DATA/)
+        expect(File.read(tempfile, :encoding => Encoding::UTF_8)).not_to match(/KEY-DATA/)
       end
     end
   end