puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/forge/errors_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'puppet/forge/errors'
+
+describe Puppet::Forge::Errors do
+  describe 'SSLVerifyError' do
+    subject { Puppet::Forge::Errors::SSLVerifyError }
+    let(:exception) { subject.new(:uri => 'https://fake.com:1111') }
+
+    it 'should return a valid single line error' do
+      exception.message.should == 'Unable to verify the SSL certificate at https://fake.com:1111'
+    end
+
+    it 'should return a valid multiline error' do
+      exception.multiline.should == <<-EOS.chomp
+Could not connect via HTTPS to https://fake.com:1111
+  Unable to verify the SSL certificate
+    The certificate may not be signed by a valid CA
+    The CA bundle included with OpenSSL may not be valid or up to date
+      EOS
+    end
+  end
+
+  describe 'CommunicationError' do
+    subject { Puppet::Forge::Errors::CommunicationError }
+    let(:socket_exception) { SocketError.new('There was a problem') }
+    let(:exception) { subject.new(:uri => 'http://fake.com:1111', :original => socket_exception) }
+
+    it 'should return a valid single line error' do
+      exception.message.should == 'Unable to connect to the server at http://fake.com:1111. Detail: There was a problem.'
+    end
+
+    it 'should return a valid multiline error' do
+      exception.multiline.should == <<-EOS.chomp
+Could not connect to http://fake.com:1111
+  There was a network communications problem
+    The error we caught said 'There was a problem'
+    Check your network connection and try again
+      EOS
+    end
+  end
+
+end

data/spec/unit/forge/repository_spec.rb

@@ -2,55 +2,132 @@ require 'spec_helper'
 require 'net/http'
 require 'puppet/forge/repository'
 require 'puppet/forge/cache'
+require 'puppet/forge/errors'
 
 describe Puppet::Forge::Repository do
-  describe 'instances' do
+  let(:consumer_version) { "Test/1.0" }
+  let(:repository) { Puppet::Forge::Repository.new('http://fake.com', consumer_version) }
+  let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', consumer_version) }
 
-    let(:repository) { Puppet::Forge::Repository.new('http://fake.com') }
+  it "retrieve accesses the cache" do
+    uri = URI.parse('http://some.url.com')
+    repository.cache.expects(:retrieve).with(uri)
 
-    describe '#retrieve' do
-      before do
-        @uri = URI.parse('http://some.url.com')
-      end
+    repository.retrieve(uri)
+  end
 
-      it "should access the cache" do
-        repository.cache.expects(:retrieve).with(@uri)
-        repository.retrieve(@uri)
-      end
+  describe 'http_proxy support' do
+    after :each do
+      ENV["http_proxy"] = nil
+    end
+
+    it "supports environment variable for port and host" do
+      ENV["http_proxy"] = "http://test.com:8011"
+
+      repository.http_proxy_host.should == "test.com"
+      repository.http_proxy_port.should == 8011
+    end
+
+    it "supports puppet configuration for port and host" do
+      ENV["http_proxy"] = nil
+      proxy_settings_of('test.com', 7456)
+
+      repository.http_proxy_port.should == 7456
+      repository.http_proxy_host.should == "test.com"
+    end
+
+    it "uses environment variable before puppet settings" do
+      ENV["http_proxy"] = "http://test1.com:8011"
+      proxy_settings_of('test2.com', 7456)
+
+      repository.http_proxy_host.should == "test1.com"
+      repository.http_proxy_port.should == 8011
+    end
+  end
+
+  describe "making a request" do
+    before :each do
+      proxy_settings_of("proxy", 1234)
     end
 
-    describe 'http_proxy support' do
-      before :each do
-        ENV["http_proxy"] = nil
+    it "returns the result object from the request" do
+      result = "the http response"
+      performs_an_http_request result do |http|
+        http.expects(:request).with(responds_with(:path, "the_path"))
       end
 
-      after :each do
-        ENV["http_proxy"] = nil
+      repository.make_http_request("the_path").should == result
+    end
+
+    it 'returns the result object from a request with ssl' do
+      result = "the http response"
+      performs_an_https_request result do |http|
+        http.expects(:request).with(responds_with(:path, "the_path"))
       end
 
-      it "should support environment variable for port and host" do
-        ENV["http_proxy"] = "http://test.com:8011"
-        repository.http_proxy_host.should == "test.com"
-        repository.http_proxy_port.should == 8011
+      ssl_repository.make_http_request("the_path").should == result
+    end
+
+    it 'return a valid exception when there is an SSL verification problem' do
+      performs_an_https_request "the http response" do |http|
+        http.expects(:request).with(responds_with(:path, "the_path")).raises OpenSSL::SSL::SSLError.new("certificate verify failed")
       end
 
-      it "should support puppet configuration for port and host" do
-        ENV["http_proxy"] = nil
-        Puppet.settings.stubs(:[]).with(:http_proxy_host).returns('test.com')
-        Puppet.settings.stubs(:[]).with(:http_proxy_port).returns(7456)
+      expect { ssl_repository.make_http_request("the_path") }.to raise_error Puppet::Forge::Errors::SSLVerifyError, 'Unable to verify the SSL certificate at https://fake.com'
+    end
 
-        repository.http_proxy_port.should == 7456
-        repository.http_proxy_host.should == "test.com"
+    it 'return a valid exception when there is a communication problem' do
+      performs_an_http_request "the http response" do |http|
+        http.expects(:request).with(responds_with(:path, "the_path")).raises SocketError
       end
 
-      it "should use environment variable before puppet settings" do
-        ENV["http_proxy"] = "http://test1.com:8011"
-        Puppet.settings.stubs(:[]).with(:http_proxy_host).returns('test2.com')
-        Puppet.settings.stubs(:[]).with(:http_proxy_port).returns(7456)
+      expect { repository.make_http_request("the_path") }.
+        to raise_error Puppet::Forge::Errors::CommunicationError,
+        'Unable to connect to the server at http://fake.com. Detail: SocketError.'
+    end
+
+    it "sets the user agent for the request" do
+      performs_an_http_request do |http|
+        http.expects(:request).with() do |request|
+          puppet_version = /Puppet\/\d+\..*/
+          os_info = /\(.*\)/
+          ruby_version = /Ruby\/\d+\.\d+\.\d+(-p\d+)? \(\d{4}-\d{2}-\d{2}; .*\)/
 
-        repository.http_proxy_host.should == "test1.com"
-        repository.http_proxy_port.should == 8011
+          request["User-Agent"] =~ /^#{consumer_version} #{puppet_version} #{os_info} #{ruby_version}/
+        end
       end
+
+      repository.make_http_request("the_path")
     end
+
+    def performs_an_http_request(result = nil, &block)
+      http = mock("http client")
+      yield http
+
+      proxy_class = mock("http proxy class")
+      proxy = mock("http proxy")
+      proxy_class.expects(:new).with("fake.com", 80).returns(proxy)
+      proxy.expects(:start).yields(http).returns(result)
+      Net::HTTP.expects(:Proxy).with("proxy", 1234).returns(proxy_class)
+    end
+
+    def performs_an_https_request(result = nil, &block)
+      http = mock("http client")
+      yield http
+
+      proxy_class = mock("http proxy class")
+      proxy = mock("http proxy")
+      proxy_class.expects(:new).with("fake.com", 443).returns(proxy)
+      proxy.expects(:start).yields(http).returns(result)
+      proxy.expects(:use_ssl=).with(true)
+      proxy.expects(:cert_store=)
+      proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      Net::HTTP.expects(:Proxy).with("proxy", 1234).returns(proxy_class)
+    end
+  end
+
+  def proxy_settings_of(host, port)
+    Puppet[:http_proxy_host] = host
+    Puppet[:http_proxy_port] = port
   end
 end

data/spec/unit/forge_spec.rb

@@ -4,8 +4,6 @@ require 'net/http'
 require 'puppet/module_tool'
 
 describe Puppet::Forge do
-  include PuppetSpec::Files
-
   let(:response_body) do
   <<-EOF
     [
@@ -22,35 +20,31 @@ describe Puppet::Forge do
     ]
   EOF
   end
-  let(:response) { stub(:body => response_body, :code => '200') }
 
-  before do
+  let(:forge) { Puppet::Forge.new("test_agent", SemVer.new("v1.0.0")) }
+
+  def repository_responds_with(response)
     Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
-    Puppet::Forge::Repository.any_instance.stubs(:retrieve).returns("/tmp/foo")
   end
 
-  describe "the behavior of the search method" do
-    context "when there are matches for the search term" do
-      before do
-        Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
-      end
+  it "returns a list of matches from the forge when there are matches for the search term" do
+    response = stub(:body => response_body, :code => '200')
+    repository_responds_with(response)
 
-      it "should return a list of matches from the forge" do
-        Puppet::Forge.search('bacula').should == PSON.load(response_body)
-      end
-    end
+    forge.search('bacula').should == PSON.load(response_body)
+  end
 
-    context "when the connection to the forge fails" do
-      let(:response)  { stub(:body => '{}', :code => '404') }
+  context "when the connection to the forge fails" do
+    before :each do
+      repository_responds_with(stub(:body => '{}', :code => '404'))
+    end
 
-      it "should raise an error for search" do
-        lambda { Puppet::Forge.search('bacula') }.should raise_error RuntimeError
-      end
+    it "raises an error for search" do
+      expect { forge.search('bacula') }.to raise_error RuntimeError
+    end
 
-      it "should raise an error for remote_dependency_info" do
-        lambda { Puppet::Forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.should raise_error RuntimeError
-      end
+    it "raises an error for remote_dependency_info" do
+      expect { forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.to raise_error RuntimeError
     end
   end
-
 end

data/spec/unit/indirector/active_record_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/rails'

data/spec/unit/indirector/catalog/active_record_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_database? do
@@ -25,61 +25,23 @@ describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_datab
   end
 
   describe "when finding an instance" do
-    let :request do
-      stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
+    it "should return nil" do
+      r = stub 'request', :key => "foo", :options => {:cache_integration_hack => false}
+      terminus.find(r).should be_nil
     end
 
-    # This hack is here because we don't want to look in the db unless we actually want
-    # to look in the db, but our indirection architecture in 0.24.x isn't flexible
-    # enough to tune that via configuration.
-    it "should return nil unless ':cache_integration_hack' is set to true" do
-      request.options[:cache_integration_hack] = false
-      Puppet::Rails::Host.expects(:find_by_name).never
-      terminus.find(request).should be_nil
-    end
-
-    it "should use the Hosts ActiveRecord class to find the host" do
-      Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
-      terminus.find(request)
-    end
-
-    it "should return nil if no host instance can be found" do
-      Puppet::Rails::Host.expects(:find_by_name).returns nil
-
-      terminus.find(request).should be_nil
-    end
-
-    it "should return a catalog with the same name as the host if the host can be found" do
-      host = stub 'host', :name => "foo", :resources => []
-      Puppet::Rails::Host.expects(:find_by_name).returns host
-
-      result = terminus.find(request)
-      result.should be_instance_of(Puppet::Resource::Catalog)
-      result.name.should == "foo"
-    end
-
-    it "should set each of the host's resources as a transportable resource within the catalog" do
-      host = stub 'host', :name => "foo"
-      Puppet::Rails::Host.expects(:find_by_name).returns host
-
-      res1 = mock 'res1', :to_transportable => "trans_res1"
-      res2 = mock 'res2', :to_transportable => "trans_res2"
-
-      host.expects(:resources).returns [res1, res2]
-
-      catalog = stub 'catalog'
-      Puppet::Resource::Catalog.expects(:new).returns catalog
-
-      catalog.expects(:add_resource).with "trans_res1"
-      catalog.expects(:add_resource).with "trans_res2"
-
-      terminus.find(request)
+    # This used to make things go to the database, but that is code that is as
+    # dead as a doornail.  This just checks we don't blow up unexpectedly, and
+    # can go away after a few releases. --daniel 2012-02-27
+    it "should always return nil" do
+      r = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
+      terminus.find(r).should be_nil
     end
   end
 
   describe "when saving an instance" do
     let :catalog do Puppet::Resource::Catalog.new("foo") end
-    let :request do Puppet::Indirector::Request.new(:active_record, :save, catalog) end
+    let :request do Puppet::Indirector::Request.new(:active_record, :save, nil, catalog) end
     let :node do Puppet::Node.new("foo", :environment => "environment") end
 
     before :each do

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/catalog/compiler'
@@ -28,11 +28,11 @@ describe Puppet::Resource::Catalog::Compiler do
       node1 = stub 'node1', :merge => nil
       node2 = stub 'node2', :merge => nil
       compiler.stubs(:compile)
-      Puppet::Node.indirection.stubs(:find).with('node1').returns(node1)
-      Puppet::Node.indirection.stubs(:find).with('node2').returns(node2)
+      Puppet::Node.indirection.stubs(:find).with('node1', anything).returns(node1)
+      Puppet::Node.indirection.stubs(:find).with('node2', anything).returns(node2)
 
-      compiler.find(stub('request', :key => 'node1', :node => 'node1', :options => {}))
-      compiler.find(stub('node2request', :key => 'node2', :node => 'node2', :options => {}))
+      compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node1', nil, :node => 'node1'))
+      compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node2', nil, :node => 'node2'))
     end
 
     it "should provide a method for determining if the catalog is networked" do
@@ -50,28 +50,19 @@ describe Puppet::Resource::Catalog::Compiler do
       @node = Puppet::Node.new @name
       @node.stubs(:merge)
       Puppet::Node.indirection.stubs(:find).returns @node
-      @request = stub 'request', :key => @name, :node => @name, :options => {}
+      @request = Puppet::Indirector::Request.new(:catalog, :find, @name, nil, :node => @name)
     end
 
-    it "should directly use provided nodes for a local request" do
+    it "should directly use provided nodes" do
       Puppet::Node.indirection.expects(:find).never
       @compiler.expects(:compile).with(@node)
       @request.stubs(:options).returns(:use_node => @node)
-      @request.stubs(:remote?).returns(false)
       @compiler.find(@request)
     end
 
-    it "rejects a provided node if the request is remote" do
-      @request.stubs(:options).returns(:use_node => @node)
-      @request.stubs(:remote?).returns(true)
-      expect {
-        @compiler.find(@request)
-      }.to raise_error Puppet::Error, /invalid option use_node/i
-    end
-
     it "should use the authenticated node name if no request key is provided" do
       @request.stubs(:key).returns(nil)
-      Puppet::Node.indirection.expects(:find).with(@name).returns(@node)
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
       @compiler.expects(:compile).with(@node)
       @compiler.find(@request)
     end
@@ -79,53 +70,35 @@ describe Puppet::Resource::Catalog::Compiler do
     it "should use the provided node name by default" do
       @request.expects(:key).returns "my_node"
 
-      Puppet::Node.indirection.expects(:find).with("my_node").returns @node
+      Puppet::Node.indirection.expects(:find).with("my_node", anything).returns @node
       @compiler.expects(:compile).with(@node)
       @compiler.find(@request)
     end
 
     it "should fail if no node is passed and none can be found" do
-      Puppet::Node.indirection.stubs(:find).with(@name).returns(nil)
+      Puppet::Node.indirection.stubs(:find).with(@name, anything).returns(nil)
       proc { @compiler.find(@request) }.should raise_error(ArgumentError)
     end
 
     it "should fail intelligently when searching for a node raises an exception" do
-      Puppet::Node.indirection.stubs(:find).with(@name).raises "eh"
+      Puppet::Node.indirection.stubs(:find).with(@name, anything).raises "eh"
       proc { @compiler.find(@request) }.should raise_error(Puppet::Error)
     end
 
     it "should pass the found node to the compiler for compiling" do
-      Puppet::Node.indirection.expects(:find).with(@name).returns(@node)
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
       config = mock 'config'
       Puppet::Parser::Compiler.expects(:compile).with(@node)
       @compiler.find(@request)
     end
 
     it "should extract and save any facts from the request" do
-      Puppet::Node.indirection.expects(:find).with(@name).returns @node
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns @node
       @compiler.expects(:extract_facts_from_request).with(@request)
       Puppet::Parser::Compiler.stubs(:compile)
       @compiler.find(@request)
     end
 
-    it "requires `facts_format` option if facts are passed in" do
-      facts = Puppet::Node::Facts.new("mynode", :afact => "avalue")
-      request = Puppet::Indirector::Request.new(:catalog, :find, "mynode", :facts => facts)
-      expect {
-        @compiler.find(request)
-      }.to raise_error ArgumentError, /no fact format provided for mynode/
-    end
-
-    it "rejects facts in the request from a different node" do
-      facts = Puppet::Node::Facts.new("differentnode", :afact => "avalue")
-      request = Puppet::Indirector::Request.new(
-        :catalog, :find, "mynode", :facts => facts, :facts_format => "unused"
-      )
-      expect {
-        @compiler.find(request)
-      }.to raise_error Puppet::Error, /fact definition for the wrong node/i
-    end
-
     it "should return the results of compiling as the catalog" do
       Puppet::Node.indirection.stubs(:find).returns(@node)
       config = mock 'config'
@@ -160,7 +133,7 @@ describe Puppet::Resource::Catalog::Compiler do
     before do
       Facter.stubs(:value).returns "something"
       @compiler = Puppet::Resource::Catalog::Compiler.new
-      @request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+      @request = stub 'request', :options => {}
 
       @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
       Puppet::Node::Facts.indirection.stubs(:save).returns(nil)
@@ -211,13 +184,13 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler = Puppet::Resource::Catalog::Compiler.new
       @name = "me"
       @node = mock 'node'
-      @request = stub 'request', :key => @name, :options => {}
+      @request = Puppet::Indirector::Request.new(:catalog, :find, @name, nil)
       @compiler.stubs(:compile)
     end
 
     it "should look node information up via the Node class with the provided key" do
       @node.stubs :merge
-      Puppet::Node.indirection.expects(:find).with(@name).returns(@node)
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
       @compiler.find(@request)
     end
   end
@@ -230,9 +203,9 @@ describe Puppet::Resource::Catalog::Compiler do
       @compiler = Puppet::Resource::Catalog::Compiler.new
       @name = "me"
       @node = mock 'node'
-      @request = stub 'request', :key => @name, :options => {}
+      @request = Puppet::Indirector::Request.new(:catalog, :find, @name, nil)
       @compiler.stubs(:compile)
-      Puppet::Node.indirection.stubs(:find).with(@name).returns(@node)
+      Puppet::Node.indirection.stubs(:find).with(@name, anything).returns(@node)
     end
 
     it "should add the server's Puppet version to the node's parameters as 'serverversion'" do