castle-rb 3.6.2 → 4.3.0

data/spec/integration/rails/support/all.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+ENV['RAILS_ENV'] = 'test'
+require_relative 'application'
+require_relative 'home_controller'
+require 'rspec/rails'

data/spec/integration/rails/support/application.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'action_controller/railtie'
+
+class TestApp < Rails::Application
+  secrets.secret_token = 'secret_token'
+  secrets.secret_key_base = 'secret_key_base'
+
+  config.logger = Logger.new($stdout)
+  Rails.logger = config.logger
+
+  routes.draw do
+    get '/' => 'home#index'
+  end
+end

data/spec/integration/rails/support/home_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class HomeController < ActionController::Base
+  def index
+    request_context = ::Castle::Client.to_context(request)
+    track_options = ::Castle::Client.to_options(
+      event: '$login.succeeded',
+      user_id: '123',
+      properties: {
+        key: 'value'
+      },
+      user_traits: {
+        key: 'value'
+      }
+    )
+    client = ::Castle::Client.new(request_context)
+    client.track(track_options)
+
+    render inline: 'hello'
+  end
+end

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

@@ -4,56 +4,69 @@ describe Castle::API::Request do
   describe '#call' do
     subject(:call) { described_class.call(command, api_secret, headers) }
 
+    let(:session) { instance_double('Castle::API::Session') }
     let(:http) { instance_double('Net::HTTP') }
-    let(:request_build) { instance_double('Castle::API::Request::Build') }
     let(:command) { Castle::Commands::Track.new({}).build(event: '$login.succeeded') }
     let(:headers) { {} }
     let(:api_secret) { 'secret' }
+    let(:request_build) { {} }
     let(:expected_headers) { { 'Content-Type' => 'application/json' } }
 
     before do
-      allow(described_class).to receive(:http).and_return(http)
-      allow(http).to receive(:request).with(request_build)
-      allow(Castle::API::Request::Build).to receive(:call)
-        .with(command, expected_headers, api_secret)
-        .and_return(request_build)
+      allow(Castle::API::Session).to receive(:instance).and_return(session)
+      allow(session).to receive(:http).and_return(http)
+      allow(http).to receive(:request)
+      allow(described_class).to receive(:build).and_return(request_build)
       call
     end
 
     it do
-      expect(Castle::API::Request::Build).to have_received(:call)
-        .with(command, expected_headers, api_secret)
+      expect(described_class).to have_received(:build).with(command, expected_headers, api_secret)
     end
+
     it { expect(http).to have_received(:request).with(request_build) }
   end
 
-  describe '#http' do
-    subject(:http) { described_class.http }
+  describe '#build' do
+    subject(:build) { described_class.build(command, headers, api_secret) }
 
-    context 'when ssl false' do
-      before do
-        Castle.config.host = 'localhost'
-        Castle.config.port = 3002
-      end
+    let(:headers) { { 'SAMPLE-HEADER' => '1' } }
+    let(:api_secret) { 'secret' }
 
-      after do
-        Castle.config.host = Castle::Configuration::HOST
-        Castle.config.port = Castle::Configuration::PORT
-      end
+    context 'when get' do
+      let(:command) { Castle::Commands::Review.build(review_id) }
+      let(:review_id) { SecureRandom.uuid }
 
-      it { expect(http).to be_instance_of(Net::HTTP) }
-      it { expect(http.address).to eq(Castle.config.host) }
-      it { expect(http.port).to eq(Castle.config.port) }
-      it { expect(http.use_ssl?).to be false }
-      it { expect(http.verify_mode).to be_nil }
+      it { expect(build.body).to be_nil }
+      it { expect(build.method).to eql('GET') }
+      it { expect(build.path).to eql("/v1/#{command.path}") }
+      it { expect(build.to_hash).to have_key('authorization') }
+      it { expect(build.to_hash).to have_key('sample-header') }
+      it { expect(build.to_hash['sample-header']).to eql(['1']) }
     end
 
-    context 'when ssl true' do
-      it { expect(http).to be_instance_of(Net::HTTP) }
-      it { expect(http.address).to eq(Castle.config.host) }
-      it { expect(http.port).to eq(Castle.config.port) }
-      it { expect(http.use_ssl?).to be true }
-      it { expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER) }
+    context 'when post' do
+      let(:time) { Time.now.utc.iso8601(3) }
+      let(:command) do
+        Castle::Commands::Track.new({}).build(event: '$login.succeeded', name: "\xC4")
+      end
+      let(:expected_body) do
+        {
+          event: '$login.succeeded',
+          name: '�',
+          context: {},
+          sent_at: time
+        }
+      end
+
+      before { allow(Castle::Utils::Timestamp).to receive(:call).and_return(time) }
+
+      it { expect(build.body).to be_eql(expected_body.to_json) }
+      it { expect(build.method).to eql('POST') }
+      it { expect(build.path).to eql("/v1/#{command.path}") }
+      it { expect(build.to_hash).to have_key('authorization') }
+      it { expect(build.to_hash).to have_key('sample-header') }
+      it { expect(build.to_hash['sample-header']).to eql(['1']) }
     end
   end
 end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+describe Castle::API::Session do
+  describe '#get' do
+    it { expect(described_class.get).to eql(described_class.get) }
+    it { expect(described_class.get).to eql(described_class.instance.http) }
+  end
+
+  describe '#initialize' do
+    subject(:session) { described_class.get }
+
+    after do
+      described_class.instance.reset
+    end
+
+    context 'when ssl false' do
+      before do
+        Castle.config.host = 'localhost'
+        Castle.config.port = 3002
+        described_class.instance.reset
+      end
+
+      after do
+        Castle.config.host = Castle::Configuration::HOST
+        Castle.config.port = Castle::Configuration::PORT
+      end
+
+      it { expect(session).to be_instance_of(Net::HTTP) }
+      it { expect(session.address).to eq('localhost') }
+      it { expect(session.port).to eq(3002) }
+      it { expect(session.use_ssl?).to be false }
+      it { expect(session.verify_mode).to be_nil }
+    end
+
+    context 'when ssl true' do
+      before do
+        described_class.instance.reset
+      end
+
+      it { expect(session).to be_instance_of(Net::HTTP) }
+      it { expect(session.address).to eq(Castle.config.host) }
+      it { expect(session.port).to eq(Castle.config.port) }
+      it { expect(session.use_ssl?).to be true }
+      it { expect(session.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER) }
+    end
+  end
+end

data/spec/lib/castle/api_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 describe Castle::API do
-  subject(:request) { described_class.request(command) }
+  subject(:call) { described_class.call(command) }
 
   let(:command) { Castle::Commands::Track.new({}).build(event: '$login.succeeded') }
 
@@ -10,7 +10,7 @@ describe Castle::API do
 
     it do
       expect do
-        request
+        call
       end.to raise_error(Castle::RequestError)
     end
   end
@@ -20,7 +20,7 @@ describe Castle::API do
 
     it do
       expect do
-        request
+        call
       end.to raise_error(Castle::BadRequestError)
     end
   end
@@ -30,7 +30,7 @@ describe Castle::API do
 
     it do
       expect do
-        request
+        call
       end.to raise_error(Castle::ConfigurationError)
     end
   end

data/spec/lib/castle/client_spec.rb

@@ -244,11 +244,13 @@ describe Castle::Client do
       it { expect(request_response[:action]).to be_eql('allow') }
       it { expect(request_response[:user_id]).to be_eql('1234') }
       it { expect(request_response[:failover]).to be true }
-      it { expect(request_response[:failover_reason]).to be_eql('Castle set to do not track.') }
+      it { expect(request_response[:failover_reason]).to be_eql('Castle is set to do not track.') }
     end
 
     context 'when request with fail' do
-      before { allow(Castle::API).to receive(:request).and_raise(Castle::RequestError.new(Timeout::Error)) }
+      before do
+        allow(Castle::API).to receive(:request).and_raise(Castle::RequestError.new(Timeout::Error))
+      end
 
       context 'with request error and throw strategy' do
         before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
@@ -274,7 +276,7 @@ describe Castle::Client do
         it { expect { request_response }.to raise_error(Castle::InternalServerError) }
       end
 
-      context 'not throw on eg deny strategy' do
+      describe 'not throw on eg deny strategy' do
         it { assert_not_requested :post, 'https://:secret@api.castle.io/v1/authenticate' }
         it { expect(request_response[:action]).to be_eql('allow') }
         it { expect(request_response[:user_id]).to be_eql('1234') }

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

@@ -10,6 +10,7 @@ describe Castle::Commands::Authenticate do
   let(:time_auto) { time_now.utc.iso8601(3) }
 
   before { Timecop.freeze(time_now) }
+
   after { Timecop.return }
 
   describe '.build' do

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

@@ -10,6 +10,7 @@ describe Castle::Commands::Identify do
   let(:time_auto) { time_now.utc.iso8601(3) }
 
   before { Timecop.freeze(time_now) }
+
   after { Timecop.return }
 
   describe '.build' do

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

@@ -11,6 +11,7 @@ describe Castle::Commands::Impersonate do
   let(:time_auto) { time_now.utc.iso8601(3) }
 
   before { Timecop.freeze(time_now) }
+
   after { Timecop.return }
 
   describe '.build' do

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

@@ -10,6 +10,7 @@ describe Castle::Commands::Track do
   let(:time_auto) { time_now.utc.iso8601(3) }
 
   before { Timecop.freeze(time_now) }
+
   after { Timecop.return }
 
   describe '#build' do

data/spec/lib/castle/configuration_spec.rb

@@ -2,7 +2,7 @@
 
 describe Castle::Configuration do
   subject(:config) do
-    described_class.new
+    described_class.instance
   end
 
   describe 'host' do
@@ -31,14 +31,26 @@ describe Castle::Configuration 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')
+        ).and_return(secret_key_env)
+        config.reset
       end
 
       it do
-        expect(config.api_secret).to be_eql('secret_key')
+        expect(config.api_secret).to be_eql(secret_key_env)
+      end
+
+      context 'when key is overwritten' do
+        before { config.api_secret = secret_key }
+
+        it do
+          expect(config.api_secret).to be_eql(secret_key)
+        end
       end
     end
 
@@ -48,13 +60,14 @@ describe Castle::Configuration do
       before do
         config.api_secret = value
       end
+
       it do
         expect(config.api_secret).to be_eql(value)
       end
     end
 
     it do
-      expect(config.api_secret).to be_eql('')
+      expect(config.api_secret).to be_eql('secret')
     end
   end
 
@@ -69,6 +82,7 @@ describe Castle::Configuration do
       before do
         config.request_timeout = value
       end
+
       it do
         expect(config.request_timeout).to be_eql(value)
       end
@@ -84,6 +98,7 @@ describe Castle::Configuration do
       before do
         config.whitelisted = ['header']
       end
+
       it do
         expect(config.whitelisted).to be_eql(['Header'])
       end
@@ -99,6 +114,7 @@ describe Castle::Configuration do
       before do
         config.blacklisted = ['header']
       end
+
       it do
         expect(config.blacklisted).to be_eql(['Header'])
       end
@@ -114,6 +130,7 @@ describe Castle::Configuration do
       before do
         config.failover_strategy = :deny
       end
+
       it do
         expect(config.failover_strategy).to be_eql(:deny)
       end

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

@@ -4,37 +4,37 @@ describe Castle::Context::Default do
   subject { described_class.new(request, nil) }
 
   let(:ip) { '1.2.3.4' }
-  let(:cookie_id) { 'abcd' }
+  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=#{cookie_id};other=efgh")
+                              'HTTP_COOKIE' => "__cid=#{client_id};other=efgh")
   end
   let(:request) { Rack::Request.new(env) }
   let(:default_context) { subject.call }
   let(:version) { '2.2.0' }
-
-  before do
-    stub_const('Castle::VERSION', version)
-  end
-
-  it { expect(default_context[:active]).to be_eql(true) }
-  it { expect(default_context[:origin]).to be_eql('web') }
-
-  it do
-    expect(default_context[:headers]).to be_eql(
+  let(:result_headers) do
+    {
       'X-Forwarded-For' => '1.2.3.4',
       'Accept-Language' => 'en',
       'User-Agent' => 'test',
       'Content-Length' => '0',
       'Cookie' => true
-    )
+    }
   end
 
+  before do
+    stub_const('Castle::VERSION', version)
+  end
+
+  it { expect(default_context[:active]).to be_eql(true) }
+  it { expect(default_context[:origin]).to be_eql('web') }
+  it { expect(default_context[:headers]).to be_eql(result_headers) }
   it { expect(default_context[:ip]).to be_eql(ip) }
+  it { expect(default_context[:client_id]).to be_eql(client_id) }
   it { expect(default_context[:library][:name]).to be_eql('castle-rb') }
   it { expect(default_context[:library][:version]).to be_eql(version) }
   it { expect(default_context[:user_agent]).to be_eql('test') }

data/spec/lib/castle/events_spec.rb

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

data/spec/lib/castle/extractors/client_id_spec.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 describe Castle::Extractors::ClientId do
-  subject(:extractor) { described_class.new(request, cookies) }
+  subject(:extractor) { described_class.new(formatted_headers, cookies) }
 
+  let(:formatted_headers) { Castle::HeadersFilter.new(request).call }
   let(:client_id_cookie) { 'abcd' }
   let(:client_id_header) { 'abcde' }
   let(:cookies) { request.cookies }

data/spec/lib/castle/extractors/headers_spec.rb

@@ -1,78 +1,94 @@
 # frozen_string_literal: true
 
 describe Castle::Extractors::Headers do
-  subject(:headers) { described_class.new(request).call }
-
-  let(:client_id) { 'abcd' }
-  let(:env) do
-    result = Rack::MockRequest.env_for(
-      '/',
-      'Action-Dispatch.request.content-Type' => 'application/json',
-      'HTTP_AUTHORIZATION' => 'Basic 123456',
-      'HTTP_COOKIE' => "__cid=#{client_id};other=efgh",
-      'HTTP_ACCEPT' => 'application/json',
-      'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-      'HTTP_USER_AGENT' => 'Mozilla 1234',
-      'TEST' => '1'
-    )
-    result[:HTTP_OK] = 'OK'
-    result
+  subject(:headers) { described_class.new(formatted_headers).call }
+
+  let(:formatted_headers) do
+    {
+      'Content-Length' => '0',
+      'Authorization' => 'Basic 123456',
+      'Cookie' => '__cid=abcd;other=efgh',
+      'Ok' => 'OK',
+      'Accept' => 'application/json',
+      'X-Forwarded-For' => '1.2.3.4',
+      'User-Agent' => 'Mozilla 1234'
+    }
+  end
+
+  after do
+    Castle.config.whitelisted = %w[]
+    Castle.config.blacklisted = %w[]
   end
-  let(:request) { Rack::Request.new(env) }
 
   context 'when whitelist is not set in the configuration' do
-    it do
-      is_expected.to eq('Accept' => 'application/json',
-                        'Authorization' => true,
-                        'Cookie' => true,
-                        'Content-Length' => '0',
-                        'Ok' => 'OK',
-                        'User-Agent' => 'Mozilla 1234',
-                        'X-Forwarded-For' => '1.2.3.4')
+    let(:result) do
+      {
+        'Accept' => 'application/json',
+        'Authorization' => true,
+        'Cookie' => true,
+        'Content-Length' => '0',
+        'Ok' => 'OK',
+        'User-Agent' => 'Mozilla 1234',
+        'X-Forwarded-For' => '1.2.3.4'
+      }
     end
+
+    it { expect(headers).to eq(result) }
   end
 
   context 'when whitelist is set in the configuration' do
     before { Castle.config.whitelisted = %w[Accept OK] }
 
-    it do
-      is_expected.to eq('Accept' => 'application/json',
-                        'Authorization' => true,
-                        'Cookie' => true,
-                        'Content-Length' => true,
-                        'Ok' => 'OK',
-                        'User-Agent' => 'Mozilla 1234',
-                        'X-Forwarded-For' => true)
+    let(:result) do
+      {
+        'Accept' => 'application/json',
+        'Authorization' => true,
+        'Cookie' => true,
+        'Content-Length' => true,
+        'Ok' => 'OK',
+        'User-Agent' => 'Mozilla 1234',
+        'X-Forwarded-For' => true
+      }
     end
+
+    it { expect(headers).to eq(result) }
   end
 
   context 'when blacklist is set in the configuration' do
     context 'with a User-Agent' do
+      let(:result) do
+        {
+          'Accept' => 'application/json',
+          'Authorization' => true,
+          'Cookie' => true,
+          'Content-Length' => '0',
+          'Ok' => 'OK',
+          'User-Agent' => 'Mozilla 1234',
+          'X-Forwarded-For' => '1.2.3.4'
+        }
+      end
+
       before { Castle.config.blacklisted = %w[User-Agent] }
 
-      it do
-        is_expected.to eq('Accept' => 'application/json',
-                          'Authorization' => true,
-                          'Cookie' => true,
-                          'Content-Length' => '0',
-                          'Ok' => 'OK',
-                          'User-Agent' => 'Mozilla 1234',
-                          'X-Forwarded-For' => '1.2.3.4')
-      end
+      it { expect(headers).to eq(result) }
     end
 
     context 'with a different header' do
+      let(:result) do
+        {
+          'Accept' => true,
+          'Authorization' => true,
+          'Cookie' => true,
+          'Content-Length' => '0',
+          'Ok' => 'OK',
+          'User-Agent' => 'Mozilla 1234',
+          'X-Forwarded-For' => '1.2.3.4'
+        }
+      end
+
       before { Castle.config.blacklisted = %w[Accept] }
 
-      it do
-        is_expected.to eq('Accept' => true,
-                          'Authorization' => true,
-                          'Cookie' => true,
-                          'Content-Length' => '0',
-                          'Ok' => 'OK',
-                          'User-Agent' => 'Mozilla 1234',
-                          'X-Forwarded-For' => '1.2.3.4')
-      end
+      it { expect(headers).to eq(result) }
     end
   end