catarse_pagarme 2.13.0 → 2.14.0

data/lib/catarse_pagarme/configuration.rb

@@ -1,12 +1,13 @@
 module CatarsePagarme
   class Configuration
-    attr_accessor :api_key, :slip_tax, :credit_card_tax, :interest_rate, :host, :subdomain, :protocol,
+    attr_accessor :api_key, :konduto_api_key, :slip_tax, :credit_card_tax, :interest_rate, :host, :subdomain, :protocol,
       :max_installments, :minimum_value_for_installment, :credit_card_cents_fee, :pagarme_tax, :stone_tax,
       :stone_installment_tax, :cielo_tax, :cielo_installment_diners_tax, :cielo_installment_not_diners_tax,
       :cielo_installment_amex_tax, :cielo_installment_not_amex_tax, :ecr_key, :slip_week_day_interval, :antifraud_tax, :use_simility
 
     def initialize
       self.api_key = ''
+      self.konduto_api_key = ''
       self.ecr_key = ''
       self.slip_tax = 0
       self.credit_card_tax = 0

data/lib/catarse_pagarme/version.rb

@@ -1,3 +1,3 @@
 module CatarsePagarme
-  VERSION = "2.13.0"
+  VERSION = "2.14.0"
 end

data/spec/dummy/app/models/payment.rb

@@ -39,6 +39,10 @@ class Payment < ActiveRecord::Base
     true
   end
 
+  def pending?
+    state == 'pending'
+  end
+
   def refunded?
     true
   end

data/spec/dummy/app/models/payment_engines.rb

@@ -10,4 +10,8 @@ class PaymentEngines
   def self.find_payment filter
     Payment.where(filter).first
   end
+
+  def self.was_credit_card_used_before?(card_id)
+    Payment.where(state: 'paid').where("gateway_data -> 'card' ->> 'id' = ?", card_id).exists?
+  end
 end

data/spec/dummy/config/initializers/pagarme.rb

@@ -1,5 +1,6 @@
 CatarsePagarme.configure do |config|
   config.api_key =  'foo'
+  config.konduto_api_key = 'bar'
   config.slip_tax = 0
   config.credit_card_tax = 0
   config.interest_rate = 0

data/spec/models/catarse_pagarme/antifraud_order_wrapper_spec.rb

@@ -0,0 +1,366 @@
+require 'spec_helper'
+
+describe CatarsePagarme::AntifraudOrderWrapper do
+  let(:attributes) { double }
+  let(:transaction) { double }
+
+  subject { described_class.new(attributes, transaction) }
+
+  describe '#send' do
+    let(:order) { double }
+    let(:client) { double }
+    let(:response) { double }
+    let(:analyze) { true }
+
+    before do
+      allow(subject).to receive(:build_order).with(analyze: analyze).and_return(order)
+      allow(subject).to receive(:client).and_return(client)
+      allow(client).to receive(:analyze).with(order).and_return(response)
+    end
+
+    it 'sends to antifraud' do
+      expect(subject.send(analyze: analyze)).to eq response
+    end
+  end
+
+  describe '#client' do
+    context 'when @client is present' do
+      it 'returns client' do
+        client = double
+        subject.instance_variable_set('@client', client)
+
+        expect(subject.__send__(:client)).to eq client
+      end
+    end
+
+    context 'when @client isn`t present' do
+      let(:client) { double }
+
+      before do
+        allow(CatarsePagarme).to receive_message_chain('configuration.konduto_api_key').and_return('some-key')
+        allow(KondutoRuby).to receive(:new).with('some-key').and_return(client)
+      end
+
+      it 'initialize a new client' do
+        subject.instance_variable_set('@client', nil)
+
+        expect(subject.__send__(:client)).to eq client
+      end
+    end
+  end
+
+  describe '#build_order' do
+    let(:order_attributes) { { total_amount: 10 } }
+    let(:customer) { KondutoCustomer.new }
+    let(:payment) { [KondutoPayment.new] }
+    let(:billing) { KondutoAddress.new }
+    let(:shipping) { KondutoAddress.new }
+    let(:shopping_cart) { [KondutoItem.new] }
+    let(:seller) { KondutoSeller.new }
+
+    before do
+      allow(subject).to receive(:order_attributes).and_return(order_attributes)
+      allow(subject).to receive(:build_customer).and_return(customer)
+      allow(subject).to receive(:build_payment).and_return(payment)
+      allow(subject).to receive(:build_billing_address).and_return(billing)
+      allow(subject).to receive(:build_shipping_address).and_return(shipping)
+      allow(subject).to receive(:build_shopping_cart).and_return(shopping_cart)
+      allow(subject).to receive(:build_seller).and_return(seller)
+    end
+
+    it 'builds an order' do
+      order = subject.__send__(:build_order, analyze: false)
+      expect(order.total_amount).to eq order_attributes[:total_amount]
+      expect(order.analyze).to eq false
+      expect(order.customer).to eq customer
+      expect(order.payment).to eq payment
+      expect(order.billing).to eq billing
+      expect(order.shipping).to eq shipping
+      expect(order.shopping_cart).to eq shopping_cart
+      expect(order.seller).to eq seller
+    end
+  end
+
+  describe '#build_customer' do
+    let(:customer_attributes) { { name: 'John Appleseed' } }
+
+    before { allow(subject).to receive(:customer_attributes).and_return(customer_attributes) }
+
+    it 'builds a customer' do
+      customer = subject.__send__(:build_customer)
+      expect(customer.name).to eq customer_attributes[:name]
+    end
+  end
+
+  describe '#build_payment' do
+    let(:payment_attributes) { { bin: '012345' } }
+
+    before { allow(subject).to receive(:payment_attributes).and_return(payment_attributes) }
+
+    it 'builds a payment' do
+      payment = subject.__send__(:build_payment)
+      expect(payment.first.bin).to eq payment_attributes[:bin]
+    end
+  end
+
+  describe '#build_billing_address' do
+    let(:billing_address_attributes) { { address1: 'R. Tree' } }
+
+    before { allow(subject).to receive(:billing_address_attributes).and_return(billing_address_attributes) }
+
+    it 'builds an address' do
+      address = subject.__send__(:build_billing_address)
+      expect(address.address1).to eq billing_address_attributes[:address1]
+    end
+  end
+
+  describe '#build_shipping_address' do
+    let(:shipping_address_attributes) { { address1: 'R. Tree' } }
+
+    before { allow(subject).to receive(:shipping_address_attributes).and_return(shipping_address_attributes) }
+
+    it 'builds an address' do
+      address = subject.__send__(:build_shipping_address)
+      expect(address.address1).to eq shipping_address_attributes[:address1]
+    end
+  end
+
+  describe '#build_shopping_cart' do
+    let(:item_attributes) { { sku: '0102' } }
+
+    before { allow(subject).to receive(:item_attributes).and_return(item_attributes) }
+
+    it 'builds an item' do
+      item = subject.__send__(:build_shopping_cart)
+      expect(item.first.sku).to eq item_attributes[:sku]
+    end
+  end
+
+  describe '#build_seller' do
+    let(:seller_attributes) { { name: 'Catarse' } }
+
+    before { allow(subject).to receive(:seller_attributes).and_return(seller_attributes) }
+
+    it 'builds a seller' do
+      seller = subject.__send__(:build_seller)
+      expect(seller.name).to eq seller_attributes[:name]
+    end
+  end
+
+  describe '#customer_attributes' do
+    let(:attributes) do
+      {
+        customer: {
+          document_number: '1234',
+          name: 'John Appleseed',
+          email: 'john@example.com',
+          phone: { ddi: '85', ddd: '85', number: '85858585' }
+        },
+        antifraud_metadata: {
+          register: {
+            registered_at: '2019-01-01 01:01:01'
+          }
+        }
+      }
+    end
+
+    before { subject.attributes = attributes }
+
+    it 'builds customer attributes' do
+      customer_attributes = subject.__send__(:customer_attributes)
+
+      expect(customer_attributes[:id]).to eq '1234'
+      expect(customer_attributes[:name]).to eq 'John Appleseed'
+      expect(customer_attributes[:email]).to eq 'john@example.com'
+      expect(customer_attributes[:phone1]).to eq '858585858585'
+      expect(customer_attributes[:created_at]).to eq '2019-01-01 01:01:01'
+    end
+  end
+
+  describe '#payment_attributes' do
+    let(:attributes) do
+      {
+        customer: {
+          document_number: '1234',
+          name: 'John Appleseed',
+          email: 'john@example.com',
+          phone: { ddi: '85', ddd: '85', number: '85858585' }
+        },
+        antifraud_metadata: {
+          register: {
+            registered_at: '2019-01-01 01:01:01'
+          }
+        }
+      }
+    end
+
+    let(:transaction) do
+      double(status: 'authorized', card: double(first_digits: '123456', last_digits: '7890', expiration_date: '1122'))
+    end
+
+    before do
+      subject.attributes = attributes
+      subject.transaction = transaction
+    end
+
+    it 'builds customer attributes' do
+      payment_attributes = subject.__send__(:payment_attributes)
+
+      expect(payment_attributes[:type]).to eq 'credit'
+      expect(payment_attributes[:bin]).to eq '123456'
+      expect(payment_attributes[:last4]).to eq '7890'
+      expect(payment_attributes[:expiration_date]).to eq '112022'
+    end
+
+    context 'when transaction status is authorized' do
+      it 'build with approved status' do
+        payment_attributes = subject.__send__(:payment_attributes)
+        expect(payment_attributes[:status]).to eq 'approved'
+      end
+    end
+
+    context 'when transaction status isn`t authorized' do
+      let(:transaction) do
+        double(status: 'refused', card: double(first_digits: '123456', last_digits: '7890', expiration_date: '1122'))
+      end
+
+      it 'build with declined status' do
+        payment_attributes = subject.__send__(:payment_attributes)
+        expect(payment_attributes[:status]).to eq 'declined'
+      end
+    end
+  end
+
+  describe '#billing_address_attributes' do
+    let(:attributes) do
+      {
+        customer: {
+          name: 'John Appleseed'
+        },
+        antifraud_metadata: {
+          billing: {
+            address: {
+              street: 'R. A',
+              city: 'New City',
+              state: 'NC',
+              zipcode: '1245'
+            }
+          }
+        }
+      }
+    end
+
+    let(:transaction) { double(card: double(country: 'BRAZIL')) }
+
+    before do
+      subject.attributes = attributes
+      subject.transaction = transaction
+    end
+
+    it 'builds customer attributes' do
+      billing_address_attributes = subject.__send__(:billing_address_attributes)
+
+      expect(billing_address_attributes[:name]).to eq 'John Appleseed'
+      expect(billing_address_attributes[:address1]).to eq 'R. A'
+      expect(billing_address_attributes[:city]).to eq 'New City'
+      expect(billing_address_attributes[:state]).to eq 'NC'
+      expect(billing_address_attributes[:zip]).to eq '1245'
+      expect(billing_address_attributes[:country]).to eq 'BR'
+    end
+  end
+
+  describe '#shipping_address_attributes' do
+    let(:attributes) do
+      {
+        antifraud_metadata: {
+          shipping: {
+            customer: {
+              name: 'John Appleseed'
+            },
+            address: {
+              street: 'R. A',
+              city: 'New City',
+              state: 'NC',
+              zipcode: '1245'
+            }
+          }
+        }
+      }
+    end
+
+    let(:transaction) { double(card: double(country: 'BRAZIL')) }
+
+    before do
+      subject.attributes = attributes
+      subject.transaction = transaction
+    end
+
+    it 'builds customer attributes' do
+      shipping_address_attributes = subject.__send__(:shipping_address_attributes)
+
+      expect(shipping_address_attributes[:name]).to eq 'John Appleseed'
+      expect(shipping_address_attributes[:address1]).to eq 'R. A'
+      expect(shipping_address_attributes[:city]).to eq 'New City'
+      expect(shipping_address_attributes[:state]).to eq 'NC'
+      expect(shipping_address_attributes[:zip]).to eq '1245'
+    end
+  end
+
+  describe '#item_attributes' do
+    let(:attributes) do
+      {
+        amount: 1000,
+        metadata: {
+          contribution_id: 'contribution-id',
+          project_online: '2019-01-01 01:01:01'
+        },
+        antifraud_metadata: {
+          shopping_cart: [
+            { name: 'Book' }
+          ]
+        }
+      }
+    end
+
+    before { subject.attributes = attributes }
+
+    it 'builds customer attributes' do
+      item_attributes = subject.__send__(:item_attributes)
+
+      expect(item_attributes[:sku]).to eq 'contribution-id'
+      expect(item_attributes[:product_code]).to eq 'contribution-id'
+      expect(item_attributes[:category]).to eq 9999
+      expect(item_attributes[:name]).to eq 'Book'
+      expect(item_attributes[:unit_cost]).to eq 10.0
+      expect(item_attributes[:quantity]).to eq 1
+      expect(item_attributes[:created_at]).to eq '2019-01-01'
+    end
+  end
+
+
+  describe '#seller_attributes' do
+    let(:attributes) do
+      {
+        antifraud_metadata: {
+          events: [
+            {
+              id: 'event-id',
+              venue_name: 'Autor',
+              date: '2019-01-01'
+            }
+          ]
+        }
+      }
+    end
+
+    before { subject.attributes = attributes }
+
+    it 'builds customer attributes' do
+      seller_attributes = subject.__send__(:seller_attributes)
+
+      expect(seller_attributes[:id]).to eq 'event-id'
+      expect(seller_attributes[:name]).to eq 'Autor'
+      expect(seller_attributes[:created_at]).to eq '2019-01-01'
+    end
+  end
+end

data/spec/models/catarse_pagarme/credit_card_transaction_spec.rb

@@ -3,19 +3,6 @@ require 'spec_helper'
 describe CatarsePagarme::CreditCardTransaction do
   let(:payment) { create(:payment, value: 100) }
 
-  let(:pagarme_transaction) {
-    double({
-      id: 'abcd',
-      charge: true,
-      status: 'paid',
-      boleto_url: nil,
-      installments: 3,
-      acquirer_name: 'stone',
-      tid: '123123',
-      card_brand: 'visa'
-    })
-  }
-
   let(:valid_attributes) do
       {
         payment_method: 'credit_card',
@@ -33,54 +20,255 @@ describe CatarsePagarme::CreditCardTransaction do
   let(:card_transaction) { CatarsePagarme::CreditCardTransaction.new(valid_attributes, payment) }
 
   before do
-    PagarMe::Transaction.stub(:new).and_return(pagarme_transaction)
+    # PagarMe::Transaction.stub(:new).and_return(pagarme_transaction)
     CatarsePagarme::PaymentDelegator.any_instance.stub(:change_status_by_transaction).and_return(true)
     CatarsePagarme.configuration.stub(:credit_card_tax).and_return(0.01)
   end
 
-  describe '#charge!' do
-    describe 'with valid attributes' do
+  describe '#process!' do
+    let(:transaction) { double(status: 'refused') }
+
+    before do
+      allow(card_transaction).to receive(:transaction).and_return(transaction)
+      allow(card_transaction).to receive(:authorize!).and_return(true)
+      allow(card_transaction).to receive(:change_payment_state).and_return(true)
+    end
+
+    it 'authorizes transaction' do
+      expect(card_transaction).to receive(:authorize!)
+      card_transaction.process!
+    end
+
+    context 'when transaction is authorized' do
+      let(:transaction) { double(status: 'authorized', capture: true, refund: true) }
+
+      context 'when credit card was used before' do
+        before { allow(card_transaction).to receive(:was_credit_card_used_before?).and_return(true) }
+
+        it 'captures transaction' do
+          expect(card_transaction.transaction).to receive(:capture)
+
+          card_transaction.process!
+        end
+      end
+
+      context 'when is a new credit credit card' do
+        let(:antifraud_outcome) { double(recommendation: :APPROVE) }
+
+        before do
+          allow(card_transaction).to receive(:was_credit_card_used_before?).and_return(false)
+          allow(card_transaction).to receive(:process_antifraud).and_return(antifraud_outcome)
+        end
+
+        it 'processes antifraud' do
+          expect(card_transaction).to receive(:process_antifraud)
+
+          card_transaction.process!
+        end
+
+        context 'when antifraud recommends approve transaction' do
+          let(:antifraud_outcome) { double(recommendation: :APPROVE) }
+
+          it 'captures transaction' do
+            expect(card_transaction.transaction).to receive(:capture)
+
+            card_transaction.process!
+          end
+        end
+
+        context 'when antifraude recommends decline transaction' do
+          let(:antifraud_outcome) { double(recommendation: :DECLINE) }
+
+          it 'refunds transaction' do
+            expect(card_transaction.transaction).to receive(:refund)
+
+            card_transaction.process!
+          end
+        end
+      end
+    end
+
+    it 'changes payment state' do
+      expect(card_transaction).to receive(:change_payment_state)
+
+      card_transaction.process!
+    end
+  end
+
+  describe '#authorize!' do
+    let(:attributes) do
+      { amount: 10, card_hash: 'capgojepaogejpeoajgpeaoj124pih3p4h32p', postback_url: 'https://example.com/postback' }
+    end
+
+    let(:transaction) do
+      PagarMe::Transaction.new(
+        amount: attributes[:amount],
+        card_hash: attributes[:card_hash],
+        capture: false,
+        async: false,
+        postback_url: attributes[:postback_url]
+      )
+    end
+
+    before do
+      card_transaction.attributes = attributes
+      allow_any_instance_of(PagarMe::Transaction).to receive(:charge).and_return(true)
+      allow(card_transaction).to receive(:change_payment_state).and_return(true)
+    end
+
+    it 'build a new pagarme transaction' do
+      transaction_attributes = {
+        amount: attributes[:amount],
+        card_hash: attributes[:card_hash],
+        capture: false,
+        async: false,
+        postback_url: attributes[:postback_url]
+      }
+
+      allow(PagarMe::Transaction).to receive(:new).with(transaction_attributes).and_return(transaction)
+
+      card_transaction.authorize!
+
+      expect(card_transaction.transaction).to eq transaction
+    end
+
+    it 'updates payment gateway and payment_method' do
+      card_transaction.authorize!
+
+      expect(payment.gateway).to eq 'Pagarme'
+      expect(payment.payment_method).to eq 'CartaoDeCredito'
+    end
+
+    it 'charges transaction' do
+      allow(PagarMe::Transaction).to receive(:new).and_return(transaction)
+      expect(transaction).to receive(:charge)
+
+      card_transaction.authorize!
+    end
+
+    it 'changes payment state' do
+      expect(card_transaction).to receive(:change_payment_state)
+
+      card_transaction.authorize!
+    end
+
+    context 'when transaction status is refused' do
       before do
-        payment.should_receive(:update_attributes).at_least(1).and_call_original
-        PagarMe::Transaction.should_receive(:find_by_id).with(pagarme_transaction.id).and_return(pagarme_transaction)
-        CatarsePagarme::PaymentDelegator.any_instance.should_receive(:change_status_by_transaction).with('paid')
+        allow_any_instance_of(PagarMe::Transaction).to receive(:status).and_return('refused')
+        allow(card_transaction.antifraud_wrapper).to receive(:send).with(analyze: false).and_return(true)
+      end
+
+      it 'sends to antifraud' do
+        expect(card_transaction.antifraud_wrapper).to receive(:send).with(analyze: false)
 
-        card_transaction.charge!
-        payment.reload
+        card_transaction.authorize! rescue nil
       end
 
-      it "should update payment payment_id" do
-        expect(payment.gateway_id).to eq('abcd')
+      it 'raises PagarMeError exception' do
+        expect do
+          card_transaction.authorize!
+        end.to raise_error(PagarMe::PagarMeError)
       end
+    end
+
+    context 'when save_card attribute is true' do
+      it 'saves credit card' do
+        card_transaction.attributes[:save_card] = true
+        expect(card_transaction).to receive(:save_user_credit_card)
 
-      it "should update payment payment_service_fee" do
-        expect(payment.gateway_fee).to eq(payment.pagarme_delegator.get_fee)
+        card_transaction.authorize!
       end
+    end
+
+    context 'when save_card attribute is false' do
+      it 'does`t save credit card' do
+        card_transaction.attributes[:save_card] = false
+        expect(card_transaction).to_not receive(:save_user_credit_card)
 
-      it "should update payment payment_method" do
-        expect(payment.gateway).to eq('Pagarme')
+        card_transaction.authorize!
       end
+    end
+  end
+
+  describe '#was_credit_card_used_before?' do
+    let(:transaction) { double(card: double(id: '123')) }
 
-      it "should update payment installments" do
-        expect(payment.installments).to eq(3)
+    before { card_transaction.transaction = transaction }
+
+    context 'when credit card was used before' do
+      before do
+        allow(PaymentEngines).to receive(:was_credit_card_used_before?)
+          .with(transaction.card.id)
+          .and_return(true)
       end
 
-      it "should update payment payment_choice" do
-        expect(payment.payment_method).to eq(CatarsePagarme::PaymentType::CREDIT_CARD)
+      it 'returns true' do
+        expect(card_transaction.was_credit_card_used_before?).to be_truthy
       end
+    end
 
-      it "should update payment acquirer_name" do
-        expect(payment.gateway_data["acquirer_name"]).to eq('stone')
+    context 'when credit card wasn`t used before' do
+      before do
+        allow(PaymentEngines).to receive(:was_credit_card_used_before?)
+          .with(transaction.card.id)
+          .and_return(false)
       end
 
-      it "should update payment acquirer_tid" do
-        expect(payment.gateway_data["acquirer_tid"]).to eq('123123')
+      it 'returns false' do
+        expect(card_transaction.was_credit_card_used_before?).to be_falsey
       end
+    end
+  end
+
+  describe '#process_antifraud' do
+    it 'sends antifraud order' do
+      expect(card_transaction.antifraud_wrapper).to receive(:send).with(analyze: true).once
+
+      card_transaction.process_antifraud
+    end
+
+    context 'when there is an error' do
+      let(:exception) { RuntimeError.new('Error') }
+      before { allow(card_transaction.antifraud_wrapper).to receive(:send).and_raise(exception) }
 
-      it "should update payment installment_value" do
-        expect(payment.installment_value).to_not be_nil
+      it 'captures exception with Raven' do
+        expect(Raven).to receive(:capture_exception).with(exception)
+
+        card_transaction.process_antifraud
+      end
+
+      it 'returns a struct with decline recommendation' do
+        outcome = card_transaction.process_antifraud
+
+        expect(outcome.recommendation).to eq :DECLINE
       end
     end
   end
 
+  describe '#antifraud_wrapper' do
+    let(:antifraud_wrapper) { double }
+
+    context 'when @antifraud_wrapper isn`t nil' do
+      it 'returns @antifraude_wrapper' do
+        card_transaction.instance_variable_set('@antifraud_wrapper', antifraud_wrapper)
+        expect(card_transaction.antifraud_wrapper).to eq antifraud_wrapper
+      end
+    end
+
+    context 'when @antifraud_wrapper is nil' do
+      let(:transaction) { double }
+
+      before do
+        card_transaction.instance_variable_set('@antifraud_wrapper', nil)
+        card_transaction.transaction = transaction
+        allow(CatarsePagarme::AntifraudOrderWrapper).to receive(:new)
+          .with(valid_attributes, transaction)
+          .and_return(antifraud_wrapper)
+      end
+
+      it 'returns a new antifraud order wrapper' do
+        expect(card_transaction.antifraud_wrapper).to eq antifraud_wrapper
+      end
+    end
+  end
 end