pagarme 2.0.2 → 2.1.0

data/test/pagarme/error_test.rb

@@ -0,0 +1,13 @@
+require_relative '../test_helper'
+
+module PagarMe
+  class ErrorTest < Test::Unit::TestCase
+    should 'be able to handle single error messages' do
+      assert_transaction_errors card_number: nil
+    end
+
+    should 'be able to handle multiple error messages' do
+      assert_transaction_errors amount: 10, card_expiration_year: 12
+    end
+  end
+end

data/test/pagarme/object_test.rb

@@ -0,0 +1,19 @@
+require_relative '../test_helper'
+
+module PagarMe
+  class ObjectTest < Test::Unit::TestCase
+    should 'be able to create object and add any attribute' do
+      object = PagarMe::PagarMeObject.new attr1: 2
+      assert_equal object.attr1, 2
+
+      object       = PagarMe::PagarMeObject.new
+      object.attr1 = 2
+      assert_equal object.attr1, 2
+    end
+
+    should 'be able to add nested attributes' do
+      object = PagarMe::PagarMeObject.new nested: { attrib: 2 }
+      assert_equal object.nested.attrib, 2
+    end
+  end
+end

data/test/pagarme/pagarme_test.rb

@@ -0,0 +1,10 @@
+require_relative '../test_helper'
+
+module PagarMe
+  class PagarMeTest < Test::Unit::TestCase
+    should 'validate fingerprint correctly' do
+      finderprint = Digest::SHA1.hexdigest "123##{PagarMe.api_key}"
+      assert PagarMe.validate_fingerprint(123, finderprint)
+    end
+  end
+end

data/test/pagarme/resources/balance_test.rb

@@ -0,0 +1,46 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class BalanceTest < Test::Unit::TestCase
+
+    should 'change amount amount after transaction being paid' do
+      transaction      = PagarMe::Transaction.charge transaction_with_boleto_params
+      previous_balance = PagarMe::Balance.balance
+
+      transaction.status = :paid
+      transaction.save
+
+      balance = PagarMe::Balance.balance
+      assert_increased_available_amount previous_balance, balance
+    end
+
+    should 'change recipient amount after transaction being paid' do
+      recipient   = PagarMe::Recipient.create recipient_with_nested_bank_account_params
+      split_rules = [ { recipient_id: recipient.id, percentage: 100 } ]
+      transaction = PagarMe::Transaction.charge transaction_with_boleto_params(split_rules: split_rules)
+
+      assert_empty_balance recipient.balance
+
+      transaction.status = :paid
+      transaction.save
+
+      assert_available_balance recipient.balance
+    end
+
+    should 'change recipient amount after recipient receive money' do
+      recipient   = PagarMe::Recipient.create recipient_with_nested_bank_account_params
+      split_rules = [ { recipient_id: recipient.id, percentage: 100 } ]
+      transaction = PagarMe::Transaction.charge transaction_with_boleto_params(split_rules: split_rules)
+
+      assert_empty_balance recipient.balance
+
+      transaction.status = :paid
+      transaction.save
+
+      recipient.receive recipient.balance.available.amount
+
+      assert_transfered_balance recipient.balance
+    end
+
+  end
+end

data/test/pagarme/resources/bank_account_test.rb

@@ -0,0 +1,35 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class BankAccountTest < Test::Unit::TestCase
+    should 'be able to create a bank_account' do
+      bank_account = PagarMe::BankAccount.create bank_account_params
+      assert_equal bank_account.bank_code, '237'
+    end
+
+    should 'be able to search by anything' do
+      bank_account  = PagarMe::BankAccount.create bank_account_params
+      bank_accounts = PagarMe::BankAccount.find_by bank_code: '237'
+
+      assert bank_accounts.size > 0
+      bank_accounts.each do |b|
+        assert_equal b.bank_code, '237'
+      end
+    end
+
+    {
+      bank_code:       'foo',
+      agencia:         'abcd',
+      agencia_dv:      'Y',
+      conta:           'ABCD',
+      conta_dv:        '',
+      legal_name:      '',
+      document_number: 'foooo'
+    }.each do |key, value|
+      should "validate bank_account - #{key}" do
+        exception = assert_raises(PagarMe::ValidationError){ BankAccount.create key => value }
+        assert_has_error_param exception, key.to_s
+      end
+    end
+  end
+end

data/test/pagarme/resources/bulk_anticipation_test.rb

@@ -0,0 +1,72 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class BulkAnticipationTest < Test::Unit::TestCase
+
+    def setup
+      super
+      ensure_waiting_funds
+    end
+
+    should 'be able to calculate anticipations limits' do
+      assert_anticipation_limits PagarMe::Recipient.default.bulk_anticipations_limits(anticipations_limits_params)
+    end
+
+    should 'be able to request anticipation and cancel it' do
+      recipient    = PagarMe::Recipient.default
+      anticipation = recipient.bulk_anticipate anticipation_params
+
+      assert_anticipation anticipation
+      assert_anticipation BulkAnticipation.find(recipient.id, anticipation.id)
+
+      anticipation.cancel
+      assert_canceled_anticipation anticipation
+
+      anticipation = recipient.bulk_anticipate anticipation_params
+      assert_canceled_anticipation PagarMe::BulkAnticipation.cancel(recipient.id, anticipation.id)
+    end
+
+    should 'have bulk anticipations on default recipient ' do
+      recipient = PagarMe::Recipient.default
+      assert recipient.bulk_anticipations.count > 0
+    end
+
+    should 'create a building anticipation an later confirm it' do
+      recipient    = PagarMe::Recipient.default
+      anticipation = recipient.bulk_anticipate anticipation_params(build: true)
+      assert_equal anticipation.id, BulkAnticipation.confirm(recipient.id, anticipation.id).id
+
+      anticipation = recipient.bulk_anticipate anticipation_params(build: true)
+      assert_equal anticipation.id, anticipation.confirm.id
+    end
+
+    should 'create a building anticipation an later delete it' do
+      recipient    = PagarMe::Recipient.default
+      anticipation = recipient.bulk_anticipate anticipation_params(build: true)
+
+      assert_equal anticipation.id, PagarMe::BulkAnticipation.find(recipient.id, anticipation.id).id
+      PagarMe::BulkAnticipation.delete(recipient.id, anticipation.id).id
+      assert_raises PagarMe::NotFound do
+        PagarMe::BulkAnticipation.find recipient.id, anticipation.id
+      end
+
+      anticipation = recipient.bulk_anticipate anticipation_params(build: true)
+      assert_equal anticipation.id, PagarMe::BulkAnticipation.find(recipient.id, anticipation.id).id
+      anticipation.delete
+      assert_raises PagarMe::NotFound do
+        PagarMe::BulkAnticipation.find recipient.id, anticipation.id
+      end
+    end
+
+    protected
+    def anticipation_params(params = Hash.new)
+      anticipations_limits_params(reasonable_amount).merge params
+    end
+
+    def reasonable_amount
+      limits = PagarMe::Recipient.default.bulk_anticipations_limits(anticipations_limits_params)
+      { requested_amount: (limits.maximum.amount + 9*limits.minimum.amount)/10 + 1 }
+    end
+
+  end
+end

data/test/pagarme/resources/card_test.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class CardTest < Test::Unit::TestCase
+    should 'be able to create' do
+      card = PagarMe::Card.create card_params
+
+      assert       card.id
+      assert_equal card.first_digits, '490172'
+      assert_equal card.last_digits,  '4448'
+    end
+
+    should 'be able to find by id' do
+      card       = PagarMe::Card.create card_params
+      found_card = PagarMe::Card.find_by_id card.id
+
+      assert_equal card.id,           found_card.id
+      assert_equal card.first_digits, found_card.first_digits
+      assert_equal card.last_digits,  found_card.last_digits
+    end
+  end
+end

data/test/pagarme/resources/payable_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class PayableTest < Test::Unit::TestCase
+    should 'be created setting default recipient on payable' do
+      transaction = PagarMe::Transaction.create transaction_with_customer_with_card_params
+      payable     = transaction.payables.first
+
+      assert_equal transaction.payables.count, 1
+      assert_equal payable.recipient_id, PagarMe::Recipient.default.id
+    end
+
+    should 'create one per split rule' do
+      transaction = PagarMe::Transaction.create transaction_with_customer_with_card_with_split_rules_params
+      payable     = transaction.payables.first
+
+      assert_equal transaction.payables.count, 4
+      assert_equal transaction.payables.map(&:recipient_id).sort, fixtures.persistent_recipient_ids.sort
+    end
+
+    should 'create be found' do
+      payables = PagarMe::Payable.find_by type: 'refund'
+
+      assert payables.count > 0
+      payables.each do |payable|
+        assert_equal payable.type, 'refund'
+      end
+    end
+  end
+end

data/test/pagarme/resources/plan_test.rb

@@ -0,0 +1,57 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class PlanTest < Test::Unit::TestCase
+    should 'be able to create a plan' do
+      plan = PagarMe::Plan.create plan_params
+      assert_plan_created plan
+    end
+
+    should 'be able to update plan' do
+      plan = PagarMe::Plan.create plan_params
+      assert_plan_created plan
+
+      plan.name = 'plano bronze'
+      plan.save
+      assert_equal plan.name, 'plano bronze'
+    end
+
+    should 'be able to search by anything' do
+      plan = PagarMe::Plan.create plan_params
+      assert_plan_created plan
+
+      # find_by_hash is possibly consistent, wait to try to ensure!!!
+      sleep 1
+      found_plans = PagarMe::Plan.find_by trial_days: 5
+
+      assert found_plans.size > 0
+      found_plans.each do |plan|
+        assert_equal plan.trial_days, 5
+      end
+    end
+
+    should 'validate plan amount' do
+      exception = assert_raises(PagarMe::ValidationError){ Plan.create amount: -1 }
+      assert_has_error_param exception, 'amount'
+    end
+
+    should 'validate plan days' do
+      exception = assert_raises(PagarMe::ValidationError){ Plan.create amount: 1000, days: -1 }
+      assert_has_error_param exception, 'days'
+    end
+
+    should 'validate plan with missing name' do
+      exception = assert_raises(PagarMe::ValidationError){ Plan.create amount: 1000, days: 20 }
+      assert_has_error_param exception, 'name'
+    end
+
+    should 'not be possible to edit days' do
+      plan = Plan.create amount: 1000, days: 20, name: 'Plano Platinum'
+      exception = assert_raises(PagarMe::ValidationError) do
+        plan.days = 30
+        plan.save
+      end
+      assert_has_error_param exception, 'days'
+    end
+  end
+end

data/test/pagarme/resources/postback_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class TransactionTest < Test::Unit::TestCase
+    should 'be valid when has valid fingerprint' do
+      fixed_api_key do
+        postback = PagarMe::Postback.new postback_response_params
+        assert postback.valid?
+      end
+    end
+
+    should 'be valid when has invalid fingerprint' do
+      invalid_fingerprint = Digest::SHA1.hexdigest 'Invalid Fingerprint!'
+      postback = PagarMe::Postback.new postback_response_params(fingerprint: invalid_fingerprint)
+      assert !postback.valid?
+    end
+  end
+end

data/test/pagarme/resources/recipient_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class RecipientTest < Test::Unit::TestCase
+
+    should 'be able to create a recipient with bank_account data' do
+      recipient = PagarMe::Recipient.create recipient_with_nested_bank_account_params
+      assert_not_nil recipient.date_created
+    end
+
+    should 'be able to create a recipient with bank_account id' do
+      bank_account = PagarMe::BankAccount.create bank_account_params
+      recipient    = PagarMe::Recipient.create recipient_params(bank_account_id: bank_account.id)
+
+      assert_not_nil recipient.date_created
+    end
+
+    should 'not be able to create a recipient without bank_account data' do
+      recipient = PagarMe::Recipient.new recipient_params
+      exception = assert_raises(PagarMe::ValidationError){ recipient.create }
+
+      [:bank_code, :agencia, :conta_dv, :conta, :document_number, :legal_name].each do |missing_attr|
+        assert_has_error_param exception, "bank_account[#{missing_attr}]"
+      end
+      assert_nil recipient.date_created
+    end
+
+    should 'be able to search' do
+      recipient = PagarMe::Recipient.create recipient_with_nested_bank_account_params
+
+      bank_account_doc_number = bank_account_params[:document_number]
+      recipients = PagarMe::Recipient.find_by 'bank_account[document_number]' => bank_account_doc_number
+
+      assert recipients.size > 0
+      recipients.each do |recipient|
+        assert_equal recipient.bank_account.document_number, bank_account_doc_number
+      end
+    end
+
+  end
+end

data/test/pagarme/resources/subscription_test.rb

@@ -0,0 +1,100 @@
+require_relative '../../test_helper'
+
+module PagarMe
+  class SubscriptionTest < Test::Unit::TestCase
+    should 'be able to create subscription with plan' do
+      plan = PagarMe::Plan.create plan_params
+      assert_plan_created plan
+
+      subscription = PagarMe::Subscription.create subscription_with_customer_params(plan: plan)
+      assert_subscription_created subscription, plan
+    end
+
+    should 'be able to see subscription transactions' do
+      plan         = PagarMe::Plan.create no_trial_plan_params
+      subscription = PagarMe::Subscription.create subscription_with_customer_params(plan: plan)
+      assert_no_trial_subscription_created subscription, plan
+
+      sleep 1
+      assert       subscription.transactions.count > 0
+      assert_equal subscription.transactions.first.status, 'paid'
+    end
+
+    should 'be able to create subscription with plan and unsaved card' do
+      plan         = PagarMe::Plan.create plan_params
+      card         = PagarMe::Card.new card_params
+      subscription = PagarMe::Subscription.create subscription_with_customer_params(plan: plan, card: card)
+      assert_subscription_created subscription, plan
+    end
+
+    should 'be able to create subscription with plan and saved card' do
+      plan         = PagarMe::Plan.create plan_params
+      card         = PagarMe::Card.create card_params
+      subscription = PagarMe::Subscription.create subscription_with_customer_params(plan: plan, card: card)
+      assert_subscription_created subscription, plan
+    end
+
+    should 'be able to create subscription without plan' do
+      subscription = PagarMe::Subscription.create subscription_with_customer_with_card_params(amount: 2000)
+      assert_subscription_successfully_paid subscription, 2000
+
+      found_subscription = PagarMe::Subscription.find_by_id subscription.id
+      assert_subscription_successfully_paid subscription, 2000
+    end
+
+    should 'be able to create subscription without plan and charge with installments' do
+      subscription = PagarMe::Subscription.create subscription_with_customer_with_card_params(amount: 2000, installments: 6)
+      assert_subscription_successfully_paid subscription, 2000, 6
+
+      id = subscription.id
+
+      subscription.charge 1500, 3
+      assert_equal id, subscription.id
+      assert_subscription_successfully_paid subscription, 1500, 3
+
+      found_subscription = PagarMe::Subscription.find_by_id subscription.id
+      assert_subscription_successfully_paid subscription, 1500, 3
+    end
+
+    should 'be able to update subscription' do
+      subscription = PagarMe::Subscription.create subscription_with_customer_with_card_params
+
+      subscription.payment_method = 'boleto'
+      subscription.save
+
+      found_subscription = PagarMe::Subscription.find_by_id subscription.id
+      assert_equal found_subscription.payment_method, 'boleto'
+    end
+
+    should 'raise an error when nil or empty string as ID' do
+      assert_raises RequestError do
+        PagarMe::Subscription.find_by_id nil
+      end
+
+      assert_raises RequestError do
+        PagarMe::Subscription.find_by_id ''
+      end
+    end
+
+    should 'be able to change plans' do
+      plan       = PagarMe::Plan.create plan_params
+      other_plan = PagarMe::Plan.create other_plan_params
+
+      subscription = PagarMe::Subscription.create subscription_with_customer_with_card_params(plan: plan)
+      assert_equal subscription.plan.id, plan.id
+
+      subscription.plan = other_plan
+      subscription.save
+      assert_equal subscription.plan.id, other_plan.id
+    end
+
+    should 'be able to cancel a subscription' do
+      plan         = PagarMe::Plan.create plan_params
+      subscription = PagarMe::Subscription.create subscription_with_customer_with_card_params(plan: plan)
+      assert_equal subscription.status, 'trialing'
+
+      subscription.cancel
+      assert_equal subscription.status, 'canceled'
+    end
+  end
+end