puppet 2.7.26 → 3.0.0.rc4

data/spec/integration/network/formats_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/network/formats'
@@ -44,7 +44,7 @@ describe Puppet::Network::FormatHandler.format(:s) do
   end
 end
 
-describe Puppet::Network::FormatHandler.format(:pson), :'fails_on_ruby_1.9.2' => true do
+describe Puppet::Network::FormatHandler.format(:pson) do
   describe "when pson is absent", :if => (! Puppet.features.pson?) do
 
     before do
@@ -75,8 +75,6 @@ describe Puppet::Network::FormatHandler.format(:pson), :'fails_on_ruby_1.9.2' =>
     end
 
     it "should be able to render multiple instances to pson" do
-      Puppet.features.add(:pson, :libs => ["pson"])
-
       one = PsonIntTest.new("one")
       two = PsonIntTest.new("two")
 

data/spec/integration/network/server/mongrel_spec.rb

@@ -1,9 +1,9 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/network/server'
 require 'net/http'
 
-describe Puppet::Network::Server, :'fails_on_ruby_1.9.2' => true do
+describe Puppet::Network::Server do
   describe "when using mongrel", :if => Puppet.features.mongrel? do
 
     # This reduces the odds of conflicting port numbers between concurrent runs
@@ -23,14 +23,6 @@ describe Puppet::Network::Server, :'fails_on_ruby_1.9.2' => true do
       @server.unlisten if @server.listening?
     end
 
-    describe "before listening" do
-      it "should not be reachable at the specified address and port" do
-        expect {
-          Net::HTTP.get('127.0.0.1', '/', port)
-        }.to raise_error(Errno::ECONNREFUSED)
-      end
-    end
-
     describe "when listening" do
       it "should be reachable on the specified address and port" do
         @server.listen

data/spec/integration/network/server/webrick_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/network/server'
 require 'puppet/ssl/certificate_authority'

data/spec/integration/node/environment_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet_spec/files'

data/spec/integration/node/facts_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Node::Facts do
@@ -10,7 +10,7 @@ describe Puppet::Node::Facts do
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
       terminus.stubs :save
 
-      Puppet::Node.indirection.expects(:expire).with("me")
+      Puppet::Node.indirection.expects(:expire).with("me", optionally(instance_of(Hash)))
 
       facts = Puppet::Node::Facts.new("me")
       Puppet::Node::Facts.indirection.save(facts)

data/spec/integration/node_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/node'
@@ -13,19 +13,6 @@ describe Puppet::Node do
       @node = Puppet::Node.new(@name)
     end
 
-    it "should be able to use the exec terminus" do
-      Puppet::Node.indirection.stubs(:terminus_class).returns :exec
-
-      # Load now so we can stub
-      terminus = Puppet::Node.indirection.terminus(:exec)
-
-      terminus.expects(:query).with(@name).returns "myresults"
-      terminus.expects(:translate).with(@name, "myresults").returns "translated_results"
-      terminus.expects(:create_node).with(@name, "translated_results").returns @node
-
-      Puppet::Node.indirection.find(@name).should equal(@node)
-    end
-
     it "should be able to use the yaml terminus" do
       Puppet::Node.indirection.stubs(:terminus_class).returns :yaml
 
@@ -42,7 +29,7 @@ describe Puppet::Node do
       Puppet::Node.indirection.terminus(:ldap).should_not be_nil
     end
 
-    it "should be able to use the plain terminus", :'fails_on_ruby_1.9.2' => true do
+    it "should be able to use the plain terminus" do
       Puppet::Node.indirection.stubs(:terminus_class).returns :plain
 
       # Load now, before we stub the exists? method.

data/spec/integration/parser/collector_spec.rb

@@ -1,11 +1,11 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/parser/collector'
 
 describe Puppet::Parser::Collector do
   before do
-    @scope = Puppet::Parser::Scope.new(:compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode")))
+    @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("mynode")))
 
     @resource = Puppet::Parser::Resource.new("file", "/tmp/testing", :scope => @scope, :source => "fakesource")
     {:owner => "root", :group => "bin", :mode => "644"}.each do |param, value|

data/spec/integration/parser/compiler_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Compiler do
@@ -13,18 +13,19 @@ describe Puppet::Parser::Compiler do
     Puppet.settings.clear
   end
 
-  it "should be able to determine the configuration version from a local version control repository", :fails_on_windows => true 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
+  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
 
-    # REMIND: this fails on Windows due to #8410, re-enable the test when it is fixed
-    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::Parser.new "development"
+      @compiler = Puppet::Parser::Compiler.new(@node)
 
-    @compiler.catalog.version.should == version
+      @compiler.catalog.version.should == version
+    end
   end
 
   it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
@@ -90,6 +91,33 @@ describe Puppet::Parser::Compiler do
       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
 
   it "should recompute the version after input files are re-parsed" do
     Puppet[:code] = 'class foo { }'

data/spec/integration/parser/functions/require_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "The require function" do

data/spec/integration/parser/functions_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Functions do

data/spec/integration/parser/parser_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Parser do

data/spec/integration/parser/ruby_manifest_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'tempfile'

data/spec/integration/parser/scope_spec.rb

@@ -0,0 +1,608 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "Two step scoping for variables" do
+  include PuppetSpec::Compiler
+
+  def expect_the_message_to_be(message, node = Puppet::Node.new('the node')) 
+    catalog = compile_to_catalog(yield, node)
+    catalog.resource('Notify', 'something')[:message].should == message
+  end
+
+  before :each do
+    Puppet.expects(:deprecation_warning).never
+  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 {
+            include baz
+          }
+          class foo {
+          }
+          class bar inherits foo {
+            $var = "local_msg"
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in its inherited scope" do
+      expect_the_message_to_be('foo_msg') do <<-MANIFEST
+          node default {
+            include baz
+          }
+          class foo {
+            $var = "foo_msg"
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "prefers values in its local scope over values in the inherited scope" do
+      expect_the_message_to_be('local_msg') do <<-MANIFEST
+          include bar
+
+          class foo {
+            $var = "inherited"
+          }
+
+          class bar inherits foo {
+            $var = "local_msg"
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds a qualified variable by following parent scopes of the specified scope" do
+      expect_the_message_to_be("from node") do <<-MANIFEST
+          class c {
+            notify { 'something': message => "$a::b" }
+          }
+          
+          class a { }
+
+          node default {
+            $b = "from node"
+            include a
+            include c
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in its inherited scope when the inherited class is qualified to the top" do
+      expect_the_message_to_be('foo_msg') do <<-MANIFEST
+          node default {
+            include baz
+          }
+          class foo {
+            $var = "foo_msg"
+          }
+          class bar inherits ::foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "prefers values in its local scope over values in the inherited scope when the inherited class is fully qualified" do
+      expect_the_message_to_be('local_msg') do <<-MANIFEST
+          include bar
+
+          class foo {
+            $var = "inherited"
+          }
+
+          class bar inherits ::foo {
+            $var = "local_msg"
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in top scope when the inherited class is qualified to the top" do
+      expect_the_message_to_be('top msg') do <<-MANIFEST
+          $var = "top msg"
+          class foo {
+          }
+
+          class bar inherits ::foo {
+            notify { 'something': message => $var, }
+          }
+
+          include bar
+        MANIFEST
+      end
+    end
+
+    it "finds values in its inherited scope when the inherited class is a nested class that shadows another class at the top" do
+      expect_the_message_to_be('inner baz') do <<-MANIFEST
+          node default {
+            include foo::bar
+          }
+          class baz {
+            $var = "top baz"
+          }
+          class foo {
+            class baz {
+              $var = "inner baz"
+            }
+
+            class bar inherits baz {
+              notify { 'something': message => $var, }
+            }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in its inherited scope when the inherited class is qualified to a nested class and qualified to the top" do
+      expect_the_message_to_be('top baz') do <<-MANIFEST
+          node default {
+            include foo::bar
+          }
+          class baz {
+            $var = "top baz"
+          }
+          class foo {
+            class baz {
+              $var = "inner baz"
+            }
+
+            class bar inherits ::baz {
+              notify { 'something': message => $var, }
+            }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in its inherited scope when the inherited class is qualified" do
+      expect_the_message_to_be('foo_msg') do <<-MANIFEST
+          node default {
+            include bar
+          }
+          class foo {
+            class baz {
+              $var = "foo_msg"
+            }
+          }
+          class bar inherits foo::baz {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "prefers values in its inherited scope over those in the node (with intermediate inclusion)" do
+      expect_the_message_to_be('foo_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include baz
+          }
+          class foo {
+            $var = "foo_msg"
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "prefers values in its inherited scope over those in the node (without intermediate inclusion)" do
+      expect_the_message_to_be('foo_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include bar
+          }
+          class foo {
+            $var = "foo_msg"
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "prefers values in its inherited scope over those from where it is included" do
+      expect_the_message_to_be('foo_msg') do <<-MANIFEST
+          node default {
+            include baz
+          }
+          class foo {
+            $var = "foo_msg"
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            $var = "baz_msg"
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "does not used variables from classes included in the inherited scope" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include bar
+          }
+          class quux {
+            $var = "quux_msg"
+          }
+          class foo inherits quux {
+          }
+          class baz {
+            include foo
+          }
+          class bar inherits baz {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "does not use a variable from a scope lexically enclosing it" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include other::bar
+          }
+          class other {
+            $var = "other_msg"
+            class bar {
+              notify { 'something': message => $var, }
+            }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in its node scope" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include baz
+          }
+          class foo {
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds values in its top scope" do
+      expect_the_message_to_be('top_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node default {
+            include baz
+          }
+          class foo {
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "prefers variables from the node over those in the top scope" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node default {
+            $var = "node_msg"
+            include foo
+          }
+          class foo {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds top scope variables referenced inside a defined type" do
+      expect_the_message_to_be('top_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node default {
+            foo { "testing": }
+          }
+          define foo() {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds node scope variables referenced inside a defined type" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          $var = "top_msg"
+          node default {
+            $var = "node_msg"
+            foo { "testing": }
+          }
+          define foo() {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+  end
+
+  describe "in situations that used to have dynamic lookup" do
+    it "ignores the dynamic value of the var" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include foo
+          }
+          class baz {
+            $var = "baz_msg"
+            include bar
+          }
+          class foo inherits baz {
+          }
+          class bar {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds nil when the only set variable is in the dynamic scope" do
+      expect_the_message_to_be(nil) do <<-MANIFEST
+          node default {
+            include baz
+          }
+          class foo {
+          }
+          class bar inherits foo {
+            notify { 'something': message => $var, }
+          }
+          class baz {
+            $var = "baz_msg"
+            include bar
+          }
+        MANIFEST
+      end
+    end
+
+    it "ignores the value in the dynamic scope for a defined type" do
+      expect_the_message_to_be('node_msg') do <<-MANIFEST
+          node default {
+            $var = "node_msg"
+            include foo
+          }
+          class foo {
+            $var = "foo_msg"
+            bar { "testing": }
+          }
+          define bar() {
+            notify { 'something': message => $var, }
+          }
+        MANIFEST
+      end
+    end
+  end
+
+  describe "using plussignment to change in a new scope" do
+    it "does not change a string 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 "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' } })
+
+      expect_the_message_to_be('from_enc', enc_node) do <<-MANIFEST
+          notify { 'something': message => $var, }
+        MANIFEST
+      end
+    end
+
+    it "does not allow the enc to specify an existing top scope var" do
+      enc_node = Puppet::Node.new("the_node", { :parameters => { "var" => 'from_enc' } })
+
+      expect {
+        compile_to_catalog("$var = 'top scope'", enc_node)
+      }.to raise_error(
+        Puppet::Error,
+        "Cannot reassign variable var at line 1 on node the_node"
+      )
+    end
+
+    it "evaluates enc classes in top scope when there is no node" do
+      enc_node = Puppet::Node.new("the node", { :classes => ['foo'], :parameters => { "var" => 'from_enc' } })
+
+      expect_the_message_to_be('from_enc', enc_node) do <<-MANIFEST
+          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
+end
+