pag_seguro 0.4.1 → 0.5.1

data/spec/pag_seguro/integration/checkout_spec.rb

@@ -1,27 +1,6 @@
 # encoding: utf-8
 require 'spec_helper'
 
-def create_valid_payment
-  payment = PagSeguro::Payment.new(EMAIL, TOKEN)
-  payment.items = [
-    PagSeguro::Item.new(id: 25, description: "A Bic Pen", amount: "1.50",  quantity: "4", shipping_cost: "1.00",  weight: 10),
-    PagSeguro::Item.new(id: 73, description: "A Book",    amount: "38.23", quantity: "1", shipping_cost: "12.00", weight: 300),
-    PagSeguro::Item.new(id: 95, description: "A Towel",   amount: "69.35", quantity: "2", weight: 400),
-    PagSeguro::Item.new(id: 17, description: "A pipe",    amount: "3.00",  quantity: "89")
-  ]
-  payment.sender = PagSeguro::Sender.new(name: "María Isabel   Andrade ", email: "stefano@heavenstudio.com.br", phone_ddd: "11", phone_number: "93430994")
-  payment.shipping = PagSeguro::Shipping.new(
-    type: PagSeguro::Shipping::SEDEX,
-    state: "SP",
-    city: "São Paulo",
-    postal_code: "05363000",
-    district: "Jd. PoliPoli",
-    street: "Av. Otacilio Tomanik",
-    number: "775",
-    complement: "apto. 92")
-  payment
-end
-
 describe PagSeguro::Payment do
   before do
     if EMAIL == "seu_email_cadastrado@nopagseguro.com.br"
@@ -31,63 +10,51 @@ describe PagSeguro::Payment do
     end
   end
   
-  describe "#code" do
-    it "should send a request to pagseguro" do
-      payment = create_valid_payment
-      payment.code.size.should == 32
-    end
-  
-    it "should be valid even without a sender and shipping information" do
-      payment = PagSeguro::Payment.new(EMAIL, TOKEN)
-      payment.items = [PagSeguro::Item.new(id: 17, description: "A pipe", amount: "3.00",  quantity: "2")]
-      payment.code.size.should == 32
-    end
-    
-    it "should tell me when the email and token are invalid" do
-      payment = PagSeguro::Payment.new("not_a_user@not_an_email.com", "NOTATOKEN7F048A09A8AEFDD1E5A7B91")
-      lambda { payment.code }.should raise_error(PagSeguro::Errors::Unauthorized)
-    end
-    
-    it "should list errors given by pagseguro" do
-      payment = PagSeguro::Payment.new(EMAIL, TOKEN)
-      lambda { payment.code }.should raise_error(PagSeguro::Errors::InvalidData)
-    end
-  
+  context "with all fields" do
+    let(:payment){ build :payment_with_all_fields, email: EMAIL, token: TOKEN }
+    subject { payment }
+
+    its('code.size'){ should == 32 }
+    its(:date){ should be_an_instance_of(DateTime) }
+
     it "should give a response code of 200 for the user pagseguro url" do
-      payment = create_valid_payment
       RestClient.get(payment.checkout_payment_url).code.should == 200
     end
   end
 
-  describe "#date" do
-    it "should send a request to pagseguro" do
-      payment = create_valid_payment
-      payment.date.should be_an_instance_of(DateTime)
+  context "with item and minimum pre approval" do
+    let(:payment){ build :payment_with_item, email: EMAIL, token: TOKEN, pre_approval: build(:minimum_pre_approval) }
+    subject { payment }
+
+    its('code.size'){ should == 32 }
+    its(:date){ should be_an_instance_of(DateTime) }
+
+    it "should give a response code of 200 for the user pagseguro url" do
+      RestClient.get(payment.checkout_payment_url).code.should == 200
     end
   end
 
-  describe "#parse_checkout_response" do
-    before do
-      @payment = create_valid_payment
-      @payment.stub(:parse_code)
-      @payment.stub(:parse_date)
-      @payment.stub(:parse_checkout_response){ "some response" }
-    end
-  
-    it "should not make a request to pagseguro more than once" do
-      @payment.should_receive(:parse_checkout_response).exactly(1).times
+  context "with items" do
+    let(:payment){ build :payment_with_items, email: EMAIL, token: TOKEN }
+    subject { payment }
     
-      @payment.code
-      @payment.code
-      @payment.date
+    its('code.size'){ should == 32 }
+    its(:date){ should be_an_instance_of(DateTime) }
+
+    it "should give a response code of 200 for the user pagseguro url" do
+      RestClient.get(payment.checkout_payment_url).code.should == 200
     end
-  
-    it "should make more than one request to pag seguro if the payment is reset" do
-      @payment.should_receive(:parse_checkout_response).exactly(2).times
+  end
 
-      @payment.code
-      @payment.reset!
-      @payment.date
+  context "without items" do
+    it "should raise error when fetching its code" do
+      payment = build :payment, email: EMAIL, token: TOKEN
+      expect { payment.code }.to raise_error(PagSeguro::Errors::InvalidData)
     end
   end
+    
+  it "should raise unauthorized error if email and token do not match" do
+    payment = build :payment, email: "not_a_user@not_an_email.com", token: "NOTATOKEN7F048A09A8AEFDD1E5A7B91"
+    expect { payment.code }.to raise_error(PagSeguro::Errors::Unauthorized)
+  end
 end

data/spec/pag_seguro/integration/config.yml

@@ -1,4 +1,4 @@
-email: billing@heavenstudio.com.br
-token: F4D44C5CE6BD4BD78E5CF5424A65A0D5
-notification_code: EE803A-59F0DEF0DEED-233499BF9A1E-3543E3
-transaction_id: UM_CODIGO_DE_TRANSACAO
+email: belbraga@bobags.com.br
+token: 4B5637E1C27C4304BFAF2C253C73D1FF
+notification_code: DD9500-8AE8FAE8FAC8-7774B44F9384-4CA5DF
+transaction_id: 84EFE527-E8FA-4116-8CA7-744530B1B45D

data/spec/pag_seguro/integration/query_spec.rb

@@ -2,43 +2,65 @@
 require 'spec_helper'
 
 describe PagSeguro::Query do
-  before :all do
-    if EMAIL == "seu_email_cadastrado@nopagseguro.com.br"
-      pending "You need to set your email for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
-    elsif TOKEN == "SEU_TOKEN_GERADO_NO_PAG_SEGURO"
-      pending "You need to set your token for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
-    elsif TRANSACTION_ID == "UM_CODIGO_DE_TRANSACAO"
-      pending "You need to set one transaction id for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
-    else
-      @query = PagSeguro::Query.new(EMAIL, TOKEN, TRANSACTION_ID)
+  describe "#new" do
+    before :all do
+      if EMAIL == "seu_email_cadastrado@nopagseguro.com.br"
+        pending "You need to set your email for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
+      elsif TOKEN == "SEU_TOKEN_GERADO_NO_PAG_SEGURO"
+        pending "You need to set your token for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
+      elsif TRANSACTION_ID == "UM_CODIGO_DE_TRANSACAO"
+        pending "You need to set one transaction id for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
+      else
+        @query = PagSeguro::Query.new(EMAIL, TOKEN, TRANSACTION_ID)
+      end
     end
+    
+    it { @query.transaction_id.should be_present }
+    it { @query.date.should be_present }
+    it { @query.id.should be_present }
+    it { @query.type.should be_present }
+    it { @query.status.should be_present }
+    it { @query.payment_method.type.should be_present }
+    it { @query.payment_method.code.should be_present }
+    it { @query.gross_amount.should be_present }
+    it { @query.discount_amount.should be_present }
+    it { @query.fee_amount.should be_present }
+    it { @query.net_amount.should be_present }
+    it { @query.extra_amount.should be_present }
+    it { @query.installment_count.should be_present }
+    it { @query.item_count.should be_present }
+    it { @query.items.should be_present }
+
+    it "should have all required item attributes" do
+      @query.items.each do |item|
+        item.id.should be_present
+        item.description.should be_present
+        item.amount.should be_present
+        item.quantity.should be_present
+      end
+    end
+    
+    it { @query.sender.email.should be_present }
+    it { @query.shipping.type.should be_present }
   end
-  
-  it { @query.transaction_id.should be_present }
-  it { @query.date.should be_present }
-  it { @query.id.should be_present }
-  it { @query.type.should be_present }
-  it { @query.status.should be_present }
-  it { @query.payment_method.type.should be_present }
-  it { @query.payment_method.code.should be_present }
-  it { @query.gross_amount.should be_present }
-  it { @query.discount_amount.should be_present }
-  it { @query.fee_amount.should be_present }
-  it { @query.net_amount.should be_present }
-  it { @query.extra_amount.should be_present }
-  it { @query.installment_count.should be_present }
-  it { @query.item_count.should be_present }
-  it { @query.items.should be_present }
 
-  it "should have all required item attributes" do
-    @query.items.each do |item|
-      item.id.should be_present
-      item.description.should be_present
-      item.amount.should be_present
-      item.quantity.should be_present
+  describe "::find" do
+    before :all do
+      if EMAIL == "seu_email_cadastrado@nopagseguro.com.br"
+        pending "You need to set your email for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
+      elsif TOKEN == "SEU_TOKEN_GERADO_NO_PAG_SEGURO"
+        pending "You need to set your token for your PagSeguro account in spec/pag_seguro/integration/config.yml in order to run this spec"
+      else
+        @transactions = PagSeguro::Query.find(EMAIL, TOKEN, initial_date: 10.days.ago, final_date: Date.today)
+        pending "You do not have any active transaction with your account in the past 30 days" unless @transactions.present?
+      end
+    end
+
+    it "should return an array of Transactions" do
+      @transactions.each do |transaction|
+        transaction.should be_an_instance_of(PagSeguro::Transaction)
+        transaction.id.should be_present
+      end
     end
   end
-  
-  it { @query.sender.email.should be_present }
-  it { @query.shipping.type.should be_present }
 end

data/spec/pag_seguro/item_spec.rb

@@ -1,79 +1,53 @@
 require "spec_helper"
 
-valid_attributes = {
-  id: 1,
-  description: "descrevendo um item",
-  amount: "100.50",
-  quantity: 1,
-  shipping_cost: "10.50",
-  weight: 300
-}
-
 describe PagSeguro::Item do
-  context "instance" do
-    before { @item = PagSeguro::Item.new }
-
-    it { @item.should have_attribute_accessor(:id) }
-    it { @item.should have_attribute_accessor(:description) }
-    it { @item.should have_attribute_accessor(:amount) }
-    it { @item.should have_attribute_accessor(:quantity) }
-    it { @item.should have_attribute_accessor(:shipping_cost) }
-    it { @item.should have_attribute_accessor(:weight) }
-
-    it "should be valid with valid attributes" do
-      PagSeguro::Item.new(valid_attributes).should be_valid
-    end
-
-    it "should not be valid without an id" do
-      PagSeguro::Item.new(valid_attributes.except(:id)).should_not be_valid
-    end
-
-    it "should not be valid without a description" do
-      PagSeguro::Item.new(valid_attributes.except(:description)).should_not be_valid
-    end
-
-    it "should trim description to 100 characters if it has more than 100 characters" do
-      item = PagSeguro::Item.new(valid_attributes)
-      item.description = "-" * 100
-      item.description.size.should == 100
-      item.should be_valid
-      item.description = "-" * 101
-      item.description.size.should == 100
-      item.should be_valid
-    end
-
-    it "should not be valid without an amount" do
-      PagSeguro::Item.new(valid_attributes.except(:amount)).should_not be_valid
-    end
-
-    it "should not allow invalid amount formats" do
-      PagSeguro::Item.new(valid_attributes.merge(amount: "10")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(amount: "10,50")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(amount: "R$ 10.50")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(amount: "-10.50")).should_not be_valid
-    end
-
-    it "should not be valid without a quantity" do
-      PagSeguro::Item.new(valid_attributes.except(:quantity)).should_not be_valid
-    end
-
-    it "should not allow invalid quantities" do
-      PagSeguro::Item.new(valid_attributes.merge(quantity: "1000")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(quantity: "0")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(quantity: "-1")).should_not be_valid
-    end
+  it { should have_attribute_accessor(:id) }
+  it { should have_attribute_accessor(:description) }
+  it { should have_attribute_accessor(:amount) }
+  it { should have_attribute_accessor(:quantity) }
+  it { should have_attribute_accessor(:shipping_cost) }
+  it { should have_attribute_accessor(:weight) }
+
+  it "should be valid with valid attributes" do
+    build(:item).should be_valid
+  end
 
-    it "should not allow invalid shipping_cost formats" do
-      PagSeguro::Item.new(valid_attributes.merge(shipping_cost: "10")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(shipping_cost: "10,50")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(shipping_cost: "R$ 10.50")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(shipping_cost: "-10.50")).should_not be_valid
-    end
+  it { should validate_presence_of :id }
+  it { should validate_presence_of :description }
+  it { should validate_presence_of :amount }
+  
+  it { should_not allow_value(nil).for(:quantity) }
+  it { should_not allow_value(0).for(:quantity) }
+  it { should_not allow_value(1000).for(:quantity) }
+  it { should allow_value(1).for(:quantity) }
+  it { should allow_value(999).for(:quantity) }
+
+  it { should_not allow_value("10,50").for(:amount) }
+  it { should_not allow_value("R$ 10.50").for(:amount) }
+  it { should_not allow_value("-10.50").for(:amount) }
+  it { should allow_value("10.50").for(:amount) }
+  it { should allow_value(10).for(:amount) }
+  it { should allow_value(BigDecimal.new("10.5")).for(:amount) }
+  
+  it { should_not allow_value("10,50").for(:shipping_cost) }
+  it { should_not allow_value("R$ 10.50").for(:shipping_cost) }
+  it { should_not allow_value("-10.50").for(:shipping_cost) }
+  it { should allow_value("10.50").for(:shipping_cost) }
+  it { should allow_value(10).for(:shipping_cost) }
+  it { should allow_value(BigDecimal.new("10.5")).for(:shipping_cost) }
+  it { should allow_value(nil).for(:shipping_cost) }
+
+  it { should_not allow_value("1000").for(:quantity) }
+  it { should_not allow_value("0").for(:quantity) }
+  it { should_not allow_value("-1").for(:quantity) }
+  it { should allow_value("1").for(:quantity) }
     
-    it "should not allow non integer values for weight" do
-      PagSeguro::Item.new(valid_attributes.merge(weight: "-10")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(weight: "10.5")).should_not be_valid
-      PagSeguro::Item.new(valid_attributes.merge(weight: "10,5")).should_not be_valid
-    end
+  it { should_not allow_value("-10").for(:weight) }
+  it { should_not allow_value("10.5").for(:weight) }
+  it { should_not allow_value("10,5").for(:weight) }
+  it { should allow_value("3").for(:weight) }
+
+  it "should trim description to 100 characters if it has more than 100 characters" do
+    PagSeguro::Item.new(description: "-" * 101).description.size.should == 100
   end
 end

data/spec/pag_seguro/payment_method_spec.rb

@@ -2,75 +2,70 @@
 require 'spec_helper'
 
 describe PagSeguro::PaymentMethod do
-  context "instance" do
-    context "accessors" do
-      before { @payment_method = PagSeguro::PaymentMethod.new }
-      
-      it { @payment_method.should have_attribute_accessor(:code) }
-	    it { @payment_method.should have_attribute_accessor(:type) }      
-	  end
+  it { should have_attribute_accessor(:code) }
+  it { should have_attribute_accessor(:type) }      
     
-    it "should be able to initialize with all attributes" do
-      payment_method = PagSeguro::PaymentMethod.new(code: "101", type: "1")
-      payment_method.code.should == 101
-      payment_method.type.should == 1
+  context "initalized with code and type" do
+    subject { build :payment_method, code: "101", type: "1" }
+
+    its(:code){ should == 101 }
+    its(:type){ should == 1 }
+  end
+    
+  describe "types" do
+    let(:payment_method){ PagSeguro::PaymentMethod.new }
+    
+    context "with type 1" do
+      subject { build :payment_method, type: 1 }
+      it { should be_credit_card }
+    end
+    
+    context "with if type 2" do
+      subject { build :payment_method, type: 2 }
+      it { should be_bank_bill }
     end
     
-    describe "types" do
-      before { @payment_method = PagSeguro::PaymentMethod.new }
-      
-      it "should be credit card if type is 1" do
-        @payment_method.stub(:type){ 1 }
-        @payment_method.should be_credit_card
-      end
-      
-      it "should be bank bill if type is 2" do
-        @payment_method.stub(:type){ 2 }
-        @payment_method.should be_bank_bill
-      end
-      
-      it "should be online debit if type is 3" do
-        @payment_method.stub(:type){ 3 }
-        @payment_method.should be_online_debit
-      end
+    context "with if type 3" do
+      subject { build :payment_method, type: 3 }
+      it { should be_online_debit }
+    end
 
-      it "should be PagSeguro balance if type is 4" do
-        @payment_method.stub(:type){ 4 }
-        @payment_method.should be_pag_seguro_balance
-      end
-      
-      it "should be oi paggo if type is 5" do
-        @payment_method.stub(:type){ 5 }
-        @payment_method.should be_oi_paggo
-      end
+    context "with if type 4" do
+      subject { build :payment_method, type: 4 }
+      it { should be_pag_seguro_balance }
     end
     
-    describe "codes" do
-      def should_have_meaning_for_code(meaning, code)
-        PagSeguro::PaymentMethod.new(code: code).name.should == meaning
-      end
-      
-      it { should_have_meaning_for_code("Cartão de crédito Visa", 101) }
-      it { should_have_meaning_for_code("Cartão de crédito MasterCard", 102) }
-      it { should_have_meaning_for_code("Cartão de crédito American Express", 103) }
-      it { should_have_meaning_for_code("Cartão de crédito Diners", 104) }
-      it { should_have_meaning_for_code("Cartão de crédito Hipercard", 105) }
-      it { should_have_meaning_for_code("Cartão de crédito Aura", 106) }
-      it { should_have_meaning_for_code("Cartão de crédito Elo", 107) }
-      it { should_have_meaning_for_code("Cartão de crédito PLENOCard", 108) }
-      it { should_have_meaning_for_code("Cartão de crédito PersonalCard", 109) }
-      it { should_have_meaning_for_code("Boleto Bradesco", 201) }
-      it { should_have_meaning_for_code("Boleto Santander", 202) }
-      it { should_have_meaning_for_code("Débito online Bradesco", 301) }
-      it { should_have_meaning_for_code("Débito online Itaú", 302) }
-      it { should_have_meaning_for_code("Débito online Unibanco", 303) }
-      it { should_have_meaning_for_code("Débito online Banco do Brasil", 304) }
-      it { should_have_meaning_for_code("Débito online Banco Real", 305) }
-      it { should_have_meaning_for_code("Débito online Banrisul", 306) }
-      it { should_have_meaning_for_code("Débito online HSBC", 307) }
-      it { should_have_meaning_for_code("Saldo PagSeguro", 401) }
-      it { should_have_meaning_for_code("Oi Paggo", 501) }
-      it { should_have_meaning_for_code("Desconhecido", 0) }
+    context "with type 5" do
+      subject { build :payment_method, type: 5 }
+      it { should be_oi_paggo }
     end
   end
+    
+  describe "codes" do
+    def should_have_meaning_for_code(meaning, code)
+      PagSeguro::PaymentMethod.new(code: code).name.should be == meaning
+    end
+    
+    it { should_have_meaning_for_code("Cartão de crédito Visa", 101) }
+    it { should_have_meaning_for_code("Cartão de crédito MasterCard", 102) }
+    it { should_have_meaning_for_code("Cartão de crédito American Express", 103) }
+    it { should_have_meaning_for_code("Cartão de crédito Diners", 104) }
+    it { should_have_meaning_for_code("Cartão de crédito Hipercard", 105) }
+    it { should_have_meaning_for_code("Cartão de crédito Aura", 106) }
+    it { should_have_meaning_for_code("Cartão de crédito Elo", 107) }
+    it { should_have_meaning_for_code("Cartão de crédito PLENOCard", 108) }
+    it { should_have_meaning_for_code("Cartão de crédito PersonalCard", 109) }
+    it { should_have_meaning_for_code("Boleto Bradesco", 201) }
+    it { should_have_meaning_for_code("Boleto Santander", 202) }
+    it { should_have_meaning_for_code("Débito online Bradesco", 301) }
+    it { should_have_meaning_for_code("Débito online Itaú", 302) }
+    it { should_have_meaning_for_code("Débito online Unibanco", 303) }
+    it { should_have_meaning_for_code("Débito online Banco do Brasil", 304) }
+    it { should_have_meaning_for_code("Débito online Banco Real", 305) }
+    it { should_have_meaning_for_code("Débito online Banrisul", 306) }
+    it { should_have_meaning_for_code("Débito online HSBC", 307) }
+    it { should_have_meaning_for_code("Saldo PagSeguro", 401) }
+    it { should_have_meaning_for_code("Oi Paggo", 501) }
+    it { should_have_meaning_for_code("Desconhecido", 0) }
+  end
 end