pagseguro-oficial 2.1.1 → 2.2.0

data/spec/pagseguro/document_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe PagSeguro::Document do
   it_assigns_attribute :type

data/spec/pagseguro/errors_spec.rb

@@ -3,6 +3,7 @@ require "spec_helper"
 
 describe PagSeguro::Errors do
   let(:response) { double }
+  let(:http_response) { double(:http_response, unauthorized?: true, bad_request?: false) }
 
   context "when have no response" do
     it "returns errors" do
@@ -16,10 +17,11 @@ describe PagSeguro::Errors do
 
     before do
       response.stub unauthorized?: true, bad_request?: false
+      errors.add(http_response)
     end
 
-    it { should_not be_empty }
-    it { should include(I18n.t("pagseguro.errors.unauthorized")) }
+    it { expect(errors).not_to be_empty }
+    it { expect(errors).to include(I18n.t("pagseguro.errors.unauthorized")) }
   end
 
   context "when message can't be translated" do
@@ -84,6 +86,7 @@ describe PagSeguro::Errors do
 
     before do
       response.stub data: xml, unauthorized?: false, bad_request?: true
+      errors.add(http_response)
     end
 
     it { expect(errors).to include("Malformed request XML: XML document structures must start and end within the same entity..") }

data/spec/pagseguro/features/create_session_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+RSpec.describe "Creating Session" do
+  let(:session) { PagSeguro::Session.create }
+
+  context "when request succeeds" do
+    before do
+      body = %[<?xml version="1.0"?><session>
+        <id>620f99e348c24f07877c927b353e49d3</id></session>]
+      FakeWeb.register_uri :post, PagSeguro.api_url("v2/sessions"), body: body,
+        content_type: "text/xml"
+    end
+
+    it "returns a session object" do
+      expect(session).to be_a(PagSeguro::Session)
+    end
+
+    describe "#errors" do
+      it "is an errors object" do
+        expect(session.errors).to be_a(PagSeguro::Errors)
+      end
+
+      it "has no errors" do
+        expect(session.errors).to be_empty
+      end
+    end
+  end
+
+  context "when request fails" do
+    before do
+      body = %[<?xml version="1.0"?><errors><error><code>1234</code>
+          <message>Sample error</message></error></errors>]
+      FakeWeb.register_uri :post, PagSeguro.api_url("v2/sessions"),
+        status: [400, "Bad Request"], body: body, content_type: "text/xml"
+    end
+
+    it "returns a session object" do
+      expect(session).to be_a(PagSeguro::Session)
+    end
+
+    describe "#errors" do
+      it "is an errors object" do
+        expect(session.errors).to be_a(PagSeguro::Errors)
+      end
+
+      it "has errors" do
+        expect(session.errors).to_not be_empty
+        expect(session.errors).to include("Sample error")
+      end
+    end
+  end
+end

data/spec/pagseguro/features/create_transaction_request_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+RSpec.describe "Creating Transaction Request" do
+  let(:transaction) { PagSeguro::OnlineDebitTransactionRequest.new }
+
+  context "when request succeeds" do
+    before do
+      body = File.read("./spec/fixtures/transaction_request/success.xml")
+      FakeWeb.register_uri :post, PagSeguro.api_url("v2/transactions"),
+        body: body, content_type: "text/xml"
+    end
+
+    it "returns true" do
+      expect(transaction.create).to be_truthy
+    end
+
+    describe "#errors" do
+      before do
+        transaction.create
+      end
+
+      it "is an errors object" do
+        expect(transaction.errors).to be_a(PagSeguro::Errors)
+      end
+
+      it "has no errors" do
+        expect(transaction.errors).to be_empty
+      end
+    end
+  end
+
+  context "when request fails" do
+    before do
+      body = %[<?xml version="1.0"?><errors><error><code>1234</code>
+          <message>Sample error</message></error></errors>]
+      FakeWeb.register_uri :post, PagSeguro.api_url("v2/transactions"),
+        status: [400, "Bad Request"], body: body, content_type: "text/xml"
+    end
+
+    it "returns false" do
+      expect(transaction.create).to be_falsey
+    end
+
+    describe "#errors" do
+      before do
+        transaction.create
+      end
+
+      it "is an errors object" do
+        expect(transaction.errors).to be_a(PagSeguro::Errors)
+      end
+
+      it "has errors" do
+        expect(transaction.errors).to_not be_empty
+      end
+    end
+  end
+end

data/spec/pagseguro/holder_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe PagSeguro::Holder do
+  it_assigns_attribute :name
+  it_assigns_attribute :birth_date
+
+  it_ensures_type PagSeguro::Document, :document
+  it_ensures_type PagSeguro::Phone, :phone
+end

data/spec/pagseguro/installment/collection_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe PagSeguro::Installment::Collection do
+  let(:installments) do
+    [
+      { amount: "100", card_brand: "visa" },
+      { amount: "110", card_brand: "visa" }
+    ]
+  end
+  subject { PagSeguro::Installment::Collection.new }
+
+  describe "initialization" do
+    it "errors should be a instance of PagSeguro::Errors" do
+      expect(subject.errors).to be_a(PagSeguro::Errors)
+    end
+
+    it "delegate empty? to @installments" do
+      subject.installments = []
+      expect(subject).to be_empty
+
+      subject.installments = installments
+      expect(subject).not_to be_empty
+    end
+
+    it "delegate any? to @installments" do
+      subject.installments = []
+      expect(subject).not_to be_any
+
+      subject.installments = installments
+      expect(subject).to be_any
+    end
+  end
+
+  context "#installments=" do
+    it "turns array of hash into installments" do
+      subject.installments = installments
+
+      subject.each do |installment|
+        expect(installment).to be_a(PagSeguro::Installment)
+      end
+    end
+  end
+end

data/spec/pagseguro/installment/request_serializer_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe PagSeguro::Installment::RequestSerializer do
+  let(:data) { { amount: "100.00", card_brand: "visa" } }
+  let(:params) { serializer.to_params }
+  subject(:serializer) { described_class.new(data) }
+
+  it { expect(params).to include(amount: "100.00") }
+  it { expect(params).to include(cardBrand: "visa") }
+
+  context "when card brand is not present" do
+    let(:data) { { amount: "100.00" } }
+
+    it { expect(params).to_not include(cardBrand: "visa") }
+  end
+end

data/spec/pagseguro/installment/{serializer_spec.rb → response_serializer_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe PagSeguro::Installment::Serializer do
+describe PagSeguro::Installment::ResponseSerializer do
   context "when there are installments" do
     let(:source) { File.read("./spec/fixtures/installment/success.xml") }
     let(:xml) { Nokogiri::XML(source) }

data/spec/pagseguro/installment/response_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+RSpec.describe PagSeguro::Installment::Response do
+  let(:http_response) do
+    double(:request, success?: true, xml?: true, data: xml_parsed, body: raw_xml, unauthorized?: false)
+  end
+  let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+  let(:collection) { PagSeguro::Installment::Collection.new }
+  subject { PagSeguro::Installment::Response.new(http_response, collection) }
+
+  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
+    context "when request succeeds" do
+      let(:serializer) { double(:serializer) }
+      let(:raw_xml) { File.read("./spec/fixtures/installment/success.xml") }
+
+      it "not change errors" do
+        expect { subject.serialize }.not_to change { collection.errors.empty? }
+      end
+
+      it "return a collection instance" do
+        expect(subject.serialize).to be_a(PagSeguro::Installment::Collection)
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(http_response).to receive(:success?).and_return(false)
+        allow(http_response).to receive(:bad_request?).and_return(true)
+      end
+
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "update collection errors" do
+        expect { subject.serialize }.to change { collection.errors.empty? }
+      end
+    end
+  end
+end

data/spec/pagseguro/installment_spec.rb

@@ -7,92 +7,41 @@ describe PagSeguro::Installment do
   it_assigns_attribute :total_amount
   it_assigns_attribute :interest_free
 
-  describe ".find" do
-    context "when request succeeds" do
-      let(:request) { double("request") }
-      let(:version) { 'v2' }
-
-      it "finds installments by the given amount" do
-        expect(PagSeguro::Request).to receive(:get)
-          .with("installments?amount=100.00", version)
-          .and_return(request)
-        expect(PagSeguro::Installment).to receive(:load_from_response)
-          .with(request)
+  let(:request) do
+    double(:request, success?: true, xml?: true, body: raw_xml, data: xml_parsed, unauthorized?: false)
+  end
 
-        PagSeguro::Installment.find("100.00")
-      end
+  let(:xml_parsed) { Nokogiri::XML(raw_xml) }
 
-      it "find installments by amount and credit card brand" do
-        expect(PagSeguro::Request).to receive(:get)
-          .with("installments?amount=100.00&cardBrand=visa", version)
-          .and_return(request)
-        expect(PagSeguro::Installment).to receive(:load_from_response)
-          .with(request)
+  describe ".find" do
+    subject { PagSeguro::Installment }
+    let(:params) { { amount: "100.00", cardBrand: "visa" } }
 
-        PagSeguro::Installment.find("100.00", :visa)
-      end
+    before do
+      allow(PagSeguro::Request).to receive(:get)
+        .with("installments", "v2", params)
+        .and_return(request)
     end
 
-    context "when request fails" do
-      it "returns response with errors" do
-        body = %[<?xml version="1.0"?><errors><error><code>1234</code>
-          <message>Sample error</message></error></errors>]
-        FakeWeb.register_uri :get, %r[.+], status: [400, "Bad Request"],
-          body: body, content_type: "text/xml"
-        response = PagSeguro::Installment.find("invalid")
+    context "when request succeeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/installment/success.xml") }
 
-        expect(response).to be_a(PagSeguro::Installment::Response)
-        expect(response.errors).to include("Sample error")
+      it "returns a instance of collection" do
+        expect(subject.find("100.00", "visa")).to be_a(PagSeguro::Installment::Collection)
       end
     end
-  end
 
-  describe ".load_from_response" do
-    context "when response succeeds" do
-      let(:response_body) { double(:response_body) }
-      let(:response) do
-        double(:response, success?: true, xml?: true, body: response_body)
-      end
-      let(:xml) { double(:xml) }
-      let(:node) { double(:node) }
-      let(:installments_nodes) { [node] }
-
-      it "loads response" do
-        expect(Nokogiri).to receive(:XML).with(response_body).and_return(xml)
-        expect(xml).to receive(:css).with("installments > installment")
-          .and_return(installments_nodes)
-        expect(PagSeguro::Installment).to receive(:load_from_xml).with(node)
-
-        PagSeguro::Installment.load_from_response(response)
+    context "when request fails" do
+      before do
+        allow(request).to receive(:success?).and_return(false)
+        allow(request).to receive(:bad_request?).and_return(true)
       end
-    end
-
-    context "when response fails" do
-      let(:response) { double(:response, success?: false) }
-      let(:error) { double(:error) }
 
-      it "returns response with errors" do
-        expect(PagSeguro::Errors).to receive(:new).with(response)
-          .and_return(error)
-        expect(PagSeguro::Installment::Response).to receive(:new).with(error)
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
 
-        PagSeguro::Installment.load_from_response(response)
+      it "returns collection with error" do
+        expect(subject.find("100.00", "visa").errors).not_to be_empty
       end
     end
   end
-
-  describe ".load_from_xml" do
-    let(:xml) { double(:xml) }
-    let(:serializer) { double(:serializer) }
-    let(:data) { double(:data) }
-
-    it "serializes the xml" do
-      expect(PagSeguro::Installment::Serializer).to receive(:new).with(xml)
-        .and_return(serializer)
-      expect(serializer).to receive(:serialize).and_return(data)
-      expect(PagSeguro::Installment).to receive(:new).with(data)
-
-      PagSeguro::Installment.load_from_xml(xml)
-    end
-  end
 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/payment_method_spec.rb

@@ -9,6 +9,7 @@ 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

data/spec/pagseguro/payment_request/response_spec.rb

@@ -2,17 +2,6 @@ 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) }