castle-rb 5.0.0 → 6.0.0

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+describe Castle::API::GetDevicesForUser do
+  before do
+    stub_request(:any, /api.castle.io/).with(
+      basic_auth: ['', 'secret']
+    ).to_return(status: 200, body: '{}', headers: {})
+  end
+
+  describe '.call' do
+    subject(:retrieve) { described_class.call(user_id: user_id) }
+
+    let(:user_id) { '1234' }
+
+    before { retrieve }
+
+    it { assert_requested :get, "https://api.castle.io/v1/users/#{user_id}/devices", times: 1 }
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe Castle::API::Identify do
+  subject(:call) { described_class.call(options) }
+
+  let(:ip) { '1.2.3.4' }
+  let(:cookie_id) { 'abcd' }
+  let(:ua) { 'Chrome' }
+  let(:env) do
+    Rack::MockRequest.env_for(
+      '/',
+      'HTTP_USER_AGENT' => ua,
+      'HTTP_X_FORWARDED_FOR' => ip,
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+    )
+  end
+  let(:request) { Rack::Request.new(env) }
+  let(:context) { Castle::Context::Prepare.call(request) }
+  let(:time_now) { Time.now }
+  let(:time_auto) { time_now.utc.iso8601(3) }
+  let(:time_user) { (Time.now - 10_000).utc.iso8601(3) }
+  let(:response_body) { {}.to_json }
+
+  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: {})
+  end
+
+  after { Timecop.return }
+
+  describe '.call' do
+    let(:request_body) do
+      { event: '$login.succeeded', context: context, user_id: '1234',
+        sent_at: time_auto }
+    end
+
+    before { call }
+
+    context 'when used with symbol keys' do
+      let(:options) { { event: '$login.succeeded', user_id: '1234', context: context } }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/identify', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      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(:request_body) do
+          { event: '$login.succeeded', user_id: '1234', context: context,
+            timestamp: time_user, sent_at: time_auto }
+        end
+
+        it do
+          assert_requested :post, 'https://api.castle.io/v1/identify', times: 1 do |req|
+            JSON.parse(req.body) == JSON.parse(request_body.to_json)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+describe Castle::API::ReportDevice do
+  before do
+    stub_request(:any, /api.castle.io/).with(
+      basic_auth: ['', 'secret']
+    ).to_return(status: 200, body: '{}', headers: {})
+  end
+
+  describe '.call' do
+    subject(:retrieve) { described_class.call(device_token: device_token) }
+
+    let(:device_token) { '1234' }
+
+    before { retrieve }
+
+    it do
+      assert_requested :put, "https://api.castle.io/v1/devices/#{device_token}/report", times: 1
+    end
+  end
+end

data/spec/lib/castle/{review_spec.rb → api/review_spec.rb}

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-describe Castle::Review do
+describe Castle::API::Review do
   before do
     stub_request(:any, /api.castle.io/).with(
       basic_auth: ['', 'secret']
     ).to_return(status: 200, body: '{}', headers: {})
   end
 
-  describe '#retrieve' do
-    subject(:retrieve) { described_class.retrieve(review_id) }
+  describe '.call' do
+    subject(:retrieve) { described_class.call(review_id: review_id) }
 
     let(:review_id) { '1234' }
 

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+describe Castle::API::StartImpersonation do
+  subject(:call) { described_class.call(options) }
+
+  let(:ip) { '1.2.3.4' }
+  let(:cookie_id) { 'abcd' }
+  let(:ua) { 'Chrome' }
+  let(:env) do
+    Rack::MockRequest.env_for(
+      '/',
+      'HTTP_USER_AGENT' => ua,
+      'HTTP_X_FORWARDED_FOR' => ip,
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+    )
+  end
+  let(:request) { Rack::Request.new(env) }
+  let(:context) { Castle::Context::Prepare.call(request) }
+  let(:time_now) { Time.now }
+  let(:time_auto) { time_now.utc.iso8601(3) }
+
+  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: {})
+  end
+
+  after { Timecop.return }
+
+  describe 'call' do
+    let(:impersonator) { 'test@castle.io' }
+    let(:request_body) do
+      { 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
+
+    context 'when used with symbol keys' do
+      before { call }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/impersonate', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      end
+    end
+
+    context 'when request is not successful' do
+      let(:response_body) { {}.to_json }
+
+      it { expect { call }.to raise_error(Castle::ImpersonationFailed) }
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe Castle::API::Track do
+  subject(:call) { described_class.call(options) }
+
+  let(:ip) { '1.2.3.4' }
+  let(:cookie_id) { 'abcd' }
+  let(:ua) { 'Chrome' }
+  let(:env) do
+    Rack::MockRequest.env_for(
+      '/',
+      'HTTP_USER_AGENT' => ua,
+      'HTTP_X_FORWARDED_FOR' => ip,
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+    )
+  end
+  let(:request) { Rack::Request.new(env) }
+  let(:context) { Castle::Context::Prepare.call(request) }
+  let(:time_now) { Time.now }
+  let(:time_auto) { time_now.utc.iso8601(3) }
+  let(:time_user) { (Time.now - 10_000).utc.iso8601(3) }
+  let(:response_body) { {}.to_json }
+
+  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: {})
+  end
+
+  after { Timecop.return }
+
+  describe 'track' do
+    let(:request_body) do
+      { event: '$login.succeeded', context: context, user_id: '1234',
+        sent_at: time_auto }
+    end
+
+    before { call }
+
+    context 'when used with symbol keys' do
+      let(:options) { { event: '$login.succeeded', user_id: '1234', context: context } }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/track', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      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(:request_body) do
+          { event: '$login.succeeded', user_id: '1234', context: context,
+            timestamp: time_user, sent_at: time_auto }
+        end
+
+        it do
+          assert_requested :post, 'https://api.castle.io/v1/track', times: 1 do |req|
+            JSON.parse(req.body) == JSON.parse(request_body.to_json)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/castle/api_spec.rb

@@ -3,7 +3,7 @@
 describe Castle::API do
   subject(:call) { described_class.call(command) }
 
-  let(:command) { Castle::Commands::Track.new({}).build(event: '$login.succeeded') }
+  let(:command) { Castle::Commands::Track.build(event: '$login.succeeded') }
 
   context 'when request timeouts' do
     before { stub_request(:any, /api.castle.io/).to_timeout }
@@ -34,4 +34,19 @@ describe Castle::API do
       end.to raise_error(Castle::ConfigurationError)
     end
   end
+
+  context 'when custom config' do
+    let(:config) { Castle::Configuration.new }
+
+    before do
+      config.api_secret = 'test'
+      stub_request(:any, /api.castle.io/)
+    end
+
+    it do
+      expect do
+        call
+      end.not_to raise_error
+    end
+  end
 end

data/spec/lib/castle/{extractors/client_id_spec.rb → client_id/extract_spec.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-describe Castle::Extractors::ClientId do
+describe Castle::ClientId::Extract do
   subject(:extractor) { described_class.new(formatted_headers, cookies) }
 
-  let(:formatted_headers) { Castle::HeadersFilter.new(request).call }
+  let(:formatted_headers) { Castle::Headers::Filter.new(request).call }
   let(:client_id_cookie) { 'abcd' }
   let(:client_id_header) { 'abcde' }
   let(:cookies) { request.cookies }

data/spec/lib/castle/client_spec.rb

@@ -14,11 +14,11 @@ describe Castle::Client do
   end
   let(:request) { Rack::Request.new(env) }
   let(:client) { described_class.from_request(request) }
-  let(:request_to_context) { described_class.to_context(request) }
+  let(:request_to_context) { Castle::Context::Prepare.call(request) }
   let(:client_with_user_timestamp) do
-    described_class.new(request_to_context, timestamp: time_user)
+    described_class.new(context: request_to_context, timestamp: time_user)
   end
-  let(:client_with_no_timestamp) { described_class.new(request_to_context) }
+  let(:client_with_no_timestamp) { described_class.new(context: request_to_context) }
 
   let(:headers) do
     {
@@ -29,7 +29,6 @@ describe Castle::Client do
     {
       client_id: 'abcd',
       active: true,
-      origin: 'web',
       user_agent: ua,
       headers: headers,
       ip: ip,
@@ -54,31 +53,44 @@ describe Castle::Client do
 
   describe 'parses the request' do
     before do
-      allow(Castle::API).to receive(:request).and_call_original
+      allow(Castle::API).to receive(:send_request).and_call_original
     end
 
     it do
       client.authenticate(event: '$login.succeeded', user_id: '1234')
-      expect(Castle::API).to have_received(:request)
+      expect(Castle::API).to have_received(:send_request)
     end
   end
 
-  describe 'to_context' do
-    it do
-      expect(described_class.to_context(request)).to eql(context)
+  describe 'end impersonation' do
+    let(:impersonator) { 'test@castle.io' }
+    let(:request_body) do
+      { user_id: '1234', timestamp: time_auto, sent_at: time_auto,
+        properties: { impersonator: impersonator }, context: context }
     end
-  end
+    let(:response_body) { { success: true }.to_json }
+    let(:options) { { user_id: '1234', properties: { impersonator: impersonator } } }
 
-  describe 'to_options' do
-    let(:options) { { user_id: '1234', user_traits: { name: 'Jo' } } }
-    let(:result) { { user_id: '1234', user_traits: { name: 'Jo' }, timestamp: time_auto } }
+    context 'when used with symbol keys' do
+      before { client.end_impersonation(options) }
 
-    it do
-      expect(described_class.to_options(options)).to eql(result)
+      it do
+        assert_requested :delete, 'https://api.castle.io/v1/impersonate', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      end
+    end
+
+    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
     end
   end
 
-  describe 'impersonate' do
+  describe 'start impersonation' do
     let(:impersonator) { 'test@castle.io' }
     let(:request_body) do
       { user_id: '1234', timestamp: time_auto, sent_at: time_auto,
@@ -88,7 +100,7 @@ describe Castle::Client do
     let(:options) { { user_id: '1234', properties: { impersonator: impersonator } } }
 
     context 'when used with symbol keys' do
-      before { client.impersonate(options) }
+      before { client.start_impersonation(options) }
 
       it do
         assert_requested :post, 'https://api.castle.io/v1/impersonate', times: 1 do |req|
@@ -100,7 +112,9 @@ describe Castle::Client do
     context 'when request is not successful' do
       let(:response_body) { {}.to_json }
 
-      it { expect { client.impersonate(options) }.to raise_error(Castle::ImpersonationFailed) }
+      it do
+        expect { client.start_impersonation(options) }.to raise_error(Castle::ImpersonationFailed)
+      end
     end
   end
 
@@ -241,7 +255,7 @@ describe Castle::Client do
       end
 
       it { assert_not_requested :post, 'https://api.castle.io/v1/authenticate' }
-      it { expect(request_response[:action]).to be_eql('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[:failover]).to be true }
       it { expect(request_response[:failover_reason]).to be_eql('Castle is set to do not track.') }
@@ -249,7 +263,9 @@ describe Castle::Client do
 
     context 'when request with fail' do
       before do
-        allow(Castle::API).to receive(:request).and_raise(Castle::RequestError.new(Timeout::Error))
+        allow(Castle::API).to receive(:send_request).and_raise(
+          Castle::RequestError.new(Timeout::Error)
+        )
       end
 
       context 'with request error and throw strategy' do
@@ -268,7 +284,9 @@ describe Castle::Client do
     end
 
     context 'when request is internal server error' do
-      before { allow(Castle::API).to receive(:request).and_raise(Castle::InternalServerError) }
+      before do
+        allow(Castle::API).to receive(:send_request).and_raise(Castle::InternalServerError)
+      end
 
       describe 'throw strategy' do
         before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+describe Castle::Commands::ApproveDevice do
+  subject(:instance) { described_class }
+
+  let(:context) { {} }
+  let(:device_token) { '1234' }
+
+  describe '.build' do
+    subject(:command) { instance.build(device_token: device_token) }
+
+    context 'without device_token' do
+      let(:device_token) { '' }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    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.data).to be_nil }
+    end
+  end
+end