puppet 3.1.1 → 3.2.0.rc1

data/spec/integration/parser/parser_spec.rb

@@ -1,11 +1,12 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/parser/parser_factory'
 
-describe Puppet::Parser::Parser do
+describe "Puppet::Parser::Parser" do
   module ParseMatcher
     class ParseAs
       def initialize(klass)
-        @parser = Puppet::Parser::Parser.new "development"
+        @parser = Puppet::Parser::ParserFactory.parser("development")
         @class = klass
       end
 
@@ -38,7 +39,7 @@ describe Puppet::Parser::Parser do
 
     class ParseWith
       def initialize(block)
-        @parser = Puppet::Parser::Parser.new "development"
+        @parser = Puppet::Parser::ParserFactory.parser("development")
         @block = block
       end
 
@@ -74,76 +75,193 @@ describe Puppet::Parser::Parser do
 
   before :each do
     @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
-    @parser = Puppet::Parser::Parser.new "development"
-  end
-
-  describe "when parsing comments before statement" do
-    it "should associate the documentation to the statement AST node" do
-      ast = @parser.parse("""
-      # comment
-      class test {}
-      """)
+    @parser = Puppet::Parser::ParserFactory.parser("development")
 
-      ast.code[0].should be_a(Puppet::Parser::AST::Hostclass)
-      ast.code[0].name.should == 'test'
-      ast.code[0].instantiate('')[0].doc.should == "comment\n"
-    end
+#    @parser = Puppet::Parser::Parser.new "development"
   end
+  shared_examples_for 'a puppet parser' do
+    describe "when parsing comments before statement" do
+      it "should associate the documentation to the statement AST node" do
+        if Puppet[:parser] == 'future'
+          pending "egrammar does not yet process comments"
+        end
+        ast = @parser.parse("""
+        # comment
+        class test {}
+        """)
 
-  describe "when parsing" do
-    it "should be able to parse normal left to right relationships" do
-      "Notify[foo] -> Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
+        ast.code[0].should be_a(Puppet::Parser::AST::Hostclass)
+        ast.code[0].name.should == 'test'
+        ast.code[0].instantiate('')[0].doc.should == "comment\n"
+      end
     end
 
-    it "should be able to parse right to left relationships" do
-      "Notify[foo] <- Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
-    end
+    describe "when parsing" do
+      it "should be able to parse normal left to right relationships" do
+        "Notify[foo] -> Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
+      end
 
-    it "should be able to parse normal left to right subscriptions" do
-      "Notify[foo] ~> Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
-    end
+      it "should be able to parse right to left relationships" do
+        "Notify[foo] <- Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
+      end
 
-    it "should be able to parse right to left subscriptions" do
-      "Notify[foo] <~ Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
-    end
+      it "should be able to parse normal left to right subscriptions" do
+        "Notify[foo] ~> Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
+      end
+
+      it "should be able to parse right to left subscriptions" do
+        "Notify[foo] <~ Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship)
+      end
 
-    it "should correctly set the arrow type of a relationship" do
-      "Notify[foo] <~ Notify[bar]".should parse_with { |rel| rel.arrow == "<~" }
+      it "should correctly set the arrow type of a relationship" do
+        "Notify[foo] <~ Notify[bar]".should parse_with { |rel| rel.arrow == "<~" }
+      end
+
+      it "should be able to parse deep hash access" do
+        %q{
+          $hash = { 'a' => { 'b' => { 'c' => 'it works' } } }
+          $out = $hash['a']['b']['c']
+        }.should parse_with { |v| v.value.is_a?(Puppet::Parser::AST::ASTHash) }
+      end
+
+      it "should fail if asked to parse '$foo::::bar'" do
+        expect { @parser.parse("$foo::::bar") }.to raise_error(Puppet::ParseError, /Syntax error at ':'/)
+      end
+
+      describe "function calls" do
+        it "should be able to pass an array to a function" do
+          "my_function([1,2,3])".should parse_with { |fun|
+            fun.is_a?(Puppet::Parser::AST::Function) &&
+            fun.arguments[0].evaluate(stub 'scope') == ['1','2','3']
+          }
+        end
+
+        it "should be able to pass a hash to a function" do
+          "my_function({foo => bar})".should parse_with { |fun|
+            fun.is_a?(Puppet::Parser::AST::Function) &&
+            fun.arguments[0].evaluate(stub 'scope') == {'foo' => 'bar'}
+          }
+        end
+      end
+
+      describe "collections" do
+        it "should find resources according to an expression" do
+          %q{ File <| mode == 0700 + 0050 + 0050 |> }.should parse_with { |coll|
+            coll.is_a?(Puppet::Parser::AST::Collection) &&
+              coll.query.evaluate(stub 'scope').first == ["mode", "==", 0700 + 0050 + 0050]
+          }
+        end
+      end
     end
+  end
 
-    it "should be able to parse deep hash access" do
-      %q{
-        $hash = { 'a' => { 'b' => { 'c' => 'it works' } } }
-        $out = $hash['a']['b']['c']
-      }.should parse_with { |v| v.value.is_a?(Puppet::Parser::AST::ASTHash) }
+  describe 'using classic parser' do
+    before :each do
+      Puppet[:parser] = 'current'
     end
+    it_behaves_like 'a puppet parser'
+  end
 
-    it "should fail if asked to parse '$foo::::bar'" do
-      expect { @parser.parse("$foo::::bar") }.to raise_error(Puppet::ParseError, /Syntax error at ':'/)
+  describe 'using future parser' do
+    before :each do
+      Puppet[:parser] = 'future'
     end
+    it_behaves_like 'a puppet parser'
 
-    describe "function calls" do
-      it "should be able to pass an array to a function" do
-        "my_function([1,2,3])".should parse_with { |fun|
-          fun.is_a?(Puppet::Parser::AST::Function) &&
-          fun.arguments[0].evaluate(stub 'scope') == ['1','2','3']
-        }
+    context 'more detailed errors should be generated' do
+      before :each do
+        Puppet[:parser] = 'future'
+        @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
+        @parser = Puppet::Parser::ParserFactory.parser("development")
+      end
+
+      it 'should flag illegal type references' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        1+1 { "title": }
+        SOURCE
+        # This error message is currently produced by the parser, and is not as detailed as desired
+        # It references position 16 at the closing '}'
+        expect { @parser.parse(source) }.to raise_error(/Expression is not valid as a resource.*line 1:16/)
+      end
+
+      it 'should flag illegal type references and get position correct' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        1+1 { "title":
+          }
+        SOURCE
+        # This error message is currently produced by the parser, and is not as detailed as desired
+        # It references position 16 at the closing '}'
+        expect { @parser.parse(source) }.to raise_error(/Expression is not valid as a resource.*line 2:3/)
       end
 
-      it "should be able to pass a hash to a function" do
-        "my_function({foo => bar})".should parse_with { |fun|
-          fun.is_a?(Puppet::Parser::AST::Function) &&
-          fun.arguments[0].evaluate(stub 'scope') == {'foo' => 'bar'}
+      it 'should flag illegal use of non r-value producing if' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        $a = if true {
+          false
         }
+        SOURCE
+        expect { @parser.parse(source) }.to raise_error(/An 'if' statement does not produce a value at line 1:6/)
       end
-    end
 
-    describe "collections" do
-      it "should find resources according to an expression" do
-        %q{ File <| mode == 0700 + 0050 + 0050 |> }.should parse_with { |coll|
-          coll.is_a?(Puppet::Parser::AST::Collection) &&
-            coll.query.evaluate(stub 'scope').first == ["mode", "==", 0700 + 0050 + 0050]
+      it 'should flag illegal use of non r-value producing case' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        $a = case true {
+          false :{ }
         }
+        SOURCE
+        expect { @parser.parse(source) }.to raise_error(/A 'case' statement does not produce a value at line 1:6/)
+      end
+
+      it 'should flag illegal use of non r-value producing <| |>' do
+        expect { @parser.parse("$a = file <| |>") }.to raise_error(/A Virtual Query does not produce a value at line 1:6/)
+      end
+
+      it 'should flag illegal use of non r-value producing <<| |>>' do
+        expect { @parser.parse("$a = file <<| |>>") }.to raise_error(/An Exported Query does not produce a value at line 1:6/)
+      end
+
+      it 'should flag illegal use of non r-value producing define' do
+        Puppet.expects(:err).with("Invalid use of expression. A 'define' expression does not produce a value at line 1:6")
+        Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
+        expect { @parser.parse("$a = define foo { }") }.to raise_error(/2 errors/)
+      end
+
+      it 'should flag illegal use of non r-value producing class' do
+        Puppet.expects(:err).with("Invalid use of expression. A Host Class Definition does not produce a value at line 1:6")
+        Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
+        expect { @parser.parse("$a = class foo { }") }.to raise_error(/2 errors/)
+      end
+
+      it 'unclosed quote should be flagged for start position of string' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        $a = "xx
+        yyy
+        SOURCE
+        expect { @parser.parse(source) }.to raise_error(/Unclosed quote after '"' followed by 'xx\\nyy\.\.\.' at line 1:6/)
+      end
+
+      it 'can produce multiple errors and raise a summary exception' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        $a = node x { }
+        SOURCE
+        Puppet.expects(:err).with("Invalid use of expression. A Node Definition does not produce a value at line 1:6")
+        Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
+        expect { @parser.parse(source) }.to raise_error(/2 errors/)
+      end
+
+      it 'can produce detailed error for a bad hostname' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        node 'macbook+owned+by+name' { }
+        SOURCE
+        expect { @parser.parse(source) }.to raise_error(/The hostname 'macbook\+owned\+by\+name' contains illegal characters.*at line 1:6/)
+      end
+
+      it 'can produce detailed error for a hostname with interpolation' do
+        source = <<-SOURCE.gsub(/^ {8}/,'')
+        $name = 'fred'
+        node "macbook-owned-by$name" { }
+        SOURCE
+        expect { @parser.parse(source) }.to raise_error(/An interpolated expression is not allowed in a hostname of a node at line 2:24/)
       end
     end
   end

data/spec/integration/parser/scope_spec.rb

@@ -182,7 +182,7 @@ describe "Two step scoping for variables" do
           class c {
             notify { 'something': message => "$a::b" }
           }
-          
+
           class a { }
 
           node default {

data/spec/integration/provider/cron/crontab_spec.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet/file_bucket/dipper'
+
+describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+
+  before :each do
+    Puppet::Type.type(:cron).stubs(:defaultprovider).returns described_class
+    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to filebucket
+
+    # I dont want to execute anything
+    described_class.stubs(:filetype).returns Puppet::Util::FileType::FileTypeFlat
+    described_class.stubs(:default_target).returns crontab_user1
+
+    # I dont want to stub Time.now to get a static header because I dont know
+    # where Time.now is used elsewere so just go with a very simple header
+    described_class.stubs(:header).returns "# HEADER: some simple\n# HEADER: header\n"
+    FileUtils.cp(my_fixture('crontab_user1'), crontab_user1)
+    FileUtils.cp(my_fixture('crontab_user2'), crontab_user2)
+  end
+
+  after :each do
+    described_class.clear
+  end
+
+  let :crontab_user1 do
+    tmpfile('cron_integration_specs')
+  end
+
+  let :crontab_user2 do
+    tmpfile('cron_integration_specs')
+  end
+
+  def run_in_catalog(*resources)
+    catalog = Puppet::Resource::Catalog.new
+    catalog.host_config = false
+    resources.each do |resource|
+      resource.expects(:err).never
+      catalog.add_resource(resource)
+    end
+    catalog.apply
+  end
+
+  def expect_output(fixture_name)
+    File.read(crontab_user1).should == File.read(my_fixture(fixture_name))
+  end
+
+  describe "when managing a cron entry" do
+    describe "with ensure absent" do
+      it "should do nothing if entry already absent" do
+        resource = Puppet::Type.type(:cron).new(
+          :name   => 'no_such_entry',
+          :ensure => :absent,
+          :target => crontab_user1,
+          :user   => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('crontab_user1')
+      end
+
+      it "should remove the resource from crontab if present" do
+        resource = Puppet::Type.type(:cron).new(
+          :name   => 'My daily failure',
+          :ensure => :absent,
+          :target => crontab_user1,
+          :user   => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('remove_named_resource')
+      end
+
+      it "should remove a matching cronentry if present" do
+        resource = Puppet::Type.type(:cron).new(
+          :name     => 'no_such_named_resource_in_crontab',
+          :ensure   => :absent,
+          :minute   => [ '17-19', '22' ],
+          :hour     => [ '0-23/2' ],
+          :weekday  => 'Tue',
+          :command  => '/bin/unnamed_regular_command',
+          :target   => crontab_user1,
+          :user     => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('remove_unnamed_resource')
+      end
+    end
+
+    describe "with ensure present" do
+      it "should do nothing if entry already present" do
+        resource = Puppet::Type.type(:cron).new(
+          :name    => 'My daily failure',
+          :special => 'daily',
+          :command => '/bin/false',
+          :target  => crontab_user1,
+          :user    => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('crontab_user1')
+      end
+
+      it "should do nothing if a matching entry already present" do
+        resource = Puppet::Type.type(:cron).new(
+          :name     => 'no_such_named_resource_in_crontab',
+          :ensure   => :present,
+          :minute   => [ '17-19', '22' ],
+          :hour     => [ '0-23/2' ],
+          :command  => '/bin/unnamed_regular_command',
+          :target   => crontab_user1,
+          :user     => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('crontab_user1')
+      end
+
+      it "should add a new normal entry if currently absent" do
+        resource = Puppet::Type.type(:cron).new(
+          :name        => 'new entry',
+          :ensure      => :present,
+          :minute      => '12',
+          :weekday     => 'Tue',
+          :command     => '/bin/new',
+          :environment => [
+            'MAILTO=""',
+            'SHELL=/bin/bash'
+          ],
+          :target      => crontab_user1,
+          :user        => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('create_normal_entry')
+      end
+
+      it "should add a new special entry if currently absent" do
+        resource = Puppet::Type.type(:cron).new(
+          :name        => 'new special entry',
+          :ensure      => :present,
+          :special     => 'reboot',
+          :command     => 'echo "Booted" 1>&2',
+          :environment => 'MAILTO=bob@company.com',
+          :target      => crontab_user1,
+          :user        => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('create_special_entry')
+      end
+
+      it "should change existing entry if out of sync" do
+        resource = Puppet::Type.type(:cron).new(
+          :name        => 'Monthly job',
+          :ensure      => :present,
+          :special     => 'monthly',
+#          :minute => ['22'],
+          :command     => '/usr/bin/monthly',
+          :environment => [],
+          :target      => crontab_user1,
+          :user        => crontab_user1
+        )
+        run_in_catalog(resource)
+        expect_output('modify_entry')
+      end
+      it "should not try to move an entry from one file to another" do
+        # force the parsedfile provider to also parse user1's crontab
+        random_resource = Puppet::Type.type(:cron).new(
+          :name   => 'foo',
+          :ensure => :absent,
+          :target => crontab_user1,
+          :user   => crontab_user1
+        )
+        resource = Puppet::Type.type(:cron).new(
+          :name         => 'My daily failure',
+          :special      => 'daily',
+	  :command      => "/bin/false",
+          :target       => crontab_user2,
+          :user         => crontab_user2
+        )
+        run_in_catalog(resource)
+        File.read(crontab_user1).should == File.read(my_fixture('moved_cronjob_input1'))
+        File.read(crontab_user2).should == File.read(my_fixture('moved_cronjob_input2'))
+      end
+    end
+
+    it "should not add multiple headers"
+  end
+
+end