castle-rb 7.2.0 → 8.0.0

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

@@ -22,9 +22,12 @@ describe Castle::API::StartImpersonation do
   before do
     Timecop.freeze(time_now)
     stub_const('Castle::VERSION', '2.2.0')
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: 200, body: response_body, headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(
+      status: 200,
+      body: response_body,
+      headers: {
+      }
+    )
   end
 
   after { Timecop.return }
@@ -32,19 +35,10 @@ describe Castle::API::StartImpersonation do
   describe 'call' do
     let(:impersonator) { 'test@castle.io' }
     let(:request_body) do
-      {
-        user_id: '1234',
-        sent_at: time_auto,
-        properties: {
-          impersonator: impersonator
-        },
-        context: context
-      }
+      { user_id: '1234', sent_at: time_auto, properties: { impersonator: impersonator }, context: context }
     end
     let(:response_body) { { success: true }.to_json }
-    let(:options) do
-      { user_id: '1234', properties: { impersonator: impersonator }, context: context }
-    end
+    let(:options) { { user_id: '1234', properties: { impersonator: impersonator }, context: context } }
 
     context 'when used with symbol keys' do
       before { call }

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

@@ -24,17 +24,18 @@ describe Castle::API::Track do
   before do
     Timecop.freeze(time_now)
     stub_const('Castle::VERSION', '2.2.0')
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: 200, body: response_body, headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(
+      status: 200,
+      body: response_body,
+      headers: {
+      }
+    )
   end
 
   after { Timecop.return }
 
   describe 'track' do
-    let(:request_body) do
-      { event: '$login.succeeded', context: context, user_id: '1234', sent_at: time_auto }
-    end
+    let(:request_body) { { event: '$login.succeeded', context: context, user_id: '1234', sent_at: time_auto } }
 
     before { call }
 
@@ -48,17 +49,9 @@ describe Castle::API::Track do
       end
 
       context 'when passed timestamp in options and no defined timestamp' do
-        let(:options) do
-          { event: '$login.succeeded', user_id: '1234', timestamp: time_user, context: context }
-        end
+        let(:options) { { event: '$login.succeeded', user_id: '1234', timestamp: time_user, context: context } }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do

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

@@ -11,20 +11,13 @@ describe Castle::ClientId::Extract do
   let(:env) { Rack::MockRequest.env_for('/', headers) }
 
   context 'with client_id' do
-    let(:headers) do
-      {
-        'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-        'HTTP_COOKIE' => "__cid=#{client_id_cookie};other=efgh"
-      }
-    end
+    let(:headers) { { 'HTTP_X_FORWARDED_FOR' => '1.2.3.4', 'HTTP_COOKIE' => "__cid=#{client_id_cookie};other=efgh" } }
 
     it { expect(extractor.call).to eql(client_id_cookie) }
   end
 
   context 'with X-Castle-Client-Id header' do
-    let(:headers) do
-      { 'HTTP_X_FORWARDED_FOR' => '1.2.3.4', 'HTTP_X_CASTLE_CLIENT_ID' => client_id_header }
-    end
+    let(:headers) { { 'HTTP_X_FORWARDED_FOR' => '1.2.3.4', 'HTTP_X_CASTLE_CLIENT_ID' => client_id_header } }
 
     it 'appends the client_id' do
       expect(extractor.call).to eql(client_id_header)

data/spec/lib/castle/client_spec.rb

@@ -9,20 +9,17 @@ describe Castle::Client 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(:client) { described_class.from_request(request) }
   let(:request_to_context) { Castle::Context::Prepare.call(request) }
-  let(:client_with_user_timestamp) do
-    described_class.new(context: request_to_context, timestamp: time_user)
-  end
+  let(:client_with_user_timestamp) { described_class.new(context: request_to_context, timestamp: time_user) }
   let(:client_with_no_timestamp) { described_class.new(context: request_to_context) }
 
-  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',
@@ -44,9 +41,12 @@ describe Castle::Client do
   let(:response_code) { 200 }
 
   let(:stub_response) do
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: response_code, body: response_body, headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(
+      status: response_code,
+      body: response_body,
+      headers: {
+      }
+    )
   end
 
   before do
@@ -95,9 +95,7 @@ describe Castle::Client do
     context 'when request is not successful' do
       let(:response_body) { {}.to_json }
 
-      it do
-        expect { client.end_impersonation(options) }.to raise_error(Castle::ImpersonationFailed)
-      end
+      it { expect { client.end_impersonation(options) }.to raise_error(Castle::ImpersonationFailed) }
     end
   end
 
@@ -130,9 +128,7 @@ describe Castle::Client do
     context 'when request is not successful' do
       let(:response_body) { {}.to_json }
 
-      it do
-        expect { client.start_impersonation(options) }.to raise_error(Castle::ImpersonationFailed)
-      end
+      it { expect { client.start_impersonation(options) }.to raise_error(Castle::ImpersonationFailed) }
     end
   end
 
@@ -140,13 +136,7 @@ describe Castle::Client do
     let(:options) { { event: '$login.succeeded', user_id: '1234' } }
     let(:request_response) { client.authenticate(options) }
     let(:request_body) do
-      {
-        event: '$login.succeeded',
-        user_id: '1234',
-        context: context,
-        timestamp: time_auto,
-        sent_at: time_auto
-      }
+      { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_auto, sent_at: time_auto }
     end
 
     context 'when used with symbol keys' do
@@ -162,13 +152,7 @@ describe Castle::Client do
         let(:client) { client_with_no_timestamp }
         let(:options) { { event: '$login.succeeded', user_id: '1234', timestamp: time_user } }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -181,13 +165,7 @@ describe Castle::Client do
       context 'with client initialized with timestamp' do
         let(:client) { client_with_user_timestamp }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -230,19 +208,15 @@ describe Castle::Client do
       end
 
       it { assert_not_requested :post, 'https://api.castle.io/v1/authenticate' }
-      it { expect(request_response[:policy][:action]).to be_eql(Castle::Verdict::ALLOW) }
-      it { expect(request_response[:action]).to be_eql(Castle::Verdict::ALLOW) }
-      it { expect(request_response[:user_id]).to be_eql('1234') }
+      it { expect(request_response[:policy][:action]).to eql(Castle::Verdict::ALLOW) }
+      it { expect(request_response[:action]).to eql(Castle::Verdict::ALLOW) }
+      it { expect(request_response[:user_id]).to eql('1234') }
       it { expect(request_response[:failover]).to be true }
-      it { expect(request_response[:failover_reason]).to be_eql('Castle is set to do not track.') }
+      it { expect(request_response[:failover_reason]).to eql('Castle is set to do not track.') }
     end
 
     context 'when request with fail' do
-      before do
-        allow(Castle::API).to receive(:send_request).and_raise(
-          Castle::RequestError.new(Timeout::Error)
-        )
-      end
+      before { allow(Castle::API).to receive(:send_request).and_raise(Castle::RequestError.new(Timeout::Error)) }
 
       context 'with request error and throw strategy' do
         before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
@@ -252,18 +226,16 @@ describe Castle::Client do
 
       context 'with request error and not throw on eg deny strategy' do
         it { assert_not_requested :post, 'https://:secret@api.castle.io/v1/authenticate' }
-        it { expect(request_response[:policy][:action]).to be_eql('allow') }
-        it { expect(request_response[:action]).to be_eql('allow') }
-        it { expect(request_response[:user_id]).to be_eql('1234') }
+        it { expect(request_response[:policy][:action]).to eql('allow') }
+        it { expect(request_response[:action]).to eql('allow') }
+        it { expect(request_response[:user_id]).to eql('1234') }
         it { expect(request_response[:failover]).to be true }
-        it { expect(request_response[:failover_reason]).to be_eql('Castle::RequestError') }
+        it { expect(request_response[:failover_reason]).to eql('Castle::RequestError') }
       end
     end
 
     context 'when request is internal server error' do
-      before do
-        allow(Castle::API).to receive(:send_request).and_raise(Castle::InternalServerError)
-      end
+      before { allow(Castle::API).to receive(:send_request).and_raise(Castle::InternalServerError) }
 
       describe 'throw strategy' do
         before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
@@ -273,24 +245,18 @@ describe Castle::Client do
 
       describe 'not throw on eg deny strategy' do
         it { assert_not_requested :post, 'https://:secret@api.castle.io/v1/authenticate' }
-        it { expect(request_response[:policy][:action]).to be_eql('allow') }
-        it { expect(request_response[:action]).to be_eql('allow') }
-        it { expect(request_response[:user_id]).to be_eql('1234') }
+        it { expect(request_response[:policy][:action]).to eql('allow') }
+        it { expect(request_response[:action]).to eql('allow') }
+        it { expect(request_response[:user_id]).to eql('1234') }
         it { expect(request_response[:failover]).to be true }
-        it { expect(request_response[:failover_reason]).to be_eql('Castle::InternalServerError') }
+        it { expect(request_response[:failover_reason]).to eql('Castle::InternalServerError') }
       end
     end
   end
 
   describe 'track' do
     let(:request_body) do
-      {
-        event: '$login.succeeded',
-        context: context,
-        user_id: '1234',
-        timestamp: time_auto,
-        sent_at: time_auto
-      }
+      { event: '$login.succeeded', context: context, user_id: '1234', timestamp: time_auto, sent_at: time_auto }
     end
 
     before { client.track(options) }
@@ -308,13 +274,7 @@ describe Castle::Client do
         let(:client) { client_with_no_timestamp }
         let(:options) { { event: '$login.succeeded', user_id: '1234', timestamp: time_user } }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -327,13 +287,7 @@ describe Castle::Client do
       context 'with client initialized with timestamp' do
         let(:client) { client_with_user_timestamp }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            context: context,
-            user_id: '1234',
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', context: context, user_id: '1234', timestamp: time_user, sent_at: time_auto }
         end
 
         it do

data/spec/lib/castle/command_spec.rb

@@ -3,7 +3,7 @@
 describe Castle::Command do
   subject(:command) { described_class.new('go', { id: '1' }, :post) }
 
-  it { expect(command.path).to be_eql('go') }
-  it { expect(command.data).to be_eql(id: '1') }
-  it { expect(command.method).to be_eql(:post) }
+  it { expect(command.path).to eql('go') }
+  it { expect(command.data).to eql(id: '1') }
+  it { expect(command.method).to be(:post) }
 end

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

@@ -16,8 +16,8 @@ describe Castle::Commands::ApproveDevice do
     end
 
     context 'with device_token' do
-      it { expect(command.method).to be_eql(:put) }
-      it { expect(command.path).to be_eql("devices/#{device_token}/approve") }
+      it { expect(command.method).to be(:put) }
+      it { expect(command.path).to eql("devices/#{device_token}/approve") }
       it { expect(command.data).to be_nil }
     end
   end

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

@@ -4,9 +4,7 @@ describe Castle::Commands::Authenticate do
   subject(:instance) { described_class }
 
   let(:context) { { test: { test1: '1' } } }
-  let(:default_payload) do
-    { event: '$login.authenticate', user_id: '1234', sent_at: time_auto, context: context }
-  end
+  let(:default_payload) { { event: '$login.authenticate', user_id: '1234', sent_at: time_auto, context: context } }
 
   let(:time_now) { Time.now }
   let(:time_auto) { time_now.utc.iso8601(3) }
@@ -22,45 +20,45 @@ describe Castle::Commands::Authenticate 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('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      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('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      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('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      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('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      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('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 
@@ -70,12 +68,7 @@ describe Castle::Commands::Authenticate do
     context 'with 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 'with user_id not present' do

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

@@ -19,40 +19,38 @@ describe Castle::Commands::EndImpersonation 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(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      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(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      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(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      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(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 
@@ -62,12 +60,7 @@ describe Castle::Commands::EndImpersonation 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/filter_spec.rb

@@ -28,45 +28,45 @@ describe Castle::Commands::Filter 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('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      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('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      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('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      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('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      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('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 end

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

@@ -16,8 +16,8 @@ describe Castle::Commands::GetDevice do
     end
 
     context 'with device_token' do
-      it { expect(command.method).to be_eql(:get) }
-      it { expect(command.path).to be_eql("devices/#{device_token}") }
+      it { expect(command.method).to be(:get) }
+      it { expect(command.path).to eql("devices/#{device_token}") }
       it { expect(command.data).to be_nil }
     end
   end

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

@@ -16,8 +16,8 @@ describe Castle::Commands::GetDevicesForUser do
     end
 
     context 'with user_id' do
-      it { expect(command.method).to be_eql(:get) }
-      it { expect(command.path).to be_eql("users/#{user_id}/devices") }
+      it { expect(command.method).to be(:get) }
+      it { expect(command.path).to eql("users/#{user_id}/devices") }
       it { expect(command.data).to be_nil }
     end
   end

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

@@ -29,45 +29,45 @@ describe Castle::Commands::Log 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('log') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('log') }
+      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('log') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('log') }
+      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('log') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('log') }
+      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('log') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('log') }
+      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('log') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('log') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 end

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

@@ -16,8 +16,8 @@ describe Castle::Commands::ReportDevice do
     end
 
     context 'with device_token' do
-      it { expect(command.method).to be_eql(:put) }
-      it { expect(command.path).to be_eql("devices/#{device_token}/report") }
+      it { expect(command.method).to be(:put) }
+      it { expect(command.path).to eql("devices/#{device_token}/report") }
       it { expect(command.data).to be_nil }
     end
   end