puppet 2.7.13 → 2.7.14

data/spec/unit/parser/functions/generate_spec.rb

@@ -41,11 +41,7 @@ describe "the generate function" do
     scope.function_generate([command]).should == 'yay'
   end
 
-  describe "on Windows" do
-    before :each do
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
-    end
-
+  describe "on Windows", :as_platform => :windows do
     it "should accept lower-case drive letters" do
       command = 'd:/command/foo'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
@@ -73,11 +69,7 @@ describe "the generate function" do
     end
   end
 
-  describe "on non-Windows" do
-    before :each do
-      Puppet.features.stubs(:microsoft_windows?).returns(false)
-    end
-
+  describe "on non-Windows", :as_platform => :posix do
     it "should reject backslashes" do
       lambda { scope.function_generate(['/com\\mand']) }.should raise_error(Puppet::ParseError)
     end

data/spec/unit/parser/scope_spec.rb

@@ -1,13 +1,13 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
+require 'puppet_spec/compiler'
 
 describe Puppet::Parser::Scope do
   before :each do
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
     @scope = Puppet::Parser::Scope.new
     @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+    @scope.source = Puppet::Resource::Type.new(:node, :foo)
+    @topscope = @scope.compiler.topscope
     @scope.parent = @topscope
   end
 
@@ -92,14 +92,6 @@ describe Puppet::Parser::Scope do
 
       Puppet::Parser::Scope.new.singleton_class.ancestors.should be_include(mod)
     end
-
-    it "should remember if it is dynamic" do
-      (!!Puppet::Parser::Scope.new(:dynamic => true).dynamic).should == true
-    end
-
-    it "should assume it is not dynamic" do
-      (!Puppet::Parser::Scope.new.dynamic).should == true
-    end
   end
 
   describe "when looking up a variable" do
@@ -128,10 +120,36 @@ describe Puppet::Parser::Scope do
       @scope.lookupvar("var").should == "childval"
     end
 
+    it "should be able to look up intermediary variables in parent scopes (DEPRECATED)" do
+      topscope_value = "parentval"
+      dynamic_value = "childval"
+
+      Puppet.expects(:deprecation_warning).with("Dynamic lookup of $var2 is deprecated. For more information, see http://docs.puppetlabs.com/guides/scope_and_puppet.html. To see the change in behavior, use the --debug flag.")
+      Puppet.expects(:debug).with("Currently $var2 is #{dynamic_value.inspect}")
+      Puppet.expects(:debug).with("In the future $var2 will be #{topscope_value.inspect}")
+
+      thirdscope = Puppet::Parser::Scope.new(:parent => @scope, :source => Puppet::Resource::Type.new(:hostclass, :foo, :module_name => "foo"))
+
+      @topscope.setvar("var2", topscope_value)
+      @scope.setvar("var2", dynamic_value)
+      thirdscope.lookupvar("var2").should == dynamic_value
+    end
+
+    it "should call out when the new variable lookup will not find a value (DEPRECATED)" do
+      dynamic_value = "childval"
+
+      Puppet.expects(:deprecation_warning).with("Dynamic lookup of $var2 is deprecated. For more information, see http://docs.puppetlabs.com/guides/scope_and_puppet.html. To see the change in behavior, use the --debug flag.")
+      Puppet.expects(:debug).with("Currently $var2 is #{dynamic_value.inspect}")
+      Puppet.expects(:debug).with("In the future $var2 will be undefined")
+
+      thirdscope = Puppet::Parser::Scope.new(:parent => @scope, :source => Puppet::Resource::Type.new(:hostclass, :foo, :module_name => "foo"))
+
+      @scope.setvar("var2", dynamic_value)
+      thirdscope.lookupvar("var2").should == dynamic_value
+    end
+
     describe "and the variable is qualified" do
-      before do
-        @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foonode"))
-        @scope.compiler = @compiler
+      before :each do
         @known_resource_types = @scope.known_resource_types
       end
 
@@ -151,6 +169,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up explicitly fully qualified variables from main" do
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("")
 
         other_scope.setvar("othervar", "otherval")
@@ -159,6 +178,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up explicitly fully qualified variables from other scopes" do
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other")
 
         other_scope.setvar("var", "otherval")
@@ -167,6 +187,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up deeply qualified variables" do
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other::deep::klass")
 
         other_scope.setvar("var", "otherval")
@@ -175,28 +196,33 @@ describe Puppet::Parser::Scope do
       end
 
       it "should return ':undefined' for qualified variables that cannot be found in other classes" do
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other::deep::klass")
 
         @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should warn and return ':undefined' for qualified variables whose classes have not been evaluated" do
+        Puppet.expects(:deprecation_warning).never
         klass = newclass("other::deep::klass")
-        @scope.expects(:warning)
+        @scope.expects(:warning).at_least_once
         @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should warn and return ':undefined' for qualified variables whose classes do not exist" do
-        @scope.expects(:warning)
+        Puppet.expects(:deprecation_warning).never
+        @scope.expects(:warning).at_least_once
         @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should return ':undefined' when asked for a non-string qualified variable from a class that does not exist" do
+        Puppet.expects(:deprecation_warning).never
         @scope.stubs(:warning)
         @scope.lookupvar("other::deep::klass::var").should == :undefined
       end
 
       it "should return ':undefined' when asked for a non-string qualified variable from a class that has not been evaluated" do
+        Puppet.expects(:deprecation_warning).never
         @scope.stubs(:warning)
         klass = newclass("other::deep::klass")
         @scope.lookupvar("other::deep::klass::var").should == :undefined
@@ -204,6 +230,309 @@ describe Puppet::Parser::Scope do
     end
   end
 
+  describe "when mixing inheritence and inclusion" do
+    include PuppetSpec::Compiler
+
+    def expect_the_message_to_be(message) 
+      catalog = compile_to_catalog(yield)
+      catalog.resource('Notify', 'something')[:message].should == message
+    end
+
+    context "deprecated scoping" do
+      before :each do
+        Puppet.expects(:deprecation_warning)
+      end
+
+      it "prefers values in its included scope over those from the node (DEPRECATED)" do
+        expect_the_message_to_be('baz_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 values in its included scope (DEPRECATED)" do
+        expect_the_message_to_be('baz_msg') 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 "recognizes a dynamically scoped boolean (DEPRECATED)" do
+        expect_the_message_to_be(true) do <<-MANIFEST
+            node default {
+              $var = false
+              include baz
+            }
+            class foo {
+            }
+            class bar inherits foo {
+              notify { 'something': message => $var, }
+            }
+            class baz {
+              $var = true
+              include bar
+            }
+          MANIFEST
+        end
+      end
+    end
+
+    context "supported scoping" do
+      before :each do
+        Puppet.expects(:deprecation_warning).never
+      end
+
+      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 "should find 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 "should find 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 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
+    end
+  end
+
   describe "when setvar is called with append=true" do
     it "should raise error if the variable is already defined in this scope" do
       @scope.setvar("var","1", :append => false)