rbraspag 0.0.19 → 0.1.0

data/spec/connection_spec.rb

@@ -11,9 +11,6 @@ describe Braspag::Connection do
   let(:braspag_homologation_url) { "https://homologacao.pagador.com.br" }
   let(:braspag_production_url) { "https://transaction.pagador.com.br" }
 
-  let(:braspag_homologation_query_url) { "https://homologacao.pagador.com.br/pagador/webservice/pedido.asmx" }
-  let(:braspag_production_query_url) { "https://query.pagador.com.br/webservices/pagador/pedido.asmx" }
-
   let(:braspag_config) do
     config = {}
     config[ENV["RACK_ENV"]] = {
@@ -135,7 +132,6 @@ describe Braspag::Connection do
 
         connection = Braspag::Connection.clone.instance
         connection.braspag_url.should == braspag_homologation_url
-        connection.braspag_query_url.should == braspag_homologation_query_url
       end
     end
 
@@ -148,7 +144,6 @@ describe Braspag::Connection do
 
         connection = Braspag::Connection.clone.instance
         connection.braspag_url.should == braspag_production_url
-        connection.braspag_query_url.should == braspag_production_query_url
       end
     end
   end

data/spec/credit_card_spec.rb

@@ -1,386 +1,108 @@
-#encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Braspag::CreditCard do
-  let!(:braspag_url) { "https://homologacao.pagador.com.br" }
-  let!(:braspag_query_url) { "https://homologacao.pagador.com.br/pagador/webservice/pedido.asmx" }
+  let(:braspag_homologation_url) { "https://homologacao.pagador.com.br" }
+  let(:braspag_production_url) { "https://transaction.pagador.com.br" }
+  let(:merchant_id) { "um id qualquer" }
 
-  describe ".authorize" do
-    it "should raise an error when :order_id is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :customer_name => "W" * 21,
-         :amount => "100.00",
-         :payment_method => :redecard,
-         :holder => "Joao Maria Souza",
-         :card_number => "9" * 10,
-         :expiration => "10/12",
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :customer_name is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :amount => "100.00",
-         :payment_method => :redecard,
-         :holder => "Joao Maria Souza",
-         :card_number => "9" * 10,
-         :expiration => "10/12",
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :amount is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "",
-         :payment_method => :redecard,
-         :holder => "Joao Maria Souza",
-         :card_number => "9" * 10,
-         :expiration => "10/12",
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :payment_method is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "",
-         :amount => "100.00",
-         :holder => "Joao Maria Souza",
-         :card_number => "9" * 10,
-         :expiration => "10/12",
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :holder is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "",
-         :payment_method => :redecard,
-         :amount => "100.00",
-         :card_number => "9" * 10,
-         :expiration => "10/12",
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :card_number is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "",
-         :payment_method => :redecard,
-         :amount => "100.00",
-         :holder => "Joao Maria Souza",
-         :expiration => "10/12",
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :expiration is not present" do
-      expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "",
-         :payment_method => :redecard,
-         :amount => "100.00",
-         :holder => "Joao Maria Souza",
-         :card_number => "9" * 10,
-         :security_code => "123",
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :security_code is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "AAAAAAAA",
-         :payment_method => :redecard,
-         :amount => "100.00",
-         :holder => "Joao Maria Souza",
-         :expiration => "10/12",
-         :card_number => "9" * 10,
-         :number_payments => 1,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :number_payments is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "AAAAAAAA",
-         :payment_method => :redecard,
-         :amount => "100.00",
-         :holder => "Joao Maria Souza",
-         :expiration => "10/12",
-         :card_number => "9" * 10,
-         :type => 0
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
-
-    it "should raise an error when :type is not present" do
-     expect {
-       Braspag::CreditCard.authorize({
-         :order_id => "1" * 5,
-         :customer_name => "AAAAAAAA",
-         :payment_method => :redecard,
-         :amount => "100.00",
-         :holder => "Joao Maria Souza",
-         :expiration => "10/12",
-         :card_number => "9" * 10,
-         :number_payments => 1
-       })
-     }.to raise_error(Braspag::IncompleteParams)
-    end
+  before do
+    @connection = mock(:merchant_id => merchant_id)
+    Braspag::Connection.stub(:instance => @connection)
+  end
 
-    let!(:valid_params) {
+  describe ".authorize" do
+    let(:params) do
       {
-        :order_id => "1" * 5,
-        :customer_name => "AAAAAAAA",
-        :payment_method => :amex_2p,
+        :order_id => "um order id",
+        :customer_name => "W" * 21,
         :amount => "100.00",
+        :payment_method => :redecard,
         :holder => "Joao Maria Souza",
-        :expiration => "10/12",
         :card_number => "9" * 10,
+        :expiration => "10/12",
         :security_code => "123",
         :number_payments => 1,
         :type => 0
       }
-    }
-
-    it "should raise an error when :order_id is more than 20 characters" do
-      expect {
-        params = valid_params
-        params[:order_id] = "A" * 21
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidOrderId)
     end
 
-    it "should raise an error when :customer_name is more than 100 characters" do
-      expect {
-        params = valid_params
-        params[:customer_name] = "B" * 101
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidCustomerName)
+    let(:params_with_merchant_id) do
+      params.merge!(:merchant_id => merchant_id)
     end
 
-    it "should raise an error when :amount is more than 10 characters" do
-      expect {
-        params = valid_params
-        params[:amount] = "1234567890,00"
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidAmount)
-    end
+    let(:authorize_url) { "http://braspag/bla" }
 
-    it "should raise an error when :holder is more than 100 characters" do
-      expect {
-        params = valid_params
-        params[:holder] = "E" * 101
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidHolder)
-    end
+    before do
+      @connection.should_receive(:merchant_id)
 
-    it "should raise an error when :expiration is more than 7 characters" do
-      expect {
-        params = valid_params
-        params[:expiration] = "7" * 8
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidExpirationDate)
-    end
+      Braspag::CreditCard.should_receive(:authorize_url)
+                         .and_return(authorize_url)
 
-    it "should raise an error when :security_code is more than 4 characters" do
-      expect {
-        params = valid_params
-        params[:security_code] = "9" * 5
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidSecurityCode)
+      Braspag::CreditCard.should_receive(:check_params)
+                         .and_return(true)
     end
 
-    it "should raise an error when :number_payments is more than 2 characters" do
-      expect {
-        params = valid_params
-        params[:number_payments] = "123"
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidNumberPayments)
-    end
+    context "with invalid params"
 
-    it "should raise an error when :type is more than 1 character" do
-      expect {
-        params = valid_params
-        params[:type] = "123"
-        Braspag::CreditCard.authorize(params)
-      }.to raise_error(Braspag::InvalidType)
-    end
-
-    let!(:params) {
-      {
-        :order_id => "123456",
-        :customer_name => "Teste",
-        :payment_method => :amex_2p,
-        :amount => 1.3,
-        :holder => "teste",
-        :expiration => "05/13",
-        :card_number => "345678000000007",
-        :security_code => "1234",
-        :number_payments => "1",
-        :type => "0"
-      }
-    }
-
-    context "with a successful transaction" do
-
-      it "should return an array with :status => 1" do
-        xml = <<-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>
-            <authorisationNumber>733610</authorisationNumber>
-            <message>Transaction Successful</message>
-            <returnCode>0</returnCode>
-            <status>1</status>
-            <transactionId>398662</transactionId>
-          </PagadorReturn>
+    context "with valid params" do
+      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>5</amount>
+          <message>Transaction Successful</message>
+          <authorisationNumber>733610</authorisationNumber>
+          <returnCode>7</returnCode>
+          <status>2</status>
+          <transactionId>0</transactionId>
+        </PagadorReturn>
         EOXML
-
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
-
-        result = Braspag::CreditCard.authorize(params)
-        result[:status].should == "1"
-
-        FakeWeb.clean_registry
       end
 
-    end
-
-    context "with a unsuccessful transaction" do
-
-      it "should return an array with :status => 2" do
-        invalid_params = params
-        invalid_params[:security_code] = 1
-
-        xml = <<-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>5</amount>
-            <message>Payment Server detected an error</message>
-            <returnCode>7</returnCode>
-            <status>2</status>
-            <transactionId>0</transactionId>
-          </PagadorReturn>
-        EOXML
-
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
-
-        result = Braspag::CreditCard.authorize(invalid_params)
-        result[:status].should == "2"
-
-        FakeWeb.clean_registry
+      before do
+        FakeWeb.register_uri(:post, authorize_url, :body => valid_xml)
+        @response = Braspag::CreditCard.authorize(params)
       end
 
-    end
-
-    context "when a internal server error occurs on the gateway" do
-
-      it "should return an array with :status => null" do
-        invalid_params = params
-        invalid_params[:security_code] = "1"
-
-        xml = <<-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>5</amount>
-            <message>Payment Server detected an error</message>
-            <returnCode>7</returnCode>
-            <status>null</status>
-            <transactionId>0</transactionId>
-          </PagadorReturn>
-        EOXML
-
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Authorize", :body => xml)
-
-        result = Braspag::CreditCard.authorize(invalid_params)
-        result[:status].should == "null"
-
-        FakeWeb.clean_registry
+      it "should return a Hash" do
+        @response.should be_kind_of Hash
+        @response.should == {
+          :amount => "5",
+          :message => "Transaction Successful",
+          :number => "733610",
+          :return_code => "7",
+          :status => "2",
+          :transaction_id => "0"
+        }
       end
-
     end
-
   end
 
   describe ".capture" do
+    let(:capture_url) { "http://foo.bar/bar/baz" }
+    let(:order_id) { "um id qualquer" }
 
-    it "should raise an error when :order_id is more than 20 characters" do
-      expect {
-        Braspag::CreditCard.capture(("A" * 21))
-      }.to raise_error(Braspag::InvalidOrderId)
+    before do
+      @connection.should_receive(:merchant_id)
     end
 
-    it "should parse all the XML fields" do
-      xml = <<-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>0.01</amount>
-          <message>Capture Successful</message>
-          <returnCode>07</returnCode>
-          <status>0</status>
-        </PagadorReturn>
-      EOXML
-
-      FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+    context "invalid order id" do
+      it "should raise an error" do
+        Braspag::CreditCard.should_receive(:valid_order_id?)
+                           .with(order_id)
+                           .and_return(false)
 
-      result = Braspag::CreditCard.capture('123456')
-
-      result[:amount].should_not be_nil
-      result[:message].should_not be_nil
-      result[:return_code].should_not be_nil
-      result[:status].should_not be_nil
-
-      FakeWeb.clean_registry
+        expect {
+          Braspag::CreditCard.capture(order_id)
+        }.to raise_error(Braspag::InvalidOrderId)
+      end
     end
 
-    context "with a successful capture" do
-
-      it "should return an array with :status => 0" do
-        xml = <<-EOXML
+    context "valid order id" do
+      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"
@@ -391,157 +113,229 @@ describe Braspag::CreditCard do
             <status>0</status>
           </PagadorReturn>
         EOXML
+      end
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+      before do
+        Braspag::CreditCard.should_receive(:capture_url)
+                           .and_return(capture_url)
 
-        result = Braspag::CreditCard.capture('123456')
-        result[:status].should == "0"
+        FakeWeb.register_uri(:post, capture_url, :body => valid_xml)
+        @response = Braspag::CreditCard.capture("order id qualquer")
+      end
 
-        FakeWeb.clean_registry
+      it "should return a Hash" do
+        @response.should be_kind_of Hash
+        @response.should == {
+          :amount => "2",
+          :number => nil,
+          :message => "Approved",
+          :return_code => "0",
+          :status => "0",
+          :transaction_id => nil
+        }
       end
+    end
+  end
 
+  describe ".info" do
+    let(:info_url) { "http://braspag/bla" }
+
+    let(:invalid_xml) do
+      <<-EOXML
+      <DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://www.pagador.com.br/">
+        <NumeroComprovante></NumeroComprovante>
+        <Autenticada>false</Autenticada>
+        <NumeroAutorizacao>557593</NumeroAutorizacao>
+        <NumeroCartao>345678*****0007</NumeroCartao>
+        <NumeroTransacao>101001225645</NumeroTransacao>
+      </DadosCartao>
+      EOXML
     end
 
-    context "with an unsuccessful capture" do
+    let(:valid_xml) do
+      <<-EOXML
+      <DadosCartao xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://www.pagador.com.br/">
+        <NumeroComprovante>11111</NumeroComprovante>
+        <Autenticada>false</Autenticada>
+        <NumeroAutorizacao>557593</NumeroAutorizacao>
+        <NumeroCartao>345678*****0007</NumeroCartao>
+        <NumeroTransacao>101001225645</NumeroTransacao>
+      </DadosCartao>
+      EOXML
+    end
 
-      it "should return an array with :status => 2" do
-        xml = <<-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>0.01</amount>
-            <message>Payment Server detected an error</message>
-            <returnCode>7</returnCode>
-          <status>2</status>
-        </PagadorReturn>
-        EOXML
+    it "should raise an error when order id is not valid" do
+      Braspag::CreditCard.should_receive(:valid_order_id?)
+                         .with("bla")
+                         .and_return(false)
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+      expect {
+        Braspag::CreditCard.info "bla"
+      }.to raise_error(Braspag::InvalidOrderId)
+    end
 
-        result = Braspag::CreditCard.capture("1")
-        result[:status].should == "2"
+    it "should raise an error when Braspag returned an invalid xml as response" do
+      FakeWeb.register_uri(:post, info_url, :body => invalid_xml)
 
-        FakeWeb.clean_registry
-      end
+      Braspag::CreditCard.should_receive(:info_url)
+                         .and_return(info_url)
 
+      expect {
+        Braspag::CreditCard.info("orderid")
+      }.to raise_error(Braspag::UnknownError)
     end
 
-    context "when an internal server error occurs on the gateway" do
+    it "should return a Hash when Braspag returned a valid xml as response" do
+      FakeWeb.register_uri(:post, info_url, :body => valid_xml)
 
-      it "should return an array with :status => null" do
-        xml = <<-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>0.01</amount>
-            <message>Payment Server detected an error</message>
-            <returnCode>7</returnCode>
-            <status>null</status>
-          </PagadorReturn>
-        EOXML
+      Braspag::CreditCard.should_receive(:info_url)
+                         .and_return(info_url)
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Pagador.asmx/Capture", :body => xml)
+      response = Braspag::CreditCard.info("orderid")
+      response.should be_kind_of Hash
 
-        result = Braspag::CreditCard.capture("1234")
-        result[:status].should == "null"
-
-        FakeWeb.clean_registry
-      end
+      response.should == {
+        :checking_number => "11111",
+        :certified => "false",
+        :autorization_number => "557593",
+        :card_number => "345678*****0007",
+        :transaction_number => "101001225645"
+      }
+    end
+  end
 
+  describe ".check_params" do
+    let(:params) do
+      {
+        :order_id => 12345,
+        :customer_name => "AAAAAAAA",
+        :payment_method => :amex_2p,
+        :amount => "100.00",
+        :holder => "Joao Maria Souza",
+        :expiration => "10/12",
+        :card_number => "9" * 10,
+        :security_code => "123",
+        :number_payments => 1,
+        :type => 0
+      }
     end
 
-    context ".payment_method_from_id" do
-      it 'Credit card amex' do
-       Braspag::CreditCard::payment_method_from_id(18).should == :amex_2p
-       Braspag::CreditCard::payment_method_from_id(18).should be_kind_of Symbol
+    [:order_id, :amount, :payment_method, :customer_name, :holder, :card_number, :expiration,
+      :security_code, :number_payments, :type].each do |param|
+      it "should raise an error when #{param} is not present" do
+        expect {
+          params[param] = nil
+          Braspag::CreditCard.check_params(params)
+        }.to raise_error Braspag::IncompleteParams
       end
     end
 
+    it "should raise an error when order_id is not valid" do
+      Braspag::CreditCard.should_receive(:valid_order_id?)
+                         .with(params[:order_id])
+                         .and_return(false)
 
-  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)
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidOrderId
     end
 
-    it "should raise an error when order_id is empty" do
+    it "should raise an error when payment_method is not invalid" do
       expect {
-        Braspag::CreditCard.info("")
-      }.to raise_error(Braspag::InvalidOrderId)
+        params[:payment_method] = "non ecziste"
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidPaymentMethod
     end
 
-    it "should raise an error when order_id is more than 50 characters" do
+    it "should raise an error when customer_name is greater than 255 chars" do
       expect {
-        Braspag::CreditCard.info("1" * 51)
-      }.to raise_error(Braspag::InvalidOrderId)
+        params[:customer_name] = "b" * 256
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidCustomerName
     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
+    it "should raise an error when holder is greater than 100 chars" do
+      expect {
+        params[:holder] = "r" * 101
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidHolder
+    end
 
-      FakeWeb.register_uri(:post, "#{braspag_query_url}/GetDadosCartao",
-        :body => xml)
+    it "should raise an error when expiration is not in a valid format" do
+      expect {
+        params[:expiration] = "2011/19/19"
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidExpirationDate
 
       expect {
-        Braspag::CreditCard.info("sadpoakjspodqdouq09wduwq")
-      }.to raise_error(Braspag::UnknownError)
+        params[:expiration] = "12/2012"
+        Braspag::CreditCard.check_params(params)
+      }.to_not raise_error Braspag::InvalidExpirationDate
 
+      expect {
+        params[:expiration] = "12/12"
+        Braspag::CreditCard.check_params(params)
+      }.to_not raise_error Braspag::InvalidExpirationDate
+    end
 
+    it "should raise an error when security code is greater than 4 chars" do
       expect {
-        Braspag::CreditCard.info("asdnasdniousa")
-      }.to raise_error(Braspag::UnknownError)
+        params[:security_code] = "12345"
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidSecurityCode
 
-      FakeWeb.clean_registry
+      expect {
+        params[:security_code] = ""
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidSecurityCode
     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
+    it "should raise an error when number_payments is greater than 99" do
+      expect {
+        params[:number_payments] = 100
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidNumberPayments
 
-        FakeWeb.register_uri(:post, "#{braspag_query_url}/GetDadosCartao",
-          :body => xml)
-        order_info = Braspag::CreditCard.info("12345")
-        FakeWeb.clean_registry
-        order_info
-      }
+      expect {
+        params[:number_payments] = 0
+        Braspag::CreditCard.check_params(params)
+      }.to raise_error Braspag::InvalidNumberPayments
+    end
+  end
 
-      it "should return a Hash" do
-        order_info.should be_kind_of Hash
-      end
+  describe ".info_url" do
+    it "should return the correct info url when connection environment is homologation" do
+      @connection.stub(:braspag_url => braspag_homologation_url)
+      @connection.should_receive(:production?)
+                 .and_return(false)
 
-      {
-        :checking_number => "225296",
-        :certified => "false",
-        :autorization_number => "557593",
-        :card_number => "345678*****0007",
-        :transaction_number => "101001225645"
-      }.each do |key, value|
+      Braspag::CreditCard.info_url.should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosCartao"
+    end
 
-        it "should return a Hash with :#{key.to_s} key" do
-          order_info[key].should == value
-        end
-      end
+    it "should return the correct info url when connection environment is production" do
+      @connection.stub(:braspag_url => braspag_production_url)
+      @connection.should_receive(:production?)
+                 .and_return(true)
+
+      Braspag::CreditCard.info_url.should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosCartao"
     end
   end
 
+  describe ".authorize_url .capture_url" do
+    it "should return the correct credit card creation url when connection environment is homologation" do
+      @connection.stub(:braspag_url => braspag_homologation_url)
+      Braspag::CreditCard.authorize_url.should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Authorize"
+      Braspag::CreditCard.capture_url.should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Capture"
+    end
 
+    it "should return the correct credit card creation url when connection environment is production" do
+      @connection.stub(:braspag_url => braspag_production_url)
+      Braspag::CreditCard.authorize_url.should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Authorize"
+      Braspag::CreditCard.capture_url.should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Capture"
+    end
   end
 end