conjur-api 4.10.1 → 4.10.2

data/spec/lib/role_grant_spec.rb

@@ -4,9 +4,9 @@ describe Conjur::RoleGrant, api: :dummy do
   describe '::parse_from_json' do
     it "creates member and grantor roles" do
       rg = Conjur::RoleGrant::parse_from_json({member: 'acc:k:r', grantor: 'acc:k:g', admin_option: true}.stringify_keys, {})
-      rg.member.url.should == "#{authz_host}/acc/roles/k/r"
-      rg.grantor.url.should == "#{authz_host}/acc/roles/k/g"
-      rg.admin_option.should == true
+      expect(rg.member.url).to eq("#{authz_host}/acc/roles/k/r")
+      expect(rg.grantor.url).to eq("#{authz_host}/acc/roles/k/g")
+      expect(rg.admin_option).to eq(true)
     end
   end
 end

data/spec/lib/role_spec.rb

@@ -10,15 +10,35 @@ describe Conjur::Role, api: :dummy do
   describe ".new" do
     context "with plain id" do
       let(:id) { "foo" }
-      its(:options) {}
-      its(:kind) { should == kind }
-      its(:id) { should == id }
+
+      describe '#options' do
+        subject { super().options }
+        it {}
+      end
+
+      describe '#kind' do
+        subject { super().kind }
+        it { is_expected.to eq(kind) }
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it { is_expected.to eq(id) }
+      end
     end
 
     context "with more complex id" do
       let(:id) { "foo/bar" }
-      its(:kind) { should == kind }
-      its(:id) { should == id }
+
+      describe '#kind' do
+        subject { super().kind }
+        it { is_expected.to eq(kind) }
+      end
+
+      describe '#id' do
+        subject { super().id }
+        it { is_expected.to eq(id) }
+      end
     end
   end
 
@@ -27,37 +47,37 @@ describe Conjur::Role, api: :dummy do
   describe "#grant_to" do
     it "should take hash as the second argument and put it" do
       members = double "members request"
-      subject.should_receive(:[]).with('?members&member=other').and_return(members)
-      members.should_receive(:put).with admin_option: true
+      expect(subject).to receive(:[]).with('?members&member=other').and_return(members)
+      expect(members).to receive(:put).with admin_option: true
       subject.grant_to "other", admin_option: true
     end
 
     it "works without arguments" do
       members = double "members request"
-      subject.should_receive(:[]).with('?members&member=other').and_return(members)
-      members.should_receive(:put).with({})
+      expect(subject).to receive(:[]).with('?members&member=other').and_return(members)
+      expect(members).to receive(:put).with({})
       subject.grant_to "other"
     end
 
     it "converts an object to roleid" do
       members = double "members request"
-      subject.should_receive(:[]).with('?members&member=other').and_return(members)
-      members.should_receive(:put).with({})
+      expect(subject).to receive(:[]).with('?members&member=other').and_return(members)
+      expect(members).to receive(:put).with({})
       require 'ostruct'
       subject.grant_to OpenStruct.new(roleid: "other")
     end
 
     it "converts an Array to roleid" do
       members = double "members request"
-      subject.should_receive(:[]).with('?members&member=other').and_return(members)
-      members.should_receive(:put).with({})
+      expect(subject).to receive(:[]).with('?members&member=other').and_return(members)
+      expect(members).to receive(:put).with({})
       subject.grant_to %w(other)
     end
   end
 
   describe '#create' do
     it 'simply puts' do
-      RestClient::Request.should_receive(:execute).with(
+      expect(RestClient::Request).to receive(:execute).with(
         method: :put,
         url: url,
         payload: {},
@@ -70,29 +90,29 @@ describe Conjur::Role, api: :dummy do
   describe '#all' do
     it 'returns roles for ids got from ?all' do
       roles = ['foo:k:bar', 'baz:k:xyzzy'] 
-      RestClient::Request.should_receive(:execute).with(
+      expect(RestClient::Request).to receive(:execute).with(
         method: :get,
         url: role.url + "/?all",
         headers: {}
       ).and_return roles.to_json
       all = role.all
-      all[0].account.should == 'foo'
-      all[0].id.should == 'bar'
-      all[1].account.should == 'baz'
-      all[1].id.should == 'xyzzy'
+      expect(all[0].account).to eq('foo')
+      expect(all[0].id).to eq('bar')
+      expect(all[1].account).to eq('baz')
+      expect(all[1].id).to eq('xyzzy')
     end
     
     describe "filter param" do
       it "applies #cast to the filter" do
         filter = %w(foo bar)
-        filter.each{ |e| subject.should_receive(:cast).with(e, :roleid).and_return e }
-        RestClient::Request.stub execute: [].to_json
+        filter.each{ |e| expect(subject).to receive(:cast).with(e, :roleid).and_return e }
+        allow(RestClient::Request).to receive_messages execute: [].to_json
         role.all filter: filter
       end
       
       def self.it_passes_the_filter_as(query_string)
         it "calls ?all&#{query_string}" do
-          RestClient::Request.should_receive(:execute).with(
+          expect(RestClient::Request).to receive(:execute).with(
             method: :get,
             url: role.url + "/?all&#{query_string}",
             headers:{}
@@ -116,22 +136,22 @@ describe Conjur::Role, api: :dummy do
   
   describe '#member_of?' do
     it 'calls #all with :filter=>id and returns true if the result is non-empty' do
-      role.should_receive(:all).with(filter: 'the filter').and_return ['an id']
-      role.member_of?('the filter').should be_true
-      role.should_receive(:all).with(filter: 'the filter').and_return []
-      role.member_of?('the filter').should be_false
+      expect(role).to receive(:all).with(filter: 'the filter').and_return ['an id']
+      expect(role.member_of?('the filter')).to be_truthy
+      expect(role).to receive(:all).with(filter: 'the filter').and_return []
+      expect(role.member_of?('the filter')).to be_falsey
     end
     
     it "accepts a Role" do
       other = double('Role', roleid: 'foo')
-      role.should_receive(:all).with(filter: other.roleid).and_return []
+      expect(role).to receive(:all).with(filter: other.roleid).and_return []
       role.member_of?(other)
     end
   end
 
   describe '#revoke_from' do
     it 'deletes member' do
-      RestClient::Request.should_receive(:execute).with(
+      expect(RestClient::Request).to receive(:execute).with(
         method: :delete,
         url: role.url + "/?members&member=the-member",
         headers: {}
@@ -142,7 +162,7 @@ describe Conjur::Role, api: :dummy do
 
   describe '#permitted?' do
     before do
-      RestClient::Request.stub(:execute).with(
+      allow(RestClient::Request).to receive(:execute).with(
         method: :get,
         url: role.url + "/?check&resource_id=chunky:bacon&privilege=fry",
         headers: {}
@@ -152,14 +172,14 @@ describe Conjur::Role, api: :dummy do
     context "when get ?check is successful" do
       let(:result) { :ok }
       it "returns true" do
-        role.permitted?('chunky:bacon', 'fry').should be_true
+        expect(role.permitted?('chunky:bacon', 'fry')).to be_truthy
       end
     end
 
     context "when get ?check not found" do
       let(:result) { raise RestClient::ResourceNotFound, 'foo' }
       it "returns false" do
-        role.permitted?('chunky:bacon', 'fry').should be_false
+        expect(role.permitted?('chunky:bacon', 'fry')).to be_falsey
       end
     end
   end
@@ -167,16 +187,16 @@ describe Conjur::Role, api: :dummy do
   describe '#members' do
     it "gets ?members and turns each into RoleGrant" do
       grants = %w(foo bar)
-      RestClient::Request.should_receive(:execute).with(
+      expect(RestClient::Request).to receive(:execute).with(
         method: :get,
         url: role.url + "/?members",
         headers: {}
       ).and_return grants.to_json
       grants.each do |g|
-        Conjur::RoleGrant.should_receive(:parse_from_json).with(g, {}).and_return g
+        expect(Conjur::RoleGrant).to receive(:parse_from_json).with(g, {}).and_return g
       end
 
-      subject.members.should == grants
+      expect(subject.members).to eq(grants)
     end
   end
 end

data/spec/lib/standard_methods_spec.rb

@@ -13,9 +13,9 @@ describe Conjur::StandardMethods do
 
   before do
     subject.extend Conjur::StandardMethods
-    subject.stub(:fully_escape){|x|x}
-    RestClient::Resource.stub(:new).with(host, credentials).and_return rest_resource
-    rest_resource.stub(:[]).with('widgets').and_return subresource
+    allow(subject).to receive(:fully_escape){|x|x}
+    allow(RestClient::Resource).to receive(:new).with(host, credentials).and_return rest_resource
+    allow(rest_resource).to receive(:[]).with('widgets').and_return subresource
     stub_const 'Conjur::Widget', widget_class
   end
 
@@ -27,12 +27,12 @@ describe Conjur::StandardMethods do
     let(:widget) { double "widget" }
 
     before do
-      subresource.stub(:post).with(options.merge(id: id)).and_return response
-      widget_class.stub(:build_from_response).with(response, credentials).and_return widget
+      allow(subresource).to receive(:post).with(options.merge(id: id)).and_return response
+      allow(widget_class).to receive(:build_from_response).with(response, credentials).and_return widget
     end
 
     it "uses restclient to post data and creates an object of the response" do
-      subject.send(:standard_create, host, type, id, options).should == widget
+      expect(subject.send(:standard_create, host, type, id, options)).to eq(widget)
     end
   end
 
@@ -42,25 +42,25 @@ describe Conjur::StandardMethods do
     let(:json) { attrs.to_json }
 
     before do
-      subresource.stub(:get).with(options).and_return json
+      allow(subresource).to receive(:get).with(options).and_return json
     end
 
     it "gets the list, then builds objects from json response" do
-      subject.should_receive(:widget).with('one').and_return(one = double)
-      one.should_receive(:attributes=).with(attrs[0].stringify_keys)
-      subject.should_receive(:widget).with('two').and_return(two = double)
-      two.should_receive(:attributes=).with(attrs[1].stringify_keys)
+      expect(subject).to receive(:widget).with('one').and_return(one = double)
+      expect(one).to receive(:attributes=).with(attrs[0].stringify_keys)
+      expect(subject).to receive(:widget).with('two').and_return(two = double)
+      expect(two).to receive(:attributes=).with(attrs[1].stringify_keys)
 
-      subject.send(:standard_list, host, type, options).should == [one, two]
+      expect(subject.send(:standard_list, host, type, options)).to eq([one, two])
     end
   end
 
   describe "#standard_show" do
     let(:id) { "some-id" }
     it "builds a path and returns indexed object" do
-      widget_class.stub(:new).with(host, credentials).and_return(bound = double)
-      bound.stub(:[]) { |x| "path: #{x}" }
-      subject.send(:standard_show, host, type, id).should == "path: widgets/some-id"
+      allow(widget_class).to receive(:new).with(host, credentials).and_return(bound = double)
+      allow(bound).to receive(:[]) { |x| "path: #{x}" }
+      expect(subject.send(:standard_show, host, type, id)).to eq("path: widgets/some-id")
     end
   end
 end

data/spec/lib/user_spec.rb

@@ -9,28 +9,48 @@ describe Conjur::User do
     let(:user) { Conjur::User.new(url, credentials)}
     describe "attributes" do
       subject { user }
-      its(:id) { should == login }
-      its(:login) { should == login }
-      its(:resource_id) { should == login }
-      its(:resource_kind) { should == "user" }
-      its(:options) { should == credentials }
+
+      describe '#id' do
+        subject { super().id }
+        it { is_expected.to eq(login) }
+      end
+
+      describe '#login' do
+        subject { super().login }
+        it { is_expected.to eq(login) }
+      end
+
+      describe '#resource_id' do
+        subject { super().resource_id }
+        it { is_expected.to eq(login) }
+      end
+
+      describe '#resource_kind' do
+        subject { super().resource_kind }
+        it { is_expected.to eq("user") }
+      end
+
+      describe '#options' do
+        subject { super().options }
+        it { is_expected.to eq(credentials) }
+      end
       specify {
-        lambda { user.roleid }.should raise_error
+        expect { user.roleid }.to raise_error
       }
     end
     it "connects to a Resource" do
       require 'conjur/resource'
-      Conjur::Core::API.should_receive(:conjur_account).and_return 'ci'
-      Conjur::Resource.should_receive(:new).with(Conjur::Authz::API.host, credentials).and_return resource = double(:resource)
-      resource.should_receive(:[]).with("ci/resources/user/the-login")
+      expect(Conjur::Core::API).to receive(:conjur_account).and_return 'ci'
+      expect(Conjur::Resource).to receive(:new).with(Conjur::Authz::API.host, credentials).and_return resource = double(:resource)
+      expect(resource).to receive(:[]).with("ci/resources/user/the-login")
       
       user.resource
     end
     it "connects to a Role" do
       require 'conjur/role'
-      Conjur::Core::API.should_receive(:conjur_account).and_return 'ci'
-      Conjur::Role.should_receive(:new).with(Conjur::Authz::API.host, credentials).and_return role = double(:role)
-      role.should_receive(:[]).with("ci/roles/user/the-login")
+      expect(Conjur::Core::API).to receive(:conjur_account).and_return 'ci'
+      expect(Conjur::Role).to receive(:new).with(Conjur::Authz::API.host, credentials).and_return role = double(:role)
+      expect(role).to receive(:[]).with("ci/roles/user/the-login")
       
       user.role
     end

data/spec/spec_helper.rb

@@ -22,7 +22,6 @@ Spork.prefork do
   #require 'webrat/integrations/rspec-rails'
 
   RSpec.configure do |config|
-    config.treat_symbols_as_metadata_keys_with_true_values = true
     config.before do
       # test with a clean environment
       stub_const 'ENV', 'CONJUR_ENV' => 'test'
@@ -78,12 +77,12 @@ Spork.each_run do
 end
 
 shared_examples_for "http response" do
-  let(:http_response) { mock(:response) }
+  let(:http_response) { double(:response) }
 
   before(:each) do
-    http_response.stub(:code).and_return 200
-    http_response.stub(:message).and_return nil
-    http_response.stub(:body).and_return http_json.to_json
+    allow(http_response).to receive(:code).and_return 200
+    allow(http_response).to receive(:message).and_return nil
+    allow(http_response).to receive(:body).and_return http_json.to_json
   end
 end
 
@@ -108,12 +107,12 @@ shared_context api: :dummy do
   let(:account) { 'the-account' }
 
   before do
-    Conjur::Authz::API.stub host: authz_host
-    Conjur::Core::API.stub host: core_host
-    Conjur::Core::API.stub conjur_account: account
-    Conjur::Audit::API.stub host:audit_host
+    allow(Conjur::Authz::API).to receive_messages host: authz_host
+    allow(Conjur::Core::API).to receive_messages host: core_host
+    allow(Conjur::Core::API).to receive_messages conjur_account: account
+    allow(Conjur::Audit::API).to receive_messages host:audit_host
     Conjur.configuration.set :account, account
-    api.stub credentials: credentials
+    allow(api).to receive_messages credentials: credentials
   end
 end
 

data/spec/standard_methods_helper.rb

@@ -4,27 +4,27 @@ end
 
 shared_examples_for 'standard_create with' do |type, id, options|
   it "calls through to standard_create" do
-    subject.should_receive(:standard_create).with(
+    expect(subject).to receive(:standard_create).with(
       core_host, type, id, options
     ).and_return :response
-    invoke.should == :response
+    expect(invoke).to eq(:response)
   end
 end
 
 shared_examples_for 'standard_list with' do |type, options|
   it "calls through to standard_list" do
-    subject.should_receive(:standard_list).with(
+    expect(subject).to receive(:standard_list).with(
       core_host, type, options
     ).and_return :response
-    invoke.should == :response
+    expect(invoke).to eq(:response)
   end
 end
 
 shared_examples_for 'standard_show with' do |type, id|
   it "calls through to standard_show" do
-    subject.should_receive(:standard_show).with(
+    expect(subject).to receive(:standard_show).with(
       core_host, type, id
     ).and_return :response
-    invoke.should == :response
+    expect(invoke).to eq(:response)
   end
 end

data/spec/variable_spec.rb

@@ -2,14 +2,19 @@ require 'spec_helper'
 
 describe Conjur::Variable do
   let(:url) { "http://example.com/variable" }
-  subject { Conjur::Variable.new url }
+  subject(:variable) { Conjur::Variable.new url }
 
   before { subject.attributes = {'versions' => 42} }
-  its(:version_count) { should == 42}
+
+  describe '#version_count' do
+    it "is read from the attributes" do
+      expect(variable.version_count).to eq(42)
+    end
+  end
 
   describe '#add_value' do
     it "posts the new value" do
-      RestClient::Request.should_receive(:execute).with(
+      expect(RestClient::Request).to receive(:execute).with(
         method: :post,
         url: "#{url}/values",
         payload: { value: 'new-value' },
@@ -21,21 +26,21 @@ describe Conjur::Variable do
 
   describe '#value' do
     it "gets the value" do
-      RestClient::Request.stub(:execute).with(
+      allow(RestClient::Request).to receive(:execute).with(
         method: :get,
         url: "#{url}/value",
         headers: {}
       ).and_return(double "response", body: "the-value")
-      subject.value.should == "the-value"
+      expect(subject.value).to eq("the-value")
     end
 
     it "parametrizes the request with a version" do
-      RestClient::Request.stub(:execute).with(
+      allow(RestClient::Request).to receive(:execute).with(
         method: :get,
         url: "#{url}/value?version=42",
         headers: {}
       ).and_return(double "response", body: "the-value")
-      subject.value(42).should == "the-value"
+      expect(subject.value(42)).to eq("the-value")
     end
   end
 end