castle-rb 7.1.2 → 8.0.0

data/spec/integration/rails/support/home_controller.rb

@@ -4,16 +4,7 @@ class HomeController < ActionController::Base
   # prepare context and calling track with client example
   def index1
     request_context = ::Castle::Context::Prepare.call(request)
-    payload = {
-      event: '$login.succeeded',
-      user_id: '123',
-      properties: {
-        key: 'value'
-      },
-      user_traits: {
-        key: 'value'
-      }
-    }
+    payload = { event: '$login.succeeded', user_id: '123', properties: { key: 'value' }, user_traits: { key: 'value' } }
     client = ::Castle::Client.new(context: request_context)
     client.track(payload)
 
@@ -24,16 +15,7 @@ class HomeController < ActionController::Base
   def index2
     payload =
       ::Castle::Payload::Prepare.call(
-        {
-          event: '$login.succeeded',
-          user_id: '123',
-          properties: {
-            key: 'value'
-          },
-          user_traits: {
-            key: 'value'
-          }
-        },
+        { event: '$login.succeeded', user_id: '123', properties: { key: 'value' }, user_traits: { key: 'value' } },
         request
       )
     client = ::Castle::Client.new
@@ -46,18 +28,10 @@ class HomeController < ActionController::Base
   def index3
     payload =
       ::Castle::Payload::Prepare.call(
-        {
-          event: '$login.succeeded',
-          user_id: '123',
-          properties: {
-            key: 'value'
-          },
-          user_traits: {
-            key: 'value'
-          }
-        },
+        { event: '$login.succeeded', user_id: '123', properties: { key: 'value' }, user_traits: { key: 'value' } },
         request
       )
+
     Castle::API::Track.call(payload)
 
     render inline: 'hello'

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

@@ -2,9 +2,7 @@
 
 describe Castle::API::ApproveDevice do
   before do
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: 200, body: '{}', headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(status: 200, body: '{}', headers: {})
   end
 
   describe '.call' do
@@ -14,8 +12,6 @@ describe Castle::API::ApproveDevice do
 
     before { retrieve }
 
-    it do
-      assert_requested :put, "https://api.castle.io/v1/devices/#{device_token}/approve", times: 1
-    end
+    it { assert_requested :put, "https://api.castle.io/v1/devices/#{device_token}/approve", times: 1 }
   end
 end

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

@@ -29,15 +29,16 @@ describe Castle::API::Authenticate do
   after { Timecop.return }
 
   describe '.call' 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 } }
 
     context 'when used with symbol keys' do
       before do
-        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: {
+          }
+        )
         call_subject
       end
 
@@ -50,17 +51,9 @@ describe Castle::API::Authenticate 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
@@ -78,15 +71,16 @@ describe Castle::API::Authenticate do
 
       context 'when denied without any risk policy' do
         let(:response_body) { deny_response_without_rp.to_json }
-        let(:deny_response_without_rp) do
-          { action: 'deny', user_id: '12345', device_token: 'abcdefg1234' }
-        end
+        let(:deny_response_without_rp) { { action: 'deny', user_id: '12345', device_token: 'abcdefg1234' } }
         let(:deny_without_rp_failover_result) { deny_response_without_rp.merge(failover_appendix) }
 
         before do
-          stub_request(:any, /api.castle.io/)
-            .with(basic_auth: ['', 'secret'])
-            .to_return(status: 200, body: deny_response_without_rp.to_json, headers: {})
+          stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(
+            status: 200,
+            body: deny_response_without_rp.to_json,
+            headers: {
+            }
+          )
           call_subject
         end
 
@@ -117,9 +111,12 @@ describe Castle::API::Authenticate do
         let(:deny_with_rp_failover_result) { deny_response_with_rp.merge(failover_appendix) }
 
         before do
-          stub_request(:any, /api.castle.io/)
-            .with(basic_auth: ['', 'secret'])
-            .to_return(status: 200, body: deny_response_with_rp.to_json, headers: {})
+          stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(
+            status: 200,
+            body: deny_response_with_rp.to_json,
+            headers: {
+            }
+          )
           call_subject
         end
 

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

@@ -22,9 +22,12 @@ describe Castle::API::EndImpersonation 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::EndImpersonation 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/get_device_spec.rb

@@ -2,9 +2,7 @@
 
 describe Castle::API::GetDevice do
   before do
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: 200, body: '{}', headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(status: 200, body: '{}', headers: {})
   end
 
   describe '.call' do

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

@@ -2,9 +2,7 @@
 
 describe Castle::API::GetDevicesForUser do
   before do
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: 200, body: '{}', headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(status: 200, body: '{}', headers: {})
   end
 
   describe '.call' do

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

@@ -2,9 +2,7 @@
 
 describe Castle::API::ReportDevice do
   before do
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: 200, body: '{}', headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(status: 200, body: '{}', headers: {})
   end
 
   describe '.call' do
@@ -14,8 +12,6 @@ describe Castle::API::ReportDevice do
 
     before { retrieve }
 
-    it do
-      assert_requested :put, "https://api.castle.io/v1/devices/#{device_token}/report", times: 1
-    end
+    it { assert_requested :put, "https://api.castle.io/v1/devices/#{device_token}/report", times: 1 }
   end
 end

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',
@@ -41,13 +38,21 @@ describe Castle::Client do
   let(:time_auto) { time_now.utc.iso8601(3) }
   let(:time_user) { (Time.now - 10_000).utc.iso8601(3) }
   let(:response_body) { {}.to_json }
+  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: {
+      }
+    )
+  end
 
   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_response
   end
 
   after { Timecop.return }
@@ -90,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
 
@@ -125,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
 
@@ -135,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
@@ -157,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
@@ -176,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
@@ -225,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) }
@@ -247,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) }
@@ -268,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) }
@@ -303,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
@@ -322,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