puppet 0.24.7 → 0.24.8

data/spec/unit/indirector/ssl_rsa/file.rb

@@ -22,6 +22,7 @@ end
 
 describe Puppet::Indirector::SslRsa::File, " when choosing a path for a ca key" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
         @name = :ca
     end
@@ -38,6 +39,7 @@ end
 
 describe Puppet::Indirector::SslRsa::File, " when choosing a path for a non-ca key" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
         @name = :publickey
     end
@@ -54,6 +56,7 @@ end
 
 describe Puppet::Indirector::SslRsa::File, " when saving" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
 
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
@@ -72,6 +75,7 @@ end
 
 describe Puppet::Indirector::SslRsa::File, " when finding a key by name" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
 
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")
@@ -95,6 +99,7 @@ end
 
 describe Puppet::Indirector::SslRsa::File, " when removing a key" do
     before do
+        Puppet.settings.stubs(:use)
         @file = Puppet::Indirector::SslRsa::File.new
 
         Puppet.settings.stubs(:value).with(:publickeydir).returns("/dir")

data/spec/unit/network/xmlrpc/client.rb

@@ -2,12 +2,170 @@
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
-describe Puppet::Network do
-    it "should raise an XMLRPCClientError if a generated class raises a Timeout::Error" do
-        http = mock 'http'
-        Puppet::Network::HttpPool.stubs(:http_instance).returns http
-        file = Puppet::Network::Client.file.new({:Server => "foo.com"})
-        http.stubs(:post2).raises Timeout::Error
-        lambda { file.retrieve }.should raise_error(Puppet::Network::XMLRPCClientError)
+describe Puppet::Network::XMLRPCClient do
+    describe "when performing the rpc call" do
+        before do
+            @client = Puppet::Network::Client.report.xmlrpc_client.new
+            @client.stubs(:call).returns "foo"
+
+        end
+
+        it "should call the specified namespace and method, with the specified arguments" do
+            @client.expects(:call).with("puppetreports.report", "eh").returns "foo"
+            @client.report("eh")
+        end
+
+        it "should return the results from the call" do
+            @client.expects(:call).returns "foo"
+            @client.report("eh").should == "foo"
+        end
+
+        it "should always close the http connection if it is still open after the call" do
+            http = mock 'http'
+            @client.stubs(:http).returns http
+
+            http.expects(:started?).returns true
+            http.expects(:finish)
+
+            @client.report("eh").should == "foo"
+        end
+
+        it "should always close the http connection if it is still open after a call that raises an exception" do
+            http = mock 'http'
+            @client.stubs(:http).returns http
+
+            @client.expects(:call).raises RuntimeError
+
+            http.expects(:started?).returns true
+            http.expects(:finish)
+
+            lambda { @client.report("eh") }.should raise_error
+        end
+
+        describe "when returning the http instance" do
+            it "should use the http pool to create the instance" do
+                @client.instance_variable_set("@http", nil)
+                @client.expects(:host).returns "myhost"
+                @client.expects(:port).returns "myport"
+                Puppet::Network::HttpPool.expects(:http_instance).with("myhost", "myport", true).returns "http"
+
+                @client.http.should == "http"
+            end
+
+            it "should reuse existing instances" do
+                @client.http.should equal(@client.http)
+            end
+        end
+
+        describe "when recycling the connection" do
+            it "should close the existing instance if it's open" do
+                http = mock 'http'
+                @client.stubs(:http).returns http
+
+                http.expects(:started?).returns true
+                http.expects(:finish)
+
+                @client.recycle_connection
+            end
+
+            it "should force creation of a new instance" do
+                Puppet::Network::HttpPool.expects(:http_instance).returns "second_http"
+
+                @client.recycle_connection
+
+                @client.http.should == "second_http"
+            end
+        end
+
+        describe "and an exception is raised" do
+            it "should raise XMLRPCClientError if XMLRPC::FaultException is raised" do
+                error = XMLRPC::FaultException.new("foo", "bar")
+
+                @client.expects(:call).raises(error)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+
+            it "should raise XMLRPCClientError if Errno::ECONNREFUSED is raised" do
+                @client.expects(:call).raises(Errno::ECONNREFUSED)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+
+            it "should log and raise XMLRPCClientError if Timeout::Error is raised" do
+                Puppet.expects(:err)
+                @client.expects(:call).raises(Timeout::Error)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+
+            it "should log and raise XMLRPCClientError if SocketError is raised" do
+                Puppet.expects(:err)
+                @client.expects(:call).raises(SocketError)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+
+            it "should log, recycle the connection, and retry if Errno::EPIPE is raised" do
+                @client.expects(:call).times(2).raises(Errno::EPIPE).then.returns "eh"
+
+                Puppet.expects(:info)
+                @client.expects(:recycle_connection)
+
+                @client.report("eh")
+            end
+
+            it "should log, recycle the connection, and retry if EOFError is raised" do
+                @client.expects(:call).times(2).raises(EOFError).then.returns "eh"
+
+                Puppet.expects(:info)
+                @client.expects(:recycle_connection)
+
+                @client.report("eh")
+            end
+
+            it "should log and retry if an exception containing 'Wrong size' is raised" do
+                error = RuntimeError.new("Wrong size. Was 15, should be 30")
+                @client.expects(:call).times(2).raises(error).then.returns "eh"
+
+                Puppet.expects(:warning)
+
+                @client.report("eh")
+            end
+
+            it "should raise XMLRPCClientError if OpenSSL::SSL::SSLError is raised" do
+                @client.expects(:call).raises(OpenSSL::SSL::SSLError)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+
+            it "should log and raise XMLRPCClientError if OpenSSL::SSL::SSLError is raised with certificate issues" do
+                error = OpenSSL::SSL::SSLError.new("hostname was not match")
+                @client.expects(:call).raises(error)
+
+                Puppet.expects(:warning)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+
+            it "should log, recycle the connection, and retry if OpenSSL::SSL::SSLError is raised containing 'bad write retry'" do
+                error = OpenSSL::SSL::SSLError.new("bad write retry")
+                @client.expects(:call).times(2).raises(error).then.returns "eh"
+
+                @client.expects(:recycle_connection)
+
+                Puppet.expects(:warning)
+
+                @client.report("eh")
+            end
+
+            it "should log and raise XMLRPCClientError if any other exception is raised" do
+                @client.expects(:call).raises(RuntimeError)
+
+                Puppet.expects(:err)
+
+                lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
+            end
+        end
     end
 end

data/spec/unit/node/catalog.rb

@@ -794,6 +794,7 @@ describe Puppet::Node::Catalog, " when writing dot files" do
     end
 
     it "should write a dot file based on the passed name" do
+        Puppet.settings.stubs(:use)
         File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil))
         @catalog.expects(:to_dot).with("name" => @name.to_s.capitalize)
         @catalog.host_config = true

data/spec/unit/other/transbucket.rb

@@ -70,20 +70,20 @@ describe Puppet::TransBucket, " when generating a catalog" do
         @bottom = Puppet::TransBucket.new
         @bottom.type = "fake"
         @bottom.name = "bottom"
-        @bottomobj = Puppet::TransObject.new("bottom", "user")
+        @bottomobj = Puppet::TransObject.new("bottom", "notify")
         @bottom.push @bottomobj
 
         @middle = Puppet::TransBucket.new
         @middle.type = "fake"
         @middle.name = "middle"
-        @middleobj = Puppet::TransObject.new("middle", "user")
+        @middleobj = Puppet::TransObject.new("middle", "notify")
         @middle.push(@middleobj)
         @middle.push(@bottom)
 
         @top = Puppet::TransBucket.new
         @top.type = "fake"
         @top.name = "top"
-        @topobj = Puppet::TransObject.new("top", "user")
+        @topobj = Puppet::TransObject.new("top", "notify")
         @top.push(@topobj)
         @top.push(@middle)
 
@@ -98,7 +98,7 @@ describe Puppet::TransBucket, " when generating a catalog" do
     it "should convert all transportable objects to RAL resources" do
         @catalog = @top.to_catalog
         @users.each do |name|
-            @catalog.vertices.find { |r| r.class.name == :user and r.title == name }.should be_instance_of(Puppet::Type.type(:user))
+            @catalog.vertices.find { |r| r.class.name == :notify and r.title == name }.should be_instance_of(Puppet::Type.type(:notify))
         end
     end
 

data/spec/unit/parser/ast.rb

@@ -5,6 +5,10 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/parser/ast'
 
 describe Puppet::Parser::AST do
+    
+    it "should use the file lookup module" do
+        Puppet::Parser::AST.ancestors.should be_include(Puppet::FileCollection::Lookup)
+    end
 
     it "should have a doc accessor" do
         ast = Puppet::Parser::AST.new({})
@@ -34,4 +38,4 @@ describe Puppet::Parser::AST do
         end
     end
 
-end
+end

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

@@ -49,7 +49,7 @@ describe Puppet::Parser::AST::ASTArray do
         operator.evaluate(@scope).should == [123]
     end
 
-    it "should flatten the results of children evaluation" do
+    it "should not flatten the results of children evaluation" do
         item1 = stub "item1", :is_a? => true
         item2 = stub "item2"
         item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
@@ -59,7 +59,7 @@ describe Puppet::Parser::AST::ASTArray do
         item1.expects(:safeevaluate).with(@scope).returns([123])
         
         operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
-        operator.evaluate(@scope).should == [123]
+        operator.evaluate(@scope).should == [[123]]
     end
     
     

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Resource do
+    ast = Puppet::Parser::AST
+
+    before :each do
+        @title = stub_everything 'title'
+        @compiler = stub_everything 'compiler'
+        @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+        @param1 = stub_everything 'parameter', :is_a? => true
+        @scope.stubs(:resource).returns(stub_everything)
+        @params = ast::ASTArray.new( :children => [@param1])
+        @resource = ast::Resource.new(:title => @title, :type => "Resource", :params => @params )
+        @resource.stubs(:qualified_type).returns("Resource")
+        Puppet::Parser::Resource.stubs(:new).returns(stub_everything)
+    end
+
+    it "should evaluate all its parameters" do
+        @param1.expects(:safeevaluate).with(@scope)
+
+        @resource.evaluate(@scope)
+    end
+
+    it "should evaluate its title" do
+
+        @title.expects(:safeevaluate).with(@scope)
+
+        @resource.evaluate(@scope)
+    end
+
+    it "should flatten the titles array" do
+        titles = stub 'titles'
+        title_array = stub 'title_array', :is_a? => true
+
+        titles.stubs(:safeevaluate).with(@scope).returns(title_array)
+
+        title_array.expects(:flatten).returns([])
+
+        @resource.title = titles
+        @resource.evaluate(@scope)
+    end
+
+    it "should create one resource objects per title" do
+        titles = stub 'titles'
+        title_array = stub 'title_array', :is_a? => true
+
+        title_array.stubs(:flatten).returns([@title])
+        titles.stubs(:safeevaluate).with(@scope).returns(title_array)
+
+        Puppet::Parser::Resource.expects(:new).with { |hash| hash[:title] == @title }
+
+        @resource.title = titles
+        @resource.evaluate(@scope)
+    end
+
+    it "should handover resources to the compiler" do
+        resource = stub 'resource'
+        titles = stub 'titles'
+        title_array = stub 'title_array', :is_a? => true
+
+        title_array.stubs(:flatten).returns([@title])
+        titles.stubs(:safeevaluate).with(@scope).returns(title_array)
+        Puppet::Parser::Resource.stubs(:new).returns(resource)
+
+        @compiler.expects(:add_resource).with(@scope, resource)
+
+        @resource.title = titles
+        @resource.evaluate(@scope)
+    end
+
+    it "should return the newly created resources" do
+        resource = stub 'resource'
+        titles = stub 'titles'
+        title_array = stub 'title_array', :is_a? => true
+
+        title_array.stubs(:flatten).returns([@title])
+        titles.stubs(:safeevaluate).with(@scope).returns(title_array)
+        Puppet::Parser::Resource.stubs(:new).returns(resource)
+
+        @compiler.stubs(:add_resource).with(resource)
+
+        @resource.title = titles
+        @resource.evaluate(@scope).should == [resource]
+    end
+
+    it "should generate virtual resources if it is virtual" do
+        @resource.virtual = true
+
+        Puppet::Parser::Resource.expects(:new).with { |hash| hash[:virtual] == true }
+
+        @resource.evaluate(@scope)
+    end
+
+    it "should generate virtual and exported resources if it is exported" do
+        @resource.exported = true
+
+        Puppet::Parser::Resource.expects(:new).with { |hash| hash[:virtual] == true and hash[:exported] == true }
+
+        @resource.evaluate(@scope)
+    end
+end