pagarme 2.0.2 → 2.1.0

data/test/pagarme/resources/transaction_test.rb

@@ -0,0 +1,221 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class TransactionTest < Test::Unit::TestCase
+    def setup
+      super
+      ensure_positive_balance
+    end
+
+    should 'be able to charge' do
+      transaction = PagarMe::Transaction.new transaction_with_customer_with_card_params
+      assert_equal transaction.status, 'local'
+
+      transaction.charge
+      assert_transaction_successfully_paid transaction
+    end
+
+    should 'be able to set postback url' do
+      transaction = PagarMe::Transaction.create transaction_with_customer_with_card_with_postback_params
+      assert_transaction_successfully_processing transaction
+    end
+
+    should 'not be able to charge when refused card' do
+      transaction = PagarMe::Transaction.new transaction_with_customer_with_refused_card_params
+      assert_equal transaction.status, 'local'
+
+      transaction.charge
+      assert_transaction_refused_by_acquirer transaction
+    end
+
+    should 'be able to charge with a saved card' do
+      card        = PagarMe::Card.create card_params
+      transaction = PagarMe::Transaction.charge customer_params(card: card, amount: 1000)
+      assert_transaction_successfully_paid transaction
+    end
+
+    should 'be able to charge with an unsaved card' do
+      card        = PagarMe::Card.new card_params
+      transaction = PagarMe::Transaction.charge customer_params(card: card, amount: 1000)
+      assert_transaction_successfully_paid transaction
+    end
+
+    should 'be able to refund' do
+      transaction = PagarMe::Transaction.charge transaction_with_customer_with_card_params
+      assert_transaction_successfully_paid transaction
+
+      transaction.refund
+      assert_equal transaction.status, 'refunded'
+    end
+
+    should 'be able to create transaciton with boleto' do
+      transaction = PagarMe::Transaction.charge transaction_with_boleto_params
+      assert_transaction_with_bolelo_on_waiting_payment transaction
+    end
+
+    should 'be able to send and retrieve metadata' do
+      metadata = {
+        'metadata' => {
+          'event' => {
+            'id'   => 335,
+            'name' => 'Evento foda'
+          }
+        }
+      }
+      transaction = PagarMe::Transaction.charge transaction_with_customer_with_card_params(metadata)
+      assert_equal transaction.metadata.to_hash, metadata['metadata']
+
+      found_transaction = PagarMe::Transaction.find_by_id transaction.id
+      assert_equal found_transaction.metadata.to_hash, metadata['metadata']
+    end
+
+    should 'be able to find a transaction' do
+      transaction = PagarMe::Transaction.charge transaction_with_customer_with_card_params
+      assert_transaction_successfully_paid transaction
+
+      other_transaction = PagarMe::Transaction.find_by_id transaction.id
+      assert_equal transaction.id, other_transaction.id
+      assert_equal transaction,    other_transaction
+    end
+
+    should 'raise an error when nil or empty string as ID' do
+      assert_raises RequestError do
+        PagarMe::Transaction.find_by_id nil
+      end
+
+      assert_raises RequestError do
+        PagarMe::Transaction.find_by_id ''
+      end
+    end
+
+    should 'require parameters on the refund with boleto' do
+      transaction = PagarMe::Transaction.create transaction_with_boleto_params
+      assert_equal transaction.status, 'waiting_payment'
+
+      assert_raises(PagarMe::ValidationError){ transaction.refund }
+      assert_raises(PagarMe::ValidationError){ transaction.refund refund_bank_account_params }
+      assert_equal transaction.status, 'waiting_payment'
+
+      transaction.status = 'paid'
+      transaction.save
+      assert_equal transaction.status, 'paid'
+
+      assert_raises(PagarMe::ValidationError){ transaction.refund }
+      assert_equal transaction.status, 'paid'
+
+      transaction.refund refund_bank_account_params
+      assert_equal transaction.status, 'pending_refund'
+
+      found_transaction = PagarMe::Transaction.find_by_id transaction.id
+      assert_equal found_transaction.status, 'pending_refund'
+    end
+
+    should 'be able to create transaction with customer' do
+      transaction = PagarMe::Transaction.charge transaction_with_card_with_customer_params
+      assert_transaction_with_customer_successfully_paid transaction
+    end
+
+    should 'be able to refund transaction with customer' do
+      transaction = PagarMe::Transaction.charge transaction_with_card_with_customer_params
+      assert_transaction_with_customer_successfully_paid transaction
+
+      transaction.refund
+      assert_equal transaction.status, 'refunded'
+    end
+
+    should 'be able to capture a transaction and pass an amount' do
+      transaction = PagarMe::Transaction.charge transaction_with_customer_with_card_params(capture: false, amount: 2000)
+      assert_equal transaction.status,          'authorized'
+      assert_equal transaction.amount,          2000
+      assert_equal transaction.paid_amount,     0
+      assert_equal transaction.refunded_amount, 0
+
+      transaction.capture amount: 1000
+      assert_equal transaction.status,          'paid'
+      assert_equal transaction.amount,          2000
+      assert_equal transaction.paid_amount,     1000
+      assert_equal transaction.refunded_amount, 0
+    end
+
+    should 'validate transaction with invalid card_number' do
+      exception = assert_raises PagarMe::ValidationError do
+        PagarMe::Transaction.charge transaction_with_card_params(card_number: '123456')
+      end
+      assert exception.errors.any?{ |error| error.parameter_name == 'card_number' }
+    end
+
+    should 'validate transaction missing card_holder_name' do
+      exception = assert_raises PagarMe::ValidationError do
+        params = {
+          card_number: '4111111111111111',
+          amount:      '1000'
+        }
+        PagarMe::Transaction.charge params
+      end
+      assert exception.errors.any?{ |error| error.parameter_name == 'card_holder_name' }
+    end
+
+    should 'validate transaction with invalid expiracy month' do
+      exception = assert_raises PagarMe::ValidationError do
+        params = {
+          card_number:         '4111111111111111',
+          card_holder_name:    'Jose da Silva',
+          amount:              '1000',
+          card_expiracy_month: 15
+        }
+        PagarMe::Transaction.charge params
+      end
+      assert exception.errors.any?{ |error| error.parameter_name == 'card_expiration_date' }
+    end
+
+    should 'validate transaction invalid expiracy year' do
+      exception = assert_raises PagarMe::ValidationError do
+        params = {
+          card_number:           '4111111111111111',
+          card_holder_name:      'Jose da Silva',
+          amount:                '1000',
+          card_expiration_month: 12,
+          card_expiration_year:  -1,
+        }
+        PagarMe::Transaction.charge params
+      end
+      assert exception.errors.any?{ |error| error.parameter_name == 'card_expiration_date' }
+    end
+
+    should 'validate transaction missing cvv' do
+      exception = assert_raises PagarMe::ValidationError do
+        params = {
+          card_number:           '4111111111111111',
+          card_holder_name:      'Jose da Silva',
+          amount:                '1000',
+          card_expiration_month: 12,
+          card_expiration_year:  16,
+        }
+        PagarMe::Transaction.charge params
+      end
+      assert exception.errors.any?{ |error| error.parameter_name == 'card_cvv' }
+    end
+
+    should 'be able to split transaction' do
+      transaction = PagarMe::Transaction.charge transaction_with_customer_with_card_with_split_rules_params
+      assert_split_rules transaction.split_rules
+    end
+
+    should 'raise error when there is an invalid split rule' do
+      assert_raises PagarMe::ValidationError do
+        PagarMe::Transaction.charge transaction_with_card_with_invalid_split_rules_params
+      end
+    end
+
+    should 'calculate installments' do
+      amount = 10000
+      result = PagarMe::Transaction.calculate_installments amount: amount, interest_rate: 0
+
+      assert_equal result['installments'].size, 12
+      (1..12).each do |i|
+        installment = (amount.to_f/i).round
+        assert_equal result['installments'][i.to_s]['installment_amount'], installment
+      end
+    end
+  end
+end

data/test/pagarme/resources/transfer_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class TransferTest < Test::Unit::TestCase
+    def setup
+      super
+      ensure_positive_balance
+    end
+
+    should 'be able to create a transfer' do
+      transfer = PagarMe::Transfer.create transfer_params
+      assert_transfer transfer
+    end
+
+    should 'be able to find with id' do
+      transfer = PagarMe::Transfer.create transfer_params
+      assert_transfer transfer
+
+      found_transfer = PagarMe::Transfer.find_by_id transfer.id
+      assert_transfer found_transfer
+    end
+  end
+end

data/test/pagarme/resources/zipcode_test.rb

@@ -0,0 +1,15 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class ZipcodeTest < Test::Unit::TestCase
+    should 'be able find a zipcode' do
+      zipcode = PagarMe::Zipcode.find '12228-462'
+
+      assert_equal zipcode.city,         'São José dos Campos'
+      assert_equal zipcode.neighborhood, 'Campus do CTA'
+      assert_equal zipcode.state,        'SP'
+      assert_equal zipcode.street,       'Rua H8C'
+      assert_equal zipcode.zipcode,      '12228462'
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,192 +1,69 @@
-require_relative '../lib/pagarme'
 require 'test/unit'
 require 'shoulda'
+require 'webmock'
+require 'pry'
+require 'vcr'
 
-def test_transaction(params = {})
-  return PagarMe::Transaction.new({
-    :card_number => "4901720080344448",
-    :card_holder_name => "Jose da Silva",
-    :card_expiration_month => "10",
-    :card_expiration_year => "15",
-    :card_cvv => "314",
-    :amount => 1000
-  }.merge(params))
-end
-
-def test_transfer(params = {})
-  return PagarMe::Transfer.new({
-    amount: 1000,
-  }.merge(params))
-end
-
-def test_card(params = {})
-  return PagarMe::Card.new({
-	:card_number => '4111111111111111',
-	:card_holder_name => 'Jose da Silva',
-	:card_expiration_month => '10',
-	:card_expiration_year => '15',
-	:card_cvv => '314'
-  }.merge(params))
-end
-
-def test_subscription_without_plan(params = {})
-  return PagarMe::Subscription.new({
-    :payment_method => 'credit_card',
-    :card_number => "4901720080344448",
-    :card_holder_name => "Jose da Silva",
-    :card_expiration_month => "10",
-    :card_expiration_year => "15",
-    :card_cvv => "314",
-    :postback_url => "http://test.com/postback",
-    :customer => {
-      :email => 'customer@pagar.me'
-    }
-  }.merge(params))
-end
-
-def test_plan(params = {})
-  return PagarMe::Plan.new({
-    :name => "Plano gold",
-    :trial_days => 5,
-    :days => 30,
-    :amount => 3000,
-  }.merge(params))
-end
-
-def test_bank_account(params = {})
-  return PagarMe::BankAccount.new({
-    :bank_code => '237',
-    :agencia => '1935',
-    :agencia_dv => '9',
-    :conta => '23398',
-    :conta_dv => '9',
-    :legal_name => 'foo bar loem',
-    :document_number => '00000000000000'
-  }.merge(params))
+require_relative '../lib/pagarme'
+require_relative 'assertions'
+require_relative 'fixtures'
+
+VCR.configure do |config|
+  config.cassette_library_dir                         = 'test/vcr_cassettes'
+  config.default_cassette_options[:match_requests_on] = [:method, :uri, :host, :path, :query, :body, :headers]
+  config.default_cassette_options[:record]            = :new_episodes
+  config.hook_into :webmock
 end
 
-def test_subscription(params = {})
-  return PagarMe::Subscription.new({
-    :payment_method => 'credit_card',
-    :card_number => "4901720080344448",
-    :card_holder_name => "Jose da Silva",
-    :card_expiration_month => "10",
-    :card_expiration_year => "15",
-    :card_cvv => "314",
-    :postback_url => "http://test.com/postback",
-    :customer => {
-      email: 'customer@pagar.me'
-    }
-  }.merge(params))
-end
+class Test::Unit::TestCase
+  FIXED_API_KEY = 'ak_test_Q2D2qDYGJSyeR1KbI4sLzGACEr73MF'
 
-def test_transaction_with_customer(params = {})
-  return PagarMe::Transaction.new({
-    :amount => 1000,
-    :card_number => '4901720080344448',
-    :card_holder_name => "Jose da Silva",
-    :card_expiration_month => "11",
-    :card_expiration_year => "19",
-    :card_cvv => "356",
-    :customer => {
-      :name => "Jose da Silva",
-      :document_number => "36433809847",
-      :email => "henrique+test@pagar.me",
-      :address => {
-        :street => 'Av. Brigadeiro Faria Lima',
-        :neighborhood => 'Itaim bibi',
-        :zipcode => '01452000',
-        :street_number => "2941",
-      },
-      :phone => {
-        :ddd => "12",
-        :number => '981433533',
-      },
-      :sex => 'M',
-      :born_at => '1970-10-11'
-    }
-  }.merge(params))
-end
+  include Fixtures::Helpers
+  include Assertions
 
-def test_subscription_with_customer(params = {})
-  return PagarMe::Subscription.new({
-    :amount => 1000,
-    :card_number => '4901720080344448',
-    :card_holder_name => "Jose da silva",
-    :card_expiration_month => "11",
-    :card_expiration_year => "19",
-    :card_cvv => "356",
-    :customer => {
-      :name => "Jose da Silva",
-      :document_number => "36433809847",
-      :email => "henrique@pagar.me",
-      :address => {
-        :street => 'Av. Brigadeiro Faria Lima',
-        :neighborhood => 'Itaim bibi',
-        :zipcode => '01452000',
-        :street_number => "1000",
-      } ,
-      :phone => {
-        :ddd => "12",
-        :number => '981444444',
-      } ,
-      :sex => 'M',
-      :born_at => '1970-10-11'
-    }
-  }.merge(params))
-end
+  def setup
+    PagarMe.api_key = temporary_api_key
+  end
 
+  def teardown
+    PagarMe.api_key = nil
+  end
 
-def test_customer_response(customer)
-  assert customer.id
-  assert customer.document_type == 'cpf'
-  assert customer.name == 'Jose da Silva'
-  assert customer.born_at
-  assert customer.id
-end
+  protected
+  def ensure_positive_balance
+    VCR.use_cassette 'TestCase/ensure_positive_balance' do
+      transaction = PagarMe::Transaction.charge transaction_with_boleto_params(amount: 100_000_00)
+      transaction.status = :paid
+      transaction.save
+    end
+  end
 
-def test_subscription_transaction_response(transaction, amount = nil, installments = nil)
-	amount ||= 2000
-	installments ||= 1
-  assert transaction.id
-  assert !transaction.refuse_reason
-  assert transaction.date_created
-  assert transaction.amount == amount
-  assert transaction.installments.to_i == installments
-  # assert transaction.card_brand == 'visa'
-  assert transaction.payment_method == 'credit_card'
-  assert transaction.status == 'paid'
-  assert !transaction.boleto_url
-  assert !transaction.boleto_barcode
-end
+  def ensure_waiting_funds
+    VCR.use_cassette 'TestCase/ensure_waiting_funds' do
+      PagarMe::Transaction.create transaction_with_customer_with_card_params(amount: 10_000_00, installments: 12)
+    end
+  end
 
-def test_transaction_response(transaction)
-  assert transaction.id
-  assert transaction.card_holder_name
-  assert !transaction.refuse_reason
-  assert transaction.date_created
-  assert transaction.amount == 1000
-  assert transaction.installments.to_i == 1
-  assert transaction.card_holder_name == 'Jose da Silva'
-  # assert transaction.card_brand == 'visa'
-  assert transaction.payment_method == 'credit_card'
-  assert transaction.status == 'paid'
-end
+  def fixed_api_key
+    PagarMe.api_key = FIXED_API_KEY
+    yield
+    PagarMe.api_key = temporary_api_key
+  end
 
-def test_plan_response(plan)
-  assert plan.id
-  assert plan.name == 'Plano gold'
-  assert plan.trial_days == 5
-  assert plan.days == 30
-  assert plan.amount = 3000
-end
+  def temporary_api_key
+    return FIXED_API_KEY
 
-class Test::Unit::TestCase
-  def setup
-    PagarMe.api_key="ak_test_Rw4JR98FmYST2ngEHtMvVf5QJW7Eoo"
+    # TODO: Unfortunately, it's right now impossible to create
+    # temporary companies properly pre-configured to run all tests
+    VCR.use_cassette 'TestCase/tmp_company_api_key' do
+      PagarMe.api_key = FIXED_API_KEY
+      Company.temporary.api_key.test
+    end
   end
 
-  def teardown
-    PagarMe.api_key=nil
+  # Monkey Patch that adds VCR everywhere
+  def self.should(description, &block)
+    cassette_name = "#{ self.name.split('::').last }/should_#{ description.gsub /\s+/, '_' }"
+    super(description){ VCR.use_cassette(cassette_name){ self.instance_exec &block } }
   end
 end