pagseguro-sdk 2.6.2

data/spec/pagseguro/transaction_request/response_serializer_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe PagSeguro::TransactionRequest::ResponseSerializer do
+  context "for existing transactions" do
+    let(:source) { File.read("./spec/fixtures/transaction_request/success.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:serializer) { described_class.new(xml.css("transaction").first) }
+    subject(:data) { serializer.serialize }
+
+    it { expect(data).to include(created_at: Time.parse("2011-02-05T15:46:12.000-02:00")) }
+    it { expect(data).to include(updated_at: Time.parse("2011-02-15T17:39:14.000-03:00")) }
+    it { expect(data).to include(code: "9E884542-81B3-4419-9A75-BCC6FB495EF1") }
+    it { expect(data).to include(reference: "REF1234") }
+    it { expect(data).to include(type_id: "1") }
+    it { expect(data).to include(status: "3") }
+    it { expect(data).to include(payment_method: {type_id: "1", code: "101"}) }
+    it { expect(data).to include(payment_link: "https://pagseguro.uol.com.br/checkout/imprimeBoleto.jhtml?code=314601B208B24A5CA5
+  3260000F7BB0D0") }
+    it { expect(data).to include(gross_amount: BigDecimal("49900.00")) }
+    it { expect(data).to include(discount_amount: BigDecimal("0.00")) }
+    it { expect(data).to include(net_amount: BigDecimal("49900.50")) }
+    it { expect(data).to include(extra_amount: BigDecimal("0.00")) }
+    it { expect(data).to include(installment_count: 1) }
+
+    it { expect(data[:items].size).to eq(2) }
+    it { expect(data[:items].first).to include(id: "0001") }
+    it { expect(data[:items].first).to include(description: "Notebook Prata") }
+    it { expect(data[:items].first).to include(quantity: 1) }
+    it { expect(data[:items].first).to include(amount: BigDecimal("24300.00")) }
+    it { expect(data[:items][1]).to include(id: "0002") }
+    it { expect(data[:items][1]).to include(description: "Notebook Rosa") }
+    it { expect(data[:items][1]).to include(quantity: 1) }
+    it { expect(data[:items][1]).to include(amount: BigDecimal("25600.00")) }
+
+    it { expect(data[:sender]).to include(name: "Jose Comprador") }
+    it { expect(data[:sender]).to include(email: "comprador@uol.com.br") }
+    it { expect(data[:sender][:phone]).to include(area_code: "11") }
+    it { expect(data[:sender][:phone]).to include(number: "56273440") }
+
+    it { expect(data[:shipping]).to include(type_id: "1") }
+    it { expect(data[:shipping]).to include(cost: BigDecimal("21.50")) }
+
+    it { expect(data[:shipping][:address]).to include(street: "Av. Brig. Faria Lima") }
+    it { expect(data[:shipping][:address]).to include(number: "1384") }
+    it { expect(data[:shipping][:address]).to include(complement: "5o andar") }
+    it { expect(data[:shipping][:address]).to include(district: "Jardim Paulistano") }
+    it { expect(data[:shipping][:address]).to include(city: "Sao Paulo") }
+    it { expect(data[:shipping][:address]).to include(state: "SP") }
+    it { expect(data[:shipping][:address]).to include(country: "BRA") }
+    it { expect(data[:shipping][:address]).to include(postal_code: "01452002") }
+  end
+end

data/spec/pagseguro/transaction_request/response_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe PagSeguro::TransactionRequest::Response do
+  let(:transaction_request) do
+    PagSeguro::TransactionRequest.new
+  end
+
+  subject { PagSeguro::TransactionRequest::Response.new(http_response, transaction_request) }
+
+  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
+
+  context "#serialize" do
+    let(:http_response) do
+      double(:HttpResponse, data: xml_parsed, body: raw_xml, success?: true, xml?: true, unauthorized?: false, bad_request?: false, not_found?: false)
+    end
+
+    let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+
+    context "with success request" do
+      let(:raw_xml) { File.read("./spec/fixtures/transaction_request/success.xml") }
+
+      it "return transaction_request instance" do
+        expect(subject.serialize).to eq transaction_request
+      end
+
+      it "change code" do
+        expect { subject.serialize }.to change { transaction_request.code }
+      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 "return transaction_request instance" do
+        expect(subject.serialize).to eq transaction_request
+      end
+
+      it "assign errors" do
+        expect { subject.serialize }.to change { transaction_request.errors.empty? }
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction_request_spec.rb

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+describe PagSeguro::TransactionRequest do |variable|
+  let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+
+  it_assigns_attribute :currency
+  it_assigns_attribute :primary_receiver
+  it_assigns_attribute :extra_amount
+  it_assigns_attribute :reference
+  it_assigns_attribute :notification_url
+  it_assigns_attribute :payment_mode
+  it_assigns_attribute :extra_params
+
+  it_ensures_type PagSeguro::Sender, :sender
+  it_ensures_type PagSeguro::Shipping, :shipping
+
+  it { is_expected.to respond_to(:code) }
+  it { is_expected.to respond_to(:type_id) }
+  it { is_expected.to respond_to(:payment_link) }
+  it { is_expected.to respond_to(:status) }
+  it { is_expected.to respond_to(:payment_method) }
+  it { is_expected.to respond_to(:gross_amount) }
+  it { is_expected.to respond_to(:discount_amount) }
+  it { is_expected.to respond_to(:net_amount) }
+  it { is_expected.to respond_to(:installment_count) }
+  it { is_expected.to respond_to(:created_at) }
+  it { is_expected.to respond_to(:updated_at) }
+
+  it "sets the sender" do
+    sender = PagSeguro::Sender.new
+    payment = PagSeguro::TransactionRequest.new(sender: sender)
+
+    expect(payment.sender).to eql(sender)
+  end
+
+  it "sets shipping" do
+    shipping = PagSeguro::Shipping.new
+    payment = PagSeguro::TransactionRequest.new(shipping: shipping)
+
+    expect(payment.shipping).to eql(shipping)
+  end
+
+  it "sets the items" do
+    payment = PagSeguro::TransactionRequest.new
+    expect(payment.items).to be_a(PagSeguro::Items)
+  end
+
+  it "sets default currency" do
+    payment = PagSeguro::TransactionRequest.new
+    expect(payment.currency).to eql("BRL")
+  end
+
+  describe "#payment_method" do
+    it "raises not implemented error" do
+      expect { subject.payment_method }.to raise_error(NotImplementedError)
+    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
+
+  describe '#receivers' do
+    subject do
+      PagSeguro::TransactionRequest.new receivers: receivers
+    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
+  end
+
+  describe "#create" do
+    let(:transaction_request) { PagSeguro::TransactionRequest.new }
+    let(:request) { double(:request, success?: true, xml?: true, body: raw_xml) }
+    let(:params) do
+      {receiverEmail: "RECEIVER", currency: "BRL", paymentMethod: "credit_card"}
+    end
+
+    before do
+      PagSeguro.configuration.receiver_email = "RECEIVER"
+
+      allow(transaction_request).to receive(:payment_method).and_return("credit_card")
+
+      allow(PagSeguro::Request).to receive(:post)
+        .with("transactions", "v2", params)
+        .and_return(request)
+    end
+
+    context "when request succeeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/transaction_request/success.xml") }
+
+      it "creates a transaction request" do
+        expect(transaction_request.create).to be_a(PagSeguro::TransactionRequest)
+        expect(transaction_request.code).to eq("9E884542-81B3-4419-9A75-BCC6FB495EF1")
+      end
+    end
+
+    context "when request fails" do
+      let :response_request do
+        double(
+          :ResponseRequest,
+          success?: false,
+          error?: true,
+          bad_request?: true,
+          error: Aitch::BadRequestError,
+          xml?: true,
+          data: xml_parsed,
+          body: raw_xml
+        )
+      end
+
+      before do
+        allow(PagSeguro::Request).to receive(:post)
+          .and_return(response_request)
+      end
+
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "does not create a transaction request" do
+        expect { transaction_request.create }.not_to change { transaction_request.code }
+      end
+
+      it "add errors" do
+        expect { transaction_request.create }.to change { transaction_request.errors.empty? }
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction_spec.rb

@@ -0,0 +1,265 @@
+require "spec_helper"
+
+describe PagSeguro::Transaction do
+  describe ".find_by_notification_code" do
+    before do
+      allow(PagSeguro::Request).to receive(:get)
+        .with("transactions/notifications/CODE", "v3", {})
+        .and_return(request)
+    end
+    let(:parsed_xml) { Nokogiri::XML(raw_xml) }
+    let(:request) do
+      double(:Request, xml?: true, success?: true, unauthorized?: false,
+             bad_request?: false, body: raw_xml, data: parsed_xml)
+    end
+    subject { PagSeguro::Transaction.find_by_notification_code("CODE") }
+
+    context "when request succeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/transactions/success.xml") }
+
+      it "returns an instance of transaction" do
+        expect(subject).to be_a(PagSeguro::Transaction)
+      end
+
+      context "returns transaction with correct attributes" do
+        it { expect(subject.code).to eq("667A3914-4F9F-4705-0EB6-CA6FA0DF8A19") }
+        it { expect(subject.reference).to eq("REF1234") }
+        it { expect(subject.type_id).to eq("1") }
+        it { expect(subject.payment_link).to eq("https://pagseguro.uol.com.br/checkout/imprimeBoleto.jhtml?code=667D39144F9F47059FB6CA6FA0DF8A20") }
+        it { expect(subject.status).to be_a(PagSeguro::PaymentStatus) }
+        it { expect(subject.status.id).to eq("1") }
+        it { expect(subject.payment_method.type).to eq(:boleto) }
+        it { expect(subject.gross_amount).to eq(459.5) }
+        it { expect(subject.discount_amount).to eq(0.0) }
+        it { expect(subject.net_amount).to eq(445.77) }
+        it { expect(subject.extra_amount).to eq(0.0) }
+        it { expect(subject.installments).to eq(1) }
+        it { expect(subject.sender.name).to eq("JOHN DOE") }
+      end
+
+      it "returns a collection with errors object" do
+        expect(subject.errors).to be_a(PagSeguro::Errors)
+      end
+
+      it "returns a collection with no errors" do
+        expect(subject.errors).to be_empty
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(request).to receive_messages(
+          success?: false,
+          error?: true,
+          error: Aitch::BadRequestError
+        )
+      end
+
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "returns an instance of Transaction" do
+        expect(subject).to be_a(PagSeguro::Transaction)
+      end
+
+      it "returns a collection with errors" do
+        expect(subject.errors).not_to be_empty
+      end
+    end
+  end
+
+  describe ".find_by_code" do
+    before do
+      allow(PagSeguro::Request).to receive(:get)
+        .with("transactions/CODE", "v3", {})
+        .and_return(request)
+    end
+    let(:parsed_xml) { Nokogiri::XML(raw_xml) }
+    let(:request) do
+      double(:Request, xml?: true, success?: true, error?: false,
+             bad_request?: false, body: raw_xml, data: parsed_xml)
+    end
+    subject { PagSeguro::Transaction.find_by_code("CODE") }
+
+    context "when request succeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/transactions/success.xml") }
+
+      it "returns an instance of transaction" do
+        expect(subject).to be_a(PagSeguro::Transaction)
+      end
+
+      it "returns a collection with errors object" do
+        expect(subject.errors).to be_a(PagSeguro::Errors)
+      end
+
+      it "returns a collection with no errors" do
+        expect(subject.errors).to be_empty
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(request).to receive_messages(
+          success?: false,
+          error?: true,
+          error: Aitch::BadRequestError
+        )
+      end
+
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "returns an instance of Transaction" do
+        expect(subject).to be_a(PagSeguro::Transaction)
+      end
+
+      it "returns a collection with errors" do
+        expect(subject.errors).not_to be_empty
+      end
+    end
+  end
+
+  describe ".find_by_code" do
+    it 'finds a transaction by its code' do
+      allow(PagSeguro::Transaction).to receive(:load_from_response)
+
+      expect(PagSeguro::Request)
+        .to receive(:get)
+        .with("transactions/CODE", 'v3', {})
+        .and_return(double.as_null_object)
+
+      PagSeguro::Transaction.find_by_code("CODE")
+    end
+  end
+
+  describe ".find_by_date" do
+    it "initializes search with default options" do
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      expect(PagSeguro::SearchByDate)
+        .to receive(:new)
+        .with("transactions",
+          hash_including(starts_at: now - 86400, ends_at: now, per_page: 50), 0)
+
+      PagSeguro::Transaction.find_by_date
+    end
+
+    it "initializes search with given options" do
+      starts_at = Time.now - 3600
+      ends_at = starts_at + 180
+      page = 0
+
+      expect(PagSeguro::SearchByDate)
+        .to receive(:new)
+        .with(
+          "transactions",
+          hash_including(per_page: 10, starts_at: starts_at, ends_at: ends_at),
+          page
+        )
+
+      PagSeguro::Transaction.find_by_date(
+        {per_page: 10, starts_at: starts_at, ends_at: ends_at},
+        page
+      )
+    end
+  end
+
+  describe ".find_by_reference" do
+    it 'initializes search with given reference code' do
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      expect(PagSeguro::SearchByReference)
+        .to receive(:new)
+        .with(
+          "transactions",
+          hash_including(reference: 'ref1234'),
+        )
+
+      PagSeguro::Transaction.find_by_reference('ref1234')
+    end
+  end
+
+  describe ".find_abandoned" do
+    it "initializes search with default options" do
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      expect(PagSeguro::SearchAbandoned)
+        .to receive(:new)
+        .with(
+          "transactions/abandoned",
+          hash_including(per_page: 50, starts_at: now - 86400, ends_at: now - 900),
+          0
+        )
+
+      PagSeguro::Transaction.find_abandoned
+    end
+
+    it "initializes search with given options" do
+      starts_at = Time.now - 3600
+      ends_at = starts_at + 180
+      page = 1
+
+      expect(PagSeguro::SearchAbandoned)
+        .to receive(:new)
+        .with(
+          "transactions/abandoned",
+          hash_including(per_page: 10, starts_at: starts_at, ends_at: ends_at),
+          page
+        )
+
+      PagSeguro::Transaction.find_abandoned(
+        { per_page: 10, starts_at: starts_at, ends_at: ends_at },
+        page
+      )
+    end
+
+    it "initializes search with given credential option" do
+      credentials = PagSeguro::AccountCredentials.new('email@example.com', 'token')
+      starts_at = Time.now - 3600
+      ends_at = starts_at + 180
+      page = 1
+
+      expect(PagSeguro::SearchAbandoned)
+        .to receive(:new)
+        .with(
+          "transactions/abandoned",
+          hash_including(per_page: 10, starts_at: starts_at, ends_at: ends_at, credentials: credentials),
+          page
+        )
+
+      PagSeguro::Transaction.find_abandoned(
+        { per_page: 10, starts_at: starts_at, ends_at: ends_at, credentials: credentials },
+        page
+      )
+    end
+  end
+
+  describe "attributes" do
+    before do
+      body = File.read("./spec/fixtures/transactions/success.xml")
+      FakeWeb.register_uri :get, %r[.+], body: body, content_type: "text/xml"
+    end
+
+    subject(:transaction) { PagSeguro::Transaction.find_by_notification_code("CODE") }
+
+    it { expect(transaction.sender).to be_a(PagSeguro::Sender) }
+    it { expect(transaction.shipping).to be_a(PagSeguro::Shipping) }
+    it { expect(transaction.items).to be_a(PagSeguro::Items) }
+    it { expect(transaction.payment_method).to be_a(PagSeguro::PaymentMethod) }
+    it { expect(transaction.status).to be_a(PagSeguro::PaymentStatus) }
+    it { expect(transaction.items.size).to eq(1) }
+    it { expect(transaction).to respond_to(:escrow_end_date) }
+  end
+
+  it "always set errors" do
+    expect(subject.errors).to be_a(PagSeguro::Errors)
+  end
+
+  it "#update_attributes" do
+    subject = PagSeguro::Transaction.new
+    expect(subject).to receive(:code=).with("1234")
+
+    subject.update_attributes(code: "1234")
+  end
+end