puppet 2.6.18 → 2.7.1

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::MatchOperator do
   before :each do

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::Minus do
   before :each do

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+describe Puppet::Parser::AST::Node do
+  describe "when instantiated" do
+    it "should make its names and context available through accessors" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'], :line => 5)
+      node.names.should == ['foo', 'bar']
+      node.context.should == {:line => 5}
+    end
+
+    it "should create a node with the proper type, name, context, and module name" do
+      node = Puppet::Parser::AST::Node.new(['foo'], :line => 5)
+      instantiated_nodes = node.instantiate('modname')
+      instantiated_nodes.length.should == 1
+      instantiated_nodes[0].type.should == :node
+      instantiated_nodes[0].name.should == 'foo'
+      instantiated_nodes[0].line.should == 5
+      instantiated_nodes[0].module_name.should == 'modname'
+    end
+
+    it "should handle multiple names" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'])
+      instantiated_nodes = node.instantiate('modname')
+      instantiated_nodes.length.should == 2
+      instantiated_nodes[0].name.should == 'foo'
+      instantiated_nodes[1].name.should == 'bar'
+    end
+  end
+end

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::Nop do
 

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::Not do
   before :each do

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::Relationship do
   before do

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::ResourceDefaults do
 

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::ResourceOverride do
 

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::ResourceReference do
 
@@ -10,21 +9,25 @@ describe Puppet::Parser::AST::ResourceReference do
     @scope = Puppet::Parser::Scope.new
   end
 
+  def ast_name(value)
+    Puppet::Parser::AST::Name.new(:value => value)
+  end
+
   def newref(type, title)
-    title = stub 'title', :safeevaluate => title
-    ref = Puppet::Parser::AST::ResourceReference.new(:type => type, :title => title)
+    title_array = Puppet::Parser::AST::ASTArray.new(:children => [title])
+    ref = Puppet::Parser::AST::ResourceReference.new(:type => type, :title => title_array)
   end
 
   it "should correctly produce reference strings" do
-    newref("File", "/tmp/yay").evaluate(@scope).to_s.should == "File[/tmp/yay]"
+    newref("File", ast_name("/tmp/yay")).evaluate(@scope).to_s.should == "File[/tmp/yay]"
   end
 
   it "should produce a single resource when the title evaluates to a string" do
-    newref("File", "/tmp/yay").evaluate(@scope).should == Puppet::Resource.new("file", "/tmp/yay")
+    newref("File", ast_name("/tmp/yay")).evaluate(@scope).should == Puppet::Resource.new("file", "/tmp/yay")
   end
 
   it "should return an array of resources if given an array of titles" do
-    titles = mock 'titles', :safeevaluate => ["title1","title2"]
+    titles = Puppet::Parser::AST::ASTArray.new(:children => [ast_name("title1"), ast_name("title2")])
     ref = ast::ResourceReference.new( :title => titles, :type => "File" )
     ref.evaluate(@scope).should == [
       Puppet::Resource.new("file", "title1"),
@@ -32,6 +35,16 @@ describe Puppet::Parser::AST::ResourceReference do
     ]
   end
 
+  it "should return an array of resources if given a variable containing an array of titles" do
+    @scope.setvar("my_files", ["foo", "bar"])
+    titles = Puppet::Parser::AST::Variable.new(:value => "my_files")
+    ref = newref('File', titles)
+    ref.evaluate(@scope).should == [
+      Puppet::Resource.new("file", "foo"),
+      Puppet::Resource.new("file", "bar")
+    ]
+  end
+
   it "should return a correct representation when converting to string" do
     type = stub 'type', :is_a? => true, :to_s => "file"
     title = stub 'title', :is_a? => true, :to_s => "[/tmp/a, /tmp/b]"

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::Resource do
   ast = Puppet::Parser::AST
@@ -11,14 +10,15 @@ describe Puppet::Parser::AST::Resource do
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
       @scope.stubs(:resource).returns(stub_everything)
-      @resource = ast::Resource.new(:title => @title, :type => "file", :parameters => ast::ASTArray.new(:children => []) )
+      @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
+      @resource = ast::Resource.new(:type => "file", :instances => ast::ASTArray.new(:children => [@instance]))
       @resource.stubs(:qualified_type).returns("Resource")
     end
 
     it "should evaluate all its parameters" do
       param = stub 'param'
       param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
-      @resource.stubs(:parameters).returns [param]
+      @instance.stubs(:parameters).returns [param]
 
       @resource.evaluate(@scope)
     end
@@ -35,7 +35,7 @@ describe Puppet::Parser::AST::Resource do
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-      @resource.title = array
+      @instance.title = array
       result = @resource.evaluate(@scope).collect { |r| r.title }
       result.should be_include("one")
       result.should be_include("two")
@@ -49,12 +49,19 @@ describe Puppet::Parser::AST::Resource do
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-      @resource.title = array
+      @instance.title = array
       result = @resource.evaluate(@scope).collect { |r| r.title }
       result.should be_include("one")
       result.should be_include("two")
     end
 
+    it "should implicitly iterate over instances" do
+      new_title = Puppet::Parser::AST::String.new(:value => "other_title")
+      new_instance = ast::ResourceInstance.new(:title => new_title, :parameters => ast::ASTArray.new(:children => []))
+      @resource.instances.push(new_instance)
+      @resource.evaluate(@scope).collect { |r| r.title }.should == ["mytitle", "other_title"]
+    end
+
     it "should handover resources to the compiler" do
       titles = []
       %w{one two}.each do |title|
@@ -63,7 +70,7 @@ describe Puppet::Parser::AST::Resource do
 
       array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-      @resource.title = array
+      @instance.title = array
       result = @resource.evaluate(@scope)
 
       result.each do |res|
@@ -91,16 +98,19 @@ describe Puppet::Parser::AST::Resource do
       before do
         @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
         @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
-        @parser.newdefine "one"
-        @parser.newdefine "one::two"
-        @parser.newdefine "three"
+        ["one", "one::two", "three"].each do |name|
+          @parser.environment.known_resource_types.add(Puppet::Resource::Type.new(:definition, name, {}))
+        end
         @twoscope = @scope.newscope(:namespace => "one")
         @twoscope.resource = @scope.resource
       end
 
       def resource(type, params = nil)
         params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
-        Puppet::Parser::AST::Resource.new(:type => type, :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
+        instance = Puppet::Parser::AST::ResourceInstance.new(
+                                                             :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
+        Puppet::Parser::AST::Resource.new(:type => type,
+                                          :instances => Puppet::Parser::AST::ASTArray.new(:children => [instance]))
       end
 
       it "should be able to generate resources with fully qualified type information" do
@@ -141,7 +151,8 @@ describe Puppet::Parser::AST::Resource do
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
       @scope.stubs(:resource).returns(stub_everything)
-      @resource = ast::Resource.new(:title => @title, :type => "Class", :parameters => ast::ASTArray.new(:children => []) )
+      @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
+      @resource = ast::Resource.new(:type => "Class", :instances => ast::ASTArray.new(:children => [@instance]))
       @resource.stubs(:qualified_type).returns("Resource")
       @type = Puppet::Resource::Type.new(:hostclass, "classname")
       @compiler.known_resource_types.add(@type)

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

@@ -1,13 +1,12 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::Selector do
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
-  describe "when evaluating" do
+  describe "when evaluating", :'fails_on_ruby_1.9.2' => true do
 
     before :each do
       @param = stub 'param'

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

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 describe Puppet::Parser::AST::VarDef do
   before :each do
@@ -16,8 +15,7 @@ describe Puppet::Parser::AST::VarDef do
       name.expects(:safeevaluate).with(@scope)
       value.expects(:safeevaluate).with(@scope)
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)
     end
 
@@ -27,8 +25,7 @@ describe Puppet::Parser::AST::VarDef do
 
       @scope.expects(:setvar).with { |name,value,options| options[:append] == nil }
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)
     end
 
@@ -38,8 +35,17 @@ describe Puppet::Parser::AST::VarDef do
 
       @scope.expects(:setvar).with { |name,value,options| options[:append] == true }
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil, :append => true
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil, :append => true
+      vardef.evaluate(@scope)
+    end
+
+    it "should call pass the source location to setvar" do
+      name = stub 'name', :safeevaluate => "var"
+      value = stub 'value', :safeevaluate => "1"
+
+      @scope.expects(:setvar).with { |name,value,options| options[:file] == 'setvar.pp' and options[:line] == 917 }
+
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => 'setvar.pp', :line => 917
       vardef.evaluate(@scope)
     end
 

data/spec/unit/parser/ast_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/parser/ast'
 

data/spec/unit/parser/collector_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/rails'
 require 'puppet/parser/collector'

data/spec/unit/parser/compiler_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
@@ -33,14 +32,6 @@ class CompilerTestResource
 
   def evaluate
   end
-
-  def file
-    "/fake/file/goes/here"
-  end
-
-  def line
-    "42"
-  end
 end
 
 describe Puppet::Parser::Compiler do
@@ -49,6 +40,13 @@ describe Puppet::Parser::Compiler do
   end
 
   before :each do
+    # Push me faster, I wanna go back in time!  (Specifically, freeze time
+    # across the test since we have a bunch of version == timestamp code
+    # hidden away in the implementation and we keep losing the race.)
+    # --daniel 2011-04-21
+    now = Time.now
+    Time.stubs(:now).returns(now)
+
     @node = Puppet::Node.new "testnode"
     @known_resource_types = Puppet::Resource::TypeCollection.new "development"
     @compiler = Puppet::Parser::Compiler.new(@node)
@@ -139,10 +137,6 @@ describe Puppet::Parser::Compiler do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
-    it "should correctly set the level of newly created scopes" do
-      @compiler.newscope(@compiler.topscope, :level => 5).level.should == 5
-    end
-
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
@@ -426,6 +420,52 @@ describe Puppet::Parser::Compiler do
       @compiler.catalog.should be_edge(@scope.resource, resource)
     end
 
+    it "should add an edge to any specified stage for class resources" do
+      other_stage = resource(:stage, "other")
+      @compiler.add_resource(@scope, other_stage)
+      resource = resource(:class, "foo")
+      resource[:stage] = 'other'
+
+      @compiler.add_resource(@scope, resource)
+
+      @compiler.catalog.edge?(other_stage, resource).should be_true
+    end
+
+    it "should fail if a non-class resource attempts to set a stage" do
+      other_stage = resource(:stage, "other")
+      @compiler.add_resource(@scope, other_stage)
+      resource = resource(:file, "foo")
+      resource[:stage] = 'other'
+
+      lambda { @compiler.add_resource(@scope, resource) }.should raise_error(ArgumentError)
+    end
+
+    it "should fail if an unknown stage is specified" do
+      resource = resource(:class, "foo")
+      resource[:stage] = 'other'
+
+      lambda { @compiler.add_resource(@scope, resource) }.should raise_error(ArgumentError)
+    end
+
+    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)
+
+      @compiler.catalog.should be_edge(main, resource)
+    end
+
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:file, "foo")
@@ -538,17 +578,16 @@ describe Puppet::Parser::Compiler do
       proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
-    it "should tag the catalog with the name of each not-found class" do
-      @compiler.catalog.expects(:tag).with("notfound")
+    it "should raise an error if a class is not found" do
       @scope.expects(:find_hostclass).with("notfound").returns(nil)
-      @compiler.evaluate_classes(%w{notfound}, @scope)
+      lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should raise_error(Puppet::Error, /Could not find class/)
     end
-    it "should log when it can't find class" do
+
+    it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
       @compiler.topscope.stubs(:find_hostclass).with('foo').returns(nil)
-      Puppet.expects(:warning).with('Could not find class foo for testnode')
-      @compiler.compile
+      lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
@@ -570,7 +609,7 @@ describe Puppet::Parser::Compiler do
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
-    it "should ensure each node class hash is in catalog and have appropriate parameters" do
+    it "should ensure each node class hash is in catalog and have appropriate parameters", :'fails_on_ruby_1.9.2' => true do
       klasses = {'foo'=>{'1'=>'one'}, 'bar::foo'=>{'2'=>'two'}, 'bar'=>{'1'=> [1,2,3], '2'=>{'foo'=>'bar'}}}
       @node.classes = klasses
       ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
@@ -594,7 +633,7 @@ describe Puppet::Parser::Compiler do
       r2.tags.should =~ ['class', 'bar']
     end
 
-    it "should ensure each node class is in catalog and has appropriate tags" do
+    it "should ensure each node class is in catalog and has appropriate tags", :'fails_on_ruby_1.9.2' => true do
       klasses = ['bar::foo']
       @node.classes = klasses
       ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
@@ -675,18 +714,6 @@ describe Puppet::Parser::Compiler do
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{MyClass}, @scope, false)
     end
-
-    it "should return the list of found classes" do
-      @compiler.catalog.stubs(:tag)
-
-      @compiler.stubs(:add_resource)
-      @scope.stubs(:find_hostclass).with("notfound").returns(nil)
-      @scope.stubs(:class_scope).with(@class)
-
-      Puppet::Parser::Resource.stubs(:new).returns(@resource)
-      @class.stubs :ensure_in_catalog
-      @compiler.evaluate_classes(%w{myclass notfound}, @scope).should == %w{myclass}
-    end
   end
 
   describe "when evaluating AST nodes with no AST nodes present" do