pagseguro-sdk 2.6.2

data/spec/pagseguro/authorization_request/response_serializer_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe PagSeguro::AuthorizationRequest::ResponseSerializer do
+  context "when payment request is created" do
+    let(:source) { File.read("./spec/fixtures/authorization_request/success.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:serializer) { described_class.new(xml.css("authorizationRequest").first) }
+
+    subject(:data) { serializer.serialize }
+
+    it { expect(data[:code]).to eql("D8DD848AC9C98D9EE44C5FB3A1E53913") }
+    it { expect(data[:date]).to eql(Time.parse("2011-02-25T11:40:50.000-03:00")) }
+  end
+end
+

data/spec/pagseguro/authorization_request/response_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe PagSeguro::AuthorizationRequest::Response do
+  let(:http_response) do
+    response = double(body: "", code: 200, content_type: "text/xml", "[]" => nil)
+    Aitch::Response.new({xml_parser: Aitch::XMLParser}, response)
+  end
+
+  subject { described_class.new(http_response) }
+
+  describe "#serialize" do
+    context "when request succeeds" do
+      let(:serializer) { double(:serializer) }
+      let(:serialized_data) { double(:serialized_data) }
+
+      it "returns a hash with serialized response data" do
+        expect(PagSeguro::AuthorizationRequest::ResponseSerializer).to receive(:new)
+          .and_return(serializer)
+        expect(serializer).to receive(:serialize).and_return(serialized_data)
+
+        expect(subject.serialize).to eq(serialized_data)
+      end
+    end
+
+    context "when request fails" do
+      before do
+        expect(http_response).to receive(:success?).and_return(false)
+      end
+
+      it "returns a hash with an errors object" do
+        expect(subject.serialize[:errors]).to be_a(PagSeguro::Errors)
+      end
+    end
+  end
+end
+

data/spec/pagseguro/authorization_request_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe PagSeguro::AuthorizationRequest do
+  it_assigns_attribute :permissions
+  it_assigns_attribute :reference
+  it_assigns_attribute :notification_url
+  it_assigns_attribute :redirect_url
+
+  describe "#create" do
+    let(:request) { double(:request) }
+    let(:response) { double(:response) }
+    let(:credentials) { PagSeguro::ApplicationCredentials.new('app123', 'key123') }
+
+    before do
+      expect(PagSeguro::Request).to receive(:post_xml)
+        .with('authorizations/request', 'v2', credentials, data)
+        .and_return(request)
+
+      expect(PagSeguro::AuthorizationRequest::Response).to receive(:new)
+        .with(request)
+        .and_return(response)
+
+      expect(response).to receive(:serialize).and_return(serialized_data)
+    end
+
+    context "when an account is not given" do
+      let(:options) do
+        {
+          credentials: credentials,
+          notification_url: 'http://seusite.com.br/notification',
+          redirect_url: 'http://seusite.com.br/redirect',
+          permissions: [:checkouts, :searches, :notifications],
+          reference: '123'
+        }
+      end
+
+      let(:data) { File.read('./spec/fixtures/authorization_request/authorization_request.xml') }
+
+      subject { described_class.new(options) }
+
+      context "when request succeeds" do
+        let(:serialized_data) { {code: "123"} }
+
+        it "creates a transaction request" do
+          expect(response).to receive(:success?).and_return(true)
+
+          expect(subject.create).to be_truthy
+          expect(subject.code).to eq(serialized_data[:code])
+        end
+      end
+
+
+      context "when request fails" do
+        let(:serialized_data) { {errors: PagSeguro::Errors.new} }
+
+        it "does not create a transaction request" do
+          expect(response).to receive(:success?).and_return(false)
+
+          expect(subject.create).to be_falsey
+          expect(subject.code).to be_nil
+        end
+      end
+    end
+
+    context "when an account is given" do
+      let(:options) do
+        {
+          credentials: credentials,
+          permissions: [:checkouts, :searches, :notifications],
+          notification_url: 'http://seusite.com.br/notification',
+          redirect_url: 'http://seusite.com.br/redirect',
+          reference: '123',
+          account: {
+            email: 'usuario@seusite.com.br',
+            type: 'SELLER',
+            person: {
+              name: 'Antonio Carlos',
+              birth_date: '05/02/1982',
+              address: {
+                postal_code: 01452002,
+                street: 'Av. Brig. Faria Lima',
+                number: 1384,
+                complement: '5o andar',
+                district: 'Jardim Paulistano',
+                city: 'Sao Paulo',
+                state: 'SP',
+                country: 'BRA'
+              },
+              documents: [{type: 'CPF', value: 99988877766}],
+              phones: [
+                {type: 'HOME', area_code: 11, number: 30302323},
+                {type: 'MOBILE', area_code: 11, number: 976302323},
+              ]
+            }
+          }
+        }
+      end
+      let(:data) { File.read('./spec/fixtures/authorization_request/authorization_request_with_account.xml') }
+      let(:request) { double(:request) }
+      let(:response) { double(:response) }
+
+      subject { described_class.new(options) }
+
+      context "when request succeeds" do
+        let(:serialized_data) { {code: "123"} }
+
+        it "creates a transaction request send xml" do
+          expect(response).to receive(:success?).and_return(true)
+
+          expect(subject.create).to be_truthy
+          expect(subject.code).to eq(serialized_data[:code])
+        end
+      end
+
+      context "when request fails" do
+        let(:serialized_data) { {errors: PagSeguro::Errors.new} }
+
+        it "does not create a transaction request" do
+          expect(response).to receive(:success?).and_return(false)
+
+          expect(subject.create).to be_falsey
+          expect(subject.code).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/pagseguro/authorization_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe PagSeguro::Authorization do
+  let(:code) { "1234" }
+  let(:notification_code) { "4321" }
+  let(:crendentials) { double(:crendentials) }
+  let(:options) { { crendentials: crendentials} }
+  let(:request) { double(:request) }
+  let(:response) { double(:response) }
+  let(:serialized_data) { { code: 1234 } }
+  let(:authorization) { double(:authorization) }
+  let(:collection) { double(:collection) }
+
+  describe ".find_by_notification_code" do
+    before do
+      expect(PagSeguro::Request).to receive(:get)
+        .with("authorizations/notifications/4321", 'v2', options)
+        .and_return(request)
+      expect(PagSeguro::Authorization).to receive(:new)
+        .and_return(authorization)
+      expect(PagSeguro::Authorization::Response).to receive(:new)
+        .with(request, authorization)
+        .and_return(response)
+      expect(response).to receive(:serialize)
+    end
+
+    it "finds authorization by the given notificationCode" do
+      expect(PagSeguro::Authorization.find_by_notification_code(notification_code, options))
+        .to eq(authorization)
+    end
+  end
+
+  describe ".find_by_code" do
+    before do
+      expect(PagSeguro::Request).to receive(:get)
+        .with("authorizations/1234", 'v2', options)
+        .and_return(request)
+      expect(PagSeguro::Authorization).to receive(:new)
+        .and_return(authorization)
+      expect(PagSeguro::Authorization::Response).to receive(:new)
+        .with(request, authorization)
+        .and_return(response)
+      expect(response).to receive(:serialize)
+    end
+
+    it "finds authorization by the given notificationCode" do
+      expect(PagSeguro::Authorization.find_by_code(code, options)).to eq(authorization)
+    end
+  end
+
+  describe "find_by" do
+    before do
+      allow(PagSeguro::Authorization::Collection).to receive(:new)
+        .and_return(collection)
+      allow(PagSeguro::Authorization::Response).to receive(:new)
+        .with(request, collection)
+        .and_return(response)
+      allow(response).to receive(:serialize_collection)
+    end
+
+    context "with reference" do
+      let(:reference) { 'REF1111' }
+
+      it 'finds authorizations' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { reference: 'REF1111' })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(reference: 'REF1111')
+      end
+    end
+
+    context "with initial_date" do
+      let(:initial_date) { Time.new(2015, 11, 1, 12, 0) }
+
+      it 'finds authorizations' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { initialDate: initial_date.xmlschema })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(initial_date: initial_date)
+      end
+    end
+
+    context "with final_date" do
+      let(:final_date) { Time.new(2015, 11, 1, 12, 0) }
+
+      it 'finds authorizations' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { finalDate: final_date.xmlschema })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(final_date: final_date)
+      end
+    end
+
+    context "with credentials" do
+      let(:credentials) do
+        PagSeguro::ApplicationCredentials.new('APP_ID', 'APP_KEY')
+      end
+
+      it 'passes' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { credentials: credentials })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(credentials: credentials)
+      end
+    end
+  end
+end

data/spec/pagseguro/bank_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe PagSeguro::Bank do
+  it_assigns_attribute :name
+end

data/spec/pagseguro/boleto_transaction_request_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe PagSeguro::BoletoTransactionRequest do
+  describe "#payment_method" do
+    it "is boleto" do
+      expect(subject.payment_method).to eq("boleto")
+    end
+  end
+end

data/spec/pagseguro/company_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Company do
+  it_assigns_attribute :name
+  it_assigns_attribute :display_name
+  it_assigns_attribute :website_url
+
+  it_ensures_type PagSeguro::Address, :address
+  it_ensures_type PagSeguro::Partner, :partner
+  it_ensures_collection_type PagSeguro::Document, :documents, [{type: 'CPF', value: 12312312312}]
+  it_ensures_collection_type PagSeguro::Phone, :phones, [{type: 'HOME', area_code: 11, number: 12312312312}]
+end

data/spec/pagseguro/config_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe PagSeguro::Config do
+  it_behaves_like "a configuration"
+end

data/spec/pagseguro/credit_card_transaction_request_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe PagSeguro::CreditCardTransactionRequest do
+  it_assigns_attribute :credit_card_token
+
+  it_ensures_type PagSeguro::TransactionInstallment, :installment
+  it_ensures_type PagSeguro::Holder, :holder
+  it_ensures_type PagSeguro::Address, :billing_address
+
+  describe "#payment_method" do
+    it "is credit_card" do
+      expect(subject.payment_method).to eq("creditCard")
+    end
+  end
+
+  it "sets the transaction installment" do
+    installment = PagSeguro::TransactionInstallment.new
+    payment = described_class.new(installment: installment)
+
+    expect(payment.installment).to eql(installment)
+  end
+
+  it "sets the holder" do
+    holder = PagSeguro::Holder.new
+    payment = described_class.new(holder: holder)
+
+    expect(payment.holder).to eql(holder)
+  end
+
+  it "sets the billing address" do
+    address = PagSeguro::Address.new
+    payment = described_class.new(billing_address: address)
+
+    expect(payment.billing_address).to eql(address)
+  end
+end

data/spec/pagseguro/creditor_fee_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe PagSeguro::CreditorFee do
+   it_assigns_attribute :intermediation_rate_amount
+   it_assigns_attribute :intermediation_fee_amount
+   it_assigns_attribute :installment_fee_amount
+   it_assigns_attribute :operational_fee_amount
+   it_assigns_attribute :commission_fee_amount
+   it_assigns_attribute :efrete
+end

data/spec/pagseguro/document_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe PagSeguro::Document do
+  it_assigns_attribute :type
+  it_assigns_attribute :value
+
+  it '==' do
+    document = PagSeguro::Document.new(type: 'TYPE', value: 'VALUE')
+    expect(document).to eq PagSeguro::Document.new(type: 'TYPE', value: 'VALUE')
+  end
+
+  context 'helpers' do
+    it 'cpf?' do
+      expect{ subject.type = 'CPF' }.to change{ subject.cpf? }.to true
+    end
+
+    it 'cnpj?' do
+      expect{ subject.type = 'CNPJ' }.to change{ subject.cnpj? }.to true
+    end
+  end
+end

data/spec/pagseguro/documents_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Documents do
+  [
+    :size,
+    :clear,
+    :empty?,
+    :any?,
+    :each,
+    :map
+  ].each do |method|
+    it { is_expected.to respond_to(method) }
+  end
+
+  it 'should initialize empty' do
+    expect(subject).to be_empty
+  end
+
+  context 'adding a new document' do
+    let(:document) { { type: 'CPF', value: 11122233344 } }
+
+    it "shouldn't add the same document" do
+      subject << document
+      expect{ subject << document }.to_not change{ subject.size }
+    end
+
+    context 'ensures type the new document' do
+      it 'can be a hash' do
+        expect{ subject << document }.to change{ subject.size }.to(1)
+      end
+
+      it 'can be a PagSeguro::Document' do
+        expect{ subject << PagSeguro::Document.new(type: 'CPF', value: 11122233344) }.to change{ subject.size }.to(1)
+      end
+    end
+  end
+end

data/spec/pagseguro/errors_spec.rb

@@ -0,0 +1,145 @@
+# -*- encoding: utf-8 -*-
+require "spec_helper"
+
+describe PagSeguro::Errors do
+  let(:response) { double }
+  let(:http_response) do
+    double(
+      :http_response,
+      error?: true,
+      error: Aitch::UnauthorizedError
+    )
+  end
+
+  context "when have no response" do
+    it "returns errors" do
+      errors = PagSeguro::Errors.new
+      expect(errors).to be_empty
+    end
+  end
+
+  context "when unauthorized" do
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        error?: true,
+        error: Aitch::UnauthorizedError
+      )
+      errors.add(http_response)
+    end
+
+    it { expect(errors).not_to be_empty }
+    it { expect(errors).to include(I18n.t("pagseguro.errors.unauthorized")) }
+  end
+
+  context "when not found" do
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        error?: true,
+        error: Aitch::NotFoundError
+      )
+      errors.add(http_response)
+    end
+
+    it { expect(errors).not_to be_empty }
+    it { expect(errors).to include(I18n.t("pagseguro.errors.not_found")) }
+  end
+
+  context 'when forbidden' do
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        error?: true,
+        error: Aitch::ForbiddenError
+      )
+      errors.add(http_response)
+    end
+
+    it { expect(errors).not_to be_empty }
+    it { expect(errors).to include(I18n.t("pagseguro.errors.forbidden")) }
+  end
+
+  context "when message can't be translated" do
+    let(:error) {
+      <<-XML
+        <errors>
+          <error>
+            <code>1234</code>
+            <message>Sample message</message>
+          </error>
+        </errors>
+      XML
+    }
+
+    let(:xml) { Nokogiri::XML(error) }
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        data: xml,
+        error?: true,
+        error: Aitch::BadRequestError
+      )
+    end
+
+    it { expect(errors).to include("Sample message") }
+  end
+
+  context "when message can be translated" do
+    let(:error) {
+      <<-XML
+        <errors>
+          <error>
+            <code>10001</code>
+            <message>Sample message</message>
+          </error>
+        </errors>
+      XML
+    }
+
+    let(:xml) { Nokogiri::XML(error) }
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        data: xml,
+        error?: true,
+        error: Aitch::BadRequestError
+      )
+    end
+
+    it { expect(errors).to include("O parâmetro email deve ser informado.") }
+  end
+
+  context "when returning 404 status" do
+    let(:error) {
+      <<-XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <errors>
+          <error>
+              <code>Malformed request XML: {0}.</code>
+              <message>Malformed request XML: XML document structures must start and end within the same entity..</message>
+          </error>
+        </errors>
+      XML
+    }
+
+    let(:xml) { Nokogiri::XML(error) }
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        data: xml,
+        error?: true,
+        error: Aitch::BadRequestError
+      )
+      errors.add(http_response)
+    end
+
+    it { expect(errors).to include("Malformed request XML: XML document structures must start and end within the same entity..") }
+  end
+end