cbraspag 0.9.3 → 0.9.4

data/lib/cbraspag/version.rb

@@ -1,3 +1,3 @@
 module Braspag
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

data/spec/core/connection_spec.rb

@@ -68,7 +68,7 @@ describe Braspag::Connection do
       connection.url_for(:generate_billet).should == "#{braspag_homologation_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
       connection.url_for(:generate_eft).should == "#{braspag_homologation_url}/pagador/passthru.asp"
       connection.url_for(:info_billet).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosBoleto"
-      connection.url_for(:info_card).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosCartao"
+      connection.url_for(:info_credit_card).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosCartao"
       connection.url_for(:info).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosPedido"
       connection.url_for(:encrypt).should == "#{braspag_homologation_url}/BraspagGeneralService/BraspagGeneralService.asmx"
       connection.url_for(:archive_card).should == "#{braspag_homologation_protected_card_url}/CartaoProtegido.asmx?wsdl"
@@ -84,7 +84,7 @@ describe Braspag::Connection do
       connection.url_for(:generate_billet).should == "#{braspag_production_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
       connection.url_for(:generate_eft).should == "#{braspag_production_url}/pagador/passthru.asp"
       connection.url_for(:info_billet).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosBoleto"
-      connection.url_for(:info_card).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosCartao"
+      connection.url_for(:info_credit_card).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosCartao"
       connection.url_for(:info).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosPedido"
       connection.url_for(:encrypt).should == "#{braspag_production_url}/BraspagGeneralService/BraspagGeneralService.asmx"
       connection.url_for(:archive_card).should == "#{braspag_production_protected_card_url}/CartaoProtegido.asmx?wsdl"
@@ -92,4 +92,58 @@ describe Braspag::Connection do
       connection.url_for(:recurrency).should == "#{braspag_production_protected_card_url}/CartaoProtegido.asmx?wsdl"
     end
   end
+  
+  describe ".post" do
+    it "should convert data" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      
+      mock1 = mock
+      mock2 = mock
+      resp = mock
+      convert_to = mock
+      
+      connection.should_receive(:convert).with(
+        :info,
+        :to,
+        [mock1, mock2]
+      ).and_return(convert_to)
+      
+      connection.should_receive(:convert).with(
+        :info,
+        :from,
+        [mock1, mock2, resp]
+      )
+      
+      Braspag::Poster.any_instance.should_receive(:do_post).with(
+        :info,
+        convert_to
+      ).and_return(resp)
+      
+      connection.post(:info, mock1, mock2)
+    end
+  end
+  
+  describe ".convert" do
+    let (:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation) }
+    {
+      :authorize => Braspag::CreditCard,
+      :void => Braspag::CreditCard,
+      :capture => Braspag::CreditCard,
+      :archive_card => Braspag::CreditCard,
+      :get_card => Braspag::CreditCard,
+      :recurrency => Braspag::CreditCard,
+      :generate_billet => Braspag::Billet,
+      :generate_eft => Braspag::EFT,
+      :info_billet => Braspag::Order,
+      :info_credit_card => Braspag::Order,
+      :info => Braspag::Order,
+      :encrypt => Braspag::Crypto::Webservice
+    }.each do |method_name, kclass|
+      it "should call method when convert #{method_name} to #{kclass}" do
+        args = [mock, mock]
+        kclass.should_receive("to_#{method_name}".to_sym).with(connection, args[0], args[1])
+        connection.convert(method_name, :to, args)
+      end
+    end
+  end
 end

data/spec/core/converter_spec.rb

@@ -3,17 +3,32 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Braspag::Converter do
   describe ".decimal_to_string" do
     it "should convert decimal to string with comma as decimal separator" do
-      Braspag::Converter.decimal_to_string(10).should == "10,00"
-      Braspag::Converter.decimal_to_string(1).should == "1,00"
-      Braspag::Converter.decimal_to_string(0.1).should == "0,10"
-      Braspag::Converter.decimal_to_string(0.01).should == "0,01"
-      Braspag::Converter.decimal_to_string(9.99999).should == "10,00" # round up
-      Braspag::Converter.decimal_to_string(10.9).should == "10,90"
-      Braspag::Converter.decimal_to_string(9.1111).should == "9,11"
+      Braspag::Converter.decimal_to_string(10).should eq("10,00")
+      Braspag::Converter.decimal_to_string(1).should eq("1,00")
+      Braspag::Converter.decimal_to_string(0.1).should eq("0,10")
+      Braspag::Converter.decimal_to_string(0.01).should eq("0,01")
+      Braspag::Converter.decimal_to_string(9.99999).should eq("10,00") # round up
+      Braspag::Converter.decimal_to_string(10.9).should eq("10,90")
+      Braspag::Converter.decimal_to_string(9.1111).should eq("9,11")
+      Braspag::Converter.decimal_to_string("10,00").should eq("10,00")
+    end
+  end
+  
+  describe ".string_to_decimal" do
+    it "should string with comma as decimal separator to decimal" do
+      Braspag::Converter.string_to_decimal("1000,00").should eq(1000.00)
+      Braspag::Converter.string_to_decimal("1.000,00").should eq(1000.00)
+      Braspag::Converter.string_to_decimal("10,00").should eq(10.00)
+      Braspag::Converter.string_to_decimal("1,00").should eq(1.00)
+      Braspag::Converter.string_to_decimal("0,10").should eq(0.1)
+      Braspag::Converter.string_to_decimal("0,01").should eq(0.01)
+      Braspag::Converter.string_to_decimal("9,99").should eq(9.99)
+      Braspag::Converter.string_to_decimal("10,9").should eq(10.90)
+      Braspag::Converter.string_to_decimal("9,1111").should eq(9.1111)
     end
   end
 
-  describe ".to_map" do
+  describe ".hash_from_xml" do
     let(:document) do
       <<-XML
       <root>
@@ -29,7 +44,14 @@ describe Braspag::Converter do
         keys = { :foo => nil, :meu_elemento => "bar", :outro_elemento => "baz" }
         expected = { :foo => "blabla", :meu_elemento => "bleble", :outro_elemento => nil }
 
-        Braspag::Converter::to_map(document, keys).should == expected
+        Braspag::Converter::hash_from_xml(document, keys).should == expected
+      end
+      
+      it "should return a Hash with invalid key" do
+        keys = { :foo => "invalid", :meu_elemento => "bar", :outro_elemento => "baz" }
+        expected = { :foo => nil, :meu_elemento => "bleble", :outro_elemento => nil }
+
+        Braspag::Converter::hash_from_xml(document, keys).should == expected
       end
     end
 
@@ -40,7 +62,7 @@ describe Braspag::Converter do
         keys = { :foo => proc, :meu_elemento => "bar", :outro_elemento => "baz" }
         expected = { :foo => "value returned by Proc", :meu_elemento => "bleble", :outro_elemento => nil }
 
-        Braspag::Converter::to_map(document, keys).should == expected
+        Braspag::Converter::hash_from_xml(document, keys).should == expected
       end
     end
   end
@@ -81,4 +103,21 @@ describe Braspag::Converter do
     end
   end
   
+  describe "payment_method_type?" do
+    it "should response nil when invalid method" do
+      Braspag::Converter.payment_method_type?(999).should be(nil)
+    end
+    
+    it "should response billet" do
+      Braspag::Converter.payment_method_type?(6).should be(:billet)
+    end
+    
+    it "should response eft" do
+      Braspag::Converter.payment_method_type?(16).should be(:eft)
+    end
+    
+    it "should response credit_card" do
+      Braspag::Converter.payment_method_type?(997).should be(:credit_card)
+    end
+  end
 end

data/spec/core/order_spec.rb

@@ -1,24 +1,220 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
+describe Braspag::Connection do
+  let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+  let(:order) { Braspag::Order.new(:id => "XPTO") }
+  
+  describe ".get" do
+    context "when error" do
+      it "should return message for response blank" do
+        connection.stub(:post).and_return({})
+        response = connection.get(order)
+        
+        response.success?.should eq(false)
+        response.message.should eq('')
+        response.params.should eq({})
+        response.test.should eq(true)
+      end
+      
+      it "should return message for error code" do
+        order_response = {:error_code => 'bla', :error_message => 'xpto', :status => '223'}
+        connection.stub(:post).and_return(order_response)
+        response = connection.get(order)
+        
+        response.success?.should eq(false)
+        response.message.should eq(order_response[:error_message])
+        response.params.should eq({"error_code"=>"bla", "error_message"=>"xpto", "status" => '223'})
+        response.test.should eq(true)
+      end
+      
+      it "should return message for empty status" do
+        connection.stub(:post).and_return({:error_message => 'bla'})
+        response = connection.get(order)
+        
+        response.success?.should eq(false)
+        response.message.should eq('bla')
+        response.params.should eq({"error_message"=>"bla"})
+        response.test.should eq(true)
+      end
+    end
+    
+    it "should return response ok" do
+      connection.stub(:post).and_return({:status => '1'})
+      response = connection.get(order)
+      
+      response.success?.should eq(true)
+      response.message.should eq('OK')
+      response.params.should eq({"status" => "1"})
+      response.test.should eq(true)
+    end
+    
+    it "should get more info for billet" do
+      connection.should_receive(:post).and_return({:status => '1'})
+      connection.should_receive(:post).with(:info_billet, order)
+      order.payment_method = 6 #BILLET BRADESCO
+      response = connection.get(order)
+      
+      response.success?.should eq(true)
+      response.message.should eq('OK')
+      response.params.should eq({"status" => "1"})
+      response.test.should eq(true)
+    end
+    
+    it "should get more info for credit_card" do
+      connection.should_receive(:post).and_return({:status => '1'})
+      connection.should_receive(:post).with(:info_credit_card, order)
+      order.payment_method = 18 #AMEX
+      response = connection.get(order)
+      
+      response.success?.should eq(true)
+      response.message.should eq('OK')
+      response.params.should eq({"status" => "1"})
+      response.test.should eq(true)
+    end
+  end
+end
+
 describe Braspag::Order 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(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+
+  describe ".payment_method_type?" do
+    it "should return payment method type" do
+      order = subject
+      order.payment_method = 6
+      order.payment_method_type?.should eq(:billet)
+    end
+  end
 
-  
-  pending ".info_billet" do
-    let(:info_url) { "http://braspag/bla" }
+  context "on info" do
+    let(:valid_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>885796</CodigoAutorizacao>
+        <CodigoPagamento>18</CodigoPagamento>
+        <FormaPagamento>American Express 2P</FormaPagamento>
+        <NumeroParcelas>1</NumeroParcelas>
+        <Status>3</Status>
+        <Valor>0.01</Valor>
+        <DataCancelamento>7/8/2011 1:19:38 PM</DataCancelamento>
+        <DataPagamento>7/8/2011 1:19:38 PM</DataPagamento>
+        <DataPedido>7/8/2011 1:06:06 PM</DataPedido>
+        <TransId>398591</TransId>
+        <BraspagTid>5a1d4463-1d11-4571-a877-763aba0ef7ff</BraspagTid>
+      </DadosPedido>
+      EOXML
+    end
+    
     let(:invalid_xml) do
       <<-EOXML
       <?xml version="1.0" encoding="utf-8"?>
-      <DadosBoleto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      <DadosPedido xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                    xsi:nil="true"
                    xmlns="http://www.pagador.com.br/" />
       EOXML
     end
-
+    
+    let(:error_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/">
+        <CodigoErro>885796</CodigoErro>
+        <MensagemErro>Deu um erro terrivel</MensagemErro>
+      </DadosPedido>
+      EOXML
+    end
+    
+    let(:order) { Braspag::Order.new(:id => "XPTO") }
+    
+    it "should convert objects to hash" do
+      Braspag::Order.to_info(connection, order).should eq({
+        "loja"          => "#{merchant_id}", 
+        "numeroPedido"  => "#{order.id}"
+      })
+    end
+    
+    it "should populate data" do
+      resp = Braspag::Order.from_info(connection, order, mock(:body => valid_xml))
+      
+      order.authorization.should eq('885796')
+      order.payment_method_name.should eq('American Express 2P')
+      order.payment_method.should eq('18')
+      order.installments.should eq('1')
+      order.status.should eq('3')
+      order.amount.should eq(0.01)
+      order.gateway_cancelled_at.should eq(Time.parse('2011-08-07 13:19:38 -0300'))
+      order.gateway_paid_at.should eq(Time.parse('2011-08-07 13:19:38 -0300'))
+      order.gateway_created_at.should eq(Time.parse('2011-08-07 13:06:06 -0300'))
+      order.transaction_id.should eq('398591')
+      order.gateway_id.should eq('5a1d4463-1d11-4571-a877-763aba0ef7ff')
+      
+      resp.should eq({
+        :authorization       => "885796",
+        :error_code          => nil,
+        :error_message       => nil,
+        :payment_method      => "18",
+        :payment_method_name => "American Express 2P",
+        :installments        => "1", 
+        :status              => "3",
+        :amount              => "0.01",
+        :cancelled_at        => Time.parse('2011-08-07 13:19:38 -0300'),
+        :paid_at             => Time.parse('2011-08-07 13:19:38 -0300'),
+        :order_date          => Time.parse('2011-08-07 13:06:06 -0300'),
+        :transaction_id      => "398591",
+        :tid                 => "5a1d4463-1d11-4571-a877-763aba0ef7ff"
+      })
+    end
+    
+    it "should populate data accepts invalid xml" do
+      resp = Braspag::Order.from_info(connection, order, mock(:body => invalid_xml))
+      
+      resp.should eq({
+        :authorization       => nil,
+        :error_code          => nil,
+        :error_message       => nil,
+        :payment_method      => nil,
+        :payment_method_name => nil,
+        :installments        => nil,
+        :status              => nil,
+        :amount              => nil,
+        :cancelled_at        => nil,
+        :paid_at             => nil,
+        :order_date          => nil,
+        :transaction_id      => nil,
+        :tid                 => nil
+      })
+    end
+    
+    it "should populate data for error" do
+      resp = Braspag::Order.from_info(connection, order, mock(:body => error_xml))
+      
+      resp.should eq({
+        :authorization       => nil,
+        :error_code          => "885796",
+        :error_message       => "Deu um erro terrivel",
+        :payment_method      => nil,
+        :payment_method_name => nil,
+        :installments        => nil,
+        :status              => nil,
+        :amount              => nil,
+        :cancelled_at        => nil,
+        :paid_at             => nil,
+        :order_date          => nil,
+        :transaction_id      => nil,
+        :tid                 => nil
+      })
+    end
+  end
+  
+  context "on info for billet" do
     let(:valid_xml) do
       <<-EOXML
       <?xml version="1.0" encoding="utf-8"?>
@@ -26,92 +222,112 @@ describe Braspag::Order do
                    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                    xmlns="http://www.pagador.com.br/">
       <NumeroDocumento>999</NumeroDocumento>
-      <Sacado/>
+      <Sacado>XPTO</Sacado>
       <NossoNumero>999</NossoNumero>
       <LinhaDigitavel>35690.00361 03962.070003 00000.009993 4 50160000001000</LinhaDigitavel>
       <DataDocumento>22/6/2011</DataDocumento>
       <DataVencimento>2/7/2011</DataVencimento>
-      <Cedente>Gonow Tecnologia e Acessoria Empresarial Ltda</Cedente>
+      <DataCredito>2/7/2011</DataCredito>
+      <Cedente>Acessoria Empresarial Ltda</Cedente>
       <Banco>356-5</Banco>
       <Agencia>0003</Agencia>
       <Conta>6039620</Conta>
       <Carteira>57</Carteira>
       <ValorDocumento>10,00</ValorDocumento>
+      <ValorPago>10,00</ValorPago>
       </DadosBoleto>
       EOXML
     end
-
-    it "should raise an error when order id is not valid" do
-      Braspag::Bill.should_receive(:valid_order_id?)
-                   .with("bla")
-                   .and_return(false)
-
-      expect {
-        Braspag::Bill.info "bla"
-      }.to raise_error(Braspag::InvalidOrderId)
+    
+    let(:invalid_xml) do
+      <<-EOXML
+      <?xml version="1.0" encoding="utf-8"?>
+      <DadosBoleto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://www.pagador.com.br/">
+      </DadosBoleto>
+      EOXML
     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::Bill.should_receive(:info_url)
-                   .and_return(info_url)
-
-      expect {
-        Braspag::Bill.info("orderid")
-      }.to raise_error(Braspag::UnknownError)
+    
+    let(:order) { Braspag::Order.new(:id => "XPTO") }
+    
+    it "should convert objects to hash" do
+      Braspag::Order.to_info_billet(connection, order).should eq({
+        "loja"          => "#{merchant_id}", 
+        "numeroPedido"  => "#{order.id}"
+      })
     end
+    
+    it "should populate data" do
+      resp = Braspag::Order.from_info_billet(connection, order, mock(:body => valid_xml))
 
-    it "should return a Hash when Braspag returned a valid xml as response" do
-      FakeWeb.register_uri(:post, info_url, :body => valid_xml)
-
-      Braspag::Bill.should_receive(:info_url)
-                   .and_return(info_url)
+      order.customer.name.should eq('XPTO')
 
-      response = Braspag::Bill.info("orderid")
-      response.should be_kind_of Hash
+      order.billet.id.should eq('999')
+      order.billet.code.should eq('35690.00361 03962.070003 00000.009993 4 50160000001000')
+      
+      order.billet.created_at.should eq(Date.parse('2011-06-22'))
+      order.billet.due_date_on.should eq(Date.parse('2011-07-2'))
+      
+      order.billet.receiver.should eq('Acessoria Empresarial Ltda')
+      
+      order.billet.bank.should eq('356-5')
+      order.billet.agency.should eq('0003')
+      order.billet.account.should eq('6039620')
+      order.billet.wallet.should eq('57')
+      order.billet.amount.should eq(10.00)
+      order.billet.amount_paid.should eq(10.00)
+      order.billet.paid_at.should eq(Date.parse('2011-07-02'))
+
+      resp.should eq({
+        :document_number=>"999",
+        :payer=>"XPTO",
+        :our_number=>"999",
+        :bill_line=>"35690.00361 03962.070003 00000.009993 4 50160000001000",
+        :document_date=>Date.parse('2011-06-22'),
+        :expiration_date=>Date.parse('2011-07-2'),
+        :receiver=>"Acessoria Empresarial Ltda",
+        :bank=>"356-5",
+        :agency=>"0003",
+        :account=>"6039620",
+        :wallet=>"57",
+        :amount=>"10,00",
+        :amount_invoice=>"10,00",
+        :invoice_date=> Date.parse('2011-07-02')
+      })
+    end
+    
+    it "should not raise error for invalid xml" do
+      resp = Braspag::Order.from_info_billet(connection, order, mock(:body => invalid_xml))
 
-      response.should == {
-        :document_number => "999",
+      resp.should eq({
+        :document_number => nil,
         :payer => nil,
-        :our_number => "999",
-        :bill_line => "35690.00361 03962.070003 00000.009993 4 50160000001000",
-        :document_date => "22/6/2011",
-        :expiration_date => "2/7/2011",
-        :receiver => "Gonow Tecnologia e Acessoria Empresarial Ltda",
-        :bank => "356-5",
-        :agency => "0003",
-        :account => "6039620",
-        :wallet => "57",
-        :amount => "10,00",
-        :amount_invoice => nil,
-        :invoice_date => nil
-      }
+        :our_number => nil,
+        :bill_line => nil,
+        :document_date => nil,
+        :expiration_date => nil,
+        :receiver => nil,
+        :bank=> nil,
+        :agency=> nil,
+        :account=> nil,
+        :wallet=> nil,
+        :amount=> nil,
+        :amount_invoice=> nil,
+        :invoice_date=> nil
+      })
     end
   end
-  
-  pending ".info" do
-    let(:info_url) { "http://braspag/bla" }
-
-    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
 
+  context "on info for credit card" do
     let(:valid_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/">
+        <RetornoAVS>12</RetornoAVS>
+        <Emissor>VISA</Emissor>
+        <NumeroAutenticacao>12345</NumeroAutenticacao>
         <NumeroComprovante>11111</NumeroComprovante>
         <Autenticada>false</Autenticada>
         <NumeroAutorizacao>557593</NumeroAutorizacao>
@@ -120,134 +336,40 @@ describe Braspag::Order do
       </DadosCartao>
       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
-
-      response.should == {
-        :checking_number => "11111",
-        :certified => "false",
-        :autorization_number => "557593",
-        :card_number => "345678*****0007",
-        :transaction_number => "101001225645"
-      }
-    end
-  end
-
-  pending ".status" do
-    let(:order_id) { "um order id qualquer" }
-    let(:status_url) { "http://foo.com/bar/baz/assererre" }
-
-    context "with invalid order id" do
-      let(:invalid_xml) do
-        <<-EOXML
-        <?xml version="1.0" encoding="utf-8"?>
-        <DadosBoleto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                     xsi:nil="true"
-                     xmlns="http://www.pagador.com.br/" />
-        EOXML
-      end
-
-      it "should raise an error when order id is not valid" do
-        Braspag::PaymentMethod.should_receive(:valid_order_id?)
-                              .with(order_id)
-                              .and_return(false)
-
-        expect {
-          Braspag::Order.status(order_id)
-        }.to raise_error(Braspag::InvalidOrderId)
-      end
-
-      it "should raise an error when Braspag returns an invalid xml" do
-        FakeWeb.register_uri(:post, status_url, :body => invalid_xml)
-
-        Braspag::Order.should_receive(:status_url)
-                      .and_return(status_url)
-
-        expect {
-          Braspag::Order.status(order_id)
-        }.to raise_error(Braspag::Order::InvalidData)
-      end
+    
+    let(:order) { Braspag::Order.new(:id => "XPTO") }
+    
+    it "should convert objects to hash" do
+      Braspag::Order.to_info_credit_card(connection, order).should eq({
+        "loja"          => "#{merchant_id}", 
+        "numeroPedido"  => "#{order.id}"
+      })
     end
-
-    context "with valid order id" do
-      let(:valid_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>885796</CodigoAutorizacao>
-          <CodigoPagamento>18</CodigoPagamento>
-          <FormaPagamento>American Express 2P</FormaPagamento>
-          <NumeroParcelas>1</NumeroParcelas>
-          <Status>3</Status>
-          <Valor>0.01</Valor>
-          <DataPagamento>7/8/2011 1:19:38 PM</DataPagamento>
-          <DataPedido>7/8/2011 1:06:06 PM</DataPedido>
-          <TransId>398591</TransId>
-          <BraspagTid>5a1d4463-1d11-4571-a877-763aba0ef7ff</BraspagTid>
-        </DadosPedido>
-        EOXML
-      end
-
-      before do
-        Braspag::Order.should_receive(:status_url)
-                      .and_return(status_url)
-
-        FakeWeb.register_uri(:post, status_url, :body => valid_xml)
-        @response = Braspag::Order.status(order_id)
-      end
-
-      it "should return a Hash" do
-        @response.should be_kind_of Hash
-        @response.should == {
-          :authorization => "885796",
-          :error_code => nil,
-          :error_message => nil,
-          :payment_method => "18",
-          :payment_method_name => "American Express 2P",
-          :installments => "1",
-          :status => "3",
-          :amount => "0.01",
-          :cancelled_at => nil,
-          :paid_at => "7/8/2011 1:19:38 PM",
-          :order_date => "7/8/2011 1:06:06 PM",
-          :transaction_id => "398591",
-          :tid => "5a1d4463-1d11-4571-a877-763aba0ef7ff"
-        }
-      end
+    
+    it "should populate data" do
+      resp = Braspag::Order.from_info_credit_card(connection, order, mock(:body => valid_xml))
+
+      order.credit_card.checking_number.should eq('11111')
+      order.credit_card.avs.should eq('false')
+      order.credit_card.autorization_number.should eq('557593')
+      order.credit_card.number.should eq('345678*****0007')
+      order.credit_card.transaction_number.should eq('101001225645')
+      order.credit_card.avs_response.should eq('12')
+      order.credit_card.issuing.should eq('VISA')
+      order.credit_card.authenticated_number.should eq('12345')
+
+      resp.should eq({
+        :checking_number      => "11111",
+        :certified            => "false",
+        :autorization_number  => "557593",
+        :card_number          => "345678*****0007",
+        :transaction_number   => "101001225645",
+        :avs_response         => "12",
+        :issuing              => "VISA",
+        :authenticated_number => "12345"
+      })
     end
   end
-
   
   [:purchase, :generate, :authorize, :capture, :void, :recurrency].each do |context_type|
     context "on #{context_type}" do