conjur-cli 4.14.0 → 4.15.0

data/spec/command/pubkeys_spec.rb

@@ -24,7 +24,7 @@ require 'conjur/command/pubkeys'
 describe Conjur::Command::Pubkeys, logged_in: true do
   describe_command "pubkeys:show alice" do
     it "calls api.public_keys('alice') and prints the result" do
-      described_class.api.should_receive(:public_keys).with('alice').and_return "a public key"
+      expect(described_class.api).to receive(:public_keys).with('alice').and_return "a public key"
       expect{ invoke }.to write("a public key")
     end
   end
@@ -33,14 +33,14 @@ describe Conjur::Command::Pubkeys, logged_in: true do
     let(:keys){ ["x y foo", "x y bar"].join("\n") }
     let(:names){ "bar\nfoo" }
     it "calls api.public_keys('alice') and prints the names" do
-      described_class.api.should_receive(:public_keys).with('alice').and_return keys
+      expect(described_class.api).to receive(:public_keys).with('alice').and_return keys
       expect{ invoke }.to write(names) 
     end
   end
   
   describe_command "pubkeys:add alice data" do
     it "calls api.add_public_key('alice', 'data') and prints the key name" do
-      described_class.api.should_receive(:add_public_key).with('alice', 'data')
+      expect(described_class.api).to receive(:add_public_key).with('alice', 'data')
       expect{ invoke }.to write("Public key 'data' added")
     end
   end
@@ -48,11 +48,11 @@ describe Conjur::Command::Pubkeys, logged_in: true do
   describe_command "pubkeys:add alice @id_rsa.pub" do
     let(:file_contents){ "ssh-rsa blahblah keyname" }
     it "calls api.add_public_key('alice', data) and prints the key name" do
-      File.should_receive(:read) do |filename|
-        filename.should end_with("id_rsa.pub")
+      expect(File).to receive(:read) do |filename|
+        expect(filename).to end_with("id_rsa.pub")
         file_contents
       end
-      described_class.api.should_receive(:add_public_key).with('alice', file_contents)
+      expect(described_class.api).to receive(:add_public_key).with('alice', file_contents)
       expect{ invoke }.to write("Public key 'keyname' added")
     end
   end
@@ -60,15 +60,15 @@ describe Conjur::Command::Pubkeys, logged_in: true do
   describe_command "pubkeys:add alice" do
     let(:stdin_contents){ "ssh-rsa blahblah keyname" }
     it "calls api.add_public_key('alice', stdin) and prints the key name" do
-      STDIN.should_receive(:read).and_return(stdin_contents)
-      described_class.api.should_receive(:add_public_key).with('alice', stdin_contents)
+      expect(STDIN).to receive(:read).and_return(stdin_contents)
+      expect(described_class.api).to receive(:add_public_key).with('alice', stdin_contents)
       expect{ invoke }.to write("Public key 'keyname' added")
     end
   end
   
   describe_command "pubkeys:delete alice keyname" do
     it "calls api.delete_public_key('alice', 'keyname')" do
-      described_class.api.should_receive(:delete_public_key).with("alice", "keyname")
+      expect(described_class.api).to receive(:delete_public_key).with("alice", "keyname")
       expect{ invoke }.to write("Public key 'keyname' deleted")
     end
   end

data/spec/command/resources_spec.rb

@@ -7,7 +7,7 @@ describe Conjur::Command::Resources, logged_in: true do
   let (:resource_attributes) { { "some" => "attribute"} }
 
   before :each do
-    api.stub(:resource).with(full_resource_id).and_return(resource_instance)
+    allow(api).to receive(:resource).with(full_resource_id).and_return(resource_instance)
   end 
 
   def invoke_silently
@@ -16,27 +16,27 @@ describe Conjur::Command::Resources, logged_in: true do
 
   shared_examples 'it displays resource attributes' do
     it "as JSON to stdout" do
-      JSON::parse( expect { invoke }.to write ).should == resource_attributes
+      expect(JSON::parse( expect { invoke }.to write )).to eq(resource_attributes)
     end
   end
 
   shared_examples "it obtains resource by id" do
     it 'id is built from kind and id' do
-      api.should_receive(:resource).with(%r{^[^:]*:#{KIND}:#{ID}$})
+      expect(api).to receive(:resource).with(%r{^[^:]*:#{KIND}:#{ID}$})
       invoke_silently
     end
     it 'uses default account as a prefix' do
-      api.should_receive(:resource).with(%r{^#{account}:})
+      expect(api).to receive(:resource).with(%r{^#{account}:})
       invoke_silently
     end
   end
 
   describe_command "resource:create #{KIND}:#{ID}"  do
     before :each do
-      resource_instance.stub(:create)
+      allow(resource_instance).to receive(:create)
     end
     it "calls resource.create()" do
-      resource_instance.should_receive(:create)
+      expect(resource_instance).to receive(:create)
       invoke_silently
     end
     it_behaves_like "it obtains resource by id"
@@ -50,31 +50,31 @@ describe Conjur::Command::Resources, logged_in: true do
 
   describe_command "resource:exists #{KIND}:#{ID}" do
     before (:each) { 
-      resource_instance.stub(:exists?).and_return("true")
+      allow(resource_instance).to receive(:exists?).and_return("true")
     }
     it_behaves_like "it obtains resource by id" 
     it 'calls resource.exists?' do
-      resource_instance.should_receive(:exists?)
+      expect(resource_instance).to receive(:exists?)
       invoke_silently
     end
     context 'displays response of resource.exists? (true/false)' do
       # NOTE: a bit redundant, but will be helpful in 'documentation' context
       it 'true' do
-        resource_instance.stub(:exists?).and_return("true")
+        allow(resource_instance).to receive(:exists?).and_return("true")
         expect { invoke }.to write "true"
       end
       it 'false' do
-        resource_instance.stub(:exists?).and_return("false")
+        allow(resource_instance).to receive(:exists?).and_return("false")
         expect { invoke }.to write "false"
       end
     end
   end
 
   describe_command "resource:permit #{KIND}:#{ID} #{ROLE} #{PRIVILEGE}" do
-    before(:each) { resource_instance.stub(:permit).and_return(true) }
+    before(:each) { allow(resource_instance).to receive(:permit).and_return(true) }
     it_behaves_like "it obtains resource by id"
     it "calls resource.permit(#{PRIVILEGE}, #{ROLE})" do
-      resource_instance.should_receive(:permit).with(PRIVILEGE, ROLE)
+      expect(resource_instance).to receive(:permit).with(PRIVILEGE, ROLE)
       invoke_silently
     end
     it {  expect { invoke }.to write "Permission granted" }
@@ -82,16 +82,16 @@ describe Conjur::Command::Resources, logged_in: true do
 
   describe_command "resource:permit -g #{KIND}:#{ID} #{ROLE} #{PRIVILEGE}" do
     it 'calls resource.permit() with grant option' do
-      resource_instance.should_receive(:permit).with(PRIVILEGE, ROLE, grant_option: true)
+      expect(resource_instance).to receive(:permit).with(PRIVILEGE, ROLE, grant_option: true)
       invoke_silently
     end
   end
 
   describe_command "resource:deny #{KIND}:#{ID} #{ROLE} #{PRIVILEGE}" do
-    before(:each) { resource_instance.stub(:deny).and_return(true) }
+    before(:each) { allow(resource_instance).to receive(:deny).and_return(true) }
     it_behaves_like "it obtains resource by id"
     it "calls resource.deny(#{PRIVILEGE},#{ROLE})" do
-      resource_instance.should_receive(:deny).with(PRIVILEGE, ROLE)
+      expect(resource_instance).to receive(:deny).with(PRIVILEGE, ROLE)
       invoke_silently
     end
     it { expect { invoke }.to write "Permission revoked" }
@@ -99,8 +99,8 @@ describe Conjur::Command::Resources, logged_in: true do
 
   describe_command "resource:check #{KIND}:#{ID} #{PRIVILEGE}" do
     it "performs a permission check for the logged-in user" do
-      api.should_receive(:resource).with("the-account:#{KIND}:#{ID}").and_return bacon = double("the-account:#{KIND}:#{ID}")
-      bacon.should_receive(:permitted?).with(PRIVILEGE)
+      expect(api).to receive(:resource).with("the-account:#{KIND}:#{ID}").and_return bacon = double("the-account:#{KIND}:#{ID}")
+      expect(bacon).to receive(:permitted?).with(PRIVILEGE)
       
       invoke
     end
@@ -111,25 +111,25 @@ describe Conjur::Command::Resources, logged_in: true do
     let (:role_response) { "role response: true|false" }
     let (:account) { ACCOUNT }
     before(:each) { 
-      api.stub(:role).and_return(role_instance)
-      role_instance.stub(:permitted?).and_return(role_response)
+      allow(api).to receive(:role).and_return(role_instance)
+      allow(role_instance).to receive(:permitted?).and_return(role_response)
     }
     it 'obtains role object by id' do
-      api.should_receive(:role).with(ROLE)
+      expect(api).to receive(:role).with(ROLE)
       invoke_silently
     end
     it "calls role.permitted?('#{ACCOUNT}:#{KIND}:#{ID}', #{PRIVILEGE})" do
-      role_instance.should_receive(:permitted?).with([ACCOUNT,KIND,ID].join(":"),PRIVILEGE)
+      expect(role_instance).to receive(:permitted?).with([ACCOUNT,KIND,ID].join(":"),PRIVILEGE)
       invoke_silently
     end
     it { expect { invoke }.to write role_response }
   end
 
   describe_command "resource:give #{KIND}:#{ID} #{OWNER}" do
-    before(:each) { resource_instance.stub(:give_to).and_return(true) }
+    before(:each) { allow(resource_instance).to receive(:give_to).and_return(true) }
     it_behaves_like "it obtains resource by id"
     it "calls resource.give_to(#{OWNER})" do
-      resource_instance.should_receive(:give_to).with(OWNER)
+      expect(resource_instance).to receive(:give_to).with(OWNER)
       invoke_silently
     end
     it { expect { invoke }.to write "Ownership granted" }
@@ -138,15 +138,15 @@ describe Conjur::Command::Resources, logged_in: true do
   describe_command "resource:permitted_roles #{KIND}:#{ID} #{PRIVILEGE}" do
     let(:roles_list) { %W[klaatu barada nikto] }
     before(:each) { 
-      resource_instance.stub(:permitted_roles).and_return(roles_list) 
+      allow(resource_instance).to receive(:permitted_roles).and_return(roles_list) 
     }
     it_behaves_like "it obtains resource by id"
     it "calls resource.permitted_roles(#{PRIVILEGE}" do
-      resource_instance.should_receive(:permitted_roles)
+      expect(resource_instance).to receive(:permitted_roles)
       invoke_silently
     end
     it "displays JSONised list of roles" do
-      JSON.parse( expect { invoke }.to write ).should == roles_list
+      expect(JSON.parse( expect { invoke }.to write )).to eq(roles_list)
     end
   end
 end

data/spec/command/roles_spec.rb

@@ -5,13 +5,13 @@ describe Conjur::Command::Roles, logged_in: true do
   describe "role:grant_to" do
     describe_command "role:grant_to test:a test:b" do
       it "grants the role without options" do
-        Conjur::Role.any_instance.should_receive(:grant_to).with("test:b", {})
+        expect_any_instance_of(Conjur::Role).to receive(:grant_to).with("test:b", {})
         invoke
       end
     end
     describe_command "role:grant_to --admin test:a test:b" do
       it "grants the role with admin option" do
-        Conjur::Role.any_instance.should_receive(:grant_to).with("test:b", {admin_option: true})
+        expect_any_instance_of(Conjur::Role).to receive(:grant_to).with("test:b", {admin_option: true})
         invoke
       end
     end
@@ -20,26 +20,26 @@ describe Conjur::Command::Roles, logged_in: true do
   describe "role:create" do
     describe_command "role:create test:the-role" do
       it "creates the role with no options" do
-        Conjur::Role.any_instance.should_receive(:create).with({})
+        expect_any_instance_of(Conjur::Role).to receive(:create).with({})
         
         invoke
       end
     end
     describe_command "role:create --as-role test:foo test:the-role" do
       it "creates the role with acting_as option" do
-        api.should_receive(:role).with("test:foo").and_return double("test:foo", exists?: true, roleid: "test:test:foo")
-        api.should_receive(:role).with("test:the-role").and_return role = double("new-role", roleid: "test:the-role")
-        role.should_receive(:create).with({acting_as: "test:test:foo"})
+        expect(api).to receive(:role).with("test:foo").and_return double("test:foo", exists?: true, roleid: "test:test:foo")
+        expect(api).to receive(:role).with("test:the-role").and_return role = double("new-role", roleid: "test:the-role")
+        expect(role).to receive(:create).with({acting_as: "test:test:foo"})
         
         expect { invoke }.to write("Created role test:the-role")
       end
     end
     describe_command "role:create --as-group the-group test:the-role" do
       it "creates the role with with acting_as option" do
-        api.should_receive(:group).with("the-group").and_return group = double("the-group", roleid: "test:group:the-group")
-        api.should_receive(:role).with(group.roleid).and_return double("group:the-group", exists?: true, roleid: "test:group:the-group")
-        api.should_receive(:role).with("test:the-role").and_return role = double("new-role", roleid: "test:the-role")
-        role.should_receive(:create).with({acting_as: "test:group:the-group"})
+        expect(api).to receive(:group).with("the-group").and_return group = double("the-group", roleid: "test:group:the-group")
+        expect(api).to receive(:role).with(group.roleid).and_return double("group:the-group", exists?: true, roleid: "test:group:the-group")
+        expect(api).to receive(:role).with("test:the-role").and_return role = double("new-role", roleid: "test:the-role")
+        expect(role).to receive(:create).with({acting_as: "test:group:the-group"})
         
         expect { invoke }.to write("Created role test:the-role")
       end
@@ -53,7 +53,7 @@ describe Conjur::Command::Roles, logged_in: true do
     end
   
     before do
-      api.stub(:role).with(rolename).and_return role
+      allow(api).to receive(:role).with(rolename).and_return role
     end
 
     context "when logged in as a user" do
@@ -62,14 +62,14 @@ describe Conjur::Command::Roles, logged_in: true do
       
       describe_command "role:memberships" do
         it "lists all roles" do
-          JSON::parse(expect { invoke }.to write).should == all_roles
+          expect(JSON::parse(expect { invoke }.to write)).to eq(all_roles)
         end
       end
   
       describe_command "role:memberships foo:bar" do
         let(:rolename) { 'foo:bar' }
         it "lists all roles of foo:bar" do
-          JSON::parse(expect { invoke }.to write).should == all_roles
+          expect(JSON::parse(expect { invoke }.to write)).to eq(all_roles)
         end
       end
     end
@@ -80,7 +80,7 @@ describe Conjur::Command::Roles, logged_in: true do
   
       describe_command "role:memberships" do
         it "lists all roles" do
-          JSON::parse(expect { invoke }.to write).should == all_roles
+          expect(JSON::parse(expect { invoke }.to write)).to eq(all_roles)
         end
       end
     end

data/spec/command/users_spec.rb

@@ -7,27 +7,27 @@ describe Conjur::Command::Users, logged_in: true do
   context "creating a user" do
     let(:new_user) { double("new-user") }
     before do
-      Conjur::Command::Users.should_receive(:display).with(new_user)
+      expect(Conjur::Command::Users).to receive(:display).with(new_user)
     end
 
     [ "user:create", "user create" ].each do |cmd|
       describe_command "#{cmd} -p the-user" do
         it "Creates a user with a password obtained by prompting the user" do
-          Conjur::API.any_instance.should_receive(:create_user).with("the-user", password: "the-password").and_return new_user
-          Conjur::Command::Users.should_receive(:prompt_for_password).and_return "the-password"
+          expect_any_instance_of(Conjur::API).to receive(:create_user).with("the-user", password: "the-password").and_return new_user
+          expect(Conjur::Command::Users).to receive(:prompt_for_password).and_return "the-password"
   
           invoke
         end
       end
       describe_command "#{cmd} the-user" do
         it "Creates a user without a password" do
-          Conjur::API.any_instance.should_receive(:create_user).with("the-user", {}).and_return new_user
+          expect_any_instance_of(Conjur::API).to receive(:create_user).with("the-user", {}).and_return new_user
           invoke
         end
       end
       describe_command "#{cmd} --uidnumber 12345 the-user" do
         it "Creates a user with specified uidnumber" do
-          Conjur::API.any_instance.should_receive(:create_user).with("the-user", { uidnumber: 12345 }).and_return new_user
+          expect_any_instance_of(Conjur::API).to receive(:create_user).with("the-user", { uidnumber: 12345 }).and_return new_user
           invoke
         end
       end
@@ -38,8 +38,8 @@ describe Conjur::Command::Users, logged_in: true do
     describe_command "user update --uidnumber 12345 the-user" do
       it "updates the uidnumber" do
         stub_user = double()
-        Conjur::API.any_instance.should_receive(:user).with("the-user").and_return stub_user
-        stub_user.should_receive(:update).with(uidnumber: 12345).and_return ""
+        expect_any_instance_of(Conjur::API).to receive(:user).with("the-user").and_return stub_user
+        expect(stub_user).to receive(:update).with(uidnumber: 12345).and_return ""
         expect { invoke }.to write "UID set"
       end
     end
@@ -49,7 +49,7 @@ describe Conjur::Command::Users, logged_in: true do
     let(:search_result) { {id: "the-user"} }
     describe_command "user uidsearch 12345" do
       it "finds user" do
-        Conjur::API.any_instance.should_receive(:find_users).with(uidnumber: 12345).and_return search_result
+        expect_any_instance_of(Conjur::API).to receive(:find_users).with(uidnumber: 12345).and_return search_result
         expect { invoke }.to write(JSON.pretty_generate(search_result))
       end
     end
@@ -57,7 +57,7 @@ describe Conjur::Command::Users, logged_in: true do
   
   context "updating password" do
     before do
-     RestClient::Request.should_receive(:execute).with(
+     expect(RestClient::Request).to receive(:execute).with(
         method: :put,
         url: update_password_url,
         user: username, 
@@ -75,7 +75,7 @@ describe Conjur::Command::Users, logged_in: true do
   
     describe_command "user:update_password" do
       it "PUTs the new password" do
-        Conjur::Command::Users.should_receive(:prompt_for_password).and_return "new-password"
+        expect(Conjur::Command::Users).to receive(:prompt_for_password).and_return "new-password"
 
         invoke
       end

data/spec/command/variables_spec.rb

@@ -7,7 +7,7 @@ describe Conjur::Command::Variables, logged_in: true do
 
   describe_command "variable:create -m text/json -k password" do
     it "lets the server assign the id" do
-     RestClient::Request.should_receive(:execute).with(
+     expect(RestClient::Request).to receive(:execute).with(
         method: :post,
         url: collection_url,
         headers: {},
@@ -19,7 +19,7 @@ describe Conjur::Command::Variables, logged_in: true do
   end
   describe_command "variable:create -m text/json -k password the-id" do
     it "propagates the user-assigned id" do
-     RestClient::Request.should_receive(:execute).with(
+     expect(RestClient::Request).to receive(:execute).with(
         method: :post,
         url: collection_url,
         headers: {},
@@ -33,7 +33,7 @@ describe Conjur::Command::Variables, logged_in: true do
 
   describe_command "variable:create" do
     it "provides default values for optional parameters mime_type and kind" do
-      RestClient::Request.should_receive(:execute).with(
+      expect(RestClient::Request).to receive(:execute).with(
         method: :post,
         url: collection_url,
         headers: {},

data/spec/command_spec.rb

@@ -6,13 +6,13 @@ describe Conjur::Command do
       describe  "injects account into brief ids" do
         context "long id (3+ tokens)" do
           it "returns id as is" do
-            described_class.full_resource_id("a:b:c").should == "a:b:c"
+            expect(described_class.full_resource_id("a:b:c")).to eq("a:b:c")
           end
         end 
         context "brief id(2 tokens)" do
-          before(:each) { described_class.stub(:conjur_account).and_return("current/acc") }
+          before(:each) { allow(described_class).to receive(:conjur_account).and_return("current/acc") }
           it "injects current account as a prefix" do
-            described_class.full_resource_id("a:b").should == "current/acc:a:b"
+            expect(described_class.full_resource_id("a:b")).to eq("current/acc:a:b")
           end
         end
         context "malformed id (no separators)" do
@@ -30,18 +30,18 @@ describe Conjur::Command do
         end
         context "for brief ids(2 tokens)" do
           it "token#1=> kind (dashes replaced with undescrores), token#2=>id" do
-            subject("the-kind:the-id").should == ['the_kind','the-id']
+            expect(subject("the-kind:the-id")).to eq(['the_kind','the-id'])
           end
         end
         context "for long ids(3+ tokens)" do    
           it "token #1=> ignored" do
-            subject("a:b:c:d").should_not include('a')
+            expect(subject("a:b:c:d")).not_to include('a')
           end
           it "token #2=> kind (dashes replaced with underscores)" do
-            subject("a:the-kind:c:d")[0].should == "the_kind"
+            expect(subject("a:the-kind:c:d")[0]).to eq("the_kind")
           end
           it "extracts remaining part (starting from 3rd token) as an id" do
-            subject("a:b:c-token:d-token")[1].should == "c-token:d-token"
+            expect(subject("a:b:c-token:d-token")[1]).to eq("c-token:d-token")
           end
         end 
         context "for too short input" do

data/spec/config_spec.rb

@@ -30,26 +30,26 @@ describe Conjur::Config do
         ENV['CONJURRC'] = oldrc
       end
 
-      it { should include('/etc/conjur.conf') }
-      it { should include("#{homedir}/.conjurrc") }
-      it { should include('.conjurrc') }
+      it { is_expected.to include('/etc/conjur.conf') }
+      it { is_expected.to include("#{homedir}/.conjurrc") }
+      it { is_expected.to include('.conjurrc') }
 
       before do
-        File.stub(:expand_path).and_call_original
-        File.stub(:expand_path).with('.conjurrc').and_return '.conjurrc'
+        allow(File).to receive(:expand_path).and_call_original
+        allow(File).to receive(:expand_path).with('.conjurrc').and_return '.conjurrc'
       end
 
       context "When .conjurrc is present" do
-        before { File.stub(:file?).with('.conjurrc').and_return true }
+        before { allow(File).to receive(:file?).with('.conjurrc').and_return true }
         it "Issues a deprecation warning" do 
           expect { subject }.to write(deprecation_warning).to(:stderr)
         end
 
         context "but the current directory is home" do
           before do
-            File.unstub(:expand_path)
-            File.stub(:expand_path).and_call_original
-            File.stub(:expand_path).with('.conjurrc').and_return("#{homedir}/.conjurrc")
+            allow(File).to receive(:expand_path).and_call_original
+            allow(File).to receive(:expand_path).and_call_original
+            allow(File).to receive(:expand_path).with('.conjurrc').and_return("#{homedir}/.conjurrc")
           end
 
           include_examples "no deprecation warning"
@@ -57,7 +57,7 @@ describe Conjur::Config do
       end
 
       context "When .conjurrc is missing" do
-        before { File.stub(:file?).with('.conjurrc').and_return false }
+        before { allow(File).to receive(:file?).with('.conjurrc').and_return false }
         include_examples "no deprecation warning"
       end
     end
@@ -69,10 +69,10 @@ describe Conjur::Config do
         example.run
         ENV['CONJURRC'] = oldrc
       end
-      it { should include('/etc/conjur.conf') }
-      it { should include('stub_conjurrc') }
-      it { should_not include("#{homedir}/.conjurrc") }
-      it { should_not include('.conjurrc') }
+      it { is_expected.to include('/etc/conjur.conf') }
+      it { is_expected.to include('stub_conjurrc') }
+      it { is_expected.not_to include("#{homedir}/.conjurrc") }
+      it { is_expected.not_to include('.conjurrc') }
 
       include_examples "no deprecation warning"
     end
@@ -84,10 +84,10 @@ describe Conjur::Config do
         example.run
         ENV['CONJURRC'] = oldrc
       end
-      before { File.stub(:file?).with('.conjurrc').and_return true }
-      it { should include('/etc/conjur.conf') }
-      it { should include('.conjurrc') }
-      it { should_not include("#{homedir}/.conjurrc") }
+      before { allow(File).to receive(:file?).with('.conjurrc').and_return true }
+      it { is_expected.to include('/etc/conjur.conf') }
+      it { is_expected.to include('.conjurrc') }
+      it { is_expected.not_to include("#{homedir}/.conjurrc") }
 
       include_examples "no deprecation warning"
     end
@@ -100,16 +100,16 @@ describe Conjur::Config do
     it "resolves the cert_file" do
       load!
       
-      Conjur::Config[:cert_file].should == cert_path
+      expect(Conjur::Config[:cert_file]).to eq(cert_path)
     end
   end
   describe "#apply" do
-    before { OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE.stub(:add_file) }
+    before { allow(OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE).to receive(:add_file) }
 
     let(:cert_file) { "/path/to/cert.pem" }
     it "trusts the cert_file" do
       Conjur::Config.class_variable_set("@@attributes", { 'cert_file' => cert_file })
-      OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE.should_receive(:add_file).with cert_file  
+      expect(OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE).to receive(:add_file).with cert_file  
       Conjur::Config.apply
     end