castle-rb 2.2.0 → 2.3.0

data/lib/castle/response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Castle
+  # parses api response
+  class Response
+    RESPONSE_ERRORS = {
+      400 => Castle::BadRequestError,
+      401 => Castle::UnauthorizedError,
+      403 => Castle::ForbiddenError,
+      404 => Castle::NotFoundError,
+      419 => Castle::UserUnauthorizedError,
+      422 => Castle::InvalidParametersError
+    }.freeze
+
+    def initialize(response)
+      @response = response
+      verify_response_code
+    end
+
+    def parse
+      response_body = @response.body
+
+      return {} if response_body.nil? || response_body.empty?
+
+      begin
+        JSON.parse(response_body, symbolize_names: true)
+      rescue JSON::ParserError
+        raise Castle::ApiError, 'Invalid response from Castle API'
+      end
+    end
+
+    private
+
+    def verify_response_code
+      response_code = @response.code.to_i
+
+      return if response_code.between?(200, 299)
+
+      error = RESPONSE_ERRORS.fetch(response_code, Castle::ApiError)
+      raise error, @response[:message]
+    end
+  end
+end

data/lib/castle/support.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'castle/support/rails' if defined?(Rails::Railtie)
+
+if defined?(Sinatra::Base)
+  if defined?(Padrino)
+    require 'castle/support/padrino'
+  else
+    require 'castle/support/sinatra'
+  end
+end

data/lib/{castle-rb → castle}/support/padrino.rb

@@ -1,4 +1,4 @@
-require_relative 'cookie_store'
+# frozen_string_literal: true
 
 module Padrino
   class Application

data/lib/{castle-rb → castle}/support/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Castle
   module CastleClient
     def castle

data/lib/{castle-rb → castle}/support/sinatra.rb

@@ -1,4 +1,4 @@
-require_relative 'cookie_store'
+# frozen_string_literal: true
 
 module Sinatra
   module Castle

data/lib/castle/system.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Castle
+  # Get information regarding system
+  module System
+    class << self
+      # Returns hardware name, nodename, operating system release,
+      #  name and version
+      # @example Castle::System.uname #=>
+      #   Linux server 3.18.44-vs2.3.7.5-beng #1 SMP
+      #   Thu Oct 27 14:11:29 BST 2016 x86_64 GNU/Linux
+      def uname
+        `uname -a 2>/dev/null`.strip if platform =~ /linux|darwin/i
+      rescue Errno::ENOMEM # couldn't create subprocess
+        'uname lookup failed'
+      end
+
+      # Returns current system platform
+      # @example Castle::System.platform #=> 'x86_64-pc-linux-gnu'
+      def platform
+        begin
+          require 'rbconfig'
+          RbConfig::CONFIG['host'] || RUBY_PLATFORM
+        rescue LoadError
+          RUBY_PLATFORM
+        end.downcase
+      end
+
+      # Returns ruby version
+      # @example Castle::System.ruby_version #=> '2.4.1-p111 (2017-03-22)'
+      def ruby_version
+        "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+      end
+    end
+  end
+end

data/lib/castle/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Castle
+  VERSION = '2.3.0'
+end

data/spec/lib/castle/api_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Castle::API do
+  let(:api) { described_class.new('abcd', '1.2.3.4', '{}') }
+  let(:api_endpoint) { 'http://new.herokuapp.com:3000/v2' }
+
+  describe 'handles timeout' do
+    before do
+      stub_request(:any, /api.castle.io/).to_timeout
+    end
+    it do
+      expect do
+        api.request('authenticate', user_id: '1234')
+      end.to raise_error(Castle::RequestError)
+    end
+  end
+
+  describe 'handles non-OK response code' do
+    before do
+      stub_request(:any, /api.castle.io/).to_return(status: 400)
+    end
+    it 'handles non-OK response code' do
+      expect do
+        api.request('authenticate', user_id: '1234')
+      end.to raise_error(Castle::BadRequestError)
+    end
+  end
+
+  describe 'handles custom API endpoint' do
+    before do
+      stub_request(:any, /new.herokuapp.com/)
+      Castle.config.api_endpoint = api_endpoint
+    end
+    it do
+      api.request('authenticate', user_id: '1234')
+      path = "#{api_endpoint.gsub(/new/, ':secret@new')}/authenticate"
+      assert_requested :post, path, times: 1
+    end
+  end
+
+  describe 'handles query request' do
+    before do
+      stub_request(:any, /new.herokuapp.com/)
+      Castle.config.api_endpoint = api_endpoint
+    end
+    it do
+      api.request_query('review/1')
+      path = "#{api_endpoint.gsub(/new/, ':secret@new')}/review/1"
+      assert_requested :get, path, times: 1
+    end
+  end
+end

data/spec/lib/castle/client_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class Request < Rack::Request
+  def delegate?
+    false
+  end
+end
+
+describe Castle::Client do
+  let(:ip) { '1.2.3.4' }
+  let(:cookie_id) { 'abcd' }
+  let(:env) do
+    Rack::MockRequest.env_for('/',
+                              'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
+                              'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh")
+  end
+  let(:request) { Request.new(env) }
+  let(:client) { described_class.new(request, nil) }
+  let(:review_id) { '12356789' }
+
+  describe 'parses the request' do
+    let(:api_data) { [cookie_id, ip, "{\"X-Forwarded-For\":\"#{ip}\"}"] }
+
+    before do
+      allow(Castle::API).to receive(:new).with(*api_data).and_call_original
+    end
+
+    it do
+      client.authenticate(name: '$login.succeeded', user_id: '1234')
+      expect(Castle::API).to have_received(:new).with(*api_data)
+    end
+  end
+
+  it 'identifies' do
+    client.identify(user_id: '1234', traits: { name: 'Jo' })
+    assert_requested :post, 'https://:secret@api.castle.io/v1/identify',
+                     times: 1,
+                     body: { user_id: '1234', traits: { name: 'Jo' } }
+  end
+
+  it 'authenticates' do
+    client.authenticate(name: '$login.succeeded', user_id: '1234')
+    assert_requested :post, 'https://:secret@api.castle.io/v1/authenticate',
+                     times: 1,
+                     body: { name: '$login.succeeded', user_id: '1234' }
+  end
+
+  it 'tracks' do
+    client.track(name: '$login.succeeded', user_id: '1234')
+    assert_requested :post, 'https://:secret@api.castle.io/v1/track',
+                     times: 1,
+                     body: { name: '$login.succeeded', user_id: '1234' }
+  end
+
+  it 'fetches review' do
+    client.fetch_review(review_id)
+
+    assert_requested :get,
+                     "https://:secret@api.castle.io/v1/reviews/#{review_id}",
+                     times: 1
+  end
+end

data/spec/lib/castle/configuration_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Castle::Configuration do
+  subject(:config) do
+    described_class.new
+  end
+
+  describe 'api_endpoint' do
+    context 'env' do
+      let(:value) { 50.0 }
+
+      before do
+        allow(ENV).to receive(:fetch).with(
+          'CASTLE_API_ENDPOINT', 'https://api.castle.io/v1'
+        ).and_return('https://new.herokuapp.com')
+        allow(ENV).to receive(:fetch).with(
+          'CASTLE_API_SECRET', ''
+        ).and_call_original
+      end
+
+      it do
+        expect(config.api_endpoint).to be_eql(URI('https://new.herokuapp.com'))
+      end
+    end
+
+    it do
+      expect(config.api_endpoint).to be_eql(URI('https://api.castle.io/v1'))
+    end
+  end
+
+  describe 'api_secret' do
+    context 'env' do
+      before do
+        allow(ENV).to receive(:fetch).with(
+          'CASTLE_API_ENDPOINT', 'https://api.castle.io/v1'
+        ).and_call_original
+        allow(ENV).to receive(:fetch).with(
+          'CASTLE_API_SECRET', ''
+        ).and_return('secret_key')
+      end
+
+      it do
+        expect(config.api_secret).to be_eql('secret_key')
+      end
+    end
+
+    context 'setter' do
+      let(:value) { 'new_secret' }
+
+      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('')
+    end
+  end
+
+  describe 'request_timeout' do
+    it do
+      expect(config.request_timeout).to be_eql(30.0)
+    end
+
+    context 'setter' do
+      let(:value) { 50.0 }
+
+      before do
+        config.request_timeout = value
+      end
+      it do
+        expect(config.request_timeout).to be_eql(value)
+      end
+    end
+  end
+
+  describe 'source_header' do
+    it do
+      expect(config.source_header).to be_eql(nil)
+    end
+
+    context 'setter' do
+      let(:value) { 'header' }
+
+      before do
+        config.source_header = value
+      end
+      it do
+        expect(config.source_header).to be_eql(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Castle::Extractors::ClientId do
+  subject(:extractor) { described_class.new(request) }
+
+  let(:client_id) { 'abcd' }
+  let(:request) { Rack::Request.new(env) }
+  let(:env) do
+    Rack::MockRequest.env_for('/', headers)
+  end
+
+  context 'with client_id' do
+    let(:headers) do
+      {
+        'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
+        'HTTP_COOKIE' => "__cid=#{client_id};other=efgh"
+      }
+    end
+
+    it do
+      expect(extractor.call(nil, '__cid')).to eql(client_id)
+    end
+  end
+
+  context 'with X-Castle-Client-Id header' do
+    let(:headers) do
+      {
+        'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
+        'HTTP_X_CASTLE_CLIENT_ID' => client_id
+      }
+    end
+
+    it 'appends the client_id' do
+      expect(extractor.call(nil, '__cid')).to eql(client_id)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Castle::Extractors::Headers do
+  subject(:extractor) { described_class.new(request) }
+
+  let(:client_id) { 'abcd' }
+  let(:env) do
+    Rack::MockRequest.env_for('/',
+                              'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
+                              'HTTP_TEST' => '2',
+                              'TEST' => '1',
+                              'HTTP_COOKIE' => "__cid=#{client_id};other=efgh")
+  end
+  let(:request) { Rack::Request.new(env) }
+
+  describe 'header should extract http headers but skip cookies related' do
+    it do
+      expect(extractor.call).to eql(
+        '{"X-Forwarded-For":"1.2.3.4","Test":"2"}'
+      )
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Castle::Extractors::IP do
+  subject(:extractor) { described_class.new(request) }
+
+  let(:request) { Rack::Request.new(env) }
+
+  describe 'ip' do
+    let(:env) do
+      Rack::MockRequest.env_for('/',
+                                'HTTP_X_FORWARDED_FOR' => '1.2.3.4')
+    end
+
+    it do
+      expect(extractor.call).to eql('1.2.3.4')
+    end
+  end
+end

data/spec/lib/castle/headers_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Castle::Headers do
+  subject do
+    described_class.new
+  end
+
+  before do
+    allow(Castle.config).to receive(:source_header).and_return('web')
+    stub_const('Castle::VERSION', '2.2.0')
+  end
+
+  let(:ip) { '1.1.1.1' }
+  let(:castle_headers) { 'headers' }
+  let(:client_id) { 'some_id' }
+
+  let(:prepared_headers) do
+    subject.prepare(client_id, ip, castle_headers)
+  end
+
+  shared_examples 'for_header' do |header, value|
+    let(:header) { header }
+
+    it "has header #{header}" do
+      expect(prepared_headers[header]).to eql(value)
+    end
+  end
+  it_behaves_like 'for_header', 'Content-Type', 'application/json'
+  it_behaves_like 'for_header', 'X-Castle-Client-Id', 'some_id'
+  it_behaves_like 'for_header', 'X-Castle-Ip', '1.1.1.1'
+  it_behaves_like 'for_header', 'X-Castle-Headers', 'headers'
+  it_behaves_like 'for_header', 'X-Castle-Source', 'web'
+  it_behaves_like 'for_header',
+                  'User-Agent',
+                  'Castle/v1 RubyBindings/2.2.0'
+
+  describe 'X-Castle-Client-User-Agent' do
+    let(:header) { 'X-Castle-Client-User-Agent' }
+    let(:prepared_header_parsed) { JSON.parse(prepared_headers[header]) }
+
+    before do
+      allow(Castle::System).to receive(:uname).and_return('name')
+    end
+
+    it { expect(prepared_header_parsed).to include('lang') }
+    it { expect(prepared_header_parsed).to include('lang_version') }
+    it { expect(prepared_header_parsed).to include('platform') }
+    it { expect(prepared_header_parsed).to include('publisher') }
+    it { expect(prepared_header_parsed['bindings_version']).to eql('2.2.0') }
+    it { expect(prepared_header_parsed['uname']).to eql('name') }
+  end
+
+  context 'missing' do
+    shared_examples 'for_missing_header' do |header|
+      let(:header) { header }
+
+      it "it missing header #{header}" do
+        expect(prepared_headers.key?(header)).to be_falsey
+      end
+    end
+
+    context 'ip' do
+      let(:ip) { nil }
+
+      it_behaves_like 'for_missing_header', 'X-Castle-Ip'
+    end
+
+    context 'client_id' do
+      let(:client_id) { nil }
+
+      it_behaves_like 'for_missing_header', 'X-Castle-Cookie-Id'
+    end
+
+    context 'castle headers' do
+      let(:castle_headers) { nil }
+
+      it_behaves_like 'for_missing_header', 'X-Castle-Headers'
+    end
+  end
+end