castle-rb 8.1.0 → 9.0.0

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Commands::Log do
-  subject(:instance) { described_class }
-
-  let(:context) { { test: { test1: '1' } } }
-  let(:user) { { id: '1234', email: 'foobar@mail.com' } }
-  let(:default_payload) do
-    {
-      request_token: '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
-      event: '$login',
-      status: '$failed',
-      user: user,
-      sent_at: time_auto,
-      context: context
-    }
-  end
-  let(:time_now) { Time.now }
-  let(:time_auto) { time_now.utc.iso8601(3) }
-
-  before { Timecop.freeze(time_now) }
-
-  after { Timecop.return }
-
-  describe '.build' do
-    subject(:command) { instance.build(payload) }
-
-    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(: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(: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(: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(: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(: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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Commands::ReportDevice 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}/report") }
-      it { expect(command.data).to be_nil }
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Commands::Risk do
-  subject(:instance) { described_class }
-
-  let(:context) { { test: { test1: '1' } } }
-  let(:user) { { id: '1234', email: 'foobar@mail.com' } }
-  let(:default_payload) do
-    {
-      request_token: '7e51335b-f4bc-4bc7-875d-b713fb61eb23-bf021a3022a1a302',
-      event: '$login',
-      status: '$succeeded',
-      user: user,
-      sent_at: time_auto,
-      context: context
-    }
-  end
-  let(:time_now) { Time.now }
-  let(:time_auto) { time_now.utc.iso8601(3) }
-
-  before { Timecop.freeze(time_now) }
-
-  after { Timecop.return }
-
-  describe '.build' do
-    subject(:command) { instance.build(payload) }
-
-    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(: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(: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(: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(: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(: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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Commands::StartImpersonation do
-  subject(:instance) { described_class }
-
-  let(:context) { { user_agent: 'test', ip: '127.0.0.1', client_id: 'test' } }
-  let(:impersonator) { 'test@castle.io' }
-  let(:default_payload) { { user_id: '1234', sent_at: time_auto, context: context } }
-
-  let(:time_now) { Time.now }
-  let(:time_auto) { time_now.utc.iso8601(3) }
-
-  before { Timecop.freeze(time_now) }
-
-  after { Timecop.return }
-
-  describe '.build' do
-    subject(:command) { instance.build(payload) }
-
-    context 'with impersonator' do
-      let(:payload) { default_payload.merge(properties: { impersonator: impersonator }) }
-      let(:command_data) { default_payload.merge(properties: { impersonator: impersonator }, context: context) }
-
-      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(: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(: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(:post) }
-      it { expect(command.path).to eql('impersonate') }
-      it { expect(command.data).to eql(command_data) }
-    end
-  end
-
-  describe '#validate!' do
-    subject(:validate!) { instance.build(payload) }
-
-    context 'when user_id not present' do
-      let(:payload) { {} }
-
-      it { expect { validate! }.to raise_error(Castle::InvalidParametersError, 'user_id is missing or empty') }
-    end
-
-    context 'when user_id present' do
-      let(:payload) { { user_id: '1234', context: context } }
-
-      it { expect { validate! }.not_to raise_error }
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Commands::Track do
-  subject(:instance) { described_class }
-
-  let(:context) { { test: { test1: '1' } } }
-  let(:default_payload) { { event: '$login.track', sent_at: time_auto, context: context } }
-
-  let(:time_now) { Time.now }
-  let(:time_auto) { time_now.utc.iso8601(3) }
-
-  before { Timecop.freeze(time_now) }
-
-  after { Timecop.return }
-
-  describe '#build' do
-    subject(:command) { instance.build(payload) }
-
-    context 'with user_id' 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(: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(: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(: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(: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(: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(:post) }
-      it { expect(command.path).to eql('track') }
-      it { expect(command.data).to eql(command_data) }
-    end
-  end
-
-  describe '#validate!' do
-    subject(:validate!) { instance.build(payload) }
-
-    context 'when event not present' do
-      let(:payload) { {} }
-
-      it { expect { validate! }.to raise_error(Castle::InvalidParametersError, 'event is missing or empty') }
-    end
-
-    context 'when event present' do
-      let(:payload) { { event: '$login.track' } }
-
-      it { expect { validate! }.not_to raise_error }
-    end
-  end
-end

data/spec/lib/castle/configuration_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Configuration do
-  subject(:config) { described_class.new }
-
-  it_behaves_like 'configuration_host'
-  it_behaves_like 'configuration_request_timeout'
-  it_behaves_like 'configuration_allowlisted'
-  it_behaves_like 'configuration_denylisted'
-  it_behaves_like 'configuration_failover_strategy'
-  it_behaves_like 'configuration_api_secret'
-
-  it { expect(config.api_secret).to eql('') }
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Context::GetDefault do
-  subject { described_class.new(request, nil) }
-
-  let(:ip) { '1.2.3.4' }
-  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",
-      'HTTP_CONTENT_LENGTH' => '0'
-    )
-  end
-  let(:request) { Rack::Request.new(env) }
-  let(:default_context) { subject.call }
-  let(:version) { '2.2.0' }
-  let(:result_headers) do
-    {
-      'X-Forwarded-For' => '1.2.3.4',
-      'Accept-Language' => 'en',
-      'User-Agent' => 'test',
-      'Content-Length' => '0',
-      'Cookie' => true
-    }
-  end
-
-  before { stub_const('Castle::VERSION', version) }
-
-  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/merge_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Context::Merge do
-  let(:first) { { test: { test1: { c: '4' } } } }
-
-  describe '#call' do
-    subject { described_class.call(first, second) }
-
-    let(:result) { { test: { test1: { c: '4', d: '5' } } } }
-
-    context 'with symbol keys' do
-      let(:second) { { test: { test1: { d: '5' } } } }
-
-      it { is_expected.to eq(result) }
-    end
-
-    context 'with string keys' do
-      let(:second) { { 'test' => { 'test1' => { 'd' => '5' } } } }
-
-      it { is_expected.to eq(result) }
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Context::Prepare 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(:context) do
-    {
-      client_id: 'abcd',
-      active: true,
-      user_agent: ua,
-      headers: headers,
-      ip: ip,
-      library: {
-        name: 'castle-rb',
-        version: '6.0.0'
-      }
-    }
-  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') }
-
-  describe '#call' do
-    subject(:generated) { described_class.call(request) }
-
-    context 'when active true' do
-      it { is_expected.to eql(context) }
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Context::Sanitize do
-  let(:paylod) { { test: 'test' } }
-
-  describe '#call' do
-    subject { described_class.call(context) }
-
-    context 'when active true' do
-      let(:context) { paylod.merge(active: true) }
-
-      it { is_expected.to eql(context) }
-    end
-
-    context 'when active false' do
-      let(:context) { paylod.merge(active: false) }
-
-      it { is_expected.to eql(context) }
-    end
-
-    context 'when active string' do
-      let(:context) { paylod.merge(active: 'uknown') }
-
-      it { is_expected.to eql(paylod) }
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Core::GetConnection do
-  describe '.call' do
-    subject(:class_call) { described_class.call }
-
-    context 'when ssl false' do
-      let(:localhost) { 'localhost' }
-      let(:port) { 3002 }
-      let(:api_url) { '/test' }
-
-      before do
-        Castle.config.base_url = 'http://localhost:3002'
-
-        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)
-      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 { Castle.config.base_url = 'https://localhost' }
-
-      context 'with block' do
-        let(:api_url) { '/test' }
-        let(:request) { Net::HTTP::Get.new(api_url) }
-
-        before { allow(Net::HTTP).to receive(:new).with(localhost, port).and_call_original }
-
-        it { expect(class_call).to be_an_instance_of(Net::HTTP) }
-      end
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Core::ProcessResponse do
-  describe '#call' do
-    subject(:call) { described_class.call(response) }
-
-    context 'when success' do
-      let(:response) { OpenStruct.new(body: '{"user":1}', code: 200) }
-
-      it { expect(call).to eql(user: 1) }
-    end
-
-    describe 'authenticate' do
-      context 'when allow without any additional props' do
-        let(:response) { OpenStruct.new(body: '{"action":"allow","user_id":"12345"}', code: 200) }
-
-        it { expect(call).to eql({ action: 'allow', user_id: '12345' }) }
-      end
-
-      context 'when allow with additional props' do
-        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) { 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
-
-      context 'when deny with risk policy' do
-        let(:body) do
-          '{"action":"deny","user_id":"1","device_token":"abc",
-          "risk_policy":{"id":"123","revision_id":"abc","name":"def","type":"bot"}}'
-        end
-        let(:response) { OpenStruct.new({ body: body, code: 200 }) }
-
-        let(:result) do
-          {
-            action: 'deny',
-            user_id: '1',
-            device_token: 'abc',
-            risk_policy: {
-              id: '123',
-              revision_id: 'abc',
-              name: 'def',
-              type: 'bot'
-            }
-          }
-        end
-
-        it { expect(call).to eql(result) }
-      end
-    end
-
-    context 'when response empty' do
-      let(:response) { OpenStruct.new(body: '', code: 200) }
-
-      it { expect(call).to eql({}) }
-    end
-
-    context 'when response nil' do
-      let(:response) { OpenStruct.new(code: 200) }
-
-      it { expect(call).to eql({}) }
-    end
-
-    context 'when json is malformed' do
-      let(:response) { OpenStruct.new(body: '{a', code: 200) }
-
-      it { expect { call }.to raise_error(Castle::ApiError) }
-    end
-  end
-
-  describe '#verify!' do
-    subject(:verify!) { described_class.verify!(response) }
-
-    context 'without error when response is 2xx' do
-      let(:response) { OpenStruct.new(code: 200) }
-
-      it { expect { verify! }.not_to raise_error }
-    end
-
-    shared_examples 'response_failed' do |code, error|
-      let(:response) { OpenStruct.new(code: code) }
-
-      it "fail when response is #{code}" do
-        expect { verify! }.to raise_error(error)
-      end
-    end
-
-    it_behaves_like 'response_failed', '400', Castle::BadRequestError
-    it_behaves_like 'response_failed', '401', Castle::UnauthorizedError
-    it_behaves_like 'response_failed', '403', Castle::ForbiddenError
-    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
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Castle::Core::ProcessWebhook do
-  describe '#call' do
-    subject(:call) { described_class.call(webhook) }
-
-    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: '',
-          trigger: '$login.succeeded',
-          context: {
-          },
-          location: {
-          },
-          user_agent: {
-          }
-        },
-        user_traits: {
-        },
-        properties: {
-        },
-        policy: {
-        }
-      }.to_json
-    end
-
-    let(:webhook) { OpenStruct.new(body: StringIO.new(webhook_body)) }
-
-    context 'when success' do
-      it { expect(call).to eql(webhook_body) }
-    end
-
-    context 'when webhook empty' do
-      let(:webhook) { OpenStruct.new(body: StringIO.new('')) }
-
-      it { expect { call }.to raise_error(Castle::ApiError, 'Invalid webhook from Castle API') }
-    end
-
-    context 'when webhook nil' do
-      let(:webhook) { OpenStruct.new(body: StringIO.new) }
-
-      it { expect { call }.to raise_error(Castle::ApiError, 'Invalid webhook from Castle API') }
-    end
-  end
-end