castle-rb 8.0.0 → 9.0.0

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::API::GetDevice 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 { assert_requested :get, "https://api.castle.io/v1/devices/#{device_token}", times: 1 }
-  end
-end

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

@@ -1,17 +0,0 @@
-# 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/log_spec.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::API::Log do
-  pending
-end

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

@@ -1,17 +0,0 @@
-# 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 { assert_requested :put, "https://api.castle.io/v1/devices/#{device_token}/report", times: 1 }
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::API::Risk do
-  pending
-end

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

@@ -1,59 +0,0 @@
-# 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) { { user_id: '1234', properties: { impersonator: impersonator }, context: context } }
-
-    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

@@ -1,65 +0,0 @@
-# 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) { { event: '$login.succeeded', context: context, user_id: '1234', sent_at: time_auto } }
-
-    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) { { 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 }
-        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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::API do
-  subject(:call) { described_class.call(command) }
-
-  let(:command) { Castle::Commands::Track.build(event: '$login.succeeded') }
-
-  context 'when request timeouts' do
-    before { stub_request(:any, /api.castle.io/).to_timeout }
-
-    it { expect { call }.to raise_error(Castle::RequestError) }
-  end
-
-  context 'when non-OK response code' do
-    before { stub_request(:any, /api.castle.io/).to_return(status: 400) }
-
-    it { expect { call }.to raise_error(Castle::BadRequestError) }
-  end
-
-  context 'when no api_secret' do
-    before { allow(Castle.config).to receive(:api_secret).and_return('') }
-
-    it { expect { call }.to raise_error(Castle::ConfigurationError) }
-  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 { expect { call }.not_to raise_error }
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::ClientId::Extract do
-  subject(:extractor) { described_class.new(formatted_headers, cookies) }
-
-  let(:formatted_headers) { Castle::Headers::Filter.new(request).call }
-  let(:client_id_cookie) { 'abcd' }
-  let(:client_id_header) { 'abcde' }
-  let(:cookies) { request.cookies }
-  let(:request) { Rack::Request.new(env) }
-  let(:env) { Rack::MockRequest.env_for('/', headers) }
-
-  context 'with client_id' do
-    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) { { '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)
-    end
-  end
-
-  context 'when cookies undefined' do
-    let(:cookies) { nil }
-    let(:headers) { {} }
-
-    it { expect(extractor.call).to eql('') }
-  end
-
-  context 'with X-Castle-Client-Id header and cookies client' do
-    let(:headers) do
-      {
-        'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-        'HTTP_X_CASTLE_CLIENT_ID' => client_id_header,
-        'HTTP_COOKIE' => "__cid=#{client_id_cookie};other=efgh"
-      }
-    end
-
-    it 'appends the client_id' do
-      expect(extractor.call).to eql(client_id_header)
-    end
-  end
-end

data/spec/lib/castle/client_spec.rb

@@ -1,337 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Client do
-  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",
-      '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) { described_class.new(context: request_to_context, timestamp: time_user) }
-  let(:client_with_no_timestamp) { described_class.new(context: request_to_context) }
-
-  let(:headers) { { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, Cookie: true } }
-  let(:context) do
-    {
-      client_id: 'abcd',
-      active: true,
-      user_agent: ua,
-      headers: headers,
-      ip: ip,
-      library: {
-        name: 'castle-rb',
-        version: '2.2.0'
-      }
-    }
-  end
-
-  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 }
-  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_response
-  end
-
-  after { Timecop.return }
-
-  describe 'parses the request' do
-    before { allow(Castle::API).to receive(:send_request).and_call_original }
-
-    it do
-      client.authenticate(event: '$login.succeeded', user_id: '1234')
-      expect(Castle::API).to have_received(:send_request)
-    end
-  end
-
-  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
-    let(:response_body) { { success: true }.to_json }
-    let(:options) { { user_id: '1234', properties: { impersonator: impersonator } } }
-
-    context 'when used with symbol keys' do
-      before { client.end_impersonation(options) }
-
-      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 { expect { client.end_impersonation(options) }.to raise_error(Castle::ImpersonationFailed) }
-    end
-  end
-
-  describe 'start 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
-    let(:response_body) { { success: true }.to_json }
-    let(:options) { { user_id: '1234', properties: { impersonator: impersonator } } }
-
-    context 'when used with symbol keys' do
-      before { client.start_impersonation(options) }
-
-      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 { client.start_impersonation(options) }.to raise_error(Castle::ImpersonationFailed) }
-    end
-  end
-
-  describe 'authenticate' 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 }
-    end
-
-    context 'when used with symbol keys' do
-      before { request_response }
-
-      it do
-        assert_requested :post, 'https://api.castle.io/v1/authenticate', 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(: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 }
-        end
-
-        it do
-          assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
-            JSON.parse(req.body) == JSON.parse(request_body.to_json)
-          end
-        end
-      end
-
-      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 }
-        end
-
-        it do
-          assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
-            JSON.parse(req.body) == JSON.parse(request_body.to_json)
-          end
-        end
-      end
-    end
-
-    context 'when used with string keys' do
-      let(:options) { { 'event' => '$login.succeeded', 'user_id' => '1234' } }
-
-      before { request_response }
-
-      it do
-        assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
-          JSON.parse(req.body) == JSON.parse(request_body.to_json)
-        end
-      end
-    end
-
-    context 'when tracking enabled' do
-      before { request_response }
-
-      it do
-        assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
-          JSON.parse(req.body) == JSON.parse(request_body.to_json)
-        end
-      end
-
-      it { expect(request_response[:failover]).to be false }
-      it { expect(request_response[:failover_reason]).to be_nil }
-    end
-
-    context 'when tracking disabled' do
-      before do
-        client.disable_tracking
-        request_response
-      end
-
-      it { assert_not_requested :post, 'https://api.castle.io/v1/authenticate' }
-      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 eql('Castle is set to do not track.') }
-    end
-
-    context 'when request with fail' do
-      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) }
-
-        it { expect { request_response }.to raise_error(Castle::RequestError) }
-      end
-
-      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 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 eql('Castle::RequestError') }
-      end
-    end
-
-    context 'when request is internal server error' do
-      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) }
-
-        it { expect { request_response }.to raise_error(Castle::InternalServerError) }
-      end
-
-      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 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 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 }
-    end
-
-    before { client.track(options) }
-
-    context 'when used with symbol keys' do
-      let(:options) { { event: '$login.succeeded', user_id: '1234' } }
-
-      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(: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 }
-        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
-
-      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 }
-        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
-
-    context 'when used with string keys' do
-      let(:options) { { 'event' => '$login.succeeded', 'user_id' => '1234' } }
-
-      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
-
-  describe 'tracked?' do
-    context 'when off' do
-      before { client.disable_tracking }
-
-      it { expect(client).not_to be_tracked }
-    end
-
-    context 'when on' do
-      before { client.enable_tracking }
-
-      it { expect(client).to be_tracked }
-    end
-  end
-
-  describe 'filter' do
-    it_behaves_like 'action request', :filter
-  end
-
-  describe 'risk' do
-    it_behaves_like 'action request', :risk
-  end
-
-  describe 'log' do
-    it_behaves_like 'action request', :log
-  end
-end

data/spec/lib/castle/command_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Command do
-  subject(:command) { described_class.new('go', { id: '1' }, :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

@@ -1,24 +0,0 @@
-# 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(:put) }
-      it { expect(command.path).to eql("devices/#{device_token}/approve") }
-      it { expect(command.data).to be_nil }
-    end
-  end
-end