castle-rb 7.2.0 → 8.0.0

data/spec/lib/castle/commands/risk_spec.rb

@@ -29,45 +29,45 @@ describe Castle::Commands::Risk do
       let(:payload) { default_payload.merge(properties: { test: '1' }) }
       let(:command_data) { default_payload.merge(properties: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('risk') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('risk') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'with user_traits' do
       let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
       let(:command_data) { default_payload.merge(user_traits: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('risk') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('risk') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active true' do
       let(:payload) { default_payload.merge(context: context.merge(active: true)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: true)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('risk') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('risk') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active false' do
       let(:payload) { default_payload.merge(context: context.merge(active: false)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: false)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('risk') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('risk') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active string' do
       let(:payload) { default_payload.merge(context: context.merge(active: 'string')) }
       let(:command_data) { default_payload.merge(context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('risk') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('risk') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 end

data/spec/lib/castle/commands/start_impersonation_spec.rb

@@ -19,40 +19,38 @@ describe Castle::Commands::StartImpersonation do
 
     context 'with impersonator' do
       let(:payload) { default_payload.merge(properties: { impersonator: impersonator }) }
-      let(:command_data) do
-        default_payload.merge(properties: { impersonator: impersonator }, context: context)
-      end
+      let(:command_data) { default_payload.merge(properties: { impersonator: impersonator }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active true' do
       let(:payload) { default_payload.merge(context: context.merge(active: true)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: true)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active false' do
       let(:payload) { default_payload.merge(context: context.merge(active: false)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: false)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active string' do
       let(:payload) { default_payload.merge(context: context.merge(active: 'string')) }
       let(:command_data) { default_payload.merge(context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 
@@ -62,12 +60,7 @@ describe Castle::Commands::StartImpersonation do
     context 'when user_id not present' do
       let(:payload) { {} }
 
-      it do
-        expect { validate! }.to raise_error(
-          Castle::InvalidParametersError,
-          'user_id is missing or empty'
-        )
-      end
+      it { expect { validate! }.to raise_error(Castle::InvalidParametersError, 'user_id is missing or empty') }
     end
 
     context 'when user_id present' do

data/spec/lib/castle/commands/track_spec.rb

@@ -20,54 +20,54 @@ describe Castle::Commands::Track do
       let(:payload) { default_payload.merge(user_id: '1234') }
       let(:command_data) { default_payload.merge(user_id: '1234', context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('track') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('track') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'with properties' do
       let(:payload) { default_payload.merge(properties: { test: '1' }) }
       let(:command_data) { default_payload.merge(properties: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('track') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('track') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'with user_traits' do
       let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
       let(:command_data) { default_payload.merge(user_traits: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('track') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('track') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active true' do
       let(:payload) { default_payload.merge(context: context.merge(active: true)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: true)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('track') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('track') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active false' do
       let(:payload) { default_payload.merge(context: context.merge(active: false)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: false)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('track') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('track') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active string' do
       let(:payload) { default_payload.merge(context: context.merge(active: 'string')) }
       let(:command_data) { default_payload.merge(context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('track') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('track') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 
@@ -77,12 +77,7 @@ describe Castle::Commands::Track do
     context 'when event not present' do
       let(:payload) { {} }
 
-      it do
-        expect { validate! }.to raise_error(
-          Castle::InvalidParametersError,
-          'event is missing or empty'
-        )
-      end
+      it { expect { validate! }.to raise_error(Castle::InvalidParametersError, 'event is missing or empty') }
     end
 
     context 'when event present' do

data/spec/lib/castle/configuration_spec.rb

@@ -10,5 +10,5 @@ describe Castle::Configuration do
   it_behaves_like 'configuration_failover_strategy'
   it_behaves_like 'configuration_api_secret'
 
-  it { expect(config.api_secret).to be_eql('') }
+  it { expect(config.api_secret).to eql('') }
 end

data/spec/lib/castle/context/get_default_spec.rb

@@ -12,7 +12,8 @@ describe Castle::Context::GetDefault do
       'HTTP_X_FORWARDED_FOR' => ip,
       'HTTP_ACCEPT_LANGUAGE' => 'en',
       'HTTP_USER_AGENT' => 'test',
-      'HTTP_COOKIE' => "__cid=#{client_id};other=efgh"
+      'HTTP_COOKIE' => "__cid=#{client_id};other=efgh",
+      'HTTP_CONTENT_LENGTH' => '0'
     )
   end
   let(:request) { Rack::Request.new(env) }
@@ -30,11 +31,11 @@ describe Castle::Context::GetDefault do
 
   before { stub_const('Castle::VERSION', version) }
 
-  it { expect(default_context[:active]).to be_eql(true) }
-  it { expect(default_context[:headers]).to be_eql(result_headers) }
-  it { expect(default_context[:ip]).to be_eql(ip) }
-  it { expect(default_context[:client_id]).to be_eql(client_id) }
-  it { expect(default_context[:library][:name]).to be_eql('castle-rb') }
-  it { expect(default_context[:library][:version]).to be_eql(version) }
-  it { expect(default_context[:user_agent]).to be_eql('test') }
+  it { expect(default_context[:active]).to be(true) }
+  it { expect(default_context[:headers]).to eql(result_headers) }
+  it { expect(default_context[:ip]).to eql(ip) }
+  it { expect(default_context[:client_id]).to eql(client_id) }
+  it { expect(default_context[:library][:name]).to eql('castle-rb') }
+  it { expect(default_context[:library][:version]).to eql(version) }
+  it { expect(default_context[:user_agent]).to eql('test') }
 end

data/spec/lib/castle/context/prepare_spec.rb

@@ -9,7 +9,8 @@ describe Castle::Context::Prepare do
       '/',
       'HTTP_USER_AGENT' => ua,
       'HTTP_X_FORWARDED_FOR' => ip,
-      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh",
+      'HTTP_CONTENT_LENGTH' => '0'
     )
   end
   let(:request) { Rack::Request.new(env) }
@@ -27,9 +28,7 @@ describe Castle::Context::Prepare do
     }
   end
 
-  let(:headers) do
-    { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true }
-  end
+  let(:headers) { { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, Cookie: true } }
 
   before { stub_const('Castle::VERSION', '6.0.0') }
 

data/spec/lib/castle/core/process_response_spec.rb

@@ -18,17 +18,13 @@ describe Castle::Core::ProcessResponse do
       end
 
       context 'when allow with additional props' do
-        let(:response) do
-          OpenStruct.new(body: '{"action":"allow","user_id":"12345","internal":{}}', code: 200)
-        end
+        let(:response) { OpenStruct.new(body: '{"action":"allow","user_id":"12345","internal":{}}', code: 200) }
 
         it { expect(call).to eql({ action: 'allow', user_id: '12345', internal: {} }) }
       end
 
       context 'when deny without risk policy' do
-        let(:response) do
-          OpenStruct.new(body: '{"action":"deny","user_id":"1","device_token":"abc"}', code: 200)
-        end
+        let(:response) { OpenStruct.new(body: '{"action":"deny","user_id":"1","device_token":"abc"}', code: 200) }
 
         it { expect(call).to eql({ action: 'deny', user_id: '1', device_token: 'abc' }) }
       end
@@ -100,6 +96,7 @@ describe Castle::Core::ProcessResponse do
     it_behaves_like 'response_failed', '404', Castle::NotFoundError
     it_behaves_like 'response_failed', '419', Castle::UserUnauthorizedError
     it_behaves_like 'response_failed', '422', Castle::InvalidParametersError
+    it_behaves_like 'response_failed', '429', Castle::RateLimitError
     it_behaves_like 'response_failed', '499', Castle::ApiError
     it_behaves_like 'response_failed', '500', Castle::InternalServerError
   end

data/spec/lib/castle/core/process_webhook_spec.rb

@@ -15,13 +15,19 @@ describe Castle::Core::ProcessWebhook do
           device_token: 'token',
           user_id: '',
           trigger: '$login.succeeded',
-          context: {},
-          location: {},
-          user_agent: {}
+          context: {
+          },
+          location: {
+          },
+          user_agent: {
+          }
         },
-        user_traits: {},
-        properties: {},
-        policy: {}
+        user_traits: {
+        },
+        properties: {
+        },
+        policy: {
+        }
       }.to_json
     end
 

data/spec/lib/castle/core/send_request_spec.rb

@@ -8,12 +8,12 @@ describe Castle::Core::SendRequest do
     let(:headers) { {} }
     let(:request_build) { {} }
     let(:expected_headers) { { 'Content-Type' => 'application/json' } }
-    let(:http) { instance_double('Net::HTTP') }
+    let(:http) { instance_double(Net::HTTP) }
 
     context 'without http arg provided' do
       subject(:call) { described_class.call(command, headers, nil, config) }
 
-      let(:http) { instance_double('Net::HTTP') }
+      let(:http) { instance_double(Net::HTTP) }
       let(:command) { Castle::Commands::Track.build(event: '$login.succeeded') }
       let(:headers) { {} }
       let(:request_build) { {} }
@@ -26,9 +26,7 @@ describe Castle::Core::SendRequest do
         call
       end
 
-      it do
-        expect(described_class).to have_received(:build).with(command, expected_headers, config)
-      end
+      it { expect(described_class).to have_received(:build).with(command, expected_headers, config) }
 
       it { expect(http).to have_received(:request).with(request_build) }
     end
@@ -45,9 +43,7 @@ describe Castle::Core::SendRequest do
 
       it { expect(Castle::Core::GetConnection).not_to have_received(:call) }
 
-      it do
-        expect(described_class).to have_received(:build).with(command, expected_headers, config)
-      end
+      it { expect(described_class).to have_received(:build).with(command, expected_headers, config) }
 
       it { expect(http).to have_received(:request).with(request_build) }
     end
@@ -66,7 +62,7 @@ describe Castle::Core::SendRequest do
 
       before { allow(Castle::Utils::GetTimestamp).to receive(:call).and_return(time) }
 
-      it { expect(build.body).to be_eql(expected_body.to_json) }
+      it { expect(build.body).to eql(expected_body.to_json) }
       it { expect(build.method).to eql('POST') }
       it { expect(build.path).to eql("/v1/#{command.path}") }
       it { expect(build.to_hash).to have_key('authorization') }
@@ -81,7 +77,7 @@ describe Castle::Core::SendRequest do
 
       before { allow(Castle::Utils::GetTimestamp).to receive(:call).and_return(time) }
 
-      it { expect(build.body).to be_eql(expected_body.to_json) }
+      it { expect(build.body).to eql(expected_body.to_json) }
       it { expect(build.method).to eql('GET') }
       it { expect(build.path).to eql("/v1/#{command.path}") }
     end
@@ -93,7 +89,7 @@ describe Castle::Core::SendRequest do
 
       before { allow(Castle::Utils::GetTimestamp).to receive(:call).and_return(time) }
 
-      it { expect(build.body).to be_eql(expected_body.to_json) }
+      it { expect(build.body).to eql(expected_body.to_json) }
       it { expect(build.method).to eql('PUT') }
       it { expect(build.path).to eql("/v1/#{command.path}") }
     end

data/spec/lib/castle/failover/strategy_spec.rb

@@ -3,10 +3,10 @@
 describe Castle::Failover::Strategy do
   subject(:strategy) { described_class }
 
-  it { expect(strategy::ALLOW).to be_eql(:allow) }
-  it { expect(strategy::DENY).to be_eql(:deny) }
-  it { expect(strategy::CHALLENGE).to be_eql(:challenge) }
-  it { expect(strategy::THROW).to be_eql(:throw) }
+  it { expect(strategy::ALLOW).to be(:allow) }
+  it { expect(strategy::DENY).to be(:deny) }
+  it { expect(strategy::CHALLENGE).to be(:challenge) }
+  it { expect(strategy::THROW).to be(:throw) }
 
-  it { expect(Castle::Failover::STRATEGIES).to be_eql(%i[allow deny challenge throw]) }
+  it { expect(Castle::Failover::STRATEGIES).to eql(%i[allow deny challenge throw]) }
 end

data/spec/lib/castle/headers/extract_spec.rb

@@ -98,6 +98,6 @@ describe Castle::Headers::Extract do
       Castle.config.denylisted = %w[Accept]
     end
 
-    it { expect(extract_call['Accept']).to eq(true) }
+    it { expect(extract_call['Accept']).to be(true) }
   end
 end

data/spec/lib/castle/headers/filter_spec.rb

@@ -14,7 +14,9 @@ describe Castle::Headers::Filter do
         'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
         'HTTP_USER_AGENT' => 'Mozilla 1234',
         'TEST' => '1',
-        'REMOTE_ADDR' => '1.2.3.4'
+        'REMOTE_ADDR' => '1.2.3.4',
+        'HTTP_CONTENT_LENGTH' => '0',
+        'http_accept_language.parser' => -> { 'noop' }
       )
     result[:HTTP_OK] = 'OK'
     result
@@ -28,12 +30,13 @@ describe Castle::Headers::Filter do
       'Ok' => 'OK',
       'User-Agent' => 'Mozilla 1234',
       'Remote-Addr' => '1.2.3.4',
-      'X-Forwarded-For' => '1.2.3.4'
+      'X-Forwarded-For' => '1.2.3.4',
+      'Accept-Language.parser' => start_with('#<Proc')
     }
   end
   let(:request) { Rack::Request.new(env) }
 
   context 'with list of header' do
-    it { expect(filter_call).to eq(filtered) }
+    it { expect(filter_call).to match(filtered) }
   end
 end

data/spec/lib/castle/headers/format_spec.rb

@@ -4,22 +4,22 @@ describe Castle::Headers::Format do
   subject(:format) { described_class }
 
   it 'removes HTTP_' do
-    expect(format.call('HTTP_X_TEST')).to be_eql('X-Test')
+    expect(format.call('HTTP_X_TEST')).to eql('X-Test')
   end
 
   it 'capitalizes header' do
-    expect(format.call('X_TEST')).to be_eql('X-Test')
+    expect(format.call('X_TEST')).to eql('X-Test')
   end
 
   it 'ignores letter case and -_ divider' do
-    expect(format.call('http-X_teST')).to be_eql('X-Test')
+    expect(format.call('http-X_teST')).to eql('X-Test')
   end
 
   it 'does not remove http if there is no _- char' do
-    expect(format.call('httpX_teST')).to be_eql('Httpx-Test')
+    expect(format.call('httpX_teST')).to eql('Httpx-Test')
   end
 
   it 'capitalizes' do
-    expect(format.call(:clearance)).to be_eql('Clearance')
+    expect(format.call(:clearance)).to eql('Clearance')
   end
 end

data/spec/lib/castle/ips/extract_spec.rb

@@ -16,9 +16,7 @@ describe Castle::IPs::Extract do
     end
 
     context 'when we need to use other ip header' do
-      let(:headers) do
-        { 'Cf-Connecting-Ip' => '1.2.3.4', 'X-Forwarded-For' => '1.1.1.1, 1.2.2.2, 1.2.3.5' }
-      end
+      let(:headers) { { 'Cf-Connecting-Ip' => '1.2.3.4', 'X-Forwarded-For' => '1.1.1.1, 1.2.2.2, 1.2.3.5' } }
 
       context 'with uppercase format' do
         before { Castle.config.ip_headers = %w[CF_CONNECTING_IP X-Forwarded-For] }
@@ -77,9 +75,7 @@ describe Castle::IPs::Extract do
     end
 
     context 'when list of not trusted ips provided in X_FORWARDED_FOR' do
-      let(:headers) do
-        { 'X-Forwarded-For' => '6.6.6.6, 2.2.2.3, 192.168.0.7', 'Client-Ip' => '6.6.6.6' }
-      end
+      let(:headers) { { 'X-Forwarded-For' => '6.6.6.6, 2.2.2.3, 192.168.0.7', 'Client-Ip' => '6.6.6.6' } }
 
       it 'does not allow to spoof ip' do
         expect(extractor.call).to eql('2.2.2.3')

data/spec/lib/castle/logger_spec.rb

@@ -3,7 +3,8 @@
 # tmp logger for testing
 class TmpLogger
   # @param _message [String]
-  def info(_message); end
+  def info(_message)
+  end
 end
 
 describe Castle::Logger do

data/spec/lib/castle/payload/prepare_spec.rb

@@ -9,14 +9,13 @@ describe Castle::Payload::Prepare do
       '/',
       'HTTP_USER_AGENT' => ua,
       'HTTP_X_FORWARDED_FOR' => ip,
-      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh",
+      'HTTP_CONTENT_LENGTH' => '0'
     )
   end
   let(:request) { Rack::Request.new(env) }
 
-  let(:headers) do
-    { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true }
-  end
+  let(:headers) { { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, Cookie: true } }
   let(:context) do
     {
       client_id: 'abcd',
@@ -34,9 +33,7 @@ describe Castle::Payload::Prepare do
   let(:time_now) { Time.now }
   let(:time_formatted) { time_now.utc.iso8601(3) }
   let(:payload_options) { { user_id: '1234', user_traits: { name: 'Jo' } } }
-  let(:result) do
-    { user_id: '1234', user_traits: { name: 'Jo' }, timestamp: time_formatted, context: context }
-  end
+  let(:result) { { user_id: '1234', user_traits: { name: 'Jo' }, timestamp: time_formatted, context: context } }
 
   before do
     Timecop.freeze(time_now)

data/spec/lib/castle/secure_mode_spec.rb

@@ -2,8 +2,6 @@
 
 describe Castle::SecureMode do
   it 'has signature' do
-    expect(described_class.signature('test')).to eql(
-      '0329a06b62cd16b33eb6792be8c60b158d89a2ee3a876fce9a881ebb488c0914'
-    )
+    expect(described_class.signature('test')).to eql('0329a06b62cd16b33eb6792be8c60b158d89a2ee3a876fce9a881ebb488c0914')
   end
 end

data/spec/lib/castle/session_spec.rb

@@ -39,11 +39,7 @@ describe Castle::Session do
 
       before do
         Castle.config.base_url = 'https://localhost'
-        stub_request(:get, 'https://localhost/test').to_return(
-          status: 200,
-          body: '{}',
-          headers: {}
-        )
+        stub_request(:get, 'https://localhost/test').to_return(status: 200, body: '{}', headers: {})
       end
 
       context 'with block' do

data/spec/lib/castle/singleton_configuration_spec.rb

@@ -10,5 +10,5 @@ describe Castle::SingletonConfiguration do
   it_behaves_like 'configuration_failover_strategy'
   it_behaves_like 'configuration_api_secret'
 
-  it { expect(config.api_secret).to be_eql('secret') }
+  it { expect(config.api_secret).to eql('secret') }
 end

data/spec/lib/castle/utils/clone_spec.rb

@@ -13,7 +13,7 @@ describe Castle::Utils::Clone do
 
     it do
       nested[:test] = 'sample'
-      expect(cloned).to be_eql(result)
+      expect(cloned).to eql(result)
     end
   end
 end

data/spec/lib/castle/utils/merge_spec.rb

@@ -5,11 +5,9 @@ describe Castle::Utils::Merge do
 
   describe 'call' do
     let(:first) { { test: { test1: { c: '4' }, test2: { c: '3' }, a: '1', b: '2' } } }
-    let(:second) do
-      { test2: '2', test: { 'test1' => { d: '5' }, :test2 => '6', :a => nil, :b => '3' } }
-    end
+    let(:second) { { test2: '2', test: { 'test1' => { d: '5' }, :test2 => '6', :a => nil, :b => '3' } } }
     let(:result) { { test2: '2', test: { test1: { c: '4', d: '5' }, test2: '6', b: '3' } } }
 
-    it { expect(merge.call(first, second)).to be_eql(result) }
+    it { expect(merge.call(first, second)).to eql(result) }
   end
 end

data/spec/lib/castle/validators/not_supported_spec.rb

@@ -7,12 +7,7 @@ describe Castle::Validators::NotSupported do
     context 'when keys is present' do
       let(:keys) { %i[first second] }
 
-      it do
-        expect { call }.to raise_error(
-          Castle::InvalidParametersError,
-          'first is/are not supported'
-        )
-      end
+      it { expect { call }.to raise_error(Castle::InvalidParametersError, 'first is/are not supported') }
     end
 
     context 'when key is not present' do

data/spec/lib/castle/validators/present_spec.rb

@@ -7,20 +7,13 @@ describe Castle::Validators::Present do
     context 'when keys is not present' do
       let(:keys) { %i[second third] }
 
-      it do
-        expect { call }.to raise_error(Castle::InvalidParametersError, 'third is missing or empty')
-      end
+      it { expect { call }.to raise_error(Castle::InvalidParametersError, 'third is missing or empty') }
     end
 
     context 'when keys is empty' do
       let(:keys) { %i[second invalid] }
 
-      it do
-        expect { call }.to raise_error(
-          Castle::InvalidParametersError,
-          'invalid is missing or empty'
-        )
-      end
+      it { expect { call }.to raise_error(Castle::InvalidParametersError, 'invalid is missing or empty') }
     end
 
     context 'when key is present' do

data/spec/lib/castle/verdict_spec.rb

@@ -3,7 +3,7 @@
 describe Castle::Verdict do
   subject(:verdict) { described_class }
 
-  it { expect(verdict::ALLOW).to be_eql('allow') }
-  it { expect(verdict::DENY).to be_eql('deny') }
-  it { expect(verdict::CHALLENGE).to be_eql('challenge') }
+  it { expect(verdict::ALLOW).to eql('allow') }
+  it { expect(verdict::DENY).to eql('deny') }
+  it { expect(verdict::CHALLENGE).to eql('challenge') }
 end