castle-rb 8.1.0 → 9.0.0

data/spec/lib/castle/utils/get_timestamp_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Utils::GetTimestamp do
-  subject(:timestamp) { described_class.call }
-
-  let(:time_string) { '2018-01-10T14:14:24.407Z' }
-  let(:time) { Time.parse(time_string) }
-
-  before { Timecop.freeze(time) }
-
-  after { Timecop.return }
-
-  describe '#call' do
-    it { expect(timestamp).to eql(time_string) }
-  end
-end

data/spec/lib/castle/utils/merge_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Utils::Merge do
-  subject(:merge) { described_class }
-
-  describe 'call' do
-    let(:first) { { test: { test1: { c: '4' }, test2: { c: '3' }, a: '1', b: '2' } } }
-    let(:second) { { test2: '2', test: { 'test1' => { d: '5' }, :test2 => '6', :a => nil, :b => '3' } } }
-    let(:result) { { test2: '2', test: { test1: { c: '4', d: '5' }, test2: '6', b: '3' } } }
-
-    it { expect(merge.call(first, second)).to eql(result) }
-  end
-end

data/spec/lib/castle/validators/not_supported_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Validators::NotSupported do
-  describe '#call' do
-    subject(:call) { described_class.call({ first: 1 }, keys) }
-
-    context 'when keys is present' do
-      let(:keys) { %i[first second] }
-
-      it { expect { call }.to raise_error(Castle::InvalidParametersError, 'first is/are not supported') }
-    end
-
-    context 'when key is not present' do
-      let(:keys) { %i[second third] }
-
-      it { expect { call }.not_to raise_error }
-    end
-  end
-end

data/spec/lib/castle/validators/present_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Validators::Present do
-  describe '#call' do
-    subject(:call) { described_class.call({ first: 1, second: '2', invalid: '' }, keys) }
-
-    context 'when keys is not present' do
-      let(:keys) { %i[second third] }
-
-      it { expect { call }.to raise_error(Castle::InvalidParametersError, 'third is missing or empty') }
-    end
-
-    context 'when keys is empty' do
-      let(:keys) { %i[second invalid] }
-
-      it { expect { call }.to raise_error(Castle::InvalidParametersError, 'invalid is missing or empty') }
-    end
-
-    context 'when key is present' do
-      let(:keys) { %i[first second] }
-
-      it { expect { call }.not_to raise_error }
-    end
-  end
-end

data/spec/lib/castle/verdict_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Verdict do
-  subject(:verdict) { described_class }
-
-  it { expect(verdict::ALLOW).to eql('allow') }
-  it { expect(verdict::DENY).to eql('deny') }
-  it { expect(verdict::CHALLENGE).to eql('challenge') }
-end

data/spec/lib/castle/version_spec.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle do
-  it { expect(described_class::VERSION).to match(/\d\.\d\.\d/) }
-end

data/spec/lib/castle/webhooks/verify_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Webhooks::Verify do
-  describe '#call' do
-    subject(:call) { described_class.call(webhook) }
-
-    let(:env) { Rack::MockRequest.env_for('/', 'HTTP_X_CASTLE_SIGNATURE' => signature) }
-
-    let(:webhook) { Rack::Request.new(env) }
-    let(:user_id) { '12345' }
-    let(:webhook_body) do
-      {
-        api_version: 'v1',
-        app_id: '12345',
-        type: '$incident.confirmed',
-        created_at: '2020-12-18T12:55:21.779Z',
-        data: {
-          id: 'test',
-          device_token: 'token',
-          user_id: user_id,
-          trigger: '$login.succeeded',
-          context: {
-          },
-          location: {
-          },
-          user_agent: {
-          }
-        },
-        user_traits: {
-        },
-        properties: {
-        },
-        policy: {
-        }
-      }.to_json
-    end
-
-    context 'when success' do
-      let(:signature) { '3ptx3rUOBnGEqPjMrbcJn2UUfzwTKP54dFyP5uyPY+Y=' }
-
-      before { allow(Castle::Core::ProcessWebhook).to receive(:call).and_return(webhook_body) }
-
-      it { expect { call }.not_to raise_error }
-    end
-
-    context 'when signature is malformed' do
-      let(:signature) { '123' }
-
-      before { allow(Castle::Core::ProcessWebhook).to receive(:call).and_return(webhook_body) }
-
-      it do
-        expect { call }.to raise_error(
-          Castle::WebhookVerificationError,
-          'Signature not matching the expected signature'
-        )
-      end
-    end
-  end
-end

data/spec/lib/castle_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle do
-  subject(:castle) { described_class }
-
-  describe 'config' do
-    it { expect(castle.config).to be_a(Castle::Configuration) }
-  end
-
-  describe 'api_secret setter' do
-    let(:value) { 'new_secret' }
-
-    before { castle.api_secret = value }
-
-    it { expect(castle.config.api_secret).to eql(value) }
-  end
-
-  describe 'configure' do
-    let(:value) { 'new_secret' }
-    let(:timeout) { 60 }
-
-    shared_examples 'config_setup' do
-      it { expect(castle.config.api_secret).to eql(value) }
-      it { expect(castle.config.request_timeout).to eql(timeout) }
-    end
-
-    context 'with block' do
-      before do
-        castle.configure do |config|
-          config.api_secret = value
-          config.request_timeout = timeout
-        end
-      end
-
-      it_behaves_like 'config_setup'
-    end
-
-    context 'with options' do
-      before { castle.configure(request_timeout: timeout, api_secret: value) }
-
-      it_behaves_like 'config_setup'
-    end
-
-    context 'with block and options' do
-      before { castle.configure(request_timeout: timeout) { |config| config.api_secret = value } }
-
-      it_behaves_like 'config_setup'
-    end
-  end
-
-  describe 'configure wrongly' do
-    let(:value) { 'new_secret' }
-
-    it do
-      expect { castle.configure { |config| config.wrong_config = value } }.to raise_error(Castle::ConfigurationError)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'bundler/setup'
-require 'rack'
-require 'webmock/rspec'
-require 'byebug'
-require 'timecop'
-
-require 'coveralls'
-Coveralls.wear!
-
-require 'castle'
-
-WebMock.disable_net_connect!(allow_localhost: true)
-
-Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.before do
-    Castle.config.reset
-    Castle.configure { |cfg| cfg.api_secret = 'secret' }
-  end
-
-  config.disable_monkey_patching!
-end

data/spec/support/shared_examples/action_request.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples_for 'action request' do |action|
-  subject(:request_response) { client.send(action.to_sym, options) }
-
-  let(:options) do
-    { request_token: request_token, event: event, status: status, user: user, context: context, properties: properties }
-  end
-  let(:request_token) { '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302' }
-  let(:event) { '$login' }
-  let(:status) { '$succeeded' }
-  let(:user) { { id: '1234', email: 'foobar@mail.com' } }
-  let(:properties) { {} }
-  let(:request_body) do
-    {
-      request_token: request_token,
-      event: event,
-      status: status,
-      user: user,
-      context: context,
-      properties: properties,
-      timestamp: time_auto,
-      sent_at: time_auto
-    }
-  end
-
-  context 'when used with symbol keys' do
-    it do
-      request_response
-
-      assert_requested :post, "https://api.castle.io/v1/#{action}", 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 }
-
-      before do
-        options[:timestamp] = time_user
-        request_body[:timestamp] = time_user
-
-        request_response
-      end
-
-      it do
-        assert_requested :post, "https://api.castle.io/v1/#{action}", 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 }
-
-      before do
-        request_body[:timestamp] = time_user
-
-        request_response
-      end
-
-      it do
-        assert_requested :post, "https://api.castle.io/v1/#{action}", 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
-    before { request_response }
-
-    it do
-      assert_requested :post, "https://api.castle.io/v1/#{action}", 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/#{action}", 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/#{action}" }
-    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/#{action}" }
-      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/#{action}" }
-      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
-
-  context 'when request is 422' do
-    describe 'throw InvalidParametersError' do
-      let(:response_body) { { type: 'bad_request', message: 'wrong params' }.to_json }
-      let(:response_code) { 422 }
-
-      it { expect { request_response }.to raise_error(Castle::InvalidParametersError, 'wrong params') }
-    end
-
-    describe 'throw InvalidParametersError for legacy endpoints' do
-      let(:response_body) { {}.to_json }
-      let(:response_code) { 422 }
-
-      it { expect { request_response }.to raise_error(Castle::InvalidParametersError) }
-    end
-
-    describe 'throw InvalidRequestTokenError' do
-      let(:response_body) { { type: 'invalid_request_token', message: 'invalid token' }.to_json }
-      let(:response_code) { 422 }
-
-      it { expect { request_response }.to raise_error(Castle::InvalidRequestTokenError, 'invalid token') }
-    end
-  end
-end

data/spec/support/shared_examples/configuration.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'configuration_host' do
-  describe 'host' do
-    context 'with default' do
-      it { expect(config.base_url.host).to eql('api.castle.io') }
-    end
-
-    context 'with setter' do
-      before { config.base_url = 'http://api.castle.dev/v2' }
-
-      it { expect(config.base_url.host).to eql('api.castle.dev') }
-    end
-  end
-end
-
-shared_examples 'configuration_request_timeout' do
-  describe 'request_timeout' do
-    it { expect(config.request_timeout).to be(1000) }
-
-    context 'with setter' do
-      let(:value) { 50.0 }
-
-      before { config.request_timeout = value }
-
-      it { expect(config.request_timeout).to eql(value) }
-    end
-  end
-end
-
-shared_examples 'configuration_allowlisted' do
-  describe 'allowlisted' do
-    it { expect(config.allowlisted.size).to be(0) }
-
-    context 'with setter' do
-      before { config.allowlisted = ['header'] }
-
-      it { expect(config.allowlisted).to eql(['Header']) }
-    end
-  end
-end
-
-shared_examples 'configuration_denylisted' do
-  describe 'denylisted' do
-    it { expect(config.denylisted.size).to be(0) }
-
-    context 'with setter' do
-      before { config.denylisted = ['header'] }
-
-      it { expect(config.denylisted).to eql(['Header']) }
-    end
-  end
-end
-
-shared_examples 'configuration_failover_strategy' do
-  describe 'failover_strategy' do
-    it { expect(config.failover_strategy).to eql(Castle::Failover::Strategy::ALLOW) }
-
-    context 'with setter' do
-      before { config.failover_strategy = Castle::Failover::Strategy::DENY }
-
-      it { expect(config.failover_strategy).to eql(Castle::Failover::Strategy::DENY) }
-    end
-
-    context 'when broken' do
-      it { expect { config.failover_strategy = :unicorn }.to raise_error(Castle::ConfigurationError) }
-    end
-  end
-end
-
-shared_examples 'configuration_api_secret' do
-  describe 'api_secret' do
-    context 'with env' do
-      let(:secret_key_env) { 'secret_key_env' }
-      let(:secret_key) { 'secret_key' }
-
-      before do
-        allow(ENV).to receive(:fetch).with('CASTLE_API_SECRET', '').and_return(secret_key_env)
-        config.reset
-      end
-
-      it { expect(config.api_secret).to eql(secret_key_env) }
-
-      context 'when key is overwritten' do
-        before { config.api_secret = secret_key }
-
-        it { expect(config.api_secret).to eql(secret_key) }
-      end
-    end
-
-    context 'with setter' do
-      let(:value) { 'new_secret' }
-
-      before { config.api_secret = value }
-
-      it { expect(config.api_secret).to eql(value) }
-    end
-  end
-end

data/spec/support/shared_examples/list_items.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'it has list item actions' do
-  describe 'archive_list_item' do
-    it do
-      client.archive_list_item(list_id: '1234', list_item_id: '5678')
-      assert_requested :delete, 'https://api.castle.io/v1/lists/1234/items/5678/archive', times: 1
-    end
-  end
-
-  describe 'count_list_items' do
-    it do
-      client.count_list_items(list_id: '1234', filters: [{ field: 'email', op: 'eq', value: 'test' }])
-      assert_requested :post, 'https://api.castle.io/v1/lists/1234/items/count', times: 1
-    end
-  end
-
-  describe 'create_list_item' do
-    it do
-      client.create_list_item(list_id: '1234', author: { type: 'other', identifier: '1234' }, primary_value: 'email')
-      assert_requested :post, 'https://api.castle.io/v1/lists/1234/items', times: 1
-    end
-  end
-
-  describe 'get_list_item' do
-    it do
-      client.get_list_item(list_id: '1234', list_item_id: '5678')
-      assert_requested :get, 'https://api.castle.io/v1/lists/1234/items/5678', times: 1
-    end
-  end
-
-  describe 'query_list_items' do
-    it do
-      client.query_list_items(list_id: '1234', filters: [{ field: 'email', op: 'eq', value: 'test' }])
-      assert_requested :post, 'https://api.castle.io/v1/lists/1234/items/query', times: 1
-    end
-  end
-
-  describe 'unarchive_list_item' do
-    it do
-      client.unarchive_list_item(list_id: '1234', list_item_id: '5678')
-      assert_requested :put, 'https://api.castle.io/v1/lists/1234/items/5678/unarchive', times: 1
-    end
-  end
-
-  describe 'update_list_item' do
-    it do
-      client.update_list_item(list_id: '1234', list_item_id: '5678', comment: 'updating comment')
-      assert_requested :put, 'https://api.castle.io/v1/lists/1234/items/5678', times: 1
-    end
-  end
-end

data/spec/support/shared_examples/lists.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'it has list actions' do
-  describe 'create_list' do
-    it do
-      client.create_list(name: 'list name', color: '$green', primary_field: 'user.email')
-      assert_requested :post, 'https://api.castle.io/v1/lists', times: 1
-    end
-  end
-
-  describe 'delete_list' do
-    it do
-      client.delete_list(list_id: 'list_id')
-      assert_requested :delete, 'https://api.castle.io/v1/lists/list_id', times: 1
-    end
-  end
-
-  describe 'get_all_lists' do
-    it do
-      client.get_all_lists
-      assert_requested :get, 'https://api.castle.io/v1/lists', times: 1
-    end
-  end
-
-  describe 'get_list' do
-    it do
-      client.get_list(list_id: 'list_id')
-      assert_requested :get, 'https://api.castle.io/v1/lists/list_id', times: 1
-    end
-  end
-
-  describe 'query_lists' do
-    it do
-      client.query_lists(filters: [{ field: 'user.email', op: 'eq', value: 'test' }])
-      assert_requested :post, 'https://api.castle.io/v1/lists/query', times: 1
-    end
-  end
-
-  describe 'update_list' do
-    it do
-      client.update_list(list_id: 'list_id', name: 'list name', color: '$green', primary_field: 'user.email')
-      assert_requested :put, 'https://api.castle.io/v1/lists/list_id', times: 1
-    end
-  end
-end