puppet 6.16.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/face/module/search_spec.rb

@@ -1,231 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/application/module'
-require 'puppet/module_tool'
-
-describe "puppet module search" do
-  subject { Puppet::Face[:module, :current] }
-
-  let(:options) do
-    {}
-  end
-
-  describe Puppet::Application::Module do
-    subject do
-      app = Puppet::Application::Module.new
-      allow(app).to receive(:action).and_return(Puppet::Face.find_action(:module, :search))
-      app
-    end
-
-    before do
-      subject.render_as = :console
-      allow(Puppet::Util::Terminal).to receive(:width).and_return(100)
-    end
-
-    it 'should output nothing when receiving an empty dataset' do
-      expect(subject.render({:answers => [], :result => :success}, ['apache', {}])).to eq("No results found for 'apache'.")
-    end
-
-    it 'should return error and exit when error returned' do
-      results = {
-        :result => :failure,
-        :error => {
-          :oneline => 'Something failed',
-          :multiline => 'Something failed',
-        }
-      }
-      expect { subject.render(results, ['apache', {}]) }.to raise_error 'Something failed'
-    end
-
-    it 'should output a header when receiving a non-empty dataset' do
-      results = {
-        :result => :success,
-        :answers => [
-          {'full_name' => '', 'author' => '', 'desc' => '', 'tag_list' => [] },
-        ],
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/NAME/)
-      expect(subject.render(results, ['apache', {}])).to match(/DESCRIPTION/)
-      expect(subject.render(results, ['apache', {}])).to match(/AUTHOR/)
-      expect(subject.render(results, ['apache', {}])).to match(/KEYWORDS/)
-    end
-
-    it 'should output the relevant fields when receiving a non-empty dataset' do
-      results = {
-        :result => :success,
-        :answers => [
-          {'full_name' => 'Name', 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/Name/)
-      expect(subject.render(results, ['apache', {}])).to match(/Author/)
-      expect(subject.render(results, ['apache', {}])).to match(/Summary/)
-      expect(subject.render(results, ['apache', {}])).to match(/tag1/)
-      expect(subject.render(results, ['apache', {}])).to match(/tag2/)
-    end
-
-    it 'should mark deprecated modules in search results' do
-      results = {
-        :result => :success,
-        :answers => [
-          {'full_name' => 'puppetlabs-corosync', 'deprecated_at' => Time.new, 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/puppetlabs-corosync.*DEPRECATED/i)
-    end
-
-    it 'should elide really long descriptions' do
-      results = {
-        :result => :success,
-        :answers => [
-          {
-            'full_name' => 'Name',
-            'author' => 'Author',
-            'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
-            'tag_list' => ['tag1', 'tag2'],
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/\.{3}  @Author/)
-    end
-
-    it 'should never truncate the module name' do
-      results = {
-        :result => :success,
-        :answers => [
-          {
-            'full_name' => 'This-module-has-a-really-really-long-name',
-            'author' => 'Author',
-            'desc' => 'Description',
-            'tag_list' => ['tag1', 'tag2'],
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/This-module-has-a-really-really-long-name/)
-    end
-
-    it 'should never truncate the author name' do
-      results = {
-        :result => :success,
-        :answers => [
-          {
-            'full_name' => 'Name',
-            'author' => 'This-author-has-a-really-really-long-name',
-            'desc' => 'Description',
-            'tag_list' => ['tag1', 'tag2'],
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/@This-author-has-a-really-really-long-name/)
-    end
-
-    it 'should never remove tags that match the search term' do
-      results = {
-        :results => :success,
-        :answers => [
-          {
-            'full_name' => 'Name',
-            'author' => 'Author',
-            'desc' => 'Description',
-            'tag_list' => ['Supercalifragilisticexpialidocious'] + (1..100).map { |i| "tag#{i}" },
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['Supercalifragilisticexpialidocious', {}])).to match(/Supercalifragilisticexpialidocious/)
-      expect(subject.render(results, ['Supercalifragilisticexpialidocious', {}])).not_to match(/tag/)
-    end
-
-    {
-      100 => "NAME          DESCRIPTION                                     AUTHOR         KEYWORDS#{' '*15}\n"\
-             "Name          This description is really too long to fit ...  @JohnnyApples  tag1 tag2 taggitty3#{' '*4}\n",
-
-      70  => "NAME          DESCRIPTION                 AUTHOR         KEYWORDS#{' '*5}\n"\
-             "Name          This description is rea...  @JohnnyApples  tag1 tag2#{' '*4}\n",
-
-      80  => "NAME          DESCRIPTION                        AUTHOR         KEYWORDS#{' '*8}\n"\
-             "Name          This description is really too...  @JohnnyApples  tag1 tag2#{' '*7}\n",
-
-      200 => "NAME          DESCRIPTION                                                                                                        AUTHOR         KEYWORDS#{' '*48}\n"\
-             "Name          This description is really too long to fit in a single data table, guys -- we should probably set about trunca...  @JohnnyApples  tag1 tag2 taggitty3#{' '*37}\n"
-    }.each do |width, expectation|
-      it "should resize the table to fit the screen, when #{width} columns" do
-        results = {
-          :result => :success,
-          :answers => [
-            {
-              'full_name' => 'Name',
-              'author' => 'JohnnyApples',
-              'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
-              'tag_list' => ['tag1', 'tag2', 'taggitty3'],
-            },
-          ]
-        }
-
-        expect(Puppet::Util::Terminal).to receive(:width).and_return(width)
-        result = subject.render(results, ['apache', {}])
-        expect(result.lines.sort_by(&:length).last.chomp.length).to be <= width
-        expect(result).to eq(expectation)
-      end
-    end
-  end
-
-  describe "option validation" do
-    context "without any options" do
-      it "should require a search term" do
-        pattern = /wrong number of arguments/
-        expect { subject.search }.to raise_error ArgumentError, pattern
-      end
-    end
-
-    it "should accept the --module_repository option" do
-      forge = double("Puppet::Forge")
-      searcher = double("Searcher")
-      options[:module_repository] = "http://forge.example.com"
-
-      expect(Puppet::Forge).to receive(:new).with("http://forge.example.com").and_return(forge)
-      expect(Puppet::ModuleTool::Applications::Searcher).to receive(:new).with("puppetlabs-apache", forge, hash_including(options)).and_return(searcher)
-      expect(searcher).to receive(:run)
-
-      subject.search("puppetlabs-apache", options)
-    end
-  end
-
-  describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action :search }
-
-    its(:summary)     { should =~ /search.*module/im }
-    its(:description) { should =~ /search.*module/im }
-    its(:returns)     { should =~ /array/i }
-    its(:examples)    { should_not be_empty }
-
-    %w{ license copyright summary description returns examples }.each do |doc|
-      context "of the" do
-        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
-      end
-    end
-  end
-
-  it "should include a deprecation warning" do
-    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
-
-    subject.search("puppetlabs-apache")
-
-    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /This action has been deprecated. Please use the Puppet Forge to search for modules./))
-  end
-
-  it "omits the warning when deprecations are disabled" do
-    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
-
-    Puppet[:disable_warnings] = 'deprecations'
-    subject.search("puppetlabs-apache")
-
-    expect(@logs).not_to include(an_object_having_attributes(level: :warning))
-  end
-end

data/spec/unit/face/module_spec.rb

@@ -1,3 +0,0 @@
-# For face related tests, look in the spec/unit/faces/module folder.
-# For integration tests, which test the behavior of module, look in the
-# spec/unit/integration folder.

data/spec/unit/face/status_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-
-describe Puppet::Face[:status, '0.0.1'] do
-  it "should be deprecated" do
-    expect(subject.deprecated?).to be_truthy
-  end
-end
-

data/spec/unit/indirector/certificate/file_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/certificate/file'
-
-describe Puppet::SSL::Certificate::File do
-  it "should have documentation" do
-    expect(Puppet::SSL::Certificate::File.doc).to be_instance_of(String)
-  end
-
-  it "should use the :certdir as the collection directory" do
-    Puppet[:certdir] = File.expand_path("/cert/dir")
-    expect(Puppet::SSL::Certificate::File.collection_directory).to eq(Puppet[:certdir])
-  end
-end

data/spec/unit/indirector/certificate/rest_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/certificate/rest'
-
-describe Puppet::SSL::Certificate::Rest do
-  before do
-    @searcher = Puppet::SSL::Certificate::Rest.new
-  end
-
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::SSL::Certificate::Rest.superclass).to equal(Puppet::Indirector::REST)
-  end
-
-  it "should set server_setting to :ca_server" do
-    expect(Puppet::SSL::Certificate::Rest.server_setting).to eq(:ca_server)
-  end
-
-  it "should set port_setting to :ca_port" do
-    expect(Puppet::SSL::Certificate::Rest.port_setting).to eq(:ca_port)
-  end
-
-  it "should use the :ca SRV service" do
-    expect(Puppet::SSL::Certificate::Rest.srv_service).to eq(:ca)
-  end
-
-  it "should make sure found certificates have their names set to the search string" do
-    terminus = Puppet::SSL::Certificate::Rest.new
-
-    # This has 'boo.com' in the CN
-    cert_string = "-----BEGIN CERTIFICATE-----
-MIICPzCCAaigAwIBAgIBBDANBgkqhkiG9w0BAQUFADAWMRQwEgYDVQQDDAtidWNr
-eS5sb2NhbDAeFw0wOTA5MTcxNzI1MzJaFw0xNDA5MTYxNzI1MzJaMBIxEDAOBgNV
-BAMMB2Jvby5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKG9B+DkTCNh
-F5xHchNDfnbC9NzWKM600oxrr84pgUVAG6B2wAZcdfoEtXszhsY9Jzpwqkvxk4Mx
-AbYqo9+TCi4UoiH6e+vAKOOJD3DHrlf+/RW4hGtyaI41DBhf4+B4/oFz5PH9mvKe
-NSfHFI/yPW+1IXYjxKLQNwF9E7q3JbnzAgMBAAGjgaAwgZ0wOAYJYIZIAYb4QgEN
-BCsWKVB1cHBldCBSdWJ5L09wZW5TU0wgR2VuZXJhdGVkIENlcnRpZmljYXRlMAwG
-A1UdEwEB/wQCMAAwHQYDVR0OBBYEFJOxEUeyf4cNOBmf9zIaE1JTuNdLMAsGA1Ud
-DwQEAwIFoDAnBgNVHSUEIDAeBggrBgEFBQcDAQYIKwYBBQUHAwIGCCsGAQUFBwME
-MA0GCSqGSIb3DQEBBQUAA4GBAFTJxKprMg6tfhGnvEvURPmlJrINn9c2b5Y4AGYp
-tO86PFFkWw/EIJvvJzbj3s+Butr+eUo//+f1xxX7UCwwGqGxKqjtVS219oU/wkx8
-h7rW4Xk7MrLl0auSS1p4wLcAMm+ZImf94+j8Cj+tkr8eGozZceRV13b8+EkdaE3S
-rn/G
------END CERTIFICATE-----
-"
-
-    network = double('network')
-    allow(terminus).to receive(:network).and_return(network)
-
-    response = double('response', :code => "200", :body => cert_string)
-    allow(response).to receive(:[]).with('content-type').and_return("text/plain")
-    allow(response).to receive(:[]).with('content-encoding')
-    allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
-    allow(network).to receive(:verify_callback=)
-    expect(network).to receive(:get).and_return(response)
-
-    request = Puppet::Indirector::Request.new(:certificate, :find, "foo.com", nil)
-    result = terminus.find(request)
-    expect(result).not_to be_nil
-    expect(result.name).to eq("foo.com")
-  end
-end

data/spec/unit/indirector/certificate_request/file_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/certificate_request/file'
-
-describe Puppet::SSL::CertificateRequest::File do
-  it "should have documentation" do
-    expect(Puppet::SSL::CertificateRequest::File.doc).to be_instance_of(String)
-  end
-
-  it "should use the :requestdir as the collection directory" do
-    Puppet[:requestdir] = File.expand_path("/request/dir")
-    expect(Puppet::SSL::CertificateRequest::File.collection_directory).to eq(Puppet[:requestdir])
-  end
-end

data/spec/unit/indirector/certificate_request/rest_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/certificate_request/rest'
-
-describe Puppet::SSL::CertificateRequest::Rest do
-  before do
-    @searcher = Puppet::SSL::CertificateRequest::Rest.new
-  end
-
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::SSL::CertificateRequest::Rest.superclass).to equal(Puppet::Indirector::REST)
-  end
-
-  it "should set server_setting to :ca_server" do
-    expect(Puppet::SSL::CertificateRequest::Rest.server_setting).to eq(:ca_server)
-  end
-
-  it "should set port_setting to :ca_port" do
-    expect(Puppet::SSL::CertificateRequest::Rest.port_setting).to eq(:ca_port)
-  end
-
-  it "should use the :ca SRV service" do
-    expect(Puppet::SSL::CertificateRequest::Rest.srv_service).to eq(:ca)
-  end
-end

data/spec/unit/indirector/key/file_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/key/file'
-
-describe Puppet::SSL::Key::File do
-  it "should have documentation" do
-    expect(Puppet::SSL::Key::File.doc).to be_instance_of(String)
-  end
-
-  it "should use the :privatekeydir as the collection directory" do
-    Puppet[:privatekeydir] = File.expand_path("/key/dir")
-    expect(Puppet::SSL::Key::File.collection_directory).to eq(Puppet[:privatekeydir])
-  end
-
-  describe "when choosing the path for the public key" do
-    it "should use the host name plus '.pem' in :publickeydir for normal hosts" do
-      Puppet[:privatekeydir] = File.expand_path("/private/key/dir")
-      Puppet[:publickeydir] = File.expand_path("/public/key/dir")
-      allow(Puppet.settings).to receive(:use)
-
-      @searcher = Puppet::SSL::Key::File.new
-      allow(@searcher).to receive(:ca?).and_return(false)
-      expect(@searcher.public_key_path("whatever")).to eq(File.expand_path("/public/key/dir/whatever.pem"))
-    end
-  end
-
-  describe "when managing private keys" do
-    before do
-      @searcher = Puppet::SSL::Key::File.new
-
-      @private_key_path = File.join("/fake/key/path")
-      @public_key_path = File.join("/other/fake/key/path")
-
-      allow(@searcher).to receive(:public_key_path).and_return(@public_key_path)
-      allow(@searcher).to receive(:path).and_return(@private_key_path)
-
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:writable?).and_return(true)
-
-      @public_key = double('public_key')
-      @real_key = double('sslkey', :public_key => @public_key)
-
-      @key = double('key', :name => "myname", :content => @real_key)
-
-      @request = double('request', :key => "myname", :instance => @key)
-    end
-
-    it "should save the public key when saving the private key" do
-      fh = StringIO.new
-
-      expect(Puppet.settings.setting(:publickeydir)).to receive(:open_file).with(@public_key_path, 'w:ASCII').and_yield(fh)
-      allow(Puppet.settings.setting(:privatekeydir)).to receive(:open_file)
-      expect(@public_key).to receive(:to_pem).and_return("my pem")
-
-      @searcher.save(@request)
-
-      expect(fh.string).to eq("my pem")
-    end
-
-    it "should destroy the public key when destroying the private key" do
-      expect(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
-      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
-
-      @searcher.destroy(@request)
-    end
-
-    it "should not fail if the public key does not exist when deleting the private key" do
-      allow(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
-
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).and_return(false)
-      expect(Puppet::FileSystem).not_to receive(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
-
-      @searcher.destroy(@request)
-    end
-  end
-end

data/spec/unit/indirector/ssl_file_spec.rb

@@ -1,305 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/ssl_file'
-
-describe Puppet::Indirector::SslFile do
-  include PuppetSpec::Files
-
-  before(:all) do
-    class Puppet::SslTestModel
-      extend Puppet::Indirector
-      indirects :ssl_test_model
-    end
-
-    class Puppet::SslTestModel::SslFile < Puppet::Indirector::SslFile
-    end
-
-    Puppet::SslTestModel.indirection.terminus_class = :ssl_file
-  end
-
-  after(:all) do
-    Puppet::SslTestModel.indirection.delete
-    Puppet.send(:remove_const, :SslTestModel)
-  end
-
-  let(:terminus_class) { Puppet::SslTestModel::SslFile }
-  let(:model) { Puppet::SslTestModel }
-
-  before :each do
-    @setting = :certdir
-    terminus_class.store_in @setting
-    terminus_class.store_at nil
-    @path = make_absolute("/thisdoesntexist/my_directory")
-    Puppet[:noop] = false
-    Puppet[@setting] = @path
-    Puppet[:trace] = false
-  end
-
-  after :each do
-    terminus_class.store_in nil
-    terminus_class.store_at nil
-  end
-
-  it "should use :main and :ssl upon initialization" do
-    expect(Puppet.settings).to receive(:use).with(:main, :ssl)
-    terminus_class.new
-  end
-
-  it "should return a nil collection directory if no directory setting has been provided" do
-    terminus_class.store_in nil
-    expect(terminus_class.collection_directory).to be_nil
-  end
-
-  it "should return a nil file location if no location has been provided" do
-    terminus_class.store_at nil
-    expect(terminus_class.file_location).to be_nil
-  end
-
-  it "should fail if no store directory or file location has been set" do
-    expect(Puppet.settings).to receive(:use).with(:main, :ssl)
-    terminus_class.store_in nil
-    terminus_class.store_at nil
-    expect {
-      terminus_class.new
-    }.to raise_error(Puppet::DevError, /No file or directory setting provided/)
-  end
-
-  describe "when managing ssl files" do
-    before do
-      allow(Puppet.settings).to receive(:use)
-      @searcher = terminus_class.new
-
-      @cert = double('certificate', :name => "myname")
-      @certpath = File.join(@path, "myname.pem")
-
-      @request = double('request', :key => @cert.name, :instance => @cert)
-    end
-
-    describe "when choosing the location for certificates" do
-      it "should set them at the file location if a file setting is available" do
-        terminus_class.store_in nil
-        terminus_class.store_at :hostcrl
-
-        Puppet[:hostcrl] = File.expand_path("/some/file")
-
-        expect(@searcher.path(@cert.name)).to eq(Puppet[:hostcrl])
-      end
-
-      it "should set them in the setting directory, with the certificate name plus '.pem', if a directory setting is available" do
-        expect(@searcher.path(@cert.name)).to eq(@certpath)
-      end
-
-      ['../foo', '..\\foo', './../foo', '.\\..\\foo',
-       '/foo', '//foo', '\\foo', '\\\\goo',
-       "test\0/../bar", "test\0\\..\\bar",
-       "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
-       " / bar", " /../ bar", " \\..\\ bar",
-       "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
-       "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
-       "//?/c:/foo",
-      ].each do |input|
-        it "should resist directory traversal attacks (#{input.inspect})" do
-          expect { @searcher.path(input) }.to raise_error(ArgumentError, /invalid key/)
-        end
-      end
-
-      # REVISIT: Should probably test MS-DOS reserved names here, too, since
-      # they would represent a vulnerability on a Win32 system, should we ever
-      # support that path.  Don't forget that 'CON.foo' == 'CON'
-      # --daniel 2011-09-24
-    end
-
-    describe "when finding certificates on disk" do
-      describe "and no certificate is present" do
-        it "should return nil" do
-          expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-          expect(Dir).to receive(:entries).with(@path).and_return([])
-          expect(Puppet::FileSystem).to receive(:exist?).with(@certpath).and_return(false)
-
-          expect(@searcher.find(@request)).to be_nil
-        end
-      end
-
-      describe "and a certificate is present" do
-        let(:cert) { double('cert') }
-        let(:model) { double('model') }
-
-        before(:each) do
-          allow(terminus_class).to receive(:model).and_return(model)
-        end
-
-        context "is readable" do
-          it "should return an instance of the model, which it should use to read the certificate" do
-            expect(Puppet::FileSystem).to receive(:exist?).with(@certpath).and_return(true)
-
-            expect(model).to receive(:new).with("myname").and_return(cert)
-            expect(cert).to receive(:read).with(@certpath)
-
-            expect(@searcher.find(@request)).to equal(cert)
-          end
-        end
-
-        context "is unreadable" do
-          it "should raise an exception" do
-            expect(Puppet::FileSystem).to receive(:exist?).with(@certpath).and_return(true)
-
-            expect(model).to receive(:new).with("myname").and_return(cert)
-            expect(cert).to receive(:read).with(@certpath).and_raise(Errno::EACCES)
-
-            expect {
-              @searcher.find(@request)
-            }.to raise_error(Errno::EACCES)
-          end
-        end
-      end
-
-      describe "and a certificate is present but has uppercase letters" do
-        before do
-          @request = double('request', :key => "myhost")
-        end
-
-        # This is kind of more an integration test; it's for #1382, until
-        # the support for upper-case certs can be removed around mid-2009.
-        it "should rename the existing file to the lower-case path" do
-          @path = @searcher.path("myhost")
-          expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(false)
-          dir, file = File.split(@path)
-          expect(Puppet::FileSystem).to receive(:exist?).with(dir).and_return(true)
-          expect(Dir).to receive(:entries).with(dir).and_return([".", "..", "something.pem", file.upcase])
-
-          expect(File).to receive(:rename).with(File.join(dir, file.upcase), @path)
-
-          cert = double('cert')
-          model = double('model')
-          allow(@searcher).to receive(:model).and_return(model)
-          expect(@searcher.model).to receive(:new).with("myhost").and_return(cert)
-          expect(cert).to receive(:read).with(@path)
-
-          @searcher.find(@request)
-        end
-      end
-    end
-
-    describe "when saving certificates to disk" do
-      before do
-        allow(FileTest).to receive(:directory?).and_return(true)
-        allow(FileTest).to receive(:writable?).and_return(true)
-      end
-
-      it "should fail if the directory is absent" do
-        expect(FileTest).to receive(:directory?).with(File.dirname(@certpath)).and_return(false)
-        expect { @searcher.save(@request) }.to raise_error(Puppet::Error)
-      end
-
-      it "should fail if the directory is not writeable" do
-        allow(FileTest).to receive(:directory?).and_return(true)
-        expect(FileTest).to receive(:writable?).with(File.dirname(@certpath)).and_return(false)
-        expect { @searcher.save(@request) }.to raise_error(Puppet::Error)
-      end
-
-      it "should save to the path the output of converting the certificate to a string" do
-        fh = double('filehandle')
-        expect(fh).to receive(:print).with("mycert")
-
-        allow(@searcher).to receive(:write).and_yield(fh)
-        expect(@cert).to receive(:to_s).and_return("mycert")
-
-        @searcher.save(@request)
-      end
-
-      describe "and a directory setting is set" do
-        it "should use the Settings class to write the file" do
-          @searcher.class.store_in @setting
-          fh = double('filehandle')
-          allow(fh).to receive(:print)
-          expect(Puppet.settings.setting(@setting)).to receive(:open_file).with(@certpath, 'w:ASCII').and_yield(fh)
-
-          @searcher.save(@request)
-        end
-      end
-
-      describe "and a file location is set" do
-        it "should use the filehandle provided by the Settings" do
-          @searcher.class.store_at @setting
-
-          fh = double('filehandle')
-          allow(fh).to receive(:print)
-          expect(Puppet.settings.setting(@setting)).to receive(:open).with('w:ASCII').and_yield(fh)
-          @searcher.save(@request)
-        end
-      end
-    end
-
-    describe "when destroying certificates" do
-      describe "that do not exist" do
-        before do
-          expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@certpath)).and_return(false)
-        end
-
-        it "should return false" do
-          expect(@searcher.destroy(@request)).to be_falsey
-        end
-      end
-
-      describe "that exist" do
-        it "should unlink the certificate file" do
-          path = Puppet::FileSystem.pathname(@certpath)
-          expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-          expect(Puppet::FileSystem).to receive(:unlink).with(path)
-          @searcher.destroy(@request)
-        end
-
-        it "should log that is removing the file" do
-          allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-          allow(Puppet::FileSystem).to receive(:unlink)
-          expect(Puppet).to receive(:notice)
-          @searcher.destroy(@request)
-        end
-      end
-    end
-
-    describe "when searching for certificates" do
-      let(:one) { double('one') }
-      let(:two) { double('two') }
-      let(:one_path) { File.join(@path, 'one.pem') }
-      let(:two_path) { File.join(@path, 'two.pem') }
-      let(:model) { double('model') }
-
-      before :each do
-        allow(terminus_class).to receive(:model).and_return(model)
-      end
-
-      it "should return a certificate instance for all files that exist" do
-        expect(Dir).to receive(:entries).with(@path).and_return(%w{. .. one.pem two.pem})
-
-        expect(model).to receive(:new).with("one").and_return(one)
-        expect(one).to receive(:read).with(one_path)
-        expect(model).to receive(:new).with("two").and_return(two)
-        expect(two).to receive(:read).with(two_path)
-
-        expect(@searcher.search(@request)).to eq([one, two])
-      end
-
-      it "should raise an exception if any file is unreadable" do
-        expect(Dir).to receive(:entries).with(@path).and_return(%w{. .. one.pem two.pem})
-
-        expect(model).to receive(:new).with("one").and_return(one)
-        expect(one).to receive(:read).with(one_path)
-        expect(model).to receive(:new).with("two").and_return(two)
-        expect(two).to receive(:read).and_raise(Errno::EACCES)
-
-        expect {
-          @searcher.search(@request)
-        }.to raise_error(Errno::EACCES)
-      end
-
-      it "should skip any files that do not match /\.pem$/" do
-        expect(Dir).to receive(:entries).with(@path).and_return(%w{. .. one two.notpem})
-
-        expect(model).not_to receive(:new)
-
-        expect(@searcher.search(@request)).to eq([])
-      end
-    end
-  end
-end