cbraspag 0.9.0

data/spec/core/poster_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Braspag::Poster do
+  let(:request) { OpenStruct.new(:url => 'http://foo/bar') }
+  let(:response) { mock(:body => 'success') }
+  let(:logger) { mock(:info => nil) }
+  let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+  let(:connection_logger) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation, :logger => logger)}
+  let(:connection_proxy) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation, :proxy_address => 'http://proxy.com')}
+
+  describe "#do_post" do
+    before do
+      ::HTTPI::Request.should_receive(:new).with('http://foo/bar').and_return(request)
+      ::HTTPI.should_receive(:post).with(request).and_return(response)
+    end
+
+    context "without proxy and logger" do
+      subject { described_class.new(connection, 'http://foo/bar') }
+
+      it "should not set the proxy if the proxy_address is not set" do
+        request.should_not_receive(:proxy=)
+        subject.do_post(:foo, {})
+      end
+      
+      it "should not raise an error if logger is not defined" do
+        expect {
+          subject.do_post(:doe, { :foo => :bar, :egg => :span })
+        }.to_not raise_error
+      end
+      
+    end
+
+    context "with logger" do
+      subject { described_class.new(connection_logger, 'http://foo/bar') }
+      
+      it "should log the request info" do
+        logger.should_receive(:info).with('[Braspag] #doe: http://foo/bar, data: {:foo=>:bar, :egg=>:span}')
+        subject.do_post(:doe, { :foo => :bar, :egg => :span })
+      end
+
+      it "should log the request info removing the credit card sensitive info" do
+        logger.should_receive(:info).with('[Braspag] #doe: http://foo/bar, data: {"cardNumber"=>"************", "securityCode"=>"***"}')
+        subject.do_post(:doe, { 'cardNumber' => '123', 'securityCode' => '456' })
+      end
+
+      it "should log response info" do
+        logger.should_receive(:info).with('[Braspag] #doe: http://foo/bar, data: {:foo=>:bar, :egg=>:span}')
+        subject.do_post(:doe, { :foo => :bar, :egg => :span })
+      end
+    end
+
+    context "with proxy" do
+      subject { described_class.new(connection_proxy, 'http://foo/bar') }
+      
+      it "should set the proxy if the proxy_address is set" do
+        request.should_receive(:proxy=).with('http://proxy.com')
+        subject.do_post(:foo, {})
+      end
+    end
+  end
+end

data/spec/core/response_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Response do
+  
+end

data/spec/crypto/jar_webservice_spec.rb

@@ -0,0 +1,183 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Crypto::JarWebservice do
+  let!(:crypt) {Braspag::Crypto::JarWebservice}
+  let! (:key) {"5u0ZN5qk8eQNuuGPHrcsk0rfi7YclF6s+ZXCE+G4uG4ztfRJrrOALlf81ra7k7p7"}
+
+  pending "when encrypt data" do
+
+      it "should return a string" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/encrypt.json",
+          :body => <<-EOJSON
+          {"encrypt":"5u0ZN5qk8eQNuuGPHrcsk0rfi7YclF6s+ZXCE+G4uG4ztfRJrrOALlf81ra7k7p7"}
+          EOJSON
+        )
+
+        crypt.encrypt(:nome => "Chapulin", :sobrenome => "Colorado").should == key
+      end
+
+      it "should raise a error with invalid params" do
+        expect {
+          crypt.encrypt(9999)
+        }.to raise_error(Braspag::IncompleteParams)
+      end
+
+      it "should raise an error with invalid params after process" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/encrypt.json",
+          :body => <<-EOJSON
+          {
+          	"msg" : "INVALID FORMAT"
+          }
+          EOJSON
+        )
+
+        expect {
+          crypt.encrypt(:venda => "value")
+        }.to raise_error(Braspag::IncompleteParams)
+      end
+
+      it "should raise an error with invalid params after process" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/encrypt.json",
+          :body => <<-EOJSON
+INVALIDO
+          EOJSON
+        )
+
+        expect {
+          crypt.encrypt(:venda => "value")
+        }.to raise_error(Braspag::UnknownError)
+      end
+
+      it "should raise an error with invalid params after process" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/encrypt.json",
+          :body => <<-EOJSON
+          {
+          	"msg" : "INVALID FIELDS"
+          }
+          EOJSON
+        )
+
+        expect {
+          crypt.encrypt(:venda => nil)
+        }.to raise_error(Braspag::IncompleteParams)
+      end
+
+      it "should raise an error with invalid crypt key" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/encrypt.json",
+          :body => <<-EOJSON
+          {
+          	"msg" : "INVALID KEY"
+          }
+          EOJSON
+        )
+
+        expect {
+          crypt.encrypt(:venda => "value")
+        }.to raise_error(Braspag::InvalidCryptKey)
+      end
+
+  end
+
+  pending "when decrypt data" do
+
+      it "should return a hash" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/decrypt.json",
+          :body => <<-EOJSON
+          {"fields":{"nome":"Chapulin","sobrenome":"Colorado"}}
+          EOJSON
+        )
+
+        crypt.decrypt(key, [:nome, :sobrenome])[:nome].should eql("Chapulin")
+      end
+
+      it "should raise a error with invalid encrypted key" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/decrypt.json",
+          :body => <<-EOJSON
+          {
+          	"msg" : "INVALID ENCRYPTED STRING"
+          }
+          EOJSON
+        )
+
+        expect {
+          crypt.decrypt("1", [:nome, :sobrenome])
+        }.to raise_error(Braspag::InvalidEncryptedKey)
+      end
+
+      it "should raise a error with invalid encrypted key" do
+        expect {
+          crypt.decrypt(1, [:nome, :sobrenome])
+        }.to raise_error(Braspag::InvalidEncryptedKey)
+      end
+
+
+      it "should raise a error with invalid fields" do
+        expect {
+          crypt.decrypt(key, 9999)
+        }.to raise_error(Braspag::IncompleteParams)
+      end
+
+      it "should raise a error with invalid fields" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/decrypt.json",
+          :body => <<-EOJSON
+          {
+          	"msg" : "INVALID FIELDS"
+          }
+          EOJSON
+        )
+
+        expect {
+          crypt.decrypt(key, [:nome, :sobrenome])
+        }.to raise_error(Braspag::IncompleteParams)
+      end
+
+      it "should raise an error with invalid params after process" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/decrypt.json",
+          :body => <<-EOJSON
+INVALIDO
+          EOJSON
+        )
+
+
+        expect {
+          crypt.decrypt(key, [:nome, :sobrenome])
+        }.to raise_error(Braspag::UnknownError)
+      end
+
+      it "should raise an error with invalid crypt key" do
+        FakeWeb.register_uri(
+          :post,
+          "http://localhost:9292/v1/decrypt.json",
+          :body => <<-EOJSON
+          {
+          	"msg" : "INVALID KEY"
+          }
+          EOJSON
+        )
+
+        expect {
+          crypt.decrypt(key, [:nome, :sobrenome])
+        }.to raise_error(Braspag::InvalidCryptKey)
+      end
+
+  end
+end

data/spec/crypto/webservice_spec.rb

@@ -0,0 +1,142 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Crypto::Webservice do
+    pending "encrypt" do
+      let!(:key) {"XXXXX"}
+
+      context "consistencies" do
+        it "should return error with invalid data" do
+          expect {
+            Braspag::Crypto::Webservice.encrypt("INVALID DATA")
+          }.to raise_error(Braspag::IncompleteParams)
+        end
+
+        it "should return error with invalid data after process" do
+          body_invalid = <<-EOXML
+SERVER was unable to process
+EOXML
+          FakeWeb.register_uri(:post,
+          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+          :body => body_invalid )
+          expect {
+            Braspag::Crypto::Webservice.encrypt(:key => "INVALID DATA")
+          }.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><EncryptRequestResponse xmlns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+<EncryptRequestResult>Erro BP 011</EncryptRequestResult></EncryptRequestResponse>
+</soap:Body></soap:Envelope>
+EOXML
+          FakeWeb.register_uri(:post,
+          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+          :body => body_invalid )
+          expect {
+            Braspag::Crypto::Webservice.encrypt(:key => "value")
+          }.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"?>
+<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><EncryptRequestResponse xmlns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+<EncryptRequestResult>Erro BP 067</EncryptRequestResult></EncryptRequestResponse>
+</soap:Body></soap:Envelope>
+EOXML
+          FakeWeb.register_uri(:post,
+          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+          :body => body_invalid )
+          expect {
+            Braspag::Crypto::Webservice.encrypt(:key => "value")
+          }.to raise_error(Braspag::InvalidIP)
+          FakeWeb.clean_registry
+        end
+      end
+
+      it "should return a string" do
+          FakeWeb.register_uri(:post,
+          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+          :body => <<-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>
+<EncryptRequestResponse xmlns='https://www.pagador.com.br/webservice/BraspagGeneralService'>
+<EncryptRequestResult>#{key}</EncryptRequestResult>
+</EncryptRequestResponse>
+</soap:Body></soap:Envelope>
+                EOXML
+          )
+          Braspag::Crypto::Webservice.encrypt(:key => "value").should == key
+          FakeWeb.clean_registry
+      end
+    end
+
+    pending "when decrypt data" do
+
+      context "consistencies" do
+        it "should return error with invalid data" do
+          expect {
+            Braspag::Crypto::Webservice.decrypt(1213123)
+          }.to raise_error(Braspag::IncompleteParams)
+        end
+
+        it "should return error with invalid data" do
+          body_invalid = <<-EOXML
+SERVER was unable to process
+EOXML
+          FakeWeb.register_uri(:post,
+          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+          :body => body_invalid )
+          expect {
+            Braspag::Crypto::Webservice.decrypt("{sdfsdf34543534}")
+          }.to raise_error(Braspag::UnknownError)
+          FakeWeb.clean_registry
+        end
+
+        it "should return error with invalid ip" 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 068</string></DecryptRequestResult>
+</DecryptRequestResponse></soap:Body></soap:Envelope>
+EOXML
+         FakeWeb.register_uri(:post,
+         "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+         :body => body_invalid )
+         expect {
+            Braspag::Crypto::Webservice.decrypt("{sdfsdf34543534}")
+          }.to raise_error(Braspag::InvalidIP)
+          FakeWeb.clean_registry
+        end
+      end
+
+      it "should return a string" do
+          FakeWeb.register_uri(:post,
+          "https://homologacao.pagador.com.br/BraspagGeneralService/BraspagGeneralService.asmx",
+          :body => <<-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>CODPAGAMENTO=18</string>
+<string>VENDAID=teste123</string>
+<string>VALOR=100</string>
+<string>PARCELAS=1</string>
+<string>NOME=comprador</string>
+</DecryptRequestResult></DecryptRequestResponse>
+</soap:Body></soap:Envelope>
+                EOXML
+          )
+          Braspag::Crypto::Webservice.decrypt("{sdfsdf34543534}")[:parcelas].should eql("1")
+          FakeWeb.clean_registry
+      end
+
+    end
+end

data/spec/payment/billet_spec.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Connection do
+  let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  let(:connection) { Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)}
+
+  context ".generate_billet" do
+    let(:customer) do
+      Braspag::Customer.new(
+        :document     => '21473696240', # (OPTIONAL)
+        :name   => 'Bob Dela Bobsen',
+        :email  => 'bob@mailinator.com' # send email to consumer (OPTIONAL)
+      )
+    end
+    
+    let(:order) do
+      Braspag::Order.new(
+        :id                => "um order id",
+        :amount            => 100.00,
+        :payment_method    => Braspag::PAYMENT_METHOD[:billet_bradesco],
+        :customer          => customer
+      )
+    end
+    
+    let(:billet) do
+      Braspag::Billet.new(
+        :id           => '123456',
+        :instructions => 'does not accepted after due date', 
+        :due_date_on  => Date.parse('2012-01-01')
+      )
+    end
+    
+    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
+    
+    let(:invalid_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 xsi:nil="true" />
+        <expirationDate xsi:nil="true" />
+        <returnCode>1</returnCode>
+        <message>Invalid merchantId</message>
+        <status xsi:nil="true" />
+      </PagadorBoletoReturn>
+      EOXML
+    end
+
+
+    it "should call gateway with correct data" do
+      Braspag::Poster.any_instance.should_receive(:do_post).with(:generate_billet, {
+            "merchantId"       => "#{merchant_id}", 
+            "orderId"          => "#{order.id}", 
+            "customerName"     => "#{customer.name}", 
+            "customerIdNumber" => "#{customer.document}",
+            "amount"           => "100,00", 
+            "paymentMethod"    => 6, 
+            "boletoNumber"     => "#{billet.id}", 
+            "expirationDate"   => "01/01/12", 
+            "instructions"     => "#{billet.instructions}", 
+            "emails"           => "#{customer.email}"
+          }
+        ).and_return(mock(:body => valid_xml))
+      connection.generate_billet(order, billet)
+    end
+    
+    it "should populate data" do
+      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
+      connection.generate_billet(order, billet)
+
+      billet.url.should eq('https://homologacao.pagador.com.br/pagador/reenvia.asp?Id_Transacao=722934be-6756-477a-87ab-42115ee1424d')
+      order.gateway_return_code.should eq('0')
+      order.gateway_status.should eq('0')
+      order.gateway_amount.should eq(3.00)
+    end
+    
+    it "should return response object" do
+      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => valid_xml))
+      response = connection.generate_billet(order, billet)
+      
+      response.success?.should be(true)
+    end
+
+    it "should return error in response" do
+      Braspag::Poster.any_instance.should_receive(:do_post).and_return(mock(:body => invalid_xml))
+      response = connection.generate_billet(order, billet)
+      
+      response.success?.should be(false)
+      response.message.should eq('Invalid merchantId')
+      response.params.should eq({"url"=>nil, "amount"=>nil, "number"=>nil, "expiration_date"=>nil, "return_code"=>"1", "status"=>nil, "message"=>"Invalid merchantId"})
+    end
+  end
+end
+
+describe Braspag::Billet do
+  context "on generate" do
+    it "should allow blank for id" do
+      subject.id = ''
+      subject.valid?(:generate)
+      subject.errors.messages[:id].should be(nil)
+    end
+    
+    it "should validate maximum 255 length of id" do
+      subject.id = '*' * 260
+      subject.valid?(:generate)
+      subject.errors.messages[:id].should include("is too long (maximum is 255 characters)")
+    end
+    
+    it "should allow blank for instructions" do
+      subject.instructions = ''
+      subject.valid?(:generate)
+      subject.errors.messages[:instructions].should be(nil)
+    end
+    
+    it "should validate maximum 512 length of instructions" do
+      subject.instructions = '*' * 520
+      subject.valid?(:generate)
+      subject.errors.messages[:instructions].should include("is too long (maximum is 512 characters)")
+    end
+    
+    it "should not allow blank for due_date_on" do
+      subject.due_date_on = ''
+      subject.valid?(:generate)
+      subject.errors.messages[:due_date_on].should include("can't be blank")
+    end
+    
+    it "should not allow invalid date for due_date_on" do
+      subject.due_date_on = '12345'
+      subject.valid?(:generate)
+      subject.errors.messages[:due_date_on].should include("invalid date")
+    end
+    
+    it "should allow date for due_date_on" do
+      subject.due_date_on = Date.parse('07/03/1988')
+      subject.valid?(:generate)
+      subject.errors.messages[:due_date_on].should be(nil)
+    end
+  end
+end
+