castle-rb 8.0.0 → 9.0.0

data/spec/lib/castle/logger_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# tmp logger for testing
-class TmpLogger
-  # @param _message [String]
-  def info(_message)
-  end
-end
-
-describe Castle::Logger do
-  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 { allow(integration_logger).to receive(:info).and_call_original }
-
-  describe '.call' do
-    context 'without logger' do
-      before do
-        Castle.config.logger = nil
-        log
-      end
-
-      it { expect(integration_logger).not_to have_received(:info) }
-    end
-
-    context 'with logger' do
-      before do
-        Castle.config.logger = integration_logger
-        log
-      end
-
-      it { expect(integration_logger).to have_received(:info).with(logger_message) }
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Payload::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(: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_formatted) { time_now.utc.iso8601(3) }
-  let(:payload_options) { { user_id: '1234', user_traits: { name: 'Jo' } } }
-  let(:result) { { user_id: '1234', user_traits: { name: 'Jo' }, timestamp: time_formatted, context: context } }
-
-  before do
-    Timecop.freeze(time_now)
-    stub_const('Castle::VERSION', '2.2.0')
-  end
-
-  after { Timecop.return }
-
-  describe '#call' do
-    subject(:generated) { described_class.call(payload_options, request) }
-
-    context 'when active true' do
-      it { is_expected.to eql(result) }
-    end
-  end
-end

data/spec/lib/castle/secure_mode_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::SecureMode do
-  it 'has signature' do
-    expect(described_class.signature('test')).to eql('0329a06b62cd16b33eb6792be8c60b158d89a2ee3a876fce9a881ebb488c0914')
-  end
-end

data/spec/lib/castle/session_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Session do
-  describe '.call' do
-    context 'when ssl false' do
-      let(:localhost) { 'localhost' }
-      let(:port) { 3002 }
-
-      before do
-        Castle.config.base_url = 'http://localhost:3002'
-        stub_request(:get, 'localhost:3002/test').to_return(status: 200, body: '{}', headers: {})
-      end
-
-      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
-
-          described_class.call { |http| http.request(request) }
-        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 { expect(a_request(:get, 'localhost:3002/test')).not_to have_been_made }
-      end
-    end
-
-    context 'when ssl true' do
-      let(:localhost) { 'localhost' }
-      let(:port) { 443 }
-
-      before do
-        Castle.config.base_url = 'https://localhost'
-        stub_request(:get, 'https://localhost/test').to_return(status: 200, body: '{}', headers: {})
-      end
-
-      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
-
-          allow(Net::HTTP).to receive(:start)
-
-          described_class.call { |http| http.request(request) }
-        end
-
-        it { expect(Net::HTTP).to have_received(:new).with(localhost, port) }
-      end
-    end
-  end
-end

data/spec/lib/castle/singleton_configuration_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::SingletonConfiguration do
-  subject(:config) { described_class.instance }
-
-  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('secret') }
-end

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Utils::CleanInvalidChars do
-  describe '::call' do
-    subject { described_class.call(input) }
-
-    context 'when input is a string' do
-      let(:input) { '1234' }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is an array' do
-      let(:input) { [1, 2, 3, '4'] }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is a hash' do
-      let(:input) { { user_id: 1 } }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is nil' do
-      let(:input) { nil }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is a nested hash' do
-      let(:input) { { user: { id: 1 } } }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'with invalid UTF-8 characters' do
-      context 'when input is a hash' do
-        let(:input) { { user_id: "inv\xC4lid" } }
-
-        it { is_expected.to eq(user_id: 'inv�lid') }
-      end
-
-      context 'when input is a nested hash' do
-        let(:input) { { user: { id: "inv\xC4lid" } } }
-
-        it { is_expected.to eq(user: { id: 'inv�lid' }) }
-      end
-
-      context 'when input is an array of hashes' do
-        let(:input) { [{ user: "inv\xC4lid" }] * 2 }
-
-        it { is_expected.to eq([{ user: 'inv�lid' }, { user: 'inv�lid' }]) }
-      end
-
-      context 'when input is an array' do
-        let(:input) { ["inv\xC4lid"] * 2 }
-
-        it { is_expected.to eq(%w[inv�lid inv�lid]) }
-      end
-
-      context 'when input is a hash with array in key' do
-        let(:input) { { items: ["inv\xC4lid"] * 2 } }
-
-        it { is_expected.to eq(items: %w[inv�lid inv�lid]) }
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Utils::Clone do
-  subject(:clone) { described_class }
-
-  describe 'call' do
-    let(:nested) { { c: '3' } }
-    let(:first) { { test: { test1: { c: '4' }, test2: nested, a: '1', b: '2' } } }
-    let(:result) { { test: { test1: { c: '4' }, test2: { c: '3' }, a: '1', b: '2' } } }
-    let(:cloned) { clone.call(first) }
-
-    before { cloned }
-
-    it do
-      nested[:test] = 'sample'
-      expect(cloned).to eql(result)
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Utils::DeepSymbolizeKeys do
-  let(:nested_strings) { { 'a' => { 'b' => { 'c' => 3 } } } }
-  let(:nested_symbols) { { a: { b: { c: 3 } } } }
-  let(:nested_mixed) { { 'a' => { b: { 'c' => 3 } } } }
-  let(:string_array_of_hashes) { { 'a' => [{ 'b' => 2 }, { 'c' => 3 }, 4] } }
-  let(:symbol_array_of_hashes) { { a: [{ b: 2 }, { c: 3 }, 4] } }
-  let(:mixed_array_of_hashes) { { a: [{ b: 2 }, { 'c' => 3 }, 4] } }
-
-  describe '::call' do
-    subject { described_class.call(hash) }
-
-    context 'when nested_symbols' do
-      let(:hash) { nested_symbols }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when nested_strings' do
-      let(:hash) { nested_strings }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when nested_mixed' do
-      let(:hash) { nested_mixed }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when string_array_of_hashes' do
-      let(:hash) { string_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-
-    context 'when symbol_array_of_hashes' do
-      let(:hash) { symbol_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-
-    context 'when mixed_array_of_hashes' do
-      let(:hash) { mixed_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-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
-
-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
-
-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
-
-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
-
-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
-
-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
-
-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,24 +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
-end