castle-rb 2.3.2 → 3.0.0

data/spec/lib/castle/client_spec.rb

@@ -1,64 +1,200 @@
 # 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")
+    Rack::MockRequest.env_for(
+      '/',
+      'HTTP_X_FORWARDED_FOR' => ip,
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+    )
+  end
+  let(:request) { Rack::Request.new(env) }
+  let(:client) { described_class.new(request) }
+  let(:headers) { { 'X-Forwarded-For' => ip.to_s } }
+  let(:context) do
+    {
+      client_id: 'abcd',
+      active: true,
+      origin: 'web',
+      headers: headers,
+      ip: ip,
+      library: { name: 'castle-rb', version: '2.2.0' }
+    }
   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
+    stub_const('Castle::VERSION', '2.2.0')
+    stub_request(:any, /api.castle.io/).with(
+      basic_auth: ['', 'secret']
+    ).to_return(status: 200, body: '{}', headers: {})
+  end
 
+  describe 'parses the request' do
     before do
-      allow(Castle::API).to receive(:new).with(*api_data).and_call_original
+      allow(Castle::API).to receive(:new).and_call_original
     end
 
     it do
-      client.authenticate(name: '$login.succeeded', user_id: '1234')
-      expect(Castle::API).to have_received(:new).with(*api_data)
+      client.authenticate(event: '$login.succeeded', user_id: '1234')
+      expect(Castle::API).to have_received(:new)
     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' } }
+  describe 'identify' do
+    let(:request_body) { { user_id: '1234', context: context, traits: { name: 'Jo' } } }
+
+    before { client.identify(options) }
+
+    context 'symbol keys' do
+      let(:options) { { user_id: '1234', traits: { name: 'Jo' } } }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/identify', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      end
+    end
+
+    context 'string keys' do
+      let(:options) { { 'user_id' => '1234', 'traits' => { 'name' => 'Jo' } } }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/identify', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      end
+    end
   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' }
+  describe 'authenticate' do
+    let(:options) { { event: '$login.succeeded', user_id: '1234' } }
+    let(:request_response) { client.authenticate(options) }
+    let(:request_body) { { event: '$login.succeeded', user_id: '1234', context: context } }
+
+    context 'symbol keys' do
+      before { request_response }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
+          req.body == request_body.to_json
+        end
+      end
+    end
+
+    context 'string keys' do
+      let(:options) { { 'event' => '$login.succeeded', 'user_id' => '1234' } }
+
+      before { request_response }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
+          req.body == request_body.to_json
+        end
+      end
+    end
+
+    context 'tracking enabled' do
+      before { request_response }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/authenticate', times: 1 do |req|
+          req.body == request_body.to_json
+        end
+      end
+
+      it { expect(request_response['failover']).to be false }
+      it { expect(request_response['failover_reason']).to be_nil }
+    end
+
+    context 'tracking disabled' do
+      before do
+        client.disable_tracking
+        request_response
+      end
+
+      it { assert_not_requested :post, 'https://api.castle.io/v1/authenticate' }
+      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.') }
+    end
+
+    context 'when request with fail' do
+      before { allow(client.api).to receive(:request).and_raise(Castle::RequestError) }
+
+      context 'with request error and throw strategy' do
+        before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
+
+        it { expect { request_response }.to raise_error(Castle::RequestError) }
+      end
+
+      context 'with request error and 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') }
+        it { expect(request_response['failover']).to be true }
+        it { expect(request_response['failover_reason']).to be_eql('Castle::RequestError') }
+      end
+    end
+
+    context 'when request is internal server error' do
+      before { allow(client.api).to receive(:request).and_raise(Castle::InternalServerError) }
+
+      context 'throw strategy' do
+        before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
+
+        it { expect { request_response }.to raise_error(Castle::InternalServerError) }
+      end
+
+      context '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') }
+        it { expect(request_response['failover']).to be true }
+        it { expect(request_response['failover_reason']).to be_eql('Castle::InternalServerError') }
+      end
+    end
   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' }
+  describe 'track' do
+    let(:request_body) { { event: '$login.succeeded', context: context, user_id: '1234' } }
+
+    before { client.track(options) }
+
+    context 'symbol keys' do
+      let(:options) { { event: '$login.succeeded', user_id: '1234' } }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/track', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      end
+    end
+
+    context 'string keys' do
+      let(:options) { { 'event' => '$login.succeeded', 'user_id' => '1234' } }
+
+      it do
+        assert_requested :post, 'https://api.castle.io/v1/track', times: 1 do |req|
+          JSON.parse(req.body) == JSON.parse(request_body.to_json)
+        end
+      end
+    end
   end
 
-  it 'fetches review' do
-    client.fetch_review(review_id)
+  describe 'tracked?' do
+    context 'off' do
+      before { client.disable_tracking }
+
+      it { expect(client).not_to be_tracked }
+    end
+
+    context 'on' do
+      before { client.enable_tracking }
 
-    assert_requested :get,
-                     "https://:secret@api.castle.io/v1/reviews/#{review_id}",
-                     times: 1
+      it { expect(client).to be_tracked }
+    end
   end
 end

data/spec/lib/castle/command_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+describe Castle::Command do
+  subject(:command) { described_class.new('go', { id: '1' }, :post) }
+
+  it { expect(command.path).to be_eql('go') }
+  it { expect(command.data).to be_eql(id: '1') }
+  it { expect(command.method).to be_eql(:post) }
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+describe Castle::Commands::Authenticate do
+  subject(:instance) { described_class.new(context) }
+
+  let(:context) { { test: { test1: '1' } } }
+  let(:default_payload) { { event: '$login.authenticate', user_id: '1234' } }
+
+  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('authenticate') }
+      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('authenticate') }
+      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('authenticate') }
+      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('authenticate') }
+      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('authenticate') }
+      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('authenticate') }
+      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 'user_id not present' do
+      let(:payload) { { event: '$login.track' } }
+
+      it do
+        expect do
+          validate!
+        end.to raise_error(Castle::InvalidParametersError, 'user_id is missing or empty')
+      end
+    end
+
+    context 'event and user_id present' do
+      let(:payload) { { event: '$login.track', user_id: '1234' } }
+
+      it { expect { validate! }.not_to raise_error }
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# 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' } }
+
+  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('identify') }
+      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('identify') }
+      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('identify') }
+      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('identify') }
+      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('identify') }
+      it { expect(command.data).to be_eql(command_data) }
+    end
+  end
+
+  describe '#validate!' do
+    subject(:validate!) { instance.build(payload) }
+
+    context 'user_id not present' do
+      let(:payload) { {} }
+
+      it do
+        expect do
+          validate!
+        end.to raise_error(Castle::InvalidParametersError, 'user_id is missing or empty')
+      end
+    end
+
+    context 'user_id present' do
+      let(:payload) { { user_id: '1234' } }
+
+      it { expect { validate! }.not_to raise_error }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+describe Castle::Commands::Review do
+  subject(:instance) { described_class.new }
+
+  let(:context) { {} }
+  let(:review_id) { '1234' }
+
+  describe '.build' do
+    subject(:command) { instance.build(review_id) }
+
+    context 'without review_id' do
+      let(:review_id) { '' }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+
+    context 'with review_id' do
+      it { expect(command.method).to be_eql(:get) }
+      it { expect(command.path).to be_eql("reviews/#{review_id}") }
+      it { expect(command.data).to be_nil }
+    end
+  end
+end