puppet 2.6.0 → 2.6.1

data/spec/unit/parser/ast/resource_spec.rb

@@ -113,6 +113,13 @@ describe Puppet::Parser::AST::Resource do
       resource("file").evaluate(@twoscope)[0].type.should == "File"
     end
 
+    it "should correctly generate resources that can look up defined classes by title" do
+      @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
+      res = resource("class").evaluate(@twoscope)[0]
+      res.type.should == "Class"
+      res.title.should == "Myresource"
+    end
+
     it "should fail for resource types that do not exist" do
       lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
     end

data/spec/unit/parser/compiler_spec.rb

@@ -430,7 +430,18 @@ describe Puppet::Parser::Compiler do
       lambda { @compiler.add_resource(@scope, resource) }.should raise_error(ArgumentError)
     end
 
-    it "should add edges from the class resources to the main stage if no stage is specified" do
+    it "should add edges from the class resources to the parent's stage if no stage is specified" do
+      main      = @compiler.catalog.resource(:stage, :main)
+      foo_stage = resource(:stage, :foo_stage)
+      @compiler.add_resource(@scope, foo_stage)
+      resource = resource(:class, "foo")
+      @scope.stubs(:resource).returns(:stage => :foo_stage)
+      @compiler.add_resource(@scope, resource)
+
+      @compiler.catalog.should be_edge(foo_stage, resource)
+    end
+
+    it "should add edges from top-level class resources to the main stage if no stage is specified" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:class, "foo")
       @compiler.add_resource(@scope, resource)

data/spec/unit/parser/files_spec.rb

@@ -154,7 +154,7 @@ describe Puppet::Parser::Files do
 
     it "should match against provided fully qualified patterns" do
       pattern = @basepath + "/fully/qualified/pattern/*"
-      Dir.expects(:glob).with(pattern+'{,.pp,.rb}').returns(%w{my file list})
+      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{my file list})
       Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{my file list}
     end
 
@@ -168,7 +168,7 @@ describe Puppet::Parser::Files do
       pattern = @basepath + "/fully/qualified/pattern/*"
       file = @basepath + "/my/file"
       dir = @basepath + "/my/directory"
-      Dir.expects(:glob).with(pattern+'{,.pp,.rb}').returns([file, dir])
+      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns([file, dir])
       FileTest.expects(:directory?).with(file).returns(false)
       FileTest.expects(:directory?).with(dir).returns(true)
       Puppet::Parser::Files.find_manifests(pattern)[1].should == [file]
@@ -176,7 +176,7 @@ describe Puppet::Parser::Files do
 
     it "should return files once only" do
       pattern = @basepath + "/fully/qualified/pattern/*"
-      Dir.expects(:glob).with(pattern+'{,.pp,.rb}').returns(%w{one two one})
+      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{one two one})
       Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{one two}
     end
   end

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

@@ -0,0 +1,95 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'tempfile'
+
+describe "the extlookup function" do
+
+  before :each do
+    @scope = Puppet::Parser::Scope.new
+
+    @scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
+    Puppet::Parser::Functions.function("extlookup")
+  end
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("extlookup").should == "function_extlookup"
+  end
+
+  it "should raise a ParseError if there is less than 1 arguments" do
+    lambda { @scope.function_extlookup([]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should raise a ParseError if there is more than 3 arguments" do
+    lambda { @scope.function_extlookup(["foo", "bar", "baz", "gazonk"]) }.should( raise_error(Puppet::ParseError))
+  end
+
+  it "should return the default" do
+    result = @scope.function_extlookup([ "key", "default"])
+    result.should == "default"
+  end
+
+  it "should lookup the key in a supplied datafile" do
+    t = Tempfile.new('extlookup.csv') do
+      t.puts 'key,value'
+      t.puts 'nonkey,nonvalue'
+      t.close
+
+      result = @scope.function_extlookup([ "key", "default", t.path])
+      result.should == "value"
+    end
+  end
+
+  it "should return an array if the datafile contains more than two columns" do
+    t = Tempfile.new('extlookup.csv') do
+      t.puts 'key,value1,value2'
+      t.puts 'nonkey,nonvalue,nonvalue'
+      t.close
+
+      result = @scope.function_extlookup([ "key", "default", t.path])
+      result.should == ["value1", "value2"]
+    end
+  end
+
+  it "should raise an error if there's no matching key and no default" do
+    t = Tempfile.new('extlookup.csv') do
+      t.puts 'key,value'
+      t.puts 'nonkey,nonvalue'
+      t.close
+
+      result = @scope.function_extlookup([ "key", nil, t.path])
+      result.should == "value"
+    end
+  end
+
+  describe "should look in $extlookup_datadir for data files listed by $extlookup_precedence" do
+    before do
+      @scope.stubs(:lookupvar).with('extlookup_datadir').returns("/tmp")
+      File.open("/tmp/one.csv","w"){|one| one.puts "key,value1" }
+      File.open("/tmp/two.csv","w") do |two|
+        two.puts "key,value2"
+        two.puts "key2,value_two"
+      end
+    end
+
+    it "when the key is in the first file" do
+      @scope.stubs(:lookupvar).with('extlookup_precedence').returns(["one","two"])
+      result = @scope.function_extlookup([ "key" ])
+      result.should == "value1"
+    end
+
+    it "when the key is in the second file" do
+      @scope.stubs(:lookupvar).with('extlookup_precedence').returns(["one","two"])
+      result = @scope.function_extlookup([ "key2" ])
+      result.should == "value_two"
+    end
+
+    it "should not modify extlookup_precedence data" do
+      variable = '%{fqdn}'
+      @scope.stubs(:lookupvar).with('extlookup_precedence').returns([variable,"one"])
+      @scope.stubs(:lookupvar).with('fqdn').returns('myfqdn')
+      result = @scope.function_extlookup([ "key" ])
+      variable.should == '%{fqdn}'
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the 'include' function" do
+
+  before :each do
+    Puppet::Node::Environment.stubs(:current).returns(nil)
+    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+    @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+  end
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("include").should == "function_include"
+  end
+
+  it "should include a single class" do
+    inc = "foo"
+    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == [inc]}.returns([inc])
+    @scope.function_include("foo")
+  end
+
+  it "should include multiple classes" do
+    inc = ["foo","bar"]
+    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
+    @scope.function_include(["foo","bar"])
+  end
+
+  it "should not lazily evaluate the included class" do
+    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| lazy == false}.returns("foo")
+    @scope.function_include("foo")
+  end
+end

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

@@ -6,7 +6,7 @@ describe "the require function" do
 
   before :each do
     @catalog = stub 'catalog'
-    @compiler = stub 'compiler', :catalog => @catalog
+    @compiler = stub 'compiler', :catalog => @catalog, :environment => nil
 
     @scope = Puppet::Parser::Scope.new
     @scope.stubs(:findresource)

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

@@ -6,6 +6,7 @@ describe "the 'tag' function" do
 
   before :each do
     @scope = Puppet::Parser::Scope.new
+    @scope.stubs(:environment).returns(nil)
   end
 
   it "should exist" do

data/spec/unit/parser/lexer_spec.rb

@@ -410,6 +410,10 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q{'single quoted string')}                                     => [[:STRING,'single quoted string']],
     %q{"double quoted string"}                                      => [[:STRING,'double quoted string']],
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
+    %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
+    %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
+    %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
+    %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
@@ -616,6 +620,12 @@ describe "Puppet::Parser::Lexer in the old tests" do
     @lexer.namespace.should == "base::sub"
   end
 
+  it "should not put class instantiation on the namespace" do
+    @lexer.string = "class base { class sub { class { mode"
+    @lexer.fullscan
+    @lexer.namespace.should == "base::sub"
+  end
+
   it "should correctly handle fully qualified names" do
     @lexer.string = "class base { class sub::more {"
     @lexer.fullscan
@@ -634,7 +644,6 @@ end
 
 require 'puppettest/support/utils'
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
-  extend PuppetTest
   extend PuppetTest::Support::Utils
   textfiles do |file|
     it "should correctly lex #{file}" do

data/spec/unit/parser/resource_spec.rb

@@ -58,23 +58,17 @@ describe Puppet::Parser::Resource do
   end
 
   it "should get its environment from its scope" do
-    scope = stub 'scope', :source => stub("source")
-    scope.expects(:environment).returns "foo"
+    scope = stub 'scope', :source => stub("source"), :namespaces => nil
+    scope.expects(:environment).returns("foo").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment.should == "foo"
   end
 
-  it "should get its namespaces from its scope" do
-    scope = stub 'scope', :source => stub("source")
-    scope.expects(:namespaces).returns %w{one two}
-    Puppet::Parser::Resource.new("file", "whatever", :scope => scope).namespaces.should == %w{one two}
-  end
-
   it "should use the resource type collection helper module" do
     Puppet::Parser::Resource.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should use the scope's environment as its environment" do
-    @scope.expects(:environment).returns "myenv"
+    @scope.expects(:environment).returns("myenv").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment.should == "myenv"
   end
 

data/spec/unit/parser/type_loader_spec.rb

@@ -192,7 +192,7 @@ describe Puppet::Parser::TypeLoader do
   end
 
   it "should be able to add classes to the current resource type collection" do
-    file = tmpfile("simple_file")
+    file = tmpfile("simple_file.pp")
     File.open(file, "w") { |f| f.puts "class foo {}" }
     @loader.import(file)
 

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -3,14 +3,16 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet_spec/files'
-require 'puppettest'
 require 'puppettest/support/utils'
 require 'puppettest/fileparsing'
+require 'tmpdir'
+require 'puppettest/fakes'
 
 provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
+  extend PuppetTest::Support::Utils
   include PuppetTest
   include PuppetTest::FileParsing
 
@@ -49,7 +51,7 @@ describe provider_class do
     @provider.target_object(@keyfile).read
   end
 
-  PuppetTest.fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
+  fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
     it "should be able to parse example data in #{file}" do
       fakedataparse(file)
     end

data/spec/unit/rails/resource_spec.rb

@@ -107,7 +107,7 @@ describe "Puppet::Rails::Resource" do
 
   describe "#to_resource" do
     it "should instantiate a Puppet::Parser::Resource" do
-      scope = stub "scope", :source => nil
+      scope = stub "scope", :source => nil, :environment => nil, :namespaces => nil
 
       @resource = Puppet::Rails::Resource.new
       @resource.stubs(:attributes).returns({

data/spec/unit/reports/tagmail_spec.rb

@@ -3,12 +3,12 @@
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/reports'
-require 'puppettest'
+require 'puppettest/support/utils'
 
 tagmail = Puppet::Reports.report(:tagmail)
 
 describe tagmail do
-  extend PuppetTest
+  extend PuppetTest::Support::Utils
 
   before do
     @processor = Puppet::Transaction::Report.new

data/spec/unit/resource/catalog_spec.rb

@@ -224,7 +224,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should convert parser resources to plain resources" do
-      resource = Puppet::Parser::Resource.new(:file, "foo", :scope => stub("scope"), :source => stub("source"))
+      resource = Puppet::Parser::Resource.new(:file, "foo", :scope => stub("scope", :environment => nil, :namespaces => nil), :source => stub("source"))
       catalog = Puppet::Resource::Catalog.new("whev")
       catalog.add_resource(resource)
       new = catalog.to_resource

data/spec/unit/resource/type_collection_spec.rb

@@ -258,6 +258,32 @@ describe Puppet::Resource::TypeCollection do
       loader.add instance
       loader.find("foo::bar", "eh", :hostclass).should be_nil
     end
+
+    describe "when topscope has a class that has the same name as a local class" do
+      before do
+        @loader = Puppet::Resource::TypeCollection.new("env")
+        [ "foo::bar", "bar" ].each do |name|
+          @loader.add Puppet::Resource::Type.new(:hostclass, name)
+        end
+      end
+
+      it "should favor the local class, if the name is unqualified" do
+        @loader.find("foo", "bar",   :hostclass).name.should == 'foo::bar'
+      end
+
+      it "should only look in the topclass, if the name is qualified" do
+        @loader.find("foo", "::bar", :hostclass).name.should == 'bar'
+      end
+
+    end
+    
+    it "should not look in the local scope for classes when the name is qualified" do
+        @loader = Puppet::Resource::TypeCollection.new("env")
+        @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
+
+        @loader.find("foo", "::bar", :hostclass).should == nil
+    end
+
   end
 
   it "should use the generic 'find' method with an empty namespace to find nodes" do
@@ -400,6 +426,14 @@ describe Puppet::Resource::TypeCollection do
       @parser.expects(:parse).raises ArgumentError
       lambda { @code.perform_initial_import }.should raise_error(Puppet::Error)
     end
+
+    it "should not do anything if the ignore_import settings is set" do
+      Puppet.settings[:ignoreimport] = true
+      @parser.expects(:string=).never
+      @parser.expects(:file=).never
+      @parser.expects(:parse).never
+      @code.perform_initial_import
+    end
   end
 
   describe "when determining the configuration version" do
@@ -429,4 +463,5 @@ describe Puppet::Resource::TypeCollection do
     end
 
   end
+
 end

data/spec/unit/resource/type_spec.rb

@@ -369,7 +369,8 @@ describe Puppet::Resource::Type do
     end
 
     it "should cache a reference to the parent type" do
-      @code.expects(:hostclass).once.with("bar").returns @parent
+      @code.stubs(:hostclass).with("foo::bar").returns nil
+      @code.expects(:hostclass).with("bar").once.returns @parent
       @child.parent_type(@scope)
       @child.parent_type
     end
@@ -411,6 +412,23 @@ describe Puppet::Resource::Type do
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
+    it "should add hostclass names to the classes list" do
+      @type.evaluate_code(@resource)
+      @compiler.catalog.classes.should be_include("foo")
+    end
+
+    it "should add node names to the classes list" do
+      @type = Puppet::Resource::Type.new(:node, "foo")
+      @type.evaluate_code(@resource)
+      @compiler.catalog.classes.should be_include("foo")
+    end
+
+    it "should not add defined resource names to the classes list" do
+      @type = Puppet::Resource::Type.new(:definition, "foo")
+      @type.evaluate_code(@resource)
+      @compiler.catalog.classes.should_not be_include("foo")
+    end
+
     it "should set all of its parameters in a subscope" do
       subscope = stub 'subscope', :compiler => @compiler
       @type.expects(:subscope).with(@scope, @resource).returns subscope

data/spec/unit/resource_spec.rb

@@ -123,18 +123,6 @@ describe Puppet::Resource do
     Puppet::Resource.new("file", "/my/file", :environment => :foo).environment.name.should == :foo
   end
 
-  it "should support specifying namespaces" do
-    Puppet::Resource.new("file", "/my/file", :namespaces => ["foo"]).namespaces.should == ["foo"]
-  end
-
-  it "should convert namespaces to an array if not specified as one" do
-    Puppet::Resource.new("file", "/my/file", :namespaces => "foo").namespaces.should == ["foo"]
-  end
-
-  it "should default to a single amespace of an empty string" do
-    Puppet::Resource.new("file", "/my/file").namespaces.should == [""]
-  end
-
   describe "and munging its type and title" do
     describe "when modeling a builtin resource" do
       it "should be able to find the resource type" do
@@ -164,16 +152,6 @@ describe Puppet::Resource do
         it "should set its title to the provided title" do
           Puppet::Resource.new("foo::bar", "/my/file").title.should == "/my/file"
         end
-
-        describe "and the resource is unqualified and models a qualified resource type" do
-          it "should set its type to the fully qualified resource type" do
-            Puppet::Resource.new("bar", "/my/file", :namespaces => %w{foo}).type.should == "Foo::Bar"
-          end
-
-          it "should be able to find the resource type" do
-            Puppet::Resource.new("bar", "/my/file", :namespaces => %w{foo}).resource_type.should equal(@type)
-          end
-        end
       end
 
       describe "that does not exist" do
@@ -210,20 +188,6 @@ describe Puppet::Resource do
         it "should be able to find the resource type" do
           Puppet::Resource.new("class", "foo::bar").resource_type.should equal(@type)
         end
-
-        describe "and the resource is unqualified and models a qualified class" do
-          it "should set its title to the fully qualified resource type" do
-            Puppet::Resource.new("class", "bar", :namespaces => %w{foo}).title.should == "Foo::Bar"
-          end
-
-          it "should be able to find the resource type" do
-            Puppet::Resource.new("class", "bar", :namespaces => %w{foo}).resource_type.should equal(@type)
-          end
-
-          it "should set its type to 'Class'" do
-            Puppet::Resource.new("class", "bar", :namespaces => %w{foo}).type.should == "Class"
-          end
-        end
       end
 
       describe "that does not exist" do