castle-rb 2.3.2 → 3.0.0

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+describe Castle::Commands::Track do
+  subject(:instance) { described_class.new(context) }
+
+  let(:context) { { test: { test1: '1' } } }
+  let(:default_payload) { { event: '$login.track' } }
+
+  describe '#build' do
+    subject(:command) { instance.build(payload) }
+
+    context '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('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+
+    context 'user_id' do
+      let(:payload) { default_payload.merge({ user_id: '1234' }) }
+      let(:command_data) do
+        default_payload.merge({ user_id: '1234', context: context })
+      end
+
+      it { expect(command.method).to be_eql(:post) }
+      it { expect(command.path).to be_eql('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+
+    context 'properties' do
+      let(:payload) { default_payload.merge({ properties: { test: '1' } }) }
+      let(:command_data) do
+        default_payload.merge({ properties: { test: '1' }, context: context })
+      end
+
+      it { expect(command.method).to be_eql(:post) }
+      it { expect(command.path).to be_eql('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+
+    context 'traits' do
+      let(:payload) { default_payload.merge({ traits: { test: '1' } }) }
+      let(:command_data) do
+        default_payload.merge({ traits: { test: '1' }, context: context })
+      end
+
+      it { expect(command.method).to be_eql(:post) }
+      it { expect(command.path).to be_eql('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+
+    context '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('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+
+    context '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('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+
+    context '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('track') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+  end
+
+  describe '#validate!' do
+    subject(:validate!) { instance.build(payload) }
+
+    context 'event not present' do
+      let(:payload) { {} }
+
+      it do
+        expect do
+          validate!
+        end.to raise_error(Castle::InvalidParametersError, 'event is missing or empty')
+      end
+    end
+
+    context 'event present' do
+      let(:payload) { { event: '$login.track' } }
+
+      it { expect { validate! }.not_to raise_error }
+    end
+  end
+end

data/spec/lib/castle/configuration_spec.rb

@@ -1,41 +1,37 @@
 # 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 }
+  describe 'host' do
+    context 'default' do
+      it { expect(config.host).to be_eql('api.castle.io') }
+    end
 
-      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
+    context 'setter' do
+      before { config.host = 'api.castle.dev' }
 
-      it do
-        expect(config.api_endpoint).to be_eql(URI('https://new.herokuapp.com'))
-      end
+      it { expect(config.host).to be_eql('api.castle.dev') }
+    end
+  end
+
+  describe 'host' do
+    context 'default' do
+      it { expect(config.port).to be_eql(443) }
     end
 
-    it do
-      expect(config.api_endpoint).to be_eql(URI('https://api.castle.io/v1'))
+    context 'setter' do
+      before { config.port = 3001 }
+
+      it { expect(config.port).to be_eql(3001) }
     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')
@@ -64,7 +60,7 @@ describe Castle::Configuration do
 
   describe 'request_timeout' do
     it do
-      expect(config.request_timeout).to be_eql(30.0)
+      expect(config.request_timeout).to be_eql(500)
     end
 
     context 'setter' do
@@ -79,19 +75,71 @@ describe Castle::Configuration do
     end
   end
 
-  describe 'source_header' do
+  describe 'whitelisted' do
+    it do
+      expect(config.whitelisted.size).to be_eql(11)
+    end
+
+    context 'setter' do
+      before do
+        config.whitelisted = ['header']
+      end
+      it do
+        expect(config.whitelisted).to be_eql(['Header'])
+      end
+    end
+
+    context 'appending' do
+      before do
+        config.whitelisted += ['header']
+      end
+      it { expect(config.whitelisted).to be_include('Header') }
+      it { expect(config.whitelisted.size).to be_eql(12) }
+    end
+  end
+
+  describe 'blacklisted' do
     it do
-      expect(config.source_header).to be_eql(nil)
+      expect(config.blacklisted.size).to be_eql(1)
     end
 
     context 'setter' do
-      let(:value) { 'header' }
+      before do
+        config.blacklisted = ['header']
+      end
+      it do
+        expect(config.blacklisted).to be_eql(['Header'])
+      end
+    end
 
+    context 'appending' do
       before do
-        config.source_header = value
+        config.blacklisted += ['header']
       end
+      it { expect(config.blacklisted).to be_include('Header') }
+      it { expect(config.blacklisted.size).to be_eql(2) }
+    end
+  end
+
+  describe 'failover_strategy' do
+    it do
+      expect(config.failover_strategy).to be_eql(:allow)
+    end
+
+    context 'setter' do
+      before do
+        config.failover_strategy = :deny
+      end
+      it do
+        expect(config.failover_strategy).to be_eql(:deny)
+      end
+    end
+
+    context 'when broken' do
       it do
-        expect(config.source_header).to be_eql(value)
+        expect do
+          config.failover_strategy = :unicorn
+        end.to raise_error(Castle::ConfigurationError)
       end
     end
   end

data/spec/lib/castle/context_merger_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe Castle::ContextMerger do
+  subject(:command) { described_class.new('go', { id: '1' }, :post) }
+
+  let(:first) { { test: { test1: { c: '4' } } } }
+
+  context '.new' do
+    subject(:instance) { described_class.new(first) }
+
+    it { expect(instance.instance_variable_get(:@main_context)).to eq(first) }
+    it do
+      expect(instance.instance_variable_get(:@main_context).object_id).not_to eq(first.object_id)
+    end
+  end
+
+  context '#call' do
+    subject { described_class.new(first).call(second) }
+
+    let(:result) { { test: { test1: { c: '4', d: '5' } } } }
+
+    context 'symbol keys' do
+      let(:second) { { test: { test1: { d: '5' } } } }
+
+      it { is_expected.to eq(result) }
+    end
+
+    context 'string keys' do
+      let(:second) { { 'test' => { 'test1' => { 'd' => '5' } } } }
+
+      it { is_expected.to eq(result) }
+    end
+  end
+end

data/spec/lib/castle/default_context_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+describe Castle::DefaultContext do
+  subject { described_class.new(request, nil) }
+
+  let(:ip) { '1.2.3.4' }
+  let(:cookie_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")
+  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 {
+    expect(default_context[:headers]).to be_eql(
+      'X-Forwarded-For' => '1.2.3.4', 'Accept-Language' => 'en', 'User-Agent' => 'test'
+    )
+  }
+  it { expect(default_context[:ip]).to be_eql(ip) }
+  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') }
+end

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

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Castle::Extractors::ClientId do
-  subject(:extractor) { described_class.new(request) }
+  subject(:extractor) { described_class.new(request, cookies) }
 
   let(:client_id) { 'abcd' }
+  let(:cookies) { request.cookies }
   let(:request) { Rack::Request.new(env) }
   let(:env) do
     Rack::MockRequest.env_for('/', headers)
@@ -20,7 +19,7 @@ describe Castle::Extractors::ClientId do
     end
 
     it do
-      expect(extractor.call(nil, '__cid')).to eql(client_id)
+      expect(extractor.call('__cid')).to eql(client_id)
     end
   end
 
@@ -33,7 +32,16 @@ describe Castle::Extractors::ClientId do
     end
 
     it 'appends the client_id' do
-      expect(extractor.call(nil, '__cid')).to eql(client_id)
+      expect(extractor.call('__cid')).to eql(client_id)
+    end
+  end
+
+  context 'allow cookies to be undefined' do
+    let(:cookies) { nil }
+    let(:headers) { {} }
+
+    it do
+      expect(extractor.call('__cid')).to eql('')
     end
   end
 end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Castle::Extractors::Headers do
   subject(:extractor) { described_class.new(request) }
 
@@ -9,16 +7,19 @@ describe Castle::Extractors::Headers do
   let(:env) do
     Rack::MockRequest.env_for('/',
                               'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-                              'HTTP_TEST' => '2',
+                              'HTTP_OK' => 'OK',
                               '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
+  describe 'extract http headers with whitelisted and blacklisted support' do
+    before do
+      Castle.config.whitelisted += ['TEST']
+    end
     it do
       expect(extractor.call).to eql(
-        '{"X-Forwarded-For":"1.2.3.4","Test":"2"}'
+        'X-Forwarded-For' => '1.2.3.4', 'Test' => '1'
       )
     end
   end

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

@@ -1,20 +1,13 @@
 # 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
+    let(:env) { Rack::MockRequest.env_for( '/', 'HTTP_X_FORWARDED_FOR' => '1.2.3.4') }
 
-    it do
-      expect(extractor.call).to eql('1.2.3.4')
-    end
+    it { expect(extractor.call).to eql('1.2.3.4') }
   end
 end

data/spec/lib/castle/header_formatter_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+describe Castle::HeaderFormatter do
+  subject(:formatter) { described_class.new }
+
+  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
+end

data/spec/lib/castle/request_spec.rb

@@ -1,21 +1,16 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Castle::Request do
-  subject do
-    described_class.new(headers)
-  end
+  subject { described_class.new(headers) }
 
   let(:headers) { { 'SAMPLE-HEADER' => '1' } }
   let(:api_secret) { Castle.config.api_secret }
 
   describe 'build' do
-    let(:path) { 'endpoint' }
-    let(:params) { { user_id: 1 } }
-
     context 'get' do
-      let(:request) { subject.build_query(path) }
+      let(:path) { 'endpoint' }
+      let(:params) { { user_id: 1 } }
+      let(:request) { subject.build(path, params, :get) }
 
       it { expect(request.body).to be_nil }
       it { expect(request.method).to eql('GET') }
@@ -25,6 +20,8 @@ describe Castle::Request do
     end
 
     context 'post' do
+      let(:path) { 'endpoint' }
+      let(:params) { { user_id: 1 } }
       let(:request) { subject.build(path, params, :post) }
 
       it { expect(request.body).to be_eql('{"user_id":1}') }
@@ -32,6 +29,12 @@ describe Castle::Request do
       it { expect(request.path).to eql('/v1/endpoint') }
       it { expect(request.to_hash['sample-header']).to eql(['1']) }
       it { expect(request.to_hash['authorization'][0]).to match(/Basic \w/) }
+
+      context 'with non-UTF-8 charaters' do
+        let(:params) { { name: "\xC4" } }
+
+        it { expect(request.body).to eq '{"name":"�"}' }
+      end
     end
   end
 end