castle-rb 7.1.2 → 8.0.0

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

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