braspag-pagador 0.9.4

data/lib/braspag/payment/recurrency_credit_card.rb

@@ -0,0 +1,15 @@
+module Braspag
+  class Connection
+    def save_credit_card(credit_card, customer, request_id)
+      response = self.soap_request(:save_credit_card, credit_card, customer, request_id)
+    end
+    # request the credit card info in Braspag PCI Compliant
+    def get_recurrency(credit_card)
+
+    end
+
+    def recurrency(order, credit_card, request_id)
+
+    end
+  end
+end

data/lib/braspag/templates/crypto/decrypt.xml.erb

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+  <env:Header />
+  <env:Body>
+    <tns:DecryptRequest xmlns:tns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+      <tns:merchantId><%= connection.merchant_id %></tns:merchantId>
+      <tns:cryptString><%= encripted_text %></tns:cryptString>
+    </tns:DecryptRequest>
+  </env:Body>
+</env:Envelope>

data/lib/braspag/templates/crypto/encrypt.xml.erb

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+  <env:Header />
+  <env:Body>
+    <tns:EncryptRequest xmlns:tns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+      <tns:merchantId><%= connection.merchant_id %></tns:merchantId>
+      <tns:request>
+        <% map.each do |key, value| %>
+          <tns:string><%= key %>=<%= value %></tns:string>
+        <% end %>
+      </tns:request>
+    </tns:EncryptRequest>
+  </env:Body>
+</env:Envelope>

data/lib/braspag/templates/justclick/archive.xml.erb

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <SaveCreditCard xmlns="http://www.cartaoprotegido.com.br/WebService/">
+      <saveCreditCardRequestWS>
+        <MerchantKey><%= merchant_id %></MerchantKey>
+        <CustomerIdentification><%= customer.cpf%></CustomerIdentification>
+        <CustomerName><%= customer.name %></CustomerName>
+        <CardHolder><%= credit_card.holder_name %></CardHolder>
+        <CardNumber><%= credit_card.number %></CardNumber>
+        <CardExpiration><%= credit_card.year + credit_card.month %></CardExpiration>
+        <JustClickAlias><%= creditcard_alias%></JustClickAlias>
+      </saveCreditCardRequestWS>
+    </SaveCreditCard>
+  </soap:Body>
+</soap:Envelope>

data/lib/braspag/templates/justclick/get_recurrency.xml.erb

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <GetCreditCard xmlns="http://www.cartaoprotegido.com.br/WebService/">
+      <getCreditCardRequestWS>
+        <MerchantKey><%= merchant_id %></MerchantKey>
+        <JustClickKey>guid</JustClickKey>
+        <JustClickAlias>string</JustClickAlias>
+      </getCreditCardRequestWS>
+    </GetCreditCard>
+  </soap:Body>
+</soap:Envelope>

data/lib/braspag/templates/justclick/recurrency.xml.erb

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <JustClickShop xmlns="http://www.cartaoprotegido.com.br/WebService/">
+      <justClickShopRequestWS>
+        <MerchantKey>guid</MerchantKey>
+        <CustomerIdentification>string</CustomerIdentification>
+        <CustomerName>string</CustomerName>
+        <OrderId>string</OrderId>
+        <Amount>int</Amount>
+        <PaymentMethod>short</PaymentMethod>
+        <NumberInstallments>short</NumberInstallments>
+        <PaymentType>short</PaymentType>
+        <JustClickKey>guid</JustClickKey>
+        <SecurityCode>string</SecurityCode>
+        <Country>string</Country>
+        <Currency>string</Currency>
+        <MerchantIdPagador>guid</MerchantIdPagador>
+        <JustClickAlias>string</JustClickAlias>
+      </justClickShopRequestWS>
+    </JustClickShop>
+  </soap:Body>
+</soap:Envelope>

data/lib/braspag/version.rb

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

data/spec/core/connection_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Connection do
+  let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  
+  it "should accept a valid merchant" do
+    expect {
+      Braspag::Connection.new(:merchant_id => merchant_id)
+    }.to_not raise_error(Braspag::Connection::InvalidMerchantId)
+  end
+  
+  it "should raise error with invalid merchant" do
+    expect {
+      Braspag::Connection.new(:merchant_id => "INVALID")
+    }.to raise_error(Braspag::Connection::InvalidMerchantId)
+  end
+  
+  [:homologation, :production].each do |env|
+    it "should accept #{env} environment" do
+      expect {
+        Braspag::Connection.new(:merchant_id => merchant_id, :environment => env)
+      }.to_not raise_error(Braspag::Connection::InvalidEnvironment)
+    end
+  end
+  
+  it "should raise error with invalid environment" do
+    expect {
+      Braspag::Connection.new(:merchant_id => merchant_id, :environment => :bla)
+    }.to raise_error(Braspag::Connection::InvalidEnvironment)
+  end
+  
+  describe  ".production?" do
+    it "should return true" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :production)
+      connection.production?.should be(true)
+    end
+    
+    it "should return false" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      connection.production?.should be(false)
+    end
+  end
+  
+  describe  ".homologation?" do
+    it "should return true" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      connection.homologation?.should be(true)
+    end
+    
+    it "should return false" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :production)
+      connection.homologation?.should be(false)
+    end
+  end
+  
+  describe ".url_for" do
+    let(:braspag_homologation_url) { "https://homologacao.pagador.com.br" }
+    let(:braspag_production_url) { "https://transaction.pagador.com.br" }
+    let(:braspag_homologation_protected_card_url) { "https://homologacao.braspag.com.br/services/testenvironment" }
+    let(:braspag_production_protected_card_url) { "https://cartaoprotegido.braspag.com.br/Services" }
+    
+    it "should return the correct credit card creation url when connection environment is homologation" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      connection.url_for(:authorize).should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Authorize"
+      connection.url_for(:capture).should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Capture"
+      connection.url_for(:void).should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/VoidTransaction"
+      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_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"
+      connection.url_for(:get_card).should == "#{braspag_homologation_protected_card_url}/CartaoProtegido.asmx/GetCreditCard"
+      connection.url_for(:recurrency).should == "#{braspag_homologation_protected_card_url}/CartaoProtegido.asmx?wsdl"
+    end
+
+    it "should return the correct credit card creation url when connection environment is production" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :production)
+      connection.url_for(:authorize).should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Authorize"
+      connection.url_for(:capture).should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Capture"
+      connection.url_for(:void).should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/VoidTransaction"
+      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_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"
+      connection.url_for(:get_card).should == "#{braspag_production_protected_card_url}/CartaoProtegido.asmx/GetCreditCard"
+      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

@@ -0,0 +1,123 @@
+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 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 ".hash_from_xml" do
+    let(:document) do
+      <<-XML
+      <root>
+        <foo>blabla</foo>
+        <bar>bleble</bar>
+        <baz></baz>
+      </root>
+      XML
+    end
+
+    context "basic document and keys" do
+      it "should return a Hash" do
+        keys = { :foo => nil, :meu_elemento => "bar", :outro_elemento => "baz" }
+        expected = { :foo => "blabla", :meu_elemento => "bleble", :outro_elemento => nil }
+
+        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
+
+    context "keys with a Proc" do
+      it "should return a Hash" do
+        proc = Proc.new { "value returned by Proc" }
+
+        keys = { :foo => proc, :meu_elemento => "bar", :outro_elemento => "baz" }
+        expected = { :foo => "value returned by Proc", :meu_elemento => "bleble", :outro_elemento => nil }
+
+        Braspag::Converter::hash_from_xml(document, keys).should == expected
+      end
+    end
+  end
+  
+  describe ".payment_method_name?" do
+    it "should return name from number" do
+      Braspag::Converter.payment_method_name?(6).should eq(:billet_bradesco)
+    end
+
+    it "should return name from string" do
+      Braspag::Converter.payment_method_name?("6").should eq(:billet_bradesco)
+    end
+
+    it "should return name from string with 0" do
+      Braspag::Converter.payment_method_name?("06").should eq(:billet_bradesco)
+    end
+
+    it "should return nil when not found" do
+      Braspag::Converter.payment_method_name?("AAA").should be(nil)
+    end
+  end
+  
+  describe ".status_name?" do
+    it "should return name from number" do
+      Braspag::Converter.status_name?(1).should eq(:starting)
+    end
+
+    it "should return name from string" do
+      Braspag::Converter.status_name?("1").should eq(:starting)
+    end
+
+    it "should return name from string with 0" do
+      Braspag::Converter.status_name?("01").should eq(:starting)
+    end
+
+    it "should return nil when not found" do
+      Braspag::Converter.status_name?("AAA").should be(nil)
+    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/customer_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Customer do
+  [:purchase, :generate, :authorize, :archive, :recurrency ].each do |context_type|
+    context "on #{context_type}" do
+      it "should validate minimum 1 length of name" do
+        subject.name = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:name].should include("is too short (minimum is 1 characters)")
+      end
+
+      it "should validate maximum 100 length of name" do
+        subject.name = '*' * 110
+        subject.valid?(context_type)
+        subject.errors.messages[:name].should include("is too long (maximum is 100 characters)")
+      end
+
+      it "should allow blank for email" do
+        subject.email = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:email].should be(nil)
+      end
+
+      it "should validate maximum 255 length of email" do
+        subject.email = '*' * 260
+        subject.valid?(context_type)
+        subject.errors.messages[:email].should include("is too long (maximum is 255 characters)")
+      end
+
+      it "should allow blank for document" do
+        subject.document = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:document].should be(nil)
+      end
+
+      it "should validate minimum 11 length of document" do
+        subject.document = 'XXX'
+        subject.valid?(context_type)
+        subject.errors.messages[:document].should include("is too short (minimum is 11 characters)")
+      end
+
+      it "should validate maximum 18 length of document" do
+        subject.document = '*' * 20
+        subject.valid?(context_type)
+        subject.errors.messages[:document].should include("is too long (maximum is 18 characters)")
+      end
+    end
+  end
+end

data/spec/core/order_spec.rb

@@ -0,0 +1,504 @@
+# 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(: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
+
+  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"?>
+      <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"?>
+      <DadosBoleto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://www.pagador.com.br/">
+      <NumeroDocumento>999</NumeroDocumento>
+      <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>
+      <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
+    
+    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
+    
+    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))
+
+      order.customer.name.should eq('XPTO')
+
+      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))
+
+      resp.should eq({
+        :document_number => nil,
+        :payer => 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
+
+  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>
+        <NumeroCartao>345678*****0007</NumeroCartao>
+        <NumeroTransacao>101001225645</NumeroTransacao>
+      </DadosCartao>
+      EOXML
+    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
+    
+    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
+      it "should validate minimum 1 length of id" do
+        subject.id = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:id].should include("is too short (minimum is 1 characters)")
+      end
+
+      it "should validate maximum 20 length of id" do
+        subject.id = '*' * 25
+        subject.valid?(context_type)
+        subject.errors.messages[:id].should include("is too long (maximum is 20 characters)")
+      end
+
+      it "should allow characters without payment_method"  do
+        subject.id = '*13*'
+        subject.valid?(context_type)
+        subject.errors.messages[:id].should eq(nil)
+      end
+      
+      [:cielo_noauth_visa, :cielo_preauth_visa, :cielo_noauth_mastercard, :cielo_preauth_mastercard, :cielo_noauth_elo, :cielo_noauth_diners ].each do |payment_method|
+        context "when has payment method for #{payment_method}" do
+          it "should not allow spaces" do
+            subject.payment_method = Braspag::PAYMENT_METHOD[payment_method]
+            subject.id = '123 4'
+            subject.valid?(context_type)
+            subject.errors.messages[:id].should include("is invalid")
+          end
+          it "should not allow characters" do
+            subject.payment_method = Braspag::PAYMENT_METHOD[payment_method]
+            subject.id = 'abcd'
+            subject.valid?(context_type)
+            subject.errors.messages[:id].should include("is invalid")
+          end
+
+          it "should not allow special characters" do
+            subject.payment_method = Braspag::PAYMENT_METHOD[payment_method]
+            subject.id = '*-[]'
+            subject.valid?(context_type)
+            subject.errors.messages[:id].should include("is invalid")
+          end
+        end
+      end
+    end
+  end
+  
+  [:purchase, :generate, :authorize, :recurrency].each do |context_type|
+    context "on #{context_type}" do
+      it "should not allow blank for payment_method" do
+        subject.payment_method = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:payment_method].should include("can't be blank")
+      end
+    
+      it "should not allow blank for amount" do
+        subject.amount = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:amount].should include("can't be blank")
+      end
+    
+      it "should validate minimum 1 of amount" do
+        subject.amount = 0
+        subject.valid?(context_type)
+        subject.errors.messages[:amount].should include("must be greater than 0")
+      end
+    
+      it "should not allow blank for customer" do
+        subject.customer = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:customer].should include("can't be blank")
+      end
+
+      it "should not allow invalid customer" do
+        subject.customer = Braspag::Customer.new
+        subject.valid?(context_type)
+        subject.errors.messages[:customer].should include("invalid data")
+      end
+    
+      it "should accept only valid payment method" do
+        subject.payment_method = 0
+        subject.valid?(context_type)
+        subject.errors.messages[:payment_method].should include("invalid payment code")
+      end
+    end
+  end
+
+  [:purchase, :authorize, :recurrency].each do |context_type|
+    context "on #{context_type}" do
+      it "should not allow blank for installments" do
+        subject.installments = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:installments].should include("can't be blank")
+      end
+    
+      it "should validate minimum 1 of installments" do
+        subject.installments = 0
+        subject.valid?(context_type)
+        subject.errors.messages[:installments].should include("must be greater than 0")
+      end
+    
+    
+      it "should validate maxium 99 of installments" do
+        subject.installments = 100
+        subject.valid?(context_type)
+        subject.errors.messages[:installments].should include("must be less than 100")
+      end
+    
+      it "should not allow blank for installments_type" do
+        subject.installments_type = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:installments_type].should include("can't be blank")
+      end
+    
+      it "should accept only valid installments_type" do
+        subject.installments_type = 100
+        subject.valid?(context_type)
+        subject.errors.messages[:installments_type].should include("invalid installments type")
+      end
+    
+    
+      context "when installments_type is NO_INTEREST" do
+        it "should installments is one" do
+          subject.installments_type = Braspag::INTEREST[:no]
+          subject.installments = 3
+          subject.valid?(context_type)
+          subject.errors.messages[:installments].should include("is invalid")
+        end
+      end
+    end
+  end
+end