puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/parser/collector_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Parser::Collector, "when initializing" do
   end
 
   it "should only accept :virtual or :exported as the collector form" do
-    proc { @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @vquery, @equery, :other) }.should raise_error(ArgumentError)
+    expect { @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @vquery, @equery, :other) }.to raise_error(ArgumentError)
   end
 
   it "should accept an optional virtual query" do
@@ -61,7 +61,7 @@ describe Puppet::Parser::Collector, "when collecting specific virtual resources"
   it "should not fail when it does not find any resources to collect" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     @scope.stubs(:findresource).returns(false)
-    proc { @collector.evaluate }.should_not raise_error
+    expect { @collector.evaluate }.to_not raise_error
   end
 
   it "should mark matched resources as non-virtual" do
@@ -429,7 +429,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       @compiler.add_resource(@scope, local)
 
       got = nil
-      expect { got = @collector.evaluate }.not_to raise_error(Puppet::ParseError)
+      expect { got = @collector.evaluate }.not_to raise_error
       got.length.should == 1
       got.first.type.should == "Notify"
       got.first.title.should == "boingy-boingy"

data/spec/unit/parser/compiler_spec.rb

@@ -225,9 +225,10 @@ describe Puppet::Parser::Compiler do
       three = stub 'three', :name => "three"
       @node.stubs(:name).returns("whatever")
       @node.stubs(:classes).returns(classes)
+      compile_stub(:evaluate_node_classes)
 
       @compiler.expects(:evaluate_classes).with(classes, @compiler.topscope)
-      @compiler.class.publicize_methods(:evaluate_node_classes) { @compiler.evaluate_node_classes }
+      @compiler.compile
     end
 
     it "should evaluate any parameterized classes named in the node" do
@@ -521,7 +522,7 @@ describe Puppet::Parser::Compiler do
         end
       }
 
-      @compiler.class.publicize_methods(:evaluate_collections) { @compiler.evaluate_collections }
+      @compiler.compile
     end
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
@@ -576,7 +577,7 @@ describe Puppet::Parser::Compiler do
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.stubs(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
+      @compiler.topscope.expects(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end

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

@@ -23,21 +23,6 @@ describe 'function for dynamically creating resources' do
     expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.to raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
   end
 
-  describe 'when the caller does not supply a name parameter' do
-    it 'should set a default resource name equal to the resource title' do
-      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'test').once
-      @scope.function_create_resources(['notify', {'test'=>{}}])
-    end
-  end
-
-  describe 'when the caller supplies a name parameter' do
-    it 'should set the resource name to the value provided' do
-      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'user_supplied').once
-      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'test').never
-      @scope.function_create_resources(['notify', {'test'=>{'name' => 'user_supplied'}}])
-    end
-  end
-
   describe 'when creating native types' do
     it 'empty hash should not cause resources to be added' do
       noop_catalog = compile_to_catalog("create_resources('file', {})")
@@ -68,12 +53,13 @@ describe 'function for dynamically creating resources' do
     end
 
     it 'should fail to add non-existing type' do
-      expect { @scope.function_create_resources(['create-resource-foo', {}]) }.to raise_error(ArgumentError, 'could not create resource of unknown type create-resource-foo')
+      expect do
+        @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
+      end.to raise_error(ArgumentError, /Invalid resource type create-resource-foo/)
     end
 
     it 'should be able to add edges' do
-      catalog = compile_to_catalog("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>'Notify[test]'}})")
-      rg = catalog.to_ral.relationship_graph
+      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>'Notify[test]'}})")
       test  = rg.vertices.find { |v| v.title == 'test' }
       foo   = rg.vertices.find { |v| v.title == 'foo' }
       test.must be
@@ -87,6 +73,7 @@ describe 'function for dynamically creating resources' do
       catalog.resource(:file, "/etc/baz")['group'].should == 'food'
     end
   end
+
   describe 'when dynamically creating resource types' do
     it 'should be able to create defined resoure types' do
       catalog = compile_to_catalog(<<-MANIFEST)
@@ -125,7 +112,7 @@ describe 'function for dynamically creating resources' do
     end
 
     it 'should be able to add edges' do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      rg = compile_to_relationship_graph(<<-MANIFEST)
         define foocreateresource($one) {
           notify { $name: message => $one }
         }
@@ -135,13 +122,11 @@ describe 'function for dynamically creating resources' do
         create_resources('foocreateresource', {'blah'=>{'one'=>'two', 'require' => 'Notify[test]'}})
       MANIFEST
 
-      rg = catalog.to_ral.relationship_graph
       test = rg.vertices.find { |v| v.title == 'test' }
       blah = rg.vertices.find { |v| v.title == 'blah' }
       test.must be
       blah.must be
       rg.path_between(test,blah).should be
-      catalog.resource(:notify, "blah")['message'].should == 'two'
     end
 
     it 'should account for default values' do
@@ -172,15 +157,15 @@ describe 'function for dynamically creating resources' do
     end
 
     it 'should fail to create non-existing classes' do
-      expect {
+      expect do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      }.to raise_error(Puppet::Error ,'could not find hostclass blah at line 1 on node foonode')
+      end.to raise_error(Puppet::Error, 'Could not find declared class blah at line 1 on node foonode')
     end
 
     it 'should be able to add edges' do
-      catalog = compile_to_catalog(<<-MANIFEST)
+      rg = compile_to_relationship_graph(<<-MANIFEST)
         class bar($one) {
           notify { test: message => $one }
         }
@@ -190,7 +175,6 @@ describe 'function for dynamically creating resources' do
         create_resources('class', {'bar'=>{'one'=>'two', 'require' => 'Notify[tester]'}})
       MANIFEST
 
-      rg = catalog.to_ral.relationship_graph
       test   = rg.vertices.find { |v| v.title == 'test' }
       tester = rg.vertices.find { |v| v.title == 'tester' }
       test.must be

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

@@ -18,11 +18,11 @@ describe "the extlookup function" do
     Puppet::Parser::Functions.function("extlookup").should == "function_extlookup"
   end
 
-  it "should raise a ArgumentError if there is less than 1 arguments" do
+  it "should raise an ArgumentError if there is less than 1 arguments" do
     lambda { @scope.function_extlookup([]) }.should( raise_error(ArgumentError))
   end
 
-  it "should raise a ArgumentError if there is more than 3 arguments" do
+  it "should raise an ArgumentError if there is more than 3 arguments" do
     lambda { @scope.function_extlookup(["foo", "bar", "baz", "gazonk"]) }.should( raise_error(ArgumentError))
   end
 

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

@@ -21,4 +21,16 @@ describe 'Puppet::Parser::Functions#hiera_include' 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/
   end
+
+  it 'should call the `include` function with the classes' do
+    HieraPuppet.expects(:lookup).returns %w[foo bar baz]
+
+    scope.expects(:function_include).with([%w[foo bar baz]])
+    scope.function_hiera_include(['key'])
+  end
+
+  it 'should not raise an error if the resulting hiera lookup returns an empty array' do
+    HieraPuppet.expects(:lookup).returns []
+    expect { scope.function_hiera_include(['key']) }.to_not raise_error
+  end
 end

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

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'stringio'
+
+describe "lookup function" do
+  before(:each) do
+    Puppet[:binder] = true
+  end
+
+  it "must be called with at least a name to lookup" do
+    scope = scope_with_injections_from(bound(bindings))
+
+    expect do
+      scope.function_lookup([])
+    end.to raise_error(ArgumentError, /Wrong number of arguments/)
+  end
+
+  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
+    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
+
+    expect(scope.function_lookup(['not_bound_value'])).to eq(:undef)
+  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/)
+  end
+
+  it "returns the value if the bound type is assignable to the requested type" 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
+    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.compiler.injector = injector
+
+    scope
+  end
+
+  def bindings
+    Puppet::Pops::Binder::BindingsFactory.named_bindings("testing")
+  end
+
+  def bind_single(name, value)
+    local_bindings = Puppet::Pops::Binder::BindingsFactory.named_bindings("testing")
+    local_bindings.bind().name(name).to(value)
+    local_bindings
+  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
+  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
+    Puppet::Pops::Model::AstTransformer.new(@file_source, nil).transform(model)
+  end
+end

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

@@ -16,11 +16,11 @@ describe "the regsubst function" do
     Puppet::Parser::Functions.function("regsubst").should == "function_regsubst"
   end
 
-  it "should raise a ArgumentError if there is less than 3 arguments" do
+  it "should raise an ArgumentError if there is less than 3 arguments" do
     lambda { @scope.function_regsubst(["foo", "bar"]) }.should( raise_error(ArgumentError))
   end
 
-  it "should raise a ArgumentError if there is more than 5 arguments" do
+  it "should raise an ArgumentError if there is more than 5 arguments" do
     lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "del", "x", "y"]) }.should( raise_error(ArgumentError))
   end
 

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

@@ -16,11 +16,11 @@ describe "the split function" do
     Puppet::Parser::Functions.function("split").should == "function_split"
   end
 
-  it "should raise a ArgumentError if there is less than 2 arguments" do
+  it "should raise an ArgumentError if there is less than 2 arguments" do
     lambda { @scope.function_split(["foo"]) }.should( raise_error(ArgumentError))
   end
 
-  it "should raise a ArgumentError if there is more than 2 arguments" do
+  it "should raise an ArgumentError if there is more than 2 arguments" do
     lambda { @scope.function_split(["foo", "bar", "gazonk"]) }.should( raise_error(ArgumentError))
   end
 

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

@@ -16,7 +16,7 @@ describe "the sprintf function" do
     Puppet::Parser::Functions.function("sprintf").should == "function_sprintf"
   end
 
-  it "should raise a ArgumentError if there is less than 1 argument" do
+  it "should raise an ArgumentError if there is less than 1 argument" do
     lambda { @scope.function_sprintf([]) }.should( raise_error(ArgumentError))
   end
 

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

@@ -16,11 +16,11 @@ describe "the versioncmp function" do
     Puppet::Parser::Functions.function("versioncmp").should == "function_versioncmp"
   end
 
-  it "should raise a ArgumentError if there is less than 2 arguments" do
+  it "should raise an ArgumentError if there is less than 2 arguments" do
     lambda { @scope.function_versioncmp(["1.2"]) }.should raise_error(ArgumentError)
   end
 
-  it "should raise a ArgumentError if there is more than 2 arguments" do
+  it "should raise an ArgumentError if there is more than 2 arguments" do
     lambda { @scope.function_versioncmp(["1.2", "2.4.5", "3.5.6"]) }.should raise_error(ArgumentError)
   end
 

data/spec/unit/parser/functions_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Parser::Functions do
     end
 
     it "should raise an error if the function type is not correct" do
-      lambda { Puppet::Parser::Functions.newfunction("name", :type => :unknown) { |args| } }.should raise_error Puppet::DevError, "Invalid statement type :unknown"
+      expect { Puppet::Parser::Functions.newfunction("name", :type => :unknown) { |args| } }.to raise_error Puppet::DevError, "Invalid statement type :unknown"
     end
 
     it "instruments the function to profiles the execution" do
@@ -85,32 +85,32 @@ describe Puppet::Parser::Functions do
 
     it "should raise an error if the function is called with too many arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => 2) { |args| }
-      lambda { callable_functions_from(function_module).function_name([1,2,3]) }.should raise_error ArgumentError
+      expect { callable_functions_from(function_module).function_name([1,2,3]) }.to raise_error ArgumentError
     end
 
     it "should raise an error if the function is called with too few arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => 2) { |args| }
-      lambda { callable_functions_from(function_module).function_name([1]) }.should raise_error ArgumentError
+      expect { callable_functions_from(function_module).function_name([1]) }.to raise_error ArgumentError
     end
 
     it "should not raise an error if the function is called with correct number of arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => 2) { |args| }
-      lambda { callable_functions_from(function_module).function_name([1,2]) }.should_not raise_error ArgumentError
+      expect { callable_functions_from(function_module).function_name([1,2]) }.to_not raise_error
     end
 
     it "should raise an error if the variable arg function is called with too few arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => -3) { |args| }
-      lambda { callable_functions_from(function_module).function_name([1]) }.should raise_error ArgumentError
+      expect { callable_functions_from(function_module).function_name([1]) }.to raise_error ArgumentError
     end
 
     it "should not raise an error if the variable arg function is called with correct number of arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => -3) { |args| }
-      lambda { callable_functions_from(function_module).function_name([1,2]) }.should_not raise_error ArgumentError
+      expect { callable_functions_from(function_module).function_name([1,2]) }.to_not raise_error
     end
 
     it "should not raise an error if the variable arg function is called with more number of arguments" do
       Puppet::Parser::Functions.newfunction("name", :arity => -3) { |args| }
-      lambda { callable_functions_from(function_module).function_name([1,2,3]) }.should_not raise_error ArgumentError
+      expect { callable_functions_from(function_module).function_name([1,2,3]) }.to_not raise_error
     end
   end
 

data/spec/unit/parser/lexer_spec.rb

@@ -855,7 +855,7 @@ describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
   end
 end
 
-describe "when trying to lex an non-existent file" do
+describe "when trying to lex a non-existent file" do
   include PuppetSpec::Files
 
   it "should return an empty list of tokens" do

data/spec/unit/parser/methods/collect_spec.rb

@@ -38,6 +38,7 @@ describe 'the collect method' do
         catalog.resource(:file, "/file_b")['ensure'].should == 'present'
         catalog.resource(:file, "/file_c")['ensure'].should == 'present'
       end
+
       it 'foreach on a hash selecting value' do
         catalog = compile_to_catalog(<<-MANIFEST)
         $a = {'a'=>1,'b'=>2,'c'=>3}
@@ -51,6 +52,46 @@ describe 'the collect method' do
         catalog.resource(:file, "/file_3")['ensure'].should == 'present'
       end
     end
+
+    context "handles data type corner cases" do
+      it "collect gets values that are false" do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = [false,false]
+          $a.collect |$x| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_0.false")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_1.false")['ensure'].should == 'present'
+      end
+
+      it "collect gets values that are nil" do
+        Puppet::Parser::Functions.newfunction(:nil_array, :type => :rvalue) do |args|
+          [nil]
+        end
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = nil_array()
+          $a.collect |$x| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_0.")['ensure'].should == 'present'
+      end
+
+      it "collect gets values that are undef" do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = [$does_not_exist]
+          $a.collect |$x = "something"| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_0.")['ensure'].should == 'present'
+      end
+    end
+
     context "in Java style should be callable as" do
       shared_examples_for 'java style' do
         it 'collect on an array (multiplying each value by 2)' do
@@ -92,11 +133,13 @@ describe 'the collect method' do
           catalog.resource(:file, "/file_3")['ensure'].should == 'present'
         end
       end
+
       describe 'without fat arrow' do
         it_should_behave_like 'java style' do
           let(:farr) { '' }
         end
       end
+
       describe 'with fat arrow' do
         it_should_behave_like 'java style' do
           let(:farr) { '=>' }