pagseguro-oficial 2.1.1 → 2.2.0

data/spec/pagseguro/sender_spec.rb

@@ -4,6 +4,7 @@ describe PagSeguro::Sender do
   it_assigns_attribute :name
   it_assigns_attribute :email
   it_assigns_attribute :cpf
+  it_assigns_attribute :hash
   it_ensures_type PagSeguro::Phone, :phone
   it_ensures_type PagSeguro::Document, :document
 end

data/spec/pagseguro/session/response_serializer_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe PagSeguro::Session::ResponseSerializer do
+  context "when there are installments" do
+    let(:source) { File.read("./spec/fixtures/session/success.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:serializer) { described_class.new(xml.css("session").first) }
+    subject(:data) { serializer.serialize }
+
+    it { expect(data).to include(id: "620f99e348c24f07877c927b353e49d3") }
+  end
+end

data/spec/pagseguro/session/response_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+RSpec.describe PagSeguro::Session::Response do
+  subject { PagSeguro::Session::Response.new(http_response, session) }
+  let(:session) { PagSeguro::Session.new }
+
+  context "#success?" do
+    let(:http_response) do
+      double(:HttpResponse, xml?: true)
+    end
+
+    it "delegate to response" do
+      allow(http_response).to receive(:success?).and_return(true)
+      expect(subject).to be_success
+
+      allow(http_response).to receive(:success?).and_return(false)
+      expect(subject).not_to be_success
+    end
+  end
+
+  describe "#serialize" do
+    let(:http_response) do
+      double(:request, success?: true, xml?: true, data: xml_parsed,
+             body: raw_xml, unauthorized?: false, bad_request?: false)
+    end
+    let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+
+    context "when request succeeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/session/success.xml") }
+
+      it "returns a hash with serialized response data" do
+        expect { subject.serialize }.to change { session.id }
+      end
+
+      it "not change session errors" do
+        expect { subject.serialize }.not_to change { session.errors.empty? }
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(http_response).to receive(:success?).and_return(false)
+        allow(http_response).to receive(:bad_request?).and_return(true)
+      end
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "change session errors" do
+        expect { subject.serialize }.to change { session.errors.empty? }
+      end
+    end
+  end
+end

data/spec/pagseguro/session_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe PagSeguro::Session do |variable|
+  describe ".create" do
+    subject { PagSeguro::Session }
+    let(:request) do
+      double(:request, success?: true, xml?: true, data: xml_parsed,
+             body: raw_xml, unauthorized?: false, bad_request?: false)
+    end
+    let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+    let(:raw_xml) { File.read("./spec/fixtures/session/success.xml") }
+
+    before do
+      allow(PagSeguro::Request).to receive(:post)
+        .with("sessions", "v2")
+        .and_return(request)
+    end
+
+    context "when request succeeds" do
+      it "creates a session" do
+        expect(subject.create).to be_a(PagSeguro::Session)
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(request).to receive(:success?).and_return(false)
+        allow(request).to receive(:bad_request?).and_return(true)
+      end
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "create a session" do
+        expect(subject.create).to be_a(PagSeguro::Session)
+      end
+
+      it "create a session with errors" do
+        expect(subject.create.errors).not_to be_empty
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction/search/search_abandoned_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe PagSeguro::SearchAbandoned do
+  describe 'it searches abandoned transactions' do
+    let(:options) { { starts_at: Time.now, ends_at: Time.now, page: 1, per_page: 10 } }
+    let(:search) { PagSeguro::SearchAbandoned.new("transactions/abandoned", options, 1) }
+    let(:source) { File.read("./spec/fixtures/transactions/search.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:response) { double(:response, data: xml, unauthorized?: false, bad_request?: false) }
+
+    describe 'the search abandoned' do
+      before do
+        FakeWeb.register_uri :get, %r[#{PagSeguro.api_url('v2/transactions/abandoned')}.*],
+          body: xml
+      end
+
+      let(:transaction) { double(:transaction) }
+
+      it 'returns an array of transactions' do
+        expect(PagSeguro::Transaction).to receive(:load_from_xml).exactly(2)
+          .times
+          .and_return(transaction)
+        expect(search.transactions).to eq([transaction, transaction])
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction/search/search_by_date_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe PagSeguro::SearchByDate do
+  describe 'it searches transactions by date' do
+    let(:options) { { starts_at: Time.now, ends_at: Time.now, per_page: 1 } }
+    let(:search) { PagSeguro::SearchByDate.new("transactions", options, 1) }
+    let(:source) { File.read("./spec/fixtures/transactions/search.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:response) { double(:response, data: xml, unauthorized?: false, bad_request?: false) }
+
+    describe 'the search by date' do
+      before do
+        FakeWeb.register_uri :get, %r[#{PagSeguro.api_url('v3/transactions')}.*], body: xml
+      end
+
+      let(:transaction) { double(:transaction) }
+
+      it 'returns an array of transactions' do
+        expect(PagSeguro::Transaction).to receive(:load_from_xml).exactly(2)
+          .times
+          .and_return(transaction)
+        expect(search.transactions).to eq([transaction, transaction])
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction/search/search_by_reference_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe PagSeguro::SearchByReference do
+  describe 'it searches transactions by reference' do
+    let(:options) { { reference: "ref1234" } }
+    let(:search) { PagSeguro::SearchByReference.new("transactions", options, 1) }
+    let(:source) { File.read("./spec/fixtures/transactions/search.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:response) { double(:response, data: xml, unauthorized?: false, bad_request?: false) }
+
+    describe 'the search by reference' do
+      before do
+        FakeWeb.register_uri :get, %r[#{PagSeguro.api_url('v3/transactions')}.*], body: xml
+      end
+
+      let(:transaction) { double(:transaction) }
+
+      it 'returns an array of transactions' do
+        expect(PagSeguro::Transaction).to receive(:load_from_xml).exactly(2)
+          .times
+          .and_return(transaction)
+        expect(search.transactions).to eq([transaction, transaction])
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction/search_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe PagSeguro::Search do
+  let(:search) { PagSeguro::Search.new("foo", "bar", 1) }
+  let(:source) { File.read("./spec/fixtures/transactions/search.xml") }
+  let(:xml) { Nokogiri::XML(source) }
+  let(:response) { double(:response, data: xml, unauthorized?: false, bad_request?: false) }
+
+  context 'when being initialized' do
+    it 'initializes with passed page number' do
+      search = PagSeguro::Search.new('/foo/bar', 'options', 1)
+      expect(search.page).to eq(1)
+    end
+
+    it 'initializes with default page number' do
+      search = PagSeguro::Search.new('/foo/bar', 'options')
+      expect(search.page).to eq(0)
+    end
+  end
+
+  describe 'methods that parse xml' do
+    before do
+      search.instance_exec(response) do |response|
+        @response = response
+        @errors = PagSeguro::Errors.new(response)
+      end
+
+      allow(search).to receive(:perform_request_and_serialize)
+    end
+
+    describe '#transactions' do
+      let(:transaction) { double(:transaction) }
+
+      it 'returns an array of transactions' do
+        expect(PagSeguro::Transaction).to receive(:load_from_xml).exactly(2)
+          .times
+          .and_return(transaction)
+        expect(search.transactions).to eq([transaction, transaction])
+      end
+    end
+
+    describe '#created_at' do
+      it 'returns the created date' do
+        expect(search.created_at).to eq(Time.parse("2011-02-16T20:14:35.000-02:00"))
+      end
+    end
+
+    describe '#results' do
+      it 'returns the number of results' do
+        expect(search.results).to eq(10)
+      end
+    end
+
+    describe '#total_pages' do
+      it 'returns the number of pages' do
+        expect(search.total_pages).to eq(1)
+      end
+    end
+  end
+
+  describe '#next_page?' do
+    context 'when there is a next page' do
+      search = PagSeguro::Search.new('foo', 'bar', 0)
+      it 'is page 0' do
+        expect(search.next_page?).to be_truthy
+      end
+
+      it 'is not page 0, but page < total_pages' do
+        allow(search).to receive(:total_pages).and_return(3)
+        expect(search.next_page?).to be_truthy
+      end
+    end
+
+    context 'when there is no next page' do
+      it 'is not page 0, but page == total_pages' do
+        allow(search).to receive(:total_pages).and_return(1)
+        expect(search.next_page?).to be_falsy
+      end
+    end
+  end
+
+  describe '#previous_page?' do
+    context 'when there is a previous page' do
+      search = PagSeguro::Search.new('foo', 'bar', 2)
+      it { expect(search.previous_page?).to be_truthy }
+    end
+
+    context 'when there is no previous page' do
+      it { expect(search.previous_page?).to be_falsy }
+    end
+  end
+
+  describe '#next_page!' do
+    it 'has next page' do
+      allow(search).to receive(:next_page?).and_return(true)
+      search.next_page!
+      expect(search.page).to eq(2)
+    end
+
+    it "doesn't have next page" do
+      allow(search).to receive(:next_page?).and_return(false)
+      search.next_page!
+      expect(search.page).to eq(1)
+    end
+  end
+
+  describe '#previous_page!' do
+    it 'has previous page' do
+      search = PagSeguro::Search.new("foo", "bar", 2)
+      search.previous_page!
+      expect(search.page).to eq(1)
+    end
+
+    it "does't have previous page" do
+      search.previous_page!
+      expect(search.page).to eq(1)
+    end
+  end
+
+  describe '#valid?' do
+    it 'is valid' do
+      allow(search).to receive(:fetch).and_return(true)
+      expect(search.valid?).to be_truthy
+    end
+
+    it "isn't valid" do
+      allow(search).to receive(:fetch).and_return(false)
+      expect(search.valid?).to be_falsy
+    end
+  end
+end

data/spec/pagseguro/transaction_installment_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe PagSeguro::TransactionInstallment do
+  it_assigns_attribute :value
+  it_assigns_attribute :quantity
+end

data/spec/pagseguro/transaction_request/request_serializer_spec.rb

@@ -0,0 +1,213 @@
+require "spec_helper"
+
+describe PagSeguro::TransactionRequest::RequestSerializer do
+  let(:transaction_request) { PagSeguro::TransactionRequest.new }
+  let(:params) { serializer.to_params }
+  subject(:serializer) { described_class.new(transaction_request) }
+
+  before do
+    transaction_request.stub({
+      payment_method: "creditCard",
+      credit_card_token: "4as56d4a56d456as456dsa"
+    })
+  end
+
+  context "global configuration serialization" do
+    before do
+      PagSeguro.receiver_email = "RECEIVER"
+    end
+
+    it { expect(params).to include(receiverEmail: PagSeguro.receiver_email) }
+  end
+
+  context "generic attributes serialization" do
+    before do
+      transaction_request.stub({
+        currency: "BRL",
+        reference: "REF123",
+        extra_amount: 1234.50,
+        notification_url: "NOTIFICATION_URL",
+        payment_mode: "default"
+      })
+    end
+
+    it { expect(params).to include(currency: "BRL") }
+    it { expect(params).to include(reference: "REF123") }
+    it { expect(params).to include(extraAmount: "1234.50") }
+    it { expect(params).to include(notificationURL: "NOTIFICATION_URL") }
+    it { expect(params).to include(paymentMethod: "creditCard") }
+    it { expect(params).to include(paymentMode: "default") }
+    it { expect(params).to include(creditCardToken: "4as56d4a56d456as456dsa") }
+  end
+
+  context "items serialization" do
+    def build_item(index)
+      PagSeguro::Item.new({
+        id: "ID#{index}",
+        description: "DESC#{index}",
+        quantity: "QTY#{index}",
+        amount: index * 100 + 0.12,
+        weight: "WEIGHT#{index}",
+        shipping_cost: index * 100 + 0.34
+      })
+    end
+
+    shared_examples_for "item serialization" do |index|
+      it { expect(params).to include("itemId#{index}" => "ID#{index}") }
+      it { expect(params).to include("itemDescription#{index}" => "DESC#{index}") }
+      it { expect(params).to include("itemAmount#{index}" => "#{index}00.12") }
+      it { expect(params).to include("itemShippingCost#{index}" => "#{index}00.34") }
+      it { expect(params).to include("itemQuantity#{index}" => "QTY#{index}") }
+      it { expect(params).to include("itemWeight#{index}" => "WEIGHT#{index}") }
+    end
+
+    before do
+      transaction_request.items << build_item(1)
+      transaction_request.items << build_item(2)
+    end
+
+    it_behaves_like "item serialization", 1
+    it_behaves_like "item serialization", 2
+  end
+
+  context "bank serialization" do
+    before do
+      allow(transaction_request).to receive(:bank) do
+        PagSeguro::Bank.new({name: "itau"})
+      end
+    end
+
+    it { expect(params).to include(bankName: "itau") }
+  end
+
+  context "holder serialization" do
+    before do
+      holder = PagSeguro::Holder.new({
+        name: "Jose Comprador",
+        birth_date: "27/10/1987",
+        document: {
+          type: "CPF",
+          value: "22111944785"
+        },
+        phone: {
+          area_code: "11",
+          number: "56273440"
+        }
+      })
+
+      transaction_request.stub({holder: holder})
+    end
+
+    it { expect(params).to include(creditCardHolderName: "Jose Comprador") }
+    it { expect(params).to include(creditCardHolderBirthDate: "27/10/1987") }
+    it { expect(params).to include(creditCardHolderCPF: "22111944785") }
+    it { expect(params).to include(creditCardHolderAreaCode: "11") }
+    it { expect(params).to include(creditCardHolderPhone: "56273440") }
+  end
+
+  context "billing address serialization" do
+    before do
+      address = PagSeguro::Address.new({
+        street: "STREET",
+        state: "STATE",
+        city: "CITY",
+        postal_code: "POSTAL_CODE",
+        district: "DISTRICT",
+        number: "NUMBER",
+        complement: "COMPLEMENT"
+      })
+
+      transaction_request.stub(billing_address: address)
+    end
+
+    it { expect(params).to include(billingAddressStreet: "STREET") }
+    it { expect(params).to include(billingAddressCountry: "BRA") }
+    it { expect(params).to include(billingAddressState: "STATE") }
+    it { expect(params).to include(billingAddressCity: "CITY") }
+    it { expect(params).to include(billingAddressPostalCode: "POSTAL_CODE") }
+    it { expect(params).to include(billingAddressDistrict: "DISTRICT") }
+    it { expect(params).to include(billingAddressNumber: "NUMBER") }
+    it { expect(params).to include(billingAddressComplement: "COMPLEMENT") }
+  end
+
+  context "sender serialization" do
+    before do
+      sender = PagSeguro::Sender.new({
+        hash: "HASH",
+        email: "EMAIL",
+        name: "NAME",
+        cpf: "CPF",
+        phone: {
+          area_code: "AREA_CODE",
+          number: "NUMBER"
+        }
+      })
+
+      transaction_request.stub(sender: sender)
+    end
+
+    it { expect(params).to include(senderHash: "HASH") }
+    it { expect(params).to include(senderEmail: "EMAIL") }
+    it { expect(params).to include(senderName: "NAME") }
+    it { expect(params).to include(senderCPF: "CPF") }
+    it { expect(params).to include(senderAreaCode: "AREA_CODE") }
+    it { expect(params).to include(senderPhone: "NUMBER") }
+  end
+
+  context "shipping serialization" do
+    before do
+      transaction_request.shipping = PagSeguro::Shipping.new({
+        type_id: 1,
+        cost: 1234.56,
+        address: {
+          street: "STREET",
+          state: "STATE",
+          city: "CITY",
+          postal_code: "POSTAL_CODE",
+          district: "DISTRICT",
+          number: "NUMBER",
+          complement: "COMPLEMENT"
+        }
+      })
+    end
+
+    it { expect(params).to include(shippingType: 1) }
+    it { expect(params).to include(shippingCost: "1234.56") }
+    it { expect(params).to include(shippingAddressStreet: "STREET") }
+    it { expect(params).to include(shippingAddressCountry: "BRA") }
+    it { expect(params).to include(shippingAddressState: "STATE") }
+    it { expect(params).to include(shippingAddressCity: "CITY") }
+    it { expect(params).to include(shippingAddressPostalCode: "POSTAL_CODE") }
+    it { expect(params).to include(shippingAddressDistrict: "DISTRICT") }
+    it { expect(params).to include(shippingAddressNumber: "NUMBER") }
+    it { expect(params).to include(shippingAddressComplement: "COMPLEMENT") }
+  end
+
+  context "installment serialization" do
+    before do
+      installment = PagSeguro::TransactionInstallment.new({
+        value: "459.50",
+        quantity: "1"
+      })
+
+      transaction_request.stub({installment: installment})
+    end
+
+    it { expect(params).to include(installmentValue: "459.50") }
+    it { expect(params).to include(installmentQuantity: "1") }
+  end
+
+  context "extra params serialization" do
+    before do
+      transaction_request.stub({
+        extra_params: [
+          { extraParam: 'param_value' },
+          { newExtraParam: 'extra_param_value' }
+        ]
+      })
+    end
+
+    it { expect(params).to include(extraParam: 'param_value') }
+    it { expect(params).to include(newExtraParam: 'extra_param_value') }
+  end
+end