pagseguro-sdk 2.6.2

data/spec/pagseguro/payment_request/response_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe PagSeguro::PaymentRequest::Response do
+  context "when payment request is created" do
+    let(:http_response) { xml_response("payment_request/success.xml") }
+    subject(:response) { described_class.new(http_response) }
+
+    it { expect(response.code).to eql("8CF4BE7DCECEF0F004A6DFA0A8243412") }
+    it { expect(response.created_at).to eql(Time.parse("2010-12-02T10:11:28.000-02:00")) }
+    it { expect(response.url).to eql("https://pagseguro.uol.com.br/v2/checkout/payment.html?code=8CF4BE7DCECEF0F004A6DFA0A8243412") }
+  end
+end
+

data/spec/pagseguro/payment_request_spec.rb

@@ -0,0 +1,148 @@
+require "spec_helper"
+
+describe PagSeguro::PaymentRequest do
+  it_assigns_attribute :primary_receiver
+  it_assigns_attribute :currency
+  it_assigns_attribute :redirect_url
+  it_assigns_attribute :extra_amount
+  it_assigns_attribute :reference
+  it_assigns_attribute :max_age
+  it_assigns_attribute :max_uses
+  it_assigns_attribute :notification_url
+  it_assigns_attribute :abandon_url
+
+  it_ensures_type PagSeguro::Sender, :sender
+  it_ensures_type PagSeguro::Shipping, :shipping
+
+  it "sets the sender" do
+    sender = PagSeguro::Sender.new
+    payment = PagSeguro::PaymentRequest.new(sender: sender)
+
+    expect(payment.sender).to eql(sender)
+  end
+
+  describe '#register split payment' do
+    before do
+      FakeWeb.register_uri(
+        :post,
+        'https://ws.pagseguro.uol.com.br/v2/checkouts?appId=id&appKey=key',
+        body: ""
+      )
+    end
+
+
+    let(:subject) do
+      PagSeguro::PaymentRequest.new(
+        receivers: receivers,
+        credentials: credentials,
+        primary_receiver: 'primary@example.com',
+        sender: sender
+      )
+    end
+
+    let(:credentials) do
+      PagSeguro::ApplicationCredentials.new('id', 'key')
+    end
+
+    let(:sender) do
+      PagSeguro::Sender.new(phone: PagSeguro::Phone.new(area_code: 1, number: 2345))
+    end
+
+    let(:receivers) do
+      [
+        { email: 'a@example.com', split: { amount: 1 } },
+        { email: 'b@example.com', split: { amount: 1 } }
+      ]
+    end
+
+    context 'ensure receivers' do
+      it 'are PagSeguro::Receiver' do
+        subject.receivers.each do |receiver|
+          expect(receiver).to be_a(PagSeguro::Receiver)
+        end
+      end
+
+      it 'have correct keys' do
+        expect(subject.receivers[0].email).to eq 'a@example.com'
+      end
+    end
+
+    it "changes url to checkouts" do
+      expect(PagSeguro::Request).to receive(:post_xml).with(
+        'checkouts', 'v2', credentials, a_string_matching(/<checkout>/)
+      )
+
+      subject.register
+    end
+  end
+
+  it "sets the items" do
+    payment = PagSeguro::PaymentRequest.new
+    expect(payment.items).to be_a(PagSeguro::Items)
+  end
+
+  it "sets default currency" do
+    payment = PagSeguro::PaymentRequest.new
+    expect(payment.currency).to eql("BRL")
+  end
+
+  describe "#register" do
+    let(:payment) { PagSeguro::PaymentRequest.new }
+    before { FakeWeb.register_uri :any, %r[.*?], body: "" }
+
+    it "serializes payment request" do
+      allow_any_instance_of(PagSeguro::PaymentRequest::RequestSerializer)
+        .to receive(:new)
+        .with(payment)
+        .and_return(double.as_null_object)
+
+      payment.register
+    end
+
+    it "performs request" do
+      params = double(:Params)
+
+      allow_any_instance_of(PagSeguro::PaymentRequest::RequestSerializer).to receive(:to_params).and_return(params)
+
+      expect(PagSeguro::Request)
+        .to receive(:post)
+        .with("checkout", "v2", params)
+
+      payment.register
+    end
+
+    it "initializes response" do
+      response = double
+      allow(PagSeguro::Request).to receive(:post).and_return(response)
+
+      expect(PagSeguro::PaymentRequest::Response)
+        .to receive(:new)
+        .with(response)
+
+      payment.register
+    end
+
+    it "returns response" do
+      response = double
+      allow(PagSeguro::PaymentRequest::Response).to receive(:new).and_return(response)
+
+      expect(payment.register).to eql(response)
+    end
+  end
+
+  describe "#extra_params" do
+    it "is empty before initialization" do
+      expect(subject.extra_params).to be_empty
+    end
+
+    it "allows extra parameter addition" do
+      subject.extra_params << { extraParam: 'value' }
+      subject.extra_params << { itemParam1: 'value1' }
+
+      expect(subject.extra_params).to eql([
+        { extraParam: 'value' },
+        { itemParam1: 'value1' }
+      ])
+    end
+  end
+end

data/spec/pagseguro/payment_status_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require "spec_helper"
+
+shared_examples_for "payment status mapping" do |id, status, description|
+  let(:payment_status) { PagSeguro::PaymentStatus.new(id) }
+
+  it "returns #{status} as status when id is #{id}" do
+    expect(payment_status.status).to eql(status)
+  end
+
+  it "detects as #{status}" do
+    expect(payment_status.public_send("#{status}?")).to be
+  end
+
+  it "described as #{description}" do
+    expect(payment_status.description).to eq(description)
+  end
+end
+
+describe PagSeguro::PaymentStatus do
+  context "status mapping" do
+    it_behaves_like "payment status mapping", 0, :initiated, 'Iniciada'
+    it_behaves_like "payment status mapping", 1, :waiting_payment, 'Aguardando pagamento'
+    it_behaves_like "payment status mapping", 2, :in_analysis, 'Em análise'
+    it_behaves_like "payment status mapping", 3, :paid, 'Paga'
+    it_behaves_like "payment status mapping", 4, :available, 'Disponível'
+    it_behaves_like "payment status mapping", 5, :in_dispute, 'Em disputa'
+    it_behaves_like "payment status mapping", 6, :refunded, 'Devolvida'
+    it_behaves_like "payment status mapping", 7, :cancelled, 'Cancelada'
+    it_behaves_like "payment status mapping", 8, :chargeback_charged, 'Chargeback debitado'
+    it_behaves_like "payment status mapping", 9, :contested, 'Em contestação'
+  end
+end

data/spec/pagseguro/permission_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe PagSeguro::Permission do
+  it_assigns_attribute :code
+  it_assigns_attribute :status
+  it_assigns_attribute :last_update
+end

data/spec/pagseguro/person_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Person do
+  it_assigns_attribute :name
+  it_assigns_attribute :birth_date
+
+  it_ensures_type PagSeguro::Address, :address
+  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/phone_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe PagSeguro::Phone do
+  it_assigns_attribute :area_code
+  it_assigns_attribute :number
+end

data/spec/pagseguro/phones_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Phones 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 phone' do
+    let(:phone) { { type: 'HOME', area_code: 11, number: 11112222 } }
+
+    it "shouldn't add the same phone" do
+      subject << phone
+      expect{ subject << phone }.to_not change{ subject.size }
+    end
+
+    context 'ensures type the new phone' do
+      it 'can be a hash' do
+        expect{ subject << phone }.to change{ subject.size }.to(1)
+      end
+
+      it 'can be a PagSeguro::Phone' do
+        phone = PagSeguro::Phone.new(type: 'MOBILE', area_code: 11, number: 22221111)
+        expect{ subject << phone }.to change{ subject.size }.to(1)
+      end
+    end
+  end
+end

data/spec/pagseguro/receiver_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe PagSeguro::Receiver do
+  it_assigns_attribute :email
+  it_assigns_attribute :public_key
+  it_ensures_type PagSeguro::ReceiverSplit, :split
+end

data/spec/pagseguro/receiver_split_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe PagSeguro::ReceiverSplit do
+  it_assigns_attribute :amount
+  it_assigns_attribute :rate_percent
+  it_assigns_attribute :fee_percent
+end

data/spec/pagseguro/request_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe PagSeguro::Request do
+  context "default headers" do
+    subject(:headers) { PagSeguro::Request.config.default_headers }
+
+    it { should include("lib-description" => "ruby:#{PagSeguro::VERSION}") }
+    it { should include("language-engine-description" => "ruby:#{RUBY_VERSION}") }
+  end
+
+  context "POST request" do
+    before do
+      FakeWeb.register_uri :post, %r[.+], body: "BODY"
+    end
+
+    it "includes credentials" do
+      PagSeguro.configuration.email = "EMAIL"
+      PagSeguro.configuration.token = "TOKEN"
+      PagSeguro::Request.post("checkout", "v3")
+
+      expect(FakeWeb.last_request.body).to include("email=EMAIL&token=TOKEN")
+    end
+
+    it "includes custom credentials" do
+      PagSeguro.configuration.email = "EMAIL"
+      PagSeguro.configuration.token = "TOKEN"
+      PagSeguro::Request.post("checkout", "v3", email: 'foo', token: 'bar')
+
+      expect(FakeWeb.last_request.body).to include("email=foo&token=bar")
+    end
+
+    it "includes encoding" do
+      PagSeguro::Request.post("checkout", "v3")
+      expect(FakeWeb.last_request.body).to include("charset=UTF-8")
+    end
+
+    it "include request headers" do
+      PagSeguro::Request.post("checkout", "v3")
+      request = FakeWeb.last_request
+
+      expect(request["Accept-Charset"]).to eql("UTF-8")
+      expect(request["Content-Type"]).to eql("application/x-www-form-urlencoded; charset=UTF-8")
+      expect(request["lib-description"]).to be
+      expect(request["language-engine-description"]).to be
+    end
+
+    context "when POST request with XML data" do
+      let(:credentials) { PagSeguro::ApplicationCredentials.new('app123', 'key123') }
+      let(:xml) { File.read('./spec/fixtures/authorization_request/authorization_request.xml') }
+
+      before do
+        PagSeguro::Request.post_xml('authorizations/request', 'v2', credentials, xml)
+      end
+
+      let(:request) { FakeWeb.last_request }
+
+      it 'include request headers' do
+        expect(request["Content-Type"]).to eq "application/xml; charset=#{PagSeguro.encoding}"
+      end
+
+      it 'include data xml' do
+        expect(request.body).to eq xml
+      end
+
+      it 'correct url' do
+        expect(request.path).to eq '/v2/authorizations/request?appId=app123&appKey=key123'
+      end
+    end
+  end
+
+  context "GET request" do
+    before do
+      FakeWeb.register_uri :get, %r[.+], body: "BODY"
+    end
+
+    context "when global acoount config is set" do
+      it "includes account credentials" do
+        PagSeguro.configure do |config|
+          config.email = "EMAIL"
+          config.token = "TOKEN"
+        end
+        PagSeguro::Request.get("checkout", "v3")
+
+        expect(FakeWeb.last_request.path).to include("email=EMAIL&token=TOKEN")
+      end
+    end
+
+    context "when global app config is set" do
+      it "includes application credentials" do
+        PagSeguro.configure do |config|
+          config.app_id = "APP123"
+          config.app_key = "APPKEY"
+        end
+        PagSeguro::Request.get("checkout", "v3")
+
+        expect(FakeWeb.last_request.path).to include("appId=APP123&appKey=APPKEY")
+      end
+    end
+
+    it "includes encoding" do
+      PagSeguro::Request.get("checkout", "v3")
+      expect(FakeWeb.last_request.path).to include("charset=UTF-8")
+    end
+
+    it "include request headers" do
+      PagSeguro::Request.get("checkout", "v3")
+      request = FakeWeb.last_request
+
+      expect(request["Accept-Charset"]).to eql("UTF-8")
+      expect(request["lib-description"]).to be
+      expect(request["language-engine-description"]).to be
+    end
+  end
+end

data/spec/pagseguro/sender_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe PagSeguro::Sender do
+  it_assigns_attribute :name
+  it_assigns_attribute :email
+  it_assigns_attribute :hash
+  it_assigns_attribute :ip
+
+  it_ensures_type PagSeguro::Phone, :phone
+  it_ensures_type PagSeguro::Address, :address
+
+  it_ensures_collection_type PagSeguro::Document, :documents, [{type: 'CPF', value: 12312312312}]
+
+  context 'when assign document' do
+    it 'documents collection should increasing by 1' do
+      expect{ subject.document = { type: 'CPF', value: 'VALUE' } }.to change{ subject.documents.size }.to 1
+    end
+
+    it 'document collection should have the document added' do
+      subject.document = { type: 'CPF', value: 'VALUE' }
+      expect(subject.documents.first).to eq PagSeguro::Document.new(type: 'CPF', value: 'VALUE')
+    end
+  end
+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,57 @@
+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,
+             not_found?: 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_messages(
+          success?: false,
+          error?: true,
+          error: Aitch::BadRequestError
+        )
+      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