puppet 2.7.19 → 2.7.20.rc1

data/spec/unit/indirector/certificate/disabled_ca_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/certificate/disabled_ca'
+
+describe Puppet::SSL::Certificate::DisabledCa do
+  def request(type, remote)
+    r = Puppet::Indirector::Request.new(:certificate, type, "foo.com", nil)
+    if remote
+      r.ip   = '10.0.0.1'
+      r.node = 'agent.example.com'
+    end
+    r
+  end
+
+  context "when not a CA" do
+    before :each do
+      Puppet[:ca] = false
+      Puppet::SSL::Host.ca_location = :none
+    end
+
+    [:find, :head, :search, :save, :destroy].each do |name|
+      it "should fail remote #{name} requests" do
+        expect { subject.send(name, request(name, true)) }.
+          to raise_error Puppet::Error, /is not a CA/
+      end
+
+      it "should forward local #{name} requests" do
+        Puppet::SSL::Certificate.indirection.terminus(:file).expects(name)
+        subject.send(name, request(name, false))
+      end
+    end
+  end
+end

data/spec/unit/indirector/certificate_request/disabled_ca_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/certificate_request/disabled_ca'
+
+describe Puppet::SSL::CertificateRequest::DisabledCa do
+  def request(type, remote)
+    r = Puppet::Indirector::Request.new(:certificate_request, type, "foo.com", nil)
+    if remote
+      r.ip   = '10.0.0.1'
+      r.node = 'agent.example.com'
+    end
+    r
+  end
+
+  context "when not a CA" do
+    before :each do
+      Puppet[:ca] = false
+      Puppet::SSL::Host.ca_location = :none
+    end
+
+    [:find, :head, :search, :save, :destroy].each do |name|
+      it "should fail remote #{name} requests" do
+        expect { subject.send(name, request(name, true)) }.
+          to raise_error Puppet::Error, /is not a CA/
+      end
+
+      it "should forward local #{name} requests" do
+        Puppet::SSL::CertificateRequest.indirection.terminus(:file).expects(name)
+        subject.send(name, request(name, false))
+      end
+    end
+  end
+end

data/spec/unit/indirector/certificate_revocation_list/disabled_ca_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/certificate_revocation_list/disabled_ca'
+
+describe Puppet::SSL::CertificateRevocationList::DisabledCa do
+  def request(type, remote)
+    r = Puppet::Indirector::Request.new(:certificate_revocation_list, type, "foo.com", nil)
+    if remote
+      r.ip   = '10.0.0.1'
+      r.node = 'agent.example.com'
+    end
+    r
+  end
+
+  context "when not a CA" do
+    before :each do
+      Puppet[:ca] = false
+      Puppet::SSL::Host.ca_location = :none
+    end
+
+    [:find, :head, :search, :save, :destroy].each do |name|
+      it "should fail remote #{name} requests" do
+        expect { subject.send(name, request(name, true)) }.
+          to raise_error Puppet::Error, /is not a CA/
+      end
+
+      it "should forward local #{name} requests" do
+        Puppet::SSL::CertificateRevocationList.indirection.terminus(:file).expects(name)
+        subject.send(name, request(name, false))
+      end
+    end
+  end
+end

data/spec/unit/indirector/key/disabled_ca_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/key/disabled_ca'
+
+describe Puppet::SSL::Key::DisabledCa do
+  def request(type, remote)
+    r = Puppet::Indirector::Request.new(:key, type, "foo.com", nil)
+    if remote
+      r.ip   = '10.0.0.1'
+      r.node = 'agent.example.com'
+    end
+    r
+  end
+
+  context "when not a CA" do
+    before :each do
+      Puppet[:ca] = false
+      Puppet::SSL::Host.ca_location = :none
+    end
+
+    [:find, :head, :search, :save, :destroy].each do |name|
+      it "should fail remote #{name} requests" do
+        expect { subject.send(name, request(name, true)) }.
+          to raise_error Puppet::Error, /is not a CA/
+      end
+
+      it "should forward local #{name} requests" do
+        Puppet::SSL::Key.indirection.terminus(:file).expects(name)
+        subject.send(name, request(name, false))
+      end
+    end
+  end
+end

data/spec/unit/indirector/request_spec.rb

@@ -311,4 +311,26 @@ describe Puppet::Indirector::Request do
       lambda { @request.query_string }.should raise_error(ArgumentError)
     end
   end
+
+  describe "#remote?" do
+    def request(options = {})
+      Puppet::Indirector::Request.new('node', 'find', 'localhost', options)
+    end
+
+    it "should not be unless node or ip is set" do
+      request.should_not be_remote
+    end
+
+    it "should be remote if node is set" do
+      request(:node => 'example.com').should be_remote
+    end
+
+    it "should be remote if ip is set" do
+      request(:ip => '127.0.0.1').should be_remote
+    end
+
+    it "should be remote if node and ip are set" do
+      request(:node => 'example.com', :ip => '127.0.0.1').should be_remote
+    end
+  end
 end

data/spec/unit/network/http/webrick_spec.rb

@@ -37,13 +37,6 @@ describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
   end
 
-  it "should order a webrick server to start in a separate thread" do
-    @mock_webrick.expects(:start)
-    # If you remove this you'll sometimes get race condition problems
-    Thread.expects(:new).yields
-    @server.listen(@listen_params)
-  end
-
   it "should tell webrick to listen on the specified address and port" do
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Port] == 31337 and args[:BindAddress] == "127.0.0.1"

data/spec/unit/node/environment_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::Node::Environment do
   end
 
   it "should use the default environment if no name is provided while initializing an environment" do
-    Puppet.settings.expects(:value).with(:environment).returns("one")
+    Puppet[:environment] = "one"
     Puppet::Node::Environment.new.name.should == :one
   end
 
@@ -80,15 +80,15 @@ describe Puppet::Node::Environment do
     end
 
     it "should give to all threads using the same environment the same collection if the collection isn't stale" do
-      original_thread_type_collection = Puppet::Resource::TypeCollection.new(env)
-      Puppet::Resource::TypeCollection.expects(:new).with(env).returns original_thread_type_collection
-      env.known_resource_types.should equal(original_thread_type_collection)
+      @original_thread_type_collection = Puppet::Resource::TypeCollection.new(env)
+      Puppet::Resource::TypeCollection.expects(:new).with(env).returns @original_thread_type_collection
+      env.known_resource_types.should equal(@original_thread_type_collection)
 
-      original_thread_type_collection.expects(:require_reparse?).returns(false)
+      @original_thread_type_collection.expects(:require_reparse?).returns(false)
       Puppet::Resource::TypeCollection.stubs(:new).with(env).returns @collection
 
       t = Thread.new {
-        env.known_resource_types.should equal(original_thread_type_collection)
+        env.known_resource_types.should equal(@original_thread_type_collection)
       }
       t.join
     end
@@ -156,8 +156,8 @@ describe Puppet::Node::Environment do
     end
 
     it "should ask the Puppet settings instance for the setting qualified with the environment name" do
-      Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
-      env["myvar"].should == "myval"
+      Puppet.settings.set_value(:server, "myval", :testing)
+      env[:server].should == "myval"
     end
 
     it "should be able to return an individual module that exists in its module path" do

data/spec/unit/parser/ast_spec.rb

@@ -4,11 +4,6 @@ require 'spec_helper'
 require 'puppet/parser/ast'
 
 describe Puppet::Parser::AST do
-
-  it "should use the file lookup module" do
-    Puppet::Parser::AST.ancestors.should be_include(Puppet::FileCollection::Lookup)
-  end
-
   it "should have a doc accessor" do
     ast = Puppet::Parser::AST.new({})
     ast.should respond_to(:doc)

data/spec/unit/parser/collector_spec.rb

@@ -53,6 +53,7 @@ describe Puppet::Parser::Collector, "when collecting specific virtual resources"
     @scope = mock 'scope'
     @vquery = mock 'vquery'
     @equery = mock 'equery'
+    @compiler = mock 'compiler'
 
     @collector = Puppet::Parser::Collector.new(@scope, "resource_type", @equery, @vquery, :virtual)
   end

data/spec/unit/parser/files_spec.rb

@@ -33,11 +33,11 @@ describe Puppet::Parser::Files do
     end
 
     it "should return the file in the templatedir if it exists" do
-      Puppet.settings.expects(:value).with(:templatedir, nil).returns("/my/templates")
+      Puppet[:templatedir] = "/my/templates"
       Puppet[:modulepath] = "/one:/two"
       File.stubs(:directory?).returns(true)
       FileTest.stubs(:exist?).returns(true)
-      Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
+      Puppet::Parser::Files.find_template("mymod/mytemplate").should == File.join(Puppet[:templatedir], "mymod/mytemplate")
     end
 
     it "should not raise an error if no valid templatedir exists and the template exists in a module" do

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

@@ -6,10 +6,9 @@ describe 'function for dynamically creating resources' do
   include PuppetSpec::Compiler
 
   before :each do
-    @scope = Puppet::Parser::Scope.new
-    @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @topscope = @scope.compiler.topscope
-    @compiler = @scope.compiler
+    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
+    @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+    @topscope = @topscope
     @scope.parent = @topscope
     Puppet::Parser::Functions.function(:create_resources)
   end

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

@@ -39,12 +39,6 @@ describe "the require function" do
     @resource["require"][0].should be_instance_of(Puppet::Resource)
   end
 
-  it "should verify the 'include' function is loaded" do
-    Puppet::Parser::Functions.expects(:function).with(:include).returns(:function_include)
-    @scope.stubs(:function_include)
-    @scope.function_require("myclass")
-  end
-
   it "should include the class but not add a dependency if used on a client not at least version 0.25" do
     @resource.expects(:metaparam_compatibility_mode?).returns true
     @scope.expects(:warning)

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

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the shellquote function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
@@ -14,7 +10,6 @@ describe "the shellquote function" do
     Puppet::Parser::Functions.function("shellquote").should == "function_shellquote"
   end
 
-
   it "should handle no arguments" do
     result = @scope.function_shellquote([])
     result.should(eql(""))

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

@@ -7,7 +7,12 @@ describe "the template function", :'fails_on_ruby_1.9.2' => true do
   end
 
   before :each do
-    @scope = Puppet::Parser::Scope.new
+    node = stub 'node'
+    node.stubs(:name).returns 'test_node'
+    node.stubs(:classes).returns []
+    env = Puppet::Node::Environment.new('production')
+    node.stubs(:environment).returns env
+    @scope = Puppet::Parser::Scope.new(:compiler => Puppet::Parser::Compiler.new(node))
   end
 
   it "should exist" do

data/spec/unit/parser/functions_spec.rb

@@ -3,22 +3,6 @@ require 'spec_helper'
 
 describe Puppet::Parser::Functions do
 
-  after(:each) do
-    # Rationale:
-    # our various tests will almost all register to Pupet::Parser::Functions
-    # a new function called "name". All tests are required to stub Puppet::Parser::Scope
-    # so that +no+ new real ruby method are defined.
-    # After each test, we want to leave the whole Puppet::Parser::Functions environment
-    # as it was before we were called, hence we call rmfunction (which might not succeed
-    # if the function hasn't been registered in the test). It is also important in this
-    # section to stub +remove_method+ here so that we don't pollute the scope.
-    Puppet::Parser::Scope.stubs(:remove_method)
-    begin
-      Puppet::Parser::Functions.rmfunction("name")
-    rescue
-    end
-  end
-
   it "should have a method for returning an environment-specific module" do
     Puppet::Parser::Functions.environment_module("myenv").should be_instance_of(Module)
   end
@@ -39,13 +23,6 @@ describe Puppet::Parser::Functions do
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
     end
 
-    it "should raise an error if the function already exists" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }.once
-      Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
-
-      lambda { Puppet::Parser::Functions.newfunction("name", :type => :rvalue) }.should raise_error
-    end
-
     it "should raise an error if the function type is not correct" do
       @module.expects(:define_method).with { |name,block| name == "function_name" }.never
 
@@ -98,4 +75,77 @@ describe Puppet::Parser::Functions do
       Puppet::Parser::Functions.function("name")
     end
   end
+
+  describe "::get_function" do
+    it "can retrieve a function defined on the *root* environment" do
+      Thread.current[:environment] = nil
+      function = Puppet::Parser::Functions.newfunction("atest", :type => :rvalue) do
+        nil
+      end
+
+      Puppet::Node::Environment.current = "test_env"
+      Puppet::Parser::Functions.send(:get_function, "atest").should equal(function)
+    end
+
+    it "can retrieve a function from the current environment" do
+      Puppet::Node::Environment.current = "test_env"
+      function = Puppet::Parser::Functions.newfunction("atest", :type => :rvalue) do
+        nil
+      end
+
+      Puppet::Parser::Functions.send(:get_function, "atest").should equal(function)
+    end
+
+    it "takes a function in the current environment over one in the root" do
+      root = Puppet::Node::Environment.root
+      env = Puppet::Node::Environment.current = "test_env"
+      func1 = {:type => :rvalue, :name => :testfunc, :extra => :func1}
+      func2 = {:type => :rvalue, :name => :testfunc, :extra => :func2}
+      Puppet::Parser::Functions.instance_eval do
+        @functions[Puppet::Node::Environment.root][:atest] = func1
+        @functions[Puppet::Node::Environment.current][:atest] = func2
+      end
+
+      Puppet::Parser::Functions.send(:get_function, "atest").should equal(func2)
+    end
+  end
+
+  describe "::merged_functions" do
+    it "returns functions in both the current and root environment" do
+      Thread.current[:environment] = nil
+      func_a = Puppet::Parser::Functions.newfunction("test_a", :type => :rvalue) do
+        nil
+      end
+      Puppet::Node::Environment.current = "test_env"
+      func_b = Puppet::Parser::Functions.newfunction("test_b", :type => :rvalue) do
+        nil
+      end
+
+      Puppet::Parser::Functions.send(:merged_functions).should include(:test_a, :test_b)
+    end
+
+    it "returns functions from the current environment over the root environment" do
+      root = Puppet::Node::Environment.root
+      env = Puppet::Node::Environment.current = "test_env"
+      func1 = {:type => :rvalue, :name => :testfunc, :extra => :func1}
+      func2 = {:type => :rvalue, :name => :testfunc, :extra => :func2}
+      Puppet::Parser::Functions.instance_eval do
+        @functions[Puppet::Node::Environment.root][:atest] = func1
+        @functions[Puppet::Node::Environment.current][:atest] = func2
+      end
+
+      Puppet::Parser::Functions.send(:merged_functions)[:atest].should equal(func2)
+    end
+  end
+
+  describe "::add_function" do
+    it "adds functions to the current environment" do
+      func = {:type => :rvalue, :name => :testfunc}
+      Puppet::Node::Environment.current = "add_function_test"
+      Puppet::Parser::Functions.send(:add_function, :testfunc, func)
+
+      Puppet::Parser::Functions.instance_variable_get(:@functions)[Puppet::Node::Environment.root].should_not include(:testfunc)
+      Puppet::Parser::Functions.instance_variable_get(:@functions)[Puppet::Node::Environment.current].should include(:testfunc)
+    end
+  end
 end

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 }
@@ -37,6 +44,18 @@ describe Puppet::Parser::Lexer do
 
       @lexer.line.should == 13
     end
+
+    {
+      'r'  => "\r",
+      'n'  => "\n",
+      't'  => "\t",
+      's'  => " "
+    }.each do |esc, expected_result|
+      it "should recognize \\#{esc} sequence" do
+        @lexer.string = "\\#{esc}'"
+        @lexer.slurpstring("'")[0].should == expected_result
+      end
+    end
   end
 end
 
@@ -406,7 +425,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.
@@ -423,7 +443,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
@@ -434,20 +460,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
@@ -457,6 +581,7 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
+    %q{'single quoted string with an escaped "\r\n"'}               => [[:STRING,'single quoted string with an escaped "\r\n"']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],