puppet 3.0.1 → 3.0.2.rc1

data/spec/unit/parser/lexer_spec.rb

@@ -11,6 +11,13 @@ RSpec::Matchers.define :be_like do |*expected|
 end
 __ = nil
 
+def tokens_scanned_from(s)
+  lexer = Puppet::Parser::Lexer.new
+  lexer.string = s
+  lexer.fullscan[0..-2]
+end
+
+
 describe Puppet::Parser::Lexer do
   describe "when reading strings" do
     before { @lexer = Puppet::Parser::Lexer.new }
@@ -419,7 +426,8 @@ describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
   end
 end
 
-shared_examples_for "variable names in the lexer" do |prefix|
+
+shared_examples_for "handling `-` in standard variable names" do |prefix|
   # Watch out - a regex might match a *prefix* on these, not just the whole
   # word, so make sure you don't have false positive or negative results based
   # on that.
@@ -436,7 +444,13 @@ shared_examples_for "variable names in the lexer" do |prefix|
 
     illegal.each do |name|
       var = prefix + global_scope + name
-      it "should NOT accept #{var.inspect} as a valid variable name" do
+      it "when `variable_with_dash` is disabled it should NOT accept #{var.inspect} as a valid variable name" do
+        Puppet[:allow_variables_with_dashes] = false
+        (subject.regex.match(var) || [])[0].should_not == var
+      end
+
+      it "when `variable_with_dash` is enabled it should NOT accept #{var.inspect} as a valid variable name" do
+        Puppet[:allow_variables_with_dashes] = true
         (subject.regex.match(var) || [])[0].should_not == var
       end
     end
@@ -447,20 +461,118 @@ describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
   its(:skip_text) { should be_false }
   its(:incr_line) { should be_false }
 
-  it_should_behave_like "variable names in the lexer", '$'
+  it_should_behave_like "handling `-` in standard variable names", '$'
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:VARIABLE] do
   its(:skip_text) { should be_false }
   its(:incr_line) { should be_false }
 
-  it_should_behave_like "variable names in the lexer", ''
+  it_should_behave_like "handling `-` in standard variable names", ''
 end
 
-def tokens_scanned_from(s)
-  lexer = Puppet::Parser::Lexer.new
-  lexer.string = s
-  lexer.fullscan[0..-2]
+describe "the horrible deprecation / compatibility variables with dashes" do
+  NamesWithDashes = %w{f- f-o -f f::-o f::o- f::o-o}
+
+  { Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR_WITH_DASH] => '$',
+    Puppet::Parser::Lexer::TOKENS[:VARIABLE_WITH_DASH]   => ''
+  }.each do |token, prefix|
+    describe token do
+      its(:skip_text) { should be_false }
+      its(:incr_line) { should be_false }
+
+      context "when compatibly is disabled" do
+        before :each do Puppet[:allow_variables_with_dashes] = false end
+        Puppet::Parser::Lexer::TOKENS.each do |name, value|
+          it "should be unacceptable after #{name}" do
+            token.acceptable?(:after => name).should be_false
+          end
+        end
+
+        # Yes, this should still *match*, just not be acceptable.
+        NamesWithDashes.each do |name|
+          ["", "::"].each do |global_scope|
+            var = prefix + global_scope + name
+            it "should match #{var.inspect}" do
+              subject.regex.match(var).to_a.should == [var]
+            end
+          end
+        end
+      end
+
+      context "when compatibility is enabled" do
+        before :each do Puppet[:allow_variables_with_dashes] = true end
+        it "should be acceptable after DQPRE" do
+          token.acceptable?(:after => :DQPRE).should be_true
+        end
+
+        NamesWithDashes.each do |name|
+          ["", "::"].each do |global_scope|
+            var = prefix + global_scope + name
+            it "should match #{var.inspect}" do
+              subject.regex.match(var).to_a.should == [var]
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context "deprecation warnings" do
+    before :each do Puppet[:allow_variables_with_dashes] = true end
+
+    it "should match a top level variable" do
+      Puppet.expects(:deprecation_warning).once
+
+      tokens_scanned_from('$foo-bar').should == [
+        [:VARIABLE, { :value => 'foo-bar', :line => 1 }]
+      ]
+    end
+
+    it "does not warn about a variable without a dash" do
+      Puppet.expects(:deprecation_warning).never
+
+      tokens_scanned_from('$c').should == [
+        [:VARIABLE, { :value => "c", :line => 1 }]
+      ]
+    end
+
+    it "does not warn about referencing a class name that contains a dash" do
+      Puppet.expects(:deprecation_warning).never
+
+      tokens_scanned_from('foo-bar').should == [
+        [:NAME, { :value => "foo-bar", :line => 1 }]
+      ]
+    end
+
+    it "warns about reference to variable" do
+      Puppet.expects(:deprecation_warning).once
+
+      tokens_scanned_from('$::foo-bar::baz-quux').should == [
+        [:VARIABLE, { :value => "::foo-bar::baz-quux", :line => 1 }]
+      ]
+    end
+
+    it "warns about reference to variable interpolated in a string" do
+      Puppet.expects(:deprecation_warning).once
+
+      tokens_scanned_from('"$::foo-bar::baz-quux"').should == [
+        [:DQPRE,    { :value => "",                    :line => 1 }],
+        [:VARIABLE, { :value => "::foo-bar::baz-quux", :line => 1 }],
+        [:DQPOST,   { :value => "",                    :line => 1 }],
+      ]
+    end
+
+    it "warns about reference to variable interpolated in a string as an expression" do
+      Puppet.expects(:deprecation_warning).once
+
+      tokens_scanned_from('"${::foo-bar::baz-quux}"').should == [
+        [:DQPRE,    { :value => "",                    :line => 1 }],
+        [:VARIABLE, { :value => "::foo-bar::baz-quux", :line => 1 }],
+        [:DQPOST,   { :value => "",                    :line => 1 }],
+      ]
+    end
+  end
 end
 
 describe Puppet::Parser::Lexer,"when lexing strings" do

data/spec/unit/parser/relationship_spec.rb

@@ -7,6 +7,8 @@ describe Puppet::Parser::Relationship do
   before do
     @source = Puppet::Resource.new(:mytype, "source")
     @target = Puppet::Resource.new(:mytype, "target")
+    @extra_resource  = Puppet::Resource.new(:mytype, "extra")
+    @extra_resource2 = Puppet::Resource.new(:mytype, "extra2")
     @dep = Puppet::Parser::Relationship.new(@source, @target, :relationship)
   end
 
@@ -15,6 +17,8 @@ describe Puppet::Parser::Relationship do
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource(@source)
       @catalog.add_resource(@target)
+      @catalog.add_resource(@extra_resource)
+      @catalog.add_resource(@extra_resource2)
     end
 
     it "should fail if the source resource cannot be found" do
@@ -44,10 +48,30 @@ describe Puppet::Parser::Relationship do
     it "should supplement rather than clobber existing relationship values" do
       @source[:before] = "File[/bar]"
       @dep.evaluate(@catalog)
+      # this test did not work before. It was appending the resources
+      # together as a string
+      (@source[:before].class == Array).should be_true
       @source[:before].should be_include("Mytype[target]")
       @source[:before].should be_include("File[/bar]")
     end
 
+    it "should supplement rather than clobber existing resource relationships" do
+      @source[:before] = @extra_resource
+      @dep.evaluate(@catalog)
+      (@source[:before].class == Array).should be_true
+      @source[:before].should be_include("Mytype[target]")
+      @source[:before].should be_include(@extra_resource)
+    end
+
+    it "should supplement rather than clobber multiple existing resource relationships" do
+      @source[:before] = [@extra_resource, @extra_resource2]
+      @dep.evaluate(@catalog)
+      (@source[:before].class == Array).should be_true
+      @source[:before].should be_include("Mytype[target]")
+      @source[:before].should be_include(@extra_resource)
+      @source[:before].should be_include(@extra_resource2)
+    end
+
     it "should use the collected retargets if the target is a Collector" do
       orig_target = @target
       @target = Puppet::Parser::Collector.new(stub("scope"), :file, "equery", "vquery", :virtual)

data/spec/unit/provider/file/windows_spec.rb

@@ -14,6 +14,8 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
   let(:path) { tmpfile('windows_file_spec') }
   let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0777, :provider => described_class.name }
   let(:provider) { resource.provider }
+  let(:sid)      { 'S-1-1-50' }
+  let(:account)  { 'quinn' }
 
   describe "#mode" do
     it "should return a string with the higher-order bits stripped away" do
@@ -47,47 +49,41 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#id2name" do
     it "should return the name of the user identified by the sid" do
-      result = [stub('user', :name => 'quinn')]
-      Puppet::Util::ADSI.stubs(:execquery).returns(result)
+      Puppet::Util::Windows::Security.expects(:valid_sid?).with(sid).returns(true)
+      Puppet::Util::Windows::Security.expects(:sid_to_name).with(sid).returns(account)
 
-      provider.id2name('S-1-1-50').should == 'quinn'
+      provider.id2name(sid).should == account
     end
 
     it "should return the argument if it's already a name" do
-      provider.id2name('flannigan').should == 'flannigan'
+      Puppet::Util::Windows::Security.expects(:valid_sid?).with(account).returns(false)
+      Puppet::Util::Windows::Security.expects(:sid_to_name).never
+
+      provider.id2name(account).should == account
     end
 
     it "should return nil if the user doesn't exist" do
-      Puppet::Util::ADSI.stubs(:execquery).returns []
+      Puppet::Util::Windows::Security.expects(:valid_sid?).with(sid).returns(true)
+      Puppet::Util::Windows::Security.expects(:sid_to_name).with(sid).returns(nil)
 
-      provider.id2name('S-1-1-50').should == nil
+      provider.id2name(sid).should == nil
     end
   end
 
   describe "#name2id" do
-    it "should return the sid of the user" do
-      Puppet::Util::ADSI.stubs(:execquery).returns [stub('account', :Sid => 'S-1-1-50')]
-
-      provider.name2id('anybody').should == 'S-1-1-50'
-    end
-
-    it "should return the argument if it's already a sid" do
-      provider.name2id('S-1-1-50').should == 'S-1-1-50'
-    end
-
-    it "should return nil if the user doesn't exist" do
-      Puppet::Util::ADSI.stubs(:execquery).returns []
+    it "should delegate to name_to_sid" do
+      Puppet::Util::Windows::Security.expects(:name_to_sid).with(account).returns(sid)
 
-      provider.name2id('someone').should == nil
+      provider.name2id(account).should == sid
     end
   end
 
   describe "#owner" do
     it "should return the sid of the owner if the file does exist" do
       FileUtils.touch(resource[:path])
-      provider.stubs(:get_owner).with(resource[:path]).returns('S-1-1-50')
+      provider.stubs(:get_owner).with(resource[:path]).returns(sid)
 
-      provider.owner.should == 'S-1-1-50'
+      provider.owner.should == sid
     end
 
     it "should return absent if the file doesn't exist" do
@@ -97,23 +93,25 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#owner=" do
     it "should set the owner to the specified value" do
-      provider.expects(:set_owner).with('S-1-1-50', resource[:path])
-      provider.owner = 'S-1-1-50'
+      provider.expects(:set_owner).with(sid, resource[:path])
+      provider.owner = sid
     end
 
     it "should propagate any errors encountered when setting the owner" do
       provider.stubs(:set_owner).raises(ArgumentError)
 
-      expect { provider.owner = 'S-1-1-50' }.to raise_error(Puppet::Error, /Failed to set owner/)
+      expect {
+        provider.owner = sid
+      }.to raise_error(Puppet::Error, /Failed to set owner/)
     end
   end
 
   describe "#group" do
     it "should return the sid of the group if the file does exist" do
       FileUtils.touch(resource[:path])
-      provider.stubs(:get_group).with(resource[:path]).returns('S-1-1-50')
+      provider.stubs(:get_group).with(resource[:path]).returns(sid)
 
-      provider.group.should == 'S-1-1-50'
+      provider.group.should == sid
     end
 
     it "should return absent if the file doesn't exist" do
@@ -123,14 +121,16 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#group=" do
     it "should set the group to the specified value" do
-      provider.expects(:set_group).with('S-1-1-50', resource[:path])
-      provider.group = 'S-1-1-50'
+      provider.expects(:set_group).with(sid, resource[:path])
+      provider.group = sid
     end
 
     it "should propagate any errors encountered when setting the group" do
       provider.stubs(:set_group).raises(ArgumentError)
 
-      expect { provider.group = 'S-1-1-50' }.to raise_error(Puppet::Error, /Failed to set group/)
+      expect {
+        provider.group = sid
+      }.to raise_error(Puppet::Error, /Failed to set group/)
     end
   end
 

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

@@ -88,8 +88,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi) do
     provider.delete
   end
 
-  it "should report the group's SID as gid" do
-    Puppet::Util::ADSI.expects(:sid_for_account).with('testers').returns('S-1-5-32-547')
+  it "should report the group's SID as gid", :if => Puppet.features.microsoft_windows? do
+    Puppet::Util::Windows::Security.expects(:name_to_sid).with('testers').returns('S-1-5-32-547')
     provider.gid.should == 'S-1-5-32-547'
   end
 

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 # We use this as a reasonable way to obtain all the support infrastructure.
-[:user, :group].each do |type_for_this_round|
+[:group].each do |type_for_this_round|
   provider_class = Puppet::Type.type(type_for_this_round).provider(:directoryservice)
 
   describe provider_class do

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

@@ -178,13 +178,13 @@ describe provider do
 
     it "should execute dpkg --set-selections when holding" do
       @provider.stubs(:install)
-      @provider.expects(:execute).with([:dpkg, '--set-selections'], {:stdinfile => @tempfile.path}).once
+      @provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => @tempfile.path}).once
       @provider.hold
     end
 
     it "should execute dpkg --set-selections when unholding" do
       @provider.stubs(:install)
-      @provider.expects(:execute).with([:dpkg, '--set-selections'], {:stdinfile => @tempfile.path}).once
+      @provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => @tempfile.path}).once
       @provider.hold
     end
   end

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

@@ -86,6 +86,7 @@ describe provider_class do
     let :infoargs do
       ["/opt/local/bin/port", "-q", :info, "--line", "--version", "--revision",  resource_name]
     end
+    let(:arguments) do {:failonfail => false, :combine => false} end
 
     before :each do
       provider.stubs(:command).with(:port).returns("/opt/local/bin/port")
@@ -93,28 +94,28 @@ describe provider_class do
 
     it "should return nil when the package cannot be found" do
       resource[:name] = resource_name
-      provider.expects(:execute).with(infoargs, {:combine=>false}).returns("")
+      provider.expects(:execute).with(infoargs, arguments).returns("")
       provider.latest.should == nil
     end
 
     it "should return the current version if the installed port has the same revision" do
       current_hash[:revision] = "2"
-      provider.expects(:execute).with(infoargs, {:combine=>false}).returns(new_info_line)
+      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
       provider.expects(:query).returns(current_hash)
       provider.latest.should == current_hash[:ensure]
     end
 
     it "should return the new version_revision if the installed port has a lower revision" do
       current_hash[:revision] = "1"
-      provider.expects(:execute).with(infoargs, {:combine=>false}).returns(new_info_line)
+      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
       provider.expects(:query).returns(current_hash)
       provider.latest.should == "1.2.3_2"
     end
 
     it "should return the newest version if the port is not installed" do
       resource[:name] = resource_name
-      provider.expects(:execute).with(infoargs, {:combine=>false}).returns(new_info_line)
-      provider.expects(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], {:combine=>false}).returns("")
+      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
+      provider.expects(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).returns("")
       provider.latest.should == "1.2.3_2"
     end
   end

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

@@ -8,7 +8,7 @@ describe Puppet::Type.type(:package).provider(:msi) do
   let (:packagecode) { '{5A6FD560-763A-4BC1-9E03-B18DFFB7C72C}' }
   let (:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :msi, :source => source) }
   let (:provider)    { resource.provider }
-  let (:execute_options) do {:combine => true} end
+  let (:execute_options) do {:failonfail => false, :combine => true} end
 
   def installer(productcodes)
     installer = mock

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

@@ -5,7 +5,7 @@ require 'stringio'
 provider = Puppet::Type.type(:package).provider(:pacman)
 
 describe provider do
-  let(:no_extra_options) { { :custom_environment => {} } }
+  let(:no_extra_options) { { :failonfail => true, :combine => true, :custom_environment => {} } }
   let(:executor) { Puppet::Util::Execution }
   let(:resolver) { Puppet::Util }
 

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

@@ -16,7 +16,7 @@ describe provider_class do
 
   describe "self.instances" do
     it "returns an array of packages" do
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:custom_environment => {}}).returns("RPM version 5.x")
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:failonfail => true, :combine => true, :custom_environment => {}}).returns("RPM version 5.x")
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
       subject.stubs(:which).with("rpm").returns("/bin/rpm")
       Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n'").yields(packages)

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

@@ -35,7 +35,7 @@ describe Puppet::Type.type(:package).provider(:sun) do
     end
 
     it "should install a package if it is not present on update" do
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false}).returns File.read(my_fixture('dummy.server'))
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false, :combine => false}).returns File.read(my_fixture('dummy.server'))
       provider.expects(:pkgrm).with(['-n', 'dummy'])
       provider.expects(:install)
       provider.update
@@ -74,7 +74,7 @@ describe Puppet::Type.type(:package).provider(:sun) do
 
   context '#query' do
     it "should find the package on query" do
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false}).returns File.read(my_fixture('dummy.server'))
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false, :combine => false}).returns File.read(my_fixture('dummy.server'))
       provider.query.should == {
         :name     => 'SUNWdummy',
         :category=>"system",
@@ -87,12 +87,12 @@ describe Puppet::Type.type(:package).provider(:sun) do
     end
 
     it "shouldn't find the package on query if it is not present" do
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false}).returns 'ERROR: information for "dummy" not found.'
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false, :combine => false}).returns 'ERROR: information for "dummy" not found.'
       provider.query.should == {:ensure => :absent}
     end
 
     it "unknown message should raise error." do
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false}).returns 'RANDOM'
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/pkginfo', '-l', 'dummy'], {:failonfail => false, :combine => false}).returns 'RANDOM'
       lambda { provider.query }.should raise_error(Puppet::Error)
     end
   end