puppet 3.4.3 → 3.5.0.rc1

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

@@ -0,0 +1,88 @@
+
+require 'spec_helper'
+
+describe "the epp function" do
+  include PuppetSpec::Files
+
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  let :node     do Puppet::Node.new('localhost') end
+  let :compiler do Puppet::Parser::Compiler.new(node) end
+  let :scope    do Puppet::Parser::Scope.new(compiler) end
+
+  context "when accessing scope variables as $ variables" do
+    it "looks up the value from the scope" do
+      scope["what"] = "are belong"
+      eval_template("all your base <%= $what %> to us").should == "all your base are belong to us"
+    end
+
+    it "get nil accessing a variable that does not exist" do
+      eval_template("<%= $kryptonite == undef %>").should == "true"
+    end
+
+    it "get nil accessing a variable that is undef" do
+      scope['undef_var'] = :undef
+      eval_template("<%= $undef_var == undef %>").should == "true"
+    end
+
+    it "gets shadowed variable if args are given" do
+      scope['phantom'] = 'of the opera'
+      eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos').should == "true"
+    end
+
+    it "gets shadowed variable if args are given and parameters are specified" do
+      scope['x'] = 'wrong one'
+      eval_template_with_args("<%-( $x )-%><%= $x == correct %>", 'x' => 'correct').should == "true"
+    end
+
+    it "raises an error if required variable is not given" do
+      scope['x'] = 'wrong one'
+      expect {
+        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
+      }.to raise_error(/no value given for required parameters x/)
+    end
+
+    it "raises an error if too many arguments are given" do
+      scope['x'] = 'wrong one'
+      expect {
+        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
+      }.to raise_error(/Too many arguments: 2 for 1/)
+    end
+  end
+
+  # although never a problem with epp
+  it "is not interfered with by having a variable named 'string' (#14093)" do
+    scope['string'] = "this output should not be seen"
+    eval_template("some text that is static").should == "some text that is static"
+  end
+
+  it "has access to a variable named 'string' (#14093)" do
+    scope['string'] = "the string value"
+    eval_template("string was: <%= $string %>").should == "string was: the string value"
+  end
+
+
+  def eval_template_with_args(content, args_hash)
+    file_path = tmpdir('epp_spec_content')
+    filename = File.join(file_path, "template.epp")
+    File.open(filename, "w+") { |f| f.write(content) }
+
+    Puppet::Parser::Files.stubs(:find_template).returns(filename)
+    scope.function_epp(['template', args_hash])
+  end
+
+  def eval_template(content)
+    file_path = tmpdir('epp_spec_content')
+    filename = File.join(file_path, "template.epp")
+    File.open(filename, "w+") { |f| f.write(content) }
+
+    Puppet::Parser::Files.stubs(:find_template).returns(filename)
+    scope.function_epp(['template'])
+  end
+end

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

@@ -1,7 +1,10 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/scope'
 
 describe "the fqdn_rand function" do
+  include PuppetSpec::Scope
+  
   it "provides a random number strictly less than the given max" do
     fqdn_rand(3).should satisfy {|n| n.to_i < 3 }
   end
@@ -35,7 +38,7 @@ describe "the fqdn_rand function" do
     host = args[:host] || '127.0.0.1'
     extra = args[:extra_identifier] || []
 
-    scope = Puppet::Parser::Scope.new_for_test_harness('localhost')
+    scope = create_test_scope_for_node('localhost')
     scope.stubs(:[]).with("::fqdn").returns(host)
 
     scope.function_fqdn_rand([max] + extra)

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

@@ -106,6 +106,10 @@ describe "the generate function" do
     cmd
   end
 
+  after :each do
+    File.delete(command) if Puppet::FileSystem.exist?(command)
+  end
+
   it "should call generator with no arguments" do
     scope.function_generate([command]).should == "a- b-\n"
   end
@@ -119,10 +123,10 @@ describe "the generate function" do
   end
 
   it "should fail if generator is not absolute" do
-    expect { scope.function_generate(['boo']) }.to raise_error Puppet::ParseError
+    expect { scope.function_generate(['boo']) }.to raise_error(Puppet::ParseError)
   end
 
   it "should fail if generator fails" do
-    expect { scope.function_generate(['/boo']) }.to raise_error Puppet::ParseError
+    expect { scope.function_generate(['/boo']) }.to raise_error(Puppet::ParseError)
   end
 end

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

@@ -1,11 +1,14 @@
 require 'spec_helper'
+require 'puppet_spec/scope'
 
 describe 'Puppet::Parser::Functions#hiera_array' do
+  include PuppetSpec::Scope
+
   before :each do
     Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
   end
 
-  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+  let :scope do create_test_scope_for_node('foo') end
 
   it 'should require a key argument' do
     expect { scope.function_hiera_array([]) }.to raise_error(ArgumentError)
@@ -17,7 +20,7 @@ describe 'Puppet::Parser::Functions#hiera_array' do
   end
 
   it 'should use the array resolution_type' do
-    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :array }.returns([])
+    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be(:array) }.returns([])
     scope.function_hiera_array(['key'])
   end
 end

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

@@ -1,7 +1,10 @@
 require 'spec_helper'
+require 'puppet_spec/scope'
 
 describe 'Puppet::Parser::Functions#hiera_hash' do
-  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+  include PuppetSpec::Scope
+
+  let :scope do create_test_scope_for_node('foo') end
 
   it 'should require a key argument' do
     expect { scope.function_hiera_hash([]) }.to raise_error(ArgumentError)

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

@@ -1,7 +1,10 @@
 require 'spec_helper'
+require 'puppet_spec/scope'
 
 describe 'Puppet::Parser::Functions#hiera_include' do
-  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+  include PuppetSpec::Scope
+
+  let :scope do create_test_scope_for_node('foo') end
 
   before :each do
     Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
@@ -18,8 +21,8 @@ describe 'Puppet::Parser::Functions#hiera_include' do
   end
 
   it 'should use the array resolution_type' do
-    HieraPuppet.expects(:lookup).with() { |*args| args[4].should be :array }.returns(['someclass'])
-    expect { scope.function_hiera_include(['key']) }.to raise_error Puppet::Error, /Could not find class someclass/
+    HieraPuppet.expects(:lookup).with() { |*args| args[4].should be(:array) }.returns(['someclass'])
+    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::Error, /Could not find class someclass/)
   end
 
   it 'should call the `include` function with the classes' do

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

@@ -1,7 +1,10 @@
 require 'spec_helper'
+require 'puppet_spec/scope'
 
 describe 'Puppet::Parser::Functions#hiera' do
-  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+  include PuppetSpec::Scope
+
+  let :scope do create_test_scope_for_node('foo') end
 
   it 'should require a key argument' do
     expect { scope.function_hiera([]) }.to raise_error(ArgumentError)
@@ -13,7 +16,7 @@ describe 'Puppet::Parser::Functions#hiera' do
   end
 
   it 'should use the priority resolution_type' do
-    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :priority }.returns('foo_result')
+    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be(:priority) }.returns('foo_result')
     scope.function_hiera(['key']).should == 'foo_result'
   end
 end

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

@@ -7,7 +7,6 @@ describe "the 'include' function" do
   end
 
   before :each do
-    Puppet::Node::Environment.stubs(:current).returns(nil)
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     @scope = Puppet::Parser::Scope.new(@compiler)
   end

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

@@ -0,0 +1,82 @@
+
+require 'spec_helper'
+
+describe "the inline_epp function" do
+  include PuppetSpec::Files
+
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  let :node     do Puppet::Node.new('localhost') end
+  let :compiler do Puppet::Parser::Compiler.new(node) end
+  let :scope    do Puppet::Parser::Scope.new(compiler) end
+
+  context "when accessing scope variables as $ variables" do
+    it "looks up the value from the scope" do
+      scope["what"] = "are belong"
+      eval_template("all your base <%= $what %> to us").should == "all your base are belong to us"
+    end
+
+    it "get nil accessing a variable that does not exist" do
+      eval_template("<%= $kryptonite == undef %>").should == "true"
+    end
+
+    it "get nil accessing a variable that is undef" do
+      scope['undef_var'] = :undef
+      eval_template("<%= $undef_var == undef %>").should == "true"
+    end
+
+    it "gets shadowed variable if args are given" do
+      scope['phantom'] = 'of the opera'
+      eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos').should == "true"
+    end
+
+    it "gets shadowed variable if args are given and parameters are specified" do
+      scope['x'] = 'wrong one'
+      eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct').should == "true"
+    end
+
+    it "raises an error if required variable is not given" do
+      scope['x'] = 'wrong one'
+      expect {
+        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
+      }.to raise_error(/no value given for required parameters x/)
+    end
+
+    it "raises an error if too many arguments are given" do
+      scope['x'] = 'wrong one'
+      expect {
+        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
+      }.to raise_error(/Too many arguments: 2 for 1/)
+    end
+  end
+
+  it "renders a block expression" do
+    eval_template_with_args("<%= {($x) $x + 1} %>", 'x' => 2).should == "3"
+  end
+
+  # although never a problem with epp
+  it "is not interfered with by having a variable named 'string' (#14093)" do
+    scope['string'] = "this output should not be seen"
+    eval_template("some text that is static").should == "some text that is static"
+  end
+
+  it "has access to a variable named 'string' (#14093)" do
+    scope['string'] = "the string value"
+    eval_template("string was: <%= $string %>").should == "string was: the string value"
+  end
+
+
+  def eval_template_with_args(content, args_hash)
+    scope.function_inline_epp([content, args_hash])
+  end
+
+  def eval_template(content)
+    scope.function_inline_epp([content])
+  end
+end

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

@@ -1,8 +1,11 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'stringio'
+require 'puppet_spec/scope'
 
 describe "lookup function" do
+  include PuppetSpec::Scope
+
   before(:each) do
     Puppet[:binder] = true
   end
@@ -17,19 +20,56 @@ describe "lookup function" do
 
   it "looks up a value that exists" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-
     expect(scope.function_lookup(['a_value'])).to eq('something')
   end
 
-  it "returns :undef when the requested value is not bound" do
+  it "searches for first found if given several names" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect(scope.function_lookup([['b_value', 'a_value', 'c_value']])).to eq('something')
+  end
 
-    expect(scope.function_lookup(['not_bound_value'])).to eq(:undef)
+  it "override wins over bound" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    options = {:override => { 'a_value' => 'something_overridden' }}
+    expect(scope.function_lookup(['a_value', options])).to eq('something_overridden')
   end
 
-  it "raises an error when the bound type is not assignable to the requested type" do
+  it "extra option is used if nothing is found" do
+    scope = scope_with_injections_from(bound(bind_single("another_value", "something")))
+    options = {:extra => { 'a_value' => 'something_extra' }}
+    expect(scope.function_lookup(['a_value', options])).to eq('something_extra')
+  end
+
+  it "hiera is called to lookup if value is not bound" do
+    Puppet::Parser::Scope.any_instance.stubs(:function_hiera).returns('from_hiera')
+    scope = scope_with_injections_from(bound(bind_single("another_value", "something")))
+    expect(scope.function_lookup(['a_value'])).to eq('from_hiera')
+  end
+
+  it "returns :undef when the requested value is not bound and undef is accepted" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect(scope.function_lookup(['not_bound_value',{'accept_undef' => true}])).to eq(:undef)
+  end
+
+  it "fails if the requested value is not bound and undef is not allowed" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect do
+      scope.function_lookup(['not_bound_value'])
+    end.to raise_error(/did not find a value for the name 'not_bound_value'/)
+  end
+
+  it "returns the given default value when the requested value is not bound" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect(scope.function_lookup(['not_bound_value','String', 'cigar'])).to eq('cigar')
+  end
+
+  it "accepts values given in a hash of options" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect(scope.function_lookup(['not_bound_value',{'type' => 'String', 'default' => 'cigar'}])).to eq('cigar')
+  end
 
+  it "raises an error when the bound type is not assignable to the requested type" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
     expect do
       scope.function_lookup(['a_value', 'Integer'])
     end.to raise_error(ArgumentError, /incompatible type, expected: Integer, got: String/)
@@ -39,33 +79,46 @@ describe "lookup function" do
     typed_bindings = bindings
     typed_bindings.bind().string().name("a_value").to("something")
     scope = scope_with_injections_from(bound(typed_bindings))
-
     expect(scope.function_lookup(['a_value', 'Data'])).to eq("something")
   end
 
   it "yields to a given lambda and returns the result" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-
     expect(scope.function_lookup(['a_value', ast_lambda('|$x|{something_else}')])).to eq('something_else')
   end
 
-  it "yields to a given lambda and returns the result when giving name and type" do
+  it "fails if given lambda produces undef" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect do
+      scope.function_lookup(['a_value', ast_lambda('|$x|{undef}')])
+    end.to raise_error(/did not find a value for the name 'a_value'/)
+  end
 
+  it "yields name and result to a given lambda" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect(scope.function_lookup(['a_value', ast_lambda('|$name, $result|{[$name, $result]}')])).to eq(['a_value', 'something'])
+  end
+
+  it "yields name and result and default to a given lambda" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+    expect(scope.function_lookup(['a_value', {'default' => 'cigar'}, 
+      ast_lambda('|$name, $result, $d|{[$name, $result, $d]}')])).to eq(['a_value', 'something', 'cigar'])
+  end
+
+  it "yields to a given lambda and returns the result when giving name and type" do
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
     expect(scope.function_lookup(['a_value', 'String', ast_lambda('|$x|{something_else}')])).to eq('something_else')
   end
 
   it "yields :undef when value is not found and using a lambda" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-
     expect(scope.function_lookup(['not_bound_value', ast_lambda('|$x|{ if $x == undef {good} else {bad}}')])).to eq('good')
   end
 
   def scope_with_injections_from(binder)
     injector = Puppet::Pops::Binder::Injector.new(binder)
-    scope = Puppet::Parser::Scope.new_for_test_harness('testing')
+    scope = create_test_scope_for_node('testing')
     scope.compiler.injector = injector
-
     scope
   end
 
@@ -80,17 +133,14 @@ describe "lookup function" do
   end
 
   def bound(local_bindings)
-    binder = Puppet::Pops::Binder::Binder.new
-    binder.define_categories(Puppet::Pops::Binder::BindingsFactory.categories([]))
-    binder.define_layers(Puppet::Pops::Binder::BindingsFactory.layered_bindings(Puppet::Pops::Binder::BindingsFactory.named_layer('test layer', local_bindings.model)))
-
-    binder
+    layered_bindings = Puppet::Pops::Binder::BindingsFactory.layered_bindings(Puppet::Pops::Binder::BindingsFactory.named_layer('test layer', local_bindings.model))
+    Puppet::Pops::Binder::Binder.new(layered_bindings)
   end
 
   def ast_lambda(puppet_source)
     puppet_source = "fake_func() " + puppet_source
     model = Puppet::Pops::Parser::EvaluatingParser.new().parse_string(puppet_source, __FILE__).current
-    model = model.lambda
+    model = model.body.lambda
     Puppet::Pops::Model::AstTransformer.new(@file_source, nil).transform(model)
   end
 end