puppet 3.8.7 → 4.0.0.rc1

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

@@ -21,12 +21,12 @@ describe Puppet::SSL::CertificateRequest::Ca, :unless => Puppet.features.microso
   end
 
   it "should have documentation" do
-    Puppet::SSL::CertificateRequest::Ca.doc.should be_instance_of(String)
+    expect(Puppet::SSL::CertificateRequest::Ca.doc).to be_instance_of(String)
   end
 
   it "should use the :csrdir as the collection directory" do
     Puppet[:csrdir] = File.expand_path("/request/dir")
-    Puppet::SSL::CertificateRequest::Ca.collection_directory.should == Puppet[:csrdir]
+    expect(Puppet::SSL::CertificateRequest::Ca.collection_directory).to eq(Puppet[:csrdir])
   end
 
   it "should overwrite the previous certificate request if allow_duplicate_certs is true" do
@@ -37,9 +37,9 @@ describe Puppet::SSL::CertificateRequest::Ca, :unless => Puppet.features.microso
 
     Puppet::SSL::Host.indirection.find("foo").generate_certificate_request
 
-    Puppet::SSL::Certificate.indirection.find("foo").name.should == "foo"
-    Puppet::SSL::CertificateRequest.indirection.find("foo").name.should == "foo"
-    Puppet::SSL::Host.indirection.find("foo").state.should == "requested"
+    expect(Puppet::SSL::Certificate.indirection.find("foo").name).to eq("foo")
+    expect(Puppet::SSL::CertificateRequest.indirection.find("foo").name).to eq("foo")
+    expect(Puppet::SSL::Host.indirection.find("foo").state).to eq("requested")
   end
 
   it "should reject a new certificate request if allow_duplicate_certs is false" do
@@ -50,8 +50,8 @@ describe Puppet::SSL::CertificateRequest::Ca, :unless => Puppet.features.microso
 
     expect { Puppet::SSL::Host.indirection.find("bar").generate_certificate_request }.to raise_error(/ignoring certificate request/)
 
-    Puppet::SSL::Certificate.indirection.find("bar").name.should == "bar"
-    Puppet::SSL::CertificateRequest.indirection.find("bar").should be_nil
-    Puppet::SSL::Host.indirection.find("bar").state.should == "signed"
+    expect(Puppet::SSL::Certificate.indirection.find("bar").name).to eq("bar")
+    expect(Puppet::SSL::CertificateRequest.indirection.find("bar")).to be_nil
+    expect(Puppet::SSL::Host.indirection.find("bar").state).to eq("signed")
   end
 end

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

@@ -5,11 +5,11 @@ require 'puppet/indirector/certificate_request/file'
 
 describe Puppet::SSL::CertificateRequest::File do
   it "should have documentation" do
-    Puppet::SSL::CertificateRequest::File.doc.should be_instance_of(String)
+    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")
-    Puppet::SSL::CertificateRequest::File.collection_directory.should == Puppet[:requestdir]
+    expect(Puppet::SSL::CertificateRequest::File.collection_directory).to eq(Puppet[:requestdir])
   end
 end

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

@@ -9,18 +9,18 @@ describe Puppet::SSL::CertificateRequest::Rest do
   end
 
   it "should be a sublcass of Puppet::Indirector::REST" do
-    Puppet::SSL::CertificateRequest::Rest.superclass.should equal(Puppet::Indirector::REST)
+    expect(Puppet::SSL::CertificateRequest::Rest.superclass).to equal(Puppet::Indirector::REST)
   end
 
   it "should set server_setting to :ca_server" do
-    Puppet::SSL::CertificateRequest::Rest.server_setting.should == :ca_server
+    expect(Puppet::SSL::CertificateRequest::Rest.server_setting).to eq(:ca_server)
   end
 
   it "should set port_setting to :ca_port" do
-    Puppet::SSL::CertificateRequest::Rest.port_setting.should == :ca_port
+    expect(Puppet::SSL::CertificateRequest::Rest.port_setting).to eq(:ca_port)
   end
 
   it "should use the :ca SRV service" do
-    Puppet::SSL::CertificateRequest::Rest.srv_service.should == :ca
+    expect(Puppet::SSL::CertificateRequest::Rest.srv_service).to eq(:ca)
   end
 end

data/spec/unit/indirector/certificate_revocation_list/ca_spec.rb

@@ -5,12 +5,12 @@ require 'puppet/indirector/certificate_revocation_list/ca'
 
 describe Puppet::SSL::CertificateRevocationList::Ca do
   it "should have documentation" do
-    Puppet::SSL::CertificateRevocationList::Ca.doc.should be_instance_of(String)
+    expect(Puppet::SSL::CertificateRevocationList::Ca.doc).to be_instance_of(String)
   end
 
   it "should use the :cacrl setting as the crl location" do
     Puppet.settings.stubs(:use)
     Puppet[:cacrl] = File.expand_path("/request/dir")
-    Puppet::SSL::CertificateRevocationList::Ca.new.path("whatever").should == Puppet[:cacrl]
+    expect(Puppet::SSL::CertificateRevocationList::Ca.new.path("whatever")).to eq(Puppet[:cacrl])
   end
 end

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

@@ -5,13 +5,13 @@ require 'puppet/indirector/certificate_revocation_list/file'
 
 describe Puppet::SSL::CertificateRevocationList::File do
   it "should have documentation" do
-    Puppet::SSL::CertificateRevocationList::File.doc.should be_instance_of(String)
+    expect(Puppet::SSL::CertificateRevocationList::File.doc).to be_instance_of(String)
   end
 
   it "should always store the file to :hostcrl location" do
     crl = File.expand_path("/host/crl")
     Puppet[:hostcrl] = crl
     Puppet.settings.stubs(:use)
-    Puppet::SSL::CertificateRevocationList::File.file_location.should == crl
+    expect(Puppet::SSL::CertificateRevocationList::File.file_location).to eq(crl)
   end
 end

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

@@ -9,18 +9,18 @@ describe Puppet::SSL::CertificateRevocationList::Rest do
   end
 
   it "should be a sublcass of Puppet::Indirector::REST" do
-    Puppet::SSL::CertificateRevocationList::Rest.superclass.should equal(Puppet::Indirector::REST)
+    expect(Puppet::SSL::CertificateRevocationList::Rest.superclass).to equal(Puppet::Indirector::REST)
   end
 
   it "should set server_setting to :ca_server" do
-    Puppet::SSL::CertificateRevocationList::Rest.server_setting.should == :ca_server
+    expect(Puppet::SSL::CertificateRevocationList::Rest.server_setting).to eq(:ca_server)
   end
 
   it "should set port_setting to :ca_port" do
-    Puppet::SSL::CertificateRevocationList::Rest.port_setting.should == :ca_port
+    expect(Puppet::SSL::CertificateRevocationList::Rest.port_setting).to eq(:ca_port)
   end
 
   it "should use the :ca SRV service" do
-    Puppet::SSL::CertificateRevocationList::Rest.srv_service.should == :ca
+    expect(Puppet::SSL::CertificateRevocationList::Rest.srv_service).to eq(:ca)
   end
 end

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

@@ -53,22 +53,22 @@ describe "Puppet::Indirector::CertificateStatus::File" do
   end
 
   it "should be a terminus on SSL::Host" do
-    @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::File)
+    expect(@terminus).to be_instance_of(Puppet::Indirector::CertificateStatus::File)
   end
 
   it "should create a CA instance if none is present" do
-    @terminus.ca.should be_instance_of(Puppet::SSL::CertificateAuthority)
+    expect(@terminus.ca).to be_instance_of(Puppet::SSL::CertificateAuthority)
   end
 
   describe "when creating the CA" do
     it "should fail if it is not a valid CA" do
       Puppet::SSL::CertificateAuthority.expects(:ca?).returns false
-      lambda { @terminus.ca }.should raise_error(ArgumentError, "This process is not configured as a certificate authority")
+      expect { @terminus.ca }.to raise_error(ArgumentError, "This process is not configured as a certificate authority")
     end
   end
 
   it "should be indirected with the name 'certificate_status'" do
-    Puppet::SSL::Host.indirection.name.should == :certificate_status
+    expect(Puppet::SSL::Host.indirection.name).to eq(:certificate_status)
   end
 
   describe "when finding" do
@@ -83,8 +83,8 @@ describe "Puppet::Indirector::CertificateStatus::File" do
 
       retrieved_host = @terminus.find(request)
 
-      retrieved_host.name.should == @host.name
-      retrieved_host.certificate_request.content.to_s.chomp.should == @host.certificate_request.content.to_s.chomp
+      expect(retrieved_host.name).to eq(@host.name)
+      expect(retrieved_host.certificate_request.content.to_s.chomp).to eq(@host.certificate_request.content.to_s.chomp)
     end
 
     it "should return the Puppet::SSL::Host when a public key exists for the host" do
@@ -93,13 +93,13 @@ describe "Puppet::Indirector::CertificateStatus::File" do
 
       retrieved_host = @terminus.find(request)
 
-      retrieved_host.name.should == @host.name
-      retrieved_host.certificate.content.to_s.chomp.should == @host.certificate.content.to_s.chomp
+      expect(retrieved_host.name).to eq(@host.name)
+      expect(retrieved_host.certificate.content.to_s.chomp).to eq(@host.certificate.content.to_s.chomp)
     end
 
     it "should return nil when neither a CSR nor public key exist for the host" do
       request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
-      @terminus.find(request).should == nil
+      expect(@terminus.find(request)).to eq(nil)
     end
   end
 
@@ -116,14 +116,14 @@ describe "Puppet::Indirector::CertificateStatus::File" do
       end
 
       it "should fail if no CSR is on disk" do
-        lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /certificate request/)
+        expect { @terminus.save(@request) }.to raise_error(Puppet::Error, /certificate request/)
       end
 
       it "should sign the on-disk CSR when it is present" do
         signed_host = generate_signed_cert(@host)
 
-        signed_host.state.should == "signed"
-        Puppet::SSL::Certificate.indirection.find("foobar").should be_instance_of(Puppet::SSL::Certificate)
+        expect(signed_host.state).to eq("signed")
+        expect(Puppet::SSL::Certificate.indirection.find("foobar")).to be_instance_of(Puppet::SSL::Certificate)
       end
     end
 
@@ -134,13 +134,13 @@ describe "Puppet::Indirector::CertificateStatus::File" do
 
       it "should fail if no certificate is on disk" do
         @host.desired_state = "revoked"
-        lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /Cannot revoke/)
+        expect { @terminus.save(@request) }.to raise_error(Puppet::Error, /Cannot revoke/)
       end
 
       it "should revoke the certificate when it is present" do
         generate_revoked_cert(@host)
 
-        @host.state.should == 'revoked'
+        expect(@host.state).to eq('revoked')
       end
     end
   end
@@ -153,19 +153,19 @@ describe "Puppet::Indirector::CertificateStatus::File" do
     it "should not delete anything if no certificate, request, or key is on disk" do
       host = Puppet::SSL::Host.new("clean_me")
       request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_me", host)
-      @terminus.destroy(request).should == "Nothing was deleted"
+      expect(@terminus.destroy(request)).to eq("Nothing was deleted")
     end
 
     it "should clean certs, cert requests, keys" do
       signed_host = Puppet::SSL::Host.new("clean_signed_cert")
       generate_signed_cert(signed_host)
       signed_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_signed_cert", signed_host)
-      @terminus.destroy(signed_request).should == "Deleted for clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key"
+      expect(@terminus.destroy(signed_request)).to eq("Deleted for clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key")
 
       requested_host = Puppet::SSL::Host.new("clean_csr")
       generate_csr(requested_host)
       csr_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_csr", requested_host)
-      @terminus.destroy(csr_request).should == "Deleted for clean_csr: Puppet::SSL::CertificateRequest, Puppet::SSL::Key"
+      expect(@terminus.destroy(csr_request)).to eq("Deleted for clean_csr: Puppet::SSL::CertificateRequest, Puppet::SSL::Key")
     end
   end
 
@@ -185,7 +185,7 @@ describe "Puppet::Indirector::CertificateStatus::File" do
       retrieved_hosts = @terminus.search(Puppet::Indirector::Request.new(:certificate_status, :search, "all", signed_host))
 
       results = retrieved_hosts.map {|h| [h.name, h.state]}.sort{ |h,i| h[0] <=> i[0] }
-      results.should == [["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]]
+      expect(results).to eq([["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]])
     end
   end
 end

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

@@ -9,10 +9,10 @@ describe "Puppet::CertificateStatus::Rest" do
   end
 
   it "should be a terminus on Puppet::SSL::Host" do
-    @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::Rest)
+    expect(@terminus).to be_instance_of(Puppet::Indirector::CertificateStatus::Rest)
   end
 
   it "should use the :ca SRV service" do
-    Puppet::Indirector::CertificateStatus::Rest.srv_service.should == :ca
+    expect(Puppet::Indirector::CertificateStatus::Rest.srv_service).to eq(:ca)
   end
 end

data/spec/unit/indirector/code_spec.rb

@@ -18,14 +18,14 @@ describe Puppet::Indirector::Code do
   end
 
   it "should not have a find() method defined" do
-    @searcher.should_not respond_to(:find)
+    expect(@searcher).not_to respond_to(:find)
   end
 
   it "should not have a save() method defined" do
-    @searcher.should_not respond_to(:save)
+    expect(@searcher).not_to respond_to(:save)
   end
 
   it "should not have a destroy() method defined" do
-    @searcher.should_not respond_to(:destroy)
+    expect(@searcher).not_to respond_to(:destroy)
   end
 end

data/spec/unit/indirector/data_binding/hiera_spec.rb

@@ -3,16 +3,16 @@ require 'puppet/indirector/data_binding/hiera'
 
 describe Puppet::DataBinding::Hiera do
   it "should have documentation" do
-    Puppet::DataBinding::Hiera.doc.should_not be_nil
+    expect(Puppet::DataBinding::Hiera.doc).not_to be_nil
   end
 
   it "should be registered with the data_binding indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:data_binding)
-    Puppet::DataBinding::Hiera.indirection.should equal(indirection)
+    expect(Puppet::DataBinding::Hiera.indirection).to equal(indirection)
   end
 
   it "should have its name set to :hiera" do
-    Puppet::DataBinding::Hiera.name.should == :hiera
+    expect(Puppet::DataBinding::Hiera.name).to eq(:hiera)
   end
 
   it_should_behave_like "Hiera indirection", Puppet::DataBinding::Hiera, my_fixture_dir

data/spec/unit/indirector/data_binding/none_spec.rb

@@ -3,26 +3,26 @@ require 'puppet/indirector/data_binding/none'
 
 describe Puppet::DataBinding::None do
   it "should be a subclass of the None terminus" do
-    Puppet::DataBinding::None.superclass.should equal(Puppet::Indirector::None)
+    expect(Puppet::DataBinding::None.superclass).to equal(Puppet::Indirector::None)
   end
 
   it "should have documentation" do
-    Puppet::DataBinding::None.doc.should_not be_nil
+    expect(Puppet::DataBinding::None.doc).not_to be_nil
   end
 
   it "should be registered with the data_binding indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:data_binding)
-    Puppet::DataBinding::None.indirection.should equal(indirection)
+    expect(Puppet::DataBinding::None.indirection).to equal(indirection)
   end
 
   it "should have its name set to :none" do
-    Puppet::DataBinding::None.name.should == :none
+    expect(Puppet::DataBinding::None.name).to eq(:none)
   end
 
   describe "the behavior of the find method" do
     it "should just return nil" do
       data_binding = Puppet::DataBinding::None.new
-      data_binding.find('fake_request').should be_nil
+      expect(data_binding.find('fake_request')).to be_nil
     end
   end
 end

data/spec/unit/indirector/direct_file_server_spec.rb

@@ -27,13 +27,15 @@ describe Puppet::Indirector::DirectFileServer do
 
     it "should return nil if the file does not exist" do
       Puppet::FileSystem.expects(:exist?).with(@path).returns false
-      @server.find(@request).should be_nil
+      expect(@server.find(@request)).to be_nil
     end
 
     it "should return a Content instance created with the full path to the file if the file exists" do
       Puppet::FileSystem.expects(:exist?).with(@path).returns true
-      @model.expects(:new).returns(:mycontent)
-      @server.find(@request).should == :mycontent
+      mycontent = stub 'content', :collect => nil
+      mycontent.expects(:collect)
+      @model.expects(:new).returns(mycontent)
+      expect(@server.find(@request)).to eq(mycontent)
     end
   end
 
@@ -57,12 +59,20 @@ describe Puppet::Indirector::DirectFileServer do
       @request.stubs(:options).returns(:links => :manage)
       @server.find(@request)
     end
+
+    it "should set 'checksum_type' on the instances if it is set in the request options" do
+      @model.expects(:new).returns(@data)
+      @data.expects(:checksum_type=).with :checksum
+
+      @request.stubs(:options).returns(:checksum_type => :checksum)
+      @server.find(@request)
+    end
   end
 
   describe Puppet::Indirector::DirectFileServer, "when searching for multiple files" do
     it "should return nil if the file does not exist" do
       Puppet::FileSystem.expects(:exist?).with(@path).returns false
-      @server.find(@request).should be_nil
+      expect(@server.find(@request)).to be_nil
     end
 
     it "should use :path2instances from the terminus_helper to return instances if the file exists" do

data/spec/unit/indirector/envelope_spec.rb

@@ -10,24 +10,24 @@ describe Puppet::Indirector::Envelope do
 
   describe "when testing if it is expired" do
     it "should return false if there is no expiration set" do
-      @instance.should_not be_expired
+      expect(@instance).not_to be_expired
     end
 
     it "should return true if the current date is after the expiration date" do
       @instance.expiration = Time.now - 10
-      @instance.should be_expired
+      expect(@instance).to be_expired
     end
 
     it "should return false if the current date is prior to the expiration date" do
       @instance.expiration = Time.now + 10
-      @instance.should_not be_expired
+      expect(@instance).not_to be_expired
     end
 
     it "should return false if the current date is equal to the expiration date" do
       now = Time.now
       Time.stubs(:now).returns(now)
       @instance.expiration = now
-      @instance.should_not be_expired
+      expect(@instance).not_to be_expired
     end
   end
 end

data/spec/unit/indirector/exec_spec.rb

@@ -26,12 +26,12 @@ describe Puppet::Indirector::Exec do
 
   it "should throw an exception if the command is not an array" do
     @searcher.command = path
-    proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
+    expect { @searcher.find(@request) }.to raise_error(Puppet::DevError)
   end
 
   it "should throw an exception if the command is not fully qualified" do
     @searcher.command = ["mycommand"]
-    proc { @searcher.find(@request) }.should raise_error(ArgumentError)
+    expect { @searcher.find(@request) }.to raise_error(ArgumentError)
   end
 
   it "should execute the command with the object name as the only argument" do
@@ -41,12 +41,12 @@ describe Puppet::Indirector::Exec do
 
   it "should return the output of the script" do
     @searcher.expects(:execute).with([path, 'foo'], arguments).returns("whatever")
-    @searcher.find(@request).should == "whatever"
+    expect(@searcher.find(@request)).to eq("whatever")
   end
 
   it "should return nil when the command produces no output" do
     @searcher.expects(:execute).with([path, 'foo'], arguments).returns(nil)
-    @searcher.find(@request).should be_nil
+    expect(@searcher.find(@request)).to be_nil
   end
 
   it "should raise an exception if there's an execution failure" do

data/spec/unit/indirector/face_spec.rb

@@ -12,10 +12,10 @@ describe Puppet::Indirector::Face do
     instance
   end
 
-  it { should be_option :extra }
+  it { is_expected.to be_option :extra }
 
   it "should be able to return a list of indirections" do
-    Puppet::Indirector::Face.indirections.should be_include("catalog")
+    expect(Puppet::Indirector::Face.indirections).to be_include("catalog")
   end
 
   it "should return the sorted to_s list of terminus classes" do
@@ -24,24 +24,24 @@ describe Puppet::Indirector::Face do
       :compiler,
       :rest
    ])
-    Puppet::Indirector::Face.terminus_classes(:catalog).should == [
+    expect(Puppet::Indirector::Face.terminus_classes(:catalog)).to eq([
       'compiler',
       'rest',
       'yaml'
-    ]
+    ])
   end
 
   describe "as an instance" do
     it "should be able to determine its indirection" do
       # Loading actions here can get, um, complicated
       Puppet::Face.stubs(:load_actions)
-      Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection.should equal(Puppet::Resource::Catalog.indirection)
+      expect(Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection).to equal(Puppet::Resource::Catalog.indirection)
     end
   end
 
   [:find, :search, :save, :destroy].each do |method|
     it "should define a '#{method}' action" do
-      Puppet::Indirector::Face.should be_action(method)
+      expect(Puppet::Indirector::Face).to be_action(method)
     end
 
     it "should call the indirection method with options when the '#{method}' action is invoked" do
@@ -54,9 +54,14 @@ describe Puppet::Indirector::Face do
     end
   end
 
+  it "should default key to certname for find action" do
+    subject.indirection.expects(:find).with(Puppet[:certname], {'one'=>'1'})
+    subject.send(:find, :extra => {'one'=>'1'})
+  end
+
   it "should be able to override its indirection name" do
     subject.set_indirection_name :foo
-    subject.indirection_name.should == :foo
+    expect(subject.indirection_name).to eq(:foo)
   end
 
   it "should be able to set its terminus class" do
@@ -65,6 +70,6 @@ describe Puppet::Indirector::Face do
   end
 
   it "should define a class-level 'info' action" do
-    Puppet::Indirector::Face.should be_action(:info)
+    expect(Puppet::Indirector::Face).to be_action(:info)
   end
 end