puppet 3.1.1 → 3.2.0.rc1

data/spec/fixtures/unit/provider/cron/crontab/vixie_header.txt

@@ -0,0 +1,3 @@
+# DO NOT EDIT THIS FILE - edit the master and reinstall.
+# (- installed on Thu Apr 12 12:16:01 2007)
+# (Cron version V5.0 -- $Id: crontab.c,v 1.12 2004/01/23 18:56:42 vixie Exp $)

data/spec/fixtures/unit/provider/cron/parsed/managed

@@ -0,0 +1,6 @@
+# Puppet Name: real_job
+* * * * * /bin/true
+# Puppet Name: complex_job
+MAILTO=foo@example.com
+SHELL=/bin/sh
+@reboot /bin/true >> /dev/null 2>&1

data/spec/fixtures/unit/provider/cron/parsed/simple

@@ -0,0 +1,9 @@
+# use /bin/sh to run commands, no matter what /etc/passwd says
+SHELL=/bin/sh
+# mail any output to `paul', no matter whose crontab this is
+MAILTO=paul
+#
+# run five minutes after midnight, every day
+5 0 * * *       $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
+# run at 2:15pm on the first of every month -- output mailed to paul
+15 14 1 * *     $HOME/bin/monthly

data/spec/fixtures/unit/provider/parsedfile/simple.txt

@@ -0,0 +1,4 @@
+# This is a sample fixture for the parsedfile provider.
+# HEADER As added by software from a third party.
+# Another inconspicuous comment.
+A generic content line with: a value.

data/spec/fixtures/unit/provider/service/systemd/list_units

@@ -0,0 +1,18 @@
+UNIT                                                                                      LOAD   ACTIVE   SUB       DESCRIPTION
+auditd.service                                                                            loaded active   running   Security Auditing Service
+crond.service                                                                             loaded active   running   Command Scheduler
+dbus.service                                                                              loaded active   running   D-Bus System Message Bus
+display-manager.service                                                                   error  inactive dead      display-manager.service
+ebtables.service                                                                          loaded inactive dead      SYSV: Ethernet Bridge filtering tables
+fedora-readonly.service                                                                   loaded active   exited    Configure read-only root support
+initrd-switch-root.service                                                                loaded inactive dead      Switch Root
+ip6tables.service                                                                         error  inactive dead      ip6tables.service
+puppet.service                                                                            loaded inactive dead      SYSV: Enables periodic system configuration checks through puppet.
+sshd.service                                                                              loaded failed   failed    OpenSSH server daemon
+
+LOAD   = Reflects whether the unit definition was properly loaded.
+ACTIVE = The high-level unit activation state, i.e. generalization of SUB.
+SUB    = The low-level unit activation state, values depend on unit type.
+
+155 loaded units listed.
+To show all installed unit files use 'systemctl list-unit-files'.

data/spec/integration/parser/collector_spec.rb

@@ -64,7 +64,7 @@ describe Puppet::Parser::Collector do
     expect_the_message_to_be(["the message", "different message"], <<-MANIFEST)
       @notify { "testing":     message => "different message", withpath => true }
       @notify { "other":       message => "the message" }
-      @notify { "yet another": message => "the message",       withpath => true } 
+      @notify { "yet another": message => "the message",       withpath => true }
 
       Notify <| (title == "testing" or message == "the message") and withpath == true |>
     MANIFEST

data/spec/integration/parser/compiler_spec.rb

@@ -1,7 +1,8 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/parser/parser_factory'
 
-describe Puppet::Parser::Compiler do
+describe "Puppet::Parser::Compiler" do
   before :each do
     @node = Puppet::Node.new "testnode"
 
@@ -13,297 +14,321 @@ describe Puppet::Parser::Compiler do
     Puppet.settings.clear
   end
 
-  it "should be able to determine the configuration version from a local version control repository" do
-    pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
-      # This should always work, because we should always be
-      # in the puppet repo when we run this.
-      version = %x{git rev-parse HEAD}.chomp
+  # shared because tests are invoked both for classic and future parser
+  #
+  shared_examples_for "the compiler" do
+    it "should be able to determine the configuration version from a local version control repository" do
+      pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
+        # This should always work, because we should always be
+        # in the puppet repo when we run this.
+        version = %x{git rev-parse HEAD}.chomp
 
-      Puppet.settings[:config_version] = 'git rev-parse HEAD'
+        Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
-      @parser = Puppet::Parser::Parser.new "development"
-      @compiler = Puppet::Parser::Compiler.new(@node)
+        @parser = Puppet::Parser::ParserFactory.parser "development"
+        @compiler = Puppet::Parser::Compiler.new(@node)
 
-      @compiler.catalog.version.should == version
+        @compiler.catalog.version.should == version
+      end
     end
-  end
-
-  it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
-    Puppet[:code] = <<-PP
-      class foo
-      {
-        notify { foo_notify: }
-        include bar
-      }
-      class bar
-      {
-        notify { bar_notify: }
-      }
-    PP
-
-    @node.stubs(:classes).returns(['foo', 'bar'])
-
-    catalog = Puppet::Parser::Compiler.compile(@node)
-
-    catalog.resource("Notify[foo_notify]").should_not be_nil
-    catalog.resource("Notify[bar_notify]").should_not be_nil
-  end
 
-  describe "when resolving class references" do
-    it "should favor local scope, even if there's an included class in topscope" do
+    it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       Puppet[:code] = <<-PP
-        class experiment {
-          class baz {
-          }
-          notify {"x" : require => Class[Baz] }
+        class foo
+        {
+          notify { foo_notify: }
+          include bar
         }
-        class baz {
+        class bar
+        {
+          notify { bar_notify: }
         }
-        include baz
-        include experiment
-        include experiment::baz
       PP
 
-      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+      @node.stubs(:classes).returns(['foo', 'bar'])
 
-      notify_resource = catalog.resource( "Notify[x]" )
+      catalog = Puppet::Parser::Compiler.compile(@node)
 
-      notify_resource[:require].title.should == "Experiment::Baz"
+      catalog.resource("Notify[foo_notify]").should_not be_nil
+      catalog.resource("Notify[bar_notify]").should_not be_nil
     end
 
-    it "should favor local scope, even if there's an unincluded class in topscope" do
-      Puppet[:code] = <<-PP
-        class experiment {
+    describe "when resolving class references" do
+      it "should favor local scope, even if there's an included class in topscope" do
+        Puppet[:code] = <<-PP
+          class experiment {
+            class baz {
+            }
+            notify {"x" : require => Class[Baz] }
+          }
           class baz {
           }
-          notify {"x" : require => Class[Baz] }
-        }
-        class baz {
-        }
-        include experiment
-        include experiment::baz
-      PP
+          include baz
+          include experiment
+          include experiment::baz
+        PP
 
-      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+        catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
-      notify_resource = catalog.resource( "Notify[x]" )
+        notify_resource = catalog.resource( "Notify[x]" )
 
-      notify_resource[:require].title.should == "Experiment::Baz"
-    end
-  end
-  describe "(ticket #13349) when explicitly specifying top scope" do
-    ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
-      describe "with #{include}" do
-        it "should find the top level class" do
-          Puppet[:code] = <<-MANIFEST
-            class { 'foo::test': }
-            class foo::test {
-            	#{include}
-            }
-            class bar::baz {
-            	notify { 'good!': }
-            }
-            class foo::bar::baz {
-            	notify { 'bad!': }
+        notify_resource[:require].title.should == "Experiment::Baz"
+      end
+
+      it "should favor local scope, even if there's an unincluded class in topscope" do
+        Puppet[:code] = <<-PP
+          class experiment {
+            class baz {
             }
-          MANIFEST
+            notify {"x" : require => Class[Baz] }
+          }
+          class baz {
+          }
+          include experiment
+          include experiment::baz
+        PP
 
-          catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+        catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
-          catalog.resource("Class[Bar::Baz]").should_not be_nil
-          catalog.resource("Notify[good!]").should_not be_nil
-          catalog.resource("Class[Foo::Bar::Baz]").should be_nil
-          catalog.resource("Notify[bad!]").should be_nil
+        notify_resource = catalog.resource( "Notify[x]" )
+
+        notify_resource[:require].title.should == "Experiment::Baz"
+      end
+    end
+    describe "(ticket #13349) when explicitly specifying top scope" do
+      ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
+        describe "with #{include}" do
+          it "should find the top level class" do
+            Puppet[:code] = <<-MANIFEST
+              class { 'foo::test': }
+              class foo::test {
+              	#{include}
+              }
+              class bar::baz {
+              	notify { 'good!': }
+              }
+              class foo::bar::baz {
+              	notify { 'bad!': }
+              }
+            MANIFEST
+
+            catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+
+            catalog.resource("Class[Bar::Baz]").should_not be_nil
+            catalog.resource("Notify[good!]").should_not be_nil
+            catalog.resource("Class[Foo::Bar::Baz]").should be_nil
+            catalog.resource("Notify[bad!]").should be_nil
+          end
         end
       end
     end
-  end
 
-  it "should recompute the version after input files are re-parsed" do
-    Puppet[:code] = 'class foo { }'
-    Time.stubs(:now).returns(1)
-    node = Puppet::Node.new('mynode')
-    Puppet::Parser::Compiler.compile(node).version.should == 1
-    Time.stubs(:now).returns(2)
-    Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
-    Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
-    Puppet::Parser::Compiler.compile(node).version.should == 2
-  end
+    it "should recompute the version after input files are re-parsed" do
+      Puppet[:code] = 'class foo { }'
+      Time.stubs(:now).returns(1)
+      node = Puppet::Node.new('mynode')
+      Puppet::Parser::Compiler.compile(node).version.should == 1
+      Time.stubs(:now).returns(2)
+      Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
+      Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
+      Puppet::Parser::Compiler.compile(node).version.should == 2
+    end
 
-  ['class', 'define', 'node'].each do |thing|
-    it "should not allow #{thing} inside evaluated conditional constructs" do
-      Puppet[:code] = <<-PP
-        if true {
-          #{thing} foo {
+    ['class', 'define', 'node'].each do |thing|
+      it "should not allow #{thing} inside evaluated conditional constructs" do
+        Puppet[:code] = <<-PP
+          if true {
+            #{thing} foo {
+            }
+            notify { decoy: }
           }
-          notify { decoy: }
-        }
-      PP
+        PP
 
-      begin
-        Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-        raise "compilation should have raised Puppet::Error"
-      rescue Puppet::Error => e
-        e.message.should =~ /at line 2/
+        begin
+          Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+          raise "compilation should have raised Puppet::Error"
+        rescue Puppet::Error => e
+          e.message.should =~ /at line 2/
+        end
       end
     end
-  end
 
-  it "should not allow classes inside unevaluated conditional constructs" do
-    Puppet[:code] = <<-PP
-      if false {
-        class foo {
+    it "should not allow classes inside unevaluated conditional constructs" do
+      Puppet[:code] = <<-PP
+        if false {
+          class foo {
+          }
         }
-      }
-    PP
-
-    lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
-  end
+      PP
 
-  describe "when defining relationships" do
-    def extract_name(ref)
-      ref.sub(/File\[(\w+)\]/, '\1')
+      lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
     end
 
-    let(:node) { Puppet::Node.new('mynode') }
-    let(:code) do
-      <<-MANIFEST
-        file { [a,b,c]:
-          mode => 0644,
-        }
-        file { [d,e]:
-          mode => 0755,
-        }
-      MANIFEST
-    end
-    let(:expected_relationships) { [] }
-    let(:expected_subscriptions) { [] }
+    describe "when defining relationships" do
+      def extract_name(ref)
+        ref.sub(/File\[(\w+)\]/, '\1')
+      end
 
-    before :each do
-      Puppet[:code] = code
-    end
+      let(:node) { Puppet::Node.new('mynode') }
+      let(:code) do
+        <<-MANIFEST
+          file { [a,b,c]:
+            mode => 0644,
+          }
+          file { [d,e]:
+            mode => 0755,
+          }
+        MANIFEST
+      end
+      let(:expected_relationships) { [] }
+      let(:expected_subscriptions) { [] }
 
-    after :each do
-      catalog = described_class.compile(node)
+      before :each do
+        Puppet[:code] = code
+      end
 
-      resources = catalog.resources.select { |res| res.type == 'File' }
+      after :each do
+        catalog = Puppet::Parser::Compiler.compile(node)
 
-      actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
-        resources.map do |res|
-          dependents = Array(res[relation])
-          dependents.map { |ref| [res.title, extract_name(ref)] }
-        end.inject(&:concat)
-      end
+        resources = catalog.resources.select { |res| res.type == 'File' }
 
-      actual_relationships.should =~ expected_relationships
-      actual_subscriptions.should =~ expected_subscriptions
-    end
+        actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
+          resources.map do |res|
+            dependents = Array(res[relation])
+            dependents.map { |ref| [res.title, extract_name(ref)] }
+          end.inject(&:concat)
+        end
 
-    it "should create a relationship" do
-      code << "File[a] -> File[b]"
+        actual_relationships.should =~ expected_relationships
+        actual_subscriptions.should =~ expected_subscriptions
+      end
 
-      expected_relationships << ['a','b']
-    end
+      it "should create a relationship" do
+        code << "File[a] -> File[b]"
 
-    it "should create a subscription" do
-      code << "File[a] ~> File[b]"
+        expected_relationships << ['a','b']
+      end
 
-      expected_subscriptions << ['a', 'b']
-    end
+      it "should create a subscription" do
+        code << "File[a] ~> File[b]"
 
-    it "should create relationships using title arrays" do
-      code << "File[a,b] -> File[c,d]"
+        expected_subscriptions << ['a', 'b']
+      end
 
-      expected_relationships.concat [
-        ['a', 'c'],
-        ['b', 'c'],
-        ['a', 'd'],
-        ['b', 'd'],
-      ]
-    end
+      it "should create relationships using title arrays" do
+        code << "File[a,b] -> File[c,d]"
 
-    it "should create relationships using collection expressions" do
-      code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
-
-      expected_relationships.concat [
-        ['a', 'd'],
-        ['b', 'd'],
-        ['c', 'd'],
-        ['a', 'e'],
-        ['b', 'e'],
-        ['c', 'e'],
-      ]
-    end
+        expected_relationships.concat [
+          ['a', 'c'],
+          ['b', 'c'],
+          ['a', 'd'],
+          ['b', 'd'],
+        ]
+      end
 
-    it "should create relationships using resource names" do
-      code << "'File[a]' -> 'File[b]'"
+      it "should create relationships using collection expressions" do
+        code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
+
+        expected_relationships.concat [
+          ['a', 'd'],
+          ['b', 'd'],
+          ['c', 'd'],
+          ['a', 'e'],
+          ['b', 'e'],
+          ['c', 'e'],
+        ]
+      end
 
-      expected_relationships << ['a', 'b']
-    end
+      it "should create relationships using resource names" do
+        code << "'File[a]' -> 'File[b]'"
 
-    it "should create relationships using variables" do
-      code << <<-MANIFEST
-        $var = File[a]
-        $var -> File[b]
-      MANIFEST
+        expected_relationships << ['a', 'b']
+      end
 
-      expected_relationships << ['a', 'b']
-    end
+      it "should create relationships using variables" do
+        code << <<-MANIFEST
+          $var = File[a]
+          $var -> File[b]
+        MANIFEST
 
-    it "should create relationships using case statements" do
-      code << <<-MANIFEST
-        $var = 10
-        case $var {
-          10: {
-            file { s1: }
-          }
-          12: {
-            file { s2: }
-          }
-        }
-        ->
-        case $var + 2 {
-          10: {
-            file { t1: }
+        expected_relationships << ['a', 'b']
+      end
+
+      it "should create relationships using case statements" do
+        code << <<-MANIFEST
+          $var = 10
+          case $var {
+            10: {
+              file { s1: }
+            }
+            12: {
+              file { s2: }
+            }
           }
-          12: {
-            file { t2: }
+          ->
+          case $var + 2 {
+            10: {
+              file { t1: }
+            }
+            12: {
+              file { t2: }
+            }
           }
-        }
-      MANIFEST
+        MANIFEST
 
-      expected_relationships << ['s1', 't2']
-    end
+        expected_relationships << ['s1', 't2']
+      end
 
-    it "should create relationships using array members" do
-      code << <<-MANIFEST
-        $var = [ [ [ File[a], File[b] ] ] ]
-        $var[0][0][0] -> $var[0][0][1]
-      MANIFEST
+      it "should create relationships using array members" do
+        code << <<-MANIFEST
+          $var = [ [ [ File[a], File[b] ] ] ]
+          $var[0][0][0] -> $var[0][0][1]
+        MANIFEST
 
-      expected_relationships << ['a', 'b']
-    end
+        expected_relationships << ['a', 'b']
+      end
 
-    it "should create relationships using hash members" do
-      code << <<-MANIFEST
-        $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
-        $var[foo][bar][source] -> $var[foo][bar][target]
-      MANIFEST
+      it "should create relationships using hash members" do
+        code << <<-MANIFEST
+          $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
+          $var[foo][bar][source] -> $var[foo][bar][target]
+        MANIFEST
 
-      expected_relationships << ['a', 'b']
-    end
+        expected_relationships << ['a', 'b']
+      end
 
-    it "should create relationships using resource declarations" do
-      code << "file { l: } -> file { r: }"
+      it "should create relationships using resource declarations" do
+        code << "file { l: } -> file { r: }"
 
-      expected_relationships << ['l', 'r']
+        expected_relationships << ['l', 'r']
+      end
+
+      it "should chain relationships" do
+        code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
+
+        expected_relationships << ['a', 'b'] << ['d', 'c']
+        expected_subscriptions << ['b', 'c'] << ['e', 'd']
+      end
     end
+  end
 
-    it "should chain relationships" do
-      code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
+  describe 'using classic parser' do
+    before :each do
+      Puppet[:parser] = 'current'
+    end
+    it_behaves_like 'the compiler' do
+    end
+  end
 
-      expected_relationships << ['a', 'b'] << ['d', 'c']
-      expected_subscriptions << ['b', 'c'] << ['e', 'd']
+  describe 'using future parser' do
+    # have absolutely no clue to why this is needed - if not required here (even if required by used classes)
+    # the tests will fail with error that rgen/ecore/ruby_to_ecore cannot be found...
+    # TODO: Solve this mystery !
+    require 'rgen/metamodel_builder'
+
+    before :each do
+      Puppet[:parser] = 'future'
     end
+    it_behaves_like 'the compiler'
   end
 end