clever_tap_dubit 0.3.2

data/spec/units/clever_tap_client_spec.rb

@@ -0,0 +1,277 @@
+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
+        adapter = subject.connection.builder.adapter
+
+        expect(adapter).to eq(Faraday::Adapter::Test)
+      end
+    end
+
+    context 'without an adapter' do
+      subject { described_class.new('123456', 'passcode') }
+
+      it 'use Net::HTTP adapter' do
+        adapter = subject.connection.builder.adapter
+
+        expect(adapter).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

data/spec/units/event_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'shared/entity'
+
+RSpec.describe CleverTap::Event do
+  describe '.upload_limit' do
+    subject { described_class.upload_limit }
+    it { is_expected.to eq 1000 }
+  end
+
+  describe '#to_h' do
+    subject { described_class.new(**params).to_h }
+
+    describe 'choosing `identity`' do
+      it_behaves_like 'choosing identity for', 'event'
+    end
+
+    describe 'choosing timestamp' do
+      it_behaves_like 'choosing timestamp'
+    end
+
+    describe 'event name' do
+      let(:data) { { 'FBID' => '1414', 'Name' => 'John' } }
+      let(:params) { { data: data, identity: 'FBID' } }
+
+      context 'when `name` is not provided' do
+        it { expect { subject }.to raise_error(CleverTap::MissingEventNameError) }
+      end
+
+      context 'when `name` is provided' do
+        let!(:params_ext) { params.merge!(name: 'Web Event') }
+        it { is_expected.to include 'evtName' => 'Web Event' }
+      end
+    end
+
+    describe 'type' do
+      it_behaves_like 'proper type'
+    end
+
+    describe 'data' do
+      it_behaves_like 'constructing data for', 'event'
+    end
+  end
+end

data/spec/units/failed_response_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe CleverTap::FailedResponse do
+  let(:records) { [{ 'id' => 1 }, { 'id' => 2 }] }
+  let(:message) { 'LOL an error' }
+  let(:code) { 401 }
+
+  subject { described_class.new(records: records, message: message, code: code) }
+
+  describe '#status' do
+    it { expect(subject.status).to eq 'fail' }
+  end
+
+  describe '#success' do
+    it { expect(subject.success).to be false }
+  end
+
+  describe '#errors' do
+    it do
+      error = { 'status' => 'fail', 'code' => code, 'error' => message }
+
+      expect(subject.errors).to match_array(
+        records.map { |r| error.merge('record' => r) }
+      )
+    end
+  end
+
+  describe '#message' do
+    it { expect(subject.message).to eq message }
+  end
+end

data/spec/units/profile_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'shared/entity'
+
+RSpec.describe CleverTap::Profile do
+  describe '.upload_limit' do
+    subject { described_class.upload_limit }
+    it { is_expected.to eq 100 }
+  end
+
+  describe '#to_h' do
+    subject { described_class.new(**params).to_h }
+
+    describe 'choosing `identity`' do
+      it_behaves_like 'choosing identity for', 'profile'
+    end
+
+    describe 'choosing timestamp' do
+      it_behaves_like 'choosing timestamp'
+    end
+
+    describe 'type' do
+      it_behaves_like 'proper type'
+    end
+
+    describe 'data' do
+      it_behaves_like 'constructing data for', 'profile'
+    end
+  end
+end

data/spec/units/response_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe CleverTap::Response do
+  let(:success) do
+    { 'status' => 'success', 'processed' => 1, 'unprocessed' => [] }
+  end
+
+  let(:partial) do
+    {
+      'status' => 'success',
+      'processed' => 1,
+      'unprocessed' => [{ '{ "ID" => "5", "Name": "John"}' => 'Some error' }]
+    }
+  end
+
+  let(:failure) do
+    {
+      'status' => 'fail',
+      'error' => 'Account Id not valid',
+      'code' => 401
+    }
+  end
+
+  let(:non_json) do
+    '<head><title>502 Bad Gateway</title></head>'\
+    '<body>' \
+    '<center><h1>502 Bad Gateway</h1></center>'\
+    '</body>'\
+    '</html>'
+  end
+
+  describe '#new' do
+    subject { described_class.new(response) }
+
+    context 'when successful request' do
+      let(:response) { OpenStruct.new(body: success.to_json, success?: true) }
+
+      it { expect(subject.success).to be true }
+      it { expect(subject.failures).to eq [] }
+    end
+
+    context 'when partially successful request' do
+      let(:response) { OpenStruct.new(body: partial.to_json, success?: true) }
+
+      it { expect(subject.success).to be false }
+      it { expect(subject.failures).to eq partial['unprocessed'] }
+    end
+
+    context 'when failed request' do
+      let(:response) { OpenStruct.new(body: failure.to_json, success?: false) }
+
+      it { expect(subject.success).to be false }
+      it { expect(subject.failures).to eq [failure] }
+    end
+
+    context 'when non json response' do
+      let(:response) { OpenStruct.new(body: non_json, success?: false) }
+
+      it { expect(subject.success).to be false }
+      it { expect(subject.failures).to eq [{ resp_string: non_json.to_s }.to_json] }
+    end
+  end
+end

data/spec/units/successful_response_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe CleverTap::SuccessfulResponse do
+  shared_context 'successful state' do
+    let(:raw_response) do
+      { 'status' => 'success', 'processed' => 2, 'unprocessed' => [] }
+    end
+  end
+
+  shared_context 'partial state' do
+    let(:records) { [{ 'id' => 1 }] }
+    let(:raw_response) do
+      {
+        'status' => 'fail',
+        'processed' => 1,
+        'unprocessed' => records.map { |r| { 'record' => r.to_json } }
+      }
+    end
+  end
+
+  shared_context 'fail state' do
+    let(:records) { [{ 'id' => 1 }, { 'id' => 2 }] }
+    let(:raw_response) do
+      {
+        'status' => 'fail',
+        'processed' => 0,
+        'unprocessed' => records.map { |r| { 'record' => r.to_json } }
+      }
+    end
+  end
+
+  subject { described_class.new(raw_response) }
+
+  describe '#status' do
+    context 'with successful status' do
+      include_context 'successful state'
+
+      it { expect(subject.status).to eq 'success' }
+    end
+
+    context 'with partial status' do
+      include_context 'partial state'
+
+      it { expect(subject.status).to eq 'partial' }
+    end
+
+    context 'with fail status' do
+      include_context 'fail state'
+
+      it { expect(subject.status).to eq 'fail' }
+    end
+  end
+
+  describe '#success' do
+    context 'with successful status' do
+      include_context 'successful state'
+
+      it { expect(subject.success).to be true }
+    end
+
+    context 'with partial status' do
+      include_context 'partial state'
+
+      it { expect(subject.success).to be false }
+    end
+
+    context 'with fail status' do
+      include_context 'fail state'
+
+      it { expect(subject.success).to be false }
+    end
+  end
+
+  describe '#errors' do
+    context 'with successful status' do
+      include_context 'successful state'
+
+      it { expect(subject.errors).to be_empty }
+    end
+
+    context 'with partial status' do
+      include_context 'partial state'
+      it { expect(subject.errors).to all(include('record')) }
+    end
+
+    context 'with fail status' do
+      include_context 'fail state'
+
+      it { expect(subject.errors).to all(include('record')) }
+    end
+  end
+
+  describe '#message' do
+    context 'with successful status' do
+      include_context 'successful state'
+
+      it { expect(subject.message).to eq '' }
+    end
+
+    context 'with partial status' do
+      include_context 'partial state'
+
+      it { expect(subject.message).to eq '' }
+    end
+
+    context 'with fail status' do
+      include_context 'fail state'
+
+      it { expect(subject.message).to eq '' }
+    end
+  end
+end