pag_seguro 0.5.5 → 0.5.6

data/spec/pag_seguro/day_of_year_spec.rb

@@ -2,8 +2,8 @@
 require "spec_helper"
 
 describe PagSeguro::DayOfYear do
-  it { should have_attribute_accessor(:day) }
-  it { should have_attribute_accessor(:month) }
+  it { is_expected.to have_attribute_accessor(:day) }
+  it { is_expected.to have_attribute_accessor(:month) }
 
   context "initialized with attributes" do
     subject{ build :day_of_year, month: 10, day: 21 }
@@ -14,10 +14,10 @@ describe PagSeguro::DayOfYear do
 
   describe "#to_s" do
     it "should output format MM-dd" do
-      build(:day_of_year, month: 11, day: 21).to_s.should == "11-21"
-      build(:day_of_year, month: 1, day: 21).to_s.should  == "01-21"
-      build(:day_of_year, month: 11, day: 1).to_s.should  == "11-01"
-      build(:day_of_year, month: 1, day: 1).to_s.should   == "01-01"
+      expect(build(:day_of_year, month: 11, day: 21).to_s).to eq("11-21")
+      expect(build(:day_of_year, month: 1, day: 21).to_s).to  eq("01-21")
+      expect(build(:day_of_year, month: 11, day: 1).to_s).to  eq("11-01")
+      expect(build(:day_of_year, month: 1, day: 1).to_s).to   eq("01-01")
     end
 
     it "should raise error if month is bigger than 13" do
@@ -35,15 +35,15 @@ describe PagSeguro::DayOfYear do
 
   describe "comparisons" do
     it "should be bigger when month is ahead" do
-      build(:day_of_year, month: 2).should be > build(:day_of_year, month: 1)
+      expect(build(:day_of_year, month: 2)).to be > build(:day_of_year, month: 1)
     end
 
     it "should be bigger when day is ahead if month is the same" do
-      build(:day_of_year, day: 2).should be > build(:day_of_year, day: 1)
+      expect(build(:day_of_year, day: 2)).to be > build(:day_of_year, day: 1)
     end
 
     it "should be equal if both day and month are the same" do
-      build(:day_of_year).should be == build(:day_of_year)
+      expect(build(:day_of_year)).to eq(build(:day_of_year))
     end
   end
 end

data/spec/pag_seguro/errors/invalid_data_spec.rb

@@ -17,6 +17,6 @@ end
 
 describe PagSeguro::Errors::InvalidData do
   it "should be able to parse an error xml and raise the error codes" do
-    lambda { raise PagSeguro::Errors::InvalidData.new(invalid_data_xml) }.should raise_error(PagSeguro::Errors::InvalidData, "404: Not Found\n422: Unauthorized\n")
+    expect { raise PagSeguro::Errors::InvalidData.new(invalid_data_xml) }.to raise_error(PagSeguro::Errors::InvalidData, "404: Not Found\n422: Unauthorized\n")
   end
 end

data/spec/pag_seguro/errors/unauthorized_spec.rb

@@ -2,6 +2,6 @@ require "spec_helper"
 
 describe PagSeguro::Errors::Unauthorized do
   it "should be able to raise an unauthorized error" do
-    lambda { raise PagSeguro::Errors::Unauthorized.new }.should raise_error(PagSeguro::Errors::Unauthorized, "Credentials provided (e-mail and token) failed to authenticate")
+    expect { raise PagSeguro::Errors::Unauthorized.new }.to raise_error(PagSeguro::Errors::Unauthorized, "Credentials provided (e-mail and token) failed to authenticate")
   end
 end

data/spec/pag_seguro/errors/unknown_error_spec.rb

@@ -12,6 +12,6 @@ end
 
 describe PagSeguro::Errors::UnknownError do
   it "should be able to raise an unknown error" do
-    lambda { raise PagSeguro::Errors::UnknownError.new(MockResponse.new) }.should raise_error(PagSeguro::Errors::UnknownError, "Unknown response code (10000):\n error description")
+    expect { raise PagSeguro::Errors::UnknownError.new(MockResponse.new) }.to raise_error(PagSeguro::Errors::UnknownError, "Unknown response code (10000):\n error description")
   end
 end

data/spec/pag_seguro/integration/checkout_spec.rb

@@ -14,11 +14,11 @@ describe PagSeguro::Payment 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) }
+    its('code.size'){ is_expected.to eq(32) }
+    its(:date){ is_expected.to 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
+      expect(RestClient.get(payment.checkout_payment_url).code).to eq(200)
     end
   end
 
@@ -26,11 +26,11 @@ describe PagSeguro::Payment 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) }
+    its('code.size'){ is_expected.to eq(32) }
+    its(:date){ is_expected.to 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
+      expect(RestClient.get(payment.checkout_payment_url).code).to eq(200)
     end
   end
 
@@ -38,11 +38,11 @@ describe PagSeguro::Payment do
     let(:payment){ build :payment_with_items, email: EMAIL, token: TOKEN }
     subject { payment }
 
-    its('code.size'){ should == 32 }
-    its(:date){ should be_an_instance_of(DateTime) }
+    its('code.size'){ is_expected.to eq(32) }
+    its(:date){ is_expected.to 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
+      expect(RestClient.get(payment.checkout_payment_url).code).to eq(200)
     end
   end
 

data/spec/pag_seguro/integration/config.yml

@@ -1,4 +1,4 @@
-email: belbraga@bobags.com.br
-token: 4B5637E1C27C4304BFAF2C253C73D1FF
-notification_code: DD9500-8AE8FAE8FAC8-7774B44F9384-4CA5DF
-transaction_id: 84EFE527-E8FA-4116-8CA7-744530B1B45D
+email: seu_email_cadastrado@nopagseguro.com.br
+token: SEU_TOKEN_GERADO_NO_PAG_SEGURO
+notification_code: SEU_CODIGO_DE_NOTIFICACAO
+transaction_id: UM_CODIGO_DE_TRANSACAO

data/spec/pag_seguro/integration/notification_spec.rb

@@ -14,31 +14,31 @@ describe PagSeguro::Notification do
     end
   end
 
-  it { @notification.transaction_id.should be_present }
-  it { @notification.date.should be_present }
-  it { @notification.id.should be_present }
-  it { @notification.type.should be_present }
-  it { @notification.status.should be_present }
-  it { @notification.payment_method.type.should be_present }
-  it { @notification.payment_method.code.should be_present }
-  it { @notification.gross_amount.should be_present }
-  it { @notification.discount_amount.should be_present }
-  it { @notification.fee_amount.should be_present }
-  it { @notification.net_amount.should be_present }
-  it { @notification.extra_amount.should be_present }
-  it { @notification.installment_count.should be_present }
-  it { @notification.item_count.should be_present }
-  it { @notification.items.should be_present }
+  it { expect(@notification.transaction_id).to be_present }
+  it { expect(@notification.date).to be_present }
+  it { expect(@notification.id).to be_present }
+  it { expect(@notification.type).to be_present }
+  it { expect(@notification.status).to be_present }
+  it { expect(@notification.payment_method.type).to be_present }
+  it { expect(@notification.payment_method.code).to be_present }
+  it { expect(@notification.gross_amount).to be_present }
+  it { expect(@notification.discount_amount).to be_present }
+  it { expect(@notification.fee_amount).to be_present }
+  it { expect(@notification.net_amount).to be_present }
+  it { expect(@notification.extra_amount).to be_present }
+  it { expect(@notification.installment_count).to be_present }
+  it { expect(@notification.item_count).to be_present }
+  it { expect(@notification.items).to be_present }
 
   it "should have all required item attributes" do
     @notification.items.each do |item|
-      item.id.should be_present
-      item.description.should be_present
-      item.amount.should be_present
-      item.quantity.should be_present
+      expect(item.id).to be_present
+      expect(item.description).to be_present
+      expect(item.amount).to be_present
+      expect(item.quantity).to be_present
     end
   end
 
-  it { @notification.sender.email.should be_present }
-  it { @notification.shipping.type.should be_present }
+  it { expect(@notification.sender.email).to be_present }
+  it { expect(@notification.shipping.type).to be_present }
 end

data/spec/pag_seguro/integration/query_spec.rb

@@ -15,33 +15,33 @@ describe PagSeguro::Query do
       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 { expect(@query.transaction_id).to be_present }
+    it { expect(@query.date).to be_present }
+    it { expect(@query.id).to be_present }
+    it { expect(@query.type).to be_present }
+    it { expect(@query.status).to be_present }
+    it { expect(@query.payment_method.type).to be_present }
+    it { expect(@query.payment_method.code).to be_present }
+    it { expect(@query.gross_amount).to be_present }
+    it { expect(@query.discount_amount).to be_present }
+    it { expect(@query.fee_amount).to be_present }
+    it { expect(@query.net_amount).to be_present }
+    it { expect(@query.extra_amount).to be_present }
+    it { expect(@query.installment_count).to be_present }
+    it { expect(@query.item_count).to be_present }
+    it { expect(@query.items).to 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
+        expect(item.id).to be_present
+        expect(item.description).to be_present
+        expect(item.amount).to be_present
+        expect(item.quantity).to be_present
       end
     end
 
-    it { @query.sender.email.should be_present }
-    it { @query.shipping.type.should be_present }
+    it { expect(@query.sender.email).to be_present }
+    it { expect(@query.shipping.type).to be_present }
   end
 
   describe "::find" do
@@ -58,8 +58,8 @@ describe PagSeguro::Query do
 
     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
+        expect(transaction).to be_an_instance_of(PagSeguro::Transaction)
+        expect(transaction.id).to be_present
       end
     end
   end

data/spec/pag_seguro/item_spec.rb

@@ -1,55 +1,55 @@
 require "spec_helper"
 
 describe PagSeguro::Item do
-  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 { is_expected.to have_attribute_accessor(:id) }
+  it { is_expected.to have_attribute_accessor(:description) }
+  it { is_expected.to have_attribute_accessor(:amount) }
+  it { is_expected.to have_attribute_accessor(:quantity) }
+  it { is_expected.to have_attribute_accessor(:shipping_cost) }
+  it { is_expected.to have_attribute_accessor(:weight) }
 
   it "should be valid with valid attributes" do
-    build(:item).should be_valid
+    expect(build(:item)).to 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_not allow_value("10.50\nanything").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_not allow_value("10.50\nanything").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_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 { is_expected.to validate_presence_of :id }
+  it { is_expected.to validate_presence_of :description }
+  it { is_expected.to validate_presence_of :amount }
+
+  it { is_expected.not_to allow_value(nil).for(:quantity) }
+  it { is_expected.not_to allow_value(0).for(:quantity) }
+  it { is_expected.not_to allow_value(1000).for(:quantity) }
+  it { is_expected.to allow_value(1).for(:quantity) }
+  it { is_expected.to allow_value(999).for(:quantity) }
+
+  it { is_expected.not_to allow_value("10,50").for(:amount) }
+  it { is_expected.not_to allow_value("R$ 10.50").for(:amount) }
+  it { is_expected.not_to allow_value("-10.50").for(:amount) }
+  it { is_expected.not_to allow_value("10.50\nanything").for(:amount) }
+  it { is_expected.to allow_value("10.50").for(:amount) }
+  it { is_expected.to allow_value(10).for(:amount) }
+  it { is_expected.to allow_value(BigDecimal.new("10.5")).for(:amount) }
+
+  it { is_expected.not_to allow_value("10,50").for(:shipping_cost) }
+  it { is_expected.not_to allow_value("R$ 10.50").for(:shipping_cost) }
+  it { is_expected.not_to allow_value("-10.50").for(:shipping_cost) }
+  it { is_expected.not_to allow_value("10.50\nanything").for(:shipping_cost) }
+  it { is_expected.to allow_value("10.50").for(:shipping_cost) }
+  it { is_expected.to allow_value(10).for(:shipping_cost) }
+  it { is_expected.to allow_value(BigDecimal.new("10.5")).for(:shipping_cost) }
+  it { is_expected.to allow_value(nil).for(:shipping_cost) }
+
+  it { is_expected.not_to allow_value("1000").for(:quantity) }
+  it { is_expected.not_to allow_value("0").for(:quantity) }
+  it { is_expected.not_to allow_value("-1").for(:quantity) }
+  it { is_expected.to allow_value("1").for(:quantity) }
+
+  it { is_expected.not_to allow_value("-10").for(:weight) }
+  it { is_expected.not_to allow_value("10.5").for(:weight) }
+  it { is_expected.not_to allow_value("10,5").for(:weight) }
+  it { is_expected.to 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
+    expect(PagSeguro::Item.new(description: "-" * 101).description.size).to eq(100)
   end
 end

data/spec/pag_seguro/notification_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe PagSeguro::Notification do
-  before { PagSeguro::Notification.any_instance.stub(transaction_data: transaction_data) }
+  before { allow_any_instance_of(PagSeguro::Notification).to receive_messages(transaction_data: transaction_data) }
   let(:transaction){ PagSeguro::Notification.new("mail", "token", "not_code") }
   subject{ PagSeguro::Notification }
 

data/spec/pag_seguro/payment_method_spec.rb

@@ -2,8 +2,8 @@
 require 'spec_helper'
 
 describe PagSeguro::PaymentMethod do
-  it { should have_attribute_accessor(:code) }
-  it { should have_attribute_accessor(:type) }
+  it { is_expected.to have_attribute_accessor(:code) }
+  it { is_expected.to have_attribute_accessor(:type) }
 
   context "initalized with code and type" do
     subject { build :payment_method, code: "101", type: "1" }
@@ -17,33 +17,33 @@ describe PagSeguro::PaymentMethod do
 
     context "with type 1" do
       subject { build :payment_method, type: 1 }
-      it { should be_credit_card }
+      it { is_expected.to be_credit_card }
     end
 
     context "with if type 2" do
       subject { build :payment_method, type: 2 }
-      it { should be_bank_bill }
+      it { is_expected.to be_bank_bill }
     end
 
     context "with if type 3" do
       subject { build :payment_method, type: 3 }
-      it { should be_online_debit }
+      it { is_expected.to be_online_debit }
     end
 
     context "with if type 4" do
       subject { build :payment_method, type: 4 }
-      it { should be_pag_seguro_balance }
+      it { is_expected.to be_pag_seguro_balance }
     end
 
     context "with type 5" do
       subject { build :payment_method, type: 5 }
-      it { should be_oi_paggo }
+      it { is_expected.to 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
+      expect(PagSeguro::PaymentMethod.new(code: code).name).to eq(meaning)
     end
 
     it { should_have_meaning_for_code("Cartão de crédito Visa", 101) }

data/spec/pag_seguro/payment_spec.rb

@@ -4,202 +4,219 @@ describe PagSeguro::Payment do
   let(:payment){ PagSeguro::Payment.new }
   subject{ payment }
 
-  it { should have_attribute_accessor(:id) }
-  it { should have_attribute_accessor(:items) }
-  it { should have_attribute_accessor(:sender) }
-  it { should have_attribute_accessor(:shipping) }
-  it { should have_attribute_accessor(:email) }
-  it { should have_attribute_accessor(:token) }
-  it { should have_attribute_accessor(:extra_amount) }
-  it { should have_attribute_accessor(:redirect_url) }
-  it { should have_attribute_accessor(:max_uses) }
-  it { should have_attribute_accessor(:max_age) }
-  it { should have_attribute_accessor(:response) }
-  it { should have_attribute_accessor(:pre_approval) }
-
-  it { should respond_to :code }
-  it { should respond_to :date }
-
-  describe "::CHECKOUT_URL" do
-    subject { PagSeguro::Payment::CHECKOUT_URL }
-    it { should == "https://ws.pagseguro.uol.com.br/v2/checkout" }
-  end
-
-  describe '#date' do
-    subject{ payment.send(:parse_date) }
-    before{ payment.stub response: double(:response, body: '<checkout><date>2001-02-03T04:05:06+07:00</date></checkout>') }
-
-    it { should be_an_instance_of(DateTime) }
-    its(:year){ should == 2001 }
-    its(:month){ should == 2 }
-    its(:day){ should == 3 }
-  end
-
-  describe '#code' do
-    before{ payment.stub response: double(:response, body: '<checkout><code>EE603A-59F0DEF0DAAD-2334FFBF9A1E-3223E3</code></checkout>') }
+  it { is_expected.to have_attribute_accessor(:id) }
+  it { is_expected.to have_attribute_accessor(:items) }
+  it { is_expected.to have_attribute_accessor(:sender) }
+  it { is_expected.to have_attribute_accessor(:shipping) }
+  it { is_expected.to have_attribute_accessor(:email) }
+  it { is_expected.to have_attribute_accessor(:token) }
+  it { is_expected.to have_attribute_accessor(:extra_amount) }
+  it { is_expected.to have_attribute_accessor(:redirect_url) }
+  it { is_expected.to have_attribute_accessor(:max_uses) }
+  it { is_expected.to have_attribute_accessor(:max_age) }
+  it { is_expected.to have_attribute_accessor(:response) }
+  it { is_expected.to have_attribute_accessor(:pre_approval) }
+
+  it { is_expected.to respond_to :code }
+  it { is_expected.to respond_to :date }
+
+  context "sandbox" do
+    before do
+      PagSeguro::Url.environment= :sandbox
+    end
 
-    its(:code){ should == 'EE603A-59F0DEF0DAAD-2334FFBF9A1E-3223E3' }
+    describe "checkout url" do
+      subject { PagSeguro::Payment.checkout_url }
+      it { is_expected.to eq("https://ws.sandbox.pagseguro.uol.com.br/v2/checkout") }
+    end
   end
 
-  its(:items){ should be_an_instance_of(Array) }
-  its(:items){ should be_empty }
-  its(:sender){ should be_an_instance_of(PagSeguro::Sender) }
-
-  context 'with email and token initialization' do
-    subject{ build(:payment) }
-    let(:payment){ subject }
-    its(:email){ should == 'myemail' }
-    its(:token){ should == 'mytoken' }
-
-    it { validate_presence_of :email }
-    it { validate_presence_of :token }
-
-    it { should_not allow_value('10,50').for(:extra_amount) }
-    it { should_not allow_value('R$ 10.50').for(:extra_amount) }
-    it { should_not allow_value('-10.50').for(:extra_amount) }
-    it { should_not allow_value('10.50\nanything').for(:extra_amount) }
-    it { should allow_value('10.50').for(:extra_amount) }
-    it { should allow_value(10).for(:extra_amount) }
-    it { should allow_value(BigDecimal.new('10.5')).for(:extra_amount) }
-
-    it { should_not allow_value('something.com.br').for(:redirect_url)}
-    it { should allow_value('http://something.com.br').for(:redirect_url)}
-
-    it { should_not allow_value(0).for(:max_uses) }
-    it { should_not allow_value('0').for(:max_uses) }
-    it { should allow_value(10).for(:max_uses) }
-    it { should allow_value('10').for(:max_uses) }
-
-    it { should_not allow_value(29).for(:max_age) }
-    it { should allow_value(30).for(:max_age) }
-
-    it 'should not be valid if its pre_approval in invalid' do
-      payment.pre_approval = PagSeguro::PreApproval.new
-      payment.should_not be_valid
+  context "production" do
+    before do
+      PagSeguro::Url.environment= :production
     end
 
-    it 'should not be valid if one of its items is invalid' do
-      payment.items = [PagSeguro::Item.new]
-      payment.should_not be_valid
+    describe "checkout url" do
+      subject { PagSeguro::Payment.checkout_url }
+      it { is_expected.to eq("https://ws.pagseguro.uol.com.br/v2/checkout") }
     end
 
-    context 'without items' do
-      it { should_not be_valid }
-    end
+    describe '#date' do
+      subject{ payment.send(:parse_date) }
+      before{ allow(payment).to receive_messages response: double(:response, body: '<checkout><date>2001-02-03T04:05:06+07:00</date></checkout>') }
 
-    context 'with items' do
-      subject { build :payment_with_item }
-      it { should be_valid }
+      it { is_expected.to be_an_instance_of(DateTime) }
+      its(:year){ should == 2001 }
+      its(:month){ should == 2 }
+      its(:day){ should == 3 }
     end
 
-    context 'using reference instead of id' do
-      subject { build :payment_with_item, id: nil, reference: "REF1234" }
-      its(:id){ should == "REF1234" }
-      its(:reference){ should == "REF1234" }
+    describe '#code' do
+      before{ allow(payment).to receive_messages response: double(:response, body: '<checkout><code>EE603A-59F0DEF0DAAD-2334FFBF9A1E-3223E3</code></checkout>') }
+
+      its(:code){ should == 'EE603A-59F0DEF0DAAD-2334FFBF9A1E-3223E3' }
     end
 
-    context 'checking out' do
-      let(:payment){ build(:payment) }
-      it 'should generate a checkout url with an external code' do
-        PagSeguro::Payment.checkout_payment_url('aabbcc').should == 'https://pagseguro.uol.com.br/v2/checkout/payment.html?code=aabbcc'
+    its(:items){ should be_an_instance_of(Array) }
+    its(:items){ should be_empty }
+    its(:sender){ should be_an_instance_of(PagSeguro::Sender) }
+
+    context 'with email and token initialization' do
+      subject{ build(:payment) }
+      let(:payment){ subject }
+      its(:email){ should == 'myemail' }
+      its(:token){ should == 'mytoken' }
+
+      it { validate_presence_of :email }
+      it { validate_presence_of :token }
+
+      it { is_expected.not_to allow_value('10,50').for(:extra_amount) }
+      it { is_expected.not_to allow_value('R$ 10.50').for(:extra_amount) }
+      it { is_expected.not_to allow_value('-10.50').for(:extra_amount) }
+      it { is_expected.not_to allow_value('10.50\nanything').for(:extra_amount) }
+      it { is_expected.to allow_value('10.50').for(:extra_amount) }
+      it { is_expected.to allow_value(10).for(:extra_amount) }
+      it { is_expected.to allow_value(BigDecimal.new('10.5')).for(:extra_amount) }
+
+      it { is_expected.not_to allow_value('something.com.br').for(:redirect_url)}
+      it { is_expected.to allow_value('http://something.com.br').for(:redirect_url)}
+
+      it { is_expected.not_to allow_value(0).for(:max_uses) }
+      it { is_expected.not_to allow_value('0').for(:max_uses) }
+      it { is_expected.to allow_value(10).for(:max_uses) }
+      it { is_expected.to allow_value('10').for(:max_uses) }
+
+      it { is_expected.not_to allow_value(29).for(:max_age) }
+      it { is_expected.to allow_value(30).for(:max_age) }
+
+      it 'should not be valid if its pre_approval in invalid' do
+        payment.pre_approval = PagSeguro::PreApproval.new
+        expect(payment).not_to be_valid
       end
 
-      it 'should generate a checkout url based on the received response' do
-        payment.stub code: 'aabbcc'
-        payment.checkout_payment_url.should == 'https://pagseguro.uol.com.br/v2/checkout/payment.html?code=aabbcc'
+      it 'should not be valid if one of its items is invalid' do
+        payment.items = [PagSeguro::Item.new]
+        expect(payment).not_to be_valid
       end
-    end
 
-    describe '#parse_checkout_response' do
-
-      it 'should not raise errors if response code is 200' do
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :code){ 200 }
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :body){ 'some body info' }
-        expect { payment.send(:parse_checkout_response) }.to_not raise_error
+      context 'without items' do
+        it { is_expected.not_to be_valid }
       end
 
-      it 'should raise PagSeguro::Errors::InvalidData if response code is 400' do
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :code){ 400 }
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :body){ 'some error description' }
-        expect { payment.send(:parse_checkout_response) }.to raise_error(PagSeguro::Errors::InvalidData)
+      context 'with items' do
+        subject { build :payment_with_item }
+        it { is_expected.to be_valid }
       end
 
-      it 'should raise PagSeguro::Errors::Unauthorized if response code is 400' do
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :code){ 401 }
-        expect { payment.send(:parse_checkout_response) }.to raise_error(PagSeguro::Errors::Unauthorized)
+      context 'using reference instead of id' do
+        subject { build :payment_with_item, id: nil, reference: "REF1234" }
+        its(:id){ should == "REF1234" }
+        its(:reference){ should == "REF1234" }
       end
 
-      it 'should raise PagSeguro::Errors::UnknownError if response code is not 200, 400 or 401' do
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :code){ 300 }
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :body){ 'some response body' }
-        expect { payment.send(:parse_checkout_response) }.to raise_error(PagSeguro::Errors::UnknownError)
-      end
+      context 'checking out' do
+        let(:payment){ build(:payment) }
+        it 'should generate a checkout url with an external code' do
+          expect(PagSeguro::Payment.checkout_payment_url('aabbcc')).to eq('https://pagseguro.uol.com.br/v2/checkout/payment.html?code=aabbcc')
+        end
 
-      it 'should set response attribute if code is 200' do
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :code){ 200 }
-        PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :body){ 'some response body' }
-        expect { payment.send(:parse_checkout_response) }.to change { payment.response }.from(nil).to('some response body')
+        it 'should generate a checkout url based on the received response' do
+          allow(payment).to receive_messages code: 'aabbcc'
+          expect(payment.checkout_payment_url).to eq('https://pagseguro.uol.com.br/v2/checkout/payment.html?code=aabbcc')
+        end
       end
 
-      it 'should be able to reset response' do
-        payment.response = 'something'
-        expect { payment.reset! }.to change{ payment.response }.from('something').to(nil)
+      describe '#parse_checkout_response' do
+
+        it 'should not raise errors if response code is 200' do
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :code){ 200 }
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :body){ 'some body info' }
+          expect { payment.send(:parse_checkout_response) }.to_not raise_error
+        end
+
+        it 'should raise PagSeguro::Errors::InvalidData if response code is 400' do
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :code){ 400 }
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :body){ 'some error description' }
+          expect { payment.send(:parse_checkout_response) }.to raise_error(PagSeguro::Errors::InvalidData)
+        end
+
+        it 'should raise PagSeguro::Errors::Unauthorized if response code is 400' do
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :code){ 401 }
+          expect { payment.send(:parse_checkout_response) }.to raise_error(PagSeguro::Errors::Unauthorized)
+        end
+
+        it 'should raise PagSeguro::Errors::UnknownError if response code is not 200, 400 or 401' do
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :code){ 300 }
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :body){ 'some response body' }
+          expect { payment.send(:parse_checkout_response) }.to raise_error(PagSeguro::Errors::UnknownError)
+        end
+
+        it 'should set response attribute if code is 200' do
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :code){ 200 }
+          allow_any_instance_of(PagSeguro::Payment).to receive_message_chain(:send_checkout, :body){ 'some response body' }
+          expect { payment.send(:parse_checkout_response) }.to change { payment.response }.from(nil).to('some response body')
+        end
+
+        it 'should be able to reset response' do
+          payment.response = 'something'
+          expect { payment.reset! }.to change{ payment.response }.from('something').to(nil)
+        end
       end
     end
-  end
 
-  describe '#code' do
-    it 'should call #parse_checkout_response if #response is nil' do
-      payment.stub(response: nil, parse_code: nil)
-      payment.should_receive(:parse_checkout_response)
-      payment.code
-    end
+    describe '#code' do
+      it 'should call #parse_checkout_response if #response is nil' do
+        allow(payment).to receive_messages(response: nil, parse_code: nil)
+        expect(payment).to receive(:parse_checkout_response)
+        payment.code
+      end
 
-    it 'should not call #parse_checkout_response if #response is present' do
-      payment.stub(response: true, parse_code: nil)
-      payment.should_not_receive(:parse_checkout_response)
-      payment.code
-    end
+      it 'should not call #parse_checkout_response if #response is present' do
+        allow(payment).to receive_messages(response: true, parse_code: nil)
+        expect(payment).not_to receive(:parse_checkout_response)
+        payment.code
+      end
 
-    it 'should call #parse_code' do
-      payment.stub(response: true)
-      payment.should_receive(:parse_code)
-      payment.code
+      it 'should call #parse_code' do
+        allow(payment).to receive_messages(response: true)
+        expect(payment).to receive(:parse_code)
+        payment.code
+      end
     end
-  end
 
-  describe '#date' do
-    it 'should call #parse_checkout_response if #response is nil' do
-      payment.stub(response: nil, parse_date: nil)
-      payment.should_receive(:parse_checkout_response)
-      payment.date
-    end
+    describe '#date' do
+      it 'should call #parse_checkout_response if #response is nil' do
+        allow(payment).to receive_messages(response: nil, parse_date: nil)
+        expect(payment).to receive(:parse_checkout_response)
+        payment.date
+      end
 
-    it 'should not call #parse_checkout_response if #response is present' do
-      payment.stub(response: true, parse_date: nil)
-      payment.should_not_receive(:parse_checkout_response)
-      payment.date
-    end
+      it 'should not call #parse_checkout_response if #response is present' do
+        allow(payment).to receive_messages(response: true, parse_date: nil)
+        expect(payment).not_to receive(:parse_checkout_response)
+        payment.date
+      end
 
-    it 'should call #parse_code' do
-      payment.stub(response: true)
-      payment.should_receive(:parse_date)
-      payment.date
+      it 'should call #parse_code' do
+        allow(payment).to receive_messages(response: true)
+        expect(payment).to receive(:parse_date)
+        payment.date
+      end
     end
-  end
 
-  describe "#send_checkout" do
-    let(:payment){ PagSeguro::Payment.new "email@mail.com", "sometoken" }
-    it "should call pagseguro's webservice" do
-      checkout_xml = double(:checkout_xml)
-      payment.stub(checkout_xml: checkout_xml)
-      params = { email: "email@mail.com", token: "sometoken" }
-      RestClient.should_receive(:post).with(
-        PagSeguro::Payment::CHECKOUT_URL,
-        checkout_xml,
-        params: params,
-        content_type: "application/xml")
-      payment.send :send_checkout
+    describe "#send_checkout" do
+      let(:payment){ PagSeguro::Payment.new "email@mail.com", "sometoken" }
+      it "should call pagseguro's webservice" do
+        checkout_xml = double(:checkout_xml)
+        allow(payment).to receive_messages(checkout_xml: checkout_xml)
+        params = { email: "email@mail.com", token: "sometoken", ssl_version: :SSLv3 }
+        expect(RestClient).to receive(:post).with(
+          PagSeguro::Payment.checkout_url,
+          checkout_xml,
+          params: params,
+          content_type: "application/xml")
+        payment.send :send_checkout
+      end
     end
   end
 end