cbraspag 0.9.3 → 0.9.4

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

@@ -6,6 +6,89 @@ describe Braspag::Connection do
   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)
@@ -13,7 +96,7 @@ describe Braspag::Connection do
         :email  => 'bob@mailinator.com' # send email to consumer (OPTIONAL)
       )
     end
-    
+
     let(:order) do
       Braspag::Order.new(
         :id                => "um order id",
@@ -22,7 +105,7 @@ describe Braspag::Connection do
         :customer          => customer
       )
     end
-    
+
     let(:billet) do
       Braspag::Billet.new(
         :id           => '123456',
@@ -31,6 +114,8 @@ describe Braspag::Connection do
       )
     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"?>
@@ -62,94 +147,58 @@ describe Braspag::Connection do
       EOXML
     end
 
-
-    it "should call gateway with correct data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).with(:generate_billet, {
-            "merchantId"       => "#{merchant_id}", 
-            "orderId"          => "#{order.id}", 
-            "customerName"     => "#{customer.name}", 
-            "customerIdNumber" => "#{customer.document}",
-            "amount"           => "100,00", 
-            "paymentMethod"    => 6, 
-            "boletoNumber"     => "#{billet.id}", 
-            "expirationDate"   => "01/01/12", 
-            "instructions"     => "#{billet.instructions}", 
-            "emails"           => "#{customer.email}"
-          }
-        ).and_return(mock(:body => valid_xml))
-      connection.generate_billet(order, billet)
+    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 populate data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      connection.generate_billet(order, billet)
-
-      billet.url.should eq('https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=722934be-6756-477a-87ab-42115ee1424d')
+    
+    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 return response object" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      response = connection.generate_billet(order, billet)
+    it "should convert response from xml with invalid date" do
+      resp = Braspag::Billet.from_generate_billet(connection, order, billet, mock(:body => invalid_xml))
       
-      response.success?.should be(true)
-    end
-
-    it "should return error in response" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => invalid_xml))
-      response = connection.generate_billet(order, billet)
+      billet.url.should eq(nil)
+      order.gateway_return_code.should eq('1')
+      order.gateway_status.should eq(nil)
+      order.gateway_amount.should eq(nil)
       
-      response.success?.should be(false)
-      response.message.should eq('Invalid merchantId')
-      response.params.should eq({"url"=>nil, "amount"=>nil, "number"=>nil, "expiration_date"=>nil, "return_code"=>"1", "status"=>nil, "message"=>"Invalid merchantId"})
-    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)
+      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

@@ -4,518 +4,131 @@ describe Braspag::Connection do
   let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
   let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
   
-  context ".authorize" do
-    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"
-      )
+  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
     
-    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
+    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
-    
-    let(:invalid_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>100</amount>
-        <authorisationNumber>null</authorisationNumber>
-        <message>Payment Server detected an error</message>
-        <returnCode>7</returnCode>
-        <status>2</status>
-        <transactionId>0</transactionId>
-      </PagadorReturn>
-      EOXML
-    end
-
-
-    it "should call gateway with correct data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).with(:authorize, {
-            "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
-          }
-        ).and_return(mock(:body => valid_xml))
-      connection.authorize(order, credit_card)
-    end
-    
-    it "should populate data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      connection.authorize(order, credit_card)
+  end
+  
+  context ".authorize" do
+    it "should return response" do
+      authorize = {
+        :status  => "2",
+        :message => "BLA",
+        :number  => "12345"
+      }
       
-      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)
+      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 response object" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      response = connection.authorize(order, credit_card)
+    it "should return success when status is one" do
+      authorize = {
+        :status  => "1",
+        :message => "BLA",
+        :number  => "12345"
+      }
       
-      response.success?.should be(true)
-      response.message.should eq('Transaction Successful')
-    end
-
-    it "should return error in response" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => invalid_xml))
-      response = connection.authorize(order, credit_card)
+      connection.should_receive(:post).and_return(authorize)
+      
+      response = connection.authorize(mock, mock)
       
-      response.success?.should be(false)
-      response.message.should eq('Payment Server detected an error')
-      response.params.should eq({"amount"=>"100", "number"=>"null", "message"=>"Payment Server detected an error", "return_code"=>"7", "status"=>"2", "transaction_id"=>"0"})
+      response.success?.should eq(true)
     end
   end
   
   context ".capture" do
-    let(:order) do
-      Braspag::Order.new(
-        :id => "um order id"
-      )
-    end
-    
-    let(:valid_xml) do
-      <<-EOXML
-      <?xml version="1.0" encoding="utf-8"?>
-      <PagadorReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                     xmlns="https://www.pagador.com.br/webservice/pagador">
-        <amount>2</amount>
-        <message>Approved</message>
-        <returnCode>0</returnCode>
-        <status>0</status>
-      </PagadorReturn>
-      EOXML
-    end
-    
-    let(:invalid_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>100</amount>
-        <message>Payment Server detected an error</message>
-        <returnCode>7</returnCode>
-        <status>2</status>
-        <transactionId>0</transactionId>
-      </PagadorReturn>
-      EOXML
-    end
-
-
-    it "should call gateway with correct data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).with(:capture, {
-            "merchantId"     => "#{merchant_id}", 
-            "orderId"        => "#{order.id}"
-          }
-        ).and_return(mock(:body => valid_xml))
-      connection.capture(order)
-    end
-    
-    it "should populate data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      connection.capture(order)
+    it "should return response" do
+      capture = {
+        :status  => "1",
+        :message => "BLA",
+        :number  => "12345"
+      }
       
-      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)
-    end
-    
-    it "should return response object" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      response = connection.capture(order)
+      connection.should_receive(:post).and_return(capture)
       
-      response.success?.should be(true)
-      response.message.should eq('Approved')
-    end
-
-    it "should return error in response" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => invalid_xml))
-      response = connection.capture(order)
+      response = connection.capture(mock)
       
-      response.success?.should be(false)
-      response.message.should eq('Payment Server detected an error')
-      response.params.should eq({"amount"=>"100", "message"=>"Payment Server detected an error", "return_code"=>"7", "status"=>"2", "transaction_id"=>"0"})
+      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
-    let(:order) do
-      Braspag::Order.new(
-        :id => "um order id"
-      )
-    end
-    
-    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
-    
-    let(:invalid_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>
-        <amount>100</amount>
-        <message>Payment Server detected an error</message>
-        <returnCode>7</returnCode>
-        <status>2</status>
-        <transactionId>0</transactionId>
-      </PagadorReturn>
-      EOXML
-    end
-
-
-    it "should call gateway with correct data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).with(:void, {
-            "merchantId"     => "#{merchant_id}", 
-            "orderId"        => "#{order.id}"
-          }
-        ).and_return(mock(:body => valid_xml))
-      connection.void(order)
-    end
-    
-    it "should populate data" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      connection.void(order)
+    it "should return response" do
+      void = {
+        :status  => "1",
+        :message => "BLA"
+      }
       
-      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)
-    end
-    
-    it "should return response object" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
-      response = connection.void(order)
+      connection.should_receive(:post).and_return(void)
       
-      response.success?.should be(true)
-      response.message.should eq('Approved')
-    end
-
-    it "should return error in response" do
-      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => invalid_xml))
-      response = connection.void(order)
+      response = connection.void(mock)
       
-      response.success?.should be(false)
-      response.message.should eq('Payment Server detected an error')
-      response.params.should eq({"order_id"=>"1234", "amount"=>"100", "message"=>"Payment Server detected an error", "return_code"=>"7", "status"=>"2", "transaction_id"=>"0"})
-    end
-  end
-
-  pending ".save" do
-    let(:params) do
-      {
-        :customer_name => "W" * 21,
-        :holder =>  "Joao Maria Souza",
-        :card_number => "9" * 10,
-        :expiration => "10/12",
-        :order_id => "um order id",
-        :request_id => "00000000-0000-0000-0000-000000000044"
-      }
-    end
-
-    let(:params_with_merchant_id) do
-      params.merge!(:merchant_id => merchant_id)
-    end
-
-    let(:save_protected_card_url) { "http://braspag.com/bla" }
-
-    let(:savon_double) { double('Savon') }
-
-    before do
-      @connection.should_receive(:merchant_id)
-    end
-
-    context "with valid params" do
-      let(:valid_hash) do
-        {
-          :save_credit_card_response => {
-            :save_credit_card_result => {
-              :just_click_key => 'SAVE-PROTECTED-CARD-TOKEN',
-              :success => true
-            }
-          }
-        }
-      end
-
-      let(:response) do
-        double('Response', :to_hash => valid_hash)
-      end
-
-      before do
-        Braspag::ProtectedCreditCard.should_receive(:save_protected_card_url)
-        Braspag::ProtectedCreditCard.should_receive(:check_protected_card_params)
-                           .and_return(true)
-        Savon::Client.should_receive(:new).and_return(savon_double)
-        savon_double.should_receive(:request).and_return(response)
-
-        @response = Braspag::ProtectedCreditCard.save(params)
-      end
-
-      it "should return a Hash" do
-        @response.should be_kind_of Hash
-        @response.should == {
-          :just_click_key => "SAVE-PROTECTED-CARD-TOKEN",
-          :success => true
-        }
-      end
-    end
-
-    context "with invalid params" do
-      let(:invalid_hash) do
-        {
-          :save_credit_card_response => {
-            :save_credit_card_result => {
-              :just_click_key => nil,
-              :success => false
-            }
-          }
-        }
-      end
-
-      let(:response) do
-        double('Response', :to_hash => invalid_hash)
-      end
-
-      before do
-        Braspag::ProtectedCreditCard.should_receive(:check_protected_card_params)
-                            .and_return(true)
-        Braspag::ProtectedCreditCard.should_receive(:save_protected_card_url)
-                            .and_return(save_protected_card_url)
-        Savon::Client.should_receive(:new).and_return(savon_double)
-        savon_double.should_receive(:request).and_return(response)
-
-        @response = Braspag::ProtectedCreditCard.save(params)
-      end
-
-      it "should return a Hash" do
-        @response.should be_kind_of Hash
-        @response.should == {
-          :just_click_key => nil,
-          :success => false
-        }
-      end
-    end
-  end
-
-  pending ".get" do
-    let(:get_protected_card_url) { "http://braspag/bla" }
-
-    let(:invalid_xml) do
-      <<-EOXML
-      <CartaoProtegidoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                   xmlns="http://www.pagador.com.br/">
-        <CardHolder>Joao Maria Souza</CardHolder>
-        <CardNumber></CardNumber>
-        <CardExpiration>10/12</CardExpiration>
-        <MaskedCardNumber>******9999</MaskedCardNumber>
-      </CartaoProtegidoReturn>
-      EOXML
-    end
-
-    let(:valid_xml) do
-      <<-EOXML
-      <CartaoProtegidoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                   xmlns="http://www.pagador.com.br/">
-        <CardHolder>Joao Maria Souza</CardHolder>
-        <CardNumber>9999999999</CardNumber>
-        <CardExpiration>10/12</CardExpiration>
-        <MaskedCardNumber>******9999</MaskedCardNumber>
-      </CartaoProtegidoReturn>
-      EOXML
+      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 raise an error when just click key is not valid" do
-      Braspag::ProtectedCreditCard.should_receive(:valid_just_click_key?)
-                         .with("bla")
-                         .and_return(false)
-
-      expect {
-        Braspag::ProtectedCreditCard.get "bla"
-      }.to raise_error(Braspag::InvalidJustClickKey)
-    end
-
-    it "should raise an error when Braspag returned an invalid xml as response" do
-      FakeWeb.register_uri(:post, get_protected_card_url, :body => invalid_xml)
-
-      Braspag::ProtectedCreditCard.should_receive(:get_protected_card_url)
-                         .and_return(get_protected_card_url)
-
-      expect {
-        Braspag::ProtectedCreditCard.get("b0b0b0b0-bbbb-4d4d-bd27-f1f1f1ededed")
-      }.to raise_error(Braspag::UnknownError)
-    end
-
-    it "should return a Hash when Braspag returned a valid xml as response" do
-      FakeWeb.register_uri(:post, get_protected_card_url, :body => valid_xml)
-
-      Braspag::ProtectedCreditCard.should_receive(:get_protected_card_url)
-                         .and_return(get_protected_card_url)
-
-      response = Braspag::ProtectedCreditCard.get("b0b0b0b0-bbbb-4d4d-bd27-f1f1f1ededed")
-      response.should be_kind_of Hash
-
-      response.should == {
-        :holder => "Joao Maria Souza",
-        :expiration => "10/12",
-        :card_number => "9" * 10,
-        :masked_card_number => "*" * 6 + "9" * 4
+    it "should return success when status is zero" do
+      void = {
+        :status  => "0",
+        :message => "BLA"
       }
-    end
-
-  end
-
-  pending ".just_click_shop" do
-    context "body" do
-      let(:params) { {
-        :request_id => "123",
-        :customer_name => "Joao Silva",
-        :order_id => "999",
-        :amount => 10.50,
-        :payment_method => :redecard,
-        :number_installments => 3,
-        :payment_type => "test",
-        :just_click_key => "key",
-        :security_code => "123"
-      } }
-
-      class SavonClientTest
-        attr_accessor :response
-        attr_reader :method
-
-        def request(web, method, &block)
-          @method = method
-          instance_eval &block
-
-          @response
-        end
-
-        def soap
-          @soap ||= OpenStruct.new
-        end
-      end
-
-      before :each do
-        @savon_client_test = SavonClientTest.new
-        @savon_client_test.response = {:just_click_shop_response => {}}
-        Savon::Client.stub(:new).with('https://www.cartaoprotegido.com.br/Services/TestEnvironment/CartaoProtegido.asmx?wsdl').and_return(@savon_client_test)
-      end
-
-      after :each do
-        Savon::Client.unstub(:new)
-      end
-
-      it "should have RequestId" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['RequestId'].should eq '123'
-      end
-
-      it "should have MerchantKey" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['MerchantKey'].should eq 'um id qualquer'
-      end
-
-      it "should have CustomerName" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['CustomerName'].should eq 'Joao Silva'
-      end
-
-      it "should have OrderId" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['OrderId'].should eq '999'
-      end
-
-      it "should have Amount" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['Amount'].should eq 10.50
-      end
-
-      it "should have PaymentMethod" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['PaymentMethod'].should eq 20
-      end
-
-      it "should have PaymentType" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['PaymentType'].should eq 'test'
-      end
-
-      it "should have NumberInstallments" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['NumberInstallments'].should eq 3
-      end
-
-      it "should have JustClickKey" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['JustClickKey'].should eq 'key'
-      end
-
-      it "should have SecurityCode" do
-        described_class.just_click_shop(params)
-        @savon_client_test.soap.body['justClickShopRequestWS']['SecurityCode'].should eq '123'
-      end
+      
+      connection.should_receive(:post).and_return(void)
+      
+      response = connection.void(mock)
+      
+      response.success?.should eq(true)
     end
   end
 end
@@ -606,4 +219,167 @@ describe Braspag::CreditCard do
     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