braspag-pagador 0.9.4 → 0.9.5

data/spec/crypto/webservice_spec.rb

@@ -1,18 +1,18 @@
 #encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Braspag::Crypto::Webservice do
+describe BraspagPagador::Crypto::Webservice do
 
   let(:merchant_id) { "merchant_id" }
   let(:connection) do
-    conn = double(Braspag::Connection)
+    conn = double(BraspagPagador::Connection)
     conn.stub(:merchant_id => merchant_id)
     conn.stub(:url_for => 'fakeurl')
     conn
   end
-  
+
   let(:poster) { mock }
-  
+
   describe "encrypt" do
     let(:key) {"XXXXX"}
 
@@ -21,10 +21,10 @@ describe Braspag::Crypto::Webservice do
 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)
+      BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
       expect {
-        Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+        BraspagPagador::Crypto::Webservice.new.encrypt(connection, {key: key})
       }.to raise_error(RuntimeError, 'UnknownError')
     end
 
@@ -36,12 +36,12 @@ EOXML
 <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)
+      BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
       expect {
-        Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+        BraspagPagador::Crypto::Webservice.new.encrypt(connection, {key: key})
       }.to raise_error(RuntimeError, 'InvalidMerchantId')
     end
 
@@ -54,12 +54,12 @@ EOXML
 </soap:Body></soap:Envelope>
 EOXML
       poster.stub(:do_post => mock(:body => body_invalid))
-      Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+      BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
       expect {
-        Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+        BraspagPagador::Crypto::Webservice.new.encrypt(connection, {key: key})
       }.to raise_error(RuntimeError, 'InvalidIP')
-      
+
     end
 
     it "should return a string" do
@@ -72,11 +72,11 @@ EOXML
 </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)
+        BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
-        resp = Braspag::Crypto::Webservice.new.encrypt(connection, {key: key})
+        resp = BraspagPagador::Crypto::Webservice.new.encrypt(connection, {key: key})
         resp.should eq(key)
     end
   end
@@ -88,12 +88,12 @@ 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)
+      BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
       expect {
-        Braspag::Crypto::Webservice.new.decrypt(connection, crypt_string)
+        BraspagPagador::Crypto::Webservice.new.decrypt(connection, crypt_string)
       }.to raise_error(RuntimeError, 'UnknownError')
-      
+
     end
 
     it "should return error with invalid ip" do
@@ -105,10 +105,10 @@ EOXML
 </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)
+     BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
      expect {
-       Braspag::Crypto::Webservice.new.decrypt(connection, crypt_string)
+       BraspagPagador::Crypto::Webservice.new.decrypt(connection, crypt_string)
      }.to raise_error(RuntimeError, 'InvalidIP')
     end
 
@@ -127,10 +127,10 @@ EOXML
               EOXML
 
         poster.stub(:do_post => mock(:body => valid_body))
-        Braspag::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
+        BraspagPagador::Poster.should_receive(:new).with(connection, 'fakeurl').and_return(poster)
 
-        resp = Braspag::Crypto::Webservice.new.decrypt(connection, crypt_string)
+        resp = BraspagPagador::Crypto::Webservice.new.decrypt(connection, crypt_string)
         resp.should eq({:codpagamento=>"18", :vendaid=>"teste123", :valor=>"100", :parcelas=>"1", :nome=>"comprador"})
     end
   end
-end
+end

data/spec/integration/billet_spec.rb

@@ -1,31 +1,31 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Braspag::Connection do
+describe BraspagPagador::Connection do
   it "should generate a billet", :billet_integration => true do
-    gateway = Braspag::Connection.new(
+    gateway = BraspagPagador::Connection.new(
       :merchant_id => ENV['BRASPAG_MERCHANT_ID'],
       :environment => :homologation
     )
-    
-    billet = Braspag::Billet.new(
+
+    billet = BraspagPagador::Billet.new(
       :instructions => 'does not accepted after due date', # (optional)
       :due_date_on  => Date.today + 2
     )
-    
-    customer = Braspag::Customer.new(
+
+    customer = BraspagPagador::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],
+
+    order = BraspagPagador::Order.new(
+      :payment_method  => BraspagPagador::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)
@@ -35,4 +35,4 @@ describe Braspag::Connection do
       fail "Invalid Params"
     end
   end
-end
+end

data/spec/payment/billet_spec.rb

@@ -1,9 +1,9 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Braspag::Connection do
+describe BraspagPagador::Connection do
   let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
-  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+  let(:connection) { BraspagPagador::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
 
   context ".generate_billet" do
     it "should return response" do
@@ -12,11 +12,11 @@ describe Braspag::Connection do
         :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])
@@ -30,67 +30,67 @@ describe Braspag::Connection do
         :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
+describe BraspagPagador::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(:connection) { BraspagPagador::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+
     let(:customer) do
-      Braspag::Customer.new(
+      BraspagPagador::Customer.new(
         :document     => '21473696240', # (OPTIONAL)
         :name   => 'Bob Dela Bobsen',
         :email  => 'bob@mailinator.com' # send email to consumer (OPTIONAL)
@@ -98,24 +98,24 @@ describe Braspag::Billet do
     end
 
     let(:order) do
-      Braspag::Order.new(
+      BraspagPagador::Order.new(
         :id                => "um order id",
         :amount            => 100.00,
-        :payment_method    => Braspag::PAYMENT_METHOD[:billet_bradesco],
+        :payment_method    => BraspagPagador::PAYMENT_METHOD[:billet_bradesco],
         :customer          => customer
       )
     end
 
     let(:billet) do
-      Braspag::Billet.new(
+      BraspagPagador::Billet.new(
         :id           => '123456',
-        :instructions => 'does not accepted after due date', 
+        :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"?>
@@ -131,7 +131,7 @@ describe Braspag::Billet do
       </PagadorBoletoReturn>
       EOXML
     end
-    
+
     let(:invalid_xml) do
       <<-EOXML
       <?xml version="1.0" encoding="utf-8"?>
@@ -148,7 +148,7 @@ describe Braspag::Billet do
     end
 
     it "should convert objects to hash" do
-      Braspag::Billet.to_generate_billet(connection, order, billet).should eq({
+      BraspagPagador::Billet.to_generate_billet(connection, order, billet).should eq({
           "merchantId"       => connection.merchant_id,
           "boletoNumber"     => billet.id.to_s,
           "instructions"     => billet.instructions.to_s,
@@ -157,46 +157,46 @@ describe Braspag::Billet do
           "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),
+          "amount"           => BraspagPagador::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))
-      
+      resp = BraspagPagador::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", 
+        :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))
-      
+      resp = BraspagPagador::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, 
+        :url             => nil,
+        :amount          => nil,
+        :number          => nil,
         :expiration_date => nil,
-        :return_code     => "1", 
-        :status          => nil, 
+        :return_code     => "1",
+        :status          => nil,
         :message         => "Invalid merchantId"
       })
     end

data/spec/payment/credit_card_spec.rb

@@ -1,16 +1,16 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Braspag::Connection do
+describe BraspagPagador::Connection do
   let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
-  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
-  
+  let(:connection) { BraspagPagador::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))
@@ -18,7 +18,7 @@ describe Braspag::Connection do
       connection.purchase(mock, mock).should eq(cap)
     end
   end
-  
+
   context ".authorize" do
     it "should return response" do
       authorize = {
@@ -26,11 +26,11 @@ describe Braspag::Connection do
         :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])
@@ -44,29 +44,29 @@ describe Braspag::Connection do
         :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 = {
@@ -74,11 +74,11 @@ describe Braspag::Connection do
         :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])
@@ -92,26 +92,26 @@ describe Braspag::Connection do
         :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"})
@@ -123,18 +123,18 @@ describe Braspag::Connection do
         :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
-  
+describe BraspagPagador::CreditCard do
+
   [:purchase, :authorize, :archive].each do |context_type|
     context "on #{context_type}" do
       it "should validate minimum 1 length of holder_name" do
@@ -166,7 +166,7 @@ describe Braspag::CreditCard do
         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"
@@ -192,7 +192,7 @@ describe Braspag::CreditCard do
       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
@@ -208,7 +208,7 @@ describe Braspag::CreditCard do
       end
     end
   end
-  
+
   [:get_recurrency, :recurrency].each do |context_type|
     context "on #{context_type}" do
       it "should validate length of id" do
@@ -218,24 +218,24 @@ describe Braspag::CreditCard do
       end
     end
   end
-  
+
   let(:customer) do
-    Braspag::Customer.new(:name => "W" * 21)
+    BraspagPagador::Customer.new(:name => "W" * 21)
   end
 
   let(:order) do
-    Braspag::Order.new(
+    BraspagPagador::Order.new(
       :id                => "um order id",
       :amount            => 1000.00,
-      :payment_method    => Braspag::PAYMENT_METHOD[:redecard],
+      :payment_method    => BraspagPagador::PAYMENT_METHOD[:redecard],
       :installments      => 1,
-      :installments_type => Braspag::INTEREST[:no],
+      :installments_type => BraspagPagador::INTEREST[:no],
       :customer          => customer
     )
   end
 
   let(:credit_card) do
-    Braspag::CreditCard.new(
+    BraspagPagador::CreditCard.new(
       :holder_name        => "Joao Maria Souza",
       :number             => "9" * 10,
       :month              => "10",
@@ -243,10 +243,10 @@ describe Braspag::CreditCard do
       :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(:connection) { BraspagPagador::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
 
     let(:valid_xml) do
       <<-EOXML
@@ -265,33 +265,33 @@ describe Braspag::CreditCard do
     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, 
+      BraspagPagador::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))
-      
+      resp = BraspagPagador::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", 
+        :amount=>"1.000,00",
         :number=>"733610",
         :message=>"Transaction Successful",
         :return_code=>"0",
@@ -299,11 +299,11 @@ describe Braspag::CreditCard do
         :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(:connection) { BraspagPagador::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+
     let(:valid_xml) do
           <<-EOXML
       <?xml version="1.0" encoding="utf-8"?>
@@ -317,37 +317,37 @@ describe Braspag::CreditCard do
       </PagadorReturn>
       EOXML
     end
-    
+
     it "should convert objects to hash" do
-      Braspag::CreditCard.to_capture(connection, order).should eq({
-        "merchantId"     => "#{merchant_id}", 
+      BraspagPagador::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))
-      
+      resp = BraspagPagador::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", 
+        :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(:connection) { BraspagPagador::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+
     let(:valid_xml) do
       <<-EOXML
       <?xml version="1.0" encoding="utf-8"?>
@@ -363,22 +363,22 @@ describe Braspag::CreditCard do
       </PagadorReturn>
       EOXML
     end
-    
+
     it "should convert objects to hash" do
-      Braspag::CreditCard.to_void(connection, order).should eq({
-        "merchantId"     => "#{merchant_id}", 
+      BraspagPagador::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))
-      
+      resp = BraspagPagador::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