locked-rb 0.0.1

data/spec/lib/Locked/command_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+describe Locked::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/Locked/commands/authenticate_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+describe Locked::Commands::Authenticate do
+  subject(:instance) { described_class.new(context) }
+
+  let(:context) { { test: { test1: '1' } } }
+  let(:default_payload) { { event: '$login.success', user_id: '1234', sent_at: time_auto } }
+
+  let(:time_now) { Time.now }
+  let(:time_auto) { time_now.utc.iso8601(3) }
+
+  before { Timecop.freeze(time_now) }
+  after { Timecop.return }
+
+  describe '.build' do
+    subject(:command) { instance.build(payload) }
+
+    context 'with 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.path).to be_eql('authenticate') }
+      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be_eql(:post) }
+    end
+
+    context 'with 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.path).to be_eql('authenticate') }
+      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be_eql(:post) }
+    end
+
+    context 'with user_traits' do
+      let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
+      let(:command_data) do
+        default_payload.merge(user_traits: { test: '1' }, context: context)
+      end
+
+      it { expect(command.path).to be_eql('authenticate') }
+      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be_eql(:post) }
+    end
+
+    context 'when 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.path).to be_eql('authenticate') }
+      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be_eql(:post) }
+    end
+
+    context 'when 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.path).to be_eql('authenticate') }
+      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be_eql(:post) }
+    end
+
+    context 'when 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 'with event not present' do
+      let(:payload) { {} }
+
+      it do
+        expect do
+          validate!
+        end.to raise_error(Locked::InvalidParametersError, 'event is missing or empty')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+describe Locked::Commands::Identify do
+  # subject(:instance) { described_class.new(context) }
+  #
+  # let(:context) { { test: { test1: '1' } } }
+  # let(:default_payload) { { user_id: '1234', sent_at: time_auto } }
+  #
+  # let(:time_now) { Time.now }
+  # let(:time_auto) { time_now.utc.iso8601(3) }
+  #
+  # before { Timecop.freeze(time_now) }
+  # after { Timecop.return }
+  #
+  # describe '.build' do
+  #   subject(:command) { instance.build(payload) }
+  #
+  #   context 'with 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 'with user_traits' do
+  #     let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
+  #     let(:command_data) do
+  #       default_payload.merge(user_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 'when 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 'when 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 'when 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 'with user_id not present' do
+  #     let(:payload) { {} }
+  #
+  #     it { expect { validate! }.not_to raise_error }
+  #   end
+  #
+  #   context 'with user_id present' do
+  #     let(:payload) { { user_id: '1234' } }
+  #
+  #     it { expect { validate! }.not_to raise_error }
+  #   end
+  # end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+describe Locked::Commands::Review do
+  subject(:instance) { described_class }
+
+  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(Locked::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

data/spec/lib/Locked/configuration_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+describe Locked::Configuration do
+  subject(:config) do
+    described_class.new
+  end
+
+  describe 'host' do
+    context 'with default' do
+      it { expect(config.host).to be_eql('locked.jp') }
+    end
+
+    context 'with setter' do
+      before { config.host = 'locked.dev' }
+
+      it { expect(config.host).to be_eql('locked.dev') }
+    end
+  end
+
+  describe 'post' do
+    context 'with default' do
+      it { expect(config.port).to be_eql(443) }
+    end
+
+    context 'with setter' do
+      before { config.port = 3001 }
+
+      it { expect(config.port).to be_eql(3001) }
+    end
+  end
+
+  describe 'api_key' do
+    context 'with env' do
+      before do
+        allow(ENV).to receive(:fetch).with(
+          'X_LOCKED_API_KEY', ''
+        ).and_return('secret_key')
+      end
+
+      it do
+        expect(config.api_key).to be_eql('secret_key')
+      end
+    end
+
+    context 'with setter' do
+      let(:value) { 'new_key' }
+
+      before do
+        config.api_key = value
+      end
+      it do
+        expect(config.api_key).to be_eql(value)
+      end
+    end
+
+    it do
+      expect(config.api_key).to be_eql('')
+    end
+  end
+
+  describe 'request_timeout' do
+    it do
+      expect(config.request_timeout).to be_eql(1000)
+    end
+
+    context 'with 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 'whitelisted' do
+    it do
+      expect(config.whitelisted.size).to be_eql(13)
+    end
+
+    context 'with setter' do
+      before do
+        config.whitelisted = ['header']
+      end
+      it do
+        expect(config.whitelisted).to be_eql(['Header'])
+      end
+    end
+
+    context 'when appending' do
+      before do
+        config.whitelisted += ['header']
+      end
+      it { expect(config.whitelisted).to be_include('Header') }
+      it { expect(config.whitelisted.size).to be_eql(14) }
+    end
+  end
+
+  describe 'blacklisted' do
+    it do
+      expect(config.blacklisted.size).to be_eql(1)
+    end
+
+    context 'with setter' do
+      before do
+        config.blacklisted = ['header']
+      end
+      it do
+        expect(config.blacklisted).to be_eql(['Header'])
+      end
+    end
+
+    context 'when appending' do
+      before do
+        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(:deny)
+    end
+
+    context 'with 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 do
+          config.failover_strategy = :unicorn
+        end.to raise_error(Locked::ConfigurationError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+describe Locked::Context::Default 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('Locked::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('locked-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/Locked/context/merger_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe Locked::Context::Merger do
+  let(:first) { { test: { test1: { c: '4' } } } }
+
+  describe '#call' do
+    subject { described_class.call(first, second) }
+
+    let(:result) { { test: { test1: { c: '4', d: '5' } } } }
+
+    context 'with symbol keys' do
+      let(:second) { { test: { test1: { d: '5' } } } }
+
+      it { is_expected.to eq(result) }
+    end
+
+    context 'with string keys' do
+      let(:second) { { 'test' => { 'test1' => { 'd' => '5' } } } }
+
+      it { is_expected.to eq(result) }
+    end
+  end
+end

data/spec/lib/Locked/context/sanitizer_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+describe Locked::Context::Sanitizer do
+  let(:paylod) { { test: 'test' } }
+
+  describe '#call' do
+    subject { described_class.call(context) }
+
+    context 'when active true' do
+      let(:context) { paylod.merge(active: true) }
+
+      it { is_expected.to eql(context) }
+    end
+
+    context 'when active false' do
+      let(:context) { paylod.merge(active: false) }
+
+      it { is_expected.to eql(context) }
+    end
+
+    context 'when active string' do
+      let(:context) { paylod.merge(active: 'uknown') }
+
+      it { is_expected.to eql(paylod) }
+    end
+  end
+end