puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/indirector/yaml_spec.rb

@@ -149,15 +149,15 @@ describe Puppet::Indirector::Yaml do
       end
 
       it "should unlink the right yaml file if it exists" do
-        File.expects(:exists?).with(path).returns true
-        File.expects(:unlink).with(path)
+        Puppet::FileSystem::File.expects(:exist?).with(path).returns true
+        Puppet::FileSystem::File.expects(:unlink).with(path)
 
         @store.destroy(@request)
       end
 
       it "should not unlink the yaml file if it does not exists" do
-        File.expects(:exists?).with(path).returns false
-        File.expects(:unlink).with(path).never
+        Puppet::FileSystem::File.expects(:exist?).with(path).returns false
+        Puppet::FileSystem::File.expects(:unlink).with(path).never
 
         @store.destroy(@request)
       end

data/spec/unit/module_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Module do
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
-    FileTest.stubs(:exist?).returns false
+    Puppet::FileSystem::File.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
@@ -90,12 +90,14 @@ describe Puppet::Module do
 
   describe "when finding unmet dependencies" do
     before do
-      FileTest.unstub(:exist?)
+      Puppet::FileSystem::File.unstub(:exist?)
       @modpath = tmpdir('modpath')
       Puppet.settings[:modulepath] = @modpath
     end
 
     it "should list modules that are missing" do
+      metadata_file = "#{@modpath}/needy/metadata.json"
+      Puppet::FileSystem::File.expects(:exist?).twice.with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -116,6 +118,8 @@ describe Puppet::Module do
     end
 
     it "should list modules that are missing and have invalid names" do
+      metadata_file = "#{@modpath}/needy/metadata.json"
+      Puppet::FileSystem::File.expects(:exist?).with(metadata_file).twice.returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -136,6 +140,10 @@ describe Puppet::Module do
     end
 
     it "should list modules with unmet version requirement" do
+      ['foobar', 'foobaz'].each do |mod_name|
+        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
+        Puppet::FileSystem::File.stubs(:exist?).with(metadata_file).returns true
+      end
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -204,6 +212,8 @@ describe Puppet::Module do
     end
 
     it "should consider a dependency without a semantic version to be unmet" do
+      metadata_file = "#{@modpath}/foobar/metadata.json"
+      Puppet::FileSystem::File.expects(:exist?).with(metadata_file).times(3).returns true
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -244,6 +254,10 @@ describe Puppet::Module do
     end
 
     it "should only list unmet dependencies" do
+      [name, 'satisfied'].each do |mod_name|
+        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
+        Puppet::FileSystem::File.expects(:exist?).with(metadata_file).twice.returns true
+      end
       mod = PuppetSpec::Modules.create(
         name,
         @modpath,
@@ -357,35 +371,42 @@ describe Puppet::Module do
     end
   end
 
-  [:plugins, :templates, :files, :manifests].each do |filetype|
-    dirname = filetype == :plugins ? "lib" : filetype.to_s
+  [:plugins, :pluginfacts, :templates, :files, :manifests].each do |filetype|
+    case filetype
+      when :plugins
+        dirname = "lib"
+      when :pluginfacts
+        dirname = "facts.d"
+      else
+        dirname = filetype.to_s
+    end
     it "should be able to return individual #{filetype}" do
       module_file = File.join(path, dirname, "my/file")
-      FileTest.expects(:exist?).with(module_file).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == module_file
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       module_file = File.join(path, dirname)
-      FileTest.expects(:exist?).with(module_file).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns true
       mod.send(filetype.to_s + "?").should be_true
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       module_file = File.join(path, dirname)
-      FileTest.expects(:exist?).with(module_file).returns false
+      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns false
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       module_file = File.join(path, dirname, "my/file")
-      FileTest.expects(:exist?).with(module_file).returns false
+      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns false
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       base = File.join(path, dirname)
-      FileTest.expects(:exist?).with(base).returns true
+      Puppet::FileSystem::File.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
@@ -418,8 +439,8 @@ describe Puppet::Module, "when finding matching manifests" do
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
-    FileTest.expects(:exist?).with("/a/manifests/init.pp").returns(true)
-    FileTest.expects(:exist?).with("/a/manifests/init.rb").returns(false)
+    Puppet::FileSystem::File.expects(:exist?).with("/a/manifests/init.pp").returns(true)
+    Puppet::FileSystem::File.expects(:exist?).with("/a/manifests/init.rb").returns(false)
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
@@ -471,21 +492,21 @@ describe Puppet::Module do
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
-    FileTest.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     @module.should be_has_metadata
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
-    FileTest.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     @module.should be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is empty" do
-    FileTest.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "/*
 +-----------------------------------------------------------------------+
 |                                                                       |
@@ -503,7 +524,7 @@ describe Puppet::Module do
   end
 
   it "should know if it is missing a metadata file" do
-    FileTest.expects(:exist?).with(@module.metadata_file).returns false
+    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns false
 
     @module.should_not be_has_metadata
   end
@@ -519,6 +540,13 @@ describe Puppet::Module do
     Puppet::Module.new("yay", "/path", mock("env"))
   end
 
+  it "should tolerate failure to parse" do
+    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
+    File.stubs(:read).with(@module.metadata_file).returns(my_fixture('trailing-comma.json'))
+
+    @module.has_metadata?.should be_false
+  end
+
   def a_module_with_metadata(data)
     text = data.to_pson
 

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -8,9 +8,9 @@ describe Puppet::ModuleTool::Tar::Gnu do
   let(:destfile)   { '/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("tar xzf #{sourcefile} --no-same-permissions --no-same-owner -C #{destdir}")
+    Puppet::Util::Execution.expects(:execute).with("tar xzf #{sourcefile} --no-same-owner -C #{destdir}")
     Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type d -exec chmod 755 {} +")
-    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod 644 {} +")
+    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod a-wst {} +")
     Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> #{destdir}")
     subject.unpack(sourcefile, destdir, '<owner:group>')
   end

data/spec/unit/module_tool/tar/solaris_spec.rb

@@ -8,9 +8,9 @@ describe Puppet::ModuleTool::Tar::Solaris do
   let(:destfile)   { '/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("gtar xzf #{sourcefile} --no-same-permissions --no-same-owner -C #{destdir}")
+    Puppet::Util::Execution.expects(:execute).with("gtar xzf #{sourcefile} --no-same-owner -C #{destdir}")
     Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type d -exec chmod 755 {} +")
-    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod 644 {} +")
+    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod a-wst {} +")
     Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> #{destdir}")
     subject.unpack(sourcefile, destdir, '<owner:group>')
   end

data/spec/unit/module_tool/tar_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'puppet/module_tool/tar'
+
+describe Puppet::ModuleTool::Tar do
+
+  it "uses gtar when present on Solaris" do
+    Facter.stubs(:value).with('osfamily').returns 'Solaris'
+    Puppet::Util.stubs(:which).with('gtar').returns '/usr/bin/gtar'
+
+    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Solaris
+  end
+
+  it "uses gtar when present on OpenBSD" do
+    Facter.stubs(:value).with('osfamily').returns 'OpenBSD'
+    Puppet::Util.stubs(:which).with('gtar').returns '/usr/bin/gtar'
+
+    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Solaris
+  end
+
+  it "uses tar when present and not on Windows" do
+    Facter.stubs(:value).with('osfamily').returns 'ObscureLinuxDistro'
+    Puppet::Util.stubs(:which).with('tar').returns '/usr/bin/tar'
+    Puppet::Util::Platform.stubs(:windows?).returns false
+
+    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Gnu
+  end
+
+  it "falls back to minitar when it and zlib are present" do
+    Facter.stubs(:value).with('osfamily').returns 'Windows'
+    Puppet::Util.stubs(:which).with('tar')
+    Puppet::Util::Platform.stubs(:windows?).returns true
+    Puppet.stubs(:features).returns(stub(:minitar? => true, :zlib? => true))
+
+    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Mini
+  end
+
+  it "fails when there is no possible implementation" do
+    Facter.stubs(:value).with('osfamily').returns 'Windows'
+    Puppet::Util.stubs(:which).with('tar')
+    Puppet::Util::Platform.stubs(:windows?).returns true
+    Puppet.stubs(:features).returns(stub(:minitar? => false, :zlib? => false))
+
+    expect { described_class.instance(nil) }.to raise_error RuntimeError, /No suitable tar/
+  end
+end

data/spec/unit/network/authconfig_spec.rb

@@ -5,7 +5,8 @@ require 'puppet/network/authconfig'
 
 describe Puppet::Network::AuthConfig do
   before :each do
-    File.stubs(:stat).returns(stub('stat', :ctime => :now))
+    stub_file = stub('file', :stat => stub('stat', :ctime => :now))
+    Puppet::FileSystem::File.stubs(:new).returns stub_file
     Time.stubs(:now).returns Time.now
 
     Puppet::Network::AuthConfig.any_instance.stubs(:exists?).returns(true)

data/spec/unit/network/authentication_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Network::Authentication do
   describe "when warning about upcoming expirations" do
     before do
       Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-      FileTest.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.stubs(:exist?).returns(false)
     end
 
     it "should check the expiration of the CA certificate" do
@@ -34,7 +34,7 @@ describe Puppet::Network::Authentication do
     it "should check the expiration of the localhost certificate" do
       Puppet::SSL::Host.stubs(:localhost).returns(host)
       cert.expects(:near_expiration?).returns(false)
-      FileTest.stubs(:exist?).with(Puppet[:hostcert]).returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).with(Puppet[:hostcert]).returns(true)
       subject.warn_if_near_expiration
     end
 

data/spec/unit/network/format_handler_spec.rb

@@ -63,8 +63,8 @@ describe Puppet::Network::FormatHandler do
       Puppet::Network::FormatHandler.most_suitable_format_for(accepted, [:one, :two])
     end
 
-    it "finds either format when anything is accepted" do
-      [format_one, format_two].should include(suitable_in_setup_formats(["*/*"]))
+    it "finds the most preferred format when anything is acceptable" do
+      Puppet::Network::FormatHandler.most_suitable_format_for(["*/*"], [:two, :one]).should == format_two
     end
 
     it "finds no format when none are acceptable" do

data/spec/unit/network/formats_spec.rb

@@ -26,6 +26,30 @@ class PsonTest
 end
 
 describe "Puppet Network Format" do
+  it "should include a msgpack format", :if => Puppet.features.msgpack? do
+    Puppet::Network::FormatHandler.format(:msgpack).should_not be_nil
+  end
+
+  describe "msgpack", :if => Puppet.features.msgpack? do
+    before do
+      @msgpack = Puppet::Network::FormatHandler.format(:msgpack)
+    end
+
+    it "should have its mime type set to application/x-msgpack" do
+      @msgpack.mime.should == "application/x-msgpack"
+    end
+
+    it "should have a weight of 20" do
+      @msgpack.weight.should == 20
+    end
+
+    it "should fail when one element does not have a from_pson" do
+      expect do
+        @msgpack.intern_multiple(Hash, MessagePack.pack(["foo"]))
+      end.to raise_error(NoMethodError)
+    end
+  end
+
   it "should include a yaml format" do
     Puppet::Network::FormatHandler.format(:yaml).should_not be_nil
   end

data/spec/unit/network/http/connection_spec.rb

@@ -7,19 +7,13 @@ describe Puppet::Network::HTTP::Connection do
 
   let (:host) { "me" }
   let (:port) { 54321 }
-  subject { Puppet::Network::HTTP::Connection.new(host, port) }
+  subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator) }
 
   context "when providing HTTP connections" do
     after do
       Puppet::Network::HTTP::Connection.instance_variable_set("@ssl_host", nil)
     end
 
-    it "should use the global SSL::Host instance to get its certificate information" do
-      host = mock 'host'
-      Puppet::SSL::Host.expects(:localhost).with.returns host
-      subject.send(:ssl_host).should equal(host)
-    end
-
     context "when initializing http instances" do
       before :each do
         # All of the cert stuff is tested elsewhere
@@ -39,51 +33,12 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "can set ssl using an option" do
-        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false).send(:connection).should_not be_use_ssl
-        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true).send(:connection).should be_use_ssl
-      end
-
-      describe "peer verification" do
-        def setup_standard_ssl_configuration
-          ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
-          FileTest.stubs(:exist?).with(ca_cert_file).returns(true)
-
-          ssl_configuration = stub('ssl_configuration', :ca_auth_file => ca_cert_file)
-          Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_configuration).returns(ssl_configuration)
-        end
-
-        def setup_standard_hostcert
-          host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-          FileTest.stubs(:exist?).with(host_cert_file).returns(true)
-
-          Puppet[:hostcert] = host_cert_file
-        end
-
-        def setup_standard_ssl_host
-          cert = stub('cert', :content => 'real_cert')
-          key  = stub('key',  :content => 'real_key')
-          host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
-
-          Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_host).returns(host)
-        end
-
-        before do
-          setup_standard_ssl_configuration
-          setup_standard_hostcert
-          setup_standard_ssl_host
-        end
-
-        it "can enable peer verification" do
-          Puppet::Network::HTTP::Connection.new(host, port, :verify_peer => true).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_PEER
-        end
-
-        it "can disable peer verification" do
-          Puppet::Network::HTTP::Connection.new(host, port, :verify_peer => false).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_NONE
-        end
+        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator).send(:connection).should_not be_use_ssl
+        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true, :verify => Puppet::SSL::Validator.no_validator).send(:connection).should be_use_ssl
       end
 
       context "proxy and timeout settings should propagate" do
-        subject { Puppet::Network::HTTP::Connection.new(host, port).send(:connection) }
+        subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator).send(:connection) }
         before :each do
           Puppet[:http_proxy_host] = "myhost"
           Puppet[:http_proxy_port] = 432
@@ -104,94 +59,13 @@ describe Puppet::Network::HTTP::Connection do
       it "should raise Puppet::Error when invalid options are specified" do
         expect { Puppet::Network::HTTP::Connection.new(host, port, :invalid_option => nil) }.to raise_error(Puppet::Error, 'Unrecognized option(s): :invalid_option')
       end
-
-    end
-
-    describe "when doing SSL setup for http instances" do
-      let :store do stub('store') end
-
-      let :ca_auth_file do
-        '/path/to/ssl/certs/ssl_server_ca_auth.pem'
-      end
-
-      let :ssl_configuration do
-        stub('ssl_configuration', :ca_auth_file => ca_auth_file)
-      end
-
-      before :each do
-        Puppet[:hostcert]    = '/host/cert'
-        Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_configuration).returns(ssl_configuration)
-
-        cert  = stub 'cert', :content => 'real_cert'
-        key   = stub 'key',  :content => 'real_key'
-        host  = stub 'host', :certificate => cert, :key => key, :ssl_store => store
-        Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_host).returns(host)
-      end
-
-      shared_examples "HTTPS setup without all certificates" do
-        subject { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true).send(:connection) }
-
-        it                { should be_use_ssl }
-        its(:cert)        { should be_nil }
-        its(:ca_file)     { should be_nil }
-        its(:key)         { should be_nil }
-        its(:verify_mode) { should == OpenSSL::SSL::VERIFY_NONE }
-      end
-
-      context "with neither a host cert or a local CA cert" do
-        before :each do
-          FileTest.stubs(:exist?).with(Puppet[:hostcert]).returns(false)
-          FileTest.stubs(:exist?).with(ca_auth_file).returns(false)
-        end
-
-        include_examples "HTTPS setup without all certificates"
-      end
-
-      context "with there is no host certificate" do
-        before :each do
-          FileTest.stubs(:exist?).with(Puppet[:hostcert]).returns(false)
-          FileTest.stubs(:exist?).with(ca_auth_file).returns(true)
-        end
-
-        include_examples "HTTPS setup without all certificates"
-      end
-
-      context "with there is no local CA certificate" do
-        before :each do
-          FileTest.stubs(:exist?).with(Puppet[:hostcert]).returns(true)
-          FileTest.stubs(:exist?).with(ca_auth_file).returns(false)
-        end
-
-        include_examples "HTTPS setup without all certificates"
-      end
-
-      context "with both the host and CA cert" do
-        subject { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true).send(:connection) }
-
-        before :each do
-          FileTest.expects(:exist?).with(Puppet[:hostcert]).returns(true)
-          FileTest.expects(:exist?).with(ca_auth_file).returns(true)
-        end
-
-        it                { should be_use_ssl }
-        its(:cert_store)  { should equal store }
-        its(:cert)        { should == "real_cert" }
-        its(:key)         { should == "real_key" }
-        its(:verify_mode) { should == OpenSSL::SSL::VERIFY_PEER }
-        its(:ca_file)     { should == ca_auth_file }
-      end
-
-      it "should set up certificate information when creating http instances" do
-        subject.expects(:cert_setup)
-        subject.send(:connection)
-      end
     end
   end
 
   context "when methods that accept a block are called with a block" do
     let (:host) { "my_server" }
     let (:port) { 8140 }
-    let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false) }
+    let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
     let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
@@ -228,95 +102,99 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
     let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
-    let (:subject) { Puppet::Network::HTTP::Connection.new(host, port) }
-
-    def a_connection_that_verifies(args)
-      connection = Net::HTTP.new(host, port)
-      connection.stubs(:warn_if_near_expiration)
-      connection.stubs(:get).with do
-        connection.verify_callback.call(args[:has_passed_pre_checks], args[:in_context])
-        true
-      end.raises(OpenSSL::SSL::SSLError.new(args[:fails_with]))
-      connection
-    end
-
-    def a_store_context(args)
-      Puppet[:confdir] = tmpdir('conf')
-      ssl_context = mock('OpenSSL::X509::StoreContext')
-      if args[:verify_raises]
-        ssl_context.stubs(:current_cert).raises("oh noes")
-      else
-        cert = Puppet::SSL::CertificateAuthority.new.generate(args[:for_server], :dns_alt_names => args[:for_aliases]).content
-        ssl_context.stubs(:current_cert).returns(cert)
-      end
-      ssl_context.stubs(:chain).returns([])
-      ssl_context.stubs(:error_string).returns(args[:with_error_string])
-      ssl_context
-    end
 
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
-      subject.stubs(:create_connection).
-          returns(a_connection_that_verifies(:has_passed_pre_checks => false,
-                                             :in_context => a_store_context(:for_server => 'not_my_server',
-                                                                            :with_error_string => 'shady looking signature'),
-                                             :fails_with => 'certificate verify failed'))
-      expect do
-        subject.request(:get, stub('request'))
-      end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature for /CN=not_my_server]")
-    end
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(:fails_with => 'certificate verify failed',
+                                              :error_string => 'shady looking signature'))
 
-    it "should provide a useful error message when verify_callback raises", :unless => Puppet.features.microsoft_windows? do
-      subject.stubs(:create_connection).
-          returns(a_connection_that_verifies(:has_passed_pre_checks => false,
-                                             :in_context => a_store_context(:verify_raises => true),
-                                             :fails_with => 'certificate verify failed'))
       expect do
-        subject.request(:get, stub('request'))
-      end.to raise_error(Puppet::Error, "certificate verify failed: [oh noes]")
+        connection.get('request')
+      end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature]")
     end
 
     it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet.features.microsoft_windows? do
-      subject.stubs(:create_connection).
-          returns(a_connection_that_verifies(:has_passed_pre_checks => true,
-                                             :in_context => a_store_context(:for_server => 'not_my_server',
-                                                                            :for_aliases => 'foo,bar,baz'),
-                                             :fails_with => 'hostname was not match with server certificate'))
-
-      expect { subject.request(:get, stub('request')) }.
-          to raise_error(Puppet::Error) do |error|
+      Puppet[:confdir] = tmpdir('conf')
+
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(
+          :fails_with => 'hostname was not match with server certificate',
+          :peer_certs => [Puppet::SSL::CertificateAuthority.new.generate(
+            'not_my_server', :dns_alt_names => 'foo,bar,baz')]))
+
+      expect do
+        connection.get('request')
+      end.to raise_error(Puppet::Error) do |error|
         error.message =~ /Server hostname 'my_server' did not match server certificate; expected one of (.+)/
         $1.split(', ').should =~ %w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server]
       end
     end
 
     it "should pass along the error message otherwise" do
-      connection = Net::HTTP.new('my_server', 8140)
-      subject.stubs(:create_connection).returns(connection)
-
-      connection.stubs(:get).raises(OpenSSL::SSL::SSLError.new('some other message'))
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => ConstantErrorValidator.new(:fails_with => 'some other message'))
 
       expect do
-        subject.request(:get, stub('request'))
+        connection.get('request')
       end.to raise_error(/some other message/)
     end
 
     it "should check all peer certificates for upcoming expiration", :unless => Puppet.features.microsoft_windows? do
-      connection = Net::HTTP.new('my_server', 8140)
-      subject.stubs(:create_connection).returns(connection)
+      Puppet[:confdir] = tmpdir('conf')
+      cert = Puppet::SSL::CertificateAuthority.new.generate(
+        'server', :dns_alt_names => 'foo,bar,baz')
+
+      connection = Puppet::Network::HTTP::Connection.new(
+        host, port,
+        :verify => NoProblemsValidator.new(cert))
 
-      cert = stubs 'cert'
-      Puppet::SSL::Certificate.expects(:from_instance).twice.returns(cert)
+      Net::HTTP.any_instance.stubs(:get).returns(httpok)
 
-      connection.stubs(:get).with do
-        context = a_store_context(:for_server => 'a_server', :with_error_string => false)
-        connection.verify_callback.call(true, context)
-        connection.verify_callback.call(true, context)
-        true
-      end.returns(httpok)
+      connection.expects(:warn_if_near_expiration).with(cert)
 
-      subject.expects(:warn_if_near_expiration).with(cert, cert)
+      connection.get('request')
+    end
+
+    class ConstantErrorValidator
+      def initialize(args)
+        @fails_with = args[:fails_with]
+        @error_string = args[:error_string] || ""
+        @peer_certs = args[:peer_certs] || []
+      end
 
-      subject.request(:get, stubs('request'))
+      def setup_connection(connection)
+        connection.stubs(:get).with do
+          true
+        end.raises(OpenSSL::SSL::SSLError.new(@fails_with))
+      end
+
+      def peer_certs
+        @peer_certs
+      end
+
+      def verify_errors
+        [@error_string]
+      end
+    end
+
+    class NoProblemsValidator
+      def initialize(cert)
+        @cert = cert
+      end
+
+      def setup_connection(connection)
+      end
+
+      def peer_certs
+        [@cert]
+      end
+
+      def verify_errors
+        []
+      end
     end
   end
 
@@ -324,7 +202,7 @@ describe Puppet::Network::HTTP::Connection do
     let (:other_host) { "redirected" }
     let (:other_port) { 9292 }
     let (:other_path) { "other-path" }
-    let (:subject) { Puppet::Network::HTTP::Connection.new("my_server", 8140, :use_ssl => false) }
+    let (:subject) { Puppet::Network::HTTP::Connection.new("my_server", 8140, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
     let (:httpredirection) { Net::HTTPFound.new('1.1', 302, 'Moved Temporarily') }
     let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
@@ -356,5 +234,4 @@ describe Puppet::Network::HTTP::Connection do
       }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
     end
   end
-
 end