puppet 3.3.2 → 3.4.0.rc1

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

@@ -28,40 +28,41 @@ describe 'the reduce method' do
     it 'reduce on an array' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
-        $b = $a.reduce {|$memo, $x| $memo + $x }
+        $b = $a.reduce |$memo, $x| { $memo + $x }
         file { "/file_$b": ensure => present }
       MANIFEST
 
       catalog.resource(:file, "/file_6")['ensure'].should == 'present'
-    end    
+    end
+
     it 'reduce on an array with start value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
-        $b = $a.reduce(4) {|$memo, $x| $memo + $x }
+        $b = $a.reduce(4) |$memo, $x| { $memo + $x }
         file { "/file_$b": ensure => present }
       MANIFEST
-  
+
       catalog.resource(:file, "/file_10")['ensure'].should == 'present'
-    end    
+    end
     it 'reduce on a hash' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>1, b=>2, c=>3}
         $start = [ignored, 4]
-        $b = $a.reduce {|$memo, $x| ['sum', $memo[1] + $x[1]] }
+        $b = $a.reduce |$memo, $x| {['sum', $memo[1] + $x[1]] }
         file { "/file_${$b[0]}_${$b[1]}": ensure => present }
       MANIFEST
-    
+
       catalog.resource(:file, "/file_sum_6")['ensure'].should == 'present'
-    end    
+    end
     it 'reduce on a hash with start value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>1, b=>2, c=>3}
         $start = ['ignored', 4]
-        $b = $a.reduce($start) {|$memo, $x| ['sum', $memo[1] + $x[1]] }
+        $b = $a.reduce($start) |$memo, $x| { ['sum', $memo[1] + $x[1]] }
         file { "/file_${$b[0]}_${$b[1]}": ensure => present }
       MANIFEST
-  
+
       catalog.resource(:file, "/file_sum_10")['ensure'].should == 'present'
-    end    
+    end
   end
 end

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

@@ -2,7 +2,7 @@
 shared_examples_for 'all iterative functions hash handling' do |func|
   it 'passes a hash entry as an array of the key and value' do
     catalog = compile_to_catalog(<<-MANIFEST)
-      {a=>1}.#{func} { |$v| notify { "${v[0]} ${v[1]}": } }
+      {a=>1}.#{func} |$v| { notify { "${v[0]} ${v[1]}": } }
     MANIFEST
 
     catalog.resource(:notify, "a 1").should_not be_nil
@@ -14,7 +14,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
   it 'raises an error when defined with more than 1 argument' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func} { |$x, $yikes| }
+        [1].#{func} |$x, $yikes|{  }
       MANIFEST
     end.to raise_error(Puppet::Error, /Too few arguments/)
   end
@@ -22,7 +22,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
   it 'raises an error when defined with fewer than 1 argument' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func} { || }
+        [1].#{func} || {  }
       MANIFEST
     end.to raise_error(Puppet::Error, /Too many arguments/)
   end
@@ -30,7 +30,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
   it 'raises an error when used against an unsupported type' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        "not correct".#{func} { |$v| }
+        "not correct".#{func} |$v| {  }
       MANIFEST
     end.to raise_error(Puppet::Error, /must be an Array or a Hash/)
   end
@@ -38,7 +38,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
   it 'raises an error when called with any parameters besides a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1) { |$v| }
+        [1].#{func}(1) |$v| {  }
       MANIFEST
     end.to raise_error(Puppet::Error, /Wrong number of arguments/)
   end

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

@@ -27,15 +27,15 @@ describe 'methods' do
   end
 
   context "should be callable on array as" do
-    
+
     it 'slice with explicit parameters' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1, present, 2, absent, 3, present]
-        $a.slice(2) |$k,$v| { 
+        $a.slice(2) |$k,$v| {
           file { "/file_${$k}": ensure => $v }
         }
       MANIFEST
-  
+
       catalog.resource(:file, "/file_1")['ensure'].should == 'present'
       catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
@@ -43,11 +43,11 @@ describe 'methods' do
     it 'slice with one parameter' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1, present, 2, absent, 3, present]
-        $a.slice(2) |$k| { 
+        $a.slice(2) |$k| {
           file { "/file_${$k[0]}": ensure => $k[1] }
         }
       MANIFEST
-  
+
       catalog.resource(:file, "/file_1")['ensure'].should == 'present'
       catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'
@@ -55,39 +55,39 @@ describe 'methods' do
     it 'slice with shorter last slice' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1, present, 2, present, 3, absent]
-        $a.slice(4) |$a, $b, $c, $d| { 
+        $a.slice(4) |$a, $b, $c, $d| {
           file { "/file_$a.$c": ensure => $b }
         }
       MANIFEST
-    
+
       catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
       catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
     end
   end
   context "should be callable on hash as" do
-    
+
     it 'slice with explicit parameters, missing are empty' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {1=>present, 2=>present, 3=>absent}
-        $a.slice(2) |$a,$b| { 
+        $a.slice(2) |$a,$b| {
           file { "/file_${a[0]}.${b[0]}": ensure => $a[1] }
         }
       MANIFEST
-  
+
       catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
       catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
     end
-  
+
   end
   context "when called without a block" do
     it "should produce an array with the result" do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1, present, 2, absent, 3, present]
-        $a.slice(2).each |$k| { 
+        $a.slice(2).each |$k| {
           file { "/file_${$k[0]}": ensure => $k[1] }
         }
       MANIFEST
-  
+
       catalog.resource(:file, "/file_1")['ensure'].should == 'present'
       catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
       catalog.resource(:file, "/file_3")['ensure'].should == 'present'

data/spec/unit/parser/parser_spec.rb

@@ -53,7 +53,7 @@ describe Puppet::Parser do
 
   describe "when parsing files" do
     before do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       File.stubs(:read).returns ""
       @parser.stubs(:watch_file)
     end

data/spec/unit/parser/resource/param_spec.rb

@@ -0,0 +1,44 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Parser::Resource::Param do
+  it "can be instantiated" do
+    Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo')
+  end
+
+  it "stores the source file" do
+    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :file => 'foo.pp')
+    param.file.should == 'foo.pp'
+  end
+
+  it "stores the line number" do
+    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :line => 42)
+    param.line.should == 42
+  end
+
+  context "parameter validation" do
+    it "throws an error when instantiated without a name" do
+      expect {
+        Puppet::Parser::Resource::Param.new(:value => 'foo')
+      }.to raise_error(Puppet::Error, /name is a required option/)
+    end
+
+    it "throws an error when instantiated without a value" do
+      expect {
+        Puppet::Parser::Resource::Param.new(:name => 'myparam')
+      }.to raise_error(Puppet::Error, /value is a required option/)
+    end
+
+    it "throws an error when instantiated with a nil value" do
+      expect {
+        Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => nil)
+      }.to raise_error(Puppet::Error, /value is a required option/)
+    end
+
+    it "includes file/line context in errors" do
+      expect {
+        Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => nil, :file => 'foo.pp', :line => 42)
+      }.to raise_error(Puppet::Error, /foo.pp:42/)
+    end
+  end
+end

data/spec/unit/parser/resource_spec.rb

@@ -90,7 +90,7 @@ describe Puppet::Parser::Resource do
   it "should use a Puppet::Resource for converting to a ral resource" do
     trans = mock 'resource', :to_ral => "yay"
     @resource = mkresource
-    @resource.expects(:to_resource).returns trans
+    @resource.expects(:copy_as_resource).returns trans
     @resource.to_ral.should == "yay"
   end
 
@@ -124,7 +124,8 @@ describe Puppet::Parser::Resource do
       tags = [ "tag1", "tag2" ]
       @arguments[:parameters] = [ param(:tag, tags , :source) ]
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
-      (res.tags & tags).should == tags
+      res.should be_tagged("tag1")
+      res.should be_tagged("tag2")
     end
   end
 
@@ -445,7 +446,7 @@ describe Puppet::Parser::Resource do
   it "should be able to be converted to a normal resource" do
     @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
-    @resource.should respond_to(:to_resource)
+    @resource.should respond_to(:copy_as_resource)
   end
 
   describe "when being converted to a resource" do
@@ -454,19 +455,19 @@ describe Puppet::Parser::Resource do
     end
 
     it "should create an instance of Puppet::Resource" do
-      @parser_resource.to_resource.should be_instance_of(Puppet::Resource)
+      @parser_resource.copy_as_resource.should be_instance_of(Puppet::Resource)
     end
 
     it "should set the type correctly on the Puppet::Resource" do
-      @parser_resource.to_resource.type.should == @parser_resource.type
+      @parser_resource.copy_as_resource.type.should == @parser_resource.type
     end
 
     it "should set the title correctly on the Puppet::Resource" do
-      @parser_resource.to_resource.title.should == @parser_resource.title
+      @parser_resource.copy_as_resource.title.should == @parser_resource.title
     end
 
     it "should copy over all of the parameters" do
-      result = @parser_resource.to_resource.to_hash
+      result = @parser_resource.copy_as_resource.to_hash
 
       # The name will be in here, also.
       result[:foo].should == "bar"
@@ -477,40 +478,40 @@ describe Puppet::Parser::Resource do
       @parser_resource.tag "foo"
       @parser_resource.tag "bar"
 
-      @parser_resource.to_resource.tags.should == @parser_resource.tags
+      @parser_resource.copy_as_resource.tags.should == @parser_resource.tags
     end
 
     it "should copy over the line" do
       @parser_resource.line = 40
-      @parser_resource.to_resource.line.should == 40
+      @parser_resource.copy_as_resource.line.should == 40
     end
 
     it "should copy over the file" do
       @parser_resource.file = "/my/file"
-      @parser_resource.to_resource.file.should == "/my/file"
+      @parser_resource.copy_as_resource.file.should == "/my/file"
     end
 
     it "should copy over the 'exported' value" do
       @parser_resource.exported = true
-      @parser_resource.to_resource.exported.should be_true
+      @parser_resource.copy_as_resource.exported.should be_true
     end
 
     it "should copy over the 'virtual' value" do
       @parser_resource.virtual = true
-      @parser_resource.to_resource.virtual.should be_true
+      @parser_resource.copy_as_resource.virtual.should be_true
     end
 
     it "should convert any parser resource references to Puppet::Resource instances" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ref}
-      result = @parser_resource.to_resource
+      result = @parser_resource.copy_as_resource
       result[:fee].should == Puppet::Resource.new(:file, "/my/file")
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", ref]}
-      result = @parser_resource.to_resource
+      result = @parser_resource.copy_as_resource
       result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file")]
     end
 
@@ -518,7 +519,7 @@ describe Puppet::Parser::Resource do
       ref1 = Puppet::Resource.new("file", "/my/file1")
       ref2 = Puppet::Resource.new("file", "/my/file2")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
-      result = @parser_resource.to_resource
+      result = @parser_resource.copy_as_resource
       result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file1"), Puppet::Resource.new(:file, "/my/file2")]
     end
 

data/spec/unit/pops/model/ast_transformer_spec.rb

@@ -13,28 +13,42 @@ describe Puppet::Pops::Model::AstTransformer do
     it "converts a decimal number to a string Name" do
       ast = transform(QNAME_OR_NUMBER("10"))
 
-      ast.should be_kind_of Puppet::Parser::AST::Name
+      ast.should be_kind_of(Puppet::Parser::AST::Name)
       ast.value.should == "10"
     end
 
+    it "converts a 0 to a decimal 0" do
+      ast = transform(QNAME_OR_NUMBER("0"))
+
+      ast.should be_kind_of(Puppet::Parser::AST::Name)
+      ast.value.should == "0"
+    end
+
+    it "converts a 00 to an octal 00" do
+      ast = transform(QNAME_OR_NUMBER("0"))
+
+      ast.should be_kind_of(Puppet::Parser::AST::Name)
+      ast.value.should == "0"
+    end
+
     it "converts an octal number to a string Name" do
       ast = transform(QNAME_OR_NUMBER("020"))
 
-      ast.should be_kind_of Puppet::Parser::AST::Name
+      ast.should be_kind_of(Puppet::Parser::AST::Name)
       ast.value.should == "020"
     end
 
     it "converts a hex number to a string Name" do
       ast = transform(QNAME_OR_NUMBER("0x20"))
 
-      ast.should be_kind_of Puppet::Parser::AST::Name
+      ast.should be_kind_of(Puppet::Parser::AST::Name)
       ast.value.should == "0x20"
     end
 
     it "converts an unknown radix to an error string" do
       ast = transform(Puppet::Pops::Model::Factory.new(Puppet::Pops::Model::LiteralNumber, 3, 2))
 
-      ast.should be_kind_of Puppet::Parser::AST::Name
+      ast.should be_kind_of(Puppet::Parser::AST::Name)
       ast.value.should == "bad radix:3"
     end
   end

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

@@ -154,7 +154,7 @@ describe Puppet::Pops::Parser::Lexer::TOKENS do
     :LBRACK => '[',
     :RBRACK => ']',
 #    :LBRACE => '{',
-    :RBRACE => '}',
+#    :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
@@ -232,7 +232,7 @@ describe Puppet::Pops::Parser::Lexer::TOKENS do
 
   # These tokens' strings don't matter, just that the tokens exist.
   [:STRING, :DQPRE, :DQMID, :DQPOST, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT,
-    :LBRACE, :LAMBDA,
+    :LBRACE, :RBRACE,
     :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
     it "should have a token named #{name.to_s}" do
       Puppet::Pops::Parser::Lexer::TOKENS[name].should_not be_nil
@@ -583,7 +583,24 @@ describe Puppet::Pops::Parser::Lexer,"when lexing strings" do
     %q[""]                                                          => [[:STRING,""]],
     %q["123 456 789 0"]                                             => [[:STRING,"123 456 789 0"]],
     %q["${123} 456 $0"]                                             => [[:DQPRE,""],[:VARIABLE,"123"],[:DQMID," 456 "],[:VARIABLE,"0"],[:DQPOST,""]],
-    %q["$foo::::bar"]                                               => [[:DQPRE,""],[:VARIABLE,"foo"],[:DQPOST,"::::bar"]]
+    %q["$foo::::bar"]                                               => [[:DQPRE,""],[:VARIABLE,"foo"],[:DQPOST,"::::bar"]],
+    # Keyword variables
+    %q["$true"]                                                     => [[:DQPRE,""],[:VARIABLE, "true"],[:DQPOST,""]],
+    %q["$false"]                                                    => [[:DQPRE,""],[:VARIABLE, "false"],[:DQPOST,""]],
+    %q["$if"]                                                       => [[:DQPRE,""],[:VARIABLE, "if"],[:DQPOST,""]],
+    %q["$case"]                                                     => [[:DQPRE,""],[:VARIABLE, "case"],[:DQPOST,""]],
+    %q["$unless"]                                                   => [[:DQPRE,""],[:VARIABLE, "unless"],[:DQPOST,""]],
+    %q["$undef"]                                                    => [[:DQPRE,""],[:VARIABLE, "undef"],[:DQPOST,""]],
+    # Expressions
+    %q["${true}"]                                                   => [[:DQPRE,""],[:BOOLEAN, true],[:DQPOST,""]],
+    %q["${false}"]                                                  => [[:DQPRE,""],[:BOOLEAN, false],[:DQPOST,""]],
+    %q["${undef}"]                                                  => [[:DQPRE,""],:UNDEF,[:DQPOST,""]],
+    %q["${if true {false}}"]                                        => [[:DQPRE,""],:IF,[:BOOLEAN, true], :LBRACE, [:BOOLEAN, false], :RBRACE, [:DQPOST,""]],
+    %q["${unless true {false}}"]                                    => [[:DQPRE,""],:UNLESS,[:BOOLEAN, true], :LBRACE, [:BOOLEAN, false], :RBRACE, [:DQPOST,""]],
+    %q["${case true {true:{false}}}"] => [
+      [:DQPRE,""],:CASE,[:BOOLEAN, true], :LBRACE, [:BOOLEAN, true], :COLON, :LBRACE, [:BOOLEAN, false],
+        :RBRACE, :RBRACE, [:DQPOST,""]],
+    %q[{ "${a}" => 1 }] => [ :LBRACE, [:DQPRE,""], [:VARIABLE,"a"], [:DQPOST,""], :FARROW, [:NAME,"1"], :RBRACE ],
   }.each { |src,expected_result|
     it "should handle #{src} correctly" do
       EgrammarLexerSpec.tokens_scanned_from(src).should be_like(*expected_result)
@@ -742,7 +759,7 @@ describe "Puppet::Pops::Parser::Lexer in the old tests" do
 
   it "should end variables at `-`" do
     EgrammarLexerSpec.tokens_scanned_from('$hyphenated-variable').
-      should be_like [:VARIABLE, "hyphenated"], [:MINUS, '-'], [:NAME, 'variable']
+      should be_like([:VARIABLE, "hyphenated"], [:MINUS, '-'], [:NAME, 'variable'])
   end
 
   it "should not include whitespace in a variable" do
@@ -769,7 +786,7 @@ describe "when trying to lex a non-existent file" do
   it "should return an empty list of tokens" do
     lexer = Puppet::Pops::Parser::Lexer.new
     lexer.file = nofile = tmpfile('lexer')
-    File.exists?(nofile).should == false
+    Puppet::FileSystem::File.exist?(nofile).should == false
 
     lexer.fullscan.should == [[false,false]]
   end

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

@@ -81,16 +81,16 @@ describe "egrammar parsing function calls" do
       dump(parse("$a.foo")).should == "(call-method (. $a foo))"
     end
 
-    it "$a.foo {|| }" do
+    it "$a.foo || { }" do
       dump(parse("$a.foo || { }")).should == "(call-method (. $a foo) (lambda ()))"
     end
 
-    it "$a.foo {|$x| }" do
-      dump(parse("$a.foo {|$x| }")).should == "(call-method (. $a foo) (lambda (parameters x) ()))"
+    it "$a.foo |$x| { }" do
+      dump(parse("$a.foo |$x|{ }")).should == "(call-method (. $a foo) (lambda (parameters x) ()))"
     end
 
-    it "$a.foo {|$x| }" do
-      dump(parse("$a.foo {|$x| $b = $x}")).should ==
+    it "$a.foo |$x|{ }" do
+      dump(parse("$a.foo |$x|{ $b = $x}")).should ==
       "(call-method (. $a foo) (lambda (parameters x) (block (= $b $x))))"
     end
   end