puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/integration/parser/ruby_manifest_spec.rb

@@ -11,10 +11,6 @@ describe "Pure ruby manifests" do
     @test_dir = tmpdir('ruby_manifest_test')
   end
 
-  after do
-    Puppet.settings.clear
-  end
-
   def write_file(name, contents)
     path = File.join(@test_dir, name)
     File.open(path, "w") { |f| f.write(contents) }

data/spec/integration/parser/scope_spec.rb

@@ -39,23 +39,27 @@ describe "Two step scoping for variables" do
       Puppet[:parser] = 'future'
     end
 
-    describe "using plussignment to change in a new scope" do
-      it "does not change a string in the parent scope" do
-        # Expects to be able to concatenate string using +=
+    describe "using unsupported operators" do
+      it "issues an error for +=" do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new('the node'))
-              $var = "top_msg"
-              class override {
-                $var += "override"
-                include foo
-              }
-              class foo {
-                notify { 'something': message => $var, }
+          catalog = compile_to_catalog(<<-MANIFEST)
+              $var = ["top_msg"]
+              node default {
+                $var += ["override"]
               }
+            MANIFEST
+        end.to raise_error(/The operator '\+=' is no longer supported/)
+      end
 
-              include override
+      it "issues an error for -=" do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+              $var = ["top_msg"]
+              node default {
+                $var -= ["top_msg"]
+              }
             MANIFEST
-        end.to raise_error(/The value 'top_msg' cannot be converted to Numeric/)
+        end.to raise_error(/The operator '-=' is no longer supported/)
       end
     end
 
@@ -184,54 +188,6 @@ describe "Two step scoping for variables" do
     end
 
     describe "when using shadowing and inheritance" do
-      it "finds value define in the inherited node" do
-        expect_the_message_to_be('parent_msg') do <<-MANIFEST
-            $var = "top_msg"
-            node parent {
-              $var = "parent_msg"
-            }
-            node default inherits parent {
-              include foo
-            }
-            class foo {
-              notify { 'something': message => $var, }
-            }
-          MANIFEST
-        end
-      end
-
-      it "finds top scope when the class is included before the node defines the var" do
-        expect_the_message_to_be('top_msg') do <<-MANIFEST
-            $var = "top_msg"
-            node parent {
-              include foo
-            }
-            node default inherits parent {
-              $var = "default_msg"
-            }
-            class foo {
-              notify { 'something': message => $var, }
-            }
-          MANIFEST
-        end
-      end
-
-      it "finds top scope when the class is included before the node defines the var" do
-        expect_the_message_to_be('top_msg') do <<-MANIFEST
-            $var = "top_msg"
-            node parent {
-              include foo
-            }
-            node default inherits parent {
-              $var = "default_msg"
-            }
-            class foo {
-              notify { 'something': message => $var, }
-            }
-          MANIFEST
-        end
-      end
-
       it "finds values in its local scope" do
         expect_the_message_to_be('local_msg') do <<-MANIFEST
             node default {
@@ -363,7 +319,7 @@ describe "Two step scoping for variables" do
                 $var = "inner baz"
               }
 
-              class bar inherits baz {
+              class bar inherits foo::baz {
                 notify { 'something': message => $var, }
               }
             }
@@ -651,80 +607,6 @@ describe "Two step scoping for variables" do
       end
     end
 
-    describe "using plussignment to change in a new scope" do
-
-      it "does not change an array in the parent scope" do
-        expect_the_message_to_be('top_msg') do <<-MANIFEST
-            $var = ["top_msg"]
-            class override {
-              $var += ["override"]
-              include foo
-            }
-            class foo {
-              notify { 'something': message => $var, }
-            }
-
-            include override
-          MANIFEST
-        end
-      end
-
-      it "concatenates two arrays" do
-        expect_the_message_to_be(['top_msg', 'override']) do <<-MANIFEST
-            $var = ["top_msg"]
-            class override {
-              $var += ["override"]
-              notify { 'something': message => $var, }
-            }
-
-            include override
-          MANIFEST
-        end
-      end
-
-      it "leaves an array of arrays unflattened" do
-        expect_the_message_to_be([['top_msg'], ['override']]) do <<-MANIFEST
-            $var = [["top_msg"]]
-            class override {
-              $var += [["override"]]
-              notify { 'something': message => $var, }
-            }
-
-            include override
-          MANIFEST
-        end
-      end
-
-      it "does not change a hash in the parent scope" do
-        expect_the_message_to_be({"key"=>"top_msg"}) do <<-MANIFEST
-            $var = { "key" => "top_msg" }
-            class override {
-              $var += { "other" => "override" }
-              include foo
-            }
-            class foo {
-              notify { 'something': message => $var, }
-            }
-
-            include override
-          MANIFEST
-        end
-      end
-
-      it "replaces a value of a key in the hash instead of merging the values" do
-        expect_the_message_to_be({"key"=>"override"}) do <<-MANIFEST
-            $var = { "key" => "top_msg" }
-            class override {
-              $var += { "key" => "override" }
-              notify { 'something': message => $var, }
-            }
-
-            include override
-          MANIFEST
-        end
-      end
-    end
-
     describe "when using an enc" do
       it "places enc parameters in top scope" do
         enc_node = Puppet::Node.new("the node", { :parameters => { "var" => 'from_enc' } })
@@ -757,20 +639,16 @@ describe "Two step scoping for variables" do
         end
       end
 
-      it "evaluates enc classes in the node scope when there is a matching node" do
-        enc_node = Puppet::Node.new("the_node", { :classes => ['foo'] })
-
-        expect_the_message_to_be('from matching node', enc_node) do <<-MANIFEST
-            node inherited {
-              $var = "from inherited"
-            }
+      it "overrides enc variables from a node scope var" do
+        enc_node = Puppet::Node.new("the_node", { :classes => ['foo'], :parameters => { 'enc_var' => 'Set from ENC.' } })
 
-            node the_node inherits inherited {
-              $var = "from matching node"
+        expect_the_message_to_be('ENC overridden in node', enc_node) do <<-MANIFEST
+            node the_node {
+              $enc_var = "ENC overridden in node"
             }
 
             class foo {
-              notify { 'something': message => $var, }
+              notify { 'something': message => $enc_var, }
             }
           MANIFEST
         end
@@ -782,7 +660,74 @@ describe "Two step scoping for variables" do
     before :each do
       Puppet[:parser] = 'current'
     end
-    it_behaves_like 'the scope' do
+
+    it_behaves_like 'the scope'
+
+    it "finds value define in the inherited node" do
+      expect_the_message_to_be('parent_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node parent {
+            $var = "parent_msg"
+          }
+          node default inherits parent {
+            include foo
+          }
+          class foo {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds top scope when the class is included before the node defines the var" do
+      expect_the_message_to_be('top_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node parent {
+            include foo
+          }
+          node default inherits parent {
+            $var = "default_msg"
+          }
+          class foo {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds top scope when the class is included before the node defines the var" do
+      expect_the_message_to_be('top_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node parent {
+            include foo
+          }
+          node default inherits parent {
+            $var = "default_msg"
+          }
+          class foo {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "evaluates enc classes in the node scope when there is a matching node" do
+      enc_node = Puppet::Node.new("the_node", { :classes => ['foo'] })
+
+      expect_the_message_to_be('from matching node', enc_node) do <<-MANIFEST
+          node inherited {
+            $var = "from inherited"
+          }
+
+          node the_node inherits inherited {
+            $var = "from matching node"
+          }
+
+          class foo {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
     end
   end
 
@@ -790,9 +735,7 @@ describe "Two step scoping for variables" do
     before :each do
       Puppet[:parser] = 'future'
     end
-    it_behaves_like 'the scope' do
-    end
-  end
 
+    it_behaves_like 'the scope'
+  end
 end
-

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

@@ -2,9 +2,11 @@
 
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
+require 'puppet_spec/compiler'
 
 describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   before :each do
     Puppet::Type.type(:cron).stubs(:defaultprovider).returns described_class
@@ -33,20 +35,6 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
     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
-
-    # the resources are not properly contained and generated resources
-    # will end up with dangling edges without this stubbing:
-    catalog.stubs(:container_of).returns resources[0]
-    catalog.apply
-  end
-
   def expect_output(fixture_name)
     File.read(crontab_user1).should == File.read(my_fixture(fixture_name))
   end
@@ -54,56 +42,53 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
   describe "when managing a cron entry" do
 
     it "should be able to purge unmanaged entries" do
-      resource = Puppet::Type.type(:cron).new(
-        :name        => 'only managed entry',
-        :ensure      => :present,
-        :command     => '/bin/true',
-        :target      => crontab_user1,
-        :user        => crontab_user1
-      )
-      resources = Puppet::Type.type(:resources).new(
-        :name        => 'cron',
-        :purge       => 'true'
-      )
-      run_in_catalog(resource, resources)
+      apply_with_error_check(<<-MANIFEST)
+      cron {
+        'only managed entry':
+          ensure      => 'present',
+          command     => '/bin/true',
+          target      => '#{crontab_user1}',
+      }
+      resources { 'cron': purge => 'true' }
+      MANIFEST
       expect_output('purged')
     end
 
     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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'no_such_entry':
+            ensure => 'absent',
+            target => '#{crontab_user1}',
+        }
+        MANIFEST
         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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            ensure => 'absent',
+            target => '#{crontab_user1}',
+        }
+        MANIFEST
         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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          '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}',
+        }
+        MANIFEST
         expect_output('remove_unnamed_resource')
       end
     end
@@ -112,137 +97,141 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
 
       context "and no command specified" do
         it "should work if the resource is already present" do
-          resource = Puppet::Type.type(:cron).new(
-            :name    => 'My daily failure',
-            :special => 'daily',
-            :target  => crontab_user1,
-            :user    => crontab_user1
-          )
-          run_in_catalog(resource)
+          apply_with_error_check(<<-MANIFEST)
+          cron {
+            'My daily failure':
+              special => 'daily',
+              target  => '#{crontab_user1}',
+          }
+          MANIFEST
           expect_output('crontab_user1')
         end
         it "should fail if the resource needs creating" do
-          resource = Puppet::Type.type(:cron).new(
-            :name    => 'Entirely new resource',
-            :special => 'daily',
-            :target  => crontab_user1,
-            :user    => crontab_user1
-          )
-          resource.expects(:err).with(regexp_matches(/no command/))
-          run_in_catalog(resource)
+          manifest = <<-MANIFEST
+          cron {
+            'Entirely new resource':
+              special => 'daily',
+              target  => '#{crontab_user1}',
+          }
+          MANIFEST
+          apply_compiled_manifest(manifest) do |res|
+            if res.ref == 'Cron[Entirely new resource]'
+              res.expects(:err).with(regexp_matches(/no command/))
+            else
+              res.expects(:err).never
+            end
+          end
         end
       end
 
       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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            special => 'daily',
+            command => '/bin/false',
+            target  => '#{crontab_user1}',
+        }
+        MANIFEST
         expect_output('crontab_user1')
       end
 
       it "should work correctly when managing 'target' but not 'user'" do
-        resource = Puppet::Type.type(:cron).new(
-          :name    => 'My daily failure',
-          :special => 'daily',
-          :command => '/bin/false',
-          :target  => crontab_user1
-        )
-        run_in_catalog(resource)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            special => 'daily',
+            command => '/bin/false',
+            target  => '#{crontab_user1}',
+        }
+        MANIFEST
         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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'no_such_named_resource_in_crontab':
+            ensure   => present,
+            minute   => [ '17-19', '22' ],
+            hour     => [ '0-23/2' ],
+            command  => '/bin/unnamed_regular_command',
+            target   => '#{crontab_user1}',
+        }
+        MANIFEST
         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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'new entry':
+            ensure      => present,
+            minute      => '12',
+            weekday     => 'Tue',
+            command     => '/bin/new',
+            environment => [
+              'MAILTO=""',
+              'SHELL=/bin/bash'
+            ],
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
         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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'new special entry':
+            ensure      => present,
+            special     => 'reboot',
+            command     => 'echo "Booted" 1>&2',
+            environment => 'MAILTO=bob@company.com',
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
         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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'Monthly job':
+            ensure      => present,
+            special     => 'monthly',
+            #minute => ['22'],
+            command     => '/usr/bin/monthly',
+            environment => [],
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
         expect_output('modify_entry')
       end
       it "should change a special schedule to numeric if requested" do
-        resource = Puppet::Type.type(:cron).new(
-          :name        => 'My daily failure',
-          :special     => 'absent',
-          :command     => '/bin/false',
-          :target      => crontab_user1,
-          :user        => crontab_user1
-        )
-        run_in_catalog(resource)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            special     => 'absent',
+            command     => '/bin/false',
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
         expect_output('unspecialized')
       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)
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'foo':
+            ensure => absent,
+            target => '#{crontab_user1}';
+          'My daily failure':
+            special      => 'daily',
+            command      => "/bin/false",
+            target       => '#{crontab_user2}',
+        }
+        MANIFEST
         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