pagseguro-sdk 2.6.2

data/spec/pagseguro/manual_subscription_charger/request_serializer_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe PagSeguro::ManualSubscriptionCharger::RequestSerializer do
+  context '#to_xml_params' do
+    subject { described_class.new(charger) }
+
+    let(:charger) { PagSeguro::ManualSubscriptionCharger.new }
+
+    it 'should serializer reference' do
+      charger.reference = 'ref-1234'
+
+      expect(subject.to_xml_params).to match %r[
+        <payment>
+          .*<reference>ref-1234
+        ]xm
+    end
+
+    it 'should serializer subscription code' do
+      charger.subscription_code = '12345'
+
+      expect(subject.to_xml_params).to match %r[
+        <payment>
+          .*<preApprovalCode>12345
+        ]xm
+    end
+
+    context "serialize items'" do
+      before do
+        charger.items = items
+      end
+
+      subject do
+        described_class.new(charger).to_xml_params
+      end
+
+      let(:items) do
+        [
+          { id: 669, description: 'Insurance', amount: 10.0, quantity: 1 }
+        ]
+      end
+
+      it do
+        is_expected.to match %r[
+          <payment>
+          .*<items>
+            .*<item>
+              .*<id>669
+        ]xm
+      end
+
+      it do
+        is_expected.to match %r[
+          <payment>
+          .*<items>
+            .*<item>
+              .*<description>Insurance
+        ]xm
+      end
+
+      it do
+        is_expected.to match %r[
+          <payment>
+          .*<items>
+            .*<item>
+              .*<quantity>1
+        ]xm
+      end
+
+      it do
+        is_expected.to match %r[
+          <payment>
+          .*<items>
+            .*<item>
+              .*<amount>10.00
+        ]xm
+      end
+    end
+  end
+end

data/spec/pagseguro/manual_subscription_charger/response_serializer_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe PagSeguro::ManualSubscriptionCharger::ResponseSerializer do
+  let(:source) { File.read('./spec/fixtures/manual_subscription_charger/success.xml') }
+  let(:xml) { Nokogiri::XML(source) }
+
+  subject { described_class.new(xml) }
+
+  it { expect(subject.serialize[:transaction_code]).to eql('D9AD1EA3DEB544A6A413E33BD4822225') }
+end

data/spec/pagseguro/manual_subscription_charger/response_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::ManualSubscriptionCharger::Response do
+  subject { PagSeguro::ManualSubscriptionCharger::Response.new(http_response, plan) }
+  let(:plan) { PagSeguro::ManualSubscriptionCharger.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,
+        not_found?: false
+      )
+    end
+
+    let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+
+    context 'when request succeeds' do
+      let(:raw_xml) { File.read('./spec/fixtures/manual_subscription_charger/success.xml') }
+
+      it 'returns a hash with serialized response data' do
+        expect { subject.serialize }.to change { plan.transaction_code }
+      end
+
+      it 'not change subscription plan errors' do
+        expect { subject.serialize }.not_to change { plan.errors.empty? }
+      end
+    end
+
+    context 'when request fails' do
+      before do
+        allow(http_response).to receive_messages(
+          success?: false,
+          error?: true,
+          error: Aitch::BadRequestError
+        )
+      end
+
+      let(:raw_xml) { File.read('./spec/fixtures/manual_subscription_charger/fail.xml') }
+
+      it 'change subscription plan errors' do
+        expect { subject.serialize }.to change { plan.errors.empty? }
+      end
+    end
+  end
+end

data/spec/pagseguro/manual_subscription_charger_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe PagSeguro::ManualSubscriptionCharger do
+  it_assigns_attribute :reference
+  it_assigns_attribute :subscription_code
+  it_assigns_attribute :transaction_code
+
+  it_ensures_collection_type PagSeguro::Item, :items, [{id: '123', description: 'abc', amount: 100.00, quantity: 1}]
+
+  context 'errors attribute' do
+    it 'should start with errors' do
+      expect(subject.errors).to be_a PagSeguro::Errors
+    end
+
+    it 'should start with empty errors' do
+      expect(subject.errors).to be_empty
+    end
+  end
+
+  describe '#create' do
+    before do
+      subject.credentials = credentials
+
+      FakeWeb.register_uri(
+        :post,
+        'https://ws.pagseguro.uol.com.br/v2/pre-approvals/payment?email=user@example.com&token=TOKEN',
+        body: ''
+      )
+    end
+
+    let(:credentials) do
+      PagSeguro::AccountCredentials.new('user@example.com', 'TOKEN')
+    end
+
+    let(:request) do
+      double(
+        :Request,
+        success?: true,
+        xml?: true,
+        body: '<result><transactionCode>1234</transactionCode><date>2011-08-19T14:47:59.000-03:00</date></result>'
+      )
+    end
+
+    it 'sends it to correct url' do
+      expect(PagSeguro).to receive(:api_url).with(
+        'v2/pre-approvals/payment?email=user@example.com&token=TOKEN'
+      ).and_return('https://ws.pagseguro.uol.com.br/v2/pre-approvals/payment?email=user@example.com&token=TOKEN')
+
+      subject.create
+    end
+
+    context 'when creating' do
+      it 'send to correct url' do
+        expect(PagSeguro::Request).to receive(:post_xml).with(
+          'pre-approvals/payment', :v2, credentials, a_string_matching(/<payment>/)
+        ).and_return(request)
+
+        subject.create
+      end
+
+      it 'update with the new transaction_code' do
+        allow(PagSeguro::Request).to receive(:post_xml).and_return(request)
+
+        expect { subject.create }.to change { subject.transaction_code }.to('1234')
+      end
+    end
+  end
+end

data/spec/pagseguro/notification_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe PagSeguro::Notification do
+  it_assigns_attribute :code
+  it_assigns_attribute :type
+end

data/spec/pagseguro/online_debit_transaction_request_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe PagSeguro::OnlineDebitTransactionRequest do
+  it_ensures_type PagSeguro::Bank, :bank
+
+  describe "#payment_method" do
+    it "is online_debit" do
+      expect(subject.payment_method).to eq("online_debit")
+    end
+  end
+
+  it "sets the bank" do
+    bank = PagSeguro::Bank.new
+    payment = described_class.new(bank: bank)
+
+    expect(payment.bank).to eq(bank)
+  end
+end

data/spec/pagseguro/pagseguro_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe PagSeguro do
+  before do
+    PagSeguro.configure do |config|
+      config.app_id = "APP123"
+      config.app_key = "APPTOKEN"
+      config.email = "EMAIL"
+      config.token = "TOKEN"
+      config.receiver_email = "RECEIVER_EMAIL"
+    end
+  end
+
+  after do
+    PagSeguro.configuration.environment = :production
+  end
+
+  it { expect(PagSeguro.email).to eql("EMAIL") }
+  it { expect(PagSeguro.token).to eql("TOKEN") }
+  it { expect(PagSeguro.receiver_email).to eql("RECEIVER_EMAIL") }
+
+  context "config delegation" do
+    subject { PagSeguro }
+    it_behaves_like "a configuration"
+  end
+
+  context "configuring library" do
+    it "yields PagSeguro::Config" do
+      expect {|block|
+        PagSeguro.configure(&block)
+      }.to yield_with_args(PagSeguro::Config)
+    end
+  end
+
+  context "default settings" do
+    it { expect(PagSeguro.configuration.encoding).to eql("UTF-8") }
+    it { expect(PagSeguro.configuration.environment).to eql(:production) }
+    it { expect(PagSeguro.account_credentials.email).to eql("EMAIL") }
+    it { expect(PagSeguro.account_credentials.token).to eql("TOKEN") }
+    it { expect(PagSeguro.application_credentials.app_id).to eql("APP123") }
+    it { expect(PagSeguro.application_credentials.app_key).to eql("APPTOKEN") }
+  end
+
+  describe ".api_url" do
+    it "raises when environment has no endpoint" do
+      PagSeguro.configuration.environment = :invalid
+
+      expect {
+        PagSeguro.api_url("/")
+      }.to raise_exception(PagSeguro::InvalidEnvironmentError)
+    end
+
+    it "returns production api url when the environment is :production" do
+      expect(PagSeguro.api_url("v2/some/path")).to eql("https://ws.pagseguro.uol.com.br/v2/some/path")
+    end
+
+    it "returns sandbox api url when the environment is :sandbox" do
+      PagSeguro.configuration.environment = :sandbox
+
+      expect(PagSeguro.api_url("v2/some/path")).to eql("https://ws.sandbox.pagseguro.uol.com.br/v2/some/path")
+    end
+  end
+
+  describe ".site_url" do
+    it "raises when environment has no endpoint" do
+      PagSeguro.configuration.environment = :invalid
+
+      expect {
+        PagSeguro.site_url("/")
+      }.to raise_exception(PagSeguro::InvalidEnvironmentError)
+    end
+
+    it "returns production site url when the environment is production" do
+      expect(PagSeguro.site_url("v2/some/path")).to eql("https://pagseguro.uol.com.br/v2/some/path")
+    end
+
+    it "returns sandbox site url when the environment is :sandbox" do
+      PagSeguro.configuration.environment = :sandbox
+      expect(PagSeguro.site_url("v2/some/path")).to eql("https://sandbox.pagseguro.uol.com.br/v2/some/path")
+    end
+  end
+end

data/spec/pagseguro/partner_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Partner do
+  it_assigns_attribute :name
+  it_assigns_attribute :birth_date
+
+  it_ensures_collection_type PagSeguro::Document, :documents, [{type: 'CPF', value: 12312312312}]
+end

data/spec/pagseguro/payment_method_spec.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+require "spec_helper"
+
+shared_examples_for "type mapping" do |id, type|
+  it "returns #{type.inspect} as type when id is #{id}" do
+    expect(PagSeguro::PaymentMethod.new(type_id: id).type).to eql(type)
+  end
+end
+
+describe PagSeguro::PaymentMethod do
+  context "type mapping" do
+    it_behaves_like "type mapping", nil, :not_set
+    it_behaves_like "type mapping", 1, :credit_card
+    it_behaves_like "type mapping", 2, :boleto
+    it_behaves_like "type mapping", 3, :online_transfer
+    it_behaves_like "type mapping", 4, :balance
+    it_behaves_like "type mapping", 5, :oi_paggo
+    it_behaves_like "type mapping", 7, :direct_deposit
+
+    it "raises for invalid id" do
+      expect {
+        PagSeguro::PaymentMethod.new(type_id: "invalid").type
+      }.to raise_exception("PagSeguro::PaymentMethod#type_id isn't mapped")
+    end
+  end
+
+  context "shortcuts" do
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 1)).to be_credit_card }
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 2)).to be_boleto }
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 3)).to be_online_transfer }
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 4)).to be_balance }
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 5)).to be_oi_paggo }
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 7)).to be_direct_deposit }
+
+    it { expect(PagSeguro::PaymentMethod.new(type_id: 5)).not_to be_credit_card }
+  end
+
+  context "description" do
+    subject(:payment_method) { PagSeguro::PaymentMethod.new(code: 102) }
+    it { expect(payment_method.description).to eql("Cartão de crédito MasterCard") }
+  end
+end

data/spec/pagseguro/payment_release_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe PagSeguro::PaymentRelease do
+   it_assigns_attribute :installment
+   it_assigns_attribute :total_amount
+   it_assigns_attribute :release_amount
+   it_assigns_attribute :release_date
+   it_assigns_attribute :status
+end

data/spec/pagseguro/payment_releases_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe PagSeguro::PaymentReleases do
+  it "implements #each" do
+    expect(PagSeguro::PaymentReleases.new).to respond_to(:each)
+  end
+
+  it "includes Enumerable" do
+    expect(PagSeguro::PaymentReleases.included_modules).to include(Enumerable)
+  end
+
+  it "sets payment" do
+    payment = PagSeguro::PaymentRelease.new
+    payments = PagSeguro::PaymentReleases.new
+    payments << payment
+
+    expect(payments.size).to eql(1)
+    expect(payments).to include(payment)
+  end
+
+  it "sets payment releases from Hash" do
+    payment = PagSeguro::PaymentRelease.new(installment: 1)
+
+    expect(PagSeguro::PaymentRelease).to(
+      receive(:new)
+      .with({installment: 1})
+      .and_return(payment))
+
+    payments = PagSeguro::PaymentReleases.new
+    payments << {installment: 1}
+
+    expect(payments).to include(payment)
+  end
+end

data/spec/pagseguro/payment_request/request_serializer_spec.rb

@@ -0,0 +1,283 @@
+require "spec_helper"
+
+describe PagSeguro::PaymentRequest::RequestSerializer do
+  context '#to_xml_params' do
+    subject { described_class.new(payment) }
+
+    let(:payment) { PagSeguro::PaymentRequest.new }
+
+    it 'should serializer primary receivers' do
+      payment.primary_receiver = 'a@example.com'
+      expect(subject.to_xml_params).to match %r[<primaryReceiver>.*<email>a@example.com<\/email>.*<\/primaryReceiver>]m
+    end
+
+    it 'should serializer other receivers' do
+      payment.receivers = [
+        {
+          email: 'a@example.com',
+          split: {
+            amount: 10,
+            fee_percent: 11,
+            rate_percent: 12
+          }
+        }
+      ]
+      expect(subject.to_xml_params).to match %r[<receivers>.*<receiver>.*<email>a@example.com<\/email>]m
+    end
+
+    it 'should serializer sender' do
+      payment.sender = PagSeguro::Sender.new(
+        name: 'Sender',
+        email: 'b@example.com',
+        phone: PagSeguro::Phone.new(area_code: 51, number: 2)
+      )
+      expect(subject.to_xml_params).to match %r[<sender>.*<name>Sender<\/name>.*<email>b@example.com<\/email>.*<phone>.*<areaCode>51<\/areaCode>.*<number>2<\/number>]m
+    end
+
+    context 'should serialize sender document' do
+      it 'when it was CPF' do
+        payment.sender = PagSeguro::Sender.new(document: PagSeguro::Document.new(type: 'CPF', value: '12312312312'))
+
+        expect(subject.to_xml_params).to match %r[
+          .*<sender>
+            .*<documents>
+              .*<document>
+                .*<type>CPF</type>
+                .*<value>12312312312</value>
+              .*</document>
+            .*</documents>
+          .*</sender>
+        ]mx
+      end
+
+      it 'when it was CNPJ' do
+        payment.sender = PagSeguro::Sender.new(document: PagSeguro::Document.new(type: 'CNPJ', value: '12123123000112'))
+
+        expect(subject.to_xml_params).to match %r[
+          .*<sender>
+            .*<documents>
+              .*<document>
+                .*<type>CNPJ</type>
+                .*<value>12123123000112</value>
+              .*</document>
+            .*</documents>
+          .*</sender>
+        ]mx
+      end
+    end
+
+    it 'should serializer currency' do
+      payment.currency = 'BRL'
+      expect(subject.to_xml_params).to match %r[<currency>BRL</currency>]
+    end
+
+    it 'should serializer reference' do
+      payment.reference = 'order123'
+      expect(subject.to_xml_params).to match %r[<reference>order123</reference>]
+    end
+
+    it 'should serializer redirect url' do
+      payment.redirect_url = 'http://example.com'
+      expect(subject.to_xml_params).to match %r[<redirectURL>http://example.com</redirectURL>]
+    end
+
+    it 'should serializer notification url' do
+      payment.notification_url = 'http://example.com'
+      expect(subject.to_xml_params).to match %r[<notificationURL>http://example.com</notificationURL>]
+    end
+
+    context 'should serializer item' do
+      before do
+        payment.items << { id: 1, description: 'Description#1', quantity: 2, amount: 3, weight: 4, shipping_cost: 5 }
+      end
+
+      it 'to include id' do
+        expect(subject.to_xml_params).to match %r[<id>1</id>]
+      end
+
+      it 'to include description' do
+        expect(subject.to_xml_params).to match %r[<description>Description#1</description>]
+      end
+
+      it 'to include quantity' do
+        expect(subject.to_xml_params).to match %r[<quantity>2</quantity>]
+      end
+
+      it 'to include amount' do
+        expect(subject.to_xml_params).to match %r[<amount>3.00</amount>]
+      end
+
+      it 'to include weight' do
+        expect(subject.to_xml_params).to match %r[<weight>4</weight>]
+      end
+
+      it 'to include weight' do
+        expect(subject.to_xml_params).to match %r[<shippingCost>5.00</shippingCost>]
+      end
+    end
+  end
+
+  context '#to_params' do
+    let(:payment_request) { PagSeguro::PaymentRequest.new }
+    let(:params) { serializer.to_params }
+    subject(:serializer) { described_class.new(payment_request) }
+
+    context "global configuration serialization" do
+      before do
+        PagSeguro.configuration.receiver_email = "RECEIVER"
+      end
+
+      it { expect(params).to include(receiverEmail: PagSeguro.configuration.receiver_email) }
+    end
+
+    context "generic attributes serialization" do
+      let(:payment_request) do
+        double(:PaymentRequest,
+          currency: "BRL",
+          reference: "REF123",
+          extra_amount: 1234.50,
+          redirect_url: "REDIRECT_URL",
+          notification_url: "NOTIFICATION_URL",
+          abandon_url: "ABANDON_URL",
+          max_uses: 5,
+          max_age: 3600,
+        ).as_null_object
+      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(redirectURL: "REDIRECT_URL") }
+      it { expect(params).to include(notificationURL: "NOTIFICATION_URL") }
+      it { expect(params).to include(abandonURL: "ABANDON_URL") }
+      it { expect(params).to include(maxUses: 5) }
+      it { expect(params).to include(maxAge: 3600) }
+    end
+
+    context "shipping serialization" do
+      before do
+        payment_request.shipping = PagSeguro::Shipping.new({
+          type_id: 1,
+          cost: 1234.56
+        })
+      end
+
+      it { expect(params).to include(shippingType: 1) }
+      it { expect(params).to include(shippingCost: "1234.56") }
+    end
+
+    context "address serialization" do
+      let(:address) do
+        PagSeguro::Address.new(
+          street: "STREET",
+          state: "STATE",
+          city: "CITY",
+          postal_code: "POSTAL_CODE",
+          district: "DISTRICT",
+          number: "NUMBER",
+          complement: "COMPLEMENT"
+        )
+      end
+      let(:payment_request) do
+        double(:PaymentRequest, shipping: shipping).as_null_object
+      end
+      let(:shipping) do
+        double(:Shipping, address: address).as_null_object
+      end
+
+      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 'sender serialize' do
+      before do
+        sender = PagSeguro::Sender.new(
+          name: 'NAME',
+          email: 'EMAIL',
+          phone: { area_code: 'AREA_CODE', number: 'NUMBER' }
+        )
+
+        allow(payment_request).to receive(:sender).and_return(sender)
+      end
+
+      it { expect(params).to include(senderName: 'NAME') }
+      it { expect(params).to include(senderEmail: 'EMAIL') }
+
+      context "phone" do
+        it { expect(params).to include(senderAreaCode: "AREA_CODE") }
+        it { expect(params).to include(senderPhone: "NUMBER") }
+      end
+
+      context 'documents' do
+        it 'when is CPF' do
+          payment_request.sender.document = PagSeguro::Document.new(type: 'CPF', value: '12312312312')
+          expect(params).to include(senderCPF: '12312312312')
+        end
+
+        it 'when is CNPJ' do
+          payment_request.sender.document = PagSeguro::Document.new(type: 'CNPJ', value: '12123123000112')
+          expect(params).to include(senderCNPJ: '12123123000112')
+        end
+      end
+    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
+        payment_request.items << build_item(1)
+        payment_request.items << build_item(2)
+      end
+
+      it_behaves_like "item serialization", 1
+      it_behaves_like "item serialization", 2
+    end
+
+    context "credentials serialization" do
+      before do
+        credentials = PagSeguro::ApplicationCredentials.new(
+          "app123", "qwerty", "authocode"
+        )
+
+        payment_request.stub(credentials: credentials)
+      end
+    end
+
+    context "extra params serialization" do
+      let(:payment_request) do
+        double(:PaymentRequest,
+          extra_params: [
+            { extraParam: 'param_value' },
+            { newExtraParam: 'extra_param_value' }
+          ]).as_null_object
+      end
+
+      it { expect(params).to include(extraParam: 'param_value') }
+      it { expect(params).to include(newExtraParam: 'extra_param_value') }
+    end
+  end
+end