puppet 3.2.2 → 3.2.3.rc1

data/lib/puppet/type/file/ensure.rb

@@ -7,30 +7,29 @@ module Puppet
 
     desc <<-'EOT'
       Whether to create files that don't currently exist.
-      Possible values are *absent*, *present*, *file*, and *directory*.
+      Possible values are `absent`, `present`, `file`, `directory`, and `link`.
       Specifying `present` will match any form of file existence, and
       if the file is missing will create an empty file. Specifying
-      `absent` will delete the file (or directory, if `recurse => true`).
+      `absent` will delete the file (or directory, if `recurse => true` and
+      `force => true`). Specifying `link` requires that you also set the `target`
+      attribute; note that symlinks cannot be managed on Windows.
 
-      Anything other than the above values will create a symlink; note that
-      symlinks cannot be managed on Windows. In the interest of readability
-      and clarity, symlinks should be created by setting `ensure => link` and
-      explicitly specifying a target; however, if a `target` attribute isn't
-      provided, the value of the `ensure` attribute will be used as the
-      symlink target. The following two declarations are equivalent:
+      If you specify the path to another file as the ensure value, it is
+      equivalent to specifying `link` and using that path as the `target`:
 
-          # (Useful on Solaris)
+          # Equivalent resources:
 
-          # Less maintainable:
           file { "/etc/inetd.conf":
             ensure => "/etc/inet/inetd.conf",
           }
 
-          # More maintainable:
           file { "/etc/inetd.conf":
             ensure => link,
             target => "/etc/inet/inetd.conf",
           }
+
+      However, we recommend using `link` and `target` explicitly, since this
+      behavior can be harder to read.
     EOT
 
     # Most 'ensure' properties have a default, but with files we, um, don't.

data/lib/puppet/util/adsi.rb

@@ -33,16 +33,16 @@ module Puppet::Util::ADSI
       @computer_name
     end
 
-    def computer_uri
-      "WinNT://#{computer_name}"
+    def computer_uri(host = '.')
+      "WinNT://#{host}"
     end
 
     def wmi_resource_uri( host = '.' )
       "winmgmts:{impersonationLevel=impersonate}!//#{host}/root/cimv2"
     end
 
-    def uri(resource_name, resource_type)
-      "#{computer_uri}/#{resource_name},#{resource_type}"
+    def uri(resource_name, resource_type, host = '.')
+      "#{computer_uri(host)}/#{resource_name},#{resource_type}"
     end
 
     def wmi_connection
@@ -54,7 +54,7 @@ module Puppet::Util::ADSI
     end
 
     def sid_for_account(name)
-      Puppet.deprecation_warning "Puppet::Util::ADSI.sid_for_account is deprecated and will be removed in 3.0, use Puppet::Util::Windows::SID.name_to_account instead."
+      Puppet.deprecation_warning "Puppet::Util::ADSI.sid_for_account is deprecated and will be removed in 3.0, use Puppet::Util::Windows::SID.name_to_sid instead."
 
       Puppet::Util::Windows::Security.name_to_sid(name)
     end
@@ -74,8 +74,8 @@ module Puppet::Util::ADSI
       @native_user ||= Puppet::Util::ADSI.connect(uri)
     end
 
-    def self.uri(name)
-      Puppet::Util::ADSI.uri(name, 'user')
+    def self.uri(name, host = '.')
+      Puppet::Util::ADSI.uri(name, 'user', host)
     end
 
     def uri
@@ -175,11 +175,11 @@ module Puppet::Util::ADSI
     end
 
     def self.each(&block)
-      wql = Puppet::Util::ADSI.execquery("select * from win32_useraccount")
+      wql = Puppet::Util::ADSI.execquery("select name from win32_useraccount")
 
       users = []
       wql.each do |u|
-        users << new(u.name, u)
+        users << new(u.name)
       end
 
       users.each(&block)
@@ -216,8 +216,8 @@ module Puppet::Util::ADSI
       self.class.uri(name)
     end
 
-    def self.uri(name)
-      Puppet::Util::ADSI.uri(name, 'group')
+    def self.uri(name, host = '.')
+      Puppet::Util::ADSI.uri(name, 'group', host)
     end
 
     def native_group
@@ -235,14 +235,14 @@ module Puppet::Util::ADSI
 
     def add_members(*names)
       names.each do |name|
-        native_group.Add(Puppet::Util::ADSI::User.uri(name))
+        native_group.Add(Puppet::Util::ADSI::User.uri(name, Puppet::Util::ADSI.computer_name))
       end
     end
     alias add_member add_members
 
     def remove_members(*names)
       names.each do |name|
-        native_group.Remove(Puppet::Util::ADSI::User.uri(name))
+        native_group.Remove(Puppet::Util::ADSI::User.uri(name, Puppet::Util::ADSI.computer_name))
       end
     end
     alias remove_member remove_members
@@ -283,11 +283,11 @@ module Puppet::Util::ADSI
     end
 
     def self.each(&block)
-      wql = Puppet::Util::ADSI.execquery( "select * from win32_group" )
+      wql = Puppet::Util::ADSI.execquery( "select name from win32_group" )
 
       groups = []
       wql.each do |g|
-        groups << new(g.name, g)
+        groups << new(g.name)
       end
 
       groups.each(&block)

data/lib/puppet/util/monkey_patches.rb

@@ -399,12 +399,3 @@ if Puppet::Util::Platform.windows?
   end
 end
 
-# Old puppet clients may make large GET requests, lets be reasonably tolerant
-# in our default WEBrick server.
-require 'webrick'
-if defined?(WEBrick::HTTPRequest::MAX_URI_LENGTH) and WEBrick::HTTPRequest::MAX_URI_LENGTH < 8192
-  # Silence ruby warning: already initialized constant MAX_URI_LENGTH
-  v, $VERBOSE = $VERBOSE, nil
-  WEBrick::HTTPRequest.const_set("MAX_URI_LENGTH", 8192)
-  $VERBOSE = v
-end

data/lib/puppet/util/windows/user.rb

@@ -54,17 +54,18 @@ module Puppet::Util::Windows::User
     fLOGON32_PROVIDER_DEFAULT = 0
 
     logon_user = Win32API.new("advapi32", "LogonUser", ['P', 'P', 'P', 'L', 'L', 'P'], 'L')
-    close_handle = Win32API.new("kernel32", "CloseHandle", ['P'], 'V')
+    close_handle = Win32API.new("kernel32", "CloseHandle", ['L'], 'B')
 
     token = 0.chr * 4
     if logon_user.call(name, ".", password, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, token) == 0
       raise Puppet::Util::Windows::Error.new("Failed to logon user #{name.inspect}")
     end
 
+    token = token.unpack('L')[0]
     begin
-      yield token.unpack('L')[0] if block_given?
+      yield token if block_given?
     ensure
-      close_handle.call(token.unpack('L')[0])
+      close_handle.call(token)
     end
   end
   module_function :logon_user
@@ -88,7 +89,7 @@ module Puppet::Util::Windows::User
       pi = [4 * 8, fPI_NOUI, user, nil, nil, nil, nil, profile].pack('LLPPPPPP')
 
       load_user_profile   = Win32API.new('userenv', 'LoadUserProfile', ['L', 'P'], 'L')
-      unload_user_profile = Win32API.new('userenv', 'UnloadUserProfile', ['L', 'P'], 'L')
+      unload_user_profile = Win32API.new('userenv', 'UnloadUserProfile', ['L', 'L'], 'L')
 
       # Load the profile. Since it doesn't exist, it will be created
       if load_user_profile.call(token, pi) == 0
@@ -97,7 +98,8 @@ module Puppet::Util::Windows::User
 
       Puppet.debug("Loaded profile for #{user}")
 
-      if unload_user_profile.call(token, pi.unpack('LLLLLLLL').last) == 0
+      profile = pi.unpack('LLLLLLLL').last
+      if unload_user_profile.call(token, profile) == 0
         raise Puppet::Util::Windows::Error.new("Failed to unload user profile #{user.inspect}")
       end
     end

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.2.2'
+  PUPPETVERSION = '3.2.3-rc1'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/application/apply_spec.rb

@@ -6,6 +6,10 @@ require 'puppet/application/apply'
 describe "apply" do
   include PuppetSpec::Files
 
+  before :each do
+    Puppet[:reports] = "none"
+  end
+
   describe "when applying provided catalogs" do
     it "should be able to apply catalogs provided in a file in pson" do
       file_to_create = tmpfile("pson_catalog")

data/spec/unit/application/apply_spec.rb

@@ -10,6 +10,7 @@ describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
+    Puppet[:reports] = "none"
   end
 
   after :each do

data/spec/unit/application/facts_spec.rb

@@ -21,7 +21,9 @@ describe Puppet::Application::Facts do
     subject.command_line.stubs(:args).returns %w{find whatever --render-as yaml}
 
     expect {
-      expect { subject.run }.to exit_with 0
+      expect {
+        subject.run
+      }.to exit_with 0
     }.to have_printed(/object:Puppet::Node::Facts/)
 
     @logs.should be_empty

data/spec/unit/configurer_spec.rb

@@ -386,6 +386,7 @@ describe Puppet::Configurer do
       Puppet[:lastrunfile] = tmpfile('last_run_file')
 
       @report = Puppet::Transaction::Report.new("apply")
+      Puppet[:reports] = "none"
     end
 
     it "should print a report summary if configured to do so" do

data/spec/unit/parser/ast/block_expression_spec.rb

@@ -0,0 +1,67 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Parser::AST::BlockExpression do
+  class StackDepthAST < Puppet::Parser::AST
+    attr_reader :call_depth
+    def evaluate(*options)
+      @call_depth = caller.length
+    end
+  end
+
+  NO_SCOPE = nil
+
+  def depth_probe
+    StackDepthAST.new({})
+  end
+
+  def sequence_probe(name, sequence)
+    probe = mock("Sequence Probe #{name}")
+    probe.expects(:safeevaluate).in_sequence(sequence)
+    probe
+  end
+
+  def block_of(children)
+    Puppet::Parser::AST::BlockExpression.new(:children => children)
+  end
+
+  def assert_all_at_same_depth(*probes)
+    depth0 = probes[0].call_depth
+    probes.drop(1).each do |p|
+      p.call_depth.should == depth0
+    end
+  end
+
+  it "evaluates all its children at the same stack depth" do
+    depth_probes = [depth_probe, depth_probe]
+    expr = block_of(depth_probes)
+
+    expr.evaluate(NO_SCOPE)
+
+    assert_all_at_same_depth(*depth_probes)
+  end
+
+  it "evaluates sequenced children at the same stack depth" do
+    depth1 = depth_probe
+    depth2 = depth_probe
+    depth3 = depth_probe
+
+    expr1 = block_of([depth1])
+    expr2 = block_of([depth2])
+    expr3 = block_of([depth3])
+
+    expr1.sequence_with(expr2).sequence_with(expr3).evaluate(NO_SCOPE)
+
+    assert_all_at_same_depth(depth1, depth2, depth3)
+  end
+
+  it "evaluates sequenced children in order" do
+    evaluation_order = sequence("Child evaluation order")
+    expr1 = block_of([sequence_probe("Step 1", evaluation_order)])
+    expr2 = block_of([sequence_probe("Step 2", evaluation_order)])
+    expr3 = block_of([sequence_probe("Step 3", evaluation_order)])
+
+    expr1.sequence_with(expr2).sequence_with(expr3).evaluate(NO_SCOPE)
+  end
+end
+

data/spec/unit/parser/functions/fqdn_rand_spec.rb

@@ -2,62 +2,42 @@
 require 'spec_helper'
 
 describe "the fqdn_rand function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
+  it "provides a random number strictly less than the given max" do
+    fqdn_rand(3).should satisfy {|n| n.to_i < 3 }
   end
 
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-    @scope["fqdn"] = "127.0.0.1"
+  it "provides the same 'random' value on subsequent calls for the same host" do
+    fqdn_rand(3).should eql(fqdn_rand(3))
   end
 
-  it "should exist" do
-    Puppet::Parser::Functions.function("fqdn_rand").should == "function_fqdn_rand"
-  end
-
-  it "should handle 0 arguments" do
-    lambda { @scope.function_fqdn_rand([]) }.should_not raise_error(Puppet::ParseError)
-  end
+  it "considers the same host and same extra arguments to have the same random sequence" do
+    first_random = fqdn_rand(3, :extra_identifier => [1, "same", "host"])
+    second_random = fqdn_rand(3, :extra_identifier => [1, "same", "host"])
 
-  it "should handle 1 argument'}" do
-    lambda { @scope.function_fqdn_rand([3]) }.should_not raise_error(Puppet::ParseError)
+    first_random.should eql(second_random)
   end
 
+  it "allows extra arguments to control the random value on a single host" do
+    first_random = fqdn_rand(10000, :extra_identifier => [1, "different", "host"])
+    second_different_random = fqdn_rand(10000, :extra_identifier => [2, "different", "host"])
 
-  (1..10).each { |n|
-    it "should handle #{n} additional arguments" do
-      lambda { @scope.function_fqdn_rand([3,1,2,3,4,5,6,7,8,9,10][0..n]) }.should_not raise_error(Puppet::ParseError)
-    end
-    it "should handle #{n} additional string arguments" do
-      lambda { @scope.function_fqdn_rand([3,%w{ 1 2 3 4 5 6 7 8 9 10}].flatten[0..n]) }.should_not raise_error(Puppet::ParseError)
-    end
-  }
-
-  it "should return a value less than max" do
-    @scope.function_fqdn_rand([3]).should satisfy {|n| n.to_i < 3 }
-  end
-
-  it "should return the same values on subsequent invocations for the same host" do
-    @scope.function_fqdn_rand([3,4]).should eql(@scope.function_fqdn_rand([3, 4]))
+    first_random.should_not eql(second_different_random)
   end
 
   it "should return different sequences of value for different hosts" do
-    val1 = @scope.function_fqdn_rand([10000000,4])
-    @scope.expects(:[]).with("::fqdn").returns("127.0.0.2")
-    val2 = @scope.function_fqdn_rand([10000000,4])
-    val1.should_not eql(val2)
-  end
+    val1 = fqdn_rand(1000000000, :host => "first.host.com")
+    val2 = fqdn_rand(1000000000, :host => "second.host.com")
 
-  it "should return different values for the same hosts with different seeds" do
-    val1 = @scope.function_fqdn_rand([10000000,4])
-    val2 = @scope.function_fqdn_rand([10000000,42])
     val1.should_not eql(val2)
   end
 
-  it "should use the Puppet::Util function" do
-    Puppet::Util.expects(:deterministic_rand).with(177093203648075535190027737376590689559,4)
-    @scope.function_fqdn_rand([4])
+  def fqdn_rand(max, args = {})
+    host = args[:host] || '127.0.0.1'
+    extra = args[:extra_identifier] || []
+
+    scope = Puppet::Parser::Scope.new_for_test_harness('localhost')
+    scope.stubs(:[]).with("::fqdn").returns(host)
+
+    scope.function_fqdn_rand([max] + extra)
   end
 end

data/spec/unit/parser/functions/sprintf_spec.rb

@@ -32,7 +32,12 @@ describe "the sprintf function" do
 
   it "should format large floats" do
     result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
-    str = Puppet.features.microsoft_windows? ? "+2.72e+016" : "+2.72e+16"
+    str =
+      if Puppet.features.microsoft_windows? && RUBY_VERSION[0,3] == '1.8'
+        "+2.72e+016"
+      else
+        "+2.72e+16"
+      end
     result.should(eql(str))
   end
 

data/spec/unit/pops/parser/rgen_sanitycheck_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/pops'
 
 require 'rgen/array_extensions'
 
-describe "RGen working with hashes" do
+describe "RGen extensions to core classes" do
   it "should be possible to create an empty hash after having required the files above" do
     # If this fails, it means the rgen addition to Array is not monkey patched as it
     # should (it will return an array instead of fail in a method_missing), and thus
@@ -12,4 +12,12 @@ describe "RGen working with hashes" do
     #
     Hash[[]]
   end
+
+  it "should be possible to automatically stringify a nested, empty array during join" do
+    # When this fails it means that rgen has incorrectly implemented
+    # method_missing on array and is returning an array for to_str instead of
+    # failing as is expected allowing stringification to occur
+    [[]].join(":").should == ""
+    ["1", []].join(":").should == "1:"
+  end
 end

data/spec/unit/provider/exec/posix_spec.rb

@@ -7,6 +7,7 @@ describe Puppet::Type.type(:exec).provider(:posix) do
   def make_exe
     cmdpath = tmpdir('cmdpath')
     exepath = tmpfile('my_command', cmdpath)
+    exepath = exepath + ".exe" if Puppet.features.microsoft_windows?
     FileUtils.touch(exepath)
     File.chmod(0755, exepath)
     exepath

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi) do
       names = ['group1', 'group2', 'group3']
       stub_groups = names.map{|n| stub(:name => n)}
 
-      connection.stubs(:execquery).with("select * from win32_group").returns stub_groups
+      connection.stubs(:execquery).with("select name from win32_group").returns stub_groups
 
       described_class.instances.map(&:name).should =~ names
     end

data/spec/unit/provider/package/pip_spec.rb

@@ -192,6 +192,10 @@ describe provider_class do
 
   describe "lazy_pip" do
 
+    after(:each) do
+      Puppet::Type::Package::ProviderPip.instance_variable_set(:@confine_collection, nil)
+    end
+
     it "should succeed if pip is present" do
       @provider.stubs(:pip).returns(nil)
       @provider.method(:lazy_pip).call "freeze"

data/spec/unit/provider/service/redhat_spec.rb

@@ -19,9 +19,10 @@ describe provider_class, :as_platform => :posix do
     @provider.stubs(:get).with(:hasstatus).returns false
     FileTest.stubs(:file?).with('/sbin/service').returns true
     FileTest.stubs(:executable?).with('/sbin/service').returns true
+    Facter.stubs(:value).with(:operatingsystem).returns('CentOS')
   end
 
-  osfamily = [ 'redhat', 'suse' ]
+  osfamily = [ 'RedHat', 'Suse' ]
 
   osfamily.each do |osfamily|
     it "should be the default provider on #{osfamily}" do

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -24,8 +24,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi) do
     it "should enumerate all users" do
       names = ['user1', 'user2', 'user3']
       stub_users = names.map{|n| stub(:name => n)}
-
-      connection.stubs(:execquery).with("select * from win32_useraccount").returns(stub_users)
+      connection.stubs(:execquery).with("select name from win32_useraccount").returns(stub_users)
 
       described_class.instances.map(&:name).should =~ names
     end

data/spec/unit/resource/catalog_spec.rb

@@ -285,10 +285,30 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.resource("notify[one]", nil).must equal(@one)
     end
 
-    it "should not allow two resources with the same resource reference" do
-      @catalog.add_resource(@one)
+    describe 'with a duplicate resource' do
+      def resource_at(type, name, file, line)
+        resource = Puppet::Resource.new(type, name)
+        resource.file = file
+        resource.line = line
+
+        Puppet::Type.type(type).new(resource)
+      end
+
+      let(:orig) { resource_at(:notify, 'duplicate-title', '/path/to/orig/file', 42) }
+      let(:dupe) { resource_at(:notify, 'duplicate-title', '/path/to/dupe/file', 314) }
 
-      proc { @catalog.add_resource(@dupe) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
+      it "should print the locations of the original duplicated resource" do
+        @catalog.add_resource(orig)
+
+        expect { @catalog.add_resource(dupe) }.to raise_error { |error|
+          error.should be_a Puppet::Resource::Catalog::DuplicateResourceError
+
+          error.message.should match %r[Duplicate declaration: Notify\[duplicate-title\] is already declared]
+          error.message.should match %r[in file /path/to/orig/file:42]
+          error.message.should match %r[cannot redeclare]
+          error.message.should match %r[at /path/to/dupe/file:314]
+        }
+      end
     end
 
     it "should not store objects that do not respond to :ref" do

data/spec/unit/resource/type_spec.rb

@@ -715,15 +715,6 @@ describe Puppet::Resource::Type do
       dest.doc.should == "foonessyayness"
     end
 
-    it "should turn its code into a BlockExpression if necessary" do
-      dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => code("foo"))
-      source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
-
-      dest.merge(source)
-
-      dest.code.should be_instance_of(Puppet::Parser::AST::BlockExpression)
-    end
-
     it "should set the other class's code as its code if it has none" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
@@ -734,15 +725,15 @@ describe Puppet::Resource::Type do
     end
 
     it "should append the other class's code to its code if it has any" do
-      dcode = Puppet::Parser::AST::ASTArray.new :children => [code("dest")]
+      dcode = Puppet::Parser::AST::BlockExpression.new(:children => [code("dest")])
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => dcode)
 
-      scode = Puppet::Parser::AST::ASTArray.new :children => [code("source")]
+      scode = Puppet::Parser::AST::BlockExpression.new(:children => [code("source")])
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
 
-      dest.code.children.collect { |l| l[0].value }.should == %w{dest source}
+      dest.code.children.collect { |l| l.value }.should == %w{dest source}
     end
   end
 end

data/spec/unit/type/exec_spec.rb

@@ -42,8 +42,9 @@ describe Puppet::Type.type(:exec) do
   describe "when not stubbing the provider" do
     before do
       path = tmpdir('path')
-      true_cmd = File.join(path, 'true')
-      false_cmd = File.join(path, 'false')
+      ext = Puppet.features.microsoft_windows? ? '.exe' : ''
+      true_cmd = File.join(path, "true#{ext}")
+      false_cmd = File.join(path, "false#{ext}")
 
       FileUtils.touch(true_cmd)
       FileUtils.touch(false_cmd)