pagseguro-oficial 2.4.0 → 2.5.0

data/spec/pagseguro/authorization_request_spec.rb

@@ -9,53 +9,118 @@ describe PagSeguro::AuthorizationRequest do
   describe "#create" do
     let(:request) { double(:request) }
     let(:response) { double(:response) }
-    let(:options) do
-      {
-        notification_url: "foo",
-        redirect_url: "bar",
-        permissions: [:notifications, :searches]
-      }
-    end
-
-    let(:params) do
-      {
-        notificationURL: "foo",
-        redirectURL: "bar",
-        permissions: "RECEIVE_TRANSACTION_NOTIFICATIONS,SEARCH_TRANSACTIONS"
-      }
-    end
-
-    subject { described_class.new(options) }
+    let(:credentials) { PagSeguro::ApplicationCredentials.new('app123', 'key123') }
 
     before do
-      expect(PagSeguro::Request).to receive(:post)
-        .with("authorizations/request", 'v2', params)
+      expect(PagSeguro::Request).to receive(:post_xml)
+        .with('authorizations/request', 'v2', credentials, data)
         .and_return(request)
+
       expect(PagSeguro::AuthorizationRequest::Response).to receive(:new)
         .with(request)
         .and_return(response)
+
       expect(response).to receive(:serialize).and_return(serialized_data)
     end
 
-    context "when request succeeds" do
-      let(:serialized_data) { {code: "123"} }
+    context "when an account is not given" do
+      let(:options) do
+        {
+          credentials: credentials,
+          notification_url: 'http://seusite.com.br/notification',
+          redirect_url: 'http://seusite.com.br/redirect',
+          permissions: [:checkouts, :searches, :notifications],
+          reference: '123'
+        }
+      end
+
+      let(:data) { File.read('./spec/fixtures/authorization_request/authorization_request.xml') }
+
+      subject { described_class.new(options) }
+
+      context "when request succeeds" do
+        let(:serialized_data) { {code: "123"} }
+
+        it "creates a transaction request" do
+          expect(response).to receive(:success?).and_return(true)
 
-      it "creates a transaction request" do
-        expect(response).to receive(:success?).and_return(true)
+          expect(subject.create).to be_truthy
+          expect(subject.code).to eq(serialized_data[:code])
+        end
+      end
+
+
+      context "when request fails" do
+        let(:serialized_data) { {errors: PagSeguro::Errors.new} }
 
-        expect(subject.create).to be_truthy
-        expect(subject.code).to eq(serialized_data[:code])
+        it "does not create a transaction request" do
+          expect(response).to receive(:success?).and_return(false)
+
+          expect(subject.create).to be_falsey
+          expect(subject.code).to be_nil
+        end
       end
     end
 
-    context "when request fails" do
-      let(:serialized_data) { {errors: PagSeguro::Errors.new} }
+    context "when an account is given" do
+      let(:options) do
+        {
+          credentials: credentials,
+          permissions: [:checkouts, :searches, :notifications],
+          notification_url: 'http://seusite.com.br/notification',
+          redirect_url: 'http://seusite.com.br/redirect',
+          reference: '123',
+          account: {
+            email: 'usuario@seusite.com.br',
+            type: 'SELLER',
+            person: {
+              name: 'Antonio Carlos',
+              birth_date: '05/02/1982',
+              address: {
+                postal_code: 01452002,
+                street: 'Av. Brig. Faria Lima',
+                number: 1384,
+                complement: '5o andar',
+                district: 'Jardim Paulistano',
+                city: 'Sao Paulo',
+                state: 'SP',
+                country: 'BRA'
+              },
+              documents: [{type: 'CPF', value: 99988877766}],
+              phones: [
+                {type: 'HOME', area_code: 11, number: 30302323},
+                {type: 'MOBILE', area_code: 11, number: 976302323},
+              ]
+            }
+          }
+        }
+      end
+      let(:data) { File.read('./spec/fixtures/authorization_request/authorization_request_with_account.xml') }
+      let(:request) { double(:request) }
+      let(:response) { double(:response) }
+
+      subject { described_class.new(options) }
+
+      context "when request succeeds" do
+        let(:serialized_data) { {code: "123"} }
+
+        it "creates a transaction request send xml" do
+          expect(response).to receive(:success?).and_return(true)
+
+          expect(subject.create).to be_truthy
+          expect(subject.code).to eq(serialized_data[:code])
+        end
+      end
+
+      context "when request fails" do
+        let(:serialized_data) { {errors: PagSeguro::Errors.new} }
 
-      it "does not create a transaction request" do
-        expect(response).to receive(:success?).and_return(false)
+        it "does not create a transaction request" do
+          expect(response).to receive(:success?).and_return(false)
 
-        expect(subject.create).to be_falsey
-        expect(subject.code).to be_nil
+          expect(subject.create).to be_falsey
+          expect(subject.code).to be_nil
+        end
       end
     end
   end

data/spec/pagseguro/authorization_spec.rb

@@ -48,22 +48,64 @@ describe PagSeguro::Authorization do
     end
   end
 
-  describe "find_by_date" do
-    let(:date_options) { { initial_date: Date.today, final_date: Date.today + 1 } }
+  describe "find_by" do
     before do
-      expect(PagSeguro::Request).to receive(:get)
-        .with("authorizations", 'v2', {})
-        .and_return(request)
-      expect(PagSeguro::Authorization::Collection).to receive(:new)
+      allow(PagSeguro::Authorization::Collection).to receive(:new)
         .and_return(collection)
-      expect(PagSeguro::Authorization::Response).to receive(:new)
+      allow(PagSeguro::Authorization::Response).to receive(:new)
         .with(request, collection)
         .and_return(response)
-      expect(response).to receive(:serialize_collection)
+      allow(response).to receive(:serialize_collection)
     end
 
-    it 'finds authorizations by a date range' do
-      expect(PagSeguro::Authorization.find_by_date(date_options)).to eq (collection)
+    context "with reference" do
+      let(:reference) { 'REF1111' }
+
+      it 'finds authorizations' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { reference: 'REF1111' })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(reference: 'REF1111')
+      end
+    end
+
+    context "with initial_date" do
+      let(:initial_date) { Time.new(2015, 11, 1, 12, 0) }
+
+      it 'finds authorizations' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { initialDate: initial_date.xmlschema })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(initial_date: initial_date)
+      end
+    end
+
+    context "with final_date" do
+      let(:final_date) { Time.new(2015, 11, 1, 12, 0) }
+
+      it 'finds authorizations' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { finalDate: final_date.xmlschema })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(final_date: final_date)
+      end
+    end
+
+    context "with credentials" do
+      let(:credentials) do
+        PagSeguro::ApplicationCredentials.new('APP_ID', 'APP_KEY')
+      end
+
+      it 'passes' do
+        expect(PagSeguro::Request).to receive(:get)
+          .with("authorizations", 'v2', { credentials: credentials })
+          .and_return(request)
+
+        PagSeguro::Authorization.find_by(credentials: credentials)
+      end
     end
   end
 end

data/spec/pagseguro/company_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Company do
+  it_assigns_attribute :name
+  it_assigns_attribute :display_name
+  it_assigns_attribute :website_url
+
+  it_ensures_type PagSeguro::Address, :address
+  it_ensures_type PagSeguro::Partner, :partner
+  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/documents_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe PagSeguro::Documents 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 document' do
+    let(:document) { { type: 'CPF', value: 11122233344 } }
+
+    it "shouldn't add the same document" do
+      subject << document
+      expect{ subject << document }.to_not change{ subject.size }
+    end
+
+    context 'ensures type the new document' do
+      it 'can be a hash' do
+        expect{ subject << document }.to change{ subject.size }.to(1)
+      end
+
+      it 'can be a PagSeguro::Document' do
+        expect{ subject << PagSeguro::Document.new(type: 'CPF', value: 11122233344) }.to change{ subject.size }.to(1)
+      end
+    end
+  end
+end

data/spec/pagseguro/errors_spec.rb

@@ -3,7 +3,13 @@ require "spec_helper"
 
 describe PagSeguro::Errors do
   let(:response) { double }
-  let(:http_response) { double(:http_response, unauthorized?: true, bad_request?: false, not_found?: false) }
+  let(:http_response) do
+    double(
+      :http_response,
+      error?: true,
+      error: Aitch::UnauthorizedError
+    )
+  end
 
   context "when have no response" do
     it "returns errors" do
@@ -16,7 +22,10 @@ describe PagSeguro::Errors do
     subject(:errors) { PagSeguro::Errors.new(response) }
 
     before do
-      response.stub unauthorized?: true, bad_request?: false, not_found?: false
+      allow(response).to receive_messages(
+        error?: true,
+        error: Aitch::UnauthorizedError
+      )
       errors.add(http_response)
     end
 
@@ -28,7 +37,10 @@ describe PagSeguro::Errors do
     subject(:errors) { PagSeguro::Errors.new(response) }
 
     before do
-      response.stub unauthorized?: true, bad_request?: false, not_found?: true
+      allow(response).to receive_messages(
+        error?: true,
+        error: Aitch::NotFoundError
+      )
       errors.add(http_response)
     end
 
@@ -36,6 +48,21 @@ describe PagSeguro::Errors do
     it { expect(errors).to include(I18n.t("pagseguro.errors.not_found")) }
   end
 
+  context 'when forbidden' do
+    subject(:errors) { PagSeguro::Errors.new(response) }
+
+    before do
+      allow(response).to receive_messages(
+        error?: true,
+        error: Aitch::ForbiddenError
+      )
+      errors.add(http_response)
+    end
+
+    it { expect(errors).not_to be_empty }
+    it { expect(errors).to include(I18n.t("pagseguro.errors.forbidden")) }
+  end
+
   context "when message can't be translated" do
     let(:error) {
       <<-XML
@@ -52,7 +79,11 @@ describe PagSeguro::Errors do
     subject(:errors) { PagSeguro::Errors.new(response) }
 
     before do
-      response.stub data: xml, unauthorized?: false, bad_request?: true, not_found?: true
+      allow(response).to receive_messages(
+        data: xml,
+        error?: true,
+        error: Aitch::BadRequestError
+      )
     end
 
     it { expect(errors).to include("Sample message") }
@@ -74,7 +105,11 @@ describe PagSeguro::Errors do
     subject(:errors) { PagSeguro::Errors.new(response) }
 
     before do
-      response.stub data: xml, unauthorized?: false, bad_request?: true, not_found?: false
+      allow(response).to receive_messages(
+        data: xml,
+        error?: true,
+        error: Aitch::BadRequestError
+      )
     end
 
     it { expect(errors).to include("O parâmetro email deve ser informado.") }
@@ -97,7 +132,11 @@ describe PagSeguro::Errors do
     subject(:errors) { PagSeguro::Errors.new(response) }
 
     before do
-      response.stub data: xml, unauthorized?: false, bad_request?: true, not_found?: true
+      allow(response).to receive_messages(
+        data: xml,
+        error?: true,
+        error: Aitch::BadRequestError
+      )
       errors.add(http_response)
     end
 

data/spec/pagseguro/extensions/collection_object_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe PagSeguro::Extensions::CollectionObject do
+  before(:all) do
+    # Collection
+    class MyItems
+      include PagSeguro::Extensions::CollectionObject
+    end
+
+    # Item
+    class MyItem
+      attr_accessor :name
+
+      def ==(other)
+        name.eql?(other.name)
+      end
+    end
+  end
+
+  let(:collection) do
+    MyItems.new
+  end
+
+  let(:object) do
+    item = MyItem.new
+    item.name = 'Item1'
+    item
+  end
+
+  context "when was included in a new class" do
+    it "new class must be include PagSeguro::Extensions::CollectionObject" do
+      expect(MyItems.included_modules).to include(PagSeguro::Extensions::CollectionObject)
+    end
+
+    context "and when this class is instantiated" do
+      it "must be initialized empty" do
+        expect(collection).to be_empty
+      end
+
+      context "must respond to" do
+        [
+          :size,
+          :clear,
+          :empty?,
+          :any?,
+          :each,
+          :include?,
+          :<<
+        ].each do |method|
+          it "#{method}" do
+            expect(collection).to respond_to(method)
+          end
+        end
+      end
+
+      it "object type must be the class name singularized" do
+        expect(collection.collection_type).to eq MyItem
+      end
+    end
+  end
+
+  context 'collection operations' do
+    it "when add a new object it must be incremented" do
+      expect{ collection << object }.to change{ collection.size }.by(1)
+    end
+
+    it "when add an object already added" do
+      collection << object
+      expect{ collection << object }.to_not change{ collection.size }
+    end
+
+    it "must to include an object before added" do
+      collection << object
+      expect(collection).to include(object)
+    end
+  end
+end