puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/integration/parser/ruby_manifest_spec.rb

@@ -8,12 +8,7 @@ describe "Pure ruby manifests" do
   include PuppetSpec::Files
 
   before do
-    @node = Puppet::Node.new "testnode"
-
-    @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
-    @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
     @test_dir = tmpdir('ruby_manifest_test')
-    Puppet.expects(:deprecation_warning).at_least(1)
   end
 
   after do

data/spec/integration/provider/cron/crontab_spec.rb

@@ -109,6 +109,30 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
     end
 
     describe "with ensure present" do
+
+      context "and no command specified" do
+        it "should work if the resource is already present" do
+          resource = Puppet::Type.type(:cron).new(
+            :name    => 'My daily failure',
+            :special => 'daily',
+            :target  => crontab_user1,
+            :user    => crontab_user1
+          )
+          run_in_catalog(resource)
+          expect_output('crontab_user1')
+        end
+        it "should fail if the resource needs creating" do
+          resource = Puppet::Type.type(:cron).new(
+            :name    => 'Entirely new resource',
+            :special => 'daily',
+            :target  => crontab_user1,
+            :user    => crontab_user1
+          )
+          resource.expects(:err).with(regexp_matches(/no command/))
+          run_in_catalog(resource)
+        end
+      end
+
       it "should do nothing if entry already present" do
         resource = Puppet::Type.type(:cron).new(
           :name    => 'My daily failure',
@@ -121,6 +145,17 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
         expect_output('crontab_user1')
       end
 
+      it "should work correctly when managing 'target' but not 'user'" do
+        resource = Puppet::Type.type(:cron).new(
+          :name    => 'My daily failure',
+          :special => 'daily',
+          :command => '/bin/false',
+          :target  => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('crontab_user1')
+      end
+
       it "should do nothing if a matching entry already present" do
         resource = Puppet::Type.type(:cron).new(
           :name     => 'no_such_named_resource_in_crontab',

data/spec/integration/type/file_spec.rb

@@ -10,7 +10,7 @@ if Puppet.features.microsoft_windows?
   end
 end
 
-describe Puppet::Type.type(:file) do
+describe Puppet::Type.type(:file), :uses_checksums => true do
   include PuppetSpec::Files
 
   let(:catalog) { Puppet::Resource::Catalog.new }
@@ -402,109 +402,111 @@ describe Puppet::Type.type(:file) do
   end
 
   describe "when writing files" do
-    it "should backup files to a filebucket when one is configured" do
-      filebucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
-      file = described_class.new :path => path, :backup => "mybucket", :content => "foo"
-      catalog.add_resource file
-      catalog.add_resource filebucket
+    with_digest_algorithms do
+      it "should backup files to a filebucket when one is configured" do
+        filebucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
+        file = described_class.new :path => path, :backup => "mybucket", :content => "foo"
+        catalog.add_resource file
+        catalog.add_resource filebucket
 
-      File.open(file[:path], "w") { |f| f.write("bar") }
+        File.open(file[:path], "w") { |f| f.write("bar") }
 
-      md5 = Digest::MD5.hexdigest("bar")
+        d = digest(IO.binread(file[:path]))
 
-      catalog.apply
+        catalog.apply
 
-      filebucket.bucket.getfile(md5).should == "bar"
-    end
+        filebucket.bucket.getfile(d).should == "bar"
+      end
 
-    it "should backup files in the local directory when a backup string is provided" do
-      file = described_class.new :path => path, :backup => ".bak", :content => "foo"
-      catalog.add_resource file
+      it "should backup files in the local directory when a backup string is provided" do
+        file = described_class.new :path => path, :backup => ".bak", :content => "foo"
+        catalog.add_resource file
 
-      File.open(file[:path], "w") { |f| f.puts "bar" }
+        File.open(file[:path], "w") { |f| f.puts "bar" }
 
-      catalog.apply
+        catalog.apply
 
-      backup = file[:path] + ".bak"
-      Puppet::FileSystem.exist?(backup).should be_true
-      File.read(backup).should == "bar\n"
-    end
+        backup = file[:path] + ".bak"
+        Puppet::FileSystem.exist?(backup).should be_true
+        File.read(backup).should == "bar\n"
+      end
 
-    it "should fail if no backup can be performed" do
-      dir = tmpdir("backups")
+      it "should fail if no backup can be performed" do
+        dir = tmpdir("backups")
 
-      file = described_class.new :path => File.join(dir, "testfile"), :backup => ".bak", :content => "foo"
-      catalog.add_resource file
+        file = described_class.new :path => File.join(dir, "testfile"), :backup => ".bak", :content => "foo"
+        catalog.add_resource file
 
-      File.open(file[:path], 'w') { |f| f.puts "bar" }
+        File.open(file[:path], 'w') { |f| f.puts "bar" }
 
-      # Create a directory where the backup should be so that writing to it fails
-      Dir.mkdir(File.join(dir, "testfile.bak"))
+        # Create a directory where the backup should be so that writing to it fails
+        Dir.mkdir(File.join(dir, "testfile.bak"))
 
-      Puppet::Util::Log.stubs(:newmessage)
+        Puppet::Util::Log.stubs(:newmessage)
 
-      catalog.apply
+        catalog.apply
 
-      File.read(file[:path]).should == "bar\n"
-    end
+        File.read(file[:path]).should == "bar\n"
+      end
 
-    it "should not backup symlinks", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
-      link = tmpfile("link")
-      dest1 = tmpfile("dest1")
-      dest2 = tmpfile("dest2")
-      bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
-      file = described_class.new :path => link, :target => dest2, :ensure => :link, :backup => "mybucket"
-      catalog.add_resource file
-      catalog.add_resource bucket
+      it "should not backup symlinks", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
+        link = tmpfile("link")
+        dest1 = tmpfile("dest1")
+        dest2 = tmpfile("dest2")
+        bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
+        file = described_class.new :path => link, :target => dest2, :ensure => :link, :backup => "mybucket"
+        catalog.add_resource file
+        catalog.add_resource bucket
 
-      File.open(dest1, "w") { |f| f.puts "whatever" }
-      Puppet::FileSystem.symlink(dest1, link)
+        File.open(dest1, "w") { |f| f.puts "whatever" }
+        Puppet::FileSystem.symlink(dest1, link)
 
-      md5 = Digest::MD5.hexdigest(File.read(file[:path]))
+        d = digest(File.read(file[:path]))
 
-      catalog.apply
+        catalog.apply
 
-      Puppet::FileSystem.readlink(link).should == dest2
-      Puppet::FileSystem.exist?(bucket[:path]).should be_false
-    end
+        Puppet::FileSystem.readlink(link).should == dest2
+        Puppet::FileSystem.exist?(bucket[:path]).should be_false
+      end
 
-    it "should backup directories to the local filesystem by copying the whole directory" do
-      file = described_class.new :path => path, :backup => ".bak", :content => "foo", :force => true
-      catalog.add_resource file
+      it "should backup directories to the local filesystem by copying the whole directory" do
+        file = described_class.new :path => path, :backup => ".bak", :content => "foo", :force => true
+        catalog.add_resource file
 
-      Dir.mkdir(path)
+        Dir.mkdir(path)
 
-      otherfile = File.join(path, "foo")
-      File.open(otherfile, "w") { |f| f.print "yay" }
+        otherfile = File.join(path, "foo")
+        File.open(otherfile, "w") { |f| f.print "yay" }
 
-      catalog.apply
+        catalog.apply
 
-      backup = "#{path}.bak"
-      FileTest.should be_directory(backup)
+        backup = "#{path}.bak"
+        FileTest.should be_directory(backup)
 
-      File.read(File.join(backup, "foo")).should == "yay"
-    end
+        File.read(File.join(backup, "foo")).should == "yay"
+      end
 
-    it "should backup directories to filebuckets by backing up each file separately" do
-      bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
-      file = described_class.new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true
-      catalog.add_resource file
-      catalog.add_resource bucket
+      it "should backup directories to filebuckets by backing up each file separately" do
+        bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
+        file = described_class.new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true
+        catalog.add_resource file
+        catalog.add_resource bucket
 
-      Dir.mkdir(file[:path])
-      foofile = File.join(file[:path], "foo")
-      barfile = File.join(file[:path], "bar")
-      File.open(foofile, "w") { |f| f.print "fooyay" }
-      File.open(barfile, "w") { |f| f.print "baryay" }
+        Dir.mkdir(file[:path])
+        foofile = File.join(file[:path], "foo")
+        barfile = File.join(file[:path], "bar")
+        File.open(foofile, "w") { |f| f.print "fooyay" }
+        File.open(barfile, "w") { |f| f.print "baryay" }
 
 
-      foomd5 = Digest::MD5.hexdigest(File.read(foofile))
-      barmd5 = Digest::MD5.hexdigest(File.read(barfile))
+        food = digest(File.read(foofile))
+        bard = digest(File.read(barfile))
 
-      catalog.apply
+        catalog.apply
 
-      bucket.bucket.getfile(foomd5).should == "fooyay"
-      bucket.bucket.getfile(barmd5).should == "baryay"
+        bucket.bucket.getfile(food).should == "fooyay"
+        bucket.bucket.getfile(bard).should == "baryay"
+      end
     end
   end
 

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

@@ -826,6 +826,23 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
       end.should_not be_nil
     end
 
+    it "allows deny ACEs with inheritance" do
+      # inheritance can only be set on directories
+      dir = tmpdir('denyaces')
+
+      inherit_flags = Puppet::Util::Windows::AccessControlEntry::OBJECT_INHERIT_ACE |
+          Puppet::Util::Windows::AccessControlEntry::CONTAINER_INHERIT_ACE
+
+      sd = winsec.get_security_descriptor(dir)
+      sd.dacl.deny(sids[:guest], Windows::File::FILE_ALL_ACCESS, inherit_flags)
+      winsec.set_security_descriptor(dir, sd)
+
+      sd = winsec.get_security_descriptor(dir)
+      sd.dacl.find do |ace|
+        ace.sid == sids[:guest] && ace.flags != 0
+      end.should_not be_nil
+    end
+
     context "when managing mode" do
       it "removes aces for sids that are neither the owner nor group" do
         # add a guest ace, it's never owner or group

data/spec/lib/matchers/resource.rb

@@ -1,23 +1,55 @@
 module Matchers; module Resource
   extend RSpec::Matchers::DSL
 
-  matcher :have_resource do |expected_resource|
+  matcher :be_resource do |expected_resource|
     @params = {}
 
-    match do |actual_catalog|
-      @mismatch = ""
-      if resource = actual_catalog.resource(expected_resource)
-        matched = true
-        failures = []
-        @params.each do |name, value|
-          if resource[name] != value
+    match do |actual_resource|
+      matched = true
+      failures = []
+
+      if actual_resource.ref != expected_resource
+        matched = false
+        failures << "expected #{expected_resource} but was #{actual_resource.ref}"
+      end
+
+      @params.each do |name, value|
+        case value
+        when RSpec::Matchers::DSL::Matcher
+          if !value.matches?(actual_resource[name])
             matched = false
-            failures << "expected #{name} to be '#{value}' but was '#{resource[name]}'"
+            failures << "expected #{name} to match '#{value.description}' but was '#{actual_resource[name]}'"
+          end
+        else
+          if actual_resource[name] != value
+            matched = false
+            failures << "expected #{name} to be '#{value}' but was '#{actual_resource[name]}'"
           end
         end
-        @mismatch = failures.join("\n")
+      end
+      @mismatch = failures.join("\n")
+
+      matched
+    end
 
-        matched
+    chain :with_parameter do |name, value|
+      @params[name] = value
+    end
+
+    def failure_message_for_should
+      @mismatch
+    end
+  end
+  module_function :be_resource
+
+  matcher :have_resource do |expected_resource|
+    @params = {}
+    @matcher = Matchers::Resource.be_resource(expected_resource)
+
+    match do |actual_catalog|
+      @mismatch = ""
+      if resource = actual_catalog.resource(expected_resource)
+        @matcher.matches?(resource)
       else
         @mismatch = "expected #{@actual.to_dot} to include #{@expected[0]}"
         false
@@ -25,11 +57,11 @@ module Matchers; module Resource
     end
 
     chain :with_parameter do |name, value|
-      @params[name] = value
+      @matcher.with_parameter(name, value)
     end
 
     def failure_message_for_should
-      @mismatch
+      @mismatch.empty? ? @matcher.failure_message_for_should : @mismatch
     end
   end
 end; end

data/spec/lib/puppet_spec/files.rb

@@ -52,6 +52,24 @@ module PuppetSpec::Files
     dir
   end
 
+  def dir_containing(name, contents_hash) PuppetSpec::Files.dir_containing(name, contents_hash) end
+  def self.dir_containing(name, contents_hash)
+    dir_contained_in(tmpdir(name), contents_hash)
+  end
+
+  def self.dir_contained_in(dir, contents_hash)
+    contents_hash.each do |k,v|
+      if v.is_a?(Hash)
+        Dir.mkdir(tmp = File.join(dir,k))
+        dir_contained_in(tmp, v)
+      else
+        file = File.join(dir, k)
+        File.open(file, 'wb') {|f| f.write(v) }
+      end
+    end
+    dir
+  end
+
   def self.record_tmp(tmp)
     # ...record it for cleanup,
     $global_tempfiles ||= []

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -0,0 +1,56 @@
+require 'json'
+
+module PuppetSpec
+  module ModuleTool
+    module SharedFunctions
+      def remote_release(name, version)
+        remote_source.available_releases[name][version]
+      end
+
+      def preinstall(name, version, options = { :into => primary_dir })
+        release = remote_release(name, version)
+        raise "Could not preinstall #{name} v#{version}" if release.nil?
+
+        name = release.name[/-(.*)/, 1]
+        moddir = File.join(options[:into], name)
+        FileUtils.mkdir_p(moddir)
+        File.open(File.join(moddir, 'metadata.json'), 'w') do |file|
+          file.puts(JSON.generate(release.metadata))
+        end
+      end
+
+      def mark_changed(path)
+        app = Puppet::ModuleTool::Applications::Checksummer
+        app.stubs(:run).with(path).returns(['README'])
+      end
+
+      def graph_should_include(name, options)
+        releases = flatten_graph(subject[:graph] || [])
+        release = releases.find { |x| x[:name] == name }
+
+        if options.nil?
+          release.should be_nil
+        else
+          from = options.keys.find { |k| k.nil? || k.is_a?(Semantic::Version) }
+          to   = options.delete(from)
+
+          if to or from
+            options[:previous_version] ||= from
+            options[:version] ||= to
+          end
+
+          release.should_not be_nil
+          release.should include options
+        end
+      end
+
+      def flatten_graph(graph)
+        graph + graph.map { |sub| flatten_graph(sub[:dependencies]) }.flatten
+      end
+
+      def v(str)
+        Semantic::Version.parse(str)
+      end
+    end
+  end
+end

data/spec/lib/puppet_spec/module_tool/stub_source.rb

@@ -0,0 +1,133 @@
+module PuppetSpec
+  module ModuleTool
+    class StubSource < Semantic::Dependency::Source
+      def inspect; "Stub Source"; end
+      def host
+        "http://nowhe.re"
+      end
+
+      def fetch(name)
+        available_releases[name.tr('/', '-')].values
+      end
+
+      def available_releases
+        return @available_releases if defined? @available_releases
+
+        @available_releases = {
+          'puppetlabs-java' => {
+            '10.0.0' => { 'puppetlabs/stdlib' => '4.1.0' },
+          },
+          'puppetlabs-stdlib' => {
+            '4.1.0' => {},
+          },
+          'pmtacceptance-stdlib' => {
+            "4.1.0" => {},
+            "3.2.0" => {},
+            "3.1.0" => {},
+            "3.0.0" => {},
+            "2.6.0" => {},
+            "2.5.1" => {},
+            "2.5.0" => {},
+            "2.4.0" => {},
+            "2.3.2" => {},
+            "2.3.1" => {},
+            "2.3.0" => {},
+            "2.2.1" => {},
+            "2.2.0" => {},
+            "2.1.3" => {},
+            "2.0.0" => {},
+            "1.1.0" => {},
+            "1.0.0" => {},
+          },
+          'pmtacceptance-keystone' => {
+            '3.0.0-rc2' => { "pmtacceptance/mysql" => ">=0.6.1 <1.0.0", "pmtacceptance/stdlib" => ">= 2.5.0" },
+            '3.0.0-rc1' => { "pmtacceptance/mysql" => ">=0.6.1 <1.0.0", "pmtacceptance/stdlib" => ">= 2.5.0" },
+            '2.2.0'     => { "pmtacceptance/mysql" => ">=0.6.1 <1.0.0", "pmtacceptance/stdlib" => ">= 2.5.0" },
+            '2.2.0-rc1' => { "pmtacceptance/mysql" => ">=0.6.1 <1.0.0", "pmtacceptance/stdlib" => ">= 2.5.0" },
+            '2.1.0'     => { "pmtacceptance/mysql" => ">=0.6.1 <1.0.0", "pmtacceptance/stdlib" => ">= 2.5.0" },
+            '2.0.0'     => { "pmtacceptance/mysql" => ">= 0.6.1" },
+            '1.2.0'     => { "pmtacceptance/mysql" => ">= 0.5.0" },
+            '1.1.1'     => { "pmtacceptance/mysql" => ">= 0.5.0" },
+            '1.1.0'     => { "pmtacceptance/mysql" => ">= 0.5.0" },
+            '1.0.1'     => { "pmtacceptance/mysql" => ">= 0.5.0" },
+            '1.0.0'     => { "pmtacceptance/mysql" => ">= 0.5.0" },
+            '0.2.0'     => { "pmtacceptance/mysql" => ">= 0.5.0" },
+            '0.1.0'     => { "pmtacceptance/mysql" => ">= 0.3.0" },
+          },
+          'pmtacceptance-mysql' => {
+            "2.1.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.0-rc5" => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.0-rc4" => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.0-rc3" => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.0-rc2" => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "2.0.0-rc1" => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "1.0.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.9.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.8.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.8.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.7.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.7.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.6.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.6.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.5.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.4.0"     => {},
+            "0.3.0"     => {},
+            "0.2.0"     => {},
+          },
+          'pmtacceptance-apache' => {
+            "0.10.0"    => { "pmtacceptance/stdlib" => ">= 2.4.0" },
+            "0.9.0"     => { "pmtacceptance/stdlib" => ">= 2.4.0" },
+            "0.8.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.8.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.7.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.6.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.5.0-rc1" => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.4.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.3.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.2.2"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.2.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.2.0"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.1.1"     => { "pmtacceptance/stdlib" => ">= 2.2.1" },
+            "0.0.4"     => {},
+            "0.0.3"     => {},
+            "0.0.2"     => {},
+            "0.0.1"     => {},
+          },
+          'pmtacceptance-bacula' => {
+            "0.0.3" => { "pmtacceptance/stdlib" => ">= 2.2.0", "pmtacceptance/mysql" => ">= 1.0.0" },
+            "0.0.2" => { "pmtacceptance/stdlib" => ">= 2.2.0", "pmtacceptance/mysql" => ">= 0.0.1" },
+            "0.0.1" => { "pmtacceptance/stdlib" => ">= 2.2.0" },
+          },
+        }
+
+        @available_releases.each do |name, versions|
+          versions.each do |version, deps|
+            deps, metadata = deps.partition { |k,v| k.is_a? String }
+            dependencies = Hash[deps.map { |k, v| [ k.tr('/', '-'), v ] }]
+
+            versions[version] = create_release(name, version, dependencies).tap do |release|
+              release.meta_def(:prepare)     { }
+              release.meta_def(:install)     { |x| @install_dir = x.to_s }
+              release.meta_def(:install_dir) { @install_dir }
+              release.meta_def(:metadata) do
+                metadata = Hash[metadata].merge(
+                  :name         => name,
+                  :version      => version,
+                  :source       => '',   # GRR, Puppet!
+                  :author       => '',   # GRR, Puppet!
+                  :license      => '',   # GRR, Puppet!
+                  :dependencies => dependencies.map do |dep, range|
+                    { :name => dep, :version_requirement => range }
+                  end
+                )
+                Hash[metadata.map { |k,v| [ k.to_s, v ] }]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end