clever_tap 0.3.0

data/lib/clever_tap/config.rb

@@ -0,0 +1,25 @@
+class CleverTap
+  # CleverTap instance's config store object
+  class Config
+    DEFAULT_IDENTITY_FIELD = 'identity'.freeze
+
+    attr_accessor :account_id, :passcode, :identity_field
+
+    def initialize(**config)
+      @account_id = config[:account_id]
+      @passcode = config[:passcode]
+      @identity_field = config[:identity_field] || DEFAULT_IDENTITY_FIELD
+      @configure_faraday = config[:configure_faraday]
+    end
+
+    # NOTE: reader or writer depending if the block is given
+    def configure_faraday(&block)
+      block ? @configure_faraday = block : @configure_faraday
+    end
+
+    def validate
+      raise 'Missing authentication parameter `account_id`' unless account_id
+      raise 'Missing authentication parameter `passcode`' unless passcode
+    end
+  end
+end

data/lib/clever_tap/entity.rb

@@ -0,0 +1,87 @@
+class CleverTap
+  class NoDataError < RuntimeError
+    def message
+      'No `data` param provided for Event'
+    end
+  end
+
+  class MissingIdentityError < RuntimeError
+    def message
+      "Couldn'n find `identity` in CleverTap.config or `data`"
+    end
+  end
+
+  class Entity
+    ALLOWED_IDENTITIES = %w(objectId FBID GPID).freeze
+    IDENTITY_STRING = 'identity'.freeze
+    TIMESTAMP_STRING = 'ts'.freeze
+    TYPE_KEY_STRING = 'type'.freeze
+    UPLOAD_LIMIT = 'Needs child class value'.freeze
+    TYPE_VALUE_STRING = 'Needs child class value'.freeze
+
+    class << self
+      def upload_limit
+        self::UPLOAD_LIMIT
+      end
+
+      def all_same_type?(items)
+        items.all? { |i| i.class == self }
+      end
+    end
+
+    def initialize(**args)
+      @data = args[:data]
+      @identity = choose_identity(args)
+      @timestamp = choose_timestamp(args)
+    end
+
+    def to_h
+      put_identity_pair
+        .merge(put_timestamp_pair)
+        .merge(put_type_pair)
+        .merge(put_data)
+    end
+
+    private
+
+    def put_identity_pair
+      raise NoDataError if @data.to_h.empty?
+      raise MissingIdentityError if @identity == '' || @data[@identity].nil?
+      return { @identity => @data[@identity].to_s } if allowed?(@identity)
+      { IDENTITY_STRING => @data[@identity].to_s }
+    end
+
+    def put_timestamp_pair
+      return {} unless @timestamp
+      { TIMESTAMP_STRING => @timestamp }
+    end
+
+    def put_type_pair
+      { TYPE_KEY_STRING => self.class::TYPE_VALUE_STRING }
+    end
+
+    def put_data
+      raise NoDataError if @data.to_h.empty?
+      @data.delete(@identity) if allowed?(@identity)
+      {
+        self.class::DATA_STRING => @data
+      }
+    end
+
+    def choose_identity(args)
+      identity = args[:identity].to_s
+
+      return identity if allowed?(identity) && @data.to_h.key?(identity)
+      CleverTap.identity_field.to_s
+    end
+
+    def choose_timestamp(args)
+      return args[:custom_timestamp].to_i if args[:custom_timestamp]
+      return @data.delete(args[:timestamp_field].to_s).to_i if args[:timestamp_field]
+    end
+
+    def allowed?(identity)
+      ALLOWED_IDENTITIES.include?(identity)
+    end
+  end
+end

data/lib/clever_tap/event.rb

@@ -0,0 +1,30 @@
+class CleverTap
+  class MissingEventNameError < RuntimeError
+    def message
+      "Couldn't find `name:` with value in Event#new(options)"
+    end
+  end
+
+  class Event < Entity
+    DATA_STRING = 'evtData'.freeze
+    EVENT_NAME_STRING = 'evtName'.freeze
+    TYPE_VALUE_STRING = 'event'.freeze
+    UPLOAD_LIMIT = 1000
+
+    def initialize(**args)
+      super(**args)
+      @name = args[:name]
+    end
+
+    def to_h
+      super.merge(put_event_name_pair)
+    end
+
+    private
+
+    def put_event_name_pair
+      raise MissingEventNameError if @name.nil?
+      { EVENT_NAME_STRING => @name }
+    end
+  end
+end

data/lib/clever_tap/failed_response.rb

@@ -0,0 +1,28 @@
+class CleverTap
+  # Introduce unified interface as the `SuccessfulResponse`
+  class FailedResponse
+    FAIL_STATUS = 'fail'.freeze
+
+    attr_reader :records, :message, :code
+
+    def initialize(records:, message:, code: -1)
+      @records = records
+      @message = message
+      @code = code
+    end
+
+    def status
+      FAIL_STATUS
+    end
+
+    def success
+      false
+    end
+
+    def errors
+      records.map do |record|
+        { 'status' => FAIL_STATUS, 'code' => code, 'error' => message, 'record' => record }
+      end
+    end
+  end
+end

data/lib/clever_tap/profile.rb

@@ -0,0 +1,7 @@
+class CleverTap
+  class Profile < Entity
+    DATA_STRING = 'profileData'.freeze
+    TYPE_VALUE_STRING = 'profile'.freeze
+    UPLOAD_LIMIT = 100
+  end
+end

data/lib/clever_tap/response.rb

@@ -0,0 +1,28 @@
+class CleverTap
+  class Response
+    attr_accessor :response, :success, :failures
+
+    def initialize(response)
+      @response = JSON.parse(response.body)
+      process_response
+    end
+
+    private
+
+    def process_response
+      return process_success if response['status'] == 'success'
+      @success = false
+      @failures = [response]
+    end
+
+    def process_success
+      if response['unprocessed'].to_a.empty?
+        @success = true
+        @failures = []
+      else
+        @success = false
+        @failures = response['unprocessed']
+      end
+    end
+  end
+end

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.0'.freeze
+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