clever_tap_dubit 0.3.2

data/lib/clever_tap/successful_response.rb

@@ -0,0 +1,30 @@
+class CleverTap
+  # Normalize the success response data to one interface with the failure one
+  class SuccessfulResponse
+    attr_reader :raw_response, :unprocessed, :message, :code
+
+    # NOTE: raw_response can include processed, unprocessed, status
+    def initialize(raw_response = {})
+      @raw_response = raw_response
+      @unprocessed = raw_response['unprocessed']
+      @message = ''
+      @code = 200
+    end
+
+    def errors
+      unprocessed
+    end
+
+    def status
+      case
+      when success then 'success'
+      when raw_response['processed'].positive? then 'partial'
+      else 'fail'
+      end
+    end
+
+    def success
+      unprocessed.empty?
+    end
+  end
+end

data/lib/clever_tap/uploader.rb

@@ -0,0 +1,72 @@
+class CleverTap
+  # unit uploading profile data to CleverTap
+  class Uploader
+    HTTP_PATH = 'upload'.freeze
+
+    TYPE_EVENT = :event
+    TYPE_PROFILE = :profile
+
+    ENTITY_DATA_NAMES = {
+      TYPE_EVENT => 'evtData',
+      TYPE_PROFILE => 'profileData'
+    }.freeze
+
+    attr_reader :records, :type, :identity_field, :date_field, :event_name, :dry_run
+
+    # TODO: make defaults configurable
+    # date_field should be a date object responding to `to_i` which
+    # should returns epoch time
+    # profile respond to .to_h
+    def initialize(records, identity_field:, date_field: nil, event_name: nil, dry_run: false)
+      @type = event_name ? TYPE_EVENT : TYPE_PROFILE
+      @records = records
+
+      @identity_field = identity_field
+      @date_field = date_field
+      @event_name = event_name
+      @dry_run = dry_run
+    end
+
+    def call(client)
+      response = client.post(HTTP_PATH, build_request_body) do |request|
+        request.params.merge!(dryRun: 1) if dry_run
+      end
+
+      parse_response(response)
+    end
+
+    private
+
+    def build_request_body
+      records.each_with_object('d' => []) do |record, request_body|
+        request_body['d'] << normalize_record(record)
+      end.to_json
+    end
+
+    def normalize_record(record)
+      ts = date_field ? record[date_field] : Time.now
+
+      {
+        'identity' => pluck_identity(record).to_s,
+        'ts' => ts.to_i,
+        'type' => type,
+        ENTITY_DATA_NAMES[type] => record.to_h
+      }.tap do |hash|
+        hash.merge!('evtName' => event_name) if type == TYPE_EVENT
+      end
+    end
+
+    def parse_response(http_response)
+      http_response
+    end
+
+    def pluck_identity(record)
+      # TODO: symbolize record keys
+      identity = record[identity_field.to_s] || record[identity_field.to_sym]
+
+      raise "Missing identity field with name: '#{identity_field}' for #{record}" unless identity
+
+      identity
+    end
+  end
+end

data/lib/clever_tap/version.rb

@@ -0,0 +1,3 @@
+class CleverTap
+  VERSION = '0.3.2'.freeze
+end

data/lib/clever_tap.rb

@@ -0,0 +1,79 @@
+require 'json'
+
+require 'clever_tap/config'
+require 'clever_tap/client'
+require 'clever_tap/entity'
+require 'clever_tap/event'
+require 'clever_tap/profile'
+require 'clever_tap/uploader'
+require 'clever_tap/response'
+require 'clever_tap/successful_response'
+require 'clever_tap/failed_response'
+
+# the main module of the system
+class CleverTap
+  attr_reader :config
+
+  class << self
+    # Never instantiated.  Variables are stored in the singleton_class.
+    private_class_method :new
+
+    attr_accessor :identity_field
+    attr_accessor :account_id
+    attr_accessor :account_passcode
+
+    def setup
+      yield(self)
+    end
+  end
+
+  def initialize(**params)
+    @config = Config.new(params)
+    yield(@config) if block_given?
+
+    @config.validate
+    @config.freeze
+  end
+
+  def client
+    @client ||= Client.new(config.account_id, config.passcode, &config.configure_faraday)
+  end
+
+  def upload_events(events, name:, **rest)
+    options = rest.merge(event_name: name, identity_field: config.identity_field)
+
+    response = Uploader.new(events, options).call(client)
+
+    normalize_response(response, records: events)
+  rescue Faraday::Error::TimeoutError, Faraday::Error::ClientError => e
+    FailedResponse.new(records: events, message: e.message)
+  end
+
+  def upload_event(event, **options)
+    upload_events([event], options)
+  end
+
+  def upload_profiles(profiles, **options)
+    options = options.merge(identity_field: config.identity_field)
+    response = Uploader.new(profiles, **options).call(client)
+
+    normalize_response(response, records: profiles)
+  rescue Faraday::Error::TimeoutError, Faraday::Error::ClientError => e
+    FailedResponse.new(records: profiles, message: e.message)
+  end
+
+  def upload_profile(profile, **options)
+    upload_profiles([profile], options)
+  end
+
+  private
+
+  def normalize_response(response, records:)
+    # TODO: handle JSON::ParserError
+    if response.success?
+      SuccessfulResponse.new(JSON.parse(response.body))
+    else
+      FailedResponse.new(records: records, code: response.status, message: response.body)
+    end
+  end
+end

data/lib/clevertap-ruby.rb

@@ -0,0 +1 @@
+require 'clever_tap'

data/spec/factories/profile.rb

@@ -0,0 +1,36 @@
+# Unit representing a profile and it's different states
+class Profile
+  class << self
+    attr_accessor :store
+  end
+
+  self.store = {
+    id: 0
+  }
+
+  def self.build_valid(extra = {})
+    new({
+      'identity' => store[:id] += 1,
+      'created_at' => Time.new,
+      'Name' => 'John Rush',
+      'Email' => 'example@gmail.com',
+      'Gender' => 'M',
+      'Phone' => '+35922333232',
+      'Employed' => 'Y',
+      'Education' => 'Graduate',
+      'Married' => 'Y',
+      'Age' => '18'
+    }.merge(extra))
+  end
+
+  attr_reader :data
+  alias to_h data
+
+  def initialize(data = {})
+    @data = data
+  end
+
+  def [](key)
+    data[key]
+  end
+end

data/spec/integrations/clever_tap_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe CleverTap, vcr: true do
+  # NOTE: clear mutations in CleverTap config
+  subject(:clever_tap) { CleverTap.new(account_id: AUTH_ACCOUNT_ID, passcode: AUTH_PASSCODE) }
+
+  describe 'uploading a profile' do
+    context 'when is valid' do
+      let(:profile) { Profile.build_valid }
+
+      it 'succeed' do
+        response = clever_tap.upload_profile(profile)
+
+        aggregate_failures do
+          expect(response.status).to eq('success')
+          expect(response.errors).to be_empty
+        end
+      end
+    end
+
+    context 'when is invalid' do
+      let(:profile) { Profile.build_valid('Email' => '$$$$$') }
+
+      it 'fails' do
+        response = clever_tap.upload_profile(profile)
+
+        aggregate_failures do
+          expect(response.status).to eq('fail')
+          expect(response.errors).to all(be_a(Hash))
+          expect(response.errors).to all(
+            include('status', 'code', 'error', 'record')
+          )
+        end
+      end
+    end
+  end
+
+  describe 'uploading a many profiles' do
+    context 'when only some are valid' do
+      let(:valid_profile) { Profile.build_valid }
+      let(:invalid_profile) { Profile.build_valid('Email' => '$$$$$') }
+      let(:profiles) { [valid_profile, invalid_profile] }
+
+      it 'partially succeds' do
+        response = clever_tap.upload_profiles(profiles)
+
+        aggregate_failures do
+          expect(response.status).to eq('partial')
+          expect(response.errors).to all(be_a(Hash))
+          expect(response.errors).to all(
+            include('status', 'code', 'error', 'record')
+          )
+        end
+      end
+    end
+  end
+
+  describe 'uploading an event' do
+    subject(:clever_tap) do
+      CleverTap.new(account_id: AUTH_ACCOUNT_ID, passcode: AUTH_PASSCODE, identity_field: 'ID')
+    end
+
+    context 'when is valid' do
+      let(:event) do
+        {
+          'ID' => 555,
+          'mobile' => true
+        }
+      end
+
+      it 'succeed' do
+        response = clever_tap.upload_event(event, name: 'register', identity_field: 'user_id')
+
+        aggregate_failures do
+          expect(response.status).to eq('success')
+          expect(response.errors).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop_spec.rb

@@ -0,0 +1,12 @@
+require 'rubocop'
+
+gem_root = File.expand_path('../', __FILE__)
+CONFIG_FILE_PATH = File.join(gem_root, 'config', 'rubocop_spec.yml')
+
+describe 'rubocop' do
+  let(:args) { ['--format', 'simple', '-D', gem_root] }
+
+  it 'passes all cops' do
+    expect { RuboCop::CLI.new.run(args) }.to output(/no offenses detected/).to_stdout
+  end
+end

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