castle-rb 6.0.1 → 7.1.2

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

@@ -7,11 +7,13 @@ describe Castle::Context::GetDefault do
   let(:client_id) { 'abcd' }
 
   let(:env) do
-    Rack::MockRequest.env_for('/',
-                              'HTTP_X_FORWARDED_FOR' => ip,
-                              'HTTP_ACCEPT_LANGUAGE' => 'en',
-                              'HTTP_USER_AGENT' => 'test',
-                              'HTTP_COOKIE' => "__cid=#{client_id};other=efgh")
+    Rack::MockRequest.env_for(
+      '/',
+      'HTTP_X_FORWARDED_FOR' => ip,
+      'HTTP_ACCEPT_LANGUAGE' => 'en',
+      'HTTP_USER_AGENT' => 'test',
+      'HTTP_COOKIE' => "__cid=#{client_id};other=efgh"
+    )
   end
   let(:request) { Rack::Request.new(env) }
   let(:default_context) { subject.call }
@@ -26,9 +28,7 @@ describe Castle::Context::GetDefault do
     }
   end
 
-  before do
-    stub_const('Castle::VERSION', version)
-  end
+  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) }

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

@@ -20,19 +20,18 @@ describe Castle::Context::Prepare do
       user_agent: ua,
       headers: headers,
       ip: ip,
-      library: { name: 'castle-rb', version: '6.0.0' }
+      library: {
+        name: 'castle-rb',
+        version: '6.0.0'
+      }
     }
   end
 
   let(:headers) do
-    {
-      'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true
-    }
+    { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true }
   end
 
-  before do
-    stub_const('Castle::VERSION', '6.0.0')
-  end
+  before { stub_const('Castle::VERSION', '6.0.0') }
 
   describe '#call' do
     subject(:generated) { described_class.call(request) }

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

@@ -12,47 +12,31 @@ describe Castle::Core::GetConnection do
       before do
         Castle.config.base_url = 'http://localhost:3002'
 
-        allow(Net::HTTP)
-          .to receive(:new)
-          .with(localhost, port)
-          .and_call_original
+        allow(Net::HTTP).to receive(:new).with(localhost, port).and_call_original
       end
 
       it do
         class_call
 
-        expect(Net::HTTP)
-          .to have_received(:new)
-          .with(localhost, port)
+        expect(Net::HTTP).to have_received(:new).with(localhost, port)
       end
 
-      it do
-        expect(class_call).to be_an_instance_of(Net::HTTP)
-      end
+      it { expect(class_call).to be_an_instance_of(Net::HTTP) }
     end
 
     context 'when ssl true' do
       let(:localhost) { 'localhost' }
       let(:port) { 443 }
 
-      before do
-        Castle.config.base_url = 'https://localhost'
-      end
+      before { Castle.config.base_url = 'https://localhost' }
 
       context 'with block' do
         let(:api_url) { '/test' }
         let(:request) { Net::HTTP::Get.new(api_url) }
 
-        before do
-          allow(Net::HTTP)
-            .to receive(:new)
-            .with(localhost, port)
-            .and_call_original
-        end
+        before { allow(Net::HTTP).to receive(:new).with(localhost, port).and_call_original }
 
-        it do
-          expect(class_call).to be_an_instance_of(Net::HTTP)
-        end
+        it { expect(class_call).to be_an_instance_of(Net::HTTP) }
       end
     end
   end

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

@@ -38,14 +38,7 @@ describe Castle::Core::ProcessResponse do
           '{"action":"deny","user_id":"1","device_token":"abc",
           "risk_policy":{"id":"123","revision_id":"abc","name":"def","type":"bot"}}'
         end
-        let(:response) do
-          OpenStruct.new(
-            {
-              body: body,
-              code: 200
-            }
-          )
-        end
+        let(:response) { OpenStruct.new({ body: body, code: 200 }) }
 
         let(:result) do
           {

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

@@ -27,9 +27,7 @@ describe Castle::Core::SendRequest do
       end
 
       it do
-        expect(described_class).to have_received(:build).with(
-          command, expected_headers, config
-        )
+        expect(described_class).to have_received(:build).with(command, expected_headers, config)
       end
 
       it { expect(http).to have_received(:request).with(request_build) }
@@ -48,9 +46,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
-        )
+        expect(described_class).to have_received(:build).with(command, expected_headers, config)
       end
 
       it { expect(http).to have_received(:request).with(request_build) }
@@ -63,40 +59,43 @@ describe Castle::Core::SendRequest do
     let(:headers) { { 'SAMPLE-HEADER' => '1' } }
     let(:api_secret) { 'secret' }
 
-    context 'when get' do
-      let(:command) { Castle::Commands::Review.build({ review_id: review_id }) }
-      let(:review_id) { SecureRandom.uuid }
+    context 'when post' do
+      let(:time) { Time.now.utc.iso8601(3) }
+      let(:command) { Castle::Commands::Track.build(event: '$login.succeeded', name: "\xC4") }
+      let(:expected_body) { { event: '$login.succeeded', name: '�', context: {}, sent_at: time } }
 
-      it { expect(build.body).to be_nil }
-      it { expect(build.method).to eql('GET') }
+      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.method).to eql('POST') }
       it { expect(build.path).to eql("/v1/#{command.path}") }
       it { expect(build.to_hash).to have_key('authorization') }
       it { expect(build.to_hash).to have_key('sample-header') }
       it { expect(build.to_hash['sample-header']).to eql(['1']) }
     end
 
-    context 'when post' do
+    context 'when get' do
       let(:time) { Time.now.utc.iso8601(3) }
-      let(:command) do
-        Castle::Commands::Track.build(event: '$login.succeeded', name: "\xC4")
-      end
-      let(:expected_body) do
-        {
-          event: '$login.succeeded',
-          name: '�',
-          context: {},
-          sent_at: time
-        }
-      end
+      let(:command) { Castle::Commands::GetDevice.build(device_token: '1') }
+      let(:expected_body) { {} }
 
       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.method).to eql('POST') }
+      it { expect(build.method).to eql('GET') }
+      it { expect(build.path).to eql("/v1/#{command.path}") }
+    end
+
+    context 'when put' do
+      let(:time) { Time.now.utc.iso8601(3) }
+      let(:command) { Castle::Commands::ApproveDevice.build(device_token: '1') }
+      let(:expected_body) { {} }
+
+      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.method).to eql('PUT') }
       it { expect(build.path).to eql("/v1/#{command.path}") }
-      it { expect(build.to_hash).to have_key('authorization') }
-      it { expect(build.to_hash).to have_key('sample-header') }
-      it { expect(build.to_hash['sample-header']).to eql(['1']) }
     end
   end
 end

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

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

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

@@ -4,17 +4,18 @@ describe Castle::Headers::Filter do
   subject(:filter_call) { described_class.new(request).call }
 
   let(:env) do
-    result = Rack::MockRequest.env_for(
-      '/',
-      'Action-Dispatch.request.content-Type' => 'application/json',
-      'HTTP_AUTHORIZATION' => 'Basic 123456',
-      'HTTP_COOKIE' => '__cid=abcd;other=efgh',
-      'HTTP_ACCEPT' => 'application/json',
-      'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-      'HTTP_USER_AGENT' => 'Mozilla 1234',
-      'TEST' => '1',
-      'REMOTE_ADDR' => '1.2.3.4'
-    )
+    result =
+      Rack::MockRequest.env_for(
+        '/',
+        'Action-Dispatch.request.content-Type' => 'application/json',
+        'HTTP_AUTHORIZATION' => 'Basic 123456',
+        'HTTP_COOKIE' => '__cid=abcd;other=efgh',
+        'HTTP_ACCEPT' => 'application/json',
+        'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
+        'HTTP_USER_AGENT' => 'Mozilla 1234',
+        'TEST' => '1',
+        'REMOTE_ADDR' => '1.2.3.4'
+      )
     result[:HTTP_OK] = 'OK'
     result
   end

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

@@ -43,9 +43,7 @@ describe Castle::IPs::Extract do
     end
 
     context 'with all the trusted proxies' do
-      let(:http_x_header) do
-        '127.0.0.1,10.0.0.1,172.31.0.1,192.168.0.1'
-      end
+      let(:http_x_header) { '127.0.0.1,10.0.0.1,172.31.0.1,192.168.0.1' }
 
       let(:headers) { { 'Remote-Addr' => '127.0.0.1', 'X-Forwarded-For' => http_x_header } }
 
@@ -55,9 +53,7 @@ describe Castle::IPs::Extract do
     end
 
     context 'with trust_proxy_chain option' do
-      let(:http_x_header) do
-        '6.6.6.6, 2.2.2.3, 6.6.6.5'
-      end
+      let(:http_x_header) { '6.6.6.6, 2.2.2.3, 6.6.6.5' }
 
       let(:headers) { { 'Remote-Addr' => '6.6.6.4', 'X-Forwarded-For' => http_x_header } }
 
@@ -69,9 +65,7 @@ describe Castle::IPs::Extract do
     end
 
     context 'with trusted_proxy_depth option' do
-      let(:http_x_header) do
-        '6.6.6.6, 2.2.2.3, 6.6.6.5'
-      end
+      let(:http_x_header) { '6.6.6.6, 2.2.2.3, 6.6.6.5' }
 
       let(:headers) { { 'Remote-Addr' => '6.6.6.4', 'X-Forwarded-For' => http_x_header } }
 
@@ -84,10 +78,7 @@ describe Castle::IPs::Extract do
 
     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'
-        }
+        { 'X-Forwarded-For' => '6.6.6.6, 2.2.2.3, 192.168.0.7', 'Client-Ip' => '6.6.6.6' }
       end
 
       it 'does not allow to spoof ip' do

data/spec/lib/castle/logger_spec.rb

@@ -7,18 +7,14 @@ class TmpLogger
 end
 
 describe Castle::Logger do
-  subject(:log) do
-    described_class.call(message, data)
-  end
+  subject(:log) { described_class.call(message, data) }
 
   let(:message) { 'https://localhost/test:' }
   let(:integration_logger) { TmpLogger.new }
   let(:data) { { a: 1 }.to_json }
   let(:logger_message) { "[CASTLE] #{message} #{data}" }
 
-  before do
-    allow(integration_logger).to receive(:info).and_call_original
-  end
+  before { allow(integration_logger).to receive(:info).and_call_original }
 
   describe '.call' do
     context 'without logger' do

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

@@ -15,9 +15,7 @@ describe Castle::Payload::Prepare do
   let(:request) { Rack::Request.new(env) }
 
   let(:headers) do
-    {
-      'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true
-    }
+    { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true }
   end
   let(:context) do
     {
@@ -26,7 +24,10 @@ describe Castle::Payload::Prepare do
       user_agent: ua,
       headers: headers,
       ip: ip,
-      library: { name: 'castle-rb', version: '2.2.0' }
+      library: {
+        name: 'castle-rb',
+        version: '2.2.0'
+      }
     }
   end
 

data/spec/lib/castle/session_spec.rb

@@ -16,35 +16,20 @@ describe Castle::Session do
         let(:request) { Net::HTTP::Get.new(api_url) }
 
         before do
-          allow(Net::HTTP)
-            .to receive(:new)
-            .with(localhost, port)
-            .and_call_original
-
-          described_class.call do |http|
-            http.request(request)
-          end
-        end
+          allow(Net::HTTP).to receive(:new).with(localhost, port).and_call_original
 
-        it do
-          expect(Net::HTTP)
-            .to have_received(:new)
-            .with(localhost, port)
+          described_class.call { |http| http.request(request) }
         end
 
-        it do
-          expect(a_request(:get, 'localhost:3002/test'))
-            .to have_been_made.once
-        end
+        it { expect(Net::HTTP).to have_received(:new).with(localhost, port) }
+
+        it { expect(a_request(:get, 'localhost:3002/test')).to have_been_made.once }
       end
 
       context 'without block' do
         before { described_class.call }
 
-        it do
-          expect(a_request(:get, 'localhost:3002/test'))
-            .not_to have_been_made
-        end
+        it { expect(a_request(:get, 'localhost:3002/test')).not_to have_been_made }
       end
     end
 
@@ -55,7 +40,9 @@ describe Castle::Session do
       before do
         Castle.config.base_url = 'https://localhost'
         stub_request(:get, 'https://localhost/test').to_return(
-          status: 200, body: '{}', headers: {}
+          status: 200,
+          body: '{}',
+          headers: {}
         )
       end
 
@@ -64,24 +51,14 @@ describe Castle::Session do
         let(:request) { Net::HTTP::Get.new(api_url) }
 
         before do
-          allow(Net::HTTP)
-            .to receive(:new)
-            .with(localhost, port)
-            .and_call_original
+          allow(Net::HTTP).to receive(:new).with(localhost, port).and_call_original
 
-          allow(Net::HTTP)
-            .to receive(:start)
+          allow(Net::HTTP).to receive(:start)
 
-          described_class.call do |http|
-            http.request(request)
-          end
+          described_class.call { |http| http.request(request) }
         end
 
-        it do
-          expect(Net::HTTP)
-            .to have_received(:new)
-            .with(localhost, port)
-        end
+        it { expect(Net::HTTP).to have_received(:new).with(localhost, port) }
       end
     end
   end

data/spec/lib/castle/singleton_configuration_spec.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 describe Castle::SingletonConfiguration do
-  subject(:config) do
-    described_class.instance
-  end
+  subject(:config) { described_class.instance }
 
   it_behaves_like 'configuration_host'
   it_behaves_like 'configuration_request_timeout'
@@ -12,7 +10,5 @@ describe Castle::SingletonConfiguration do
   it_behaves_like 'configuration_failover_strategy'
   it_behaves_like 'configuration_api_secret'
 
-  it do
-    expect(config.api_secret).to be_eql('secret')
-  end
+  it { expect(config.api_secret).to be_eql('secret') }
 end