braspag-pagador 0.9.4

data/spec/core/poster_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Braspag::Poster do
+  let(:request) { OpenStruct.new(:url => 'http://foo/bar') }
+  let(:response) { mock(:body => 'success') }
+  let(:logger) { mock(:info => nil) }
+  let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+  let(:connection_logger) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation, :logger => logger)}
+  let(:connection_proxy) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation, :proxy_address => 'http://proxy.com')}
+
+  describe "#do_post" do
+    before do
+      ::HTTPI::Request.should_receive(:new).with('http://foo/bar').and_return(request)
+      ::HTTPI.should_receive(:post).with(request).and_return(response)
+    end
+
+    context "without proxy and logger" do
+      subject { described_class.new(connection, 'http://foo/bar') }
+
+      it "should not set the proxy if the proxy_address is not set" do
+        request.should_not_receive(:proxy=)
+        subject.do_post(:foo, {})
+      end
+      
+      it "should not raise an error if logger is not defined" do
+        expect {
+          subject.do_post(:doe, { :foo => :bar, :egg => :span })
+        }.to_not raise_error
+      end
+      
+    end
+
+    context "with logger" do
+      subject { described_class.new(connection_logger, 'http://foo/bar') }
+      
+      it "should log the request info" do
+        logger.should_receive(:info).with('[Braspag] #doe: http://foo/bar, data: {:foo=>:bar, :egg=>:span}')
+        subject.do_post(:doe, { :foo => :bar, :egg => :span })
+      end
+
+      it "should log the request info removing the credit card sensitive info" do
+        logger.should_receive(:info).with('[Braspag] #doe: http://foo/bar, data: {"cardNumber"=>"************", "securityCode"=>"***"}')
+        subject.do_post(:doe, { 'cardNumber' => '123', 'securityCode' => '456' })
+      end
+
+      it "should log response info" do
+        logger.should_receive(:info).with('[Braspag] #doe: http://foo/bar, data: {:foo=>:bar, :egg=>:span}')
+        subject.do_post(:doe, { :foo => :bar, :egg => :span })
+      end
+    end
+
+    context "with proxy" do
+      subject { described_class.new(connection_proxy, 'http://foo/bar') }
+      
+      it "should set the proxy if the proxy_address is set" do
+        request.should_receive(:proxy=).with('http://proxy.com')
+        subject.do_post(:foo, {})
+      end
+    end
+  end
+end

data/spec/crypto/webservice_spec.rb

@@ -0,0 +1,136 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Crypto::Webservice do
+
+  let(:merchant_id) { "merchant_id" }
+  let(:connection) do
+    conn = double(Braspag::Connection)
+    conn.stub(:merchant_id => merchant_id)
+    conn.stub(:url_for => 'fakeurl')
+    conn
+  end
+  
+  let(:poster) { mock }
+  
+  describe "encrypt" do
+    let(:key) {"XXXXX"}
+
+    it "should return error with invalid data after process" do
+      body_invalid = <<-EOXML
+SERVER was unable to process
+EOXML
+      poster.stub(:do_post => mock(:body => body_invalid))
+      Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+      expect {
+        Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+      }.to raise_error(RuntimeError, 'UnknownError')
+    end
+
+    it "should return error with invalid merchant_id" do
+      body_invalid = <<-EOXML
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<soap:Body><EncryptRequestResponse xmlns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+<EncryptRequestResult>Erro BP 011</EncryptRequestResult></EncryptRequestResponse>
+</soap:Body></soap:Envelope>
+EOXML
+      
+      poster.stub(:do_post => mock(:body => body_invalid))
+      Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+      expect {
+        Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+      }.to raise_error(RuntimeError, 'InvalidMerchantId')
+    end
+
+    it "should return error with invalid ip" do
+      body_invalid = <<-EOXML
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<soap:Body><EncryptRequestResponse xmlns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+<EncryptRequestResult>Erro BP 067</EncryptRequestResult></EncryptRequestResponse>
+</soap:Body></soap:Envelope>
+EOXML
+      poster.stub(:do_post => mock(:body => body_invalid))
+      Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+      expect {
+        Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+      }.to raise_error(RuntimeError, 'InvalidIP')
+      
+    end
+
+    it "should return a string" do
+        valid_body = <<-EOXML
+<?xml version='1.0' encoding='utf-8'?>
+<soap:Envelope xmlns:soap='http://www.w3.org/2003/05/soap-envelope' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
+<soap:Body>
+<EncryptRequestResponse xmlns='https://www.pagador.com.br/webservice/BraspagGeneralService'>
+<EncryptRequestResult>#{key}</EncryptRequestResult>
+</EncryptRequestResponse>
+</soap:Body></soap:Envelope>
+              EOXML
+        
+        poster.stub(:do_post => mock(:body => valid_body))
+        Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+        resp = Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+        resp.should eq(key)
+    end
+  end
+
+  describe "decrypt" do
+    let(:crypt_string) {"{sdfsdf34543534}"}
+    it "should return error with invalid data" do
+      body_invalid = <<-EOXML
+SERVER was unable to process
+EOXML
+      poster.stub(:do_post => mock(:body => body_invalid))
+      Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+      expect {
+        Braspag::Crypto::Webservice.new.decrypt(connection, crypt_string)
+      }.to raise_error(RuntimeError, 'UnknownError')
+      
+    end
+
+    it "should return error with invalid ip" do
+      body_invalid = <<-EOXML
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<soap:Body><DecryptRequestResponse xmlns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+<DecryptRequestResult><string>Erro BP 068</string></DecryptRequestResult>
+</DecryptRequestResponse></soap:Body></soap:Envelope>
+EOXML
+     poster.stub(:do_post => mock(:body => body_invalid))
+     Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+     expect {
+       Braspag::Crypto::Webservice.new.decrypt(connection, crypt_string)
+     }.to raise_error(RuntimeError, 'InvalidIP')
+    end
+
+    it "should return a string" do
+        valid_body = <<-EOXML
+<?xml version='1.0' encoding='utf-8'?><soap:Envelope xmlns:soap='http://www.w3.org/2003/05/soap-envelope' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
+<soap:Body><DecryptRequestResponse xmlns='https://www.pagador.com.br/webservice/BraspagGeneralService'>
+<DecryptRequestResult>
+<string>CODPAGAMENTO=18</string>
+<string>VENDAID=teste123</string>
+<string>VALOR=100</string>
+<string>PARCELAS=1</string>
+<string>NOME=comprador</string>
+</DecryptRequestResult></DecryptRequestResponse>
+</soap:Body></soap:Envelope>
+              EOXML
+
+        poster.stub(:do_post => mock(:body => valid_body))
+        Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+
+        resp = Braspag::Crypto::Webservice.new.decrypt(connection, crypt_string)
+        resp.should eq({:codpagamento=>"18", :vendaid=>"teste123", :valor=>"100", :parcelas=>"1", :nome=>"comprador"})
+    end
+  end
+end

data/spec/integration/billet_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Connection do
+  it "should generate a billet", :billet_integration => true do
+    gateway = Braspag::Connection.new(
+      :merchant_id => ENV['BRASPAG_MERCHANT_ID'],
+      :environment => :homologation
+    )
+    
+    billet = Braspag::Billet.new(
+      :instructions => 'does not accepted after due date', # (optional)
+      :due_date_on  => Date.today + 2
+    )
+    
+    customer = Braspag::Customer.new(
+      :document     => '21473696240', # (OPTIONAL)
+      :name   => 'Bob Dela Bobsen',
+      :email  => 'bob@mailinator.com' # send email to consumer (OPTIONAL)
+    )
+    
+    order = Braspag::Order.new(
+      :payment_method  => Braspag::PAYMENT_METHOD[:billet_santader],
+      :id              => 11,
+      :amount          => 10.00, # $10.00 (accepts all amounts as Integer values in cents)
+      :customer        => customer
+    )
+    
+    # Validating the card automatically detects the card type
+    if billet.valid?(:generate) && customer.valid?(:generate) && order.valid?(:generate)
+      response = gateway.generate_billet(order, billet)
+      response.success?.should eq(true)
+      puts "Successfully created billet, open in:#{billet.url}"
+    else
+      fail "Invalid Params"
+    end
+  end
+end

data/spec/payment/billet_spec.rb

@@ -0,0 +1,205 @@
+# 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)}
+
+  context ".generate_billet" do
+    it "should return response" do
+      generate_billet = {
+        :status  => "1",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(generate_billet)
+      
+      response = connection.generate_billet(mock, mock)
+      
+      response.success?.should eq(false)
+      response.message.should eq(generate_billet[:message])
+      response.authorization.should eq(generate_billet[:number])
+      response.params.should eq({"status"=>"1", "message"=>"BLA", "number"=>"12345"})
+      response.test.should eq(true)
+    end
+
+    it "should return success when status is zero" do
+      generate_billet = {
+        :status  => "0",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(generate_billet)
+      
+      response = connection.generate_billet(mock, mock)
+      
+      response.success?.should eq(true)
+    end
+  end
+end
+
+describe Braspag::Billet do
+  context "on generate" do
+    it "should allow blank for id" do
+      subject.id = ''
+      subject.valid?(:generate)
+      subject.errors.messages[:id].should be(nil)
+    end
+    
+    it "should validate maximum 255 length of id" do
+      subject.id = '*' * 260
+      subject.valid?(:generate)
+      subject.errors.messages[:id].should include("is too long (maximum is 255 characters)")
+    end
+    
+    it "should allow blank for instructions" do
+      subject.instructions = ''
+      subject.valid?(:generate)
+      subject.errors.messages[:instructions].should be(nil)
+    end
+    
+    it "should validate maximum 512 length of instructions" do
+      subject.instructions = '*' * 520
+      subject.valid?(:generate)
+      subject.errors.messages[:instructions].should include("is too long (maximum is 512 characters)")
+    end
+    
+    it "should not allow blank for due_date_on" do
+      subject.due_date_on = ''
+      subject.valid?(:generate)
+      subject.errors.messages[:due_date_on].should include("can't be blank")
+    end
+    
+    it "should not allow invalid date for due_date_on" do
+      subject.due_date_on = '12345'
+      subject.valid?(:generate)
+      subject.errors.messages[:due_date_on].should include("invalid date")
+    end
+    
+    it "should allow date for due_date_on" do
+      subject.due_date_on = Date.parse('07/03/1988')
+      subject.valid?(:generate)
+      subject.errors.messages[:due_date_on].should be(nil)
+    end
+  end
+  
+  context "on generate billet" do
+    let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+    let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+    
+    let(:customer) do
+      Braspag::Customer.new(
+        :document     => '21473696240', # (OPTIONAL)
+        :name   => 'Bob Dela Bobsen',
+        :email  => 'bob@mailinator.com' # send email to consumer (OPTIONAL)
+      )
+    end
+
+    let(:order) do
+      Braspag::Order.new(
+        :id                => "um order id",
+        :amount            => 100.00,
+        :payment_method    => Braspag::PAYMENT_METHOD[:billet_bradesco],
+        :customer          => customer
+      )
+    end
+
+    let(:billet) do
+      Braspag::Billet.new(
+        :id           => '123456',
+        :instructions => 'does not accepted after due date', 
+        :due_date_on  => Date.parse('2012-01-01')
+      )
+    end
+    
+    let(:url) { "https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=722934be-6756-477a-87ab-42115ee1424d" }
+    
+    let(:valid_xml) do
+      <<-EOXML
+      <?xml version="1.0" encoding="utf-8"?>
+      <PagadorBoletoReturn 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>3.00</amount>
+        <boletoNumber>123123</boletoNumber>
+        <expirationDate>2012-01-08T00:00:00</expirationDate>
+        <url>https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=722934be-6756-477a-87ab-42115ee1424d</url>
+        <returnCode>0</returnCode>
+        <status>0</status>
+      </PagadorBoletoReturn>
+      EOXML
+    end
+    
+    let(:invalid_xml) do
+      <<-EOXML
+      <?xml version="1.0" encoding="utf-8"?>
+      <PagadorBoletoReturn 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 xsi:nil="true" />
+        <expirationDate xsi:nil="true" />
+        <returnCode>1</returnCode>
+        <message>Invalid merchantId</message>
+        <status xsi:nil="true" />
+      </PagadorBoletoReturn>
+      EOXML
+    end
+
+    it "should convert objects to hash" do
+      Braspag::Billet.to_generate_billet(connection, order, billet).should eq({
+          "merchantId"       => connection.merchant_id,
+          "boletoNumber"     => billet.id.to_s,
+          "instructions"     => billet.instructions.to_s,
+          "expirationDate"   => billet.due_date_on.strftime("%d/%m/%y"),
+          "customerName"     => order.customer.name.to_s,
+          "customerIdNumber" => order.customer.document.to_s,
+          "emails"           => order.customer.email.to_s,
+          "orderId"          => order.id.to_s,
+          "amount"           => Braspag::Converter::decimal_to_string(order.amount),
+          "paymentMethod"    => order.payment_method
+      })
+    end
+    
+    
+    it "should convert response from xml" do
+      resp = Braspag::Billet.from_generate_billet(connection, order, billet, mock(:body => valid_xml))
+      
+      billet.url.should eq(url)
+      order.gateway_return_code.should eq('0')
+      order.gateway_status.should eq('0')
+      order.gateway_amount.should eq(3.00)
+      
+      resp.should eq({
+        :url             => url, 
+        :amount          => "3.00", 
+        :number          => "123123", 
+        :expiration_date => Date.parse('2012-01-08'), 
+        :return_code     => "0", 
+        :status          => "0", 
+        :message         => nil
+      })
+    end
+    
+    it "should convert response from xml with invalid date" do
+      resp = Braspag::Billet.from_generate_billet(connection, order, billet, mock(:body => invalid_xml))
+      
+      billet.url.should eq(nil)
+      order.gateway_return_code.should eq('1')
+      order.gateway_status.should eq(nil)
+      order.gateway_amount.should eq(nil)
+      
+      resp.should eq({
+        :url             => nil, 
+        :amount          => nil, 
+        :number          => nil, 
+        :expiration_date => nil,
+        :return_code     => "1", 
+        :status          => nil, 
+        :message         => "Invalid merchantId"
+      })
+    end
+  end
+end
+

data/spec/payment/credit_card_spec.rb

@@ -0,0 +1,385 @@
+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)}
+  
+  context ".purchase" do
+    it "should return authorize when authroize response failed" do
+      auth = mock(:success? => false)
+      connection.stub(:authorize).and_return(auth)
+      connection.purchase(mock, mock).should eq(auth)
+    end
+    
+    it "should return capture when authorize response success" do
+      cap = mock(:success? => true)
+      connection.stub(:authorize).and_return(mock(:success? => true))
+      connection.stub(:capture).and_return(cap)
+      connection.purchase(mock, mock).should eq(cap)
+    end
+  end
+  
+  context ".authorize" do
+    it "should return response" do
+      authorize = {
+        :status  => "2",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(authorize)
+      
+      response = connection.authorize(mock, mock)
+      
+      response.success?.should eq(false)
+      response.message.should eq(authorize[:message])
+      response.authorization.should eq(authorize[:number])
+      response.params.should eq({"status"=>"2", "message"=>"BLA", "number"=>"12345"})
+      response.test.should eq(true)
+    end
+
+    it "should return success when status is zero" do
+      authorize = {
+        :status  => "0",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(authorize)
+      
+      response = connection.authorize(mock, mock)
+      
+      response.success?.should eq(true)
+    end
+    
+    it "should return success when status is one" do
+      authorize = {
+        :status  => "1",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(authorize)
+      
+      response = connection.authorize(mock, mock)
+      
+      response.success?.should eq(true)
+    end
+  end
+  
+  context ".capture" do
+    it "should return response" do
+      capture = {
+        :status  => "1",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(capture)
+      
+      response = connection.capture(mock)
+      
+      response.success?.should eq(false)
+      response.message.should eq(capture[:message])
+      response.authorization.should eq(capture[:number])
+      response.params.should eq({"status"=>"1", "message"=>"BLA", "number"=>"12345"})
+      response.test.should eq(true)
+    end
+
+    it "should return success when status is zero" do
+      capture = {
+        :status  => "0",
+        :message => "BLA",
+        :number  => "12345"
+      }
+      
+      connection.should_receive(:post).and_return(capture)
+      
+      response = connection.capture(mock)
+      
+      response.success?.should eq(true)
+    end
+  end
+  
+  context ".void" do
+    it "should return response" do
+      void = {
+        :status  => "1",
+        :message => "BLA"
+      }
+      
+      connection.should_receive(:post).and_return(void)
+      
+      response = connection.void(mock)
+      
+      response.success?.should eq(false)
+      response.message.should eq(void[:message])
+      response.params.should eq({"status"=>"1", "message"=>"BLA"})
+      response.test.should eq(true)
+    end
+
+    it "should return success when status is zero" do
+      void = {
+        :status  => "0",
+        :message => "BLA"
+      }
+      
+      connection.should_receive(:post).and_return(void)
+      
+      response = connection.void(mock)
+      
+      response.success?.should eq(true)
+    end
+  end
+end
+
+describe Braspag::CreditCard do
+  
+  [:purchase, :authorize, :archive].each do |context_type|
+    context "on #{context_type}" do
+      it "should validate minimum 1 length of holder_name" do
+        subject.holder_name = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:holder_name].should include("is too short (minimum is 1 characters)")
+      end
+
+      it "should validate maximum 100 length of holder_name" do
+        subject.holder_name = '*' * 110
+        subject.valid?(context_type)
+        subject.errors.messages[:holder_name].should include("is too long (maximum is 100 characters)")
+      end
+
+      it "should not allow blank for number" do
+        subject.number = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:number].should include("can't be blank")
+      end
+
+      it "should not allow blank for month" do
+        subject.month = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:month].should include("can't be blank")
+      end
+
+      it "should not allow blank for year" do
+        subject.year = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:year].should include("can't be blank")
+      end
+      
+      it "should not allow invalid date for month & year" do
+        subject.month = "14"
+        subject.year = "2012"
+        subject.valid?(context_type)
+        subject.errors.messages[:month].should include("invalid date")
+        subject.errors.messages[:year].should include("invalid date")
+      end
+
+      it "should allow valid date for month & year" do
+        subject.month = "09"
+        subject.year = "12"
+        subject.valid?(context_type)
+        subject.errors.messages[:month].should be(nil)
+        subject.errors.messages[:year].should be(nil)
+      end
+
+      it "should allow valid date for month & year" do
+        subject.month = 12
+        subject.year = 2014
+        subject.valid?(context_type)
+        subject.errors.messages[:month].should be(nil)
+        subject.errors.messages[:year].should be(nil)
+      end
+    end
+  end
+  
+  [:purchase, :authorize, :recurrency].each do |context_type|
+    context "on #{context_type}" do
+      it "should validate minimum 1 length of verification_value" do
+        subject.verification_value = ''
+        subject.valid?(context_type)
+        subject.errors.messages[:verification_value].should include("is too short (minimum is 1 characters)")
+      end
+
+      it "should validate maximum 4 length of verification_value" do
+        subject.verification_value = '*' * 5
+        subject.valid?(context_type)
+        subject.errors.messages[:verification_value].should include("is too long (maximum is 4 characters)")
+      end
+    end
+  end
+  
+  [:get_recurrency, :recurrency].each do |context_type|
+    context "on #{context_type}" do
+      it "should validate length of id" do
+        subject.id = '*' * 37
+        subject.valid?(context_type)
+        subject.errors.messages[:id].should include("is the wrong length (should be 36 characters)")
+      end
+    end
+  end
+  
+  let(:customer) do
+    Braspag::Customer.new(:name => "W" * 21)
+  end
+
+  let(:order) do
+    Braspag::Order.new(
+      :id                => "um order id",
+      :amount            => 1000.00,
+      :payment_method    => Braspag::PAYMENT_METHOD[:redecard],
+      :installments      => 1,
+      :installments_type => Braspag::INTEREST[:no],
+      :customer          => customer
+    )
+  end
+
+  let(:credit_card) do
+    Braspag::CreditCard.new(
+      :holder_name        => "Joao Maria Souza",
+      :number             => "9" * 10,
+      :month              => "10",
+      :year               => "12",
+      :verification_value => "123"
+    )
+  end
+  
+  context "on authorize credit card" do
+    let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+    let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+
+    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>1.000,00</amount>
+        <message>Transaction Successful</message>
+        <authorisationNumber>733610</authorisationNumber>
+        <returnCode>0</returnCode>
+        <status>1</status>
+        <transactionId>01231234</transactionId>
+      </PagadorReturn>
+      EOXML
+    end
+
+    it "should convert objects to hash" do
+      Braspag::CreditCard.to_authorize(connection, order, credit_card).should eq({
+        "merchantId"     => "#{merchant_id}", 
+        "orderId"        => "#{order.id}", 
+        "customerName"   => "#{customer.name}", 
+        "amount"         => "1000,00", 
+        "paymentMethod"  => 20, 
+        "holder"         => "#{credit_card.holder_name}", 
+        "cardNumber"     => "#{credit_card.number}", 
+        "expiration"     => "10/12", 
+        "securityCode"   => "123", 
+        "numberPayments" => order.installments, 
+        "typePayment"    => order.installments_type
+      })
+    end
+    
+    it "should populate data" do
+      resp = Braspag::CreditCard.from_authorize(connection, order, credit_card, mock(:body => valid_xml))
+      
+      order.gateway_authorization.should eq('733610')
+      order.gateway_id.should eq('01231234')
+      order.gateway_return_code.should eq('0')
+      order.gateway_status.should eq('1')
+      order.gateway_message.should eq('Transaction Successful')
+      order.gateway_amount.should eq(1000.00)
+      
+      resp.should eq({
+        :amount=>"1.000,00", 
+        :number=>"733610",
+        :message=>"Transaction Successful",
+        :return_code=>"0",
+        :status=>"1",
+        :transaction_id=>"01231234"})
+    end
+  end
+  
+  context "on capture credit card" do
+    let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+    let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+    
+    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
+    
+    it "should convert objects to hash" do
+      Braspag::CreditCard.to_capture(connection, order).should eq({
+        "merchantId"     => "#{merchant_id}", 
+        "orderId"        => "#{order.id}"
+      })
+    end
+    
+    it "should populate data" do
+      resp = Braspag::CreditCard.from_capture(connection, order, mock(:body => valid_xml))
+      
+      order.gateway_capture_return_code.should eq('0')
+      order.gateway_capture_status.should eq('0')
+      order.gateway_capture_message.should eq('Approved')
+      order.gateway_capture_amount.should eq(2.00)
+
+      
+      resp.should eq({
+        :amount=>"2", 
+        :message=>"Approved", 
+        :return_code=>"0", 
+        :status=>"0", 
+        :transaction_id=>nil
+      })
+    end
+  end
+  
+  context "on void credit card" do
+    let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+    let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+    
+    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">
+       <orderId>1234</orderId>
+       <transactionId>0</transactionId>
+       <amount>100</amount>
+       <message>Approved</message>
+       <returnCode>0</returnCode>
+       <status>0</status>
+      </PagadorReturn>
+      EOXML
+    end
+    
+    it "should convert objects to hash" do
+      Braspag::CreditCard.to_void(connection, order).should eq({
+        "merchantId"     => "#{merchant_id}", 
+        "order"        => "#{order.id}"
+      })
+    end
+    
+    it "should populate data" do
+      resp = Braspag::CreditCard.from_void(connection, order, mock(:body => valid_xml))
+      
+      order.gateway_void_return_code.should eq('0')
+      order.gateway_void_status.should eq('0')
+      order.gateway_void_message.should eq('Approved')
+      order.gateway_void_amount.should eq(100.00)
+      
+      resp.should eq({:order_id=>"1234", :amount=>"100", :message=>"Approved", :return_code=>"0", :status=>"0", :transaction_id=>"0"})
+    end
+  end
+end