castle-rb 5.0.0 → 7.1.1

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::API::Session do
-  describe '.call' do
-    context 'when ssl false' do
-      let(:localhost) { 'localhost' }
-      let(:port) { 3002 }
-
-      before do
-        Castle.config.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 do |http|
-            http.request(request)
-          end
-        end
-
-        it do
-          expect(Net::HTTP)
-            .to have_received(:new)
-            .with(localhost, port)
-        end
-
-        it do
-          expect(a_request(:get, 'localhost:3002/test'))
-            .to have_been_made.once
-        end
-      end
-
-      context 'without block' do
-        before { described_class.call }
-
-        it do
-          expect(a_request(:get, 'localhost:3002/test'))
-            .not_to have_been_made
-        end
-      end
-    end
-
-    context 'when ssl true' do
-      let(:localhost) { 'localhost' }
-      let(:port) { 443 }
-
-      before do
-        Castle.config.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 do |http|
-            http.request(request)
-          end
-        end
-
-        it do
-          expect(Net::HTTP)
-            .to have_received(:new)
-            .with(localhost, port)
-        end
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Commands::Identify do
-  subject(:instance) { described_class.new(context) }
-
-  let(:context) { { test: { test1: '1' } } }
-  let(:default_payload) { { user_id: '1234', sent_at: time_auto } }
-
-  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 simple merger' do
-      let(:payload) { default_payload.merge(context: { test: { test2: '1' } }) }
-      let(:command_data) do
-        default_payload.merge(context: { test: { test1: '1', test2: '1' } })
-      end
-
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('identify') }
-      it { expect(command.data).to be_eql(command_data) }
-    end
-
-    context 'with user_traits' do
-      let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
-      let(:command_data) do
-        default_payload.merge(user_traits: { test: '1' }, context: context)
-      end
-
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('identify') }
-      it { expect(command.data).to be_eql(command_data) }
-    end
-
-    context 'when active true' do
-      let(:payload) { default_payload.merge(context: { active: true }) }
-      let(:command_data) do
-        default_payload.merge(context: context.merge(active: true))
-      end
-
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('identify') }
-      it { expect(command.data).to be_eql(command_data) }
-    end
-
-    context 'when active false' do
-      let(:payload) { default_payload.merge(context: { active: false }) }
-      let(:command_data) do
-        default_payload.merge(context: context.merge(active: false))
-      end
-
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('identify') }
-      it { expect(command.data).to be_eql(command_data) }
-    end
-
-    context 'when active string' do
-      let(:payload) { default_payload.merge(context: { active: 'string' }) }
-      let(:command_data) { default_payload.merge(context: context) }
-
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('identify') }
-      it { expect(command.data).to be_eql(command_data) }
-    end
-  end
-
-  describe '#validate!' do
-    subject(:validate!) { instance.build(payload) }
-
-    context 'with user_id not present' do
-      let(:payload) { {} }
-
-      it { expect { validate! }.not_to raise_error }
-    end
-
-    context 'with user_id present' do
-      let(:payload) { { user_id: '1234' } }
-
-      it { expect { validate! }.not_to raise_error }
-    end
-  end
-end

data/spec/lib/castle/events_spec.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Events do
-  it { expect(described_class::LOGIN_SUCCEEDED).to eq('$login.succeeded') }
-end

data/spec/lib/castle/headers_filter_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::HeadersFilter do
-  subject(:headers) { described_class.new(request).call }
-
-  let(:env) do
-    result = Rack::MockRequest.env_for(
-      '/',
-      'Action-Dispatch.request.content-Type' => 'application/json',
-      'HTTP_AUTHORIZATION' => 'Basic 123456',
-      'HTTP_COOKIE' => '__cid=abcd;other=efgh',
-      'HTTP_ACCEPT' => 'application/json',
-      'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-      'HTTP_USER_AGENT' => 'Mozilla 1234',
-      'TEST' => '1',
-      'REMOTE_ADDR' => '1.2.3.4'
-    )
-    result[:HTTP_OK] = 'OK'
-    result
-  end
-  let(:filtered) do
-    {
-      'Accept' => 'application/json',
-      'Authorization' => 'Basic 123456',
-      'Cookie' => '__cid=abcd;other=efgh',
-      'Content-Length' => '0',
-      'Ok' => 'OK',
-      'User-Agent' => 'Mozilla 1234',
-      'Remote-Addr' => '1.2.3.4',
-      'X-Forwarded-For' => '1.2.3.4'
-    }
-  end
-  let(:request) { Rack::Request.new(env) }
-
-  context 'with list of header' do
-    it { expect(headers).to eq(filtered) }
-  end
-end

data/spec/lib/castle/headers_formatter_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::HeadersFormatter do
-  subject(:formatter) { described_class }
-
-  it 'removes HTTP_' do
-    expect(formatter.call('HTTP_X_TEST')).to be_eql('X-Test')
-  end
-
-  it 'capitalizes header' do
-    expect(formatter.call('X_TEST')).to be_eql('X-Test')
-  end
-
-  it 'ignores letter case and -_ divider' do
-    expect(formatter.call('http-X_teST')).to be_eql('X-Test')
-  end
-
-  it 'does not remove http if there is no _- char' do
-    expect(formatter.call('httpX_teST')).to be_eql('Httpx-Test')
-  end
-
-  it 'capitalizes' do
-    expect(formatter.call(:clearance)).to be_eql('Clearance')
-  end
-end

data/spec/lib/castle/review_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::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) }
-
-    let(:review_id) { '1234' }
-
-    before { retrieve }
-
-    it { assert_requested :get, "https://api.castle.io/v1/reviews/#{review_id}", times: 1 }
-  end
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Utils::Merger do
-  subject(:merger) { 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(merger.call(first, second)).to be_eql(result) }
-  end
-end

data/spec/lib/castle/utils_spec.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Utils 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 '#deep_symbolize_keys' do
-    subject { described_class.deep_symbolize_keys(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
-
-  describe '#cloner' do
-    subject { described_class.deep_symbolize_keys!(Castle::Utils::Cloner.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
-
-  describe '::replace_invalid_characters' do
-    subject { described_class.replace_invalid_characters(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(['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: ['inv�lid', 'inv�lid']) }
-      end
-    end
-  end
-end