rbraspag 0.0.19 → 0.1.0

data/lib/rbraspag/eft.rb

@@ -1,5 +1,6 @@
 module Braspag
   class Eft < PaymentMethod
+
     PAYMENT_METHODS = {
       :bradesco => 11,
       :itau => 12,
@@ -20,92 +21,70 @@ module Braspag
       :has_interest => "TIPOPARCELADO"
     }
 
+    ACTION_URI = "/pagador/passthru.asp"
+
     def self.generate(params, crypto_strategy = nil)
       connection = Braspag::Connection.instance
-
       params[:merchant_id] = connection.merchant_id
 
-      if params[:amount] && !params[:amount].is_a?(BigDecimal)
-        params[:amount] = BigDecimal.new(params[:amount].to_s)
-      end
-
-      raise IncompleteParams if params[:order_id].nil? || params[:amount].nil? || params[:payment_method].nil?
-
-      raise InvalidOrderId unless params[:order_id].is_a?(String) || params[:order_id].is_a?(Fixnum)
-      raise InvalidOrderId unless (1..50).include?(params[:order_id].to_s.size)
+      params = self.normalize_params(params)
+      self.check_params(params)
 
-      params[:installments] = "1" if params[:installments].nil?
-      params[:installments] = "1" if params[:installments].nil?
-
-      unless params[:customer_name].nil?
-        raise InvalidCustomerName unless (1..255).include?(params[:customer_name].to_s.size)
-      end
+      data = {}
 
-      unless params[:customer_id].nil?
-        raise InvalidCustomerId unless (11..18).include?(params[:customer_id].to_s.size)
-      end
-
-      unless params[:installments].nil?
-        raise InvalidInstallments unless (1..2).include?(params[:installments].to_s.size)
-        begin
-          params[:installments] = Integer(params[:installments]) unless params[:installments].is_a?(Integer)
-        rescue Exception => e
-          raise InvalidInstallments
+      MAPPING.each do |k, v|
+        case k
+        when :payment_method
+          data[v] = PAYMENT_METHODS[params[:payment_method]]
+        when :amount
+          data[v] = Utils.convert_decimal_to_string(params[:amount])
+        else
+          data[v] = params[k] || ""
         end
       end
 
-      unless params[:has_interest].nil?
-        raise InvalidHasInterest unless (params[:has_interest].is_a?(TrueClass) || params[:has_interest].is_a?(FalseClass))
-      end
-
-      if params[:has_interest]
-         params[:has_interest] = "1"
-      else
-         params[:has_interest] = "0"
-      end
-
-      data =  create_data(params)
-
-      html = "<form id=\"form_tef_#{params[:order_id]}\" name=\"form_tef_#{params[:order_id]}\" action=\"#{self.uri}\" method=\"post\">\n"
+      html = "<form id=\"form_tef_#{params[:order_id]}\" name=\"form_tef_#{params[:order_id]}\" action=\"#{self.action_url}\" method=\"post\">"
 
       if crypto_strategy.nil?
         data.each do |key, value|
-          html.concat "  <input type=\"text\" name=\"#{key}\" value=\"#{value}\" />\n"
+          html << "<input type=\"text\" name=\"#{key}\" value=\"#{value}\" />"
         end
       else
         data.delete("Id_Loja")
-        html.concat "  <input type=\"text\" name=\"crypt\" value=\"#{crypto_strategy.encrypt(data)}\" />\n"
-        html.concat "  <input type=\"text\" name=\"Id_Loja\" value=\"#{params[:merchant_id]}\" />\n"
+        html << "<input type=\"text\" name=\"Id_Loja\" value=\"#{params[:merchant_id]}\" />"
+        html << "<input type=\"text\" name=\"crypt\" value=\"#{crypto_strategy.encrypt(data)}\" />"
       end
 
-      html.concat <<-EOHTML
-</form>
-<script type="text/javascript" charset="utf-8">
-  document.forms["form_tef_#{params[:order_id]}"].submit();
-</script>
-      EOHTML
+      html << "</form><script type=\"text/javascript\" charset=\"utf-8\">document.forms[\"form_tef_#{params[:order_id]}\"].submit();</script>"
 
       html
     end
 
-    protected
-    def self.create_data(params)
-      MAPPING.inject({}) do |memo, k|
-        if k[0] == :payment_method
-          memo[k[1]] = PAYMENT_METHODS[params[:payment_method]]
-        elsif k[0] == :amount
-          memo[k[1]] = Utils.convert_decimal_to_string(params[:amount])
-        else
-          memo[k[1]] = params[k[0]] || "";
-        end
+    def self.normalize_params(params)
+      params = super
+
+      params[:installments] = params[:installments].to_i unless params[:installments].nil?
+      params[:installments] ||= 1
+
+      params[:has_interest] = params[:has_interest] == true ? "1" : "0"
 
-        memo
+      params
+    end
+
+    def self.check_params(params)
+      super
+
+      if params[:installments]
+        raise InvalidInstallments if params[:installments].to_i < 1 || params[:installments].to_i > 99
+      end
+
+      if params[:has_interest]
+        raise InvalidHasInterest if params[:has_interest] != "1" && params[:has_interest] != "0"
       end
     end
 
-    def self.uri
-      connection = Braspag::Connection.instance
-      "#{connection.braspag_url}/pagador/passthru.asp"
+    def self.action_url
+      Braspag::Connection.instance.braspag_url + ACTION_URI
     end
   end
 end

data/lib/rbraspag/errors.rb

@@ -24,4 +24,14 @@ module Braspag
   class InvalidType < Exception ; end
   class InvalidNumberPayments < Exception ; end
   class UnknownError < Exception ; end
+
+  class Connection
+    class InvalidMerchantId < Exception ; end
+    class InvalidEnv < Exception ; end
+    class InvalidBraspagUrl < Exception ; end
+  end
+
+  class Order
+    class InvalidData < Exception; end
+  end
 end

data/lib/rbraspag/order.rb

@@ -1,15 +1,17 @@
 module Braspag
   class Order
-    class InvalidData < Exception; end
+    PRODUCTION_INFO_URI   = "/webservices/pagador/pedido.asmx/GetDadosPedido"
+    HOMOLOGATION_INFO_URI = "/pagador/webservice/pedido.asmx/GetDadosPedido"
 
     def self.status(order_id)
       connection = Braspag::Connection.instance
 
-      raise InvalidOrderId unless order_id.is_a?(String) || order_id.is_a?(Fixnum)
-      raise InvalidOrderId unless (1..50).include?(order_id.to_s.size)
+      raise InvalidOrderId unless Braspag::PaymentMethod.valid_order_id?(order_id)
 
-      request = ::HTTPI::Request.new("#{connection.braspag_query_url}/GetDadosPedido")
-      request.body = {:loja => connection.merchant_id, :numeroPedido => order_id.to_s}
+      request = ::HTTPI::Request.new(self.status_url)
+      request.body = {
+        :loja => connection.merchant_id, :numeroPedido => order_id.to_s
+      }
 
       response = ::HTTPI.post(request)
 
@@ -31,7 +33,11 @@ module Braspag
 
       raise InvalidData if response[:authorization].nil?
       response
+    end
 
+    def self.status_url
+      connection = Braspag::Connection.instance
+      connection.braspag_url + (connection.production? ? PRODUCTION_INFO_URI : HOMOLOGATION_INFO_URI)
     end
   end
 end

data/lib/rbraspag/payment_method.rb

@@ -3,5 +3,37 @@ module Braspag
     def self.payment_method_from_id(code)
       self::PAYMENT_METHODS.invert.values_at(code).first
     end
+
+    def self.normalize_params(params)
+      if params[:amount] && !params[:amount].is_a?(BigDecimal)
+        params[:amount] = BigDecimal.new(params[:amount].to_s)
+      end
+
+      params
+    end
+
+    def self.check_params(params)
+      [:order_id, :amount, :payment_method].each do |param|
+        raise IncompleteParams if params[param].nil?
+      end
+
+      raise InvalidOrderId unless self.valid_order_id?(params[:order_id])
+
+      if params[:customer_name]
+        raise InvalidCustomerName unless (1..255).include?(params[:customer_name].to_s.size)
+      end
+
+      if params[:customer_id]
+        raise InvalidCustomerId unless (11..18).include?(params[:customer_id].to_s.size)
+      end
+
+      unless params[:payment_method].is_a?(Symbol) && self::PAYMENT_METHODS[params[:payment_method]]
+        raise InvalidPaymentMethod
+      end
+    end
+
+    def self.valid_order_id?(order_id)
+      (order_id.is_a?(String) || order_id.is_a?(Fixnum)) && (1..50).include?(order_id.to_s.size)
+    end
   end
 end

data/lib/rbraspag/utils.rb

@@ -1,32 +1,29 @@
 module Braspag
   class Utils
     def self.convert_decimal_to_string(value)
-      cents = "0#{((value - value.to_i) * 100).to_i}".slice(-2,2)
-      integer = (value - (value - value.to_i)).to_i
-      "#{integer},#{cents}"
+      ("%.2f" % value.to_f).gsub('.', ',')
     end
 
     def self.convert_to_map(document, map = {})
       document = Nokogiri::XML(document)
 
-      map.each do |keyForMap , keyValue|
-        if keyValue.is_a?(String) || keyValue.nil?
-          keyValue = keyForMap if keyValue.nil?
+      map.each do |key, value|
+        if value.is_a?(String) || value.nil?
+          value = key if value.nil?
 
-          value = document.search(keyValue).first
-          if !value.nil?
-            value = value.content.to_s
-            map[keyForMap] = value unless value == ""
-            map[keyForMap] = nil if value == ""
+          new_value = document.search(value).first
+
+          if new_value.nil?
+            map[key] = nil
           else
-            map[keyForMap] = nil
+            new_value = new_value.content.to_s
+            map[key] = new_value unless new_value == ""
+            map[key] = nil if new_value == ""
           end
 
-        elsif keyValue.is_a?(Proc)
-          map[keyForMap] = keyValue.call(document)
+        elsif value.is_a?(Proc)
+          map[key] = value.call(document)
         end
-
-        map[keyForMap]
       end
 
       map

data/lib/rbraspag/version.rb

@@ -1,3 +1,3 @@
 module Braspag
-  VERSION = "0.0.19"
+  VERSION = "0.1.0"
 end

data/rbraspag.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'cs-httpi', '>= 0.9.5.2'
   s.add_dependency 'json', '>= 1.6.1'
-  s.add_dependency 'nokogiri', '>= 1.5.0'
+  s.add_dependency 'nokogiri', '>= 1.4.7'
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"

data/spec/bill_spec.rb

@@ -1,272 +1,47 @@
-#encoding: utf-8
+# encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Braspag::Bill 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 ".generate" do
-    context "consitencies" do
-      before do
-        xml = <<-EOXML
-<?xml version="1.0" encoding="utf-8"?>
-<PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="https://www.pagador.com.br/webservice/pagador">
-  <amount>1234.56</amount>
-  <boletoNumber>70345</boletoNumber>
-  <expirationDate>2011-08-13T00:00:00-03:00</expirationDate>
-  <url>https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=0224306d-d483-4026-9022-a855a645e7ec</url>
-  <returnCode>0</returnCode>
-  <status>0</status>
-</PagadorBoletoReturn>
-        EOXML
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto", :body => xml)
-      end
-
-      after do
-        FakeWeb.clean_registry
-      end
-
-      it "should raise an error when :order_id is not present" do
-        expect {
-          Braspag::Bill.generate( {
-              :amount => "100.00",
-              :payment_method => :bradesco
-            })
-        }.to raise_error(Braspag::IncompleteParams)
-      end
-
-      it "should raise an error when :amount is not present" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "12",
-              :payment_method => :bradesco
-            })
-        }.to raise_error(Braspag::IncompleteParams)
-      end
-
-      it "should raise an error when :payment_method is not present" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "13",
-              :amount => "120.00"
-            })
-        }.to raise_error(Braspag::IncompleteParams)
-      end
-
-      it "should raise an error when invalid string :payment_method" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "13",
-              :amount => "120.00",
-              :payment_method => "10"
-            })
-        }.to raise_error(Braspag::InvalidPaymentMethod)
-      end
-
-      it "should raise an error when invalid symbol :payment_method" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "13",
-              :amount => "120.00",
-              :payment_method => :invalid
-            })
-        }.to raise_error(Braspag::InvalidPaymentMethod)
-      end
-
-      it "should raise an error when :order_id is less than 1 character" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "",
-              :amount => "123.00",
-              :payment_method => :bradesco
-            })
-        }.to raise_error(Braspag::InvalidOrderId)
-      end
-
-      it "should raise an error when :order_id is more than 50 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "1" * 51,
-              :amount => "12.00",
-              :payment_method => :bradesco
-            })
-        }.to raise_error(Braspag::InvalidOrderId)
-      end
-
-      it "should raise an error when :customer_name is less than 1 character" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "102",
-              :amount => "42.00",
-              :payment_method => :bradesco,
-              :customer_name => ""
-            })
-        }.to raise_error(Braspag::InvalidCustomerName)
-      end
-
-      it "should raise an error when :customer_name is more than 255 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "112",
-              :amount => "121.00",
-              :payment_method => :bradesco,
-              :customer_name => "A" * 256
-            })
-        }.to raise_error(Braspag::InvalidCustomerName)
-      end
-
-      it "should raise an error when :customer_id is less than 11 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "23",
-              :amount => "251.00",
-              :payment_method => :bradesco,
-              :customer_id => "2" * 10
-            })
-        }.to raise_error(Braspag::InvalidCustomerId)
-      end
-
-      it "should raise an error when :customer_id is more than 18 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "90",
-              :amount => "90.00",
-              :payment_method => :bradesco,
-              :customer_id => "3" * 19
-            })
-        }.to raise_error(Braspag::InvalidCustomerId)
-      end
-
-      it "should raise an error when :number is less than 1 character" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "900",
-              :amount => "92.00",
-              :payment_method => :bradesco,
-              :number => ""
-            })
-        }.to raise_error(Braspag::InvalidNumber)
-      end
-
-      it "should raise an error when :number is more than 255 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "91",
-              :amount => "80.00",
-              :payment_method => :bradesco,
-              :number => "5" * 256
-            })
-        }.to raise_error(Braspag::InvalidNumber)
-      end
-
-      it "should raise an error when :instructions is less than 1 character" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "76",
-              :amount => "50.00",
-              :payment_method => :bradesco,
-              :instructions => ""
-            })
-        }.to raise_error(Braspag::InvalidInstructions)
-      end
-
-      it "should raise an error when :instructions is more than 512 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "65",
-              :amount => "210.00",
-              :payment_method => :bradesco,
-              :instructions => "O" * 513
-            })
-        }.to raise_error(Braspag::InvalidInstructions)
-      end
-
-      it "should raise an error when :expiration_date is more or less than 8 characters" do
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "34",
-              :amount => "245.00",
-              :payment_method => :bradesco,
-              :expiration_date => "1" * 7
-            })
-        }.to raise_error(Braspag::InvalidExpirationDate)
-
-        expect {
-          Braspag::Bill.generate( {
-              :order_id => "67",
-              :amount => "321.00",
-              :payment_method => :bradesco,
-              :expiration_date => "2" * 9
-            })
-        }.to raise_error(Braspag::InvalidExpirationDate)
-      end
+  before do
+    @connection = mock(:merchant_id => merchant_id)
+    Braspag::Connection.stub(:instance => @connection)
+  end
 
-      it "should accept :payment_method as Symbol Object and convert to relative String value" do
-        Braspag::Bill.generate( {
-              :order_id => "67",
-              :amount => "321.00",
-              :payment_method => :itau,
-              :expiration_date => Date.today + 2
-        }).should be_instance_of(Hash)
-      end
+  describe ".generate" do
+    let(:params) do
+      {
+        :order_id => 11,
+        :amount => 3,
+        :payment_method => :hsbc
+      }
+    end
 
-      it "should accept :expiration_date with Date Object" do
-        Braspag::Bill.generate( {
-            :order_id => "67",
-            :amount => "321.00",
-            :payment_method => :bradesco,
-            :expiration_date => Date.today + 2
-        }).should be_instance_of(Hash)
-      end
+    let(:params_with_merchant_id) do
+      params.merge!(:merchant_id => merchant_id)
+    end
 
-      it "should accept :expiration_date with valid string date" do
-        Braspag::Bill.generate( {
-            :order_id => "67",
-            :amount => "321.00",
-            :payment_method => :bradesco,
-            :expiration_date => (Date.today + 2).strftime("%d/%m/%y")
-        }).should be_instance_of(Hash)
-      end
+    let(:creation_url) { "https://bla.com/foo/bar/baz" }
 
-      it "should accept string as :amount" do
-        Braspag::Bill.generate( {
-              :order_id => "67",
-              :amount => "54321.45",
-              :payment_method => :bradesco,
-              :expiration_date => (Date.today + 2).strftime("%d/%m/%y")
-        }).should be_instance_of(Hash)
-      end
+    before do
+      @connection.should_receive(:merchant_id)
 
-      it "should accept integer as :amount" do
-        Braspag::Bill.generate( {
-              :order_id => "67",
-              :amount => 123,
-              :payment_method => :bradesco,
-              :expiration_date => (Date.today + 2).strftime("%d/%m/%y")
-        }).should be_instance_of(Hash)
-      end
+      Braspag::Bill.should_receive(:creation_url)
+                   .and_return(creation_url)
 
-      it "should accept BigDecimal as :amount" do
-        Braspag::Bill.generate( {
-              :order_id => "67",
-              :amount => BigDecimal.new("123.45"),
-              :payment_method => :bradesco,
-              :expiration_date => (Date.today + 2).strftime("%d/%m/%y")
-        }).should be_instance_of(Hash)
-      end
+      Braspag::Bill.should_receive(:normalize_params)
+                   .with(params_with_merchant_id)
+                   .and_return(params_with_merchant_id)
 
-      it "should accept integer as :amount" do
-        Braspag::Bill.generate( {
-              :order_id => "67",
-              :amount => 12345,
-              :payment_method => :bradesco,
-              :expiration_date => (Date.today + 2).strftime("%d/%m/%y")
-        }).should be_instance_of(Hash)
-      end
+      Braspag::Bill.should_receive(:check_params)
+                   .and_return(true)
     end
 
-    context "with incorrect data" do
-      it "should raise an error for invalid :merchantId" do
+    context "with invalid params" do
+      it "should raise an error when Braspag returns 'Invalid merchantId' as response" do
         xml = <<-EOXML
         <?xml version="1.0" encoding="utf-8"?>
         <PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -280,20 +55,14 @@ describe Braspag::Bill do
         </PagadorBoletoReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto", :body => xml)
+        FakeWeb.register_uri(:post, creation_url, :body => xml)
 
         expect {
-          Braspag::Bill.generate( {
-              :order_id => 1,
-              :amount => 3,
-              :payment_method => :hsbc
-            })
+          Braspag::Bill.generate(params)
         }.to raise_error(Braspag::InvalidMerchantId)
-
-        FakeWeb.clean_registry
       end
 
-      it "should raise an error for invalid :number" do
+      it "should raise an error when Braspag returns 'Input string was not in a correct format' as response" do
         xml = <<-EOXML
         <?xml version="1.0" encoding="utf-8"?>
         <PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -307,21 +76,14 @@ describe Braspag::Bill do
         </PagadorBoletoReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto", :body => xml)
+        FakeWeb.register_uri(:post, creation_url, :body => xml)
 
         expect {
-          Braspag::Bill.generate( {
-              :number => "A" * 50,
-              :order_id => "x",
-              :amount => 3,
-              :payment_method => :hsbc
-            })
+          Braspag::Bill.generate(params)
         }.to raise_error(Braspag::InvalidStringFormat)
-
-        FakeWeb.clean_registry
       end
 
-      it "should raise an error for invalid :payment_method" do
+      it "should raise an error when Braspag returns 'Invalid payment method' as response" do
         xml = <<-EOXML
         <?xml version="1.0" encoding="utf-8"?>
         <PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -335,20 +97,14 @@ describe Braspag::Bill do
         </PagadorBoletoReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto", :body => xml)
+        FakeWeb.register_uri(:post, creation_url, :body => xml)
 
         expect {
-          bill = Braspag::Bill.generate( {
-              :order_id => 1,
-              :amount => "0000",
-              :payment_method => :hsbc
-            })
+          Braspag::Bill.generate(params)
         }.to raise_error(Braspag::InvalidPaymentMethod)
-
-        FakeWeb.clean_registry
       end
 
-      it "should raise an error for invalid :amount" do
+      it "should raise an error when Braspag returns 'Invalid purchase amount' as response" do
         xml = <<-EOXML
         <?xml version="1.0" encoding="utf-8"?>
         <PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -362,20 +118,14 @@ describe Braspag::Bill do
         </PagadorBoletoReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto", :body => xml)
+        FakeWeb.register_uri(:post, creation_url, :body => xml)
 
         expect {
-          bill = Braspag::Bill.generate( {
-              :order_id => 1,
-              :amount => -33,
-              :payment_method => :hsbc
-            })
+          Braspag::Bill.generate(params)
         }.to raise_error(Braspag::InvalidAmount)
-
-        FakeWeb.clean_registry
       end
 
-      it "should raise an error for unknown problems" do
+      it "should raise an error when Braspag returns any other error as response" do
         xml = <<-EOXML
         <?xml version="1.0" encoding="utf-8"?>
         <PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -389,164 +139,244 @@ describe Braspag::Bill do
         </PagadorBoletoReturn>
         EOXML
 
-        FakeWeb.register_uri(:post, "#{braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto", :body => xml)
+        FakeWeb.register_uri(:post, creation_url, :body => xml)
 
         expect {
-          bill = Braspag::Bill.generate( {
-              :order_id => 1,
-              :amount => 3,
-              :payment_method => :real
-            })
+          Braspag::Bill.generate(params)
         }.to raise_error(Braspag::UnknownError)
-
-        FakeWeb.clean_registry
       end
     end
 
+    context "with valid params" do
+      let(:valid_xml) do
+        <<-EOXML
+        <?xml version="1.0" encoding="utf-8"?>
+        <PagadorBoletoReturn xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                             xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                             xmlns="https://www.pagador.com.br/webservice/pagador">
+          <amount>3.00</amount>
+          <boletoNumber>123123</boletoNumber>
+          <expirationDate>2012-01-08T00:00:00</expirationDate>
+          <url>https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=722934be-6756-477a-87ab-42115ee1424d</url>
+          <returnCode>0</returnCode>
+          <status>0</status>
+        </PagadorBoletoReturn>
+        EOXML
+      end
 
-    context "with all data" do
-      before(:all) do
-        @tomorrow = (Time.now + 3600 * 24 * 2)
-
-        data = {
-          :order_id => Time.now.to_i.to_s,
+      let(:params) do
+        {
+          :order_id => 2901,
           :amount => 3,
           :payment_method => :real,
           :number => "123123",
-          :expiration_date => @tomorrow.strftime("%d/%m/%y")
+          :expiration_date => Date.today.strftime("%d/%m/%y")
         }
-
-        @response = Braspag::Bill.generate( data)
       end
 
-      it "should return the bill number" do
-        @response[:number].should == "123123"
+      before do
+        FakeWeb.register_uri(:post, creation_url, :body => valid_xml)
+        @response = Braspag::Bill.generate(params)
       end
 
-      it "should return the expiration date" do
-        @response[:expiration_date].should be_kind_of Date
-        @response[:expiration_date].strftime("%d/%m/%Y").should == @tomorrow.strftime("%d/%m/%Y")
+      it "should return a Hash" do
+        @response.should be_kind_of Hash
+        @response.should == {
+          :url => "https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=722934be-6756-477a-87ab-42115ee1424d",
+          :amount => BigDecimal.new("3.00"),
+          :number => "123123",
+          :expiration_date => Date.new(2012, 1, 8),
+          :return_code => "0",
+          :status => "0",
+          :message => nil
+        }
       end
     end
+  end
 
-    context "with minimum correct data" do
-      before(:all) do
-        data = {
-          :order_id => Time.now.to_i.to_s,
-          :amount => 1234.56,
-          :payment_method => :real
-        }
-        @response =  Braspag::Bill.generate( data)
-      end
+  describe ".normalize_params" do
+    it "should format the expiration_date param" do
+      params = { :expiration_date => Date.new(2011, 12, 10) }
 
-      it "should return a public url" do
-        regexp = %r"https://homologacao\.pagador\.com\.br/pagador/reenvia\.asp\?Id_Transacao=[a-z0-9]{8}\-[a-z0-9]{4}\-[a-z0-9]{4}\-[a-z0-9]{4}\-[a-z0-9]{12}"
-        @response[:url].should match(regexp)
-      end
+      result = Braspag::Bill.normalize_params(params)
+      result.should be_kind_of Hash
 
-      it "should return 0 (waiting payment) as the status" do
-        @response[:status].should == "0"
-      end
+      result[:expiration_date].should =~ /10\/12\/11/
+    end
 
-      it "should return 0 (success) as the return_code" do
-        @response[:return_code].should == "0"
-      end
+    it "should convert amount to BigDecimal" do
+      params = { :amount => "100.2" }
 
-      it "should return 3 as the amount" do
-        @response[:amount].should == BigDecimal.new("1234.56")
-      end
+      result = Braspag::Bill.normalize_params(params)
+      result.should be_kind_of Hash
 
-      it "should return the bill number" do
-        @response[:number].should_not be_empty
-      end
+      result[:amount].should be_kind_of BigDecimal
+    end
+  end
 
-      it "should return the expiration date" do
-        ten_days_after_today = (Time.now + 3600 * 24 * 10)
+  describe ".check_params" do
+    let(:params) do
+      {
+        :order_id => "111",
+        :amount => 100.0,
+        :payment_method => :bradesco
+      }
+    end
 
-        @response[:expiration_date].should be_kind_of Date
-        @response[:expiration_date].strftime("%d/%m/%Y").should == ten_days_after_today.strftime("%d/%m/%Y")
+    [:order_id, :amount, :payment_method].each do |param|
+      it "should raise an error when #{param} is not present" do
+        expect {
+          params[param] = nil
+          Braspag::Bill.check_params(params)
+        }.to raise_error Braspag::IncompleteParams
       end
     end
-  end
 
-  describe "#status" do
-    it "should raise an error when no Bill_id is given" do
+    it "should raise an error when order_id is not valid" do
+      Braspag::Bill.should_receive(:valid_order_id?)
+                   .with(params[:order_id])
+                   .and_return(false)
+
       expect {
-        Braspag::Bill.info(nil)
-      }.to raise_error(Braspag::InvalidOrderId)
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidOrderId
     end
 
-    it "should raise an error when Bill_id is empty" do
+    it "should raise an error when customer_name is present and is greater than 255 chars" do
       expect {
-        Braspag::Bill.info("")
-      }.to raise_error(Braspag::InvalidOrderId)
+        params[:customer_name] = "b" * 256
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidCustomerName
     end
 
-    it "should raise an error when Bill_id is more than 50 characters" do
+    it "should raise an error when customer_id is present and is greater than 18 chars" do
       expect {
-        Braspag::Bill.info("1" * 51)
-      }.to raise_error(Braspag::InvalidOrderId)
+        params[:customer_id] = "1" * 19
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidCustomerId
     end
 
-    it "should raise an error for incorrect data" do
-      xml = <<-EOXML
-<?xml version="1.0" encoding="utf-8"?>
-<DadosBoleto 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 customer_id is present and is less than 11 chars" do
+      expect {
+        params[:customer_id] = "1" * 10
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidCustomerId
+    end
 
-      FakeWeb.register_uri(:post, "#{braspag_query_url}/GetDadosBoleto",
-        :body => xml)
+    it "should raise an error when number is present and is greater than 255 chars" do
+      expect {
+        params[:number] = "1" * 256
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidNumber
+    end
 
+    it "should raise an error when instructions is present and is greater than 512 chars" do
       expect {
-        Braspag::Bill.info("sadpoakjspodqdouq09wduwq")
-      }.to raise_error(Braspag::UnknownError)
+        params[:instructions] = "A" * 513
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidInstructions
+    end
 
+    it "should raise an error when expiration_date is present and is not in a valid format" do
+      expect {
+        params[:expiration_date] = "2011/19/19"
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidExpirationDate
 
       expect {
-        Braspag::Bill.info("asdnasdniousa")
-      }.to raise_error(Braspag::UnknownError)
+        params[:expiration_date] = "29/10/1991"
+        Braspag::Bill.check_params(params)
+      }.to_not raise_error Braspag::InvalidExpirationDate
+    end
 
-      FakeWeb.clean_registry
+    it "should raise an error when payment_method is not invalid" do
+      expect {
+        params[:payment_method] = "non ecziste"
+        Braspag::Bill.check_params(params)
+      }.to raise_error Braspag::InvalidPaymentMethod
     end
+  end
 
-    context "with correct data" do
+  describe ".valid_order_id?" do
+    it "should return false when order id is greater than 50 chars" do
+      Braspag::Bill.valid_order_id?("A"*51).should be_false
+    end
 
-      let(:status) {
-        xml = <<-EOXML
-<?xml version="1.0" encoding="utf-8"?>
-<DadosBoleto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-             xmlns="http://www.pagador.com.br/">
-<NumeroDocumento>999</NumeroDocumento>
-<Sacado/>
-<NossoNumero>999</NossoNumero>
-<LinhaDigitavel>35690.00361 03962.070003 00000.009993 4 50160000001000</LinhaDigitavel>
-<DataDocumento>22/6/2011</DataDocumento>
-<DataVencimento>2/7/2011</DataVencimento>
-<Cedente>Gonow Tecnologia e Acessoria Empresarial Ltda</Cedente>
-<Banco>356-5</Banco>
-<Agencia>0003</Agencia>
-<Conta>6039620</Conta>
-<Carteira>57</Carteira>
-<ValorDocumento>10,00</ValorDocumento>
-</DadosBoleto>
-        EOXML
+    it "should return false when order id is not a String or Fixnum" do
+      Braspag::Bill.valid_order_id?(nil).should be_false
+    end
 
-        FakeWeb.register_uri(:post, "#{braspag_query_url}/GetDadosBoleto",
-          :body => xml)
-        status = Braspag::Bill.info("12345")
-        FakeWeb.clean_registry
-        status
-      }
+    it "should return true" do
+      Braspag::Bill.valid_order_id?("A"*50).should be_true
+      Braspag::Bill.valid_order_id?(100).should be_true
+    end
+  end
 
-      it "should return a Hash" do
-        status.should be_kind_of Hash
-      end
+  describe ".info" do
+    let(:info_url) { "http://braspag/bla" }
+    let(:invalid_xml) do
+      <<-EOXML
+      <?xml version="1.0" encoding="utf-8"?>
+      <DadosBoleto 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
+    end
 
-      {
+    let(:valid_xml) do
+      <<-EOXML
+      <?xml version="1.0" encoding="utf-8"?>
+      <DadosBoleto xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://www.pagador.com.br/">
+      <NumeroDocumento>999</NumeroDocumento>
+      <Sacado/>
+      <NossoNumero>999</NossoNumero>
+      <LinhaDigitavel>35690.00361 03962.070003 00000.009993 4 50160000001000</LinhaDigitavel>
+      <DataDocumento>22/6/2011</DataDocumento>
+      <DataVencimento>2/7/2011</DataVencimento>
+      <Cedente>Gonow Tecnologia e Acessoria Empresarial Ltda</Cedente>
+      <Banco>356-5</Banco>
+      <Agencia>0003</Agencia>
+      <Conta>6039620</Conta>
+      <Carteira>57</Carteira>
+      <ValorDocumento>10,00</ValorDocumento>
+      </DadosBoleto>
+      EOXML
+    end
+
+    it "should raise an error when order id is not valid" do
+      Braspag::Bill.should_receive(:valid_order_id?)
+                   .with("bla")
+                   .and_return(false)
+
+      expect {
+        Braspag::Bill.info "bla"
+      }.to raise_error(Braspag::InvalidOrderId)
+    end
+
+    it "should raise an error when Braspag returned an invalid xml as response" do
+      FakeWeb.register_uri(:post, info_url, :body => invalid_xml)
+
+      Braspag::Bill.should_receive(:info_url)
+                   .and_return(info_url)
+
+      expect {
+        Braspag::Bill.info("orderid")
+      }.to raise_error(Braspag::UnknownError)
+    end
+
+    it "should return a Hash when Braspag returned a valid xml as response" do
+      FakeWeb.register_uri(:post, info_url, :body => valid_xml)
+
+      Braspag::Bill.should_receive(:info_url)
+                   .and_return(info_url)
+
+      response = Braspag::Bill.info("orderid")
+      response.should be_kind_of Hash
+
+      response.should == {
         :document_number => "999",
         :payer => nil,
         :our_number => "999",
@@ -559,19 +389,39 @@ describe Braspag::Bill do
         :account => "6039620",
         :wallet => "57",
         :amount => "10,00",
-      }.each do |key, value|
+        :amount_invoice => nil,
+        :invoice_date => nil
+      }
+    end
+  end
 
-        it "should return a Hash with :#{key.to_s} key" do
-          status[key].should == value
-        end
-      end
+  describe ".creation_url" do
+    it "should return the correct bill creation url when connection environment is homologation" do
+      @connection.stub(:braspag_url => braspag_homologation_url)
+      Braspag::Bill.creation_url.should == "#{braspag_homologation_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
+    end
+
+    it "should return the correct bill creation url when connection environment is production" do
+      @connection.stub(:braspag_url => braspag_production_url)
+      Braspag::Bill.creation_url.should == "#{braspag_production_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
     end
   end
 
-  describe ".payment_method_from_id" do
-      it 'Credit card amex' do
-        Braspag::Bill::payment_method_from_id("06").should == :bradesco
-        Braspag::Bill::payment_method_from_id("06").should be_kind_of Symbol
-      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)
+
+      Braspag::Bill.info_url.should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosBoleto"
+    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::Bill.info_url.should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosBoleto"
+    end
   end
 end