baby-braspag 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: 4cc72353166c66ccae00c73721c59ebb1bc4bd38
-  data.tar.gz: 6ab5cc4910eeb939fe6372df4cdb573aee4ea310
+SHA1:
+  metadata.gz: 9b8a1b58bac46347ec265ddf6279427a3e4f4146
+  data.tar.gz: b31e86eed6df4e4828c60efca30584a827f9311e
 SHA512:
-  metadata.gz: f6e7e9f6027fabba4ef8fdaf143e23fc15bcd8d88af6ef04ad0d958b1d2c85e4a8dfb28ca66e0346c63b2b641197f04b836cf3e9f432c8a112144ff66dd14d8f
-  data.tar.gz: 49e19fb8ec41b4dc324690dc9c3aeb57ee89a502e95c08af49104de609355ab428e0619ff4f79fdcb2f29e444b0bff3fe7a90eebc4d218e4e71ff9e2a3f05b0b
+  metadata.gz: 5b6f5744db076aaef3373e4b3413d4a60267ccee3f3b5bc29c64168f23cc594e45f4892f6cff0d4643c42fc1e5de368dbe5b7417619242c9741c563a22c593a6
+  data.tar.gz: cbb231e804583bd4841da0e00b6d2ac44330ca9af18546b6d133ab18ad2a83d32973e2898b750334a4e0363aa1f63a317712cb3e489747c5f8c92e7cb82caacb

data/lib/baby-braspag/credit_card.rb

@@ -1,6 +1,5 @@
 module Braspag
   class CreditCard < PaymentMethod
-
     MAPPING = {
       :merchant_id => "merchantId",
       :order => 'order',
@@ -22,12 +21,13 @@ module Braspag
     CANCELLATION_URI = "/webservices/pagador/Pagador.asmx/VoidTransaction"
     PRODUCTION_INFO_URI   = "/webservices/pagador/pedido.asmx/GetDadosCartao"
     HOMOLOGATION_INFO_URI = "/pagador/webservice/pedido.asmx/GetDadosCartao"
+    STATUS_URI = "/webservices/pagador/pedido.asmx/GetDadosPedido"
 
     def self.authorize(params = {})
       connection = Braspag::Connection.instance
       params[:merchant_id] = connection.merchant_id
 
-      self.check_params(params)
+      check_params(params)
 
       data = {}
       MAPPING.each do |k, v|
@@ -41,16 +41,16 @@ module Braspag
         end
       end
 
-      response = Braspag::Poster.new(self.authorize_url).do_post(:authorize, data)
+      response = Braspag::Poster.new(authorize_url).do_post(:authorize, data)
 
       Utils::convert_to_map(response.body, {
-          :amount => nil,
-          :number => "authorisationNumber",
-          :message => 'message',
-          :return_code => 'returnCode',
-          :status => 'status',
-          :transaction_id => "transactionId"
-        })
+        :amount => nil,
+        :number => "authorisationNumber",
+        :message => 'message',
+        :return_code => 'returnCode',
+        :status => 'status',
+        :transaction_id => "transactionId"
+      })
     end
 
     def self.capture(order_id)
@@ -64,16 +64,16 @@ module Braspag
         MAPPING[:merchant_id] => merchant_id
       }
 
-      response = Braspag::Poster.new(self.capture_url).do_post(:capture, data)
+      response = Braspag::Poster.new(capture_url).do_post(:capture, data)
 
       Utils::convert_to_map(response.body, {
-          :amount => nil,
-          :number => "authorisationNumber",
-          :message => 'message',
-          :return_code => 'returnCode',
-          :status => 'status',
-          :transaction_id => "transactionId"
-        })
+        :amount => nil,
+        :number => "authorisationNumber",
+        :message => 'message',
+        :return_code => 'returnCode',
+        :status => 'status',
+        :transaction_id => "transactionId"
+      })
     end
 
     def self.partial_capture(order_id, amount)
@@ -88,16 +88,16 @@ module Braspag
         "captureAmount" => Utils.convert_decimal_to_string(amount)
       }
 
-      response = Braspag::Poster.new(self.partial_capture_url).do_post(:partial_capture, data)
+      response = Braspag::Poster.new(partial_capture_url).do_post(:partial_capture, data)
 
       Utils::convert_to_map(response.body, {
-          :amount => nil,
-          :number => "authorisationNumber",
-          :message => 'message',
-          :return_code => 'returnCode',
-          :status => 'status',
-          :transaction_id => "transactionId"
-        })
+        :amount => nil,
+        :number => "authorisationNumber",
+        :message => 'message',
+        :return_code => 'returnCode',
+        :status => 'status',
+        :transaction_id => "transactionId"
+      })
     end
 
     def self.void(order_id)
@@ -111,16 +111,16 @@ module Braspag
         MAPPING[:merchant_id] => merchant_id
       }
 
-      response = Braspag::Poster.new(self.cancellation_url).do_post(:void, data)
+      response = Braspag::Poster.new(cancellation_url).do_post(:void, data)
 
       Utils::convert_to_map(response.body, {
-          :amount => nil,
-          :number => "authorisationNumber",
-          :message => 'message',
-          :return_code => 'returnCode',
-          :status => 'status',
-          :transaction_id => "transactionId"
-        })
+        :amount => nil,
+        :number => "authorisationNumber",
+        :message => 'message',
+        :return_code => 'returnCode',
+        :status => 'status',
+        :transaction_id => "transactionId"
+      })
     end
 
     def self.info(order_id)
@@ -129,43 +129,42 @@ module Braspag
       raise InvalidOrderId unless self.valid_order_id?(order_id)
 
       data = {:loja => connection.merchant_id, :numeroPedido => order_id.to_s}
-      response = Braspag::Poster.new(self.info_url).do_post(:info_credit_card, data)
+      response = Braspag::Poster.new(info_url).do_post(:info_credit_card, data)
 
       response = Utils::convert_to_map(response.body, {
-          :checking_number => "NumeroComprovante",
-          :certified => "Autenticada",
-          :autorization_number => "NumeroAutorizacao",
-          :card_number => "NumeroCartao",
-          :transaction_number => "NumeroTransacao"
-        })
+        :checking_number => "NumeroComprovante",
+        :certified => "Autenticada",
+        :autorization_number => "NumeroAutorizacao",
+        :card_number => "NumeroCartao",
+        :transaction_number => "NumeroTransacao"
+      })
 
       raise UnknownError if response[:checking_number].nil?
       response
     end
 
-    def self.check_params(params)
-      super
-
-      [:customer_name, :holder, :card_number, :expiration, :security_code, :number_payments, :type].each do |param|
-        raise IncompleteParams if params[param].nil?
-      end
-
-      raise InvalidHolder if params[:holder].to_s.size < 1 || params[:holder].to_s.size > 100
+    def self.status(order_id)
+      connection = Braspag::Connection.instance
 
-      matches = params[:expiration].to_s.match /^(\d{2})\/(\d{2,4})$/
-      raise InvalidExpirationDate unless matches
-      begin
-        year = matches[2].to_i
-        year = "20#{year}" if year.size == 2
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
 
-        Date.new(year.to_i, matches[1].to_i)
-      rescue ArgumentError
-        raise InvalidExpirationDate
-      end
+      data = { :numeroPedido => order_id, :loja => connection.merchant_id }
 
-      raise InvalidSecurityCode if params[:security_code].to_s.size < 1 || params[:security_code].to_s.size > 4
+      response = Braspag::Poster.new(status_url).do_post(:order_status, data)
 
-      raise InvalidNumberPayments if params[:number_payments].to_i < 1 || params[:number_payments].to_i > 99
+      Utils::convert_to_map(response.body, {
+        :authorization_code => "CodigoAutorizacao",
+        :payment_code => "CodigoPagamento",
+        :payment_method => "FormaPagamento",
+        :installments => "NumeroParcelas",
+        :status => "Status",
+        :value => "Valor",
+        :payment_date => "DataPagamento",
+        :order_date => "DataPedido",
+        :transaction_id => "TransId",
+        :error_code => "CodigoErro",
+        :error_message => "MensagemErro"
+      })
     end
 
     # <b>DEPRECATED:</b> Please use <tt>ProtectedCreditCard.save</tt> instead.
@@ -186,25 +185,53 @@ module Braspag
       ProtectedCreditCard.just_click_shop(params)
     end
 
-    def self.info_url
-      connection = Braspag::Connection.instance
-      connection.braspag_url + (connection.production? ? PRODUCTION_INFO_URI : HOMOLOGATION_INFO_URI)
-    end
+    class << self
+      private
 
-    def self.authorize_url
-      Braspag::Connection.instance.braspag_url + AUTHORIZE_URI
-    end
+      def check_params(params)
+        super
 
-    def self.capture_url
-      Braspag::Connection.instance.braspag_url + CAPTURE_URI
-    end
+        [:customer_name, :holder, :card_number, :expiration, :security_code, :number_payments, :type].each do |param|
+          raise IncompleteParams if params[param].nil?
+        end
 
-    def self.partial_capture_url
-      Braspag::Connection.instance.braspag_url + PARTIAL_CAPTURE_URI
-    end
+        raise InvalidHolder if params[:holder].to_s.size < 1 || params[:holder].to_s.size > 100
+
+        matches = params[:expiration].to_s.match /^(\d{2})\/(\d{2,4})$/
+        raise InvalidExpirationDate unless matches
 
-    def self.cancellation_url
-      Braspag::Connection.instance.braspag_url + CANCELLATION_URI
+        year = matches[2].size == 4 ? matches[2] : "20#{matches[2]}"
+        raise if !Date.valid_date?(year.to_i, matches[1].to_i, 1)
+
+        raise InvalidSecurityCode if params[:security_code].to_s.size < 1 || params[:security_code].to_s.size > 4
+
+        raise InvalidNumberPayments if params[:number_payments].to_i < 1 || params[:number_payments].to_i > 99
+      end
+
+      def authorize_url
+        Braspag::Connection.instance.braspag_url + AUTHORIZE_URI
+      end
+
+      def capture_url
+        Braspag::Connection.instance.braspag_url + CAPTURE_URI
+      end
+
+      def partial_capture_url
+        Braspag::Connection.instance.braspag_url + PARTIAL_CAPTURE_URI
+      end
+
+      def cancellation_url
+        Braspag::Connection.instance.braspag_url + CANCELLATION_URI
+      end
+
+      def info_url
+        connection = Braspag::Connection.instance
+        connection.braspag_url + (connection.production? ? PRODUCTION_INFO_URI : HOMOLOGATION_INFO_URI)
+      end
+
+      def status_url
+        Braspag::Connection.instance.braspag_url + STATUS_URI
+      end
     end
   end
 end

data/lib/baby-braspag/version.rb

@@ -1,3 +1,3 @@
 module Braspag
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/credit_card_spec.rb

@@ -2,318 +2,330 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'ostruct'
 
 describe Braspag::CreditCard do
-  let(:braspag_homologation_url) { "https://homologacao.pagador.com.br" }
-  let(:braspag_production_url) { "https://transaction.pagador.com.br" }
-  let(:merchant_id) { "um id qualquer" }
-  let(:logger) { mock(:info => nil) }
+  let(:braspag_service_url) { 'https://homologacao.pagador.com.br' }
+
+  let(:connection) { mock(
+    :merchant_id => 'merchant-id',
+    :protected_card_url => 'https://www.cartaoprotegido.com.br/Services/TestEnvironment',
+    :homologation? => (environment == 'homologation'),
+    :production? => (environment == 'production'),
+    braspag_url: braspag_service_url
+  ) }
+
+  let(:request) { OpenStruct.new :url => operation_url }
+  let(:environment) { 'homologation' }
+  let(:response_xml) { nil }
+  let(:operation_url) { nil }
+
+  before { Braspag::Connection.stub(:instance => connection) }
 
   before do
-    @connection = mock(:merchant_id => merchant_id, :protected_card_url => 'https://www.cartaoprotegido.com.br/Services/TestEnvironment', :homologation? => false)
-    Braspag::Connection.stub(:instance => @connection)
+    ::HTTPI::Request.stub(:new).with(operation_url).and_return(request)
+    ::HTTPI.stub(:post).with(request).and_return(mock(:body => response_xml))
   end
 
   describe ".authorize" do
-    let(:params) do
-      {
-        :order_id => "um order id",
-        :customer_name => "W" * 21,
-        :amount => "100.00",
-        :payment_method => :redecard,
-        :holder => "Joao Maria Souza",
-        :card_number => "9" * 10,
-        :expiration => "10/12",
-        :security_code => "123",
-        :number_payments => 1,
-        :type => 0
-      }
+    let(:operation_url) { "#{connection.braspag_url}/webservices/pagador/Pagador.asmx/Authorize" }
+    let(:order_id) { 'order-id' }
+
+    let(:params) { {
+      :order_id => order_id,
+      :customer_name => 'W' * 21,
+      :amount => '100.00',
+      :payment_method => :redecard,
+      :holder => 'Joao Maria Souza',
+      :card_number => '9' * 10,
+      :expiration => '10/12',
+      :security_code => '123',
+      :number_payments => 1,
+      :type => 0
+    } }
+
+
+    let(:response_xml) do
+      <<-EOXML
+      <?xml version="1.0" encoding="utf-8"?>
+      <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                     xmlns="https://www.pagador.com.br/webservice/pagador">
+        <amount>5</amount>
+        <message>Transaction Successful</message>
+        <authorisationNumber>733610</authorisationNumber>
+        <returnCode>7</returnCode>
+        <status>2</status>
+        <transactionId>0</transactionId>
+      </PagadorReturn>
+      EOXML
     end
 
-    let(:params_with_merchant_id) do
-      params.merge!(:merchant_id => merchant_id)
+    it "request the order authorization" do
+      Braspag::CreditCard.authorize(params)
+      request.body.should == {
+        'merchantId' => 'merchant-id',
+        'order' => '',
+        'orderId' => 'order-id',
+        'customerName' => 'WWWWWWWWWWWWWWWWWWWWW',
+        'amount' => '100,00',
+        'paymentMethod' => 997,
+        'holder' => 'Joao Maria Souza',
+        'cardNumber' => '9999999999',
+        'expiration' => '10/12',
+        'securityCode' => '123',
+        'numberPayments' => 1,
+        'typePayment' => 0
+      }
     end
 
-    let(:authorize_url) { "http://braspag/bla" }
+    it "returns the authorization result" do
+      response = Braspag::CreditCard.authorize(params)
+      response.should == {
+        :amount => '5',
+        :message => 'Transaction Successful',
+        :number => '733610',
+        :return_code => '7',
+        :status => '2',
+        :transaction_id => '0'
+      }
+    end
 
-    before do
-      @connection.should_receive(:merchant_id)
+    describe "validation" do
+      [:order_id, :amount, :payment_method, :customer_name, :holder, :card_number, :expiration,
+        :security_code, :number_payments, :type].each do |param|
+        it "raises an error when #{param} parameter is missing" do
+          params[param] = nil
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::IncompleteParams)
+        end
+      end
 
-      Braspag::CreditCard.should_receive(:authorize_url)
-                         .and_return(authorize_url)
+      context "when order id is invalid" do
+        before { params[:order_id] = '' }
 
-      Braspag::CreditCard.should_receive(:check_params)
-                         .and_return(true)
-    end
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidOrderId)
+        end
+      end
 
-    context "with invalid params"
+      context "when payment method is invalid" do
+        before { params[:payment_method] = 'invalid' }
 
-    context "with valid params" do
-      let(:valid_xml) do
-        <<-EOXML
-        <?xml version="1.0" encoding="utf-8"?>
-        <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                       xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                       xmlns="https://www.pagador.com.br/webservice/pagador">
-          <amount>5</amount>
-          <message>Transaction Successful</message>
-          <authorisationNumber>733610</authorisationNumber>
-          <returnCode>7</returnCode>
-          <status>2</status>
-          <transactionId>0</transactionId>
-        </PagadorReturn>
-        EOXML
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidPaymentMethod)
+        end
       end
 
-      let(:request) { OpenStruct.new :url => authorize_url }
+      context "when customer name is too long" do
+        before { params[:customer_name] = 'n' * 256 }
 
-      before do
-        Braspag::Connection.instance.should_receive(:homologation?)
-        ::HTTPI::Request.should_receive(:new).with(authorize_url).and_return(request)
-        ::HTTPI.should_receive(:post).with(request).and_return(mock(:body => valid_xml))
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidCustomerName)
+        end
       end
 
-      it "should return a Hash" do
-        response = Braspag::CreditCard.authorize(params)
-        response.should be_kind_of Hash
-        response.should == {
-          :amount => "5",
-          :message => "Transaction Successful",
-          :number => "733610",
-          :return_code => "7",
-          :status => "2",
-          :transaction_id => "0"
-        }
-      end
+      context "when card holder name is too long" do
+        before { params[:holder] = 'h' * 101 }
 
-      it "should post transation info" do
-        Braspag::CreditCard.authorize(params)
-        request.body.should == {"merchantId"=>"um id qualquer", "order"=>"", "orderId"=>"um order id", "customerName"=>"WWWWWWWWWWWWWWWWWWWWW", "amount"=>"100,00", "paymentMethod"=>20, "holder"=>"Joao Maria Souza", "cardNumber"=>"9999999999", "expiration"=>"10/12", "securityCode"=>"123", "numberPayments"=>1, "typePayment"=>0}
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidHolder)
+        end
       end
-    end
-  end
 
-  describe ".capture" do
-    let(:capture_url) { "http://foo.bar/bar/baz" }
-    let(:order_id) { "um id qualquer" }
+      context "when expiration is in invalid format" do
+        before { params[:expiration] = '2011/19/19' }
 
-    before do
-      @connection.should_receive(:merchant_id)
-    end
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidExpirationDate)
+        end
+      end
 
-    context "invalid order id" do
-      it "should raise an error" do
-        Braspag::CreditCard.should_receive(:valid_order_id?)
-                           .with(order_id)
-                           .and_return(false)
+      context "when expiration is in valid format with invalid date" do
+        before { params[:expiration] = '2015/19' }
 
-        expect {
-          Braspag::CreditCard.capture(order_id)
-        }.to raise_error(Braspag::InvalidOrderId)
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidExpirationDate)
+        end
       end
-    end
 
-    context "valid order id" do
-      let(:valid_xml) do
-        <<-EOXML
-          <?xml version="1.0" encoding="utf-8"?>
-          <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                         xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                         xmlns="https://www.pagador.com.br/webservice/pagador">
-            <amount>2</amount>
-            <message>Approved</message>
-            <returnCode>0</returnCode>
-            <status>0</status>
-          </PagadorReturn>
-        EOXML
+      ['01/15', '01/2015'].each do |expiration|
+        context "when expiration is in #{expiration} format" do
+          before { params[:expiration] = expiration }
+
+          it "raises no error" do
+            expect { Braspag::CreditCard.authorize(params) }.not_to raise_error
+          end
+        end
       end
 
-      let(:request) { OpenStruct.new :url => capture_url }
+      context "when security code is too long" do
+        before { params[:security_code] = '12345' }
 
-      before do
-        Braspag::CreditCard.should_receive(:capture_url)
-                           .and_return(capture_url)
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidSecurityCode)
+        end
+      end
 
-        ::HTTPI::Request.should_receive(:new)
-                        .with(capture_url)
-                        .and_return(request)
+      context "when security code is too short" do
+        before { params[:security_code] = '' }
 
-        ::HTTPI.should_receive(:post)
-               .with(request)
-               .and_return(mock(:body => valid_xml))
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidSecurityCode)
+        end
       end
 
-      it "should return a Hash" do
-        response = Braspag::CreditCard.capture("order id qualquer")
-        response.should be_kind_of Hash
-        response.should == {
-          :amount => "2",
-          :number => nil,
-          :message => "Approved",
-          :return_code => "0",
-          :status => "0",
-          :transaction_id => nil
-        }
+      context "when the number of payments is too high" do
+        before { params[:number_payments] = 100 }
+
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidNumberPayments)
+        end
       end
 
-      it "should post capture info" do
-        Braspag::CreditCard.capture("order id qualquer")
-        request.body.should == {"orderId"=>"order id qualquer", "merchantId"=>"um id qualquer"}
+      context "when the number of payments is too low" do
+        before { params[:number_payments] = 0 }
+
+        it "raises an error" do
+          expect { Braspag::CreditCard.authorize(params) }.to raise_error(Braspag::InvalidNumberPayments)
+        end
       end
     end
   end
 
-  describe ".partial_capture" do
-    let(:partial_capture_url) { "http://foo.bar/bar/partial" }
-    let(:order_id) { "um id qualquer" }
+  describe ".capture" do
+    let(:operation_url) { "#{connection.braspag_url}/webservices/pagador/Pagador.asmx/Capture" }
+    let(:order_id) { 'order-id' }
 
-    before do
-      @connection.should_receive(:merchant_id)
+    let(:response_xml) do
+      <<-EOXML
+        <?xml version="1.0" encoding="utf-8"?>
+        <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                       xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                       xmlns="https://www.pagador.com.br/webservice/pagador">
+          <amount>2</amount>
+          <message>Approved</message>
+          <returnCode>0</returnCode>
+          <status>0</status>
+        </PagadorReturn>
+      EOXML
     end
 
-    context "invalid order id" do
-      it "should raise an error" do
-        Braspag::CreditCard.should_receive(:valid_order_id?)
-                           .with(order_id)
-                           .and_return(false)
+    it "requests the order capture" do
+      Braspag::CreditCard.capture('order id qualquer')
+      request.body.should == { 'orderId' => 'order id qualquer', 'merchantId' => 'merchant-id' }
+    end
 
-        expect {
-          Braspag::CreditCard.partial_capture(order_id, 10.0)
-        }.to raise_error(Braspag::InvalidOrderId)
-      end
+    it "returns the capture result" do
+      response = Braspag::CreditCard.capture('order id qualquer')
+      response.should == {
+        :amount => '2',
+        :number => nil,
+        :message => 'Approved',
+        :return_code => '0',
+        :status => '0',
+        :transaction_id => nil
+      }
     end
 
-    context "valid order id" do
-      let(:valid_xml) do
-        <<-EOXML
-          <?xml version="1.0" encoding="utf-8"?>
-          <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                         xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                         xmlns="https://www.pagador.com.br/webservice/pagador">
-            <amount>2</amount>
-            <message>Approved</message>
-            <returnCode>0</returnCode>
-            <status>0</status>
-          </PagadorReturn>
-        EOXML
+    context "when the order id is invalid" do
+      let(:order_id) { '' }
+
+      it "raises an error" do
+        expect { Braspag::CreditCard.capture(order_id) }.to raise_error(Braspag::InvalidOrderId)
       end
+    end
+  end
 
-      let(:request) { OpenStruct.new :url => partial_capture_url }
+  describe ".partial_capture" do
+    let(:operation_url) { "#{connection.braspag_url}/webservices/pagador/Pagador.asmx/CapturePartial" }
+    let(:order_id) { 'order-id' }
 
-      before do
-        Braspag::CreditCard.should_receive(:partial_capture_url)
-                           .and_return(partial_capture_url)
+    let(:response_xml) do
+      <<-EOXML
+        <?xml version="1.0" encoding="utf-8"?>
+        <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                       xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                       xmlns="https://www.pagador.com.br/webservice/pagador">
+          <amount>2</amount>
+          <message>Approved</message>
+          <returnCode>0</returnCode>
+          <status>0</status>
+        </PagadorReturn>
+      EOXML
+    end
 
-        ::HTTPI::Request.should_receive(:new)
-                        .with(partial_capture_url)
-                        .and_return(request)
+    it "requests the order partial capture" do
+      Braspag::CreditCard.partial_capture(order_id, 10.0)
+      request.body.should == { 'orderId' => 'order-id', 'captureAmount' => '10,00', 'merchantId' => 'merchant-id' }
+    end
 
-        ::HTTPI.should_receive(:post)
-               .with(request)
-               .and_return(mock(:body => valid_xml))
-      end
+    it "returns the partial capture response" do
+      response = Braspag::CreditCard.partial_capture(order_id, 10.0)
+      response.should == {
+        :amount => '2',
+        :number => nil,
+        :message => 'Approved',
+        :return_code => '0',
+        :status => '0',
+        :transaction_id => nil
+      }
+    end
 
-      it "should return a Hash" do
-        response = Braspag::CreditCard.partial_capture("order id qualquer", 10.0)
-        response.should be_kind_of Hash
-        response.should == {
-          :amount => "2",
-          :number => nil,
-          :message => "Approved",
-          :return_code => "0",
-          :status => "0",
-          :transaction_id => nil
-        }
-      end
+    context "when the order id is invalid" do
+      let(:order_id) { '' }
 
-      it "should post capture info" do
-        Braspag::CreditCard.partial_capture("order id qualquer", 10.0)
-        request.body.should == {"orderId"=>"order id qualquer", "captureAmount"=>"10,00", "merchantId"=>"um id qualquer"}
+      it "raises an error" do
+        expect { Braspag::CreditCard.partial_capture(order_id, 10.0) }.to raise_error(Braspag::InvalidOrderId)
       end
     end
   end
 
   describe ".void" do
-    let(:cancellation_url) { "http://foo.bar/bar/baz" }
-    let(:order_id) { "um id qualquer" }
+    let(:operation_url) { "#{connection.braspag_url}/webservices/pagador/Pagador.asmx/VoidTransaction" }
+    let(:order_id) { 'order-id' }
 
-    before do
-      @connection.should_receive(:merchant_id)
+    let(:response_xml) do
+      <<-EOXML
+        <?xml version="1.0" encoding="utf-8"?>
+        <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                       xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                       xmlns="https://www.pagador.com.br/webservice/pagador">
+          <amount>2</amount>
+          <message>Approved</message>
+          <returnCode>0</returnCode>
+          <status>0</status>
+        </PagadorReturn>
+      EOXML
     end
 
-    context "invalid order id" do
-      it "should raise an error" do
-        Braspag::CreditCard.should_receive(:valid_order_id?)
-                           .with(order_id)
-                           .and_return(false)
-
-        expect {
-          Braspag::CreditCard.void(order_id)
-        }.to raise_error(Braspag::InvalidOrderId)
-      end
+    it "requests the order cancellation" do
+      Braspag::CreditCard.void(order_id)
+      request.body.should == { 'order' => 'order-id', 'merchantId' => 'merchant-id' }
     end
 
-    context "valid order id" do
-      let(:valid_xml) do
-        <<-EOXML
-          <?xml version="1.0" encoding="utf-8"?>
-          <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                         xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                         xmlns="https://www.pagador.com.br/webservice/pagador">
-            <amount>2</amount>
-            <message>Approved</message>
-            <returnCode>0</returnCode>
-            <status>0</status>
-          </PagadorReturn>
-        EOXML
-      end
-
-      let(:request) { OpenStruct.new :url => cancellation_url }
-
-      before do
-        Braspag::CreditCard.should_receive(:cancellation_url)
-                           .and_return(cancellation_url)
-
-        ::HTTPI::Request.should_receive(:new).with(cancellation_url).and_return(request)
-        ::HTTPI.should_receive(:post).with(request).and_return(mock(:body => valid_xml))
-      end
+    it "returns the cancellation response" do
+      response = Braspag::CreditCard.void(order_id)
+      response.should == {
+        :amount => '2',
+        :number => nil,
+        :message => 'Approved',
+        :return_code => '0',
+        :status => '0',
+        :transaction_id => nil
+      }
+    end
 
-      it "should return a Hash" do
-        response = Braspag::CreditCard.void("order id qualquer")
-        response.should be_kind_of Hash
-        response.should == {
-          :amount => "2",
-          :number => nil,
-          :message => "Approved",
-          :return_code => "0",
-          :status => "0",
-          :transaction_id => nil
-        }
-      end
+    context "when the order id is invalid" do
+      let(:order_id) { '' }
 
-      it "should post void info" do
-        Braspag::CreditCard.void("order id qualquer")
-        request.body.should == {"order"=>"order id qualquer", "merchantId"=>"um id qualquer"}
+      it "raises an error" do
+        expect { Braspag::CreditCard.void(order_id) }.to raise_error(Braspag::InvalidOrderId)
       end
     end
   end
 
   describe ".info" do
-    let(:info_url) { "http://braspag/bla" }
+    let(:operation_url) { "#{connection.braspag_url}/pagador/webservice/pedido.asmx/GetDadosCartao" }
+    let(:order_id) { 'order-id' }
 
-    let(:invalid_xml) do
-      <<-EOXML
-      <DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                   xmlns="http://www.pagador.com.br/">
-        <NumeroComprovante></NumeroComprovante>
-        <Autenticada>false</Autenticada>
-        <NumeroAutorizacao>557593</NumeroAutorizacao>
-        <NumeroCartao>345678*****0007</NumeroCartao>
-        <NumeroTransacao>101001225645</NumeroTransacao>
-      </DadosCartao>
-      EOXML
-    end
-
-    let(:valid_xml) do
+    let(:response_xml) do
       <<-EOXML
       <DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
@@ -327,178 +339,96 @@ describe Braspag::CreditCard do
       EOXML
     end
 
-    it "should raise an error when order id is not valid" do
-      Braspag::CreditCard.should_receive(:valid_order_id?)
-                         .with("bla")
-                         .and_return(false)
-
-      expect {
-        Braspag::CreditCard.info "bla"
-      }.to raise_error(Braspag::InvalidOrderId)
-    end
-
-    it "should raise an error when Braspag returned an invalid xml as response" do
-      FakeWeb.register_uri(:post, info_url, :body => invalid_xml)
-
-      Braspag::CreditCard.should_receive(:info_url)
-                         .and_return(info_url)
-
-      expect {
-        Braspag::CreditCard.info("orderid")
-      }.to raise_error(Braspag::UnknownError)
-    end
-
-    it "should return a Hash when Braspag returned a valid xml as response" do
-      FakeWeb.register_uri(:post, info_url, :body => valid_xml)
-
-      Braspag::CreditCard.should_receive(:info_url)
-                         .and_return(info_url)
-
-      response = Braspag::CreditCard.info("orderid")
-      response.should be_kind_of Hash
-
+    it "returns the credit card info response" do
+      response = Braspag::CreditCard.info(order_id)
       response.should == {
-        :checking_number => "11111",
-        :certified => "false",
-        :autorization_number => "557593",
-        :card_number => "345678*****0007",
-        :transaction_number => "101001225645"
+        :checking_number => '11111',
+        :certified => 'false',
+        :autorization_number => '557593',
+        :card_number => '345678*****0007',
+        :transaction_number => '101001225645'
       }
     end
-  end
 
-  describe ".check_params" do
-    let(:params) do
-      {
-        :order_id => 12345,
-        :customer_name => "AAAAAAAA",
-        :payment_method => :amex_2p,
-        :amount => "100.00",
-        :holder => "Joao Maria Souza",
-        :expiration => "10/12",
-        :card_number => "9" * 10,
-        :security_code => "123",
-        :number_payments => 1,
-        :type => 0
-      }
-    end
+    context "when in production" do
+      let(:environment) { 'production' }
+      let(:operation_url) { "#{connection.braspag_url}/webservices/pagador/pedido.asmx/GetDadosCartao" }
 
-    [:order_id, :amount, :payment_method, :customer_name, :holder, :card_number, :expiration,
-      :security_code, :number_payments, :type].each do |param|
-      it "should raise an error when #{param} is not present" do
-        expect {
-          params[param] = nil
-          Braspag::CreditCard.check_params(params)
-        }.to raise_error Braspag::IncompleteParams
+      it "hits the production path" do
+        Braspag::CreditCard.info(order_id)
       end
     end
 
-    it "should raise an error when order_id is not valid" do
-      Braspag::CreditCard.should_receive(:valid_order_id?)
-                         .with(params[:order_id])
-                         .and_return(false)
-
-      expect {
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidOrderId
-    end
-
-    it "should raise an error when payment_method is not invalid" do
-      expect {
-        params[:payment_method] = "non ecziste"
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidPaymentMethod
-    end
-
-    it "should raise an error when customer_name is greater than 255 chars" do
-      expect {
-        params[:customer_name] = "b" * 256
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidCustomerName
-    end
-
-    it "should raise an error when holder is greater than 100 chars" do
-      expect {
-        params[:holder] = "r" * 101
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidHolder
-    end
-
-    it "should raise an error when expiration is not in a valid format" do
-      expect {
-        params[:expiration] = "2011/19/19"
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidExpirationDate
-
-      expect {
-        params[:expiration] = "12/2012"
-        Braspag::CreditCard.check_params(params)
-      }.to_not raise_error Braspag::InvalidExpirationDate
-
-      expect {
-        params[:expiration] = "12/12"
-        Braspag::CreditCard.check_params(params)
-      }.to_not raise_error Braspag::InvalidExpirationDate
-    end
-
-    it "should raise an error when security code is greater than 4 chars" do
-      expect {
-        params[:security_code] = "12345"
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidSecurityCode
-
-      expect {
-        params[:security_code] = ""
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidSecurityCode
-    end
-
-    it "should raise an error when number_payments is greater than 99" do
-      expect {
-        params[:number_payments] = 100
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidNumberPayments
+    context "when gateway returns a bad response" do
+      let(:response_xml) do
+        <<-EOXML
+        <DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                     xmlns="http://www.pagador.com.br/">
+          <NumeroComprovante></NumeroComprovante>
+          <Autenticada>false</Autenticada>
+          <NumeroAutorizacao>557593</NumeroAutorizacao>
+          <NumeroCartao>345678*****0007</NumeroCartao>
+          <NumeroTransacao>101001225645</NumeroTransacao>
+        </DadosCartao>
+        EOXML
+      end
 
-      expect {
-        params[:number_payments] = 0
-        Braspag::CreditCard.check_params(params)
-      }.to raise_error Braspag::InvalidNumberPayments
+      it "raises an error" do
+        expect { Braspag::CreditCard.info(order_id) }.to raise_error(Braspag::UnknownError)
+      end
     end
   end
 
-  describe ".info_url" do
-    it "should return the correct info url when connection environment is homologation" do
-      @connection.stub(:braspag_url => braspag_homologation_url)
-      @connection.should_receive(:production?)
-                 .and_return(false)
+  describe ".status" do
+    let(:operation_url) { "#{connection.braspag_url}/webservices/pagador/pedido.asmx/GetDadosPedido" }
+    let(:order_id) { 'order-id' }
 
-      Braspag::CreditCard.info_url.should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosCartao"
+    let(:response_xml) do
+      <<-EOXML
+        <?xml version="1.0" encoding="utf-8"?>
+        <DadosPedido xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.pagador.com.br/">
+          <CodigoAutorizacao>012543   </CodigoAutorizacao>
+          <CodigoPagamento>42</CodigoPagamento>
+          <FormaPagamento>Redecard Webservice PreAuth</FormaPagamento>
+          <NumeroParcelas>1</NumeroParcelas>
+          <Status>3</Status>
+          <Valor>35.46</Valor>
+          <DataPagamento>2/28/2015 12:00:00 AM</DataPagamento>
+          <DataPedido>2/28/2015 9:56:35 AM</DataPedido>
+          <TransId>0301122</TransId>
+        </DadosPedido>
+      EOXML
     end
 
-    it "should return the correct info url when connection environment is production" do
-      @connection.stub(:braspag_url => braspag_production_url)
-      @connection.should_receive(:production?)
-                 .and_return(true)
-
-      Braspag::CreditCard.info_url.should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosCartao"
+    it "requests the order status" do
+      Braspag::CreditCard.status(order_id)
+      request.body.should == { :numeroPedido => 'order-id', :loja => 'merchant-id' }
     end
-  end
 
-  describe ".authorize_url .capture_url .cancellation_url" do
-    it "should return the correct credit card creation url when connection environment is homologation" do
-      @connection.stub(:braspag_url => braspag_homologation_url)
-
-      Braspag::CreditCard.authorize_url.should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Authorize"
-      Braspag::CreditCard.capture_url.should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Capture"
-      Braspag::CreditCard.cancellation_url.should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/VoidTransaction"
+    it "returns the status response" do
+      response = Braspag::CreditCard.status(order_id)
+      response.should == {
+        :authorization_code=>'012543   ',
+        :payment_code=>'42',
+        :payment_method=>'Redecard Webservice PreAuth',
+        :installments=>'1',
+        :status=>'3',
+        :value=>'35.46',
+        :payment_date=>'2/28/2015 12:00:00 AM',
+        :order_date=>'2/28/2015 9:56:35 AM',
+        :transaction_id=>'0301122',
+        :error_code=>nil,
+        :error_message=>nil
+      }
     end
 
-    it "should return the correct credit card creation url when connection environment is production" do
-      @connection.stub(:braspag_url => braspag_production_url)
+    context "when the order id is invalid" do
+      let(:order_id) { '' }
 
-      Braspag::CreditCard.authorize_url.should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Authorize"
-      Braspag::CreditCard.capture_url.should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Capture"
-      Braspag::CreditCard.cancellation_url.should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/VoidTransaction"
+      it "raises an error" do
+        expect { Braspag::CreditCard.status(order_id) }.to raise_error(Braspag::InvalidOrderId)
+      end
     end
   end
 

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: baby-braspag
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - baby dev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2015-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.9.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.9.6
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.6.1
 - !ruby/object:Gem::Dependency
@@ -70,14 +70,14 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -98,75 +98,75 @@ dependencies:
   name: fakeweb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: debugger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: baby braspag gem to use Braspag gateway
 email:
-- ! '"dev-team@baby.com.br"'
+- '"dev-team@baby.com.br"'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -216,12 +216,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -242,4 +242,3 @@ test_files:
 - spec/protected_credit_card_spec.rb
 - spec/spec_helper.rb
 - spec/utils_spec.rb
-has_rdoc: