pagseguro-oficial 2.0.5

data/spec/pagseguro/pagseguro_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe PagSeguro do
+  before do
+    PagSeguro.email = "EMAIL"
+    PagSeguro.token = "TOKEN"
+    PagSeguro.receiver_email = "RECEIVER_EMAIL"
+  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 "configuring library" do
+    it "yields PagSeguro" do
+      expect {|block|
+        PagSeguro.configure(&block)
+      }.to yield_with_args(PagSeguro)
+    end
+  end
+
+  context "default settings" do
+    it { expect(PagSeguro.encoding).to eql("UTF-8") }
+    it { expect(PagSeguro.environment).to eql(:production) }
+  end
+
+  describe ".api_url" do
+    it "raises when environment has no endpoint" do
+      PagSeguro.environment = :invalid
+
+      expect {
+        PagSeguro.api_url("/")
+      }.to raise_exception(PagSeguro::InvalidEnvironmentError)
+    end
+
+    it "returns api url" do
+      expect(PagSeguro.api_url("/some/path")).to eql("https://ws.pagseguro.uol.com.br/v2/some/path")
+    end
+  end
+
+  describe ".site_url" do
+    it "raises when environment has no endpoint" do
+      PagSeguro.environment = :invalid
+
+      expect {
+        PagSeguro.site_url("/")
+      }.to raise_exception(PagSeguro::InvalidEnvironmentError)
+    end
+
+    it "returns site url" do
+      expect(PagSeguro.site_url("/some/path")).to eql("https://pagseguro.uol.com.br/v2/some/path")
+    end
+  end
+end

data/spec/pagseguro/payment_method_spec.rb

@@ -0,0 +1,41 @@
+# -*- 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", 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_request/response_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe PagSeguro::PaymentRequest::Response do
+  context "when payment request is created" do
+    def xml_response(path)
+      response = double(
+        body: File.read("./spec/fixtures/#{path}"),
+        code: 200,
+        content_type: "text/xml",
+        "[]" => nil
+      )
+
+      Aitch::Response.new({xml_parser: Aitch::XMLParser}, response)
+    end
+
+    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/serializer_spec.rb

@@ -0,0 +1,142 @@
+require "spec_helper"
+
+describe PagSeguro::PaymentRequest::Serializer 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.receiver_email = "RECEIVER"
+    end
+
+    it { expect(params).to include(receiverEmail: PagSeguro.receiver_email) }
+  end
+
+  context "generic attributes serialization" do
+    before do
+      payment_request.stub({
+        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
+      })
+    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
+    before do
+      address = PagSeguro::Address.new({
+        street: "STREET",
+        state: "STATE",
+        city: "CITY",
+        postal_code: "POSTAL_CODE",
+        district: "DISTRICT",
+        number: "NUMBER",
+        complement: "COMPLEMENT"
+      })
+
+      shipping = double(address: address).as_null_object
+
+      payment_request.stub(
+        shipping: shipping
+      )
+    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 serialization" do
+    before do
+      sender = PagSeguro::Sender.new({
+        email: "EMAIL",
+        name: "NAME",
+        cpf: "CPF"
+      })
+
+      payment_request.stub(sender: sender)
+    end
+
+    it { expect(params).to include(senderEmail: "EMAIL") }
+    it { expect(params).to include(senderName: "NAME") }
+    it { expect(params).to include(senderCPF: "CPF") }
+  end
+
+  context "phone serialization" do
+    before do
+      sender = PagSeguro::Sender.new({
+        phone: {
+          area_code: "AREA_CODE",
+          number: "NUMBER"
+        }
+      })
+
+      payment_request.stub(sender: sender)
+    end
+
+    it { expect(params).to include(senderAreaCode: "AREA_CODE") }
+    it { expect(params).to include(senderPhone: "NUMBER") }
+  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
+end

data/spec/pagseguro/payment_request_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe PagSeguro::PaymentRequest do
+  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_assigns_attribute :email
+  it_assigns_attribute :token
+
+  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
+
+  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 "#email" do
+    before { PagSeguro.email = 'DEFAULT_EMAIL' }
+
+    it "returns the email set in the constructor" do
+      expect(described_class.new(email: 'foo').email).to eq('foo')
+    end
+
+    it "defaults to PagSeguro.email" do
+      expect(described_class.new.email).to eq('DEFAULT_EMAIL')
+    end
+  end
+
+  describe "#token" do
+    before { PagSeguro.token = 'DEFAULT_TOKEN' }
+
+    it "returns the token set in the constructor" do
+      expect(described_class.new(token: 'foo').token).to eq('foo')
+    end
+
+    it "defaults to PagSeguro.token" do
+      expect(described_class.new.token).to eq('DEFAULT_TOKEN')
+    end
+  end
+
+  describe "#register" do
+    let(:payment) { PagSeguro::PaymentRequest.new }
+    before { FakeWeb.register_uri :any, %r[.*?], body: "" }
+
+    it "serializes payment request" do
+      PagSeguro::PaymentRequest::Serializer
+        .should_receive(:new)
+        .with(payment)
+        .and_return(double.as_null_object)
+
+      payment.register
+    end
+
+    it "performs request" do
+      params = double
+
+      params.should_receive(:merge).with({
+        email: PagSeguro.email,
+        token: PagSeguro.token
+      }).and_return(params)
+
+      PagSeguro::PaymentRequest::Serializer.any_instance.stub to_params: params
+
+      PagSeguro::Request
+        .should_receive(:post)
+        .with("checkout", params)
+
+      payment.register
+    end
+
+    it "initializes response" do
+      response = double
+      PagSeguro::Request.stub post: response
+
+      PagSeguro::PaymentRequest::Response
+        .should_receive(:new)
+        .with(response)
+
+      payment.register
+    end
+
+    it "returns response" do
+      response = double
+      PagSeguro::PaymentRequest::Response.stub new: response
+
+      expect(payment.register).to eql(response)
+    end
+  end
+end

data/spec/pagseguro/payment_status_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+shared_examples_for "payment status mapping" do |id, status|
+  it "returns #{status} as status when id is #{id}" do
+    expect(PagSeguro::PaymentStatus.new(id).status).to eql(status)
+  end
+
+  it "detects as #{status}" do
+    expect(PagSeguro::PaymentStatus.new(id).public_send("#{status}?")).to be
+  end
+end
+
+describe PagSeguro::PaymentStatus do
+  context "status mapping" do
+    it_behaves_like "payment status mapping", 0, :initiated
+    it_behaves_like "payment status mapping", 1, :waiting_payment
+    it_behaves_like "payment status mapping", 2, :in_analysis
+    it_behaves_like "payment status mapping", 3, :paid
+    it_behaves_like "payment status mapping", 4, :available
+    it_behaves_like "payment status mapping", 5, :in_dispute
+    it_behaves_like "payment status mapping", 6, :refunded
+    it_behaves_like "payment status mapping", 7, :cancelled
+  end
+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/request_spec.rb

@@ -0,0 +1,75 @@
+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.email = "EMAIL"
+      PagSeguro.token = "TOKEN"
+      PagSeguro::Request.post("checkout")
+
+      expect(FakeWeb.last_request.body).to include("email=EMAIL&token=TOKEN")
+    end
+
+    it "includes custom credentials" do
+      PagSeguro.email = "EMAIL"
+      PagSeguro.token = "TOKEN"
+      PagSeguro::Request.post("checkout", email: 'foo', token: 'bar')
+
+      expect(FakeWeb.last_request.body).to include("email=foo&token=bar")
+    end
+
+    it "includes encoding" do
+      PagSeguro::Request.post("checkout")
+      expect(FakeWeb.last_request.body).to include("charset=UTF-8")
+    end
+
+    it "include request headers" do
+      PagSeguro::Request.post("checkout")
+      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
+  end
+
+  context "GET request" do
+    before do
+      FakeWeb.register_uri :get, %r[.+], body: "BODY"
+    end
+
+    it "includes credentials" do
+      PagSeguro.email = "EMAIL"
+      PagSeguro.token = "TOKEN"
+      PagSeguro::Request.get("checkout")
+
+      expect(FakeWeb.last_request.path).to include("email=EMAIL&token=TOKEN")
+    end
+
+    it "includes encoding" do
+      PagSeguro::Request.get("checkout")
+      expect(FakeWeb.last_request.path).to include("charset=UTF-8")
+    end
+
+    it "include request headers" do
+      PagSeguro::Request.get("checkout")
+      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