clever_tap 0.3.0

data/spec/shared/clever_tap_client.rb

@@ -0,0 +1,13 @@
+shared_examples 'configured `Client`' do
+  it 'preserves credentials in `Client`' do
+    expect(subject.account_id).to eq account_id
+    expect(subject.passcode).to eq account_passcode
+  end
+end
+
+shared_examples 'configured `Client`' do
+  it 'preserves credentials in `Client`' do
+    expect(subject.account_id).to eq account_id
+    expect(subject.passcode).to eq account_passcode
+  end
+end

data/spec/shared/entity.rb

@@ -0,0 +1,105 @@
+shared_examples_for 'setting allowed identities for' do |type|
+  type_data = type == 'event' ? 'evtData' : 'profileData'
+  described_class::ALLOWED_IDENTITIES.each do |id|
+    context "when `identity` set as `#{id}` in the event" do
+      let!(:params_ext) { params.merge!(identity: id) }
+      let!(:data_ext) { data.merge!(id => '1414') }
+
+      it { is_expected.to include(id => '1414') }
+      it { expect(subject[type_data]).not_to include(id => '1414') }
+    end
+  end
+end
+
+shared_examples_for 'choosing identity for' do |type|
+  evt_name = type == 'event' ? { name: 'Evt' } : {}
+  before { CleverTap.setup { |c| c.identity_field = 'ID' } }
+  let(:params) { { data: data }.merge!(evt_name) }
+  let(:data) { { 'ID' => 1, 'Name' => 'John' } }
+
+  context 'when custom `identity` from config' do
+    it { is_expected.to include 'identity' => '1' }
+  end
+
+  context 'when `identity` different from ALLOWED_IDENTITIES and config' do
+    let!(:params_ext) { params.merge!(identity: 'email') }
+    let!(:data_ext) { data.merge!('email' => 'example@email.com') }
+
+    it { is_expected.to include 'identity' => '1' }
+  end
+
+  context 'when `identity` missing from `data`' do
+    let(:data) { { 'Name' => 'John' } }
+
+    it { expect { subject }.to raise_error CleverTap::MissingIdentityError }
+  end
+
+  it_behaves_like 'setting allowed identities for', type
+end
+
+shared_examples_for 'choosing timestamp' do
+  let(:data) { { 'FBID' => 1, 'Name' => 'John' } }
+  let(:params) { { data: data, identity: 'FBID', name: 'evt' } }
+
+  context 'when no `timestamp_field`' do
+    it { is_expected.not_to include 'ts' }
+  end
+
+  context 'when specific `timestamp` field' do
+    let!(:data_ext) { data.merge!('Open Time' => open_time) }
+    let!(:params_ext) { params.merge!(timestamp_field: 'Open Time') }
+
+    context 'and `timestamp_field` is Unix timestamp' do
+      let(:open_time) { '1508241881' }
+      it { is_expected.to include('ts' => open_time.to_i) }
+    end
+
+    context 'and `timestamp_field` is `DateTime` timestamp' do
+      let(:open_time) { Time.now }
+      it { is_expected.to include('ts' => open_time.to_i) }
+    end
+  end
+
+  context 'when `custom_timestamp` specified' do
+    let!(:params_ext) { params.merge!(custom_timestamp: open_time) }
+
+    context 'and `custom_timestamp` is Unix timestamp' do
+      let(:open_time) { '1508241881' }
+      it { is_expected.to include('ts' => open_time.to_i) }
+    end
+
+    context 'and `custom_timestamp` is `DateTime` timestamp' do
+      let(:open_time) { Time.now }
+      it { is_expected.to include('ts' => open_time.to_i) }
+    end
+  end
+end
+
+shared_examples_for 'proper type' do
+  let(:data) { { 'FBID' => '1414', 'Name' => 'John' } }
+  let(:params) { { data: data, name: 'e', identity: 'FBID' } }
+
+  it { is_expected.to include described_class::TYPE_KEY_STRING => described_class::TYPE_VALUE_STRING }
+end
+
+shared_examples_for 'constructing data for' do |type|
+  obj_type = type == 'event' ? 'evtData' : 'profileData'
+  evt_name = type == 'event' ? { name: 'Evt' } : {}
+
+  let(:data) { { 'FBID' => '1414', 'Name' => 'John' } }
+  let(:params) { { data: data, identity: 'FBID' }.merge!(evt_name) }
+
+  context 'when no `data` param in `params` hash' do
+    let(:params) { {}.merge!(evt_name) }
+    it { expect { subject }.to raise_error CleverTap::NoDataError }
+  end
+
+  context 'when `data` empty hash in `params` hash' do
+    let(:params) { { data: {} }.merge!(evt_name) }
+    it { expect { subject }.to raise_error CleverTap::NoDataError }
+  end
+
+  context 'when `data` available in `params` hash' do
+    it { is_expected.to include(obj_type => { 'Name' => 'John' }) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+require 'clever_tap'
+
+require 'vcr'
+require 'vcr_config'
+
+require 'factories/profile'
+require 'pry-byebug'
+
+# Use for recording VCR cassettes
+AUTH_ACCOUNT_ID = ENV['CLEVER_TAP_ACCOUNT_ID'] || 'fake-id'
+AUTH_PASSCODE = ENV['CLEVER_TAP_PASSCODE'] || 'fake-passcode'
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.mock_with(:rspec) { |c| c.syntax = :expect }
+end

data/spec/units/clever_tap_client_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+require 'shared/clever_tap_client'
+
+describe CleverTap::Client, vcr: true do
+  subject { described_class.new('123456', 'passcode') }
+
+  describe 'authentication' do
+    it 'send right `account_id`' do
+      expect(subject.connection.headers['X-CleverTap-Account-Id']).to eq('123456')
+    end
+
+    it 'send right `passcode`' do
+      expect(subject.connection.headers['X-CleverTap-Passcode']).to eq('passcode')
+    end
+  end
+
+  describe 'customisations' do
+    context 'with different adapter' do
+      subject do
+        described_class.new('123456', 'passcode') { |config| config.adapter(:test) }
+      end
+
+      it 'override the default adapter' do
+        handlers = subject.connection.builder.handlers
+
+        expect(handlers.count).to eq(1)
+        expect(handlers.first).to eq(Faraday::Adapter::Test)
+      end
+    end
+
+    context 'without an adapter' do
+      subject { described_class.new('123456', 'passcode') }
+
+      it 'use Net::HTTP adapter' do
+        handlers = subject.connection.builder.handlers
+
+        expect(handlers.count).to eq(1)
+        expect(handlers.first).to eq(Faraday::Adapter::NetHttp)
+      end
+    end
+  end
+
+  describe '#new' do
+    let(:identity_field) { 'ID' }
+    let(:account_id) { 'ABC1234' }
+    let(:account_passcode) { 'AcCPasScoDe123' }
+
+    context 'when credentials set in `CleverTap.setup`' do
+      subject { CleverTap::Client.new }
+
+      before do
+        CleverTap.setup do |config|
+          config.identity_field = identity_field
+          config.account_id = account_id
+          config.account_passcode = account_passcode
+        end
+      end
+
+      it_behaves_like 'configured `Client`'
+    end
+
+    context 'when credentials set in `CleverTap::Client.new`' do
+      subject { CleverTap::Client.new(account_id, account_passcode) }
+      it_behaves_like 'configured `Client`'
+    end
+  end
+
+  def event_factory(id, name)
+    CleverTap::Event.new(
+      data: { 'FBID' => id.to_s, 'Name' => name.to_s },
+      name: 'Web Event',
+      identity: 'FBID'
+    )
+  end
+
+  def profile_factory
+    CleverTap::Profile.new(
+      data: { 'ID' => '1414', 'Name' => 'John', 'Phone' => '+44+441234' }
+    )
+  end
+
+  describe '#upload' do
+    let(:success_proc) { proc { 'sample proc' } }
+    let(:response) { subject.upload([event1, event2]) }
+
+    subject do
+      client = described_class.new
+      client.on_successful_upload(&success_proc)
+      client
+    end
+
+    before do
+      CleverTap.setup do |c|
+        c.identity_field = 'ID'
+        c.account_id = AUTH_ACCOUNT_ID
+        c.account_passcode = AUTH_PASSCODE
+      end
+    end
+
+    context 'when upload records are homogenous' do
+      context 'and valid records' do
+        let(:event1) { event_factory('1414', 'John') }
+        let(:event2) { event_factory('1515', 'Jill') }
+
+        context 'and objects fit `upload_limit`' do
+          VCR.use_cassette('upload within Event limit') do
+            it 'returns an array with one successful `Response` object' do
+              expect(response.count).to eq 1
+              expect(response.first.success).to be true
+              expect(response.first).to be_a(CleverTap::Response)
+            end
+
+            it 'calls `on_successful_upload` proc once' do
+              expect(success_proc).to receive(:call).once
+              subject.upload([event1, event2])
+            end
+          end
+        end
+
+        context 'and objects do not fit `upload_limit`' do
+          before do
+            allow(CleverTap::Event)
+              .to receive(:upload_limit).and_return(1)
+          end
+
+          VCR.use_cassette('upload out of Event limit') do
+            it 'returns an array with two successful `Response` objects' do
+              expect(response.count).to eq 2
+              expect(response.all?(&:success)).to be true
+              expect(
+                response.all? { |r| r.class == CleverTap::Response }
+              ).to be true
+            end
+
+            it 'calls `on_successful_upload` proc twice' do
+              expect(success_proc).to receive(:call).twice
+              subject.upload([event1, event2])
+            end
+          end
+        end
+      end
+
+      context 'and invalid records' do
+        let(:failure_proc) { proc { 'sample proc' } }
+        let(:response) { subject.upload([profile]) }
+
+        subject do
+          client = described_class.new
+          client.on_failed_upload(&failure_proc)
+          client
+        end
+
+        let(:profile) { profile_factory }
+
+        it 'returns an array with one failed `Response` object' do
+          expect(response.count).to eq 1
+          expect(response.first.class).to eq CleverTap::Response
+          expect(response.first.success).to be false
+        end
+
+        it 'calls `on_failed_upload` once' do
+          expect(failure_proc).to receive(:call).once
+          subject.upload([profile])
+        end
+      end
+    end
+
+    context 'when objects are not homogenous' do
+      let(:event1) { event_factory('1414', 'John') }
+      let(:event2) { {} }
+
+      it 'raises `NotConsistentArrayError`' do
+        expect { subject.upload([event1, event2]) }.to raise_error CleverTap::NotConsistentArrayError
+      end
+    end
+  end
+
+  describe '#request_body' do
+    subject { described_class.new('123456', 'passcode') }
+    let(:records) do
+      [
+        { 'ID' => '123', 'Name' => 'John' },
+        { 'ID' => '456', 'Name' => 'Jill' }
+      ]
+    end
+
+    it 'converts records hash to json' do
+      expect(subject.send(:request_body, records))
+        .to eq({ 'd' => records }.to_json)
+    end
+  end
+
+  describe '#determine_type' do
+    subject { described_class.new('123456', 'passcode') }
+
+    context 'when records are of the same type' do
+      let(:records) { [{}, {}] }
+
+      it 'returns the class of the elements' do
+        expect(subject.send(:determine_type, records)).to eq Hash
+      end
+    end
+
+    context 'when records are of different type' do
+      let(:records) { [{}, []] }
+
+      it 'raises `NotConsistentArrayError`' do
+        expect { subject.send(:determine_type, records) }.to raise_error CleverTap::NotConsistentArrayError
+      end
+    end
+  end
+
+  describe '#ensure_array' do
+    subject { described_class.new('123456', 'passcode') }
+    let(:records) { %w[sample sample2] }
+    let(:record) { 'sample' }
+
+    it 'returns an array when an array passed' do
+      expect(subject.send(:ensure_array, records)).to eq records
+    end
+
+    it 'returns an array when a single element passed' do
+      expect(subject.send(:ensure_array, record)).to eq [record]
+    end
+  end
+
+  describe 'setting `account_id` and `passcode`' do
+    subject { described_class.new(client_id, client_passcode) }
+    let(:client_id) { '123456' }
+    let(:client_passcode) { 'passcode' }
+    let(:config_id) { 'config_account_id' }
+    let(:config_passcode) { 'config_passcode' }
+
+    def config_client(account, pass)
+      CleverTap.setup do |c|
+        c.account_id = account
+        c.account_passcode = pass
+      end
+    end
+
+    context 'when credentials provided in configuration' do
+      before { config_client(config_id, config_passcode) }
+
+      context 'and in initialization as well' do
+        it 'has initialization values' do
+          expect(subject.send(:assign_account_id, client_id)).to eq client_id
+          expect(subject.send(:assign_passcode, client_passcode)).to eq client_passcode
+        end
+      end
+
+      context 'and not in initialization' do
+        it 'has initialization values' do
+          expect(subject.send(:assign_account_id, nil)).to eq config_id
+          expect(subject.send(:assign_passcode, nil)).to eq config_passcode
+        end
+      end
+    end
+
+    context 'when credentials not provided in configuration' do
+      before { config_client(nil, nil) }
+
+      context 'but provided in initialization' do
+        it 'has initialization values' do
+          expect(subject.send(:assign_account_id, client_id)).to eq client_id
+          expect(subject.send(:assign_passcode, client_passcode)).to eq client_passcode
+        end
+      end
+
+      context 'and not provided in initialization as well' do
+        before { config_client(nil, nil) }
+        subject { described_class.new }
+
+        it 'raises a `RuntimeError` error' do
+          expect { subject }.to raise_error RuntimeError
+        end
+      end
+    end
+  end
+end

data/spec/units/clever_tap_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+RSpec.describe CleverTap do
+  describe '#new' do
+    context 'with valid arguments' do
+      context 'with keyword arguments' do
+        subject(:clever_tap) do
+          CleverTap.new(account_id: 'foo',
+                        passcode: 'passcode',
+                        identity_field: 'ID',
+                        configure_faraday: configure_faraday)
+        end
+
+        let(:configure_faraday) { proc {} }
+
+        it('persist the account_id') { expect(clever_tap.config.account_id).to eq('foo') }
+        it('persist the passcode') { expect(clever_tap.config.passcode).to eq('passcode') }
+        it('persist the identity field') { expect(clever_tap.config.identity_field).to eq('ID') }
+        it('persist the faraday config') { expect(clever_tap.config.configure_faraday).to eq(configure_faraday) }
+      end
+
+      context 'with block' do
+        subject(:clever_tap) do
+          CleverTap.new do |config|
+            config.account_id = 'foo'
+            config.passcode = 'passcode'
+            config.identity_field = 'ID'
+            config.configure_faraday(&configure_faraday)
+          end
+        end
+
+        let(:configure_faraday) { proc {} }
+
+        it('persist the account_id') { expect(clever_tap.config.account_id).to eq('foo') }
+        it('persist the passcode') { expect(clever_tap.config.passcode).to eq('passcode') }
+        it('persist the identity field') { expect(clever_tap.config.identity_field).to eq('ID') }
+        it('persist the faraday config') { expect(clever_tap.config.configure_faraday).to eq(configure_faraday) }
+      end
+    end
+
+    context 'with invalid arguments' do
+      it 'require `account_id`' do
+        expect { CleverTap.new(passcode: 'foo') }
+          .to raise_error(RuntimeError, /account_id/)
+      end
+
+      it 'require `passcode`' do
+        expect { CleverTap.new(account_id: 'bar') }
+          .to raise_error(RuntimeError, /passcode/)
+      end
+    end
+  end
+
+  describe '#client' do
+    subject(:clever_tap) { CleverTap.new(account_id: 'foo', passcode: 'passcode', &configure_faraday) }
+    let(:configure_faraday) { proc { |_faraday| } }
+
+    it 'initialize client with a right auth data' do
+      expect(CleverTap::Client).to receive(:new).with('foo', 'passcode', &configure_faraday)
+
+      clever_tap.client
+    end
+
+    it 'cache the client between calls' do
+      id = clever_tap.client.object_id
+      expect(clever_tap.client.object_id).to eq(id)
+    end
+  end
+
+  describe '.config' do
+    let(:identity_field) { 'ID' }
+    let(:account_id) { 'ABC1234' }
+    let(:account_passcode) { 'AcCPasScoDe123' }
+    let(:remove_identity) { true }
+
+    it 'sets config variables' do
+      described_class.setup do |config|
+        config.identity_field = identity_field
+        config.account_id = account_id
+        config.account_passcode = account_passcode
+      end
+
+      expect(described_class.identity_field).to eq identity_field
+      expect(described_class.account_id).to eq account_id
+      expect(described_class.account_passcode).to eq account_passcode
+    end
+  end
+end