rbraspag 0.0.11 → 0.0.12

data/spec/connection_spec.rb

@@ -2,53 +2,128 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Braspag::Connection do
-  let!(:connection) { Braspag::Connection }
   let!(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  let!(:braspag_url) { "https://homologacao.pagador.com.br" }
+  let!(:crypto_key) {"{84BE7E7F-698A-6C74-F820-AE359C2A07C2}"}
+  let!(:crypto_url) {"http://localhost:9292"}
 
-  it "deve gerar uma exceção quando :merchantId for maior que 38 caracteres" do
-    merchant_id = (1..100).collect{"A"}.join
-    expect { connection.new(merchant_id) }.should raise_error(Braspag::Connection::InvalidMerchantId)
+  let!(:mock_for_connection) {
+    mock = {}
+    mock[ENV["RACK_ENV"]] = {
+      "merchant_id" => merchant_id,
+      "braspag_url" => braspag_url,
+      "crypto_key" => crypto_key,
+      "crypto_url" => crypto_url
+    }
+    mock
+  }
+
+  before(:all) do
+    @connection = Braspag::Connection.clone
   end
 
-  it "deve gerar uma exceção quando :merchantId for menor que 38 caracteres" do
-    merchant_id = (1..37).collect{"B"}.join
-    expect { connection.new(merchant_id) }.should raise_error(Braspag::Connection::InvalidMerchantId)
+  it "should read config/braspag.yml when alloc first instance" do
+    YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_for_connection)
+    @connection.instance
   end
 
-  it "deve gerar uma exceção quando :merchantId não seguir o formato {00000000-0000-0000-0000-000000000000}" do
-    expect { connection.new("0000000-0000-0000-0000-000000000000") }.should raise_error(Braspag::Connection::InvalidMerchantId)
-    expect { connection.new("{000000000000000000000000000000000000}") }.should raise_error(Braspag::Connection::InvalidMerchantId)
+  it "should not read config/braspag.yml when alloc second instance" do
+    YAML.should_not_receive(:load_file)
+    @connection.instance
+  end
 
-    expect { connection.new(merchant_id) }.should_not raise_error
+  it "should generate exception when RACK_ENV is nil" do
+    backup = ENV["RACK_ENV"].clone
+    ENV["RACK_ENV"] = nil
+    expect {
+      other_connection = Braspag::Connection.clone
+      other_connection.instance
+    }.should raise_error(Braspag::Connection::InvalidEnv)
+    ENV["RACK_ENV"] = backup
   end
 
-  it "deve inicializar dado um ambiente e o id da loja" do
-    expect { connection.new(merchant_id, :test) }.should_not raise_error
+  it "should generate exception when RACK_ENV is empty" do
+    backup = ENV["RACK_ENV"].clone
+    ENV["RACK_ENV"] = ""
+    expect {
+      other_connection = Braspag::Connection.clone
+      other_connection.instance
+    }.should raise_error(Braspag::Connection::InvalidEnv)
+    ENV["RACK_ENV"] = backup
   end
 
-  it "deve inicializar dado um id da loja" do
-    expect { connection.new(merchant_id) }.should_not raise_error
+
+  it "should generate exception when :merchant_id is more than 38 chars" do
+    mock_merchant = mock_for_connection
+    mock_merchant[ENV["RACK_ENV"]]["merchant_id"] = (1..100).collect{"A"}.join
+    YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_merchant)
+    other_connection = Braspag::Connection.clone
+
+    expect { other_connection.instance }.should raise_error(Braspag::Connection::InvalidMerchantId)
   end
 
-  it "deve entender que o ambiente é produção quando nehum for especificado" do
-    connection.new(merchant_id).environment.should eql(Braspag::Production)
+  it "should generate exception when :merchant_id is less than 38 chars" do
+    mock_merchant = mock_for_connection
+    mock_merchant[ENV["RACK_ENV"]]["merchant_id"] = (1..37).collect{"B"}.join
+    YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_merchant)
+    other_connection = Braspag::Connection.clone
+
+    expect { other_connection.instance }.should raise_error(Braspag::Connection::InvalidMerchantId)
   end
 
-   it "deve entender que o ambiente é teste quando for especificado staging" do
-    connection.new(merchant_id, 'staging').environment.should eql(Braspag::Test)
+  context "should generate exception when :merchant_id not follow format {00000000-0000-0000-0000-000000000000}" do
+    it "0000000-0000-0000-0000-000000000000" do
+     mock_merchant = mock_for_connection
+     mock_merchant[ENV["RACK_ENV"]]["merchant_id"] = "0000000-0000-0000-0000-000000000000"
+     YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_merchant)
+     other_connection = Braspag::Connection.clone
+     expect { other_connection.instance }.should raise_error(Braspag::Connection::InvalidMerchantId)
+    end
+
+    it "{000000000000000000000000000000000000}" do
+     mock_merchant = mock_for_connection
+     mock_merchant[ENV["RACK_ENV"]]["merchant_id"] = "{000000000000000000000000000000000000}"
+     YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_merchant)
+     other_connection = Braspag::Connection.clone
+     expect { other_connection.instance }.should raise_error(Braspag::Connection::InvalidMerchantId)
+    end
   end
 
-  it "deve reconhecer a url do ambiente de teste" do
-    connection.new(merchant_id, :test).base_url.should eql(Braspag::Test::BASE_URL)
+  it "should :merchant_id has correct in instance" do
+    new_connection = @connection.instance
+    new_connection.merchant_id.should == merchant_id
   end
 
-  it "deve reconhecer a url do ambiente de produção" do
-    connection.new(merchant_id, :production).base_url.should eql(Braspag::Production::BASE_URL)
+  it "should generate exception when :braspag_url is nil" do
+    mock_merchant = mock_for_connection
+    mock_merchant[ENV["RACK_ENV"]]["braspag_url"] = nil
+    YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_merchant)
+    other_connection = Braspag::Connection.clone
+
+    expect { other_connection.instance }.should raise_error(Braspag::Connection::InvalidBraspagUrl)
   end
 
-  it "deve devolver o merchant id utilizado na conexão" do
-    connection.new(merchant_id).merchant_id.should eql(merchant_id)
+  it "should generate exception when :braspag_url is empty" do
+    mock_merchant = mock_for_connection
+    mock_merchant[ENV["RACK_ENV"]]["braspag_url"] = ""
+    YAML.should_receive(:load_file).with("config/braspag.yml").and_return(mock_merchant)
+    other_connection = Braspag::Connection.clone
+
+    expect { other_connection.instance }.should raise_error(Braspag::Connection::InvalidBraspagUrl)
+  end
+
+  it "should :braspag_url has correct in instance" do
+    new_connection = @connection.instance
+    new_connection.braspag_url.should == braspag_url
   end
-  
 
+  it "should :crypto_url has correct in instance" do
+    new_connection = @connection.instance
+    new_connection.crypto_url.should == crypto_url
+  end
+
+  it "should :crypto_key has correct in instance" do
+    new_connection = @connection.instance
+    new_connection.crypto_key.should == crypto_key
+  end
 end

data/spec/credit_card_spec.rb

@@ -2,25 +2,12 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Braspag::CreditCard do
-
-  let!(:merchant_id) { "{84BE7E7F-698A-6C74-F820-AE359C2A07C2}" }
-  let!(:connection) { Braspag::Connection.new(merchant_id, :test) }
-
-  describe ".new" do
-
-    it "should raise an error when no connection is given" do
-      expect {
-        Braspag::CreditCard.new(Object.new)
-      }.to raise_error(Braspag::InvalidConnection)
-    end
-
-  end
+  let!(:braspag_url) { "https://homologacao.pagador.com.br" }
 
   describe ".authorize" do
-
     it "should raise an error when :order_id is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :customer_name => "W" * 21,
          :amount => "100.00",
          :payment_method => :redecard,
@@ -36,7 +23,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :customer_name is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :amount => "100.00",
          :payment_method => :redecard,
@@ -52,7 +39,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :amount is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "",
          :payment_method => :redecard,
@@ -68,7 +55,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :payment_method is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "",
          :amount => "100.00",
@@ -84,7 +71,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :holder is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "",
          :payment_method => :redecard,
@@ -100,7 +87,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :card_number is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "",
          :payment_method => :redecard,
@@ -116,7 +103,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :expiration is not present" do
       expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "",
          :payment_method => :redecard,
@@ -132,7 +119,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :security_code is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "AAAAAAAA",
          :payment_method => :redecard,
@@ -148,7 +135,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :number_payments is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "AAAAAAAA",
          :payment_method => :redecard,
@@ -163,7 +150,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :type is not present" do
      expect {
-       Braspag::CreditCard.new(connection).authorize({
+       Braspag::CreditCard.authorize({
          :order_id => "1" * 5,
          :customer_name => "AAAAAAAA",
          :payment_method => :redecard,
@@ -195,7 +182,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:order_id] = "A" * 21
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidOrderId)
     end
 
@@ -203,7 +190,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:customer_name] = "B" * 101
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidCustomerName)
     end
 
@@ -211,7 +198,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:amount] = "1234567890,00"
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidAmount)
     end
 
@@ -219,7 +206,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:holder] = "E" * 101
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidHolder)
     end
 
@@ -227,7 +214,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:expiration] = "7" * 8
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidExpirationDate)
     end
 
@@ -235,7 +222,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:security_code] = "9" * 5
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidSecurityCode)
     end
 
@@ -243,7 +230,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:number_payments] = "123"
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidNumberPayments)
     end
 
@@ -251,7 +238,7 @@ describe Braspag::CreditCard do
       expect {
         params = valid_params
         params[:type] = "123"
-        Braspag::CreditCard.new(connection).authorize(params)
+        Braspag::CreditCard.authorize(params)
       }.to raise_error(Braspag::InvalidType)
     end
 
@@ -287,9 +274,9 @@ describe Braspag::CreditCard do
           </PagadorReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
+        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
 
-        result = Braspag::CreditCard.new(connection).authorize(params)
+        result = Braspag::CreditCard.authorize(params)
         result[:status].should == "1"
 
         FakeWeb.clean_registry
@@ -315,9 +302,9 @@ describe Braspag::CreditCard do
           </PagadorReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
+        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
 
-        result = Braspag::CreditCard.new(connection).authorize(invalid_params)
+        result = Braspag::CreditCard.authorize(invalid_params)
         result[:status].should == "2"
 
         FakeWeb.clean_registry
@@ -344,9 +331,9 @@ describe Braspag::CreditCard do
           </PagadorReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
+        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
 
-        result = Braspag::CreditCard.new(connection).authorize(invalid_params)
+        result = Braspag::CreditCard.authorize(invalid_params)
         result[:status].should == "null"
 
         FakeWeb.clean_registry
@@ -360,7 +347,7 @@ describe Braspag::CreditCard do
 
     it "should raise an error when :order_id is more than 20 characters" do
       expect {
-        Braspag::CreditCard.new(connection).capture(("A" * 21))
+        Braspag::CreditCard.capture(("A" * 21))
       }.to raise_error(Braspag::InvalidOrderId)
     end
 
@@ -377,9 +364,9 @@ describe Braspag::CreditCard do
         </PagadorReturn>
       EOXML
 
-      FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+      FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
 
-      result = Braspag::CreditCard.new(connection).capture('123456')
+      result = Braspag::CreditCard.capture('123456')
 
       result[:amount].should_not be_nil
       result[:message].should_not be_nil
@@ -404,9 +391,9 @@ describe Braspag::CreditCard do
           </PagadorReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
 
-        result = Braspag::CreditCard.new(connection).capture('123456')
+        result = Braspag::CreditCard.capture('123456')
         result[:status].should == "0"
 
         FakeWeb.clean_registry
@@ -429,9 +416,9 @@ describe Braspag::CreditCard do
         </PagadorReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
 
-        result = Braspag::CreditCard.new(connection).capture("1")
+        result = Braspag::CreditCard.capture("1")
         result[:status].should == "2"
 
         FakeWeb.clean_registry
@@ -454,9 +441,9 @@ describe Braspag::CreditCard do
           </PagadorReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{Braspag::Test::BASE_URL}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
 
-        result = Braspag::CreditCard.new(connection).capture("1234")
+        result = Braspag::CreditCard.capture("1234")
         result[:status].should == "null"
 
         FakeWeb.clean_registry
@@ -471,7 +458,89 @@ describe Braspag::CreditCard do
       end
     end
 
+
+  describe "#status" do
+    it "should raise an error when no order_id is given" do
+      expect {
+        Braspag::CreditCard.info(nil)
+      }.to raise_error(Braspag::InvalidOrderId)
+    end
+
+    it "should raise an error when order_id is empty" do
+      expect {
+        Braspag::CreditCard.info("")
+      }.to raise_error(Braspag::InvalidOrderId)
+    end
+
+    it "should raise an error when order_id is more than 50 characters" do
+      expect {
+        Braspag::CreditCard.info("1" * 51)
+      }.to raise_error(Braspag::InvalidOrderId)
+    end
+
+    it "should raise an error for incorrect data" do
+      xml = <<-EOXML
+<?xml version="1.0" encoding="utf-8"?>
+<DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+           xsi:nil="true"
+           xmlns="http://www.pagador.com.br/" />
+      EOXML
+
+      FakeWeb.register_uri(:post, "#{braspag_url}/pagador/webservice/pedido.asmx/GetDadosCartao",
+        :body => xml)
+
+      expect {
+        Braspag::CreditCard.info("sadpoakjspodqdouq09wduwq")
+      }.to raise_error(Braspag::UnknownError)
+
+
+      expect {
+        Braspag::CreditCard.info("asdnasdniousa")
+      }.to raise_error(Braspag::UnknownError)
+
+      FakeWeb.clean_registry
+    end
+
+    context "with correct data" do
+
+      let(:order_info) {
+        xml = <<-EOXML
+<DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.pagador.com.br/">
+  <NumeroComprovante>225296</NumeroComprovante>
+  <Autenticada>false</Autenticada>
+  <NumeroAutorizacao>557593</NumeroAutorizacao>
+  <NumeroCartao>345678*****0007</NumeroCartao>
+  <NumeroTransacao>101001225645</NumeroTransacao>
+</DadosCartao>
+        EOXML
+
+        FakeWeb.register_uri(:post, "#{braspag_url}/pagador/webservice/pedido.asmx/GetDadosCartao",
+          :body => xml)
+        order_info = Braspag::CreditCard.info("12345")
+        FakeWeb.clean_registry
+        order_info
+      }
+
+      it "should return a Hash" do
+        order_info.should be_kind_of Hash
+      end
+
+      {
+        :checking_number => "225296",
+        :certified => "false",
+        :autorization_number => "557593",
+        :card_number => "345678*****0007",
+        :transaction_number => "101001225645"
+      }.each do |key, value|
+
+        it "should return a Hash with :#{key.to_s} key" do
+          order_info[key].should == value
+        end
+      end
+    end
   end
 
-end
 
+  end
+end

data/spec/crypto/jar_webservice_spec.rb

@@ -2,10 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Braspag::Crypto::JarWebservice do
-  let!(:crypto_key) {"{84BE7E7F-698A-6C74-F820-AE359C2A07C2}"}
-  let!(:uri) {"http://localhost:9292"}
-  let!(:crypt) {Braspag::Crypto::JarWebservice.new(crypto_key, uri)}
-  let!(:crypt_invalid) {Braspag::Crypto::JarWebservice.new("00000", uri)}
+  let!(:crypt) {Braspag::Crypto::JarWebservice}
   let! (:key) {"5u0ZN5qk8eQNuuGPHrcsk0rfi7YclF6s+ZXCE+G4uG4ztfRJrrOALlf81ra7k7p7"}
 
   after (:each) do
@@ -90,7 +87,7 @@ INVALIDO
         )
 
         expect {
-          crypt_invalid.encrypt(:venda => "value")
+          crypt.encrypt(:venda => "value")
         }.to raise_error(Braspag::InvalidCryptKey)
       end
       
@@ -182,7 +179,7 @@ INVALIDO
         )
         
         expect {
-          crypt_invalid.decrypt(key, [:nome, :sobrenome])
+          crypt.decrypt(key, [:nome, :sobrenome])
         }.to raise_error(Braspag::InvalidCryptKey)
       end
       

data/spec/crypto/webservice_spec.rb

@@ -2,11 +2,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Braspag::Crypto::Webservice do
-  let!(:merchant_id) {"{84BE7E7F-698A-6C74-F820-AE359C2A07C2}"}
-  let!(:connection) {Braspag::Connection.new(merchant_id, :test)}
-  let!(:connection_invalid) {Braspag::Connection.new("{83BE7E7F-698A-6C74-F820-AE359C2A07A1}", :test)}
-  let!(:crypt) {Braspag::Crypto::Webservice.new(connection)}
-  let!(:crypt_invalid) {Braspag::Crypto::Webservice.new(connection_invalid)}
   
     context "encrypt" do
       let!(:key) {"XXXXX"}
@@ -14,7 +9,7 @@ describe Braspag::Crypto::Webservice do
       context "consistencies" do
         it "should return error with invalid data" do
           expect {
-            crypt.encrypt("INVALID DATA")
+            Braspag::Crypto::Webservice.encrypt("INVALID DATA")
           }.to raise_error(Braspag::IncompleteParams)
         end
 
@@ -26,7 +21,7 @@ EOXML
           "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx", 
           :body => body_invalid )
           expect {
-            crypt.encrypt(:key => "INVALID DATA")
+            Braspag::Crypto::Webservice.encrypt(:key => "INVALID DATA")
           }.to raise_error(Braspag::UnknownError)
           FakeWeb.clean_registry
         end
@@ -43,7 +38,7 @@ EOXML
           "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx", 
           :body => body_invalid )
           expect {
-            crypt.encrypt(:key => "value")
+            Braspag::Crypto::Webservice.encrypt(:key => "value")
           }.to raise_error(Braspag::InvalidMerchantId)
           FakeWeb.clean_registry
         end
@@ -60,7 +55,7 @@ EOXML
           "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx", 
           :body => body_invalid )
           expect {
-            crypt.encrypt(:key => "value")
+            Braspag::Crypto::Webservice.encrypt(:key => "value")
           }.to raise_error(Braspag::InvalidIP)
           FakeWeb.clean_registry
         end
@@ -79,7 +74,7 @@ EOXML
 </soap:Body></soap:Envelope>
                 EOXML
           )
-          crypt.encrypt(:key => "value").should == key
+          Braspag::Crypto::Webservice.encrypt(:key => "value").should == key
           FakeWeb.clean_registry
       end
     end
@@ -89,7 +84,7 @@ EOXML
       context "consistencies" do
         it "should return error with invalid data" do
           expect {
-            crypt.decrypt(1213123)
+            Braspag::Crypto::Webservice.decrypt(1213123)
           }.to raise_error(Braspag::IncompleteParams)
         end
         
@@ -101,28 +96,11 @@ EOXML
           "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx", 
           :body => body_invalid )
           expect {
-            crypt.decrypt("{sdfsdf34543534}")
+            Braspag::Crypto::Webservice.decrypt("{sdfsdf34543534}")
           }.to raise_error(Braspag::UnknownError)
           FakeWeb.clean_registry
         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><DecryptRequestResponse xmlns="https://www.pagador.com.br/webservice/BraspagGeneralService">
-<DecryptRequestResult><string>Erro BP 011</string></DecryptRequestResult>
-</DecryptRequestResponse></soap:Body></soap:Envelope>
-EOXML
-          FakeWeb.register_uri(:post, 
-          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx", 
-          :body => body_invalid )
-          expect {
-            crypt_invalid.decrypt("{sdfsdf34543534}")
-          }.to raise_error(Braspag::InvalidMerchantId)
-          FakeWeb.clean_registry
-        end
-        
         it "should return error with invalid ip" do
           body_invalid = <<-EOXML
 <?xml version="1.0" encoding="utf-8"?>
@@ -135,7 +113,7 @@ EOXML
          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx", 
          :body => body_invalid )
          expect {
-            crypt.decrypt("{sdfsdf34543534}")
+            Braspag::Crypto::Webservice.decrypt("{sdfsdf34543534}")
           }.to raise_error(Braspag::InvalidIP)
           FakeWeb.clean_registry
         end
@@ -157,7 +135,7 @@ EOXML
 </soap:Body></soap:Envelope>
                 EOXML
           )
-          crypt.decrypt("{sdfsdf34543534}")[:parcelas].should eql("1")
+          Braspag::Crypto::Webservice.decrypt("{sdfsdf34543534}")[:parcelas].should eql("1")
           FakeWeb.clean_registry
       end