tray-checkout 0.3.2 → 0.4.0

data/spec/tray/checkout/account_response_parser_spec.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Tray::Checkout::AccountResponseParser do
+  describe "#parse" do
+    context "with success response from get_info" do
+      let(:xml) { body_for :get_account_info }
+      let(:parser) { Tray::Checkout::AccountResponseParser.new(xml) }
+      let(:response) { parser.parse }
+
+      context "returns people" do
+        {
+          contact_primary: "08000059230",
+          name: "Vendedor Loja Modelo",
+          trade_name: "Loja Modelo",
+          email: "lojamodelo@tray.com.br",
+          url_logo: nil,
+          css_url: "http://default.com/default.css"
+        }.each do |param, value|
+          it param do
+            response.people[param].should == value
+          end
+        end
+      end
+
+      context "returns service_contact" do
+        {
+          service_phone: "(14)3412-1377",
+          email_service: "lojamodelo@tray.com.br",
+          service_phone_status: "true",
+          email_service_status: "true"
+        }.each do |param, value|
+          it param do
+            response.service_contact[param].should == value
+          end
+        end
+      end
+
+      context "returns seconds_redirect" do
+        it 'returns the seconds_redirect parameter' do
+          response.seconds_redirect.should be_nil
+        end
+      end
+    end
+
+    context "with error response" do
+      let(:xml) { body_for :get_failure_not_found }
+      let(:parser) { Tray::Checkout::ResponseParser.new(xml) }
+      let(:response) { parser.parse  }
+
+      [:people, :service_contact, :seconds_redirect].each do |info|
+        it "returns nil #{info}" do
+          response.send(info).should be_nil
+        end
+      end
+    end
+
+    context "with validation error response" do
+      let(:xml) { body_for :create_failure_validation_errors }
+      let(:parser) { Tray::Checkout::ResponseParser.new(xml) }
+      let(:response) { parser.parse  }
+
+      [:people, :service_contact, :seconds_redirect].each do |info|
+        it "returns nil #{info}" do
+          response.send(info).should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/tray/checkout/account_spec.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Tray::Checkout::Account do
+  let(:token_account) { '8bfe5ddcb77207b' }
+
+  before :all do
+    Tray::Checkout.environment = :sandbox
+  end
+
+  after :all do
+    Tray::Checkout.environment = :production
+  end
+
+  describe "#get_by_token" do
+    let(:account) { Tray::Checkout::Account.new }
+
+    context 'when token account is valid/exists' do
+      before do
+        VCR.use_cassette 'model/valid_token' do
+          @response = account.get_by_token(token_account)
+        end
+      end
+
+      it 'response returns true' do
+        @response.success?.should be_true
+      end
+
+      it 'response has name attribute' do
+        @response.people[:name].should == 'Vendedor Loja Modelo '
+      end
+
+      it 'response has service_contact attribute' do
+        @response.service_contact.should_not be_blank
+      end
+    end
+
+    context "when token account is not valid/doesn't exists" do
+      before do
+        VCR.use_cassette 'model/invalid_token' do
+          @response = account.get_by_token("9q8w7e6r5t")
+        end
+      end
+
+      it 'response returns false' do
+        @response.success?.should be_false
+      end
+    end
+  end
+end

data/spec/tray/checkout/params_parser_spec.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Tray::Checkout::ParamsParser do
+  context 'transaction' do
+    let :params do
+      {
+        token_account: "949u5uu9ef36f7u",
+        customer: {
+          name: "Pedro Bonamides",
+          cpf: "18565842673",
+          email: "pedro@bo.com.br",
+          sex: :male,
+          marital_status: :single,
+          contacts: [
+            { type: :home,   number: "1142360873"  },
+            { type: :mobile, number: "11987654321" },
+            { type: :work,   number: "1134567890"  }
+          ],
+          addresses: [
+            { type: :billing,
+              street: "Avenida Pedro Alvares Cabral",
+              number: "123",
+              neighborhood: "Parque Ibirapuera",
+              postal_code: "04094050",
+              city: "São Paulo",
+              state: "SP"
+            },
+            { type: :delivery,
+              street: "Avenida Pedro Alvares Cabral",
+              number: "123",
+              neighborhood: "Parque Ibirapuera",
+              postal_code: "04094050",
+              city: "São Paulo",
+              state: "SP"
+            }
+          ]
+        },
+        transaction: {
+          order_number: "R1245",
+          shipping_type: "Sedex",
+          shipping_price: 13.94,
+          url_notification: "http://prodis.blog.br/tray_notification",
+          products: [
+            { code: "LOGO-8278",
+              quantity: 2,
+              price_unit: 100.99,
+              description: "Logo Prodis"
+            },
+            { code: "877",
+              quantity: 1,
+              price_unit: 10.00,
+              description: "Outro produto"
+            }
+          ]
+        },
+        payment: {
+          method: :mastercard,
+          split: 3,
+          card: {
+            name: "ZEFINHA NOCEGA",
+            number: "5105105105105100",
+            expdate_month: "09",
+            expdate_year: "2015",
+            cvv: "123"
+          }
+        }
+      }
+    end
+
+    let(:parser) { Tray::Checkout::ParamsParser.new(params) }
+    let(:response_params) { parser.parse }
+
+    describe "#parse" do
+      it "sets customer gender expect API value" do
+        response_params[:customer][:gender].should == "M"
+      end
+
+      it "sets customer relationship expect API value" do
+        response_params[:customer][:relationship].should == "S"
+      end
+
+      it "sets customer contact type expect API value" do
+        response_params[:customer][:contacts][0][:type_contact].should == "H"
+        response_params[:customer][:contacts][1][:type_contact].should == "M"
+        response_params[:customer][:contacts][2][:type_contact].should == "W"
+      end
+
+      it "sets customer contact number expect API value" do
+        response_params[:customer][:contacts][0][:number_contact].should == "1142360873"
+        response_params[:customer][:contacts][1][:number_contact].should == "11987654321"
+        response_params[:customer][:contacts][2][:number_contact].should == "1134567890"
+      end
+
+      it "sets customer address type expect API value" do
+        response_params[:customer][:addresses][0][:type_address].should == "B"
+        response_params[:customer][:addresses][1][:type_address].should == "D"
+      end
+
+      it "sets payment method ID expect API value" do
+        response_params[:payment][:payment_method_id].should == 4
+      end
+
+      { card_name: "ZEFINHA NOCEGA",
+        card_number: "5105105105105100",
+        card_expdate_month: "09",
+        card_expdate_year: "2015",
+        card_cvv: "123"
+      }.each do |param, value|
+        it "sets payment #{param}" do
+          response_params[:payment][param].should == value
+        end
+      end
+
+      it "sets products as expect API data structure" do
+        response_params[:transaction_product][0][:code].should == "LOGO-8278"
+        response_params[:transaction_product][0][:quantity].should == 2
+        response_params[:transaction_product][0][:price_unit].should == 100.99
+        response_params[:transaction_product][0][:description].should == "Logo Prodis"
+
+        response_params[:transaction_product][1][:code].should == "877"
+        response_params[:transaction_product][1][:quantity].should == 1
+        response_params[:transaction_product][1][:price_unit].should == 10.00
+        response_params[:transaction_product][1][:description].should == "Outro produto"
+      end
+
+      it "keeps token account supplied in params" do
+        response_params[:token_account].should == params[:token_account]
+      end
+
+      context "when sets token account in configuration" do
+        around do |example|
+          Tray::Checkout.configure { |config| config.token_account = "1q2w3e4r5t6y7u8" }
+          example.run
+          Tray::Checkout.configure { |config| config.token_account = nil }
+        end
+
+        context "and token account is supplied in params" do
+          it "keeps token account supplied in params" do
+            response_params[:token_account].should == params[:token_account]
+          end
+        end
+
+        context "and token account is not supplied in params" do
+          it "uses token account from configuration" do
+            params.delete(:token_account)
+            response_params = Tray::Checkout::ParamsParser.new(params).parse
+            response_params[:token_account].should == "1q2w3e4r5t6y7u8"
+          end
+        end
+      end
+    end
+  end
+
+  context 'account' do
+    let :params do
+      {
+        contact_primary: "08000059230",
+        name: "Vendedor Loja Modelo",
+        trade_name: "Loja Modelo",
+        email: "lojamodelo@tray.com.br",
+        url_logo: nil,
+        css_url: "http://default.com/default.css",
+        service_contact: {
+          service_phone: "(14)3412-1377",
+          email_service: "lojamodelo@tray.com.br",
+          service_phone_status: "true",
+          email_service_status: "true"
+        },
+        seconds_redirect: nil
+      }
+    end
+
+    let(:parser) { Tray::Checkout::ParamsParser.new(params) }
+    let(:account_params) { parser.parse }
+
+    describe "#parse" do
+      it "sets service_contact expect API value" do
+        account_params[:service_contact][:service_phone].should == "(14)3412-1377"
+        account_params[:service_contact][:email_service].should == "lojamodelo@tray.com.br"
+        account_params[:service_contact][:service_phone_status].should == "true"
+        account_params[:service_contact][:email_service_status].should == "true"
+      end
+
+      it "sets seconds_redirect expect API value" do
+        account_params[:seconds_redirect].should be_nil
+      end
+    end
+  end
+end

data/spec/tray/checkout/parser_spec.rb

@@ -23,30 +23,30 @@ describe Tray::Checkout::Parser do
     end
   end
 
-  describe "#transaction_params" do
+  describe "#response_params" do
     before :each do
       @params = {
         token_account: "949u5uu9ef36f7u",
         customer: { name: "Pedro Bonamides", sex: :male },
         payment: { payment_method: :boleto_bancario }
       }
-      @transaction_params = {
+      @response_params = {
         token_account: "949u5uu9ef36f7u",
         customer: { name: "Pedro Bonamides", sex: :male, gender: "M" },
         payment: { payment_method: :boleto, payment_method_id: "6" }
       }
-      @transaction_params_parser = Tray::Checkout::TransactionParamsParser.new(@params)
-      Tray::Checkout::TransactionParamsParser.stub(:new).and_return(@transaction_params_parser)
+      @params_parser = Tray::Checkout::ParamsParser.new(@params)
+      Tray::Checkout::ParamsParser.stub(:new).and_return(@params_parser)
     end
 
     it "creates transaction params parser" do
-      Tray::Checkout::TransactionParamsParser.should_receive(:new).with(@params)
-      parser.transaction_params(@params)
+      Tray::Checkout::ParamsParser.should_receive(:new).with(@params)
+      parser.response_params(@params)
     end
 
     it "parses params" do
-      @transaction_params_parser.should_receive(:parse).and_return(@transaction_params)
-      parser.transaction_params(@params).should == @transaction_params
+      @params_parser.should_receive(:parse).and_return(@response_params)
+      parser.response_params(@params).should == @response_params
     end
   end
 end

data/spec/tray/checkout/response_parser_spec.rb

@@ -3,53 +3,6 @@ require 'spec_helper'
 
 describe Tray::Checkout::ResponseParser do
   describe "#parse" do
-    context "with success response from temp_transaction" do
-      let(:xml) { body_for :create_temp_transaction_with_token }
-      let(:parser) { Tray::Checkout::ResponseParser.new(xml) }
-      let(:response) { parser.parse }
-
-      it "returns success" do
-        response.success?.should be_true
-      end
-
-      context "returns transaction" do
-        {
-          token: "a906bf32cb59060dfc90769524f99d5a",
-          url_car: "\n\t\t\thttp://checkout.sandbox.tray.com.br/payment/car/v1/\n\t\t"
-        }.each do |param, value|
-          it param do
-            response.transaction[param].should == value
-          end
-        end
-      end
-
-      context "returns products" do
-        {
-          code: "teste",
-          img: "\n\t\t\t\t\thttp://catnross.com/wp-content/uploads/2011/08/product1.jpg\n\t\t\t\t",
-          sku_code: nil,
-          description: "produto teste",
-          extra: nil,
-          id: 4502,
-          type_product: nil
-        }.each do |param, value|
-          it param do
-            response.transaction[:products].first[param].should == value
-          end
-        end
-
-        {
-          price_unit: "10.0",
-          quantity: "5.0",
-          weight: "300.0"
-        }.each do |param, value|
-          it param do
-            response.transaction[:products].first[param].to_s.should == value
-          end
-        end
-      end
-    end
-
     context "with success response" do
       let(:xml) { body_for :get_success_boleto }
       let(:parser) { Tray::Checkout::ResponseParser.new(xml) }
@@ -58,102 +11,6 @@ describe Tray::Checkout::ResponseParser do
       it "returns success" do
         response.success?.should be_true
       end
-
-      it "returns empty errors" do
-        response.errors.should be_empty
-      end
-
-      context "returns transaction" do
-        {
-          order_number: "1234567",
-          free: "Texto Interno",
-          status_name: "Em Recupera\\xC3\\xA7\\xC3\\xA3o",
-          status: :recovering,
-          id: 3856,
-          token: "4761d2e198ba6b60b45900a4d95482d5"
-        }.each do |param, value|
-          it param do
-            response.transaction[param].should == value
-          end
-        end
-      end
-
-      context "returns payment" do
-        {
-          tid: nil,
-          split: 1,
-          linha_digitavel: "34191.76007 00536.260144 50565.600009 6 58630000219999",
-          method: :boleto,
-          method_name: "Boleto Bancario"
-        }.each do |param, value|
-          it param do
-            response.payment[param].should == value
-          end
-        end
-
-        {
-          price_original: '2199.99',
-          price: '2199.99'
-        }.each do |param, value|
-          it param do
-            response.payment[param].to_s.should == value
-          end
-        end
-      end
-
-      context "returns customer" do
-        {
-          name: "Nome do Cliente",
-          cpf: "98489882380",
-          email: "emaildo@cliente.com.br",
-          company_name: nil,
-          trade_name: nil,
-          cnpj: nil
-        }.each do |param, value|
-          it param do
-            response.customer[param].should == value
-          end
-        end
-
-        context "address with" do
-          {
-            street: "Av Paulista",
-            number: "1001",
-            neighborhood: "Centro",
-            postal_code: "04001001",
-            completion: nil,
-            city: "S\\xC3\\xA3o Paulo",
-            state: "SP"
-          }.each do |param, value|
-            it param do
-              response.customer[:addresses].first[param].should == value
-            end
-          end
-        end
-
-        context "contacts with" do
-          [ {
-              number: "11998761234",
-              id: nil,
-              type: :mobile
-            }
-          ].each_with_index do |contacts, i|
-            contacts.each do |param, value|
-              it param do
-                response.customer[:contacts][i][param].should == value
-              end
-            end
-          end
-        end
-
-        context "without contacts" do
-          it "returns empty array" do
-            parser = Tray::Checkout::ResponseParser.new(body_for(:get_success_boleto_without_contacts))
-            response = parser.parse
-            response.customer[:contacts].should == []
-          end
-        end
-      end
     end
 
     context "with error response" do
@@ -165,12 +22,6 @@ describe Tray::Checkout::ResponseParser do
         response.success?.should be_false
       end
 
-      [:transaction, :payment, :customer].each do |info|
-        it "returns nil #{info}" do
-          response.send(info).should be_nil
-        end
-      end
-
       context "returns error" do
         { code: "001001",
           message: "Token inválido ou não encontrado"
@@ -191,12 +42,6 @@ describe Tray::Checkout::ResponseParser do
         response.success?.should be_false
       end
 
-      [:transaction, :payment, :customer].each do |info|
-        it "returns nil #{info}" do
-          response.send(info).should be_nil
-        end
-      end
-
       context "returns error" do
         { code: "13",
           message: "Tipo de Contato não está incluído na lista"
@@ -208,4 +53,22 @@ describe Tray::Checkout::ResponseParser do
       end
     end
   end
+
+  describe("transaction?") do
+    context "response is from a transaction" do
+      let(:xml) { body_for :get_success_boleto }
+
+      it "returns true" do
+        Tray::Checkout::ResponseParser.transaction?(xml).should be_true
+      end
+    end
+
+    context "response is not from a transaction" do
+      let(:xml) { body_for :get_account_info }
+
+      it "returns false" do
+        Tray::Checkout::ResponseParser.transaction?(xml).should be_false
+      end
+    end
+  end
 end