pagarme 2.0.2 → 2.1.0

data/test/pagarme/pagarme.rb

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

data/test/pagarme/plan.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-require_relative '../test_helper'
-
-module PagarMe
-  class PlanTest < Test::Unit::TestCase
-    should 'be able to create a plan' do
-      plan = test_plan
-      plan.create
-      test_plan_response(plan)
-    end
-
-    should 'be able to update plan' do
-      plan = test_plan
-      plan.create
-      plan.name = "plano silver"
-      plan.save
-      assert plan.name == 'plano silver'
-    end
-
-    should 'be able to search by anything' do
-      plan = test_plan
-      plan.create
-
-      plans = PagarMe::Plan.find_by({:trial_days => 5})
-
-      assert plans.size
-      plans.each do |p|
-        assert p.trial_days == 5
-      end
-    end
-
-    should 'validate plan' do
-      exception = assert_raises PagarMeError do
-        plan = Plan.new({
-          :amount => -1
-        })
-        plan.create
-      end
-      assert exception.errors.first.parameter_name == 'amount'
-      exception = assert_raises PagarMeError do
-        plan = Plan.new({
-          :amount => 1000,
-          :days => -1,
-        })
-        plan.create
-      end
-      assert exception.errors.first.parameter_name == 'days'
-
-      exception = assert_raises PagarMeError do
-        plan = Plan.new({
-          :amount => 1000,
-          :days => 30,
-        })
-        plan.create
-      end
-      assert exception.errors.first.parameter_name == 'name'
-      exception = assert_raises PagarMeError do
-        plan = Plan.new({
-          :amount => 1000,
-          :days => 30,
-          :name => "Plano Silver"
-        })
-        plan.create
-        plan.days = 'Plano gold'
-        plan.save
-      end
-      assert exception.errors.first.parameter_name == 'days'
-    end
-  end
-end

data/test/pagarme/subscription.rb

@@ -1,123 +0,0 @@
-# encoding: utf-8
-require_relative '../test_helper'
-
-module PagarMe
-  class SubscriptionTest < Test::Unit::TestCase
-    should 'be able to create subscription with plan' do
-      plan = test_plan
-      plan.create
-      subscription = test_subscription
-      subscription.plan = plan
-      subscription.create
-      test_plan_response(subscription.plan)
-      test_transaction_with_customer(subscription)
-    end
-
-	should 'be able to create subscription with plan and unsaved card' do
-	  plan = test_plan
-	  plan.create
-
-	  card = test_card
-
-	  subscription = PagarMe::Subscription.new({
-		:postback_url => 'http://test.com/postback',
-		:payment_method => 'credit_card',
-		:card => card,
-		:plan => plan,
-		:customer => {
-		  :email => 'customer@pagar.me'
-		}
-	  })
-	  subscription.create
-	  
-	  assert subscription.id
-	  assert subscription.plan.id == plan.id
-	end
-
-	should 'be able to create subscription with plan and saved card' do
-	  plan = test_plan
-	  plan.create
-
-	  card = test_card
-	  card.create
-
-	  subscription = PagarMe::Subscription.new({
-		:postback_url => 'http://test.com/postback',
-		:payment_method => 'credit_card',
-		:card => card,
-		:plan => plan,
-		:customer => {
-		  :email => 'customer@pagar.me'
-		}
-	  })
-	  subscription.create
-	  
-	  assert subscription.id
-	  assert subscription.plan.id == plan.id
-	end
-
-    should 'be able to create subscription without plan' do
-      subscription = test_subscription({:amount => 2000})
-      subscription.create
-      assert subscription.current_transaction.amount == 2000
-      subscription.charge(2000)
-      assert subscription.current_transaction.kind_of?(PagarMe::Transaction)
-      test_subscription_transaction_response(subscription.current_transaction)
-    end
-
-    should 'be able to create subscription without plan and charge with installments' do
-      subscription = test_subscription({:amount => 2000, :installments => 6})
-      subscription.create
-      # assert subscription.current_transaction.amount == 2000
-      # assert subscription.current_transaction.installments == 6
-      subscription.charge(1500, 3)
-      assert subscription.current_transaction.kind_of?(PagarMe::Transaction)
-      test_subscription_transaction_response(subscription.current_transaction, 1500, 3)
-    end
-
-    should 'be able to update subscription' do
-      subscription = test_subscription
-      subscription.create
-      subscription.payment_method = 'boleto'
-      subscription.save
-
-      subscription2 = PagarMe::Subscription.find_by_id(subscription.id)
-      assert subscription2.payment_method == 'boleto'
-    end
-
-    should 'be able to change plans' do
-      subscription = test_subscription
-      plan = test_plan
-      plan.create
-
-      plan2 = PagarMe::Plan.new({
-        :name => "Plano Silver",
-        :days => 30,
-        :amount => 3000
-      });
-      plan2.create
-
-      subscription.plan = plan
-      subscription.create
-
-      assert subscription.plan.id == plan.id
-      subscription.plan = plan2
-      subscription.save
-
-      assert subscription.plan.id == plan2.id
-    end
-
-    should 'be able to cancel a subscription' do
-      subscription = test_subscription
-      plan = test_plan
-      plan.create
-
-      subscription.plan = plan
-      subscription.create
-
-      subscription.cancel
-
-      assert subscription.status == 'canceled'
-    end
-  end
-end

data/test/pagarme/transaction.rb

@@ -1,215 +0,0 @@
-# encoding: utf-8
-require_relative '../test_helper'
-
-module PagarMe
-  class TransactionTest < Test::Unit::TestCase
-    should 'be able to charge' do
-      transaction = test_transaction
-      assert transaction.status == 'local'
-      transaction.charge
-      assert transaction.status == 'paid'
-      test_transaction_response(transaction)
-    end
-
-	should 'be able to charge with a saved card' do
-	  card = test_card
-	  card.create
-
-	  transaction = PagarMe::Transaction.new({
-		:card => card,
-		:amount => 1000,
-		:payment_method => 'credit_card'
-	  })
-
-	  transaction.charge
-	  assert transaction.status == 'paid'
-	end
-
-	should 'be able to charge with an unsaved card' do
-	  card = test_card
-	  transaction = PagarMe::Transaction.new({
-		:card => card,
-		:amount => 1000,
-		:payment_method => 'credit_card'
-	  })
-
-	  transaction.charge
-	  assert transaction.status == 'paid'
-	end
-
-	should 'return a card object' do
-	  transaction = test_transaction
-	  transaction.create
-	  assert transaction.card.id
-	  assert transaction.card.first_digits == '490172'
-	  assert transaction.card.last_digits == '4448'
-	end
-
-    should 'be able to refund' do
-      transaction = test_transaction
-      transaction.charge
-      test_transaction_response(transaction)
-      transaction.refund
-      assert transaction.status == 'refunded'
-    end
-
-    should 'be able to create transaciton with boleto' do
-      transaction = PagarMe::Transaction.new({
-        :payment_method => "boleto",
-        :amount => "1000"
-      })
-      transaction.charge
-
-      assert transaction.payment_method == 'boleto'
-      assert transaction.status == 'waiting_payment'
-      assert transaction.amount.to_s == '1000'
-    end
-
-    should 'be able to send metadata' do
-      transaction = test_transaction
-      transaction.metadata = {event: {:name => "Evento foda", :id => 335}}
-      transaction.charge
-      assert transaction.metadata
-
-      transaction2 = PagarMe::Transaction.find_by_id(transaction.id)
-      assert transaction2.metadata.event.id.to_i == 335
-      assert transaction2.metadata.event.name == "Evento foda"
-    end
-
-    should 'be able to find a transaction' do
-      transaction = test_transaction
-      transaction.charge
-      test_transaction_response(transaction)
-
-      transaction_2 = PagarMe::Transaction.find_by_id(transaction.id)
-      assert transaction_2.id == transaction.id
-    end
-
-	should 'accept parameters on the refund' do
-	  transaction = PagarMe::Transaction.new({
-	  	:payment_method => 'boleto',
-		:amount => '1000'
-	  })
-
-	  transaction2 = PagarMe::Transaction.new({
-	  	:payment_method => 'boleto',
-		:amount => '1000'
-	  })
-	  
-	  transaction.charge
-	  transaction2.charge
-
-	  transaction.status = 'paid'
-	  transaction.save
-
-	  transaction2.status = 'paid'
-	  transaction2.save
-
-	  transaction.refund({bank_account: {:bank_code => '399', :agencia => '1234', :conta => '1234567', :conta_dv => '1', :legal_name => 'Jose da silva', :document_number => '68782915423'}})
-	  assert transaction.status == 'pending_refund'
-	end
-
-    should 'be able to create transaction with customer' do
-      transaction = test_transaction_with_customer
-      transaction.charge
-      test_transaction_response(transaction)
-      assert transaction.address.class == Address
-      assert transaction.address.street== 'Av. Brigadeiro Faria Lima'
-      assert transaction.customer.class == Customer
-      test_customer_response(transaction.customer)
-	  assert transaction.customer.email = "henrique+test@pagar.me"
-    end
-
-    should 'be able to refund transaction with customer' do
-      transaction = test_transaction_with_customer
-      transaction.charge
-      test_transaction_response(transaction)
-      assert transaction.customer.class == Customer
-      test_customer_response(transaction.customer)
-      transaction.refund
-
-      assert transaction.status == 'refunded'
-    end
-
-	should 'be able to capture a transaction and pass an amount' do
-	  transaction = test_transaction({:capture => false})
-	  transaction.charge
-	  assert transaction.status == 'authorized'
-	  transaction.capture({:amount => 1000})
-	  assert transaction.status == 'paid'
-	  assert transaction.amount == 1000
-	end
-
-    should 'validate invalid transaction' do
-
-      #Test invalid card_number
-      exception = assert_raises PagarMeError do
-        transaction = PagarMe::Transaction.new({
-          :amount => "1000",
-          :card_number => '123456',
-          :card_holder_name => "Jose da Silva",
-        })
-        transaction.charge
-      end
-      assert exception.errors.first.parameter_name == 'card_number'
-
-      #Test missing card_holder_name
-      exception = assert_raises PagarMeError do
-        transaction = PagarMe::Transaction.new({
-          :card_number => '4111111111111111',
-          :amount => "1000",
-        })
-        transaction.charge
-      end
-      assert exception.errors.first.parameter_name == 'card_holder_name'
-
-      #Test invalid expiracy month
-      exception = assert_raises PagarMeError do
-        transaction = PagarMe::Transaction.new({
-          :card_number => '4111111111111111',
-          :card_holder_name => "Jose da Silva",
-          :amount => "1000",
-          :card_expiracy_month => 15
-        })
-        transaction.charge
-      end
-      assert exception.errors.first.parameter_name == 'card_expiration_date'
-
-      #Test invalid expiracy year
-      exception = assert_raises PagarMeError do
-        transaction = PagarMe::Transaction.new({
-          :card_number => '4111111111111111',
-          :card_holder_name => "Jose da Silva",
-          :amount => "1000",
-          :card_expiration_month => 12,
-          :card_expiration_year => -1,
-        })
-        transaction.charge
-      end
-      assert exception.errors.first.parameter_name == 'card_expiration_date'
-
-      #Test invalid expiracy year
-      exception = assert_raises PagarMeError do
-        transaction = PagarMe::Transaction.new({
-          :card_number => '4111111111111111',
-          :card_holder_name => "Jose da Silva",
-          :amount => "1000",
-          :card_expiration_month => 12,
-          :card_expiration_year => 16,
-        })
-        transaction.charge
-      end
-      assert exception.errors.first.parameter_name == 'card_cvv'
-    end
-
-	should 'calculate installments' do
-      installments_result = PagarMe::Transaction.calculate_installments({
-        amount: 10000,
-        interest_rate: 0
-      })
-
-      assert installments_result['installments'].size == 12
-      assert installments_result['installments']['2']['installment_amount'] == 5000
-    end
-  end
-end

data/test/pagarme/transfer.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-require_relative '../test_helper'
-
-module PagarMe
-  class TransferTest < Test::Unit::TestCase
-		def setup
-			super
-
-			t = PagarMe::Transaction.new({
-				:payment_method => 'boleto',
-				:amount => 10000
-			})
-
-			t.charge
-			t.status = 'paid'
-			t.save
-		end
-
-    should 'be able to create a transfer' do
-      transfer = test_transfer
-      transfer.create
-
-      assert transfer.id != nil
-      assert transfer.fee != nil
-      assert transfer.object == "transfer"
-      assert %w(doc credito_em_conta ted).include?(transfer.type)
-    end
-
-    should 'be able to find with id' do
-      transfer_r = test_transfer
-      transfer_r.create
-
-      transfer = PagarMe::Transfer.find_by_id transfer_r.id
-
-      assert transfer.id != nil
-      assert transfer.fee != nil
-      assert transfer.object == "transfer"
-      assert %w(doc credito_em_conta ted).include?(transfer.type)
-    end
-  end
-end
-