puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/parser/resource_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::Parser::Resource do
     @resource = Puppet::Parser::Resource.new("whatever", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
   end
 
-  it "should have a array-indexing method for retrieving parameter values" do
+  it "should have an array-indexing method for retrieving parameter values" do
     @resource = mkresource
     @resource[:one].should == "yay"
   end
@@ -181,7 +181,7 @@ describe Puppet::Parser::Resource do
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
 
-      lambda { resource.evaluate }.should raise_error(ArgumentError, /Could not find stage other specified by/)
+      expect { resource.evaluate }.to raise_error(ArgumentError, /Could not find stage other specified by/)
     end
 
     it "should add edges from the class resources to the parent's stage if no stage is specified" do
@@ -328,19 +328,19 @@ describe Puppet::Parser::Resource do
     end
 
     it "should fail on tags containing '*' characters" do
-      lambda { @resource.tag("bad*tag") }.should raise_error(Puppet::ParseError)
+      expect { @resource.tag("bad*tag") }.to raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags starting with '-' characters" do
-      lambda { @resource.tag("-badtag") }.should raise_error(Puppet::ParseError)
+      expect { @resource.tag("-badtag") }.to raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags containing ' ' characters" do
-      lambda { @resource.tag("bad tag") }.should raise_error(Puppet::ParseError)
+      expect { @resource.tag("bad tag") }.to raise_error(Puppet::ParseError)
     end
 
     it "should allow alpha tags" do
-      lambda { @resource.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
+      expect { @resource.tag("good_tag") }.to_not raise_error
     end
   end
 
@@ -354,7 +354,7 @@ describe Puppet::Parser::Resource do
     it "should fail when the override was not created by a parent class" do
       @override.source = "source2"
       @override.source.expects(:child_of?).with("source1").returns(false)
-      lambda { @resource.merge(@override) }.should raise_error(Puppet::ParseError)
+      expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
@@ -550,7 +550,7 @@ describe Puppet::Parser::Resource do
       resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
       resource[:one] = :two
       resource.expects(:validate_parameter).with(:one).raises ArgumentError
-      lambda { resource.send(:validate) }.should raise_error(Puppet::ParseError)
+      expect { resource.send(:validate) }.to raise_error(Puppet::ParseError)
     end
   end
 
@@ -567,7 +567,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should fail when provided a parameter name but no value" do
-      lambda { @resource.set_parameter("myparam") }.should raise_error(ArgumentError)
+      expect { @resource.set_parameter("myparam") }.to raise_error(ArgumentError)
     end
 
     it "should allow parameters to be set to 'false'" do

data/spec/unit/parser/scope_spec.rb

@@ -142,8 +142,8 @@ describe Puppet::Parser::Scope do
     end
 
     it "should fail if invoked with a non-string name" do
-      expect { @scope[:foo] }.to raise_error Puppet::DevError
-      expect { @scope[:foo] = 12 }.to raise_error Puppet::DevError
+      expect { @scope[:foo] }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
+      expect { @scope[:foo] = 12 }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
     end
 
     it "should return nil for unset variables" do
@@ -612,4 +612,47 @@ describe Puppet::Parser::Scope do
       end
     end
   end
+
+  context "when producing a hash of all variables (as used in templates)" do
+    it "should contain all defined variables in the scope" do
+      @scope.setvar("orange", :tangerine)
+      @scope.setvar("pear", :green)
+      @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green }
+    end
+
+    it "should contain variables in all local scopes (#21508)" do
+      @scope.new_ephemeral true
+      @scope.setvar("orange", :tangerine)
+      @scope.setvar("pear", :green)
+      @scope.new_ephemeral true
+      @scope.setvar("apple", :red)
+      @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green, 'apple' => :red }
+    end
+
+    it "should contain all defined variables in the scope and all local scopes" do
+      @scope.setvar("orange", :tangerine)
+      @scope.setvar("pear", :green)
+      @scope.new_ephemeral true
+      @scope.setvar("apple", :red)
+      @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green, 'apple' => :red }
+    end
+
+    it "should not contain varaibles in match scopes (non local emphemeral)" do
+      @scope.new_ephemeral true
+      @scope.setvar("orange", :tangerine)
+      @scope.setvar("pear", :green)
+      @scope.ephemeral_from(/(f)(o)(o)/.match('foo'))
+      @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green }
+    end
+
+    it "should delete values that are :undef in inner scope" do
+      @scope.new_ephemeral true
+      @scope.setvar("orange", :tangerine)
+      @scope.setvar("pear", :green)
+      @scope.new_ephemeral true
+      @scope.setvar("apple", :red)
+      @scope.setvar("orange", :undef)
+      @scope.to_hash.should == {'pear' => :green, 'apple' => :red }
+    end
+  end
 end

data/spec/unit/parser/type_loader_spec.rb

@@ -11,235 +11,219 @@ describe Puppet::Parser::TypeLoader do
   include PuppetSpec::Modules
   include PuppetSpec::Files
 
-  shared_examples_for 'the typeloader' do
-    before do
-      @loader = Puppet::Parser::TypeLoader.new(:myenv)
-      Puppet.expects(:deprecation_warning).never
-    end
+  let(:empty_hostclass) { Puppet::Parser::AST::Hostclass.new('') }
+  let(:loader) { Puppet::Parser::TypeLoader.new(:myenv) }
 
-    it "should support an environment" do
-      loader = Puppet::Parser::TypeLoader.new(:myenv)
-      loader.environment.name.should == :myenv
-    end
+  it "should support an environment" do
+    loader = Puppet::Parser::TypeLoader.new(:myenv)
+    loader.environment.name.should == :myenv
+  end
+
+  it "should include the Environment Helper" do
+    loader.class.ancestors.should be_include(Puppet::Node::Environment::Helper)
+  end
 
-    it "should include the Environment Helper" do
-      @loader.class.ancestors.should be_include(Puppet::Node::Environment::Helper)
+  it "should delegate its known resource types to its environment" do
+    loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
+  end
+
+  describe "when loading names from namespaces" do
+    it "should do nothing if the name to import is an empty string" do
+      loader.try_load_fqname(:hostclass, "").should be_nil
     end
 
-    it "should delegate its known resource types to its environment" do
-      @loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
+    it "should attempt to import each generated name" do
+      loader.expects(:import_from_modules).with("foo/bar").returns([])
+      loader.expects(:import_from_modules).with("foo").returns([])
+      loader.try_load_fqname(:hostclass, "foo::bar")
     end
 
-    describe "when loading names from namespaces" do
-      it "should do nothing if the name to import is an empty string" do
-        @loader.expects(:name2files).never
-        @loader.try_load_fqname(:hostclass, "") { |filename, modname| raise :should_not_occur }.should be_nil
+    it "should attempt to load each possible name going from most to least specific" do
+      path_order = sequence('path')
+      ['foo/bar/baz', 'foo/bar', 'foo'].each do |path|
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).with(path, anything).returns([nil, []]).in_sequence(path_order)
       end
 
-      it "should attempt to import each generated name" do
-        @loader.expects(:import_from_modules).with("foo/bar").returns([])
-        @loader.expects(:import_from_modules).with("foo").returns([])
-        @loader.try_load_fqname(:hostclass, "foo::bar") { |f| false }
-      end
+      loader.try_load_fqname(:hostclass, 'foo::bar::baz')
     end
+  end
 
-    describe "when importing" do
-      before do
-        Puppet::Parser::Files.stubs(:find_manifests_in_modules).returns ["modname", %w{file}]
-        parser_class.any_instance.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
-        parser_class.any_instance.stubs(:file=)
-      end
+  describe "when importing" do
+    let(:stub_parser) { stub 'Parser', :file= => nil, :parse => empty_hostclass }
 
-      it "should return immediately when imports are being ignored" do
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).never
-        Puppet[:ignoreimport] = true
-        @loader.import("foo", "/path").should be_nil
-      end
+    before(:each) do
+      Puppet::Parser::ParserFactory.stubs(:parser).with(anything).returns(stub_parser)
+    end
 
-      it "should find all manifests matching the file or pattern" do
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
-        @loader.import("myfile", "/path")
-      end
+    it "should return immediately when imports are being ignored" do
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).never
+      Puppet[:ignoreimport] = true
+      loader.import("foo", "/path").should be_nil
+    end
 
-      it "should pass the environment when looking for files" do
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, @loader.environment).returns ["modname", %w{one}]
-        @loader.import("myfile", "/path")
-      end
+    it "should find all manifests matching the file or pattern" do
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
+      loader.import("myfile", "/path")
+    end
 
-      it "should fail if no files are found" do
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
-        lambda { @loader.import("myfile", "/path") }.should raise_error(Puppet::ImportError)
-      end
+    it "should pass the environment when looking for files" do
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, loader.environment).returns ["modname", %w{one}]
+      loader.import("myfile", "/path")
+    end
 
-      it "should parse each found file" do
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
-        @loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
-        @loader.import("myfile", "/path")
-      end
+    it "should fail if no files are found" do
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
+      lambda { loader.import("myfile", "/path") }.should raise_error(Puppet::ImportError)
+    end
 
-      it "should not attempt to import files that have already been imported" do
-        @loader = Puppet::Parser::TypeLoader.new(:myenv)
+    it "should parse each found file" do
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
+      loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
+      loader.import("myfile", "/path")
+    end
 
-        Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", %w{/one}]
-        parser_class.any_instance.expects(:parse).once.returns(Puppet::Parser::AST::Hostclass.new(''))
-        other_parser_class.any_instance.expects(:parse).never.returns(Puppet::Parser::AST::Hostclass.new(''))
-        @loader.import("myfile", "/path")
+    it "should not attempt to import files that have already been imported" do
+      loader = Puppet::Parser::TypeLoader.new(:myenv)
 
-        # This will fail if it tries to reimport the file.
-        @loader.import("myfile", "/path")
-      end
+      Puppet::Parser::Files.expects(:find_manifests_in_modules).twice.returns ["modname", %w{/one}]
+      loader.import("myfile", "/path").should_not be_empty
+
+      loader.import("myfile", "/path").should be_empty
     end
+  end
 
-    describe "when importing all" do
-      before do
-        @base = tmpdir("base")
+  describe "when importing all" do
+    before do
+      @base = tmpdir("base")
 
-        # Create two module path directories
-        @modulebase1 = File.join(@base, "first")
-        FileUtils.mkdir_p(@modulebase1)
-        @modulebase2 = File.join(@base, "second")
-        FileUtils.mkdir_p(@modulebase2)
+      # Create two module path directories
+      @modulebase1 = File.join(@base, "first")
+      FileUtils.mkdir_p(@modulebase1)
+      @modulebase2 = File.join(@base, "second")
+      FileUtils.mkdir_p(@modulebase2)
 
-        Puppet[:modulepath] = "#{@modulebase1}#{File::PATH_SEPARATOR}#{@modulebase2}"
-      end
+      Puppet[:modulepath] = "#{@modulebase1}#{File::PATH_SEPARATOR}#{@modulebase2}"
+    end
 
-      def mk_module(basedir, name)
-        PuppetSpec::Modules.create(name, basedir)
-      end
+    def mk_module(basedir, name)
+      PuppetSpec::Modules.create(name, basedir)
+    end
 
-      # We have to pass the base path so that we can
-      # write to modules that are in the second search path
-      def mk_manifests(base, mod, type, files)
-        exts = {"ruby" => ".rb", "puppet" => ".pp"}
-        files.collect do |file|
-          name = mod.name + "::" + file.gsub("/", "::")
-          path = File.join(base, mod.name, "manifests", file + exts[type])
-          FileUtils.mkdir_p(File.split(path)[0])
-
-          # write out the class
-          if type == "ruby"
-            File.open(path, "w") { |f| f.print "hostclass '#{name}' do\nend" }
-          else
-            File.open(path, "w") { |f| f.print "class #{name} {}" }
-          end
-          name
+    # We have to pass the base path so that we can
+    # write to modules that are in the second search path
+    def mk_manifests(base, mod, type, files)
+      exts = {"ruby" => ".rb", "puppet" => ".pp"}
+      files.collect do |file|
+        name = mod.name + "::" + file.gsub("/", "::")
+        path = File.join(base, mod.name, "manifests", file + exts[type])
+        FileUtils.mkdir_p(File.split(path)[0])
+
+        # write out the class
+        if type == "ruby"
+          File.open(path, "w") { |f| f.print "hostclass '#{name}' do\nend" }
+        else
+          File.open(path, "w") { |f| f.print "class #{name} {}" }
         end
+        name
       end
+    end
 
-      it "should load all puppet manifests from all modules in the specified environment" do
-        @module1 = mk_module(@modulebase1, "one")
-        @module2 = mk_module(@modulebase2, "two")
+    it "should load all puppet manifests from all modules in the specified environment" do
+      @module1 = mk_module(@modulebase1, "one")
+      @module2 = mk_module(@modulebase2, "two")
 
-        mk_manifests(@modulebase1, @module1, "puppet", %w{a b})
-        mk_manifests(@modulebase2, @module2, "puppet", %w{c d})
+      mk_manifests(@modulebase1, @module1, "puppet", %w{a b})
+      mk_manifests(@modulebase2, @module2, "puppet", %w{c d})
 
-        @loader.import_all
+      loader.import_all
 
-        @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
-      end
+      loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
+    end
 
-      it "should load all ruby manifests from all modules in the specified environment" do
-        Puppet.expects(:deprecation_warning).at_least(1)
+    it "should load all ruby manifests from all modules in the specified environment" do
+      Puppet.expects(:deprecation_warning).at_least(1)
 
-        @module1 = mk_module(@modulebase1, "one")
-        @module2 = mk_module(@modulebase2, "two")
+      @module1 = mk_module(@modulebase1, "one")
+      @module2 = mk_module(@modulebase2, "two")
 
-        mk_manifests(@modulebase1, @module1, "ruby", %w{a b})
-        mk_manifests(@modulebase2, @module2, "ruby", %w{c d})
+      mk_manifests(@modulebase1, @module1, "ruby", %w{a b})
+      mk_manifests(@modulebase2, @module2, "ruby", %w{c d})
 
-        @loader.import_all
+      loader.import_all
 
-        @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
-      end
+      loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
+    end
 
-      it "should not load manifests from duplicate modules later in the module path" do
-        @module1 = mk_module(@modulebase1, "one")
+    it "should not load manifests from duplicate modules later in the module path" do
+      @module1 = mk_module(@modulebase1, "one")
 
-        # duplicate
-        @module2 = mk_module(@modulebase2, "one")
+      # duplicate
+      @module2 = mk_module(@modulebase2, "one")
 
-        mk_manifests(@modulebase1, @module1, "puppet", %w{a})
-        mk_manifests(@modulebase2, @module2, "puppet", %w{c})
+      mk_manifests(@modulebase1, @module1, "puppet", %w{a})
+      mk_manifests(@modulebase2, @module2, "puppet", %w{c})
 
-        @loader.import_all
+      loader.import_all
 
-        @loader.environment.known_resource_types.hostclass("one::c").should be_nil
-      end
+      loader.environment.known_resource_types.hostclass("one::c").should be_nil
+    end
 
-      it "should load manifests from subdirectories" do
-        @module1 = mk_module(@modulebase1, "one")
+    it "should load manifests from subdirectories" do
+      @module1 = mk_module(@modulebase1, "one")
 
-        mk_manifests(@modulebase1, @module1, "puppet", %w{a a/b a/b/c})
+      mk_manifests(@modulebase1, @module1, "puppet", %w{a a/b a/b/c})
 
-        @loader.import_all
+      loader.import_all
 
-        @loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
-        @loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
-      end
+      loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
     end
 
-    describe "when parsing a file" do
-      before do
-        @parser = Puppet::Parser::ParserFactory.parser(@loader.environment)
-        @parser.class.should == parser_class
-        @parser.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
-        @parser.stubs(:file=)
-        Puppet::Parser::ParserFactory.stubs(:parser).with(@loader.environment).returns @parser
-      end
+    it "should skip modules that don't have manifests" do
+      @module1 = mk_module(@modulebase1, "one")
+      @module2 = mk_module(@modulebase2, "two")
+      mk_manifests(@modulebase2, @module2, "ruby", %w{c d})
 
-      it "should create a new parser instance for each file using the current environment" do
-        Puppet::Parser::ParserFactory.expects(:parser).with(@loader.environment).returns @parser
-        @loader.parse_file("/my/file")
-      end
+      loader.import_all
 
-      it "should assign the parser its file and parse" do
-        @parser.expects(:file=).with("/my/file")
-        @parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
-        @loader.parse_file("/my/file")
-      end
+      loader.environment.known_resource_types.hostclass("one::a").should be_nil
+      loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+      loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
     end
+  end
 
-    it "should be able to add classes to the current resource type collection" do
-      file = tmpfile("simple_file.pp")
-      File.open(file, "w") { |f| f.puts "class foo {}" }
-      @loader.import(File.basename(file), File.dirname(file))
+  describe "when parsing a file" do
+    it "should create a new parser instance for each file using the current environment" do
+      parser = stub 'Parser', :file= => nil, :parse => empty_hostclass
 
-      @loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
-    end
+      Puppet::Parser::ParserFactory.expects(:parser).twice.with(loader.environment).returns(parser)
 
-    describe "when deciding where to look for files" do
-      { 'foo' => ['foo'],
-        'foo::bar' => ['foo/bar', 'foo'],
-        'foo::bar::baz' => ['foo/bar/baz', 'foo/bar', 'foo']
-      }.each do |fqname, expected_paths|
-        it "should look for #{fqname.inspect} in #{expected_paths.inspect}" do
-          @loader.instance_eval { name2files(fqname) }.should == expected_paths
-        end
-      end
-    end
-  end
-  describe 'when using the classic parser' do
-    before :each do
-      Puppet[:parser] = 'current'
+      loader.parse_file("/my/file")
+      loader.parse_file("/my/other_file")
     end
-    it_should_behave_like 'the typeloader' do
-      let(:parser_class) { Puppet::Parser::Parser}
-      let(:other_parser_class) { Puppet::Parser::EParserAdapter}
+
+    it "should assign the parser its file and parse" do
+      parser = mock 'parser'
+
+      Puppet::Parser::ParserFactory.expects(:parser).with(loader.environment).returns(parser)
+      parser.expects(:file=).with("/my/file")
+      parser.expects(:parse).returns(empty_hostclass)
+
+      loader.parse_file("/my/file")
     end
   end
-  describe 'when using the future parser' do
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-    it_should_behave_like 'the typeloader' do
-      let(:parser_class) { Puppet::Parser::EParserAdapter}
-      let(:other_parser_class) { Puppet::Parser::Parser}
-    end
+
+  it "should be able to add classes to the current resource type collection" do
+    file = tmpfile("simple_file.pp")
+    File.open(file, "w") { |f| f.puts "class foo {}" }
+    loader.import(File.basename(file), File.dirname(file))
+
+    loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
   end
 end