castle-rb 3.6.2

data/lib/castle/review.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Castle
+  class Review
+    def self.retrieve(review_id)
+      Castle::API.request(
+        Castle::Commands::Review.build(review_id)
+      )
+    end
+  end
+end

data/lib/castle/secure_mode.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Castle
+  module SecureMode
+    def self.signature(user_id)
+      OpenSSL::HMAC.hexdigest('sha256', Castle.config.api_secret, user_id.to_s)
+    end
+  end
+end

data/lib/castle/support/hanami.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Castle
+  module Hanami
+    module Action
+      def castle
+        @castle ||= ::Castle::Client.from_request(request, cookies: (cookies if defined? cookies))
+      end
+    end
+
+    def self.included(base)
+      base.configure do
+        controller.prepare do
+          include Castle::Hanami::Action
+        end
+      end
+    end
+  end
+end

data/lib/castle/support/padrino.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Padrino
+  class Application
+    module Castle
+      module Helpers
+        def castle
+          @castle ||= ::Castle::Client.from_request(request)
+        end
+      end
+
+      def self.registered(app)
+        app.helpers Helpers
+      end
+    end
+
+    register Castle
+  end
+end

data/lib/castle/support/rails.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Castle
+  module CastleClient
+    def castle
+      @castle ||= request.env['castle'] || Castle::Client.from_request(request)
+    end
+  end
+
+  ActiveSupport.on_load(:action_controller) do
+    include CastleClient
+  end
+end

data/lib/castle/support/sinatra.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+
+module Sinatra
+  module Castle
+    module Helpers
+      def castle
+        @castle ||= ::Castle::Client.from_request(request)
+      end
+    end
+
+    def self.registered(app)
+      app.helpers Castle::Helpers
+    end
+  end
+
+  register Castle
+end

data/lib/castle/utils.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Castle
+  module Utils
+    class << self
+      # Returns a new hash with all keys converted to symbols, as long as
+      # they respond to +to_sym+. This includes the keys from the root hash
+      # and from all nested hashes and arrays.
+      #
+      #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+      #
+      #   Castle::Hash.deep_symbolize_keys(hash)
+      #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+      def deep_symbolize_keys(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = deep_symbolize_keys(value, &block)
+          end
+        when Array
+          object.map { |e| deep_symbolize_keys(e, &block) }
+        else
+          object
+        end
+      end
+
+      def deep_symbolize_keys!(object, &block)
+        case object
+        when Hash
+          object.keys.each do |key|
+            value = object.delete(key)
+            object[key.to_sym] = deep_symbolize_keys!(value, &block)
+          end
+          object
+        when Array
+          object.map! { |e| deep_symbolize_keys!(e, &block) }
+        else
+          object
+        end
+      end
+
+      def replace_invalid_characters(arg)
+        if arg.is_a?(::String)
+          arg.encode('UTF-8', invalid: :replace, undef: :replace)
+        elsif arg.is_a?(::Hash)
+          arg.each_with_object({}) { |(k, v), h| h[k] = replace_invalid_characters(v) }
+        elsif arg.is_a?(::Array)
+          arg.map(&method(:replace_invalid_characters))
+        else
+          arg
+        end
+      end
+    end
+  end
+end

data/lib/castle/utils/cloner.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Castle
+  module Utils
+    class Cloner
+      def self.call(object)
+        Marshal.load(Marshal.dump(object))
+      end
+    end
+  end
+end

data/lib/castle/utils/merger.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Castle
+  module Utils
+    class Merger
+      def self.call(base, extra)
+        base_s = Castle::Utils.deep_symbolize_keys(base)
+        extra_s = Castle::Utils.deep_symbolize_keys(extra)
+
+        extra_s.each do |name, value|
+          if value.nil?
+            base_s.delete(name)
+          elsif value.is_a?(Hash) && base_s[name].is_a?(Hash)
+            base_s[name] = call(base_s[name], value)
+          else
+            base_s[name] = value
+          end
+        end
+        base_s
+      end
+    end
+  end
+end

data/lib/castle/utils/timestamp.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Castle
+  module Utils
+    # generates proper timestamp
+    class Timestamp
+      def self.call
+        Time.now.utc.iso8601(3)
+      end
+    end
+  end
+end

data/lib/castle/validators/not_supported.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Castle
+  module Validators
+    class NotSupported
+      class << self
+        def call(options, keys)
+          keys.each do |key|
+            next unless options.key?(key)
+            raise Castle::InvalidParametersError, "#{key} is/are not supported"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/castle/validators/present.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Castle
+  module Validators
+    class Present
+      class << self
+        def call(options, keys)
+          keys.each do |key|
+            next unless options[key].to_s.empty?
+            raise Castle::InvalidParametersError, "#{key} is missing or empty"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/castle/version.rb

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

data/spec/lib/castle/api/request/build_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+describe Castle::API::Request::Build do
+  subject(:call) { described_class.call(command, headers, api_secret) }
+
+  let(:headers) { { 'SAMPLE-HEADER' => '1' } }
+  let(:api_secret) { 'secret' }
+
+  describe 'call' do
+    context 'when get' do
+      let(:command) { Castle::Commands::Review.build(review_id) }
+      let(:review_id) { SecureRandom.uuid }
+
+      it { expect(call.body).to be_nil }
+      it { expect(call.method).to eql('GET') }
+      it { expect(call.path).to eql("/v1/#{command.path}") }
+      it { expect(call.to_hash).to have_key('authorization') }
+      it { expect(call.to_hash).to have_key('sample-header') }
+      it { expect(call.to_hash['sample-header']).to eql(['1']) }
+    end
+
+    context 'when post' do
+      let(:time) { Time.now.utc.iso8601(3) }
+      let(:command) { Castle::Commands::Track.new({}).build(event: '$login.succeeded', name: "\xC4") }
+      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(call.body).to be_eql(expected_body.to_json) }
+      it { expect(call.method).to eql('POST') }
+      it { expect(call.path).to eql("/v1/#{command.path}") }
+      it { expect(call.to_hash).to have_key('authorization') }
+      it { expect(call.to_hash).to have_key('sample-header') }
+      it { expect(call.to_hash['sample-header']).to eql(['1']) }
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+describe Castle::API::Request do
+  describe '#call' do
+    subject(:call) { described_class.call(command, api_secret, headers) }
+
+    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(: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)
+      call
+    end
+
+    it do
+      expect(Castle::API::Request::Build).to have_received(:call)
+        .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 }
+
+    context 'when ssl false' do
+      before do
+        Castle.config.host = 'localhost'
+        Castle.config.port = 3002
+      end
+
+      after do
+        Castle.config.host = Castle::Configuration::HOST
+        Castle.config.port = Castle::Configuration::PORT
+      end
+
+      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 }
+    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) }
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+describe Castle::API::Response 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
+
+    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', '499', Castle::ApiError
+    it_behaves_like 'response_failed', '500', Castle::InternalServerError
+  end
+end

data/spec/lib/castle/api_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+describe Castle::API do
+  subject(:request) { described_class.request(command) }
+
+  let(:command) { Castle::Commands::Track.new({}).build(event: '$login.succeeded') }
+
+  context 'when request timeouts' do
+    before { stub_request(:any, /api.castle.io/).to_timeout }
+
+    it do
+      expect do
+        request
+      end.to raise_error(Castle::RequestError)
+    end
+  end
+
+  context 'when non-OK response code' do
+    before { stub_request(:any, /api.castle.io/).to_return(status: 400) }
+
+    it do
+      expect do
+        request
+      end.to raise_error(Castle::BadRequestError)
+    end
+  end
+
+  context 'when no api_secret' do
+    before { allow(Castle.config).to receive(:api_secret).and_return('') }
+
+    it do
+      expect do
+        request
+      end.to raise_error(Castle::ConfigurationError)
+    end
+  end
+end