puppet 2.7.11 → 2.7.12

data/spec/integration/defaults_spec.rb

@@ -309,4 +309,14 @@ describe "Puppet defaults" do
       end
     end
   end
+
+  describe "diff" do
+    it "should default to 'diff' on POSIX", :unless => Puppet.features.microsoft_windows? do
+      Puppet.settings[:diff].should == 'diff'
+    end
+
+    it "should default to '' on Windows", :if => Puppet.features.microsoft_windows? do
+      Puppet.settings[:diff].should == ''
+    end
+  end
 end

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -22,7 +22,7 @@ describe Puppet::Indirector::DirectFileServer, " when interacting with the files
   it "should return an instance capable of returning its content" do
     FileTest.expects(:exists?).with(@filepath).returns(true)
     File.stubs(:lstat).with(@filepath).returns(stub("stat", :ftype => "file"))
-    Puppet::Util.expects(:binread).with(@filepath).returns("my content")
+    IO.expects(:binread).with(@filepath).returns("my content")
 
     instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}"))
 

data/spec/integration/module_tool_spec.rb

@@ -8,7 +8,7 @@ def stub_repository_read(code, body)
   kind = Net::HTTPResponse.send(:response_class, code.to_s)
   response = kind.new('1.0', code.to_s, 'HTTP MESSAGE')
   response.stubs(:read_body).returns(body)
-  Puppet::Module::Tool::Repository.any_instance.stubs(:read_response).returns(response)
+  Puppet::Forge::Repository.any_instance.stubs(:read_response).returns(response)
 end
 
 def stub_installer_read(body)
@@ -16,7 +16,7 @@ def stub_installer_read(body)
 end
 
 def stub_cache_read(body)
-  Puppet::Module::Tool::Cache.any_instance.stubs(:read_retrieve).returns(body)
+  Puppet::Forge::Cache.any_instance.stubs(:read_retrieve).returns(body)
 end
 
 # Return path to temparory directory for testing.
@@ -98,11 +98,11 @@ describe "module_tool", :fails_on_windows => true do
 
   before :each do
     Puppet.settings.stubs(:parse)
-    Puppet::Module::Tool::Cache.clean
+    Puppet::Forge::Cache.clean
   end
 
   after :each do
-    Puppet::Module::Tool::Cache.clean
+    Puppet::Forge::Cache.clean
   end
 
   describe "generate" do
@@ -376,9 +376,8 @@ describe "module_tool", :fails_on_windows => true do
         stub_cache_read File.read("#{@full_module_name}/pkg/#{@release_name}.tar.gz")
         FileUtils.rm_rf(@full_module_name)
 
-        stub_installer_read <<-HERE
-          {"file": "/foo/bar/#{@release_name}.tar.gz", "version": "#{@version}"}
-        HERE
+        release = {"file" => "/foo/bar/#{@release_name}.tar.gz", "version" => "#{@version}"}
+        Puppet::Forge::Forge.any_instance.stubs(:get_release).returns(release)
 
         Puppet::Module::Tool::Applications::Installer.run(@full_module_name, @options)
 
@@ -426,9 +425,8 @@ describe "module_tool", :fails_on_windows => true do
         stub_cache_read File.read("#{@full_module_name}/pkg/#{@release_name}.tar.gz")
         FileUtils.rm_rf(@full_module_name)
 
-        stub_installer_read <<-HERE
-          {"file": "/foo/bar/#{@release_name}.tar.gz", "version": "#{@version}"}
-        HERE
+        release = {"file" => "/foo/bar/#{@release_name}.tar.gz", "version" => "#{@version}"}
+        Puppet::Forge::Forge.any_instance.stubs(:get_release).returns(release)
 
         Puppet::Module::Tool::Applications::Installer.run(@full_module_name, @options).should be_kind_of(Pathname)
       end
@@ -441,9 +439,9 @@ describe "module_tool", :fails_on_windows => true do
     it "should clean cache" do
       run do
         build_and_install_module
-        Puppet::Module::Tool::Cache.base_path.directory?.should == true
+        Puppet::Forge::Cache.base_path.directory?.should == true
         Puppet::Module::Tool::Applications::Cleaner.run
-        Puppet::Module::Tool::Cache.base_path.directory?.should == false
+        Puppet::Forge::Cache.base_path.directory?.should == false
       end
     end
 

data/spec/integration/parser/compiler_spec.rb

@@ -131,4 +131,151 @@ describe Puppet::Parser::Compiler do
 
     lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
   end
+
+  describe "when defining relationships" do
+    def extract_name(ref)
+      ref.sub(/File\[(\w+)\]/, '\1')
+    end
+
+    let(:node) { Puppet::Node.new('mynode') }
+    let(:code) do
+      <<-MANIFEST
+        file { [a,b,c]:
+          mode => 0644,
+        }
+        file { [d,e]:
+          mode => 0755,
+        }
+      MANIFEST
+    end
+    let(:expected_relationships) { [] }
+    let(:expected_subscriptions) { [] }
+
+    before :each do
+      Puppet[:code] = code
+    end
+
+    after :each do
+      catalog = described_class.compile(node)
+
+      resources = catalog.resources.select { |res| res.type == 'File' }
+
+      actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
+        resources.map do |res|
+          dependents = Array(res[relation])
+          dependents.map { |ref| [res.title, extract_name(ref)] }
+        end.inject(&:concat)
+      end
+
+      actual_relationships.should =~ expected_relationships
+      actual_subscriptions.should =~ expected_subscriptions
+    end
+
+    it "should create a relationship" do
+      code << "File[a] -> File[b]"
+
+      expected_relationships << ['a','b']
+    end
+
+    it "should create a subscription" do
+      code << "File[a] ~> File[b]"
+
+      expected_subscriptions << ['a', 'b']
+    end
+
+    it "should create relationships using title arrays" do
+      code << "File[a,b] -> File[c,d]"
+
+      expected_relationships.concat [
+        ['a', 'c'],
+        ['b', 'c'],
+        ['a', 'd'],
+        ['b', 'd'],
+      ]
+    end
+
+    it "should create relationships using collection expressions" do
+      code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
+
+      expected_relationships.concat [
+        ['a', 'd'],
+        ['b', 'd'],
+        ['c', 'd'],
+        ['a', 'e'],
+        ['b', 'e'],
+        ['c', 'e'],
+      ]
+    end
+
+    it "should create relationships using resource names" do
+      code << "'File[a]' -> 'File[b]'"
+
+      expected_relationships << ['a', 'b']
+    end
+
+    it "should create relationships using variables" do
+      code << <<-MANIFEST
+        $var = File[a]
+        $var -> File[b]
+      MANIFEST
+
+      expected_relationships << ['a', 'b']
+    end
+
+    it "should create relationships using case statements" do
+      code << <<-MANIFEST
+        $var = 10
+        case $var {
+          10: {
+            file { s1: }
+          }
+          12: {
+            file { s2: }
+          }
+        }
+        ->
+        case $var + 2 {
+          10: {
+            file { t1: }
+          }
+          12: {
+            file { t2: }
+          }
+        }
+      MANIFEST
+
+      expected_relationships << ['s1', 't2']
+    end
+
+    it "should create relationships using array members" do
+      code << <<-MANIFEST
+        $var = [ [ [ File[a], File[b] ] ] ]
+        $var[0][0][0] -> $var[0][0][1]
+      MANIFEST
+
+      expected_relationships << ['a', 'b']
+    end
+
+    it "should create relationships using hash members" do
+      code << <<-MANIFEST
+        $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
+        $var[foo][bar][source] -> $var[foo][bar][target]
+      MANIFEST
+
+      expected_relationships << ['a', 'b']
+    end
+
+    it "should create relationships using resource declarations" do
+      code << "file { l: } -> file { r: }"
+
+      expected_relationships << ['l', 'r']
+    end
+
+    it "should chain relationships" do
+      code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
+
+      expected_relationships << ['a', 'b'] << ['d', 'c']
+      expected_subscriptions << ['b', 'c'] << ['e', 'd']
+    end
+  end
 end

data/spec/integration/type/file_spec.rb

@@ -360,7 +360,7 @@ describe Puppet::Type.type(:file) do
 
       File.open(file[:path], "wb") { |f| f.puts "bar" }
 
-      md5 = Digest::MD5.hexdigest(Puppet::Util.binread(file[:path]))
+      md5 = Digest::MD5.hexdigest(IO.binread(file[:path]))
 
       catalog.apply
 

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

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby -- rspec
+
+require 'spec_helper'
+
+describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows? do
+  describe "2003 without UAC" do
+    before :each do
+      Facter.stubs(:value).with(:kernelmajversion).returns("5.2")
+    end
+
+    it "should be an admin if user's token contains the Administrators SID" do
+      Puppet::Util::Windows::User.expects(:check_token_membership).returns(true)
+      Win32::Security.expects(:elevated_security?).never
+
+      Puppet::Util::Windows::User.should be_admin
+    end
+
+    it "should not be an admin if user's token doesn't contain the Administrators SID" do
+      Puppet::Util::Windows::User.expects(:check_token_membership).returns(false)
+      Win32::Security.expects(:elevated_security?).never
+
+      Puppet::Util::Windows::User.should_not be_admin
+    end
+
+    it "should raise an exception if we can't check token membership" do
+      Puppet::Util::Windows::User.expects(:check_token_membership).raises(Win32::Security::Error, "Access denied.")
+      Win32::Security.expects(:elevated_security?).never
+
+      lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Win32::Security::Error, /Access denied./)
+    end
+  end
+
+  describe "2008 with UAC" do
+    before :each do
+      Facter.stubs(:value).with(:kernelmajversion).returns("6.0")
+    end
+
+    it "should be an admin if user is running with elevated privileges" do
+      Win32::Security.stubs(:elevated_security?).returns(true)
+      Puppet::Util::Windows::User.expects(:check_token_membership).never
+
+      Puppet::Util::Windows::User.should be_admin
+    end
+
+    it "should not be an admin if user is not running with elevated privileges" do
+      Win32::Security.stubs(:elevated_security?).returns(false)
+      Puppet::Util::Windows::User.expects(:check_token_membership).never
+
+      Puppet::Util::Windows::User.should_not be_admin
+    end
+
+    it "should raise an exception if the process fails to open the process token" do
+      Win32::Security.stubs(:elevated_security?).raises(Win32::Security::Error, "Access denied.")
+      Puppet::Util::Windows::User.expects(:check_token_membership).never
+
+      lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Win32::Security::Error, /Access denied./)
+    end
+  end
+end

data/spec/lib/puppet/face/basetest.rb

@@ -43,4 +43,9 @@ Puppet::Face.define(:basetest, '0.0.1') do
     summary "return the count of arguments given"
     when_invoked do |*args| args.length - 1 end
   end
+
+  action :with_specific_exit_code do
+    summary "just call exit with the desired exit code"
+    when_invoked do |options| exit(5) end
+  end
 end

data/spec/lib/puppet_spec/modules.rb

@@ -0,0 +1,26 @@
+module PuppetSpec::Modules
+  class << self
+    def create(name, dir, options = {})
+      module_dir = File.join(dir, name)
+      FileUtils.mkdir_p(module_dir)
+
+      environment = Puppet::Node::Environment.new(options[:environment])
+
+      if metadata = options[:metadata]
+        metadata[:source]  ||= 'github'
+        metadata[:author]  ||= 'puppetlabs'
+        metadata[:version] ||= '9.9.9'
+        metadata[:license] ||= 'to kill'
+        metadata[:dependencies] ||= []
+
+        metadata[:name] = "#{metadata[:author]}/#{name}"
+
+        File.open(File.join(module_dir, 'metadata.json'), 'w') do |f|
+          f.write(metadata.to_pson)
+        end
+      end
+
+      Puppet::Module.new(name, :environment => environment, :path => module_dir)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -34,6 +34,9 @@ RSpec.configure do |config|
   config.mock_with :mocha
 
   config.before :each do
+    # Disabling garbage collection inside each test, and only running it at
+    # the end of each block, gives us an ~ 15 percent speedup, and more on
+    # some platforms *cough* windows *cough* that are a little slower.
     GC.disable
 
     # We need to preserve the current state of all our indirection cache and
@@ -67,6 +70,17 @@ RSpec.configure do |config|
     # I suck for letting this float. --daniel 2011-04-21
     Signal.stubs(:trap)
 
+    # Longer keys are secure, but they sure make for some slow testing - both
+    # in terms of generating keys, and in terms of anything the next step down
+    # the line doing validation or whatever.  Most tests don't care how long
+    # or secure it is, just that it exists, so these are better and faster
+    # defaults, in testing only.
+    #
+    # I would make these even shorter, but OpenSSL doesn't support anything
+    # below 512 bits.  Sad, really, because a 0 bit key would be just fine.
+    Puppet[:req_bits]  = 512
+    Puppet[:keylength] = 512
+
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
     Puppet[:confdir] = "/dev/null"
@@ -102,6 +116,17 @@ RSpec.configure do |config|
     end
     $saved_indirection_state = nil
 
+    # Some tests can cause us to connect, in which case the lingering
+    # connection is a resource that can cause unexpected failure in later
+    # tests, as well as sharing state accidentally.
+    # We're testing if ActiveRecord::Base is defined because some test cases
+    # may stub Puppet.features.rails? which is how we should normally
+    # introspect for this functionality.
+    ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+
+    # This will perform a GC between tests, but only if actually required.  We
+    # experimented with forcing a GC run, and that was less efficient than
+    # just letting it run all the time.
     GC.enable
   end
 end

data/spec/unit/agent/locker_spec.rb

@@ -29,6 +29,18 @@ describe Puppet::Agent::Locker do
     @locker.lockfile.should equal(@locker.lockfile)
   end
 
+  it "should use the lock file to anonymously lock the process when disabled" do
+    @locker.lockfile.expects(:lock).with(:anonymous => true)
+
+    @locker.disable
+  end
+
+  it "should use the lock file to anonymously unlock the process when enabled" do
+    @locker.lockfile.expects(:unlock).with(:anonymous => true)
+
+    @locker.enable
+  end
+
   it "should have a method that yields when a lock is attained" do
     @locker.lockfile.expects(:lock).returns true
 

data/spec/unit/agent_backward_compatibility_spec.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/agent'
+
+
+############################################################################
+#                                  NOTE                                    #
+############################################################################
+#                                                                          #
+# This entire spec is only here for backwards compatibility from 2.7.12+   #
+# with 2.7.10 and 2.7.11. The entire file should be able to be removed     #
+# for the 3.x series.                                                      #
+#                                                                          #
+# For more info, see the comments on the #handle_2_7_10_disabled_lockfile  #
+# method in pidlock.rb                                                     #
+#                                                                          #
+# --cprice 2012-03-01                                                      #
+############################################################################
+
+class AgentTestClient
+  def run
+    # no-op
+  end
+  def stop
+    # no-op
+  end
+end
+
+describe Puppet::Agent do
+  include PuppetSpec::Files
+
+  let(:agent) { Puppet::Agent.new(AgentTestClient) }
+
+  describe "in order to be backwards-compatibility with versions 2.7.10 and 2.7.11" do
+
+    describe "when the 2.7.10/2.7.11 'disabled' lockfile exists" do
+
+      # the "normal" lockfile
+      let(:lockfile_path) { tmpfile("agent_spec_lockfile") }
+
+      # the 2.7.10/2.7.11 "disabled" lockfile
+      # (can't use PuppetSpec::Files.tmpfile here because we need the ".disabled" file to have *exactly* the same
+      #   path/name as the original file, plus the ".disabled" suffix.)
+      let(:disabled_lockfile_path) { lockfile_path + ".disabled" }
+
+      # some regexes to match log messages
+      let(:warning_regex) { /^Found special lockfile '#{disabled_lockfile_path}'.*renaming/ }
+      let(:disabled_regex) { /^Skipping run of .*; administratively disabled/ }
+
+      before(:each) do
+        # create the 2.7.10 "disable" lockfile.
+        FileUtils.touch(disabled_lockfile_path)
+
+        # stub in our temp lockfile path.
+        AgentTestClient.expects(:lockfile_path).returns lockfile_path
+      end
+
+      after(:each) do
+        # manually clean up the files that we didn't create via PuppetSpec::Files.tmpfile
+        begin
+          File.unlink(disabled_lockfile_path)
+        rescue Errno::ENOENT
+          # some of the tests expect for the agent code to take care of deleting this file,
+          # so it may (validly) not exist.
+        end
+      end
+
+      describe "when the 'regular' lockfile also exists" do
+        # the logic here is that if a 'regular' lockfile already exists, then there is some state that the
+        # current version of puppet is responsible for dealing with.  All of the tests in this block are
+        # simply here to make sure that our backwards-compatibility hack does *not* interfere with this.
+        #
+        # Even if the ".disabled" lockfile exists--it can be dealt with at another time, when puppet is
+        # in *exactly* the state that we want it to be in (mostly meaning that the 'regular' lockfile
+        # does not exist.)
+
+        before(:each) do
+          # create the "regular" lockfile
+          FileUtils.touch(lockfile_path)
+        end
+
+        it "should be recognized as 'disabled'" do
+          agent.should be_disabled
+        end
+
+        it "should not try to start a new agent run" do
+          AgentTestClient.expects(:new).never
+          Puppet.expects(:notice).with(regexp_matches(disabled_regex))
+
+          agent.run
+        end
+
+        it "should not delete the 2.7.10/2.7.11 lockfile" do
+          agent.run
+
+          File.exists?(disabled_lockfile_path).should == true
+        end
+
+        it "should not print the warning message" do
+          Puppet.expects(:warning).with(regexp_matches(warning_regex)).never
+
+          agent.run
+        end
+      end
+
+      describe "when the 'regular' lockfile does not exist" do
+        # this block of tests is for actually testing the backwards compatibility hack.  This
+        # is where we're in a clean state and we know it's safe(r) to muck with the lockfile
+        # situation.
+
+        it "should recognize that the agent is disabled" do
+          agent.should be_disabled
+        end
+
+        describe "when an agent run is requested" do
+          it "should not try to start a new agent run" do
+            AgentTestClient.expects(:new).never
+            Puppet.expects(:notice).with(regexp_matches(disabled_regex))
+
+            agent.run
+          end
+
+          it "should warn, remove the 2.7.10/2.7.11 lockfile, and create the 'normal' lockfile" do
+            Puppet.expects(:warning).with(regexp_matches(warning_regex))
+
+            agent.run
+
+            File.exists?(disabled_lockfile_path).should == false
+            File.exists?(lockfile_path).should == true
+          end
+        end
+
+        describe "when running --enable" do
+          it "should recognize that the agent is disabled" do
+            agent.should be_disabled
+          end
+
+          it "should warn and clean up the 2.7.10/2.7.11 lockfile" do
+            Puppet.expects(:warning).with(regexp_matches(warning_regex))
+
+            agent.enable
+
+            File.exists?(disabled_lockfile_path).should == false
+            File.exists?(lockfile_path).should == false
+          end
+        end
+      end
+    end
+  end
+
+
+end