pag_seguro 0.4.1 → 0.5.1

data/spec/pag_seguro/payment_spec.rb

@@ -1,155 +1,182 @@
 require 'spec_helper'
 
 describe PagSeguro::Payment do
-  context "instance" do
-    context "accessors" do
-      before { @payment = PagSeguro::Payment.new }
-      
-      it { @payment.should have_attribute_accessor(:id) }
-      it { @payment.should have_attribute_accessor(:items) }
-      it { @payment.should have_attribute_accessor(:sender) }
-      it { @payment.should have_attribute_accessor(:shipping) }
-      it { @payment.should have_attribute_accessor(:email) }
-      it { @payment.should have_attribute_accessor(:token) }
-      it { @payment.should have_attribute_accessor(:extra_amount) }
-      it { @payment.should have_attribute_accessor(:redirect_url) }
-      it { @payment.should have_attribute_accessor(:max_uses) }
-      it { @payment.should have_attribute_accessor(:max_age) }
-      it { @payment.should have_attribute_accessor(:response) }
-
-      it "should respond to :code" do
-        @payment.respond_to?(:code).should be_true
-      end
+  let(:payment){ PagSeguro::Payment.new }
+  subject{ payment }
 
-      it "should respond to :date" do
-        @payment.respond_to?(:date).should be_true
-      end
-      
-      it "should have a DateTime object as date" do
-        response = double("response")
-        response.stub(body: "<checkout><date>2001-02-03T04:05:06+07:00</date></checkout>")
-        @payment.instance_variable_set(:"@response", response)
-        date = @payment.send(:parse_date)
-        date.should be_an_instance_of(DateTime)
-        date.year.should == 2001
-        date.month.should == 2
-        date.day.should == 3
-      end
+  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 have items" do
-        @payment.items.should be_instance_of(Array)
-        @payment.items.should be_empty
-      end
+  it { should respond_to :code }
+  it { should respond_to :date }
 
-      it "should have a sender" do
-        @payment.sender.should be_instance_of(PagSeguro::Sender)
-      end
-    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>') }
+
+    its(:code){ should == 'EE603A-59F0DEF0DAAD-2334FFBF9A1E-3223E3' }
+  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 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 allow to set email and token initialization" do
-      payment = PagSeguro::Payment.new("mymail", "mytoken")
-      payment.email.should == "mymail"
-      payment.token.should == "mytoken"
+    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
     end
-    
-    context "validation" do
-      before { @payment = PagSeguro::Payment.new("mymail", "mytoken") }
-      it "should be valid with valid attributes" do
-        @payment.should be_valid
-      end
-      
-      it "should not be valid without email" do
-        @payment.email = nil
-        @payment.should_not be_valid
-      end
 
-      it "should not be valid without token" do
-        @payment.token = nil
-        @payment.should_not be_valid
-      end
-      
-      it "should not be valid with invalid extra amount format" do
-        @payment.extra_amount = "10,50"
-        @payment.should_not be_valid
-        @payment.extra_amount = "R$ 10.50"
-        @payment.should_not be_valid
-        @payment.extra_amount = "10.50"
-        @payment.should be_valid
-      end
-      
-      it "should not allow invalid urls" do
-        @payment.redirect_url = "httd://something"
-        @payment.should_not be_valid
-        @payment.redirect_url = "http://heavenstudio.com.br"
-        @payment.should be_valid
+    it 'should not be valid if one of its items is invalid' do
+      payment.items = [PagSeguro::Item.new]
+      payment.should_not be_valid
+    end
+
+    context 'without items' do
+      it { should_not be_valid }
+    end
+
+    context 'with items' do
+      subject { build :payment_with_item }
+      it { should be_valid }
+    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'
       end
       
-      it "should not allow an invalid number of uses" do
-        @payment.max_uses = "0"
-        @payment.should_not be_valid
-        @payment.max_uses = "10"
-        @payment.should be_valid
+      it 'should have a checkout_url_with_params' do
+        payment.checkout_url_with_params.should == 'https://ws.pagseguro.uol.com.br/v2/checkout?email=myemail&token=mytoken'
       end
       
-      it "should not allow an invalid second time" do
-        @payment.max_age = "29"
-        @payment.should_not be_valid
-        @payment.max_age = "30"
-        @payment.should be_valid
+      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'
       end
     end
-  end
-  
-  context "checking out" do
-    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"
-    end
-    
-    it "should have a checkout_url_with_params" do
-      PagSeguro::Payment.new("mymail", "mytoken").checkout_url_with_params.should == 'https://ws.pagseguro.uol.com.br/v2/checkout?email=mymail&token=mytoken'
-    end
-    
-    it "should generate a checkout url based on the received response" do
-      payment = PagSeguro::Payment.new("mymail", "mytoken")
-      payment.stub(:code).and_return("aabbcc")
-      payment.checkout_payment_url.should == "https://pagseguro.uol.com.br/v2/checkout/payment.html?code=aabbcc"
-    end
-    
-    describe "parse_checkout_response" do
-      before do
-        @payment = PagSeguro::Payment.new("mymail", "mytoken")
-      end
 
-      it "should not raise errors if response code is 200" do
+    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" }
-        lambda { @payment.send(:parse_checkout_response) }.should_not raise_error
+        PagSeguro::Payment.any_instance.stub_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
+      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" }
-        lambda { @payment.send(:parse_checkout_response) }.should raise_error(PagSeguro::Errors::InvalidData)
+        PagSeguro::Payment.any_instance.stub_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
+      it 'should raise PagSeguro::Errors::Unauthorized if response code is 400' do
         PagSeguro::Payment.any_instance.stub_chain(:send_checkout, :code){ 401 }
-        lambda { @payment.send(:parse_checkout_response) }.should raise_error(PagSeguro::Errors::Unauthorized)
+        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
+      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" }
-        lambda { @payment.send(:parse_checkout_response) }.should raise_error(PagSeguro::Errors::UnknownError)
+        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
+
+      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')
       end
       
-      it "should be able to reset response" do
-        @payment.response = "something"
-        @payment.response.should be_present
-        @payment.reset!
-        @payment.response.should be_nil
+      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
+
+  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
+
+    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 call #parse_code' do
+      payment.stub(response: true)
+      payment.should_receive(:parse_code)
+      payment.code
+    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
+
+    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 call #parse_code' do
+      payment.stub(response: true)
+      payment.should_receive(:parse_date)
+      payment.date
+    end
   end
 end

data/spec/pag_seguro/pre_approval_spec.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+require "spec_helper"
+
+describe PagSeguro::PreApproval do
+  it { should have_attribute_accessor(:name) }
+  it { should have_attribute_accessor(:details) }
+  it { should have_attribute_accessor(:amount_per_payment) }
+  it { should have_attribute_accessor(:period) }
+  it { should have_attribute_accessor(:day_of_week) }
+  it { should have_attribute_accessor(:day_of_month) }
+  it { should have_attribute_accessor(:day_of_year) }
+  it { should have_attribute_accessor(:initial_date) }
+  it { should have_attribute_accessor(:final_date) }
+  it { should have_attribute_accessor(:max_amount_per_period) }
+  it { should have_attribute_accessor(:max_total_amount) }
+  it { should have_attribute_accessor(:review_URL) }
+
+  it { should validate_presence_of :name }
+  it { should validate_presence_of :period }
+  it { should validate_presence_of :final_date }
+  it { should validate_presence_of :max_amount_per_period }
+  it { should validate_presence_of :max_total_amount }
+
+  [:weekly, :monthly, :bimonthly, :trimonthly, :semiannually, :yearly].each do |period_type|
+    it { should allow_value(period_type).for(:period) }
+    it { should allow_value(period_type.to_s).for(:period) }
+    it { should allow_value(period_type.to_s.upcase).for(:period) }
+  end
+  it { should_not allow_value(:some_other_period_type).for(:period) }
+
+  it { should allow_value( nil ).for(:initial_date) }
+  it { should_not allow_value( Time.now - 10.minutes ).for(:initial_date) }
+  it { should allow_value( Time.now ).for(:initial_date) }
+  it { should allow_value( (PagSeguro::PreApproval::DATE_RANGE - 5.minutes).from_now ).for(:initial_date) }
+  it { should_not allow_value( PagSeguro::PreApproval::DATE_RANGE.from_now + 5.minutes ).for(:initial_date) }
+
+  it { should_not allow_value( nil ).for(:final_date) }
+  it { should_not allow_value( Time.now - 10.minutes ).for(:final_date) }
+  it { should allow_value( Time.now ).for(:final_date) }
+  it { should allow_value( (PagSeguro::PreApproval::DATE_RANGE - 5.minutes).from_now ).for(:final_date) }
+  it { should_not allow_value( PagSeguro::PreApproval::DATE_RANGE.from_now + 5.minutes ).for(:final_date) }
+
+  context "with an initial date" do
+    subject { PagSeguro::PreApproval.new(initial_date: 5.days.from_now) }
+
+    it { should_not allow_value( nil ).for(:final_date) }
+    it { should_not allow_value( Time.now - 10.minutes + 5.days ).for(:final_date) }
+    it { should allow_value( Time.now + 5.days ).for(:final_date) }
+    it { should allow_value( (PagSeguro::PreApproval::DATE_RANGE - 5.minutes + 5.days).from_now ).for(:final_date) }
+    it { should_not allow_value( PagSeguro::PreApproval::DATE_RANGE.from_now + 5.minutes + 5.days ).for(:final_date) }    
+  end
+
+  describe "initialized with minimum attributes" do
+    subject{ build :minimum_pre_approval }
+    it { should be_valid }
+  end
+
+  describe "initialized with attributes" do
+    subject{ build :pre_approval }
+
+    it { should be_valid }
+    its(:name){ should == "Super seguro para notebook" }
+    its(:details){ should == "Toda segunda feira será cobrado o valor de R$150,00 para o seguro do notebook" }
+    its(:amount_per_payment){ should == '150.00' }
+    its(:initial_date){ Date.new(2015, 1, 17) }
+    its(:final_date){ Date.new(2017, 1, 17) }
+    its(:max_amount_per_period){ should == '200.00' }
+    its(:max_total_amount){ should == '900.00' }
+    its(:review_URL){ should == "http://sounoob.com.br/produto1" }
+
+    context "weekly" do
+      subject{ build :weekly_pre_approval }
+
+      it { should ensure_inclusion_of(:day_of_week).in_array(%w(monday tuesday wednesday thursday friday saturday sunday)) }
+
+      its(:period){ should == 'weekly' }
+      its(:day_of_week){ should == 'monday' }
+      it { should be_weekly }
+      it { should_not be_monthly }
+      it { should_not be_yearly }
+
+    end
+
+    context "monthly" do
+      subject{ build :monthly_pre_approval }
+
+      it { should ensure_inclusion_of(:day_of_month).in_range(1..28) }
+
+      its(:period){ should == 'monthly' }
+      its(:day_of_month){ should == 3 }
+      it { should_not be_weekly }
+      it { should be_monthly }
+      it { should_not be_yearly }
+    end
+
+    context "yearly" do
+      subject{ build :yearly_pre_approval }
+
+      it { should validate_presence_of(:day_of_year) }
+      it { should allow_value('10-22').for(:day_of_year) }
+      it { should allow_value('01-01').for(:day_of_year) }
+      it { should allow_value(PagSeguro::DayOfYear.new(month: 1, day: 1)).for(:day_of_year) }
+      it { should_not allow_value('1-1').for(:day_of_year) }
+
+      its(:period){ should == 'yearly' }
+      its(:day_of_year){ should == '03-01' }
+      it { should_not be_weekly }
+      it { should_not be_monthly }
+      it { should be_yearly }
+    end
+  end
+end

data/spec/pag_seguro/query_spec.rb

@@ -3,9 +3,116 @@
 require 'spec_helper'
 
 describe PagSeguro::Query do
-  before { PagSeguro::Query.any_instance.stub(transaction_data: transaction_data) }
-  let(:transaction){ PagSeguro::Query.new("mail", "token", "trans_code") }
-  subject{ PagSeguro::Query }
+  let(:transactions_xml){ File.open( File.expand_path( File.dirname(__FILE__) + '/../fixtures/transaction_history.xml') ) }
 
-  it_behaves_like "a transaction"
+  describe "instance" do
+    before { PagSeguro::Query.any_instance.stub(transaction_data: transaction_data) }
+    let(:transaction){ PagSeguro::Query.new("mail", "token", "trans_code") }
+    subject{ PagSeguro::Query }
+
+    it_behaves_like "a transaction"
+  end
+
+  describe "::find" do
+    it "raises error without valid credentials" do
+      expect { PagSeguro::Query.find nil, nil }.to raise_error(RestClient::Exception, "401 Unauthorized")
+    end
+
+    context "with a stubbed response" do
+      before { RestClient.stub(get: transactions_xml) }
+      subject{ PagSeguro::Query.find "email", "token", options: true }
+
+      it "calls search_url with received options" do
+        PagSeguro::Query.should_receive(:search_params).with("email", "token", {options: true})
+        PagSeguro::Query.find "email", "token", options: true
+      end
+
+      it{ should be_a Array }
+      it{ should have(2).transactions }
+      it("should have transaction ids"){ subject.map(&:id).should == ["REF1234", "REF5678"] }
+    end
+  end
+
+  describe "::search_params" do
+    it("returns an Hash"){ PagSeguro::Query.search_params("email", "token").should be_a Hash }
+
+    context "with default options" do
+      let(:search_params) { PagSeguro::Query.search_params("email", "token") }
+      it { search_params.keys.should_not include :maxPageResults }
+      it { search_params.keys.should_not include :page }
+      it { search_params[:finalDate].should include Date.today.iso8601 }
+      it { search_params[:initialDate].should include Date.yesterday.iso8601 }
+      
+      it "should call parse_dates" do
+        PagSeguro::Query.should_receive(:parse_dates)
+        search_params
+      end
+    end
+
+    context "with page number set to 2" do
+      let(:search_params){ PagSeguro::Query.search_params("email", "token", page: 2) }
+      it { search_params[:page].should == 2 }
+    end
+
+    context "with max_page_results set to 100" do
+      let(:search_params){ PagSeguro::Query.search_params("email", "token", max_page_results: 100) }
+      it { search_params[:maxPageResults].should == 100 }
+    end
+
+    context "with initial_date set to 20 days ago" do
+      let(:search_params){ PagSeguro::Query.search_params("email", "token", initial_date: 20.days.ago) }
+      it { search_params[:initialDate].should include 20.days.ago.iso8601 }
+    end
+
+    context "with final_date set to 10 days ago" do
+      let(:search_params){ PagSeguro::Query.search_params("email", "token", initial_date: 20.days.ago, final_date: 10.days.ago) }
+      it { search_params[:finalDate].should include 10.days.ago.iso8601 }
+    end
+  end
+
+  describe "::parse_dates" do
+    it "raises error if initial date is less than 6 months ago" do
+      expect {
+        PagSeguro::Query.parse_dates initial_date: 7.months.ago
+      }.to raise_error("Invalid initial date. Must be bigger than 6 months ago")
+    end
+
+    it "raises error if final date is bigger than today" do
+      expect {
+        PagSeguro::Query.parse_dates final_date: 1.day.from_now
+      }.to raise_error("Invalid end date. Must be less than today")
+    end
+
+    it "raises error if final date is less than initial date" do
+      expect {
+        PagSeguro::Query.parse_dates initial_date: 30.days.ago, final_date: 31.days.ago
+      }.to raise_error("Invalid end date. Must be bigger than initial date")
+    end
+
+    it "raises error if final date is bigger than initial date in more than 30 days" do
+      expect {
+        PagSeguro::Query.parse_dates initial_date: 32.days.ago, final_date: 1.day.ago
+      }.to raise_error("Invalid end date. Must not differ from initial date in more than 30 days")
+    end
+
+    context "first return argument" do
+      it "returns yesterday if no initial date was given" do
+        PagSeguro::Query.parse_dates.first.should == (Time.now - 1.day).iso8601
+      end
+
+      it "returns the initial date in iso8601 format if provided" do
+        PagSeguro::Query.parse_dates(initial_date: 3.days.ago).first.should == 3.days.ago.iso8601
+      end
+    end
+
+    context "second return argument" do
+      it "returns initial_date + 1 day no final date was given" do
+        PagSeguro::Query.parse_dates(initial_date: 2.days.ago).last.should == 1.day.ago.iso8601
+      end
+
+      it "returns the final date in iso8601 format if provided" do
+        PagSeguro::Query.parse_dates(initial_date: 3.days.ago, final_date: 2.days.ago).last.should == 2.days.ago.iso8601
+      end
+    end
+  end
 end